//
// --- ROOT system ---
+#include "TVector3.h"
#include "TTree.h"
#include "TBenchmark.h"
#include "AliESDtrack.h"
#include "AliPHOSEmcRecPoint.h"
#include "AliPHOSCpvRecPoint.h"
+#include "AliLog.h"
+#include "AliMagF.h"
+#include "AliMagF.h"
+#include "AliTracker.h"
+#include "AliGeomManager.h"
+#include "AliCluster.h"
+#include "AliKalmanTrack.h"
+#include "AliGlobalQADataMaker.h"
+#include "AliVParticle.h"
+
ClassImp( AliPHOSTrackSegmentMakerv1)
fNTrackSegments(0),
fRcpv(0.f),
fRtpc(0.f),
- fVtx(0.f),
+ fVtx(0.f,0.f,0.f),
fLinkUpArray(0),
fEmcFirst(0),
fEmcLast(0),
fNTrackSegments(0),
fRcpv(0.f),
fRtpc(0.f),
- fVtx(0.f),
+ fVtx(0.f,0.f,0.f),
fLinkUpArray(0),
fEmcFirst(0),
fEmcLast(0),
fNTrackSegments(0),
fRcpv(0.f),
fRtpc(0.f),
- fVtx(0.f),
+ fVtx(0.f,0.f,0.f),
fLinkUpArray(0),
fEmcFirst(0),
fEmcLast(0),
//First EMC clusters
Int_t totalEmc = fEMCRecPoints->GetEntriesFast() ;
for(fEmcFirst = fEmcLast; (fEmcLast < totalEmc) &&
- ((dynamic_cast<AliPHOSRecPoint *>(fEMCRecPoints->At(fEmcLast)))->GetPHOSMod() == fModule );
+ ((static_cast<AliPHOSRecPoint *>(fEMCRecPoints->At(fEmcLast)))->GetPHOSMod() == fModule );
fEmcLast ++) ;
//Now CPV clusters
Int_t totalCpv = fCPVRecPoints->GetEntriesFast() ;
for(fCpvFirst = fCpvLast; (fCpvLast < totalCpv) &&
- ((dynamic_cast<AliPHOSRecPoint *>(fCPVRecPoints->At(fCpvLast)))->GetPHOSMod() == fModule );
+ ((static_cast<AliPHOSRecPoint *>(fCPVRecPoints->At(fCpvLast)))->GetPHOSMod() == fModule );
fCpvLast ++) ;
}
Float_t &dx, Float_t &dz) const
{
// Calculates the distance between the EMC RecPoint and the CPV RecPoint
+ // If no CPV, calculates the distance between the EMC RecPoint and the track
+ // prolongation to the PHOS module plane.
// Clusters are sorted in "rows" and "columns" of width 1 cm
// Float_t delta = 1 ; // Width of the rows in sorting of RecPoints (in cm)
// // if you change this value, change it as well in xxxRecPoint::Compare()
- Float_t distance2Track = fRtpc ;
- trackindex = -1 ; // closest track within fRCpv
+ trackindex = -1;
+ dx = 999.;
+ dz = 999.;
+
+ if(!cpvClu) {
+
+ if(!emcClu) {
+ return;
+ }
+
+ // *** Start the matching
+ Int_t nt=fESD->GetNumberOfTracks();
+ Int_t iPHOSMod = emcClu->GetPHOSMod() ;
+ //Calculate actual distance to PHOS module
+ TVector3 globaPos ;
+ fGeom->Local2Global(iPHOSMod, 0.,0., globaPos) ;
+ const Double_t rPHOS = globaPos.Pt() ; //Distance to center of PHOS module
+ const Double_t kYmax = 72.+10. ; //Size of the module (with some reserve) in phi direction
+ const Double_t kZmax = 64.+10. ; //Size of the module (with some reserve) in z direction
+ const Double_t kAlpha0=330./180.*TMath::Pi() ; //First PHOS module angular direction
+ const Double_t kAlpha= 20./180.*TMath::Pi() ; //PHOS module angular size
+ Double_t minDistance = 1.e6;
+
+ TVector3 vecEmc ; // Local position of EMC recpoint
+ emcClu->GetLocalPosition(vecEmc) ;
+
+ Double_t gposTrack[3] ;
+ Double_t bz = AliTracker::GetBz() ; //B-Field for approximate matching
+ Double_t b[3];
+ for (Int_t i=0; i<nt; i++) {
+ AliESDtrack *esdTrack=fESD->GetTrack(i);
+
+ // Skip the tracks having "wrong" status (has to be checked/tuned)
+ ULong_t status = esdTrack->GetStatus();
+ if ((status & AliESDtrack::kTPCout) == 0) continue;
+// if ((status & AliESDtrack::kTRDout) == 0) continue;
+// if ((status & AliESDtrack::kTRDrefit) == 1) continue;
+
+ //Continue extrapolation from TPC outer surface
+ const AliExternalTrackParam *outerParam=esdTrack->GetOuterParam();
+ if (!outerParam) continue;
+ AliExternalTrackParam t(*outerParam);
+
+ t.GetBxByBz(b) ;
+ //Direction to the current PHOS module
+ Double_t phiMod=kAlpha0-kAlpha*iPHOSMod ;
+ if(!t.Rotate(phiMod))
+ continue ;
+
+ Double_t y; // Some tracks do not reach the PHOS
+ if (!t.GetYAt(rPHOS,bz,y)) continue; // because of the bending
+
+ Double_t z;
+ if(!t.GetZAt(rPHOS,bz,z))
+ continue ;
+ if (TMath::Abs(z) > kZmax)
+ continue; // Some tracks miss the PHOS in Z
+ if(TMath::Abs(y) < kYmax){
+ t.PropagateToBxByBz(rPHOS,b); // Propagate to the matching module
+ //t.CorrectForMaterial(...); // Correct for the TOF material, if needed
+ t.GetXYZ(gposTrack) ;
+ TVector3 globalPositionTr(gposTrack) ;
+ TVector3 localPositionTr ;
+ fGeom->Global2Local(localPositionTr,globalPositionTr,iPHOSMod) ;
+ Double_t ddx = vecEmc.X()-localPositionTr.X();
+ Double_t ddz = vecEmc.Z()-localPositionTr.Z();
+ Double_t d2 = ddx*ddx + ddz*ddz;
+ if(d2 < minDistance) {
+ dx = ddx ;
+ dz = ddz ;
+ trackindex=i;
+ minDistance=d2 ;
+ }
+ }
+ } //Scanned all tracks
+ return ;
+ }
+
+ TVector3 emcGlobal;
+ fGeom->GetGlobalPHOS((AliPHOSRecPoint*)emcClu,emcGlobal);
+
+ // Radius from IP to current point
+ Double_t rEMC = TMath::Abs(emcGlobal.Pt());
+
+ // Extrapolate the global track direction to EMC
+ // and find the closest track
+
+ Int_t nTracks = fESD->GetNumberOfTracks();
+
+ AliESDtrack *track;
+ Double_t xyz[] = {-1,-1,-1};
+ Double_t pxyz[3];
+ Double_t zEMC,xEMC;
+ Int_t module;
+ TVector3 vecP;
+ TVector3 locClu;
+
+ Float_t minDistance = 1.e6;
+ Float_t dr;
+
+ for (Int_t iTrack=0; iTrack<nTracks; iTrack++) {
+ track = fESD->GetTrack(iTrack);
+ if (!track->GetXYZAt(rEMC, fESD->GetMagneticField(), xyz)) continue;
+
+ AliDebug(1,Form("Event %d, iTrack: %d, (%.3f,%.3f,%.3f)",
+ fESD->GetEventNumberInFile(),iTrack,xyz[0],xyz[1],xyz[2]));
+
+ if (track->GetPxPyPzAt(rEMC,fESD->GetMagneticField(),pxyz)) {
+
+ vecP.SetXYZ(pxyz[0],pxyz[1],pxyz[2]);
+ fGeom->ImpactOnEmc(xyz,vecP.Theta(),vecP.Phi(),module,zEMC,xEMC) ;
+
+ if(!module) continue;
+ AliDebug(1,Form("\t\tTrack hit PHOS! Module: %d, (x,z)=(%.3f,%.3f)",module,xEMC,zEMC));
+
+ if(emcClu->GetPHOSMod() != module) continue;
+
+ // match track to EMC cluster
+ emcClu->GetLocalPosition(locClu);
+
+ Float_t delta_x = xEMC - locClu.X();
+ Float_t delta_z = zEMC - locClu.Z();
+ dr = TMath::Sqrt(delta_x*delta_x + delta_z*delta_z);
+ AliDebug(1,Form("\tMatch iTrack=%d: (dx,dz)=(%.3f,%.3f)",iTrack,delta_x,delta_z));
+
+ if(dr<minDistance) {
+ trackindex = iTrack;
+ minDistance = dr;
+ dx = delta_x;
+ dz = delta_z;
+ }
+ }
+
+ }
+
+ if(trackindex>=0) {
+ AliDebug(1,Form("\t\tBest match for (xClu,zClu,eClu)=(%.3f,%.3f,%.3f): iTrack=%d, dR=%.3f",
+ locClu.X(),locClu.Z(),emcClu->GetEnergy(),
+ trackindex,TMath::Sqrt(dx*dx+dz*dz)));
+ return;
+ }
+
+ Float_t distance2Track = fRtpc ;
+
+ trackindex = -1 ; // closest track within fRCpv
+
TVector3 vecEmc ; // Local position of EMC recpoint
- TVector3 vecP ; // Momentum direction at CPV plain
TVector3 vecPloc ; // Momentum direction at CPV plain
//toofar = kTRUE ;
dz=999. ;
return ;
}
-
+
emcClu->GetLocalPosition(vecEmc) ;
-
- Double_t xCPV,zCPV ; //EMC-projected coordinates of CPV cluster
+
+ Double_t xCPV=0,zCPV=0 ; //EMC-projected coordinates of CPV cluster
TVector3 cpvGlobal; // Global position of the CPV recpoint
fGeom->GetGlobalPHOS((AliPHOSRecPoint*)cpvClu,cpvGlobal);
Double_t vtxCPV[3]={cpvGlobal.X(),cpvGlobal.Y(),cpvGlobal.Z()} ;
Int_t dummyMod ;
if (fESD == 0x0) {
- //if no track information available, assume straight line from IP to emcal
- fGeom->ImpactOnEmc(vtxCPV,cpvGlobal.Theta(),cpvGlobal.Phi(),dummyMod,zCPV,xCPV) ;
- dx=xCPV - vecEmc.X() ;
- dz=zCPV - vecEmc.Z() ;
- return ;
+ //if no track information available, assume straight line from IP to emcal
+ fGeom->ImpactOnEmc(vtxCPV,cpvGlobal.Theta(),cpvGlobal.Phi(),dummyMod,zCPV,xCPV) ;
+ dx=xCPV - vecEmc.X() ;
+ dz=zCPV - vecEmc.Z() ;
+ return ;
}
-
+
//if there is ESD try to correct distance using TPC information on particle direct in CPV
if (fESD != 0x0) {
Double_t rCPV = cpvGlobal.Pt() ;// Radius from IP to current point
// Extrapolate the global track direction if any to CPV and find the closest track
- Int_t nTracks = fESD->GetNumberOfTracks();
Int_t iClosestTrack = -1;
- Double_t minDistance = 1.e6;
TVector3 inPHOS ;
- AliESDtrack *track;
- Double_t xyz[3] ;
- Double_t pxyz[3];
for (Int_t iTrack=0; iTrack<nTracks; iTrack++) {
track = fESD->GetTrack(iTrack);
if (!track->GetXYZAt(rCPV, fESD->GetMagneticField(), xyz))
- continue; //track coord on the cylinder of PHOS radius
+ continue; //track coord on the cylinder of PHOS radius
if ((TMath::Abs(xyz[0])+TMath::Abs(xyz[1])+TMath::Abs(xyz[2]))<=0)
- continue;
+ continue;
//Check if this track hits PHOS
inPHOS.SetXYZ(xyz[0],xyz[1],xyz[2]);
distance2Track = inPHOS.Angle(cpvGlobal) ;
// Find the closest track to the CPV recpoint
if (distance2Track < minDistance) {
- minDistance = distance2Track;
- iClosestTrack = iTrack;
+ minDistance = distance2Track;
+ iClosestTrack = iTrack;
}
}
track = fESD->GetTrack(iClosestTrack);
if (track->GetPxPyPzAt(rCPV, fESD->GetMagneticField(), pxyz)) { // track momentum ibid.
vecP.SetXYZ(pxyz[0],pxyz[1],pxyz[2]);
- Int_t dummyMod ;
fGeom->ImpactOnEmc(vtxCPV,vecP.Theta(),vecP.Phi(),dummyMod,zCPV,xCPV) ;
}
}
// remove them from the list of "unassigned".
//Make arrays to mark clusters already chosen
+ Int_t index;
+
Int_t * emcExist = 0;
- if(fEmcLast > fEmcFirst)
+ if(fEmcLast > fEmcFirst) {
emcExist = new Int_t[fEmcLast-fEmcFirst] ;
-
- Int_t index;
- for(index = 0; index <fEmcLast-fEmcFirst; index ++)
- emcExist[index] = 1 ;
-
+ for(index = 0; index <fEmcLast-fEmcFirst; index ++)
+ emcExist[index] = 1 ;
+ }
+ else
+ return;
+
Bool_t * cpvExist = 0;
- if(fCpvLast > fCpvFirst)
+ if(fCpvLast > fCpvFirst) {
cpvExist = new Bool_t[fCpvLast-fCpvFirst] ;
- for(index = 0; index <fCpvLast-fCpvFirst; index ++)
- cpvExist[index] = kTRUE ;
-
+ for(index = 0; index <fCpvLast-fCpvFirst; index ++)
+ cpvExist[index] = kTRUE ;
+ }
// Finds the smallest links and makes pairs of CPV and EMC clusters with smallest distance
TIter nextUp(fLinkUpArray) ;
if(emcExist[linkUp->GetEmc()-fEmcFirst] != -1){
- if(cpvExist[linkUp->GetCpv()-fCpvFirst]){ //CPV still exist
+ //array cpvExist[] should be non-zero as far as linkUp exists
+ //But Coverity requires to check it
+ if(cpvExist && cpvExist[linkUp->GetCpv()-fCpvFirst]){ //CPV still exist
Float_t dx,dz ;
linkUp->GetXZ(dx,dz) ;
new ((* fTrackSegments)[fNTrackSegments])
- AliPHOSTrackSegment(dynamic_cast<AliPHOSEmcRecPoint *>(fEMCRecPoints->At(linkUp->GetEmc())) ,
- dynamic_cast<AliPHOSCpvRecPoint *>(fCPVRecPoints->At(linkUp->GetCpv())) ,
+ AliPHOSTrackSegment(static_cast<AliPHOSEmcRecPoint *>(fEMCRecPoints->At(linkUp->GetEmc())) ,
+ static_cast<AliPHOSCpvRecPoint *>(fCPVRecPoints->At(linkUp->GetCpv())) ,
linkUp->GetTrack(),dx,dz) ;
- (dynamic_cast<AliPHOSTrackSegment *>(fTrackSegments->At(fNTrackSegments)))->SetIndexInList(fNTrackSegments);
+ (static_cast<AliPHOSTrackSegment *>(fTrackSegments->At(fNTrackSegments)))->SetIndexInList(fNTrackSegments);
fNTrackSegments++ ;
emcExist[linkUp->GetEmc()-fEmcFirst] = -1 ; //Mark emc that Cpv was found
//mark CPV recpoint as already used
cpvExist[linkUp->GetCpv()-fCpvFirst] = kFALSE ;
} //if CpvUp still exist
- }
- }
+ }
+ }
//look through emc recPoints left without CPV
if(emcExist){ //if there is emc rec point
Int_t iEmcRP ;
for(iEmcRP = 0; iEmcRP < fEmcLast-fEmcFirst ; iEmcRP++ ){
if(emcExist[iEmcRP] > 0 ){
- new ((*fTrackSegments)[fNTrackSegments])
- AliPHOSTrackSegment(dynamic_cast<AliPHOSEmcRecPoint *>(fEMCRecPoints->At(iEmcRP+fEmcFirst)),
- nullpointer) ;
- (dynamic_cast<AliPHOSTrackSegment *>(fTrackSegments->At(fNTrackSegments)))->SetIndexInList(fNTrackSegments);
- fNTrackSegments++;
+ Int_t track = -1 ;
+ Float_t dx,dz ;
+ AliPHOSEmcRecPoint *emcclu = dynamic_cast<AliPHOSEmcRecPoint *>(fEMCRecPoints->At(iEmcRP+fEmcFirst));
+ GetDistanceInPHOSPlane(emcclu, 0, track,dx,dz);
+ if(track<0)
+ new ((*fTrackSegments)[fNTrackSegments]) AliPHOSTrackSegment(emcclu,nullpointer) ;
+ else
+ new ((*fTrackSegments)[fNTrackSegments]) AliPHOSTrackSegment(emcclu,0,track,dx,dz);
+ (static_cast<AliPHOSTrackSegment *>(fTrackSegments->At(fNTrackSegments)))->SetIndexInList(fNTrackSegments);
+ fNTrackSegments++;
}
}
}
delete [] emcExist ;
- delete [] cpvExist ;
+ if(cpvExist)
+ delete [] cpvExist ;
}
//____________________________________________________________________________
fTrackSegments->Clear();
// if(!ReadRecPoints(ievent)) continue; //reads RecPoints for event ievent
-
+
for(fModule = 1; fModule <= fGeom->GetNModules() ; fModule++ ) {
FillOneModule() ;
MakeLinks() ;
}
}
}
+