X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITSDetTypeRec.cxx;h=47b9a54b5dd8c41a5d0f8d03ff191dc772e2d5c3;hb=074b8e6f07b13bfaae60927f985f0d5ca1005cf0;hp=9975a3fe2e7764cb785daabdc6653aba958fc52b;hpb=b17dae484ff236012904cac8ecbe55defe2f4c98;p=u%2Fmrichter%2FAliRoot.git diff --git a/ITS/AliITSDetTypeRec.cxx b/ITS/AliITSDetTypeRec.cxx index 9975a3fe2e7..47b9a54b5dd 100644 --- a/ITS/AliITSDetTypeRec.cxx +++ b/ITS/AliITSDetTypeRec.cxx @@ -26,6 +26,7 @@ #include "TTree.h" #include "AliCDBManager.h" +#include "AliCDBStorage.h" #include "AliCDBEntry.h" #include "AliITSClusterFinder.h" #include "AliITSClusterFinderV2.h" @@ -36,12 +37,18 @@ #include "AliITSClusterFinderSDD.h" #include "AliITSClusterFinderSSD.h" #include "AliITSDetTypeRec.h" +#include "AliITSgeom.h" #include "AliITSRawCluster.h" #include "AliITSRawClusterSPD.h" #include "AliITSRawClusterSDD.h" #include "AliITSRawClusterSSD.h" #include "AliITSRecPoint.h" #include "AliITSCalibrationSDD.h" +#include "AliITSMapSDD.h" +#include "AliITSCalibrationSSD.h" +#include "AliITSNoiseSSD.h" +#include "AliITSGainSSD.h" +#include "AliITSBadChannelsSSD.h" #include "AliITSsegmentationSPD.h" #include "AliITSsegmentationSDD.h" #include "AliITSsegmentationSSD.h" @@ -56,39 +63,22 @@ const Int_t AliITSDetTypeRec::fgkDefaultNModulesSSD = 1698; ClassImp(AliITSDetTypeRec) //________________________________________________________________ -AliITSDetTypeRec::AliITSDetTypeRec(): TObject(){ - // Default Constructor - // Inputs: - // none. - // Outputs: - // none. - // Return: - // A properly zero-ed AliITSDetTypeRec class. - fReconstruction = 0; - fSegmentation = 0; - fCalibration = 0; - fPreProcess = 0; - fPostProcess = 0; - fDigits = 0;; - for(Int_t i=0; i<3; i++){ - fClusterClassName[i]=0; - fDigClassName[i]=0; - fRecPointClassName[i]=0; - } - fNdtype = 0; - fCtype = 0; - fNMod = 0; - fNctype = 0; - fRecPoints = 0; - fNRecPoints = 0; - SelectVertexer(" "); - fLoader = 0; - fRunNumber = 0; - fFirstcall = kTRUE; - -} -//________________________________________________________________ -AliITSDetTypeRec::AliITSDetTypeRec(AliITSLoader *loader): TObject(){ +AliITSDetTypeRec::AliITSDetTypeRec(): TObject(), +fNMod(0), +fITSgeom(0), +fReconstruction(0), +fSegmentation(0), +fCalibration(0), +fPreProcess(0), +fPostProcess(0), +fDigits(0), +fNdtype(0), +fCtype(0), +fNctype(0), +fRecPoints(0), +fNRecPoints(0), +fSelectedVertexer(), +fFirstcall(kTRUE){ // Standard Constructor // Inputs: // none. @@ -98,10 +88,6 @@ AliITSDetTypeRec::AliITSDetTypeRec(AliITSLoader *loader): TObject(){ // fReconstruction = new TObjArray(fgkNdettypes); - fSegmentation = 0; - fCalibration = 0; - fPreProcess = 0; - fPostProcess = 0; fDigits = new TObjArray(fgkNdettypes); for(Int_t i=0; i<3; i++){ fClusterClassName[i]=0; @@ -123,32 +109,44 @@ AliITSDetTypeRec::AliITSDetTypeRec(AliITSLoader *loader): TObject(){ fNctype[i]=0; } - SelectVertexer(" "); - fLoader = loader; - - SetRunNumber(); - fFirstcall = kTRUE; + SelectVertexer(" "); } + //______________________________________________________________________ -AliITSDetTypeRec::AliITSDetTypeRec(const AliITSDetTypeRec &/*rec*/):TObject(/*rec*/){ - // Copy constructor. +AliITSDetTypeRec::AliITSDetTypeRec(const AliITSDetTypeRec & rec):TObject(rec), +fNMod(rec.fNMod), +fITSgeom(rec.fITSgeom), +fReconstruction(rec.fReconstruction), +fSegmentation(rec.fSegmentation), +fCalibration(rec.fCalibration), +fPreProcess(rec.fPreProcess), +fPostProcess(rec.fPostProcess), +fDigits(rec.fDigits), +fNdtype(rec.fNdtype), +fCtype(rec.fCtype), +fNctype(rec.fNctype), +fRecPoints(rec.fRecPoints), +fNRecPoints(rec.fNRecPoints), +fSelectedVertexer(rec.fSelectedVertexer), +fFirstcall(rec.fFirstcall) +{ + + // Copy constructor. - Error("Copy constructor","Copy constructor not allowed"); - } //______________________________________________________________________ -AliITSDetTypeRec& AliITSDetTypeRec::operator=(const AliITSDetTypeRec& /*source*/){ - // Assignment operator. This is a function which is not allowed to be - // done. - Error("operator=","Assignment operator not allowed\n"); - return *this; +AliITSDetTypeRec& AliITSDetTypeRec::operator=(const AliITSDetTypeRec& source){ + // Assignment operator. + this->~AliITSDetTypeRec(); + new(this) AliITSDetTypeRec(source); + return *this; + } //_____________________________________________________________________ AliITSDetTypeRec::~AliITSDetTypeRec(){ - //Destructor - + if(fReconstruction){ fReconstruction->Delete(); delete fReconstruction; @@ -159,16 +157,18 @@ AliITSDetTypeRec::~AliITSDetTypeRec(){ delete fSegmentation; fSegmentation = 0; } - if(fCalibration && fRunNumber<0){ - AliITSresponse* rspd = ((AliITSCalibration*)fCalibration->At(GetITSgeom()->GetStartSPD()))->GetResponse(); - AliITSresponse* rsdd = ((AliITSCalibration*)fCalibration->At(GetITSgeom()->GetStartSDD()))->GetResponse(); - AliITSresponse* rssd = ((AliITSCalibration*)fCalibration->At(GetITSgeom()->GetStartSSD()))->GetResponse(); - if(rspd) delete rspd; - if(rsdd) delete rsdd; - if(rssd) delete rssd; - fCalibration->Delete(); - delete fCalibration; - fCalibration = 0; + if(fCalibration){ + if(!(AliCDBManager::Instance()->GetCacheFlag())) { + AliITSresponse* rspd = ((AliITSCalibration*)fCalibration->At(GetITSgeom()->GetStartSPD()))->GetResponse(); + AliITSresponse* rsdd = ((AliITSCalibration*)fCalibration->At(GetITSgeom()->GetStartSDD()))->GetResponse(); + AliITSresponse* rssd = ((AliITSCalibration*)fCalibration->At(GetITSgeom()->GetStartSSD()))->GetResponse(); + if(rspd) delete rspd; + if(rsdd) delete rsdd; + if(rssd) delete rssd; + fCalibration->Delete(); + delete fCalibration; + fCalibration = 0; + } } if(fPreProcess) delete fPreProcess; if(fPostProcess) delete fPostProcess; @@ -191,8 +191,9 @@ AliITSDetTypeRec::~AliITSDetTypeRec(){ delete [] fNctype; delete [] fNdtype; delete [] fNMod; - if(fLoader) delete fLoader; + if (fITSgeom) delete fITSgeom; + } //___________________________________________________________________ @@ -265,16 +266,6 @@ AliITSCalibration* AliITSDetTypeRec::GetCalibrationModel(Int_t iMod){ return (AliITSCalibration*)fCalibration->At(iMod); } -//______________________________________________________________________ -void AliITSDetTypeRec::SetTreeAddress(){ - // Set branch address for the Trees. - - TTree *treeR = fLoader->TreeR(); - TTree *treeD = fLoader->TreeD(); - - SetTreeAddressD(treeD); - SetTreeAddressR(treeR); -} //______________________________________________________________________ void AliITSDetTypeRec::SetTreeAddressD(TTree *treeD){ // Set branch address for the tree of digits. @@ -307,7 +298,7 @@ void AliITSDetTypeRec::SetTreeAddressD(TTree *treeD){ TBranch* AliITSDetTypeRec::MakeBranchInTree(TTree *tree, const char* name, const char *classname, void* address,Int_t size, - Int_t splitlevel, const char */*file*/) + Int_t splitlevel) { // // Makes branch in given tree and diverts them to a separate file @@ -356,7 +347,7 @@ void AliITSDetTypeRec::SetDefaults(){ } if(dettype==1){ AliITSCalibrationSDD* res=(AliITSCalibrationSDD*) GetCalibrationModel(GetITSgeom()->GetStartSDD()); - seg = new AliITSsegmentationSDD(GetITSgeom(),res); + seg = new AliITSsegmentationSDD(GetITSgeom()); SetSegmentationModel(dettype,seg); const char *kopt = ((AliITSresponseSDD*)res->GetResponse())->ZeroSuppOption(); if((!strstr(kopt,"2D"))&&(!strstr(kopt,"1D"))) SetDigitClassName(dettype,"AliITSdigit"); @@ -388,88 +379,99 @@ Bool_t AliITSDetTypeRec::GetCalibration() { fFirstcall = kFALSE; } - SetRunNumber((Int_t)AliCDBManager::Instance()->GetRun()); - Int_t run=GetRunNumber(); - if(run<0)run=0; // if the run number is not yet set, use fake run # 0 + // SetRunNumber((Int_t)AliCDBManager::Instance()->GetRun()); + // Int_t run=GetRunNumber(); - Bool_t origCacheStatus = AliCDBManager::Instance()->GetCacheFlag(); - Bool_t isCacheActive = kTRUE; - if(GetRunNumber()<0)isCacheActive=kFALSE; + Bool_t cacheStatus = AliCDBManager::Instance()->GetCacheFlag(); if (fCalibration==0) { fCalibration = new TObjArray(GetITSgeom()->GetIndexMax()); - fCalibration->SetOwner(isCacheActive); + fCalibration->SetOwner(!cacheStatus); fCalibration->Clear(); } - AliCDBManager::Instance()->SetCacheFlag(isCacheActive); - - AliCDBEntry *entrySPD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSPD", run); - AliCDBEntry *entrySDD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSDD", run); - AliCDBEntry *entrySSD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSSD", run); - AliCDBEntry *entry2SPD = AliCDBManager::Instance()->Get("ITS/Calib/RespSPD", run); - AliCDBEntry *entry2SDD = AliCDBManager::Instance()->Get("ITS/Calib/RespSDD", run); - AliCDBEntry *entry2SSD = AliCDBManager::Instance()->Get("ITS/Calib/RespSSD", run); - - if(!entrySPD || !entrySDD || !entrySSD || !entry2SPD || !entry2SDD || !entry2SSD){ - AliWarning("Calibration object retrieval failed! Dummy calibration will be used."); - AliCDBStorage *origStorage = AliCDBManager::Instance()->GetDefaultStorage(); - AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT"); - - entrySPD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSPD", run); - entrySDD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSDD", run); - entrySSD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSSD", run); - entry2SPD = AliCDBManager::Instance()->Get("ITS/Calib/RespSPD", run); - entry2SDD = AliCDBManager::Instance()->Get("ITS/Calib/RespSDD", run); - entry2SSD = AliCDBManager::Instance()->Get("ITS/Calib/RespSSD", run); - - AliCDBManager::Instance()->SetDefaultStorage(origStorage); - } - + AliCDBEntry *entrySPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDDead"); + AliCDBEntry *entrySDD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSDD"); + // AliCDBEntry *entrySSD = AliCDBManager::Instance()->Get("ITS/Calib/CalibSSD"); + AliCDBEntry *entryNoiseSSD = AliCDBManager::Instance()->Get("ITS/Calib/NoiseSSD"); + AliCDBEntry *entryGainSSD = AliCDBManager::Instance()->Get("ITS/Calib/GainSSD"); + AliCDBEntry *entryBadChannelsSSD = AliCDBManager::Instance()->Get("ITS/Calib/BadChannelsSSD"); + + AliCDBEntry *entry2SPD = AliCDBManager::Instance()->Get("ITS/Calib/RespSPD"); + AliCDBEntry *entry2SDD = AliCDBManager::Instance()->Get("ITS/Calib/RespSDD"); + AliCDBEntry *entry2SSD = AliCDBManager::Instance()->Get("ITS/Calib/RespSSD"); + AliCDBEntry *mapASDD = AliCDBManager::Instance()->Get("ITS/Calib/MapsAnodeSDD"); + AliCDBEntry *mapTSDD = AliCDBManager::Instance()->Get("ITS/Calib/MapsTimeSDD"); + + if(!entrySPD || !entrySDD || !entryNoiseSSD || !entryGainSSD || !entryBadChannelsSSD || + !entry2SPD || !entry2SDD || !entry2SSD || !mapASDD || !mapTSDD){ + AliFatal("Calibration object retrieval failed! "); + return kFALSE; + } + TObjArray *calSPD = (TObjArray *)entrySPD->GetObject(); - if(!isCacheActive)entrySPD->SetObject(NULL); + if(!cacheStatus)entrySPD->SetObject(NULL); entrySPD->SetOwner(kTRUE); AliITSresponseSPD *pSPD = (AliITSresponseSPD*)entry2SPD->GetObject(); - if(!isCacheActive)entry2SPD->SetObject(NULL); + if(!cacheStatus)entry2SPD->SetObject(NULL); entry2SPD->SetOwner(kTRUE); TObjArray *calSDD = (TObjArray *)entrySDD->GetObject(); - if(!isCacheActive)entrySDD->SetObject(NULL); + if(!cacheStatus)entrySDD->SetObject(NULL); entrySDD->SetOwner(kTRUE); AliITSresponseSDD *pSDD = (AliITSresponseSDD*)entry2SDD->GetObject(); - if(!isCacheActive)entry2SDD->SetObject(NULL); + if(!cacheStatus)entry2SDD->SetObject(NULL); entry2SDD->SetOwner(kTRUE); - TObjArray *calSSD = (TObjArray *)entrySSD->GetObject(); - if(!isCacheActive)entrySSD->SetObject(NULL); - entrySSD->SetOwner(kTRUE); + TObjArray *mapAn = (TObjArray *)mapASDD->GetObject(); + if(!cacheStatus)mapASDD->SetObject(NULL); + mapASDD->SetOwner(kTRUE); + + TObjArray *mapT = (TObjArray *)mapTSDD->GetObject(); + if(!cacheStatus)mapTSDD->SetObject(NULL); + mapTSDD->SetOwner(kTRUE); + + TObjArray *noiseSSD = (TObjArray *)entryNoiseSSD->GetObject(); + if(!cacheStatus)entryNoiseSSD->SetObject(NULL); + entryNoiseSSD->SetOwner(kTRUE); + + TObjArray *gainSSD = (TObjArray *)entryGainSSD->GetObject(); + if(!cacheStatus)entryGainSSD->SetObject(NULL); + entryGainSSD->SetOwner(kTRUE); + + TObjArray *badchannelsSSD = (TObjArray *)entryBadChannelsSSD->GetObject(); + if(!cacheStatus)entryBadChannelsSSD->SetObject(NULL); + entryBadChannelsSSD->SetOwner(kTRUE); AliITSresponseSSD *pSSD = (AliITSresponseSSD*)entry2SSD->GetObject(); - if(!isCacheActive)entry2SSD->SetObject(NULL); + if(!cacheStatus)entry2SSD->SetObject(NULL); entry2SSD->SetOwner(kTRUE); // DB entries are deleted. In this way metadeta objects are deleted as well - if(!isCacheActive){ + if(!cacheStatus){ delete entrySPD; delete entrySDD; - delete entrySSD; + delete entryNoiseSSD; + delete entryGainSSD; + delete entryBadChannelsSSD; delete entry2SPD; delete entry2SDD; delete entry2SSD; + delete mapASDD; + delete mapTSDD; } - AliCDBManager::Instance()->SetCacheFlag(origCacheStatus); - - if ((!pSPD)||(!pSDD)||(!pSSD) || (!calSPD) || (!calSDD) || (!calSSD)) { + if ((!pSPD)||(!pSDD)||(!pSSD) || (!calSPD) || (!calSDD) + || (!mapAn) || (!mapT) || (!noiseSSD)|| (!gainSSD)|| (!badchannelsSSD)) { AliWarning("Can not get calibration from calibration database !"); return kFALSE; } fNMod[0] = calSPD->GetEntries(); fNMod[1] = calSDD->GetEntries(); - fNMod[2] = calSSD->GetEntries(); + fNMod[2] = noiseSSD->GetEntries(); AliInfo(Form("%i SPD, %i SDD and %i SSD in calibration database", fNMod[0], fNMod[1], fNMod[2])); AliITSCalibration* cal; @@ -477,18 +479,37 @@ Bool_t AliITSDetTypeRec::GetCalibration() { cal = (AliITSCalibration*) calSPD->At(i); cal->SetResponse((AliITSresponse*)pSPD); SetCalibrationModel(i, cal); - } + } + Int_t nn1=0; + Int_t nn2=0; for (Int_t i=0; iAt(i); cal->SetResponse((AliITSresponse*)pSDD); + AliITSMapSDD* m1 = (AliITSMapSDD*)mapAn->At(nn1);nn1++; + AliITSMapSDD* m2 = (AliITSMapSDD*)mapAn->At(nn1);nn1++; + AliITSMapSDD* m3 = (AliITSMapSDD*)mapT->At(nn2);nn2++; + AliITSMapSDD* m4 = (AliITSMapSDD*)mapT->At(nn2);nn2++; + cal->SetMapA(0,m1); + cal->SetMapA(1,m2); + cal->SetMapT(0,m3); + cal->SetMapT(1,m4); Int_t iMod = i + fNMod[0]; SetCalibrationModel(iMod, cal); - } + } for (Int_t i=0; iAt(i); - cal->SetResponse((AliITSresponse*)pSSD); + + AliITSCalibrationSSD *calibSSD = new AliITSCalibrationSSD(); + calibSSD->SetResponse((AliITSresponse*)pSSD); + + AliITSNoiseSSD *noise = (AliITSNoiseSSD*) (noiseSSD->At(i)); + calibSSD->SetNoise(noise); + AliITSGainSSD *gain = (AliITSGainSSD*) (gainSSD->At(i)); + calibSSD->SetGain(gain); + AliITSBadChannelsSSD *bad = (AliITSBadChannelsSSD*) (badchannelsSSD->At(i)); + calibSSD->SetBadChannels(bad); + Int_t iMod = i + fNMod[0] + fNMod[1]; - SetCalibrationModel(iMod, cal); + SetCalibrationModel(iMod, calibSSD); } return kTRUE; @@ -507,9 +528,7 @@ void AliITSDetTypeRec::SetDefaultClusterFinders(){ AliITSClusterFinder *clf; - MakeTreeC(); - - for(Int_t dettype=0;dettypeTreeC()== 0x0) fLoader->MakeTree("C"); - MakeBranchC(); -} - -//______________________________________________________________ -void AliITSDetTypeRec::MakeBranchC(){ - - //Make branches in the tree of clusters - - if(!fLoader){ - Warning("MakeBranchC","ITS loader is null!"); - return; - } - TTree* lTC = fLoader->TreeC(); - if(lTC==0x0){ - Error("MakeTreeC","Can not get TreeC from loader"); - return; - } - - Int_t buffersize = 4000; - Char_t branchname[30]; - Char_t* cluclass; - const char *det[4]={"SPD","SDD","SSD","ITS"}; - - for(Int_t i=0;iAddAt(new TClonesArray(cluclass,1000),i); - } - if(fgkNdettypes==3) sprintf(branchname,"%sClusters%s",det[3],det[i]); - else sprintf(branchname,"%sClusters%d",det[3],i+1); - if(fCtype && lTC){ - if(lTC->GetBranch(branchname)){ - Warning("MakeBranchC","Branch %s already exists in TreeC",branchname); - } else{ - Info("MakeBranchC","Creating branch %s in TreeC",branchname); - lTC->Branch(branchname,&((*fCtype)[i]),buffersize); - } - } - - } - -} - -//_______________________________________________________________ -void AliITSDetTypeRec::GetTreeC(Int_t event){ - - //Get the clusters tree for this event and - //sets the branch address - - - if(!fLoader){ - Warning("GetTreeC","ITS loader is null!"); - return; - } - - Char_t branchname[30]; - const char *det[4] = {"SPD","SDD","SSD","ITS"}; - TTree* lTC = fLoader->TreeC(); - - ResetClusters(); - if(lTC) fLoader->CleanRawClusters(); - - TBranch* branch; - if(lTC){ - Char_t* cluclass; - for(Int_t i=0;iAt(i)) fCtype->AddAt(new TClonesArray(cluclass,1000),i); - if(fgkNdettypes==3) sprintf(branchname,"%sClusters%s",det[3],det[i]); - else sprintf(branchname,"%sClusters%d",det[3],i+1); - if(fCtype){ - branch = lTC->GetBranch(branchname); - if(branch) branch->SetAddress(&((*fCtype)[i])); - } - } - } else{ - Error("GetTreeC","cannot find clusters Tree for vent %d",event); - } + if(cR) MakeBranchR(tree); + if(cRF) MakeBranchRF(tree); } @@ -752,7 +678,7 @@ void AliITSDetTypeRec::ResetClusters(Int_t i){ if (fNctype) fNctype[i]=0; } //__________________________________________________________________ -void AliITSDetTypeRec::MakeBranchR(const char *file, Option_t *opt){ +void AliITSDetTypeRec::MakeBranchR(TTree *treeR, Option_t *opt){ //Creates tree branches for recpoints // Inputs: @@ -760,11 +686,6 @@ void AliITSDetTypeRec::MakeBranchR(const char *file, Option_t *opt){ // to. If blank it write the SDigits to the same // file in which the Hits were found. - if(!fLoader){ - Warning("MakeBranchR","ITS loader is null!"); - return; - } - Int_t buffsz = 4000; char branchname[30]; @@ -781,13 +702,8 @@ void AliITSDetTypeRec::MakeBranchR(const char *file, Option_t *opt){ } if(!fRecPoints)fRecPoints = new TClonesArray("AliITSRecPoint",1000); - if (fLoader->TreeR()) { - if(fRecPoints==0x0) fRecPoints = new TClonesArray("AliITSRecPoint", - 1000); - MakeBranchInTree(fLoader->TreeR(),branchname,0,&fRecPoints,buffsz,99,file); - } // end if - - + if (treeR) + MakeBranchInTree(treeR,branchname,0,&fRecPoints,buffsz,99); } //______________________________________________________________________ void AliITSDetTypeRec::SetTreeAddressR(TTree *treeR){ @@ -833,28 +749,20 @@ void AliITSDetTypeRec::AddRecPoint(const AliITSRecPoint &r){ } //______________________________________________________________________ -void AliITSDetTypeRec::DigitsToRecPoints(Int_t evNumber,Int_t lastentry,Option_t *opt, Bool_t v2){ +void AliITSDetTypeRec::DigitsToRecPoints(TTree *treeD,TTree *treeR,Int_t lastentry,Option_t *opt, Bool_t v2){ // cluster finding and reconstruction of space points // the condition below will disappear when the geom class will be // initialized for all versions - for the moment it is only for v5 ! // 7 is the SDD beam test version // Inputs: - // Int_t evNumber Event number to be processed. + // TTree *treeD Digits tree + // TTree *treeR Clusters tree // Int_t lastentry Offset for module when not all of the modules // are processed. // Option_t *opt String indicating which ITS sub-detectors should // be processed. If ="All" then all of the ITS // sub detectors are processed. - if(!GetITSgeom()){ - Warning("DigitsToRecPoints","Null pointer to AliITSgeom !"); - return; - } - if(!fLoader){ - Warning("DigitsToRecPoints","ITS loader is null!"); - return; - } - const char *all = strstr(opt,"All"); const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"), strstr(opt,"SSD")}; @@ -867,11 +775,6 @@ void AliITSDetTypeRec::DigitsToRecPoints(Int_t evNumber,Int_t lastentry,Option_t AliInfo("V2 cluster finder has been selected \n"); } - TTree *treeC=fLoader->TreeC(); - if(!treeC){ - MakeTreeC(); - MakeBranchC(); - } AliITSClusterFinder *rec = 0; Int_t id,module,first=0; for(module=0;moduleGetIndexMax();module++){ @@ -880,69 +783,47 @@ void AliITSDetTypeRec::DigitsToRecPoints(Int_t evNumber,Int_t lastentry,Option_t if(det[id]) first = GetITSgeom()->GetStartDet(id); rec = (AliITSClusterFinder*)GetReconstructionModel(id); TClonesArray *itsDigits = DigitsAddress(id); - if (!rec) { - Error("DigitsToRecPoints", - "The reconstruction class was not instanciated! event=%d", - evNumber); - exit(1); - } - ResetDigits(); - TTree *lTD = fLoader->TreeD(); + if (!rec) + AliFatal("The reconstruction class was not instanciated!"); + ResetDigits(); // MvL: Not sure we neeed this when rereading anyways if (all) { - lTD->GetEvent(lastentry+module); + treeD->GetEvent(lastentry+module); }else { - lTD->GetEvent(lastentry+(module-first)); + treeD->GetEvent(lastentry+(module-first)); } Int_t ndigits = itsDigits->GetEntriesFast(); if(ndigits>0){ rec->SetDetTypeRec(this); rec->SetDigits(DigitsAddress(id)); - rec->SetClusters(ClustersAddress(id)); + // rec->SetClusters(ClustersAddress(id)); rec->FindRawClusters(module); } // end if - fLoader->TreeR()->Fill(); + treeR->Fill(); ResetRecPoints(); - treeC->Fill(); ResetClusters(); } - - fLoader->WriteRecPoints("OVERWRITE"); - fLoader->WriteRawClusters("OVERWRITE"); } //______________________________________________________________________ -void AliITSDetTypeRec::DigitsToRecPoints(AliRawReader* rawReader){ +void AliITSDetTypeRec::DigitsToRecPoints(AliRawReader* rawReader,TTree *treeR,Option_t *opt){ // cluster finding and reconstruction of space points // the condition below will disappear when the geom class will be // initialized for all versions - for the moment it is only for v5 ! // 7 is the SDD beam test version // Inputs: - // Int_t evNumber Event number to be processed. - // Int_t lastentry Offset for module when not all of the modules - // are processed. - // Option_t *opt String indicating which ITS sub-detectors should - // be processed. If ="All" then all of the ITS - // sub detectors are processed. + // AliRawReader *rawReader Pointer to the raw-data reader + // TTree *treeR Clusters tree // Outputs: // none. // Return: // none. - if(!GetITSgeom()){ - Warning("DigitsToRecPoints","Null pointer to AliITSgeom !"); - return; - } - if(!fLoader){ - Warning("DigitsToRecPoints","ITS loader is null!"); - return; - } - - + const char *all = strstr(opt,"All"); + const char *det[3] = {strstr(opt,"SPD"),strstr(opt,"SDD"), + strstr(opt,"SSD")}; AliITSClusterFinderV2 *rec = 0; Int_t id=0; - if(!fLoader->TreeR()) fLoader->MakeTree("R"); - TTree* cTree = fLoader->TreeR(); TClonesArray *array=new TClonesArray("AliITSRecPoint",1000); - cTree->Branch("ITSRecPoints",&array); + TBranch *branch = treeR->Branch("ITSRecPoints",&array); delete array; TClonesArray** clusters = new TClonesArray*[GetITSgeom()->GetIndexMax()]; @@ -950,28 +831,33 @@ void AliITSDetTypeRec::DigitsToRecPoints(AliRawReader* rawReader){ clusters[iModule] = NULL; } for(id=0;id<3;id++){ + if (!all && !det[id]) continue; rec = (AliITSClusterFinderV2*)GetReconstructionModel(id); + if (!rec) + AliFatal("The reconstruction class was not instanciated"); rec->SetDetTypeRec(this); - if (!rec) { - Error("DigitsToRecPoints", - "The reconstruction class was not instanciated"); - exit(1); - } rec->RawdataToClusters(rawReader,clusters); } Int_t nClusters =0; + TClonesArray *emptyArray=new TClonesArray("AliITSRecPoint"); for(Int_t iModule=0;iModuleGetIndexMax();iModule++){ + id = GetITSgeom()->GetModuleType(iModule); + if (!all && !det[id]) continue; array = clusters[iModule]; if(!array){ - Error("DigitsToRecPoints","data for module %d missing!",iModule); - array = new TClonesArray("AliITSRecPoint"); + AliDebug(1,Form("data for module %d missing!",iModule)); + array = emptyArray; } - cTree->SetBranchAddress("ITSRecPoints",&array); - cTree->Fill(); + branch->SetAddress(&array); + treeR->Fill(); nClusters+=array->GetEntriesFast(); - delete array; + + if (array != emptyArray) { + array->Delete(); + delete array; + } } - fLoader->WriteRecPoints("OVERWRITE"); + delete emptyArray; delete[] clusters; Info("DigitsToRecPoints", "total number of found recpoints in ITS: %d\n",