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(),
79 fTriggerConditions(0),
89 fFastOrFiredMap(1200){
90 // Standard Constructor
98 fReconstruction = new TObjArray(fgkNdettypes);
99 fDigits = new TObjArray(fgkNdettypes);
100 for(Int_t i=0; i<3; i++){
103 fSSDCalibration=new AliITSCalibrationSSD();
104 fNMod = new Int_t [fgkNdettypes];
105 fNMod[0] = fgkDefaultNModulesSPD;
106 fNMod[1] = fgkDefaultNModulesSDD;
107 fNMod[2] = fgkDefaultNModulesSSD;
108 fRecPoints = new TClonesArray("AliITSRecPoint",3000);
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 fTriggerConditions(rec.fTriggerConditions),
124 fDigits(rec.fDigits),
125 fFOSignals(rec.fFOSignals),
126 fDDLMapSDD(rec.fDDLMapSDD),
127 fRespSDD(rec.fRespSDD),
128 fAveGainSDD(rec.fAveGainSDD),
129 fRecPoints(rec.fRecPoints),
130 fNRecPoints(rec.fNRecPoints),
131 fFirstcall(rec.fFirstcall),
132 fLoadOnlySPDCalib(rec.fLoadOnlySPDCalib),
133 fFastOrFiredMap(rec.fFastOrFiredMap){
138 //______________________________________________________________________
139 AliITSDetTypeRec& AliITSDetTypeRec::operator=(const AliITSDetTypeRec& source){
140 // Assignment operator.
141 this->~AliITSDetTypeRec();
142 new(this) AliITSDetTypeRec(source);
147 //_____________________________________________________________________
148 AliITSDetTypeRec::~AliITSDetTypeRec(){
152 fReconstruction->Delete();
153 delete fReconstruction;
157 fSegmentation->Delete();
158 delete fSegmentation;
162 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
163 fCalibration->Delete();
166 if(fRespSDD) delete fRespSDD;
167 if(fDDLMapSDD) delete fDDLMapSDD;
171 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
172 delete fSSDCalibration;
173 fSSDCalibration = NULL;
177 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
183 if(fTriggerConditions){
184 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
185 fTriggerConditions->Delete();
186 delete fTriggerConditions;
187 fTriggerConditions = 0;
196 fRecPoints->Delete();
202 if (fITSgeom) delete fITSgeom;
206 //___________________________________________________________________
207 void AliITSDetTypeRec::SetReconstructionModel(Int_t dettype,AliITSClusterFinder *clf){
209 //Set reconstruction model for detector type
211 if(fReconstruction==0) fReconstruction = new TObjArray(fgkNdettypes);
212 if(fReconstruction->At(dettype)!=0) delete fReconstruction->At(dettype);
213 fReconstruction->AddAt(clf,dettype);
215 //______________________________________________________________________
216 AliITSClusterFinder* AliITSDetTypeRec::GetReconstructionModel(Int_t dettype) const{
218 //Get reconstruction model for detector type
219 if(fReconstruction==0) {
220 Warning("GetReconstructionModel","fReconstruction is 0!");
223 return (AliITSClusterFinder*)fReconstruction->At(dettype);
226 //______________________________________________________________________
227 void AliITSDetTypeRec::SetSegmentationModel(Int_t dettype,AliITSsegmentation *seg){
229 //Set segmentation model for detector type
231 if(fSegmentation==0) fSegmentation = new TObjArray(fgkNdettypes);
232 if(fSegmentation->At(dettype)!=0) delete fSegmentation->At(dettype);
233 fSegmentation->AddAt(seg,dettype);
236 //______________________________________________________________________
237 AliITSsegmentation* AliITSDetTypeRec::GetSegmentationModel(Int_t dettype) const {
239 //Get segmentation model for detector type
241 if(fSegmentation==0) {
242 Warning("GetSegmentationModel","fSegmentation is 0!");
245 return (AliITSsegmentation*)fSegmentation->At(dettype);
248 //_______________________________________________________________________
249 void AliITSDetTypeRec::SetCalibrationModel(Int_t iMod, AliITSCalibration *cal){
251 //Set calibration (response) for the module iMod of type dettype
252 if (fCalibration==0) {
253 fCalibration = new TObjArray(GetITSgeom()->GetIndexMax());
254 fCalibration->SetOwner(kTRUE);
255 fCalibration->Clear();
258 if (fCalibration->At(iMod) != 0)
259 delete (AliITSCalibration*) fCalibration->At(iMod);
260 fCalibration->AddAt(cal,iMod);
263 //_______________________________________________________________________
264 void AliITSDetTypeRec::SetSPDDeadModel(Int_t iMod, AliITSCalibration *cal){
266 //Set dead pixel info for the SPD module iMod
268 fSPDDead = new TObjArray(fgkDefaultNModulesSPD);
269 fSPDDead->SetOwner(kTRUE);
273 if (fSPDDead->At(iMod) != 0)
274 delete (AliITSCalibration*) fSPDDead->At(iMod);
275 fSPDDead->AddAt(cal,iMod);
277 //_______________________________________________________________________
278 AliITSCalibration* AliITSDetTypeRec::GetCalibrationModel(Int_t iMod) const {
280 //Get calibration model for module type
282 if(fCalibration==0) {
283 Warning("GetalibrationModel","fCalibration is 0!");
287 if(iMod<fgkDefaultNModulesSPD+fgkDefaultNModulesSDD){
288 return (AliITSCalibration*)fCalibration->At(iMod);
290 Int_t i=iMod-(fgkDefaultNModulesSPD+fgkDefaultNModulesSDD);
291 fSSDCalibration->SetModule(i);
292 return (AliITSCalibration*)fSSDCalibration;
296 //_______________________________________________________________________
297 AliITSCalibration* AliITSDetTypeRec::GetSPDDeadModel(Int_t iMod) const {
299 //Get SPD dead for module iMod
302 AliWarning("fSPDDead is 0!");
305 return (AliITSCalibration*)fSPDDead->At(iMod);
307 //_______________________________________________________________________
308 AliITSTriggerConditions* AliITSDetTypeRec::GetTriggerConditions() const {
309 //Get Pixel Trigger Conditions
310 if (fTriggerConditions==0) {
311 AliWarning("fTriggerConditions is 0!");
313 return fTriggerConditions;
315 //______________________________________________________________________
316 void AliITSDetTypeRec::SetTreeAddressD(TTree* const treeD){
317 // Set branch address for the tree of digits.
319 const char *det[4] = {"SPD","SDD","SSD","ITS"};
321 const Char_t* digclass;
326 if (fDigits == 0x0) fDigits = new TObjArray(fgkNdettypes);
327 for (i=0; i<fgkNdettypes; i++) {
328 digclass = GetDigitClassName(i);
329 if(!(fDigits->At(i))) {
330 fDigits->AddAt(new TClonesArray(digclass,1000),i);
335 if (fgkNdettypes==3) sprintf(branchname,"%sDigits%s",det[3],det[i]);
336 else sprintf(branchname,"%sDigits%d",det[3],i+1);
338 branch = treeD->GetBranch(branchname);
339 if (branch) branch->SetAddress(&((*fDigits)[i]));
345 //_______________________________________________________________________
346 TBranch* AliITSDetTypeRec::MakeBranchInTree(TTree* const tree,
347 const char* name, const char *classname,
348 void* address,Int_t size,Int_t splitlevel)
351 // Makes branch in given tree and diverts them to a separate file
357 Error("MakeBranchInTree","Making Branch %s Tree is NULL",name);
360 TBranch *branch = tree->GetBranch(name);
365 branch = tree->Branch(name,classname,address,size,splitlevel);
368 branch = tree->Bronch(name, "TClonesArray", address, size, splitlevel);
374 //____________________________________________________________________
375 void AliITSDetTypeRec::SetDefaults(){
377 //Set defaults for segmentation and response
380 Warning("SetDefaults","null pointer to AliITSgeomGeom !");
384 AliITSsegmentation* seg;
385 if(!GetCalibration()) {AliFatal("Exit");exit(0);}
387 for(Int_t dettype=0;dettype<fgkNdettypes;dettype++){
389 seg = new AliITSsegmentationSPD();
390 SetSegmentationModel(dettype,seg);
391 SetDigitClassName(dettype,"AliITSdigitSPD");
393 if(fLoadOnlySPDCalib==kFALSE){
395 seg = new AliITSsegmentationSDD();
396 AliITSCalibrationSDD* cal=(AliITSCalibrationSDD*)GetCalibrationModel(fgkDefaultNModulesSPD+1);
397 if(cal->IsAMAt20MHz()){
398 seg->SetPadSize(seg->Dpz(0),20.);
399 seg->SetNPads(seg->Npz()/2,128);
401 SetSegmentationModel(dettype,seg);
402 SetDigitClassName(dettype,"AliITSdigitSDD");
406 AliITSsegmentationSSD* seg2 = new AliITSsegmentationSSD();
407 SetSegmentationModel(dettype,seg2);
408 SetDigitClassName(dettype,"AliITSdigitSSD");
412 //______________________________________________________________________
413 Bool_t AliITSDetTypeRec::GetCalibration() {
414 // Get Default calibration if a storage is not defined.
417 AliITSCalibration* cal = GetCalibrationModel(0);
423 // SetRunNumber((Int_t)AliCDBManager::Instance()->GetRun());
424 // Int_t run=GetRunNumber();
426 Bool_t cacheStatus = AliCDBManager::Instance()->GetCacheFlag();
427 if (fCalibration==0) {
428 fCalibration = new TObjArray(GetITSgeom()->GetIndexMax());
429 fCalibration->SetOwner(!cacheStatus);
430 fCalibration->Clear();
433 Bool_t retCode=GetCalibrationSPD(cacheStatus);
434 if(retCode==kFALSE) return kFALSE;
436 if(fLoadOnlySPDCalib==kFALSE){
437 retCode=GetCalibrationSDD(cacheStatus);
438 if(retCode==kFALSE) return kFALSE;
439 retCode=GetCalibrationSSD(cacheStatus);
440 if(retCode==kFALSE) return kFALSE;
443 AliInfo(Form("%i SPD, %i SDD and %i SSD in calibration database",
444 fNMod[0], fNMod[1], fNMod[2]));
447 //______________________________________________________________________
448 Bool_t AliITSDetTypeRec::GetCalibrationSPD(Bool_t cacheStatus) {
449 // Get SPD calibration objects from OCDB
450 // dead pixel are not used for local reconstruction
453 AliCDBEntry *noisySPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDNoisy");
454 AliCDBEntry *deadSPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDDead");
455 AliCDBEntry *pitCond = AliCDBManager::Instance()->Get("TRIGGER/SPD/PITConditions");
456 if(!noisySPD || !deadSPD || !pitCond ){
457 AliFatal("SPD Calibration object retrieval failed! ");
461 TObjArray *calNoisySPD = (TObjArray*) noisySPD->GetObject();
462 if (!cacheStatus) noisySPD->SetObject(NULL);
463 noisySPD->SetOwner(kTRUE);
465 TObjArray *calDeadSPD = (TObjArray*) deadSPD->GetObject();
466 if (!cacheStatus) deadSPD->SetObject(NULL);
467 deadSPD->SetOwner(kTRUE);
469 AliITSTriggerConditions *calPitCond = (AliITSTriggerConditions*) pitCond->GetObject();
470 if (!cacheStatus) pitCond->SetObject(NULL);
471 pitCond->SetOwner(kTRUE);
478 if ((!calNoisySPD) || (!calDeadSPD) || (!calPitCond)){
479 AliWarning("Can not get SPD calibration from calibration database !");
483 fNMod[0] = calNoisySPD->GetEntries();
485 AliITSCalibration* cal;
486 for (Int_t i=0; i<fNMod[0]; i++) {
487 cal = (AliITSCalibration*) calNoisySPD->At(i);
488 SetCalibrationModel(i, cal);
489 cal = (AliITSCalibration*) calDeadSPD->At(i);
490 SetSPDDeadModel(i, cal);
492 fTriggerConditions = calPitCond;
497 //______________________________________________________________________
498 Bool_t AliITSDetTypeRec::GetCalibrationSDD(Bool_t cacheStatus) {
499 // Get SDD calibration objects from OCDB
501 AliCDBEntry *entrySDD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSDD");
502 AliCDBEntry *entry2SDD = AliCDBManager::Instance()->Get("ITS/Calib/RespSDD");
503 AliCDBEntry *drSpSDD = AliCDBManager::Instance()->Get("ITS/Calib/DriftSpeedSDD");
504 AliCDBEntry *ddlMapSDD = AliCDBManager::Instance()->Get("ITS/Calib/DDLMapSDD");
505 // AliCDBEntry *mapASDD = AliCDBManager::Instance()->Get("ITS/Calib/MapsAnodeSDD");
506 AliCDBEntry *mapTSDD = AliCDBManager::Instance()->Get("ITS/Calib/MapsTimeSDD");
508 if(!entrySDD || !entry2SDD || !drSpSDD || !ddlMapSDD || !mapTSDD ){
509 AliFatal("SDD Calibration object retrieval failed! ");
515 TObjArray *calSDD = (TObjArray *)entrySDD->GetObject();
516 if(!cacheStatus)entrySDD->SetObject(NULL);
517 entrySDD->SetOwner(kTRUE);
519 AliITSresponseSDD *pSDD = (AliITSresponseSDD*)entry2SDD->GetObject();
520 if(!cacheStatus)entry2SDD->SetObject(NULL);
521 entry2SDD->SetOwner(kTRUE);
523 TObjArray *drSp = (TObjArray *)drSpSDD->GetObject();
524 if(!cacheStatus)drSpSDD->SetObject(NULL);
525 drSpSDD->SetOwner(kTRUE);
527 AliITSDDLModuleMapSDD *ddlsdd=(AliITSDDLModuleMapSDD*)ddlMapSDD->GetObject();
528 if(!cacheStatus)ddlMapSDD->SetObject(NULL);
529 ddlMapSDD->SetOwner(kTRUE);
531 // TObjArray *mapAn = (TObjArray *)mapASDD->GetObject();
532 // if(!cacheStatus)mapASDD->SetObject(NULL);
533 // mapASDD->SetOwner(kTRUE);
535 TObjArray *mapT = (TObjArray *)mapTSDD->GetObject();
536 if(!cacheStatus)mapTSDD->SetObject(NULL);
537 mapTSDD->SetOwner(kTRUE);
540 // DB entries are deleted. In this way metadeta objects are deleted as well
550 if ((!pSDD)||(!calSDD) || (!drSp) || (!ddlsdd) || (!mapT) ){
551 AliWarning("Can not get SDD calibration from calibration database !");
555 fNMod[1] = calSDD->GetEntries();
559 AliITSCalibration* cal;
562 Bool_t oldMapFormat=kFALSE;
563 TObject* objmap=(TObject*)mapT->At(0);
564 TString cname(objmap->ClassName());
565 if(cname.CompareTo("AliITSMapSDD")==0){
567 AliInfo("SDD Maps converted to new format");
569 for(Int_t iddl=0; iddl<AliITSDDLModuleMapSDD::GetNDDLs(); iddl++){
570 for(Int_t icar=0; icar<AliITSDDLModuleMapSDD::GetNModPerDDL();icar++){
571 Int_t iMod=fDDLMapSDD->GetModuleNumber(iddl,icar);
572 if(iMod==-1) continue;
573 Int_t i=iMod - fgkDefaultNModulesSPD;
574 cal = (AliITSCalibration*) calSDD->At(i);
577 for(Int_t iAnode=0;iAnode< ((AliITSCalibrationSDD*)cal)->NOfAnodes(); iAnode++){
578 if(((AliITSCalibrationSDD*)cal)->IsBadChannel(iAnode)) continue;
579 avegain+= ((AliITSCalibrationSDD*)cal)->GetChannelGain(iAnode);
582 AliITSDriftSpeedArraySDD* arr0 = (AliITSDriftSpeedArraySDD*) drSp->At(i0);
583 AliITSDriftSpeedArraySDD* arr1 = (AliITSDriftSpeedArraySDD*) drSp->At(i1);
585 AliITSCorrMapSDD* mt0 = 0;
586 AliITSCorrMapSDD* mt1 = 0;
588 AliITSMapSDD* oldmap0=(AliITSMapSDD*)mapT->At(i0);
589 AliITSMapSDD* oldmap1=(AliITSMapSDD*)mapT->At(i1);
590 mt0=oldmap0->ConvertToNewFormat();
591 mt1=oldmap1->ConvertToNewFormat();
593 mt0=(AliITSCorrMapSDD*)mapT->At(i0);
594 mt1=(AliITSCorrMapSDD*)mapT->At(i1);
596 cal->SetDriftSpeed(0,arr0);
597 cal->SetDriftSpeed(1,arr1);
600 SetCalibrationModel(iMod, cal);
603 if(nGdAnodes) fAveGainSDD=avegain/nGdAnodes;
608 //______________________________________________________________________
609 Bool_t AliITSDetTypeRec::GetCalibrationSSD(Bool_t cacheStatus) {
610 // Get SSD calibration objects from OCDB
611 // AliCDBEntry *entrySSD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSSD");
613 AliCDBEntry *entryNoiseSSD = AliCDBManager::Instance()->Get("ITS/Calib/NoiseSSD");
614 AliCDBEntry *entryGainSSD = AliCDBManager::Instance()->Get("ITS/Calib/GainSSD");
615 AliCDBEntry *entryBadChannelsSSD = AliCDBManager::Instance()->Get("ITS/Calib/BadChannelsSSD");
617 if(!entryNoiseSSD || !entryGainSSD || !entryBadChannelsSSD){
618 AliFatal("SSD Calibration object retrieval failed! ");
622 TObject *emptyssd = 0; TString ssdobjectname;
623 AliITSNoiseSSDv2 *noiseSSD = NULL;
624 emptyssd = (TObject *)entryNoiseSSD->GetObject();
625 ssdobjectname = emptyssd->GetName();
626 if(ssdobjectname=="TObjArray") {
627 TObjArray *noiseSSDOld = (TObjArray *)entryNoiseSSD->GetObject();
628 noiseSSD = new AliITSNoiseSSDv2();
629 ReadOldSSDNoise(noiseSSDOld, noiseSSD);
631 else if(ssdobjectname=="AliITSNoiseSSDv2")
632 noiseSSD = (AliITSNoiseSSDv2 *)entryNoiseSSD->GetObject();
633 if(!cacheStatus)entryNoiseSSD->SetObject(NULL);
634 entryNoiseSSD->SetOwner(kTRUE);
636 AliITSGainSSDv2 *gainSSD = NULL;;
637 emptyssd = (TObject *)entryGainSSD->GetObject();
638 ssdobjectname = emptyssd->GetName();
639 if(ssdobjectname=="Gain") {
640 TObjArray *gainSSDOld = (TObjArray *)entryGainSSD->GetObject();
641 gainSSD = new AliITSGainSSDv2();
642 ReadOldSSDGain(gainSSDOld, gainSSD);
644 else if(ssdobjectname=="AliITSGainSSDv2")
645 gainSSD = (AliITSGainSSDv2 *)entryGainSSD->GetObject();
646 if(!cacheStatus)entryGainSSD->SetObject(NULL);
647 entryGainSSD->SetOwner(kTRUE);
649 AliITSBadChannelsSSDv2 *badChannelsSSD = NULL;
650 emptyssd = (TObject *)entryBadChannelsSSD->GetObject();
651 ssdobjectname = emptyssd->GetName();
652 if(ssdobjectname=="TObjArray") {
653 TObjArray *badChannelsSSDOld = (TObjArray *)entryBadChannelsSSD->GetObject();
654 badChannelsSSD = new AliITSBadChannelsSSDv2();
655 ReadOldSSDBadChannels(badChannelsSSDOld, badChannelsSSD);
657 else if(ssdobjectname=="AliITSBadChannelsSSDv2")
658 badChannelsSSD = (AliITSBadChannelsSSDv2*)entryBadChannelsSSD->GetObject();
659 if(!cacheStatus)entryBadChannelsSSD->SetObject(NULL);
660 entryBadChannelsSSD->SetOwner(kTRUE);
662 // DB entries are deleted. In this way metadeta objects are deleted as well
664 delete entryNoiseSSD;
666 delete entryBadChannelsSSD;
669 if ((!noiseSSD)|| (!gainSSD)|| (!badChannelsSSD)) {
670 AliWarning("Can not get SSD calibration from calibration database !");
674 fSSDCalibration->SetNoise(noiseSSD);
675 fSSDCalibration->SetGain(gainSSD);
676 fSSDCalibration->SetBadChannels(badChannelsSSD);
677 //fSSDCalibration->FillBadChipMap();
682 //________________________________________________________________
683 void AliITSDetTypeRec::SetDefaultClusterFindersV2(Bool_t rawdata){
685 //Set defaults for cluster finder V2
688 Warning("SetDefaults","Null pointer to AliITSgeom !");
692 AliITSClusterFinder *clf;
694 for(Int_t dettype=0;dettype<fgkNdettypes;dettype++){
697 if(!GetReconstructionModel(dettype)){
698 clf = new AliITSClusterFinderV2SPD(this);
700 if(!rawdata) clf->SetDigits(DigitsAddress(0));
701 SetReconstructionModel(dettype,clf);
707 if(!GetReconstructionModel(dettype)){
708 clf = new AliITSClusterFinderV2SDD(this);
710 if(!rawdata) clf->SetDigits(DigitsAddress(1));
711 SetReconstructionModel(dettype,clf);
718 if(!GetReconstructionModel(dettype)){
719 clf = new AliITSClusterFinderV2SSD(this);
721 if(!rawdata) clf->SetDigits(DigitsAddress(2));
722 SetReconstructionModel(dettype,clf);
729 //______________________________________________________________________
730 void AliITSDetTypeRec::MakeBranch(TTree* tree, Option_t* option){
732 //Creates branches for clusters and recpoints
733 Bool_t cR = (strstr(option,"R")!=0);
734 Bool_t cRF = (strstr(option,"RF")!=0);
738 if(cR) MakeBranchR(tree);
739 if(cRF) MakeBranchRF(tree);
743 //___________________________________________________________________
744 void AliITSDetTypeRec::ResetDigits(){
745 // Reset number of digits and the digits array for the ITS detector.
748 for(Int_t i=0;i<fgkNdettypes;i++){
752 //___________________________________________________________________
753 void AliITSDetTypeRec::ResetDigits(Int_t branch){
754 // Reset number of digits and the digits array for this branch.
756 if(fDigits->At(branch)) ((TClonesArray*)fDigits->At(branch))->Clear();
759 //__________________________________________________________________
760 void AliITSDetTypeRec::MakeBranchR(TTree *treeR, Option_t *opt){
762 //Creates tree branches for recpoints
764 // cont char *file File name where RecPoints branch is to be written
765 // to. If blank it write the SDigits to the same
766 // file in which the Hits were found.
771 // only one branch for rec points for all detector types
772 Bool_t oFast= (strstr(opt,"Fast")!=0);
774 Char_t detname[10] = "ITS";
778 sprintf(branchname,"%sRecPointsF",detname);
780 sprintf(branchname,"%sRecPoints",detname);
783 if(!fRecPoints)fRecPoints = new TClonesArray("AliITSRecPoint",1000);
785 MakeBranchInTree(treeR,branchname,0,&fRecPoints,buffsz,99);
787 //______________________________________________________________________
788 void AliITSDetTypeRec::SetTreeAddressR(TTree* const treeR){
789 // Set branch address for the Reconstructed points Trees.
791 // TTree *treeR Tree containing the RecPoints.
797 Char_t namedet[10]="ITS";
800 if(fRecPoints==0x0) fRecPoints = new TClonesArray("AliITSRecPoint",1000);
802 sprintf(branchname,"%sRecPoints",namedet);
803 branch = treeR->GetBranch(branchname);
805 branch->SetAddress(&fRecPoints);
808 sprintf(branchname,"%sRecPointsF",namedet);
809 branch = treeR->GetBranch(branchname);
811 branch->SetAddress(&fRecPoints);
815 //____________________________________________________________________
816 void AliITSDetTypeRec::AddRecPoint(const AliITSRecPoint &r){
817 // Add a reconstructed space point to the list
819 // const AliITSRecPoint &r RecPoint class to be added to the tree
820 // of reconstructed points TreeR.
826 TClonesArray &lrecp = *fRecPoints;
827 new(lrecp[fNRecPoints++]) AliITSRecPoint(r);
830 //______________________________________________________________________
831 void AliITSDetTypeRec::DigitsToRecPoints(TTree *treeD,TTree *treeR,Int_t lastentry,Option_t *opt, Int_t optCluFind){
832 // cluster finding and reconstruction of space points
833 // the condition below will disappear when the geom class will be
834 // initialized for all versions - for the moment it is only for v5 !
835 // 7 is the SDD beam test version
837 // TTree *treeD Digits tree
838 // TTree *treeR Clusters tree
839 // Int_t lastentry Offset for module when not all of the modules
841 // Option_t *opt String indicating which ITS sub-detectors should
842 // be processed. If ="All" then all of the ITS
843 // sub detectors are processed.
845 const char *all = strstr(opt,"All");
846 const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
849 SetDefaultClusterFindersV2();
850 AliDebug(1,"V2 cluster finder has been selected \n");
852 SetDefaultClusterFindersV2();
853 AliInfo("Cluster Finder Option not implemented, V2 cluster finder will be used \n");
857 // Reset Fast-OR fired map
858 ResetFastOrFiredMap();
860 if (all || det[0]) { // SPD present
861 // Get the FO signals for this event
862 AliRunLoader* runLoader = AliRunLoader::Instance();
863 AliITSLoader* itsLoader = (AliITSLoader*) runLoader->GetLoader("ITSLoader");
865 AliError("ITS loader is NULL.");
868 fFOSignals = (AliITSFOSignalsSPD*)itsLoader->TreeD()->GetUserInfo()->FindObject("AliITSFOSignalsSPD");
869 if(!fFOSignals) AliError("FO signals not retrieved");
875 AliITSClusterFinder *rec = 0;
876 Int_t id,module,first=0;
877 for(module=0;module<GetITSgeom()->GetIndexMax();module++){
878 id = GetITSgeom()->GetModuleType(module);
879 if (!all && !det[id]) continue;
880 if(det[id]) first = GetITSgeom()->GetStartDet(id);
881 rec = (AliITSClusterFinder*)GetReconstructionModel(id);
882 TClonesArray *itsDigits = DigitsAddress(id);
884 AliFatal("The reconstruction class was not instanciated!");
885 ResetDigits(); // MvL: Not sure we neeed this when rereading anyways
887 treeD->GetEvent(lastentry+module);
890 treeD->GetEvent(lastentry+(module-first));
892 Int_t ndigits = itsDigits->GetEntriesFast();
893 if (ndigits>0 || id==0) { // for SPD we always want to call FindRawClusters (to process FO signals)
894 rec->SetDetTypeRec(this);
895 rec->SetDigits(DigitsAddress(id));
896 // rec->SetClusters(ClustersAddress(id));
897 rec->FindRawClusters(module);
903 // Remove PIT in-active chips from Fast-OR fired map
904 if (all || det[0]) { // SPD present
905 RemoveFastOrFiredInActive();
906 // here removing bits which have no associated clusters
907 RemoveFastOrFiredFromDead(GetFiredChipMap(treeR));
910 AliITSRecPointContainer* rpcont = AliITSRecPointContainer::Instance();
912 nClu[0]=rpcont->GetNClustersInLayer(1,treeR);
913 for(Int_t iLay=2; iLay<=6; iLay++) nClu[iLay-1]=rpcont->GetNClustersInLayerFast(iLay);
914 AliInfo(Form("Number of RecPoints in ITS Layers = %d %d %d %d %d %d",
915 nClu[0],nClu[1],nClu[2],nClu[3],nClu[4],nClu[5]));
917 //______________________________________________________________________
918 void AliITSDetTypeRec::DigitsToRecPoints(AliRawReader* rawReader,TTree *treeR,Option_t *opt){
919 // cluster finding and reconstruction of space points
920 // the condition below will disappear when the geom class will be
921 // initialized for all versions - for the moment it is only for v5 !
922 // 7 is the SDD beam test version
924 // AliRawReader *rawReader Pointer to the raw-data reader
925 // TTree *treeR Clusters tree
930 const char *all = strstr(opt,"All");
931 const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
936 TClonesArray *array=new TClonesArray("AliITSRecPoint",1000);
937 TBranch *branch = treeR->Branch("ITSRecPoints",&array);
940 TClonesArray** clusters = new TClonesArray*[GetITSgeom()->GetIndexMax()];
941 for (Int_t iModule = 0; iModule < GetITSgeom()->GetIndexMax(); iModule++) {
942 clusters[iModule] = NULL;
945 DigitsToRecPoints(rawReader,clusters,opt);
948 TClonesArray *emptyArray=new TClonesArray("AliITSRecPoint");
949 for(Int_t iModule=0;iModule<GetITSgeom()->GetIndexMax();iModule++){
950 id = GetITSgeom()->GetModuleType(iModule);
951 if (!all && !det[id]) continue;
952 array = clusters[iModule];
954 AliDebug(1,Form("data for module %d missing!",iModule));
957 branch->SetAddress(&array);
959 nClusters+=array->GetEntriesFast();
961 if (array != emptyArray) {
968 AliITSRecPointContainer* rpcont = AliITSRecPointContainer::Instance();
970 nClu[0]=rpcont->GetNClustersInLayer(1,treeR);
971 for(Int_t iLay=2; iLay<=6; iLay++) nClu[iLay-1]=rpcont->GetNClustersInLayerFast(iLay);
972 AliInfo(Form("Number of RecPoints in ITS Layers = %d %d %d %d %d %d, Total = %d",
973 nClu[0],nClu[1],nClu[2],nClu[3],nClu[4],nClu[5],nClusters));
976 //______________________________________________________________________
977 void AliITSDetTypeRec::DigitsToRecPoints(AliRawReader* rawReader,TClonesArray** clusters,Option_t *opt){
978 // cluster finding and reconstruction of space points
979 // the condition below will disappear when the geom class will be
980 // initialized for all versions - for the moment it is only for v5 !
981 // 7 is the SDD beam test version
983 // AliRawReader *rawReader Pointer to the raw-data reader
984 // TClonesArray **clusters Clusters Array
989 const char *all = strstr(opt,"All");
990 const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"),
993 // Reset Fast-OR fired map
994 ResetFastOrFiredMap();
996 AliITSClusterFinder *rec = 0;
1000 if (!all && !det[id]) continue;
1001 rec = (AliITSClusterFinder*)GetReconstructionModel(id);
1003 AliFatal("The reconstruction class was not instantiated");
1004 rec->SetDetTypeRec(this);
1005 rec->RawdataToClusters(rawReader,clusters);
1008 // Remove PIT in-active chips from Fast-OR fired map
1009 if (all || det[0]) { // SPD present
1010 RemoveFastOrFiredInActive();
1011 // here removing bits which have no associated clusters
1012 if(clusters) RemoveFastOrFiredFromDead(GetFiredChipMap(clusters));
1016 //______________________________________________________________________
1017 void AliITSDetTypeRec::ReadOldSSDNoise(const TObjArray *array,
1018 AliITSNoiseSSDv2 *noiseSSD) {
1019 //Reads the old SSD calibration object and converts it to the new format
1020 const Int_t fgkSSDSTRIPSPERMODULE = 1536;
1021 const Int_t fgkSSDPSIDESTRIPSPERMODULE = 768;
1023 Int_t gNMod = array->GetEntries();
1024 cout<<"Converting old calibration object for noise..."<<endl;
1027 Double_t noise = 0.0;
1028 for (Int_t iModule = 0; iModule < gNMod; iModule++) {
1029 AliITSNoiseSSD *noiseModule = (AliITSNoiseSSD*) (array->At(iModule));
1030 for(Int_t iStrip = 0; iStrip < fgkSSDSTRIPSPERMODULE; iStrip++) {
1031 noise = (iStrip < fgkSSDPSIDESTRIPSPERMODULE) ? noiseModule->GetNoiseP(iStrip) : noiseModule->GetNoiseN(1535 - iStrip);
1032 if(iStrip < fgkSSDPSIDESTRIPSPERMODULE)
1033 noiseSSD->AddNoiseP(iModule,iStrip,noise);
1034 if(iStrip >= fgkSSDPSIDESTRIPSPERMODULE)
1035 noiseSSD->AddNoiseN(iModule,1535 - iStrip,noise);
1037 }//loop over modules
1040 //______________________________________________________________________
1041 void AliITSDetTypeRec::ReadOldSSDBadChannels(const TObjArray *array,
1042 AliITSBadChannelsSSDv2 *badChannelsSSD) {
1043 //Reads the old SSD calibration object and converts it to the new format
1044 Int_t gNMod = array->GetEntries();
1045 cout<<"Converting old calibration object for bad channels..."<<endl;
1046 for (Int_t iModule = 0; iModule < gNMod; iModule++) {
1047 //for (Int_t iModule = 0; iModule < 1; iModule++) {
1048 AliITSBadChannelsSSD *bad = (AliITSBadChannelsSSD*) (array->At(iModule));
1049 TArrayI arrayPSide = bad->GetBadPChannelsList();
1050 for(Int_t iPCounter = 0; iPCounter < arrayPSide.GetSize(); iPCounter++)
1051 badChannelsSSD->AddBadChannelP(iModule,
1053 (Char_t)arrayPSide.At(iPCounter));
1055 TArrayI arrayNSide = bad->GetBadNChannelsList();
1056 for(Int_t iNCounter = 0; iNCounter < arrayNSide.GetSize(); iNCounter++)
1057 badChannelsSSD->AddBadChannelN(iModule,
1059 (Char_t)arrayNSide.At(iNCounter));
1061 }//loop over modules
1064 //______________________________________________________________________
1065 void AliITSDetTypeRec::ReadOldSSDGain(const TObjArray *array,
1066 AliITSGainSSDv2 *gainSSD) {
1067 //Reads the old SSD calibration object and converts it to the new format
1069 Int_t gNMod = array->GetEntries();
1070 cout<<"Converting old calibration object for gain..."<<endl;
1073 for (Int_t iModule = 0; iModule < gNMod; iModule++) {
1074 AliITSGainSSD *gainModule = (AliITSGainSSD*) (array->At(iModule));
1075 TArrayF arrayPSide = gainModule->GetGainP();
1076 for(Int_t iPCounter = 0; iPCounter < arrayPSide.GetSize(); iPCounter++)
1077 gainSSD->AddGainP(iModule,
1079 arrayPSide.At(iPCounter));
1080 TArrayF arrayNSide = gainModule->GetGainN();
1081 for(Int_t iNCounter = 0; iNCounter < arrayNSide.GetSize(); iNCounter++)
1082 gainSSD->AddGainN(iModule,
1084 arrayNSide.At(iNCounter));
1085 }//loop over modules
1087 //______________________________________________________________________
1088 void AliITSDetTypeRec::RemoveFastOrFiredInActive() {
1089 // Removes the chips that were in-active in the pixel trigger (from fast-or fired map)
1091 if (fTriggerConditions==NULL) {
1092 AliError("Pixel trigger conditions are missing.");
1098 while (fTriggerConditions->GetNextInActiveChip(eq,hs,chip)) {
1099 UInt_t chipKey = AliITSRawStreamSPD::GetOfflineChipKeyFromOnline(eq,hs,chip);
1100 fFastOrFiredMap.SetBitNumber(chipKey,kFALSE);
1103 //______________________________________________________________________
1104 TBits AliITSDetTypeRec::GetFiredChipMap(TClonesArray **clusters) const {
1107 // TBits of the fired chips
1110 TBits isfiredchip(1200);
1112 AliITSsegmentationSPD *segSPD = (AliITSsegmentationSPD*)GetSegmentationModel(0);
1114 AliError("no segmentation model for SPD available, the fired chip map is empty. Exiting");
1119 for(Int_t imod =0; imod < fgkDefaultNModulesSPD; imod++){
1120 TClonesArray *array = clusters[imod];
1121 if(!array) continue;
1122 Int_t nCluster = array->GetEntriesFast();
1125 AliITSRecPoint* cluster = (AliITSRecPoint*)array->UncheckedAt(nCluster);
1126 if (cluster->GetLayer()>1)continue;
1127 Float_t local[3]={-1,-1};
1128 local[1]=cluster->GetDetLocalX();
1129 local[0]=cluster->GetDetLocalZ();
1131 Int_t eq = AliITSRawStreamSPD::GetOnlineEqIdFromOffline(imod);
1132 Int_t hs = AliITSRawStreamSPD::GetOnlineHSFromOffline(imod);
1134 segSPD->LocalToDet(0.5,local[0],row,col);
1135 Int_t chip = AliITSRawStreamSPD::GetOnlineChipFromOffline(imod,col);
1136 Int_t chipkey = AliITSRawStreamSPD::GetOfflineChipKeyFromOnline(eq,hs,chip);
1137 isfiredchip.SetBitNumber(chipkey,kTRUE);
1145 //______________________________________________________________________
1146 TBits AliITSDetTypeRec::GetFiredChipMap(TTree *treeR) const{
1148 // TBits of the fired chips
1150 TBits isfiredchip(1200);
1153 AliError("no treeR. fired chip map stays empty. Exiting.");
1157 AliITSRecPointContainer* rpcont=AliITSRecPointContainer::Instance();
1158 TClonesArray *recpoints = rpcont->FetchClusters(0,treeR);
1159 if(!rpcont->GetStatusOK() || !rpcont->IsSPDActive()){
1160 AliError("no clusters. fired chip map stays empty. Exiting.");
1164 AliITSsegmentationSPD *segSPD = (AliITSsegmentationSPD*)GetSegmentationModel(0);
1166 for(Int_t imod =0; imod < fgkDefaultNModulesSPD; imod++){
1167 recpoints = rpcont->UncheckedGetClusters(imod);
1168 Int_t nCluster = recpoints->GetEntriesFast();
1170 // loop over clusters
1172 AliITSRecPoint* cluster = (AliITSRecPoint*)recpoints->UncheckedAt(nCluster);
1173 if (cluster->GetLayer()>1)continue;
1174 Float_t local[3]={-1,-1};
1175 local[1]=cluster->GetDetLocalX();
1176 local[0]=cluster->GetDetLocalZ();
1178 Int_t eq = AliITSRawStreamSPD::GetOnlineEqIdFromOffline(imod);
1179 Int_t hs = AliITSRawStreamSPD::GetOnlineHSFromOffline(imod);
1181 segSPD->LocalToDet(0.5,local[0],row,col);
1182 Int_t chip = AliITSRawStreamSPD::GetOnlineChipFromOffline(imod,col);
1183 Int_t chipkey = AliITSRawStreamSPD::GetOfflineChipKeyFromOnline(eq,hs,chip);
1184 isfiredchip.SetBitNumber(chipkey,kTRUE);
1190 //______________________________________________________________________
1191 void AliITSDetTypeRec::RemoveFastOrFiredFromDead(TBits firedchipmap){
1193 // resetting of the fast-or bit on cluster basis.
1194 // fast-or bits can be remnant from SPD ideal simulation (no dead channels)
1197 for(Int_t chipKey=0; chipKey<1200; chipKey++){
1198 // FO masked chips have been previously removed
1199 if(!fFastOrFiredMap.TestBitNumber(chipKey)) continue;
1200 if(!firedchipmap.TestBitNumber(chipKey)) {
1201 fFastOrFiredMap.SetBitNumber(chipKey,kFALSE);
1202 AliDebug(2,Form("removing bit in key %i \n ",chipKey));
1207 //______________________________________________________________________
1208 void AliITSDetTypeRec::SetFastOrFiredMapOnline(UInt_t eq, UInt_t hs, UInt_t chip) {
1209 // Set fast-or fired map for this chip
1210 Int_t chipKey = AliITSRawStreamSPD::GetOfflineChipKeyFromOnline(eq,hs,chip);
1211 return SetFastOrFiredMap(chipKey);