X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=EMCAL%2FAliEMCALClusterizerFixedWindow.cxx;h=79af6c6d8a2a72ca907ed50dd740b2989b2bacc7;hb=c96dd5740381ff0e4a1b948641e40ecece70c7cb;hp=b094e28fb4e62b66ff792c6f876bd5ba297db037;hpb=27bad38624b5c5784395301cad9c3dc0371c5868;p=u%2Fmrichter%2FAliRoot.git diff --git a/EMCAL/AliEMCALClusterizerFixedWindow.cxx b/EMCAL/AliEMCALClusterizerFixedWindow.cxx index b094e28fb4e..79af6c6d8a2 100644 --- a/EMCAL/AliEMCALClusterizerFixedWindow.cxx +++ b/EMCAL/AliEMCALClusterizerFixedWindow.cxx @@ -34,50 +34,88 @@ #include "AliEMCALCalibData.h" #include "AliESDCaloCluster.h" #include "AliEMCALUnfolding.h" -#include "AliEMCALFixedWindowClusterInfo.h" #include "AliEMCALClusterizerFixedWindow.h" ClassImp(AliEMCALClusterizerFixedWindow) //__________________________________________________________________________________________ -AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow() - : AliEMCALClusterizer(), - fNphi(4), - fNeta(4), - fShiftPhi(2), - fShiftEta(2), - fTRUshift(0), - fClustersInfo(new AliEMCALFixedWindowClusterInfo("clustersInfo")), - fClustersArray(0) +AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow() : + AliEMCALClusterizer(), + fNphi(4), + fNeta(4), + fShiftPhi(2), + fShiftEta(2), + fTRUshift(0), + fNEtaDigitsSupMod(0), + fNPhiDigitsSupMod(0), + fNTRUPhi(0), + fNTRUEta(0), + fNEtaDigits(0), + fNPhiDigits(0), + fMaxShiftPhi(0), + fMaxShiftEta(0), + fNDigitsCluster(0), + fNClusEtaNoShift(0), + fNClusPhiNoShift(0), + fNClusters(0), + fNTotalClus(0), + fClustersArray(0), + fInitialized(0) { - // Constructor + // Constructor } //__________________________________________________________________________________________ -AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow(AliEMCALGeometry* geometry) - : AliEMCALClusterizer(geometry), - fNphi(4), - fNeta(4), - fShiftPhi(2), - fShiftEta(2), - fTRUshift(0), - fClustersInfo(new AliEMCALFixedWindowClusterInfo("clustersInfo")), - fClustersArray(0) +AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow(AliEMCALGeometry* geometry) : + AliEMCALClusterizer(geometry), + fNphi(4), + fNeta(4), + fShiftPhi(2), + fShiftEta(2), + fTRUshift(0), + fNEtaDigitsSupMod(0), + fNPhiDigitsSupMod(0), + fNTRUPhi(0), + fNTRUEta(0), + fNEtaDigits(0), + fNPhiDigits(0), + fMaxShiftPhi(0), + fMaxShiftEta(0), + fNDigitsCluster(0), + fNClusEtaNoShift(0), + fNClusPhiNoShift(0), + fNClusters(0), + fNTotalClus(0), + fClustersArray(0), + fInitialized(0) { // Constructor } //__________________________________________________________________________________________ -AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow(AliEMCALGeometry* geometry, AliEMCALCalibData * calib, AliCaloCalibPedestal * caloped) - : AliEMCALClusterizer(geometry, calib, caloped), - fNphi(4), - fNeta(4), - fShiftPhi(2), - fShiftEta(2), - fTRUshift(0), - fClustersInfo(new AliEMCALFixedWindowClusterInfo("clustersInfo")), - fClustersArray(0) +AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow(AliEMCALGeometry* geometry, AliEMCALCalibData * calib, AliCaloCalibPedestal * caloped) : + AliEMCALClusterizer(geometry, calib, caloped), + fNphi(4), + fNeta(4), + fShiftPhi(2), + fShiftEta(2), + fTRUshift(0), + fNEtaDigitsSupMod(0), + fNPhiDigitsSupMod(0), + fNTRUPhi(0), + fNTRUEta(0), + fNEtaDigits(0), + fNPhiDigits(0), + fMaxShiftPhi(0), + fMaxShiftEta(0), + fNDigitsCluster(0), + fNClusEtaNoShift(0), + fNClusPhiNoShift(0), + fNClusters(0), + fNTotalClus(0), + fClustersArray(0), + fInitialized(0) { // Constructor } @@ -85,10 +123,19 @@ AliEMCALClusterizerFixedWindow::AliEMCALClusterizerFixedWindow(AliEMCALGeometry* //__________________________________________________________________________________________ AliEMCALClusterizerFixedWindow::~AliEMCALClusterizerFixedWindow() { - // Destructor - - delete fClustersInfo; - delete fClustersArray; + // Destructor + + if (fClustersArray) { + for (Int_t i = 0; i < fNTotalClus; i++) { + if (fClustersArray[i]) { + delete[] fClustersArray[i]; + fClustersArray[i] = 0; + } + } + delete[] fClustersArray; + fClustersArray = 0; + } + } //__________________________________________________________________________________________ @@ -96,7 +143,7 @@ void AliEMCALClusterizerFixedWindow::SetNphi (Int_t n) { // Set fNphi; if clusterizer already initialized gives a warning and does nothing - if (fClustersArray) + if (fInitialized != 0) AliWarning("Clusterizer already initialized. Unable to change the parameters."); else fNphi = n; @@ -107,7 +154,7 @@ void AliEMCALClusterizerFixedWindow::SetNeta (Int_t n) { // Set fNeta; if clusterizer already initialized gives a warning and does nothing - if (fClustersArray) + if (fInitialized != 0) AliWarning("Clusterizer already initialized. Unable to change the parameters."); else fNeta = n; @@ -118,7 +165,7 @@ void AliEMCALClusterizerFixedWindow::SetShiftPhi (Int_t s) { // Set fShiftPhi; if clusterizer already initialized gives a warning and does nothing - if (fClustersArray) + if (fInitialized != 0) AliWarning("Clusterizer already initialized. Unable to change the parameters."); else fShiftPhi = s; @@ -129,7 +176,7 @@ void AliEMCALClusterizerFixedWindow::SetShiftEta (Int_t s) { // Set fShiftEta; if clusterizer already initialized gives a warning and does nothing - if (fClustersArray) + if (fInitialized != 0) AliWarning("Clusterizer already initialized. Unable to change the parameters."); else fShiftEta = s; @@ -140,7 +187,7 @@ void AliEMCALClusterizerFixedWindow::SetTRUshift(Bool_t b) { // Set fTRUshift; if clusterizer already initialized gives a warning and does nothing - if (fClustersArray) + if (fInitialized != 0) AliWarning("Clusterizer already initialized. Unable to change the parameters."); else fTRUshift = b; @@ -150,210 +197,278 @@ void AliEMCALClusterizerFixedWindow::SetTRUshift(Bool_t b) //__________________________________________________________________________________________ void AliEMCALClusterizerFixedWindow::Digits2Clusters(Option_t * option) { - // Steering method to perform clusterization for the current event - - if (strstr(option,"tim")) - gBenchmark->Start("EMCALClusterizer"); + // Steering method to perform clusterization for the current event + + static Float_t cputime = 0; + static Float_t realtime = 0; + + if (strstr(option,"tim")) + gBenchmark->Start("EMCALClusterizer"); - if (strstr(option,"print")) - Print(""); + if (strstr(option,"print")) + Print(""); - //Get calibration parameters from file or digitizer default values. - GetCalibrationParameters(); + //Get calibration parameters from file or digitizer default values. + GetCalibrationParameters(); - //Get dead channel map from file or digitizer default values. - GetCaloCalibPedestal(); + //Get dead channel map from file or digitizer default values. + GetCaloCalibPedestal(); - MakeClusters(); //only the real clusters + MakeClusters(); //only the real clusters - if (fToUnfold) { - fClusterUnfolding->SetInput(fNumberOfECAClusters,fRecPoints,fDigitsArr); - fClusterUnfolding->MakeUnfolding(); - } + if (fToUnfold) { + fClusterUnfolding->SetInput(fNumberOfECAClusters,fRecPoints,fDigitsArr); + fClusterUnfolding->MakeUnfolding(); + } - //Evaluate position, dispersion and other RecPoint properties for EC section - for (Int_t index = 0; index < fRecPoints->GetEntries(); index++) { - AliEMCALRecPoint * rp = dynamic_cast(fRecPoints->At(index)); - if (rp) { - rp->EvalAll(fECAW0,fDigitsArr,fJustClusters); - AliDebug(5, Form("MAX INDEX %d ", rp->GetMaximalEnergyIndex())); - //For each rec.point set the distance to the nearest bad crystal - if (fCaloPed) - rp->EvalDistanceToBadChannels(fCaloPed); - } - } + //Evaluate position, dispersion and other RecPoint properties for EC section + for (Int_t index = 0; index < fRecPoints->GetEntries(); index++) { + AliEMCALRecPoint * rp = dynamic_cast(fRecPoints->At(index)); + if (rp) { + rp->EvalAll(fECAW0,fDigitsArr,fJustClusters); + AliDebug(5, Form("MAX INDEX %d ", rp->GetMaximalEnergyIndex())); + //For each rec.point set the distance to the nearest bad crystal + if (fCaloPed) + rp->EvalDistanceToBadChannels(fCaloPed); + } + } + + fRecPoints->Sort(); - for (Int_t index = 0; index < fRecPoints->GetEntries(); index++) { - AliEMCALRecPoint *rp = dynamic_cast(fRecPoints->At(index)); - if (rp) { - rp->SetIndexInList(index); - } - else AliFatal("RecPoint NULL!!"); - } + for (Int_t index = 0; index < fRecPoints->GetEntries(); index++) { + AliEMCALRecPoint *rp = dynamic_cast(fRecPoints->At(index)); + if (rp) { + rp->SetIndexInList(index); + } + else AliFatal("RecPoint NULL!!"); + } - if (fTreeR) - fTreeR->Fill(); + if (fTreeR) + fTreeR->Fill(); - if (strstr(option,"deb") || strstr(option,"all")) - PrintRecPoints(option); + if (strstr(option,"deb") || strstr(option,"all")) + PrintRecPoints(option); - AliDebug(1,Form("EMCAL Clusterizer found %d Rec Points",fRecPoints->GetEntriesFast())); + AliDebug(1,Form("EMCAL Clusterizer found %d Rec Points",fRecPoints->GetEntriesFast())); - if (strstr(option,"tim")) { - gBenchmark->Stop("EMCALClusterizer"); - printf("Exec took %f seconds for Clusterizing", - gBenchmark->GetCpuTime("EMCALClusterizer")); - } + if (strstr(option,"tim")) { + gBenchmark->Stop("EMCALClusterizer"); + Printf("Exec took %f CPU time (%f real time) for clusterizing", + gBenchmark->GetCpuTime("EMCALClusterizer")-cputime,gBenchmark->GetRealTime("EMCALClusterizer")-realtime); + cputime = gBenchmark->GetCpuTime("EMCALClusterizer"); + realtime = gBenchmark->GetRealTime("EMCALClusterizer"); + } } //__________________________________________________________________________________________ -void AliEMCALClusterizerFixedWindow::MakeClusters() +void AliEMCALClusterizerFixedWindow::ExecOnce() { - // Make clusters - - if (fGeom == 0) - AliFatal("Did not get geometry from EMCALLoader"); - - fNumberOfECAClusters = 0; - fRecPoints->Delete(); + // Initialize clusterizer. - if (fClustersInfo->GetLastElementPosition() > 0) - fClustersInfo->Clear(); - - Int_t nSupMod=0, nModule=0, nIphi=0, nIeta=0, iphi=0, ieta=0; + fInitialized = -1; + + if (!fGeom) { + AliError("Did not get geometry!"); + return; + } - // Defining geometry and clusterization parameter - Int_t nEtaDigitsSupMod = fGeom->GetNEta() * fGeom->GetNETAdiv(); // always 48?; - Int_t nPhiDigitsSupMod = fGeom->GetNPhi() * fGeom->GetNPHIdiv(); // always 24?; + // Defining geometry and clusterization parameter + fNEtaDigitsSupMod = fGeom->GetNEta() * fGeom->GetNETAdiv(); // always 48?; + fNPhiDigitsSupMod = fGeom->GetNPhi() * fGeom->GetNPHIdiv(); // always 24?; - Int_t nTRUPhi = 1; - Int_t nTRUEta = 1; + fNTRUPhi = 1; + fNTRUEta = 1; - Int_t nEtaDigits = nEtaDigitsSupMod * fGeom->GetNumberOfSuperModules() / fGeom->GetNPhiSuperModule(); - Int_t nPhiDigits = nPhiDigitsSupMod * fGeom->GetNPhiSuperModule(); + fNEtaDigits = fNEtaDigitsSupMod * fGeom->GetNumberOfSuperModules() / fGeom->GetNPhiSuperModule(); + fNPhiDigits = fNPhiDigitsSupMod * fGeom->GetNPhiSuperModule(); if (fTRUshift){ - nTRUPhi = fGeom->GetNPhiSuperModule() * 3; - nTRUEta = fGeom->GetNumberOfSuperModules() / fGeom->GetNPhiSuperModule(); - nEtaDigits /= nTRUEta; - nPhiDigits /= nTRUPhi; + fNTRUPhi = fGeom->GetNPhiSuperModule() * 3; + fNTRUEta = fGeom->GetNumberOfSuperModules() / fGeom->GetNPhiSuperModule(); + fNEtaDigits /= fNTRUEta; + fNPhiDigits /= fNTRUPhi; } // Check if clusterizer parameter are compatible with calorimeter geometry - if (nEtaDigits < fNeta){ - AliFatal(Form("Error: fNeta = %d is greater than nEtaDigits = %d.",fNeta,nEtaDigits)); - return; - } - if (nPhiDigits < fNphi){ - AliFatal(Form("Error: fNphi = %d is greater than nPhiDigits = %d.",fNphi,nPhiDigits)); - return; - } - if (nEtaDigits % fShiftEta != 0){ - AliFatal(Form("Error: fShiftEta = %d is such that clusters cannot slide the whole calorimeter (nEtaDigits = %d).",fShiftEta,nEtaDigits)); - return; - } - if (nPhiDigits % fShiftPhi != 0){ - AliFatal(Form("Error: fShiftPhi = %d is such that clusters cannot slide the whole calorimeter (nPhiDigits = %d).",fShiftPhi,nPhiDigits)); - return; - } - if (fNeta % fShiftEta != 0){ - AliFatal(Form("Error: fShiftEta = %d is not divisor of fNeta = %d.",fShiftEta,fNeta)); - return; - } - if (fNphi % fShiftPhi != 0){ - AliFatal(Form("Error: fShiftPhi = %d is not divisor of fNphi = %d).",fShiftPhi,fNphi)); - return; - } - - Int_t maxiShiftPhi = fNphi / fShiftPhi; - Int_t maxiShiftEta = fNeta / fShiftEta; - - Int_t nDigitsCluster = fNphi * fNeta; - - Int_t nClusEtaNoShift = nEtaDigits / fNeta; - Int_t nClusPhiNoShift = nPhiDigits / fNphi; - - Int_t nClusters = nClusEtaNoShift * nClusPhiNoShift * nTRUEta * nTRUPhi; + if (fNEtaDigits < fNeta){ + AliError(Form("Error: fNeta = %d is greater than nEtaDigits = %d.",fNeta,fNEtaDigits)); + return; + } + if (fNPhiDigits < fNphi){ + AliError(Form("Error: fNphi = %d is greater than nPhiDigits = %d.",fNphi,fNPhiDigits)); + return; + } + if (fNEtaDigits % fShiftEta != 0){ + AliError(Form("Error: fShiftEta = %d is such that clusters cannot slide the whole calorimeter (nEtaDigits = %d).",fShiftEta,fNEtaDigits)); + return; + } + if (fNPhiDigits % fShiftPhi != 0){ + AliError(Form("Error: fShiftPhi = %d is such that clusters cannot slide the whole calorimeter (nPhiDigits = %d).",fShiftPhi,fNPhiDigits)); + return; + } + if (fNeta % fShiftEta != 0){ + AliError(Form("Error: fShiftEta = %d is not divisor of fNeta = %d.",fShiftEta,fNeta)); + return; + } + if (fNphi % fShiftPhi != 0){ + AliError(Form("Error: fShiftPhi = %d is not divisor of fNphi = %d).",fShiftPhi,fNphi)); + return; + } - Int_t nTotalClus = nClusters * maxiShiftEta * maxiShiftPhi; + fMaxShiftPhi = fNphi / fShiftPhi; + fMaxShiftEta = fNeta / fShiftEta; - if (!fClustersArray){ - fClustersArray = new AliEMCALDigit**[nTotalClus]; - for (Int_t i = 0; i < nTotalClus; i++) - { - fClustersArray[i] = NULL; + fNClusEtaNoShift = fNEtaDigits / fNeta; + fNClusPhiNoShift = fNPhiDigits / fNphi; + + fNClusters = fNClusEtaNoShift * fNClusPhiNoShift * fNTRUEta * fNTRUPhi; + + fNTotalClus = fNClusters * fMaxShiftEta * fMaxShiftPhi; + + fNDigitsCluster = fNphi * fNeta; + + if (fClustersArray) { + for (Int_t i = 0; i < fNTotalClus; i++) { + if (fClustersArray[i]) { + delete[] fClustersArray[i]; + fClustersArray[i] = 0; + } + } + delete[] fClustersArray; + fClustersArray = 0; + } + + fClustersArray = new AliEMCALDigit**[fNTotalClus]; + for (Int_t i = 0; i < fNTotalClus; i++) { + fClustersArray[i] = new AliEMCALDigit*[fNDigitsCluster]; + for (Int_t j = 0; j < fNDigitsCluster; j++) { + fClustersArray[i][j] = 0; } } + + AliDebug(1,Form("****ExecOnce*****\n" + "fNphi = %d, fNeta = %d, fShiftPhi = %d, fShiftEta = %d, fTRUshift = %d\n" + "fNEtaDigitsSupMod = %d, fNPhiDigitsSupMod = %d, fNTRUPhi = %d, fNTRUEta = %d, fNEtaDigits = %d, fNPhiDigits = %d\n" + "fMaxShiftPhi = %d, fMaxShiftEta = %d, fNDigitsCluster = %d, fNClusEtaNoShift = %d, fNClusPhiNoShift = %d\n" + "fNClusters = %d, fNTotalClus = %d\n", + fNphi,fNeta,fShiftPhi,fShiftEta,fTRUshift, + fNEtaDigitsSupMod,fNPhiDigitsSupMod,fNTRUPhi,fNTRUEta,fNEtaDigits,fNPhiDigits, + fMaxShiftPhi,fMaxShiftEta,fNDigitsCluster,fNClusEtaNoShift,fNClusPhiNoShift, + fNClusters,fNTotalClus)); + + fInitialized = 1; +} + +//__________________________________________________________________________________________ +void AliEMCALClusterizerFixedWindow::MakeClusters() +{ + // Make clusters. + + fNumberOfECAClusters = 0; + fRecPoints->Delete(); + + if (fInitialized == 0) + ExecOnce(); + + if (fInitialized == -1) { + AliError(Form("%s: error initializing the clusterizer. No clusterization will be performed.",GetName())); + return; + } - AliEMCALDigit *digit = 0; + // Set up TObjArray with pointers to digits to work on calibrated digits + TObjArray *digitsC = new TObjArray(); + AliEMCALDigit *digit; + Float_t dEnergyCalibrated = 0.0, ehs = 0.0, time = 0.0; + TIter nextdigit(fDigitsArr); + while ((digit = dynamic_cast(nextdigit()))) { // calibrate and clean up digits + dEnergyCalibrated = digit->GetAmplitude(); + time = digit->GetTime(); + Calibrate(dEnergyCalibrated, time, digit->GetId()); + digit->SetCalibAmp(dEnergyCalibrated); + digit->SetTime(time); + if (dEnergyCalibrated < fMinECut || time > fTimeMax || time < fTimeMin) { + continue; + } + else if (!fGeom->CheckAbsCellId(digit->GetId())) { + continue; + } + else { + ehs += dEnergyCalibrated; + digitsC->AddLast(digit); + } + } - for (Int_t ishiftPhi = 0; ishiftPhi < maxiShiftPhi; ishiftPhi++){ - Int_t nClusPhi = (nPhiDigits - fShiftPhi * ishiftPhi) / fNphi; + AliDebug(1,Form("MakeClusters: Number of digits %d -> (e %f), ehs %f\n", + fDigitsArr->GetEntries(),fMinECut,ehs)); + + Int_t nSupMod=0, nModule=0, nIphi=0, nIeta=0; + Int_t iphi=0, ieta=0; // cell eta-phi indexes in SM + + for (Int_t ishiftPhi = 0; ishiftPhi < fMaxShiftPhi; ishiftPhi++){ + Int_t nClusPhi = (fNPhiDigits - fShiftPhi * ishiftPhi) / fNphi; - for (Int_t ishiftEta = 0; ishiftEta < maxiShiftEta; ishiftEta++){ - - Int_t nClusEta = (nEtaDigits - fShiftEta * ishiftEta) / fNeta; + for (Int_t ishiftEta = 0; ishiftEta < fMaxShiftEta; ishiftEta++) { - Int_t iTotalClus = nClusters * (ishiftPhi * maxiShiftEta + ishiftEta); + Int_t nClusEta = (fNEtaDigits - fShiftEta * ishiftEta) / fNeta; - TIter nextdigit(fDigitsArr); + Int_t iTotalClus = fNClusters * (ishiftPhi * fMaxShiftEta + ishiftEta); - nextdigit.Reset(); - - while ((digit = static_cast(nextdigit()))){ + TIter nextdigitC(digitsC); + while ((digit = dynamic_cast(nextdigitC()))) { // scan over the list of digitsC + fGeom->GetCellIndex (digit->GetId(), nSupMod, nModule, nIphi, nIeta); fGeom->GetCellPhiEtaIndexInSModule (nSupMod, nModule, nIphi, nIeta, iphi, ieta); - Int_t iphi_eff = iphi - fShiftPhi * ishiftPhi + nPhiDigitsSupMod * (nSupMod / 2); // N supermodules along phi + Int_t iphi_eff = iphi - fShiftPhi * ishiftPhi + fNPhiDigitsSupMod * (nSupMod / 2); // N supermodules along phi - Int_t iTRUphi = iphi_eff / nPhiDigits; + Int_t iTRUphi = iphi_eff / fNPhiDigits; - iphi_eff -= iTRUphi * nPhiDigits; + iphi_eff -= iTRUphi * fNPhiDigits; Int_t iClusPhi = iphi_eff / fNphi; if (iphi_eff < 0 || iClusPhi >= nClusPhi) continue; - Int_t ieta_eff = ieta - fShiftEta * ishiftEta + nEtaDigitsSupMod * (nSupMod % 2); // 2 supermodules along eta + Int_t ieta_eff = ieta - fShiftEta * ishiftEta + fNEtaDigitsSupMod * (nSupMod % 2); // 2 supermodules along eta - Int_t iTRUeta = ieta_eff / nEtaDigits; + Int_t iTRUeta = ieta_eff / fNEtaDigits; - ieta_eff -= iTRUeta * nEtaDigits; + ieta_eff -= iTRUeta * fNEtaDigits; Int_t iClusEta = ieta_eff / fNeta; if (ieta_eff < 0 || iClusEta >= nClusEta) continue; - iphi_eff += iTRUphi * nPhiDigits; + iphi_eff += iTRUphi * fNPhiDigits; iClusPhi = iphi_eff / fNphi; - ieta_eff += iTRUeta * nEtaDigits; + ieta_eff += iTRUeta * fNEtaDigits; iClusEta = ieta_eff / fNeta; - Int_t iCluster = iClusPhi + iClusEta * nClusPhiNoShift * nTRUPhi; + Int_t iCluster = iClusPhi + iClusEta * fNClusPhiNoShift * fNTRUPhi; Int_t iDigit = iphi_eff % fNphi + (ieta_eff % fNeta) * fNphi; - if (iCluster >= nClusters){ - AliWarning(Form("iCluster out of range! iCluster = %d, nClusters = %d", iCluster, nClusters)); + if (iCluster >= fNClusters){ + AliError(Form("iCluster out of range! iCluster = %d, fNClusters = %d (should never happen...)", iCluster, fNClusters)); return; } iCluster += iTotalClus; - - if (fClustersArray[iCluster] == NULL){ - fNumberOfECAClusters++; - fClustersArray[iCluster] = new AliEMCALDigit*[nDigitsCluster]; - for (Int_t i = 0; i < nDigitsCluster; i++){ - fClustersArray[iCluster][i] = NULL; - } - - fClustersInfo->Add(iCluster, -1, iClusEta, iClusPhi); + + if (iCluster >= fNTotalClus){ + AliError(Form("iCluster out of range! iCluster = %d, fNTotalClus = %d (should never happen...)", iCluster, fNTotalClus)); + return; } - - if (fClustersArray[iCluster][iDigit] != NULL){ - AliWarning("Digit already added!"); + + if (iDigit >= fNDigitsCluster){ + AliError(Form("iDigit out of range! iDigit = %d, fNDigitsCluster = %d (should never happen...)", iDigit, fNDigitsCluster)); + return; + } + + if (fClustersArray[iCluster][iDigit] != 0){ + AliError("Digit already added! (should never happen...)"); return; } @@ -363,42 +478,49 @@ void AliEMCALClusterizerFixedWindow::MakeClusters() } // loop on eta shift - } // loop on phi shift - - Int_t iRecPoint = 0; - for (Int_t iCluster = 0; iCluster < nTotalClus; iCluster++){ - - if (fClustersArray[iCluster] == NULL) continue; - - (*fRecPoints)[iRecPoint] = new AliEMCALRecPoint(""); - AliEMCALRecPoint *recPoint = dynamic_cast (fRecPoints->At(iRecPoint)); - - if (recPoint) { - if (fClustersInfo->ContainsIndex(iRecPoint)) - AliFatal(Form("ERROR: index present already, %d", iRecPoint)); - - fClustersInfo->SetIndexFromId(iCluster, iRecPoint); - - iRecPoint++; - recPoint->SetClusterType(AliVCluster::kEMCALClusterv1); - - for (Int_t iDigit = 0; iDigit < nDigitsCluster; iDigit++){ - if (fClustersArray[iCluster][iDigit] == NULL) continue; - digit = fClustersArray[iCluster][iDigit]; - Float_t dEnergyCalibrated = digit->GetAmplitude(); - Float_t time = digit->GetTime(); - Calibrate(dEnergyCalibrated,time,digit->GetId()); - digit->SetCalibAmp(dEnergyCalibrated); - recPoint->AddDigit(*digit, dEnergyCalibrated, kFALSE); //Time or TimeR? - fClustersArray[iCluster][iDigit] = NULL; - } - } - - delete[] fClustersArray[iCluster]; - fClustersArray[iCluster] = NULL; - } + } // loop on phi shift - AliDebug(1, Form("MakeClusters: Number of digits %d -> (e %f)\n", fDigitsArr->GetEntries(),fMinECut)); - - AliDebug(1, Form("total no of clusters %d from %d digits", fNumberOfECAClusters, fDigitsArr->GetEntriesFast())); + AliEMCALRecPoint *recPoint = 0; + Bool_t recPointOk = kFALSE; + for (Int_t iCluster = 0; iCluster < fNTotalClus; iCluster++) { + + if (!recPoint) { + if(fNumberOfECAClusters >= fRecPoints->GetSize()) fRecPoints->Expand(fNumberOfECAClusters*2+1); + + (*fRecPoints)[fNumberOfECAClusters] = new AliEMCALRecPoint(""); + recPoint = static_cast(fRecPoints->At(fNumberOfECAClusters)); + } + + if (recPoint) { + recPoint->SetClusterType(AliVCluster::kEMCALClusterv1); + recPoint->SetUniqueID(iCluster); + fNumberOfECAClusters++; + + for (Int_t iDigit = 0; iDigit < fNDigitsCluster; iDigit++) { + if (fClustersArray[iCluster][iDigit] == 0) continue; + digit = fClustersArray[iCluster][iDigit]; + recPoint->AddDigit(*digit, digit->GetCalibAmp(), kFALSE); //Time or TimeR? + fClustersArray[iCluster][iDigit] = 0; + recPointOk = kTRUE; + } + + if (recPointOk) { // unset the pointer so that a new rec point will be allocated in the next iteration + recPoint = 0; + recPointOk = kFALSE; + } + } + else { + AliError("Error allocating rec points!"); + break; + } + } + + if (!recPointOk) { + fRecPoints->RemoveLast(); + fNumberOfECAClusters--; + } + + delete digitsC; + AliDebug(1, Form("MakeClusters: Number of digits %d -> (e %f)\n", fDigitsArr->GetEntries(),fMinECut)); + AliDebug(1, Form("total no of clusters %d from %d digits", fNumberOfECAClusters, fDigitsArr->GetEntriesFast())); }