* 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]));
}
}
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;
}
-
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);
strstr(opt,"SSD")};
Int_t id=0;
- /*
- TClonesArray *array=new TClonesArray("AliITSRecPoint",1000);
- 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;
- }
- */
AliITSRecPointContainer* rpc = AliITSRecPointContainer::Instance();
rpc->FullReset();
TClonesArray* array = rpc->UncheckedGetClusters(0);
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 = 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;
- printf("=============== +++++++++++++++++ ===================\n");
- for(Int_t iModule=0;iModule<GetITSgeom()->GetIndexMax();iModule++){
- array = rpc->UncheckedGetClusters(iModule);
- Int_t number = array->GetEntries();
- if(number>0)printf("Module %d has %d clusters\n",iModule,number);
}
+
rpc->FullReset();
AliITSRecPointContainer* rpcont = AliITSRecPointContainer::Instance();
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));
-
- printf("=============== SECOND +++++++++++++++++ ===================\n");
- for(Int_t iModule=0;iModule<GetITSgeom()->GetIndexMax();iModule++){
- array = rpc->UncheckedGetClusters(iModule);
- Int_t number = array->GetEntries();
- if(number>0)printf("Module %d has %d clusters\n",iModule,number);
- }
-
- // delete[] clusters;
}
//______________________________________________________________________
void AliITSDetTypeRec::DigitsToRecPoints(AliRawReader* rawReader,Option_t *opt){
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;