#include "AliITSDetTypeRec.h"
#include "AliITSDDLModuleMapSDD.h"
#include "AliITSRecPoint.h"
+#include "AliITSRecPointContainer.h"
#include "AliITSCalibrationSDD.h"
#include "AliITSMapSDD.h"
#include "AliITSCalibrationSSD.h"
fCalibration(0),
fSSDCalibration(0),
fSPDDead(0),
+fSPDSparseDead(0),
fTriggerConditions(0),
fDigits(0),
fFOSignals(0),
fCalibration(rec.fCalibration),
fSSDCalibration(rec.fSSDCalibration),
fSPDDead(rec.fSPDDead),
+fSPDSparseDead(rec.fSPDSparseDead),
fTriggerConditions(rec.fTriggerConditions),
fDigits(rec.fDigits),
fFOSignals(rec.fFOSignals),
fFastOrFiredMap(rec.fFastOrFiredMap){
// Copy constructor.
-
+ for(Int_t i=0; i<3; i++){
+ fkDigClassName[i]=rec.fkDigClassName[i]; // NB only copies Char_t*, so not so safe, but this code should never be reached anyways
+ }
}
//______________________________________________________________________
AliITSDetTypeRec& AliITSDetTypeRec::operator=(const AliITSDetTypeRec& source){
if(fDDLMapSDD) delete fDDLMapSDD;
}
}
- if(fSSDCalibration) delete fSSDCalibration;
+ if(fSSDCalibration){
+ if(!(AliCDBManager::Instance()->GetCacheFlag())) {
+ delete fSSDCalibration;
+ fSSDCalibration = NULL;
+ }
+ }
if(fSPDDead){
if(!(AliCDBManager::Instance()->GetCacheFlag())) {
fSPDDead->Delete();
delete fSPDDead;
fSPDDead = 0;
}
+ }
+ if(fSPDSparseDead){
+ if(!(AliCDBManager::Instance()->GetCacheFlag())) {
+ fSPDSparseDead->Delete();
+ delete fSPDSparseDead;
+ fSPDSparseDead = 0;
+ }
}
if(fTriggerConditions){
if(!(AliCDBManager::Instance()->GetCacheFlag())) {
fSPDDead->AddAt(cal,iMod);
}
//_______________________________________________________________________
+void AliITSDetTypeRec::SetSPDSparseDeadModel(Int_t iMod, AliITSCalibration *cal){
+
+ //Set dead pixel info for the SPD ACTIVE module iMod
+ if (fSPDSparseDead==0) {
+ fSPDSparseDead = new TObjArray(fgkDefaultNModulesSPD);
+ fSPDSparseDead->SetOwner(kTRUE);
+ fSPDSparseDead->Clear();
+ }
+
+ if (fSPDSparseDead->At(iMod) != 0)
+ delete (AliITSCalibration*) fSPDSparseDead->At(iMod);
+ fSPDSparseDead->AddAt(cal,iMod);
+}
+//_______________________________________________________________________
AliITSCalibration* AliITSDetTypeRec::GetCalibrationModel(Int_t iMod) const {
//Get calibration model for module type
return (AliITSCalibration*)fSPDDead->At(iMod);
}
//_______________________________________________________________________
+AliITSCalibration* AliITSDetTypeRec::GetSPDSparseDeadModel(Int_t iMod) const {
+
+ //Get SPD dead for module iMod
+
+ if(fSPDSparseDead==0) {
+ AliWarning("fSPDSparseDead is 0!");
+ return 0;
+ }
+ return (AliITSCalibration*)fSPDSparseDead->At(iMod);
+}
+//_______________________________________________________________________
AliITSTriggerConditions* AliITSDetTypeRec::GetTriggerConditions() const {
//Get Pixel Trigger Conditions
if (fTriggerConditions==0) {
char branchname[30];
if(!treeD) return;
- if (fDigits == 0x0) fDigits = new TObjArray(fgkNdettypes);
+ if (fDigits == 0x0) {
+ fDigits = new TObjArray(fgkNdettypes);
+ }
+ else {
+ ResetDigits();
+ }
for (i=0; i<fgkNdettypes; i++) {
digclass = GetDigitClassName(i);
- if(!(fDigits->At(i))) {
- fDigits->AddAt(new TClonesArray(digclass,1000),i);
- }
- else{
- ResetDigits(i);
- }
- if (fgkNdettypes==3) sprintf(branchname,"%sDigits%s",det[3],det[i]);
- else sprintf(branchname,"%sDigits%d",det[3],i+1);
- if (fDigits) {
- branch = treeD->GetBranch(branchname);
- if (branch) branch->SetAddress(&((*fDigits)[i]));
- }
+ fDigits->AddAt(new TClonesArray(digclass,1000),i);
+ if (fgkNdettypes==3) snprintf(branchname,29,"%sDigits%s",det[3],det[i]);
+ else snprintf(branchname,29,"%sDigits%d",det[3],i+1);
+ branch = treeD->GetBranch(branchname);
+ if (branch) branch->SetAddress(&((*fDigits)[i]));
}
}
SetSegmentationModel(dettype,seg);
SetDigitClassName(dettype,"AliITSdigitSPD");
}
- if(fLoadOnlySPDCalib==kFALSE){
- if(dettype==1){
- seg = new AliITSsegmentationSDD();
+ if(dettype==1){
+ seg = new AliITSsegmentationSDD();
+ if(fLoadOnlySPDCalib==kFALSE){
AliITSCalibrationSDD* cal=(AliITSCalibrationSDD*)GetCalibrationModel(fgkDefaultNModulesSPD+1);
if(cal->IsAMAt20MHz()){
seg->SetPadSize(seg->Dpz(0),20.);
seg->SetNPads(seg->Npz()/2,128);
}
- SetSegmentationModel(dettype,seg);
- SetDigitClassName(dettype,"AliITSdigitSDD");
}
+ SetSegmentationModel(dettype,seg);
+ SetDigitClassName(dettype,"AliITSdigitSDD");
}
if(dettype==2){
AliITSsegmentationSSD* seg2 = new AliITSsegmentationSSD();
AliCDBEntry *noisySPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDNoisy");
AliCDBEntry *deadSPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDDead");
+ AliCDBEntry *deadSparseSPD = AliCDBManager::Instance()->Get("ITS/Calib/SPDSparseDead");
AliCDBEntry *pitCond = AliCDBManager::Instance()->Get("TRIGGER/SPD/PITConditions");
if(!noisySPD || !deadSPD || !pitCond ){
AliFatal("SPD Calibration object retrieval failed! ");
if (!cacheStatus) deadSPD->SetObject(NULL);
deadSPD->SetOwner(kTRUE);
+ TObjArray *calSparseDeadSPD = (TObjArray*) deadSparseSPD->GetObject();
+ if (!cacheStatus) deadSparseSPD->SetObject(NULL);
+ deadSparseSPD->SetOwner(kTRUE);
+
+
AliITSTriggerConditions *calPitCond = (AliITSTriggerConditions*) pitCond->GetObject();
if (!cacheStatus) pitCond->SetObject(NULL);
pitCond->SetOwner(kTRUE);
if(!cacheStatus){
delete noisySPD;
delete deadSPD;
+ delete deadSparseSPD;
delete pitCond;
}
- if ((!calNoisySPD) || (!calDeadSPD) || (!calPitCond)){
+ if ((!calNoisySPD) || (!calDeadSPD) || (!calSparseDeadSPD) || (!calPitCond)){
AliWarning("Can not get SPD calibration from calibration database !");
return kFALSE;
}
SetCalibrationModel(i, cal);
cal = (AliITSCalibration*) calDeadSPD->At(i);
SetSPDDeadModel(i, cal);
+ cal = (AliITSCalibration*) calSparseDeadSPD->At(i);
+ SetSPDSparseDeadModel(i, cal);
}
fTriggerConditions = calPitCond;
}
TObject *emptyssd = 0; TString ssdobjectname;
- AliITSNoiseSSDv2 *noiseSSD = new AliITSNoiseSSDv2();
+ AliITSNoiseSSDv2 *noiseSSD = NULL;
emptyssd = (TObject *)entryNoiseSSD->GetObject();
ssdobjectname = emptyssd->GetName();
if(ssdobjectname=="TObjArray") {
TObjArray *noiseSSDOld = (TObjArray *)entryNoiseSSD->GetObject();
+ noiseSSD = new AliITSNoiseSSDv2();
ReadOldSSDNoise(noiseSSDOld, noiseSSD);
}
else if(ssdobjectname=="AliITSNoiseSSDv2")
if(!cacheStatus)entryNoiseSSD->SetObject(NULL);
entryNoiseSSD->SetOwner(kTRUE);
- AliITSGainSSDv2 *gainSSD = new AliITSGainSSDv2();
+ AliITSGainSSDv2 *gainSSD = NULL;;
emptyssd = (TObject *)entryGainSSD->GetObject();
ssdobjectname = emptyssd->GetName();
if(ssdobjectname=="Gain") {
TObjArray *gainSSDOld = (TObjArray *)entryGainSSD->GetObject();
+ gainSSD = new AliITSGainSSDv2();
ReadOldSSDGain(gainSSDOld, gainSSD);
}
else if(ssdobjectname=="AliITSGainSSDv2")
if(!cacheStatus)entryGainSSD->SetObject(NULL);
entryGainSSD->SetOwner(kTRUE);
- AliITSBadChannelsSSDv2 *badChannelsSSD = new AliITSBadChannelsSSDv2();
+ AliITSBadChannelsSSDv2 *badChannelsSSD = NULL;
emptyssd = (TObject *)entryBadChannelsSSD->GetObject();
ssdobjectname = emptyssd->GetName();
if(ssdobjectname=="TObjArray") {
TObjArray *badChannelsSSDOld = (TObjArray *)entryBadChannelsSSD->GetObject();
+ badChannelsSSD = new AliITSBadChannelsSSDv2();
ReadOldSSDBadChannels(badChannelsSSDOld, badChannelsSSD);
}
else if(ssdobjectname=="AliITSBadChannelsSSDv2")
if(oFast){
- sprintf(branchname,"%sRecPointsF",detname);
+ snprintf(branchname,29,"%sRecPointsF",detname);
} else {
- sprintf(branchname,"%sRecPoints",detname);
+ snprintf(branchname,29,"%sRecPoints",detname);
}
if(!fRecPoints)fRecPoints = new TClonesArray("AliITSRecPoint",1000);
if(!treeR) return;
if(fRecPoints==0x0) fRecPoints = new TClonesArray("AliITSRecPoint",1000);
TBranch *branch;
- sprintf(branchname,"%sRecPoints",namedet);
+ snprintf(branchname,29,"%sRecPoints",namedet);
branch = treeR->GetBranch(branchname);
if (branch) {
branch->SetAddress(&fRecPoints);
}
else {
- sprintf(branchname,"%sRecPointsF",namedet);
+ snprintf(branchname,29,"%sRecPointsF",namedet);
branch = treeR->GetBranch(branchname);
if (branch) {
branch->SetAddress(&fRecPoints);
if(det[id]) first = GetITSgeom()->GetStartDet(id);
rec = (AliITSClusterFinder*)GetReconstructionModel(id);
TClonesArray *itsDigits = DigitsAddress(id);
- if (!rec)
- AliFatal("The reconstruction class was not instanciated!");
+ if (!rec){
+ AliFatal("The reconstruction class was not instanciated!");
+ return;
+ }
ResetDigits(); // MvL: Not sure we neeed this when rereading anyways
if (all) {
treeD->GetEvent(lastentry+module);
// Remove PIT in-active chips from Fast-OR fired map
if (all || det[0]) { // SPD present
RemoveFastOrFiredInActive();
+ // here removing bits which have no associated clusters
+ RemoveFastOrFiredFromDead(GetFiredChipMap(treeR));
}
+
+ AliITSRecPointContainer* rpcont = AliITSRecPointContainer::Instance();
+ Int_t nClu[6];
+ nClu[0]=rpcont->GetNClustersInLayer(1,treeR);
+ for(Int_t iLay=2; iLay<=6; iLay++) nClu[iLay-1]=rpcont->GetNClustersInLayerFast(iLay);
+ AliInfo(Form("Number of RecPoints in ITS Layers = %d %d %d %d %d %d",
+ nClu[0],nClu[1],nClu[2],nClu[3],nClu[4],nClu[5]));
}
//______________________________________________________________________
void AliITSDetTypeRec::DigitsToRecPoints(AliRawReader* rawReader,TTree *treeR,Option_t *opt){
strstr(opt,"SSD")};
Int_t id=0;
-
- TClonesArray *array=new TClonesArray("AliITSRecPoint",1000);
+ AliITSRecPointContainer* rpc = AliITSRecPointContainer::Instance();
+ rpc->FullReset();
+ TClonesArray* array = rpc->UncheckedGetClusters(0);
TBranch *branch = treeR->Branch("ITSRecPoints",&array);
- delete array;
-
- TClonesArray** clusters = new TClonesArray*[GetITSgeom()->GetIndexMax()];
- for (Int_t iModule = 0; iModule < GetITSgeom()->GetIndexMax(); iModule++) {
- clusters[iModule] = NULL;
- }
-
- DigitsToRecPoints(rawReader,clusters,opt);
+ DigitsToRecPoints(rawReader,opt);
Int_t nClusters =0;
- TClonesArray *emptyArray=new TClonesArray("AliITSRecPoint");
for(Int_t iModule=0;iModule<GetITSgeom()->GetIndexMax();iModule++){
id = GetITSgeom()->GetModuleType(iModule);
if (!all && !det[id]) continue;
- array = clusters[iModule];
+ array = rpc->UncheckedGetClusters(iModule);
if(!array){
AliDebug(1,Form("data for module %d missing!",iModule));
- array = emptyArray;
}
branch->SetAddress(&array);
treeR->Fill();
nClusters+=array->GetEntriesFast();
-
- if (array != emptyArray) {
- array->Delete();
- delete array;
- }
}
- delete emptyArray;
- delete[] clusters;
- Info("DigitsToRecPoints", "total number of found recpoints in ITS: %d\n",
- nClusters);
-
+ rpc->FullReset();
+
+ AliITSRecPointContainer* rpcont = AliITSRecPointContainer::Instance();
+ Int_t nClu[6];
+ nClu[0]=rpcont->GetNClustersInLayer(1,treeR);
+ for(Int_t iLay=2; iLay<=6; iLay++) nClu[iLay-1]=rpcont->GetNClustersInLayerFast(iLay);
+ AliInfo(Form("Number of RecPoints in ITS Layers = %d %d %d %d %d %d, Total = %d",
+ nClu[0],nClu[1],nClu[2],nClu[3],nClu[4],nClu[5],nClusters));
}
//______________________________________________________________________
-void AliITSDetTypeRec::DigitsToRecPoints(AliRawReader* rawReader,TClonesArray** clusters,Option_t *opt){
+void AliITSDetTypeRec::DigitsToRecPoints(AliRawReader* rawReader,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:
// AliRawReader *rawReader Pointer to the raw-data reader
- // TClonesArray **clusters Clusters Array
// Outputs:
// none.
// Return:
for(id=0;id<3;id++){
if (!all && !det[id]) continue;
rec = (AliITSClusterFinder*)GetReconstructionModel(id);
- if (!rec)
+ if (!rec){
AliFatal("The reconstruction class was not instantiated");
+ return;
+ }
rec->SetDetTypeRec(this);
- rec->RawdataToClusters(rawReader,clusters);
+ rec->RawdataToClusters(rawReader);
}
// Remove PIT in-active chips from Fast-OR fired map
if (all || det[0]) { // SPD present
RemoveFastOrFiredInActive();
+ // here removing bits which have no associated clusters
+ RemoveFastOrFiredFromDead(GetFiredChipMap());
+
}
}
//______________________________________________________________________
//______________________________________________________________________
void AliITSDetTypeRec::RemoveFastOrFiredInActive() {
// Removes the chips that were in-active in the pixel trigger (from fast-or fired map)
+
if (fTriggerConditions==NULL) {
AliError("Pixel trigger conditions are missing.");
return;
}
}
//______________________________________________________________________
+TBits AliITSDetTypeRec::GetFiredChipMap() const {
+
+ //
+ // TBits of the fired chips
+ //
+
+ AliITSRecPointContainer* rpc = AliITSRecPointContainer::Instance();
+
+ TBits isfiredchip(1200);
+
+ AliITSsegmentationSPD *segSPD = (AliITSsegmentationSPD*)GetSegmentationModel(0);
+ if(!segSPD) {
+ AliError("no segmentation model for SPD available, the fired chip map is empty. Exiting");
+ return isfiredchip;
+ }
+
+
+ for(Int_t imod =0; imod < fgkDefaultNModulesSPD; imod++){
+ TClonesArray *array = rpc->UncheckedGetClusters(imod);
+ if(!array) continue;
+ Int_t nCluster = array->GetEntriesFast();
+
+ while(nCluster--) {
+ AliITSRecPoint* cluster = (AliITSRecPoint*)array->UncheckedAt(nCluster);
+ if (cluster->GetLayer()>1)continue;
+ Float_t local[3]={-1,-1};
+ local[1]=cluster->GetDetLocalX();
+ local[0]=cluster->GetDetLocalZ();
+
+ Int_t eq = AliITSRawStreamSPD::GetOnlineEqIdFromOffline(imod);
+ Int_t hs = AliITSRawStreamSPD::GetOnlineHSFromOffline(imod);
+ Int_t row, col;
+ segSPD->LocalToDet(0.5,local[0],row,col);
+ Int_t chip = AliITSRawStreamSPD::GetOnlineChipFromOffline(imod,col);
+ Int_t chipkey = AliITSRawStreamSPD::GetOfflineChipKeyFromOnline(eq,hs,chip);
+ isfiredchip.SetBitNumber(chipkey,kTRUE);
+ }
+
+ }
+
+ return isfiredchip;
+
+}
+//______________________________________________________________________
+TBits AliITSDetTypeRec::GetFiredChipMap(TTree *treeR) const{
+ //
+ // TBits of the fired chips
+ //
+ TBits isfiredchip(1200);
+
+ if(!treeR) {
+ AliError("no treeR. fired chip map stays empty. Exiting.");
+ return isfiredchip;
+ }
+
+ AliITSRecPointContainer* rpcont=AliITSRecPointContainer::Instance();
+ TClonesArray *recpoints = NULL;
+ rpcont->FetchClusters(0,treeR);
+ if(!rpcont->GetStatusOK() || !rpcont->IsSPDActive()){
+ AliError("no clusters. fired chip map stays empty. Exiting.");
+ return isfiredchip;
+ }
+
+ AliITSsegmentationSPD *segSPD = (AliITSsegmentationSPD*)GetSegmentationModel(0);
+
+ for(Int_t imod =0; imod < fgkDefaultNModulesSPD; imod++){
+ recpoints = rpcont->UncheckedGetClusters(imod);
+ Int_t nCluster = recpoints->GetEntriesFast();
+
+ // loop over clusters
+ while(nCluster--) {
+ AliITSRecPoint* cluster = (AliITSRecPoint*)recpoints->UncheckedAt(nCluster);
+ if (cluster->GetLayer()>1)continue;
+ Float_t local[3]={-1,-1};
+ local[1]=cluster->GetDetLocalX();
+ local[0]=cluster->GetDetLocalZ();
+
+ Int_t eq = AliITSRawStreamSPD::GetOnlineEqIdFromOffline(imod);
+ Int_t hs = AliITSRawStreamSPD::GetOnlineHSFromOffline(imod);
+ Int_t row, col;
+ segSPD->LocalToDet(0.5,local[0],row,col);
+ Int_t chip = AliITSRawStreamSPD::GetOnlineChipFromOffline(imod,col);
+ Int_t chipkey = AliITSRawStreamSPD::GetOfflineChipKeyFromOnline(eq,hs,chip);
+ isfiredchip.SetBitNumber(chipkey,kTRUE);
+ }
+ }
+
+ return isfiredchip;
+}
+//______________________________________________________________________
+void AliITSDetTypeRec::RemoveFastOrFiredFromDead(TBits firedchipmap){
+ //
+ // resetting of the fast-or bit on cluster basis.
+ // fast-or bits can be remnant from SPD ideal simulation (no dead channels)
+ //
+
+ for(Int_t chipKey=0; chipKey<1200; chipKey++){
+ // FO masked chips have been previously removed
+ if(!fFastOrFiredMap.TestBitNumber(chipKey)) continue;
+ if(!firedchipmap.TestBitNumber(chipKey)) {
+ fFastOrFiredMap.SetBitNumber(chipKey,kFALSE);
+ AliDebug(2,Form("removing bit in key %i \n ",chipKey));
+ }
+ }
+
+}
+//______________________________________________________________________
void AliITSDetTypeRec::SetFastOrFiredMapOnline(UInt_t eq, UInt_t hs, UInt_t chip) {
// Set fast-or fired map for this chip
Int_t chipKey = AliITSRawStreamSPD::GetOfflineChipKeyFromOnline(eq,hs,chip);
return SetFastOrFiredMap(chipKey);
}
-
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff