#include "AliLog.h"
#include "AliESDEvent.h"
#include "AliESDtrack.h"
-#include "AliKalmanTrack.h"
+#include "AliESDCaloCluster.h"
#include "AliEMCALRecPoint.h"
#include "AliRunLoader.h"
#include "AliEMCALTrack.h"
#include "AliEMCALLoader.h"
#include "AliEMCALGeometry.h"
+#include "AliEMCALReconstructor.h"
+#include "AliEMCALRecParam.h"
+#include "AliCDBEntry.h"
+#include "AliCDBManager.h"
#include "AliEMCALTracker.h"
ClassImp(AliEMCALTracker)
+
+AliEMCALRecParam* AliEMCALTracker::fgkRecParam = 0; // EMCAL rec. parameters
+
//
//------------------------------------------------------------------------------
//
fCutAlphaMin(-200.0),
fCutAlphaMax(200.0),
fCutAngle(100.0),
- fMaxDist(100.0),
+ fMaxDist(10.0),
fRho(1.0),
fX0(1.0),
fTracks(0),
// and all collections to NULL.
// Output file name is set to a default value.
//
+
+ InitParameters();
}
//
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
//
+void AliEMCALTracker::InitParameters()
+{
+ //
+ // Retrieve initialization parameters
+ //
+
+ // Check if the instance of AliEMCALRecParam exists,
+ // if not, get it from OCDB if available, otherwise create a default one
+
+ if (!fgkRecParam && (AliCDBManager::Instance()->IsDefaultStorageSet())) {
+ AliCDBEntry *entry = (AliCDBEntry*)
+ AliCDBManager::Instance()->Get("EMCAL/Config/RecParam");
+ if (entry) fgkRecParam = (AliEMCALRecParam*) entry->GetObject();
+ }
+
+ if(!fgkRecParam){
+ AliWarning("The Track Matching parameters for EMCAL nonitialized - Used default one");
+ fgkRecParam = new AliEMCALRecParam;
+ }
+
+ fCutX = fgkRecParam->GetTrkCutX();
+ fCutY = fgkRecParam->GetTrkCutY();
+ fCutZ = fgkRecParam->GetTrkCutZ();
+ fMaxDist = fgkRecParam->GetTrkCutR();
+ fCutAngle = fgkRecParam->GetTrkCutAngle();
+ fCutAlphaMin = fgkRecParam->GetTrkCutAlphaMin();
+ fCutAlphaMax = fgkRecParam->GetTrkCutAlphaMax();
+
+}
+//
+//------------------------------------------------------------------------------
+//
TTree* AliEMCALTracker::SearchTrueMatches()
{
+ //Search through the list of
+ //track match candidates and clusters
+ //and look for true matches
+ //
+ //
if (!fClusters) return 0;
if (fClusters->IsEmpty()) return 0;
if (!fTracks) return 0;
{
//
// Clearing method
- // Clears all specified arrays and the containers themselves.
+ // Deletes all objects in arrays and the arrays themselves
//
TString opt(option);
- Bool_t doDelete = opt.Contains("DELETE");
Bool_t clearTracks = opt.Contains("TRACKS");
Bool_t clearClusters = opt.Contains("CLUSTERS");
Bool_t clearMatches = opt.Contains("MATCHES");
}
if (fTracks != 0x0 && clearTracks) {
- if (!doDelete) {
- fTracks->Clear();
- }
- else {
- if (!fTracks->IsEmpty()) fTracks->Delete();
- delete fTracks;
- fTracks = 0;
- }
+ fTracks->Delete();
+ delete fTracks;
+ fTracks = 0;
}
if (fClusters != 0x0 && clearClusters) {
- if (!doDelete) {
- fClusters->Clear();
- }
- else {
- if (!fClusters->IsEmpty()) fClusters->Delete();
- delete fClusters;
- fClusters = 0;
- }
+ fClusters->Delete();
+ delete fClusters;
+ fClusters = 0;
}
if (fMatches != 0x0 && clearMatches) {
- if (!doDelete) {
- fMatches->Clear();
- }
- else {
- if (!fMatches->IsEmpty()) fMatches->Delete();
- delete fMatches;
- fMatches = 0;
- }
+ fMatches->Delete();
+ delete fMatches;
+ fMatches = 0;
}
}
//
for (Int_t i = 0; i < nClusters; i++) {
AliEMCALRecPoint *cluster = (AliEMCALRecPoint*)clusters->At(i);
if (!cluster) continue;
- if (cluster->GetClusterType() != AliESDCaloCluster::kClusterv1) continue;
+ if (cluster->GetClusterType() != AliESDCaloCluster::kEMCALClusterv1) continue;
AliEMCALMatchCluster *matchCluster = new AliEMCALMatchCluster(i, cluster);
fClusters->AddLast(matchCluster);
}
- if (fClusters->IsEmpty()) {
- AliError("No clusters collected");
- return 1;
- }
-
+
branch->SetAddress(0);
clusters->Delete();
delete clusters;
+ if (fClusters->IsEmpty())
+ AliWarning("No clusters collected");
- AliInfo(Form("Collected %d clusters", fClusters->GetEntries()));
+ AliInfo(Form("Collected %d clusters (RecPoints)", fClusters->GetEntries()));
return 0;
}
for (i = start; i < end; i++) {
AliESDCaloCluster *cluster = esd->GetCaloCluster(i);
if (!cluster) continue;
- if (cluster->GetClusterType() != AliESDCaloCluster::kClusterv1) continue;
+ if (cluster->GetClusterType() != AliESDCaloCluster::kEMCALClusterv1) continue;
AliEMCALMatchCluster *matchCluster = new AliEMCALMatchCluster(i, cluster);
fClusters->AddLast(matchCluster);
}
- if (fClusters->IsEmpty()) {
- AliError("No clusters collected");
- return 1;
- }
+ if (fClusters->IsEmpty())
+ AliWarning("No clusters collected");
- AliInfo(Form("Collected %d clusters", fClusters->GetEntries()));
+ AliInfo(Form("Collected %d clusters from ESD", fClusters->GetEntries()));
return 0;
}
fTracks->AddLast(track);
}
if (fTracks->IsEmpty()) {
- AliError("No tracks collected");
- return 1;
+ AliWarning("No tracks collected");
}
AliInfo(Form("Collected %d tracks", fTracks->GetEntries()));
// After executing match finding, stores in the same ESD object all infos
// and releases the object for further reconstruction steps.
//
-
+ //
+ // Note: should always return 0=OK, because otherwise all tracking
+ // is aborted for this event
+
if (!esd) {
AliError("NULL ESD passed");
return 1;
Int_t okLoadClusters, nClusters;
if (!fClusters || (fClusters && fClusters->IsEmpty())) {
okLoadClusters = LoadClusters(esd);
- if (okLoadClusters) return 2;
}
nClusters = fClusters->GetEntries();
Int_t nMatches = CreateMatches();
if (!nMatches) {
AliInfo(Form("#clusters = %d -- #tracks = %d --> No good matches found.", nClusters, nTracks));
- return 4;
+ return 0;
}
else {
AliInfo(Form("#clusters = %d -- #tracks = %d --> Found %d matches.", nClusters, nTracks, nMatches));
// check against cut on difference 'alpha - phi'
Double_t phi = TMath::ATan2(cl->Y(), cl->X());
phi = AngleDiff(phi, tr->GetAlpha());
- if (phi < fCutAlphaMin || phi > fCutAlphaMax) return distance;
+ if (phi < fCutAlphaMin || phi > fCutAlphaMax){
+ delete tr;
+ return distance;
+ }
// try to propagate to cluster radius
// (return the 'distance' value if it fails)
pos2[0] = cl->X();
pos2[1] = cl->Y();
pos2[2] = cl->Z();
- AliKalmanTrack::MeanMaterialBudget(pos1, pos2, param);
- rho = param[0];
+ MeanMaterialBudget(pos1, pos2, param);
+ rho = param[0]*param[4];
x0 = param[1];
}
else if (fTrackCorrMode == kTrackCorrFixed) {
if (isTrue) cout << "Init : " << rt << ' ' << x << ' ' << y << ' ' << z << endl;
for (i = 0; i < fNPropSteps; i++) {
r = rt + (rc - rt) * ((Double_t)(i+1)/(Double_t)fNPropSteps);
- if (!tr->PropagateTo(r, x0, rho)) return distance;
+ if (!tr->PropagateTo(r, x0, rho)){
+ delete tr;
+ return distance;
+ }
tr->GetXYZ(pos);
if (isTrue) cout << "Step : " << r << ' ' << x << ' ' << y << ' ' << z << endl;
}
else {
// when no steps are used, no correction makes sense
//if (!tr->PropagateTo(rc, 0.0, 0.0)) return distance;
- if (!tr->PropagateToGlobal(cl->X(), cl->Y(), cl->Z(), 0.0, 0.0)) return distance;
+ if (!tr->PropagateToGlobal(cl->X(), cl->Y(), cl->Z(), 0.0, 0.0)){
+ delete tr;
+ return distance;
+ }
/*
Bool_t propOK = kFALSE;
cout << "START" << endl;
if (angle > fCutAngle) {
//cout << "angle" << endl;
+ delete tr;
return distance;
}
x -= cl->X();
if (TMath::Abs(x) > fCutX) {
//cout << "cut X" << endl;
+ delete tr;
return distance;
}
y -= cl->Y();
if (TMath::Abs(y) > fCutY) {
//cout << "cut Y" << endl;
+ delete tr;
return distance;
}
z -= cl->Z();
if (TMath::Abs(z) > fCutZ) {
//cout << "cut Z" << endl;
+ delete tr;
return distance;
}
pos2[0] = cl->X();
pos2[1] = cl->Y();
pos2[2] = cl->Z();
- AliKalmanTrack::MeanMaterialBudget(pos1, pos2, param);
- rho = param[0];
+ MeanMaterialBudget(pos1, pos2, param);
+ rho = param[0]*param[4];
x0 = param[1];
}
else if (fTrackCorrMode == kTrackCorrFixed) {
TVector3 vdiff = vt-vc;
// compute differences wr to each coordinate
+ delete track;
if (vdiff.X() > fCutX) return distance;
if (vdiff.Y() > fCutY) return distance;
if (vdiff.Z() > fCutZ) return distance;
Double_t distance = 2.0 * fMaxDist;
Double_t dx, dy, dz;
Double_t phi, alpha, slope, tgtXnum, tgtXden, sectorWidth = 20.0 * TMath::DegToRad();
- Double_t xcurr, xprop, param[6] = {0., 0., 0., 0., 0., 0.}, d, x0, rho, bz;
+ Double_t xcurr, xprop, param[6] = {0., 0., 0., 0., 0., 0.}, x0, rho, bz;
Double_t x[3], x1[3], x2[3];
// get initial track position
bz = tr.GetBz();
if (!tr.GetXYZAt(xprop, bz, x2)) return distance;
//AliKalmanTrack::MeanMaterialBudget(x1, x2, param);
- d = param[4];
- rho = param[0];
+ rho = param[0]*param[4];
x0 = param[1];
- if (!tr.PropagateTo(xprop, d*rho/x0, x0)) return distance;
+ if (!tr.PropagateTo(xprop, x0, rho)) return distance;
//if (!tr.PropagateTo(xprop, 0.0, 0.0)) return distance;
// get propagated position at the end
// Propagates the track to the proximity of the EMCAL surface
//
- Double_t xcurr, xtemp, xprop = 438.0, step = 10.0, param[6], d, x0, rho, bz;
+ Double_t xcurr, xtemp, xprop = 438.0, step = 10.0, param[6], x0, rho, bz;
Double_t x1[3], x2[3];
// get initial track position
tr->GetXYZ(x1);
bz = tr->GetBz();
if (!tr->GetXYZAt(xtemp, bz, x2)) return kFALSE;
- AliKalmanTrack::MeanMaterialBudget(x1, x2, param);
- d = param[4];
- rho = param[0];
+ MeanMaterialBudget(x1, x2, param);
+ rho = param[0]*param[4];
x0 = param[1];
- if (!tr->PropagateTo(xtemp, d*rho/x0, x0)) return kFALSE;
+ if (!tr->PropagateTo(xtemp, x0, rho)) return kFALSE;
}
return kTRUE;
candidate->SetIndexT(it);
candidate->SetIndexC(ic);
candidate->SetDistance(dist);
- candidate->SetPt(track->GetPt());
+ candidate->SetPt(track->GetSignedPt());
fMatches->Add(candidate);
count++;
}
}
*/
+ delete [] usedC;
+ delete [] usedT;
+
return count;
}
//
void AliEMCALTracker::UnloadClusters()
{
//
- // Free memory from clusters
+ // Free memory from all arrays
+ // This method is called after the local tracking step
+ // so we can safely delete everything
//
- Clear("CLUSTERS");
+ Clear();
}
//
//------------------------------------------------------------------------------