* provided "as is" without express or implied warranty. *
**************************************************************************/
-/*
- $Id$
-*/
+
////////////////////////////////////////////////////////////////////////
// This class defines the "Standard" reconstruction for the ITS //
#include "AliITSClusterFinder.h"
#include "AliITSClusterFinderV2SPD.h"
#include "AliITSClusterFinderV2SDD.h"
+#include "AliITSClusterFinderSDDfast.h"
#include "AliITSClusterFinderV2SSD.h"
#include "AliITSDetTypeRec.h"
#include "AliITSDDLModuleMapSDD.h"
#include "AliDataLoader.h"
#include "AliITSLoader.h"
+
class AliITSDriftSpeedArraySDD;
class AliITSCorrMapSDD;
class AliITSRecoParam;
fCalibration(0),
fSSDCalibration(0),
fSPDDead(0),
+fSPDSparseDead(0),
fTriggerConditions(0),
fDigits(0),
fFOSignals(0),
fNMod[0] = fgkDefaultNModulesSPD;
fNMod[1] = fgkDefaultNModulesSDD;
fNMod[2] = fgkDefaultNModulesSSD;
- fRecPoints = new TClonesArray("AliITSRecPoint",3000);
fNRecPoints = 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(fReconstruction){
fReconstruction->Delete();
delete fReconstruction;
- fReconstruction = 0;
}
if(fSegmentation){
fSegmentation->Delete();
delete fSegmentation;
- fSegmentation = 0;
}
if(fCalibration){
if(!(AliCDBManager::Instance()->GetCacheFlag())) {
fCalibration->Delete();
delete fCalibration;
- fCalibration = 0;
if(fRespSDD) delete fRespSDD;
if(fDDLMapSDD) delete fDDLMapSDD;
}
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;
}
}
if(fTriggerConditions){
if(!(AliCDBManager::Instance()->GetCacheFlag())) {
fTriggerConditions->Delete();
delete fTriggerConditions;
- fTriggerConditions = 0;
}
}
if(fDigits){
fDigits->Delete();
delete fDigits;
- fDigits=0;
}
if(fRecPoints){
fRecPoints->Delete();
delete fRecPoints;
- fRecPoints=0;
}
delete [] fNMod;
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]));
}
}
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;
}
-
fNMod[0] = calNoisySPD->GetEntries();
AliITSCalibration* cal;
SetCalibrationModel(i, cal);
cal = (AliITSCalibration*) calDeadSPD->At(i);
SetSPDDeadModel(i, cal);
+ cal = (AliITSCalibration*) calSparseDeadSPD->At(i);
+ SetSPDSparseDeadModel(i, cal);
}
fTriggerConditions = calPitCond;
}
//________________________________________________________________
-void AliITSDetTypeRec::SetDefaultClusterFindersV2(Bool_t rawdata){
+void AliITSDetTypeRec::SetDefaultClusterFindersV2(Bool_t rawdata, Bool_t fastSDD){
//Set defaults for cluster finder V2
//SDD
if(dettype==1){
if(!GetReconstructionModel(dettype)){
- clf = new AliITSClusterFinderV2SDD(this);
+ if(fastSDD){
+ clf = new AliITSClusterFinderSDDfast(this);
+ }
+ else {
+ clf = new AliITSClusterFinderV2SDD(this);
+ }
clf->InitGeometry();
if(!rawdata) clf->SetDigits(DigitsAddress(1));
SetReconstructionModel(dettype,clf);
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);
// none.
// Return:
// none.
-
TClonesArray &lrecp = *fRecPoints;
new(lrecp[fNRecPoints++]) AliITSRecPoint(r);
}
SetDefaultClusterFindersV2();
AliDebug(1,"V2 cluster finder has been selected \n");
}else{
- SetDefaultClusterFindersV2();
- AliInfo("Cluster Finder Option not implemented, V2 cluster finder will be used \n");
+ SetDefaultClusterFindersV2(kFALSE,kTRUE);
+ AliDebug(1,"SPD and SSD V2 Cluster Finder - SDD fast Cluster Finder \n");
}
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);
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);
}
const Int_t fgkSSDPSIDESTRIPSPERMODULE = 768;
Int_t gNMod = array->GetEntries();
- cout<<"Converting old calibration object for noise..."<<endl;
+ AliInfo("Converting old calibration object for noise...\n");
//NOISE
Double_t noise = 0.0;
AliITSBadChannelsSSDv2 *badChannelsSSD) {
//Reads the old SSD calibration object and converts it to the new format
Int_t gNMod = array->GetEntries();
- cout<<"Converting old calibration object for bad channels..."<<endl;
+ AliInfo("Converting old calibration object for bad channels...");
for (Int_t iModule = 0; iModule < gNMod; iModule++) {
//for (Int_t iModule = 0; iModule < 1; iModule++) {
AliITSBadChannelsSSD *bad = (AliITSBadChannelsSSD*) (array->At(iModule));
//Reads the old SSD calibration object and converts it to the new format
Int_t gNMod = array->GetEntries();
- cout<<"Converting old calibration object for gain..."<<endl;
+ AliInfo("Converting old calibration object for gain...\n");
//GAIN
for (Int_t iModule = 0; iModule < gNMod; iModule++) {
}
AliITSRecPointContainer* rpcont=AliITSRecPointContainer::Instance();
- TClonesArray *recpoints = rpcont->FetchClusters(0,treeR);
+ TClonesArray *recpoints = NULL;
+ rpcont->FetchClusters(0,treeR);
if(!rpcont->GetStatusOK() || !rpcont->IsSPDActive()){
AliError("no clusters. fired chip map stays empty. Exiting.");
return isfiredchip;