#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)
+
//
//------------------------------------------------------------------------------
//
fCutAlphaMin(-200.0),
fCutAlphaMax(200.0),
fCutAngle(100.0),
- fMaxDist(100.0),
+ fMaxDist(10.0),
+ fCutNITS(3.0),
+ fCutNTPC(20.0),
fRho(1.0),
fX0(1.0),
fTracks(0),
// and all collections to NULL.
// Output file name is set to a default value.
//
+ InitParameters();
}
//
//------------------------------------------------------------------------------
fCutAlphaMax(copy.fCutAlphaMax),
fCutAngle(copy.fCutAngle),
fMaxDist(copy.fMaxDist),
+ fCutNITS(copy.fCutNITS),
+ fCutNTPC(copy.fCutNTPC),
fRho(copy.fRho),
fX0(copy.fX0),
fTracks((TObjArray*)copy.fTracks->Clone()),
fCutAlphaMax = copy.fCutAlphaMax;
fCutAngle = copy.fCutAngle;
fMaxDist = copy.fMaxDist;
+ fCutNITS = copy.fCutNITS;
+ fCutNTPC = copy.fCutNTPC;
fTracks = (TObjArray*)copy.fTracks->Clone();
fClusters = (TObjArray*)copy.fClusters->Clone();
//
//------------------------------------------------------------------------------
//
+void AliEMCALTracker::InitParameters()
+{
+ //
+ // Retrieve initialization parameters
+ //
+
+ // Check if the instance of AliEMCALRecParam exists,
+ const AliEMCALRecParam* recParam = new AliEMCALRecParam();
+
+ if(!recParam){
+ AliFatal("Reconstruction parameters for EMCAL not set!");
+ }
+
+ fCutX = recParam->GetTrkCutX();
+ fCutY = recParam->GetTrkCutY();
+ fCutZ = recParam->GetTrkCutZ();
+ fMaxDist = recParam->GetTrkCutR();
+ fCutAngle = recParam->GetTrkCutAngle();
+ fCutAlphaMin = recParam->GetTrkCutAlphaMin();
+ fCutAlphaMax = recParam->GetTrkCutAlphaMax();
+ fCutNITS = recParam->GetTrkCutNITS();
+ fCutNTPC = recParam->GetTrkCutNTPC();
+
+}
+//
+//------------------------------------------------------------------------------
+//
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;
clusters->Delete();
delete clusters;
if (fClusters->IsEmpty())
- AliWarning("No clusters collected");
+ AliDebug(1,"No clusters collected");
- AliInfo(Form("Collected %d clusters (RecPoints)", fClusters->GetEntries()));
+ AliDebug(1,Form("Collected %d clusters (RecPoints)", fClusters->GetEntries()));
return 0;
}
// make sure that tracks/clusters collections are empty
Clear("CLUSTERS");
- Int_t start = esd->GetFirstEMCALCluster();
- Int_t nClustersEMC = esd->GetNumberOfEMCALClusters();
+ Int_t start = 0;
+ Int_t nClustersEMC = esd->GetNumberOfCaloClusters();
Int_t end = start + nClustersEMC;
fClusters = new TObjArray(0);
for (i = start; i < end; i++) {
AliESDCaloCluster *cluster = esd->GetCaloCluster(i);
if (!cluster) continue;
- if (cluster->GetClusterType() != AliESDCaloCluster::kEMCALClusterv1) continue;
+ if (!cluster->IsEMCAL()) continue ;
AliEMCALMatchCluster *matchCluster = new AliEMCALMatchCluster(i, cluster);
fClusters->AddLast(matchCluster);
}
if (fClusters->IsEmpty())
- AliWarning("No clusters collected");
+ AliDebug(1,"No clusters collected");
- AliInfo(Form("Collected %d clusters from ESD", fClusters->GetEntries()));
+ AliDebug(1,Form("Collected %d clusters from ESD", fClusters->GetEntries()));
return 0;
}
fTracks->AddLast(track);
}
if (fTracks->IsEmpty()) {
- AliWarning("No tracks collected");
+ AliDebug(1,"No tracks collected");
}
- AliInfo(Form("Collected %d tracks", fTracks->GetEntries()));
+ AliDebug(1,Form("Collected %d tracks", fTracks->GetEntries()));
return 0;
}
// IF no clusters lie within the maximum allowed distance, no matches are assigned.
Int_t nMatches = CreateMatches();
if (!nMatches) {
- AliInfo(Form("#clusters = %d -- #tracks = %d --> No good matches found.", nClusters, nTracks));
+ AliDebug(1,Form("#clusters = %d -- #tracks = %d --> No good matches found.", nClusters, nTracks));
return 0;
}
else {
- AliInfo(Form("#clusters = %d -- #tracks = %d --> Found %d matches.", nClusters, nTracks, nMatches));
+ AliDebug(1,Form("#clusters = %d -- #tracks = %d --> Found %d matches.", nClusters, nTracks, nMatches));
}
// step 4:
// when more than 1 track share the same matched cluster, only the closest one is kept.
Int_t nRemoved = SolveCompetitions();
- AliInfo(Form("Removed %d duplicate matches", nRemoved));
+ AliDebug(1,Form("Removed %d duplicate matches", nRemoved));
if (nRemoved >= nMatches) {
AliError("Removed ALL matches! Check the algorithm or data. Nothing to save");
return 5;
// step 5:
// save obtained information setting the 'fEMCALindex' field of AliESDtrack object
- Int_t nSaved = 0, trackID, nGood = 0, nFake = 0;
+ Int_t nSaved = 0, trackID;
TListIter iter(fMatches);
AliEMCALMatch *match = 0;
while ( (match = (AliEMCALMatch*)iter.Next()) ) {
trackID = track->GetSeedIndex();
AliESDtrack *esdTrack = esd->GetTrack(trackID);
if (!esdTrack) continue;
- if (TMath::Abs(esdTrack->GetLabel()) == cluster->Label()) {
- esdTrack->SetEMCALcluster(cluster->Index());
- nGood++;
- }
- else {
- esdTrack->SetEMCALcluster(-cluster->Index());
- nFake++;
- }
+
+ // cut on its and tpc track hits
+ if(esdTrack->GetNcls(0)<=fCutNITS)continue;
+ if(esdTrack->GetNcls(1)<=fCutNTPC)continue;
+
+ esdTrack->SetEMCALcluster(cluster->Index());
nSaved++;
}
/*
else {
AliEMCALMatchCluster *cluster = (AliEMCALMatchCluster*)fClusters->At(clusterID);
if (!cluster) continue;
- if (esdTrack->GetLabel() == cluster->Label()) {
- nGood++;
- esdTrack->SetEMCALcluster(cluster->Index());
- }
- else {
- esdTrack->SetEMCALcluster(-cluster->Index());
- }
+
+ esdTrack->SetEMCALcluster(cluster->Index());
nSaved++;
}
}
*/
- AliInfo(Form("Saved %d matches [%d good + %d fake]", nSaved, nGood, nFake));
+ AliDebug(1,Form("Saved %d matches", nSaved));
return 0;
}
// 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)
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;
}
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;
}
}
}
-
- /*
- // loop on clusters and tracks
- Int_t icBest;
- Double_t dist, distBest;
- for (it = 0; it < nTracks; it++) {
- AliEMCALTrack *track = (AliEMCALTrack*)fTracks->At(it);
- if (!track) continue;
- icBest = -1;
- distBest = fMaxDist;
- for (ic = 0; ic < nClusters; ic++) {
- AliEMCALMatchCluster *cluster = (AliEMCALMatchCluster*)fClusters->At(ic);
- if (!cluster) continue;
- dist = CheckPair(track, cluster);
- if (dist < distBest) {
- distBest = dist;
- icBest = ic;
- }
- }
- if (icBest >= 0) {
- track->SetMatchedClusterIndex(icBest);
- track->SetMatchedClusterDist(distBest);
- count++;
- }
- else {
- track->SetMatchedClusterIndex(-1);
- }
- }
- */
return count;
}
}
}
- /*
- Int_t it1, it2, nTracks = (Int_t)fTracks->GetEntries();
- AliEMCALTrack *track1 = 0, *track2 = 0;
- for (it1 = 0; it1 < nTracks; it1++) {
- track1 = (AliEMCALTrack*)fTracks->At(it1);
- if (!track1) continue;
- if (track1->GetMatchedClusterIndex() < 0) continue;
- for (it2 = it1+1; it2 < nTracks; it2++) {
- track2 = (AliEMCALTrack*)fTracks->At(it2);
- if (!track2) continue;
- if (track2->GetMatchedClusterIndex() < 0) continue;
- if (track1->GetMatchedClusterIndex() != track2->GetMatchedClusterIndex()) continue;
- count++;
- if (track1->GetMatchedClusterDist() < track2->GetMatchedClusterDist()) {
- track2->SetMatchedClusterIndex(-1);
- }
- else if (track2->GetMatchedClusterDist() < track1->GetMatchedClusterDist()) {
- track1->SetMatchedClusterIndex(-1);
- }
- }
- }
- */
-
delete [] usedC;
delete [] usedT;
Clear();
}
+//
+//------------------------------------------------------------------------------
+//
+TVector3 AliEMCALTracker::FindExtrapolationPoint(Double_t x,Double_t y,Double_t z, AliESDtrack *track)
+{
+ //Method to determine extrapolation point of track at location x,y,z
+ AliEMCALTrack *tr = new AliEMCALTrack(*track);
+ TVector3 error(-100.,-100.,-100.);
+ if (!tr->PropagateToGlobal(x,y,z, 0.0, 0.0)) {
+ return error;
+ }
+ Double_t pos[3];
+ tr->GetXYZ(pos);
+ TVector3 ExTrPos(pos[0],pos[1],pos[2]);
+ return ExTrPos;
+}
+
//
//------------------------------------------------------------------------------
//
AliEMCALTracker::AliEMCALMatchCluster::AliEMCALMatchCluster(Int_t index, AliEMCALRecPoint *recPoint)
: fIndex(index),
- fLabel(recPoint->GetPrimaryIndex()),
+ fLabel(recPoint->GetPrimaryIndex()), //wrong! fixed below
fX(0.),
fY(0.),
fZ(0.)
fX = clpos.X();
fY = clpos.Y();
fZ = clpos.Z();
+
+ //AliEMCALRecPoint stores the track labels in the parents
+ //list, sorted according to the fractional contribution to the
+ //RecPoint. The zeroth parent gave the highest contribution
+ Int_t multparent = 0;
+ Int_t *parents = recPoint->GetParents(multparent);
+ if(multparent > 0)
+ fLabel = parents[0];
+ else
+ fLabel = -1;
+
}
//
//------------------------------------------------------------------------------