#include <TMatrixD.h>
#include <TTree.h>
-#include <TTreeStream.h>
#include <TDatabasePDG.h>
#include <TString.h>
#include <TRandom.h>
+#include <TTreeStream.h>
#include "AliLog.h"
+#include "AliITSPlaneEff.h"
+#include "AliITSCalibrationSPD.h"
+#include "AliITSCalibrationSDD.h"
+#include "AliITSCalibrationSSD.h"
+#include "AliCDBEntry.h"
+#include "AliCDBManager.h"
+#include "AliAlignObj.h"
+#include "AliTrackPointArray.h"
+#include "AliESDVertex.h"
#include "AliESDEvent.h"
#include "AliESDtrack.h"
-#include "AliESDVertex.h"
#include "AliV0.h"
#include "AliHelix.h"
+#include "AliITSChannelStatus.h"
+#include "AliITSDetTypeRec.h"
#include "AliITSRecPoint.h"
#include "AliITSgeomTGeo.h"
#include "AliITSReconstructor.h"
-#include "AliTrackPointArray.h"
-#include "AliAlignObj.h"
#include "AliITSClusterParam.h"
-#include "AliCDBManager.h"
-#include "AliCDBEntry.h"
#include "AliITSsegmentation.h"
#include "AliITSCalibration.h"
-#include "AliITSCalibrationSPD.h"
-#include "AliITSCalibrationSDD.h"
-#include "AliITSCalibrationSSD.h"
-#include "AliITSPlaneEff.h"
#include "AliITSPlaneEffSPD.h"
#include "AliITSPlaneEffSDD.h"
#include "AliITSPlaneEffSSD.h"
+#include "AliITSV0Finder.h"
#include "AliITStrackerMI.h"
ClassImp(AliITStrackerMI)
fxTimesRhoLayerTrks(0),
fDebugStreamer(0),
fITSChannelStatus(0),
-fDetTypeRec(0),
+fkDetTypeRec(0),
fPlaneEff(0) {
//Default constructor
Int_t i;
fxTimesRhoLayerTrks(0),
fDebugStreamer(0),
fITSChannelStatus(0),
-fDetTypeRec(0),
+fkDetTypeRec(0),
fPlaneEff(0) {
//--------------------------------------------------------------------
//This is the AliITStrackerMI constructor
fDebugStreamer = new TTreeSRedirector("ITSdebug.root");
// only for plane efficiency evaluation
- if (AliITSReconstructor::GetRecoParam()->GetComputePlaneEff()) {
+ if (AliITSReconstructor::GetRecoParam()->GetComputePlaneEff() &&
+ AliITSReconstructor::GetRecoParam()->GetIPlanePlaneEff()>=0) {
Int_t iplane=AliITSReconstructor::GetRecoParam()->GetIPlanePlaneEff();
if(AliITSReconstructor::GetRecoParam()->GetLayersToSkip(iplane))
AliWarning(Form("Evaluation of Plane Eff for layer %d will be attempted without removing it from tracker",iplane));
fxTimesRhoLayerTrks(0),
fDebugStreamer(tracker.fDebugStreamer),
fITSChannelStatus(tracker.fITSChannelStatus),
-fDetTypeRec(tracker.fDetTypeRec),
+fkDetTypeRec(tracker.fkDetTypeRec),
fPlaneEff(tracker.fPlaneEff) {
//Copy constructor
Int_t i;
if(fPlaneEff) delete fPlaneEff;
}
//------------------------------------------------------------------------
-void AliITStrackerMI::SetLayersNotToSkip(Int_t *l) {
+void AliITStrackerMI::SetLayersNotToSkip(const Int_t *l) {
//--------------------------------------------------------------------
//This function set masks of the layers which must be not skipped
//--------------------------------------------------------------------
Info("ReadBadFromDetTypeRec","Reading info about bad ITS detectors and channels");
- if(!fDetTypeRec) Error("ReadBadFromDetTypeRec","AliITSDetTypeRec nof found!\n");
+ if(!fkDetTypeRec) Error("ReadBadFromDetTypeRec","AliITSDetTypeRec nof found!\n");
// ITS channels map
if(fITSChannelStatus) delete fITSChannelStatus;
- fITSChannelStatus = new AliITSChannelStatus(fDetTypeRec);
+ fITSChannelStatus = new AliITSChannelStatus(fkDetTypeRec);
// ITS detectors and chips
Int_t i=0,j=0,k=0,ndet=0;
for (j=1; j<AliITSgeomTGeo::GetNLadders(i)+1; j++) {
for (k=1; k<ndet+1; k++) {
AliITSdetector &det=fgLayers[i-1].GetDetector((j-1)*ndet + k-1);
- det.ReadBadDetectorAndChips(i-1,(j-1)*ndet + k-1,fDetTypeRec);
+ det.ReadBadDetectorAndChips(i-1,(j-1)*ndet + k-1,fkDetTypeRec);
if(det.IsBad()) {nBadDetsPerLayer++;}
} // end loop on detectors
} // end loop on ladders
return;
}
//------------------------------------------------------------------------
-static Int_t CorrectForTPCtoITSDeadZoneMaterial(AliITStrackMI *t) {
+Int_t AliITStrackerMI::CorrectForTPCtoITSDeadZoneMaterial(AliITStrackMI *t) {
//--------------------------------------------------------------------
// Correction for the material between the TPC and the ITS
//--------------------------------------------------------------------
if (!t->PropagateToTGeo(AliITSRecoParam::Getrcd(),1)) return 0;// TPC central drum
if (!t->PropagateToTGeo(AliITSRecoParam::Getriw()+0.001,1)) return 0;// TPC inner wall
} else {
- Error("CorrectForTPCtoITSDeadZoneMaterial","Track is already in the dead zone !");
+ printf("CorrectForTPCtoITSDeadZoneMaterial: Track is already in the dead zone !\n");
return 0;
}
if(event->GetNumberOfV0s()>0) UpdateTPCV0(event);
if(AliITSReconstructor::GetRecoParam()->GetFindV0s()) FindV02(event);
+ //if(event->GetNumberOfV0s()>0) AliITSV0Finder::UpdateTPCV0(event,this);
+ //if(AliITSReconstructor::GetRecoParam()->GetFindV0s()) AliITSV0Finder::FindV02(event,this);
fAfterV0 = kTRUE;
//
itsTracks.Delete();
// The clusters must be loaded !
//--------------------------------------------------------------------
fTrackingPhase="RefitInward";
+
if(AliITSReconstructor::GetRecoParam()->GetFindV0s()) RefitV02(event);
+ //if(AliITSReconstructor::GetRecoParam()->GetFindV0s()) AliITSV0Finder::RefitV02(event,this);
+
Int_t nentr=event->GetNumberOfTracks();
Info("RefitInward", "Number of ESD tracks: %d\n", nentr);
fTrackToFollow.ResetCovariance(10.);
//Refitting...
- Bool_t pe=AliITSReconstructor::GetRecoParam()->GetComputePlaneEff();
+ Bool_t pe=(AliITSReconstructor::GetRecoParam()->GetComputePlaneEff() &&
+ AliITSReconstructor::GetRecoParam()->GetIPlanePlaneEff()>=0);
AliDebug(2,Form("Refit LABEL %d %d",t->GetLabel(),t->GetNumberOfClusters()));
if (RefitAt(AliITSRecoParam::GetrInsideSPD1(),&fTrackToFollow,t,kTRUE,pe)) {
AliDebug(2," refit OK");
}
//------------------------------------------------------------------------
void AliITStrackerMI::AliITSdetector::ReadBadDetectorAndChips(Int_t ilayer,Int_t idet,
- AliITSDetTypeRec *detTypeRec)
+ const AliITSDetTypeRec *detTypeRec)
{
//--------------------------------------------------------------------
// Read bad detectors and chips from calibration objects in AliITSDetTypeRec
return normchi2;
}
//------------------------------------------------------------------------
-Double_t AliITStrackerMI::GetMatchingChi2(AliITStrackMI * track1, AliITStrackMI * track2)
+Double_t AliITStrackerMI::GetMatchingChi2(const AliITStrackMI * track1,const AliITStrackMI * track2)
{
//
// return matching chi2 between two tracks
return chi2(0,0);
}
//------------------------------------------------------------------------
-Double_t AliITStrackerMI::GetSPDDeadZoneProbability(Double_t zpos, Double_t zerr)
+Double_t AliITStrackerMI::GetSPDDeadZoneProbability(Double_t zpos, Double_t zerr) const
{
//
// return probability that given point (characterized by z position and error)
return probability;
}
//------------------------------------------------------------------------
-Double_t AliITStrackerMI::GetTruncatedChi2(AliITStrackMI * track, Float_t fac)
+Double_t AliITStrackerMI::GetTruncatedChi2(const AliITStrackMI * track, Float_t fac)
{
//
// calculate normalized chi2
return normchi2;
}
//------------------------------------------------------------------------
-Double_t AliITStrackerMI::GetInterpolatedChi2(AliITStrackMI * forwardtrack, AliITStrackMI * backtrack)
+Double_t AliITStrackerMI::GetInterpolatedChi2(const AliITStrackMI * forwardtrack,const AliITStrackMI * backtrack)
{
//
// calculate normalized chi2
return fgLayers[l].GetWeight(c);
}
//------------------------------------------------------------------------
-void AliITStrackerMI::RegisterClusterTracks(AliITStrackMI* track,Int_t id)
+void AliITStrackerMI::RegisterClusterTracks(const AliITStrackMI* track,Int_t id)
{
//---------------------------------------------
// register track to the list
}
}
//------------------------------------------------------------------------
-void AliITStrackerMI::UnRegisterClusterTracks(AliITStrackMI* track, Int_t id)
+void AliITStrackerMI::UnRegisterClusterTracks(const AliITStrackMI* track, Int_t id)
{
//---------------------------------------------
// unregister track from the list
return shared;
}
//------------------------------------------------------------------------
-Int_t AliITStrackerMI::GetOverlapTrack(AliITStrackMI *track, Int_t trackID, Int_t &shared, Int_t clusterlist[6],Int_t overlist[6])
+Int_t AliITStrackerMI::GetOverlapTrack(const AliITStrackMI *track, Int_t trackID, Int_t &shared, Int_t clusterlist[6],Int_t overlist[6])
{
//
// find first shared track
//------------------------------------------------------------------------
void AliITStrackerMI::MakeCoefficients(Int_t ntracks){
//
+ // Create some arrays
//
if (fCoefficients) delete []fCoefficients;
fCoefficients = new Float_t[ntracks*48];
Double_t AliITStrackerMI::GetPredictedChi2MI(AliITStrackMI* track, const AliITSRecPoint *cluster,Int_t layer)
{
//
- //
+ // Compute predicted chi2
//
Float_t erry,errz;
Float_t theta = track->GetTgl();
Int_t AliITStrackerMI::UpdateMI(AliITStrackMI* track, const AliITSRecPoint* cl,Double_t chi2,Int_t index) const
{
//
- //
+ // Update ITS track
//
Int_t layer = (index & 0xf0000000) >> 28;
track->SetClIndex(layer, index);
}
//------------------------------------------------------------------------
-void AliITStrackerMI::GetDCASigma(AliITStrackMI* track, Float_t & sigmarfi, Float_t &sigmaz)
+void AliITStrackerMI::GetDCASigma(const AliITStrackMI* track, Float_t & sigmarfi, Float_t &sigmaz)
{
//
//DCA sigmas parameterization
sigmaz = 0.0110+4.37*TMath::Abs(track->GetC());
}
//------------------------------------------------------------------------
-void AliITStrackerMI::SignDeltas( TObjArray *ClusterArray, Float_t vz)
+void AliITStrackerMI::SignDeltas(const TObjArray *clusterArray, Float_t vz)
{
//
+ // Clusters from delta electrons?
//
- Int_t entries = ClusterArray->GetEntriesFast();
+ Int_t entries = clusterArray->GetEntriesFast();
if (entries<4) return;
- AliITSRecPoint* cluster = (AliITSRecPoint*)ClusterArray->At(0);
+ AliITSRecPoint* cluster = (AliITSRecPoint*)clusterArray->At(0);
Int_t layer = cluster->GetLayer();
if (layer>1) return;
Int_t index[10000];
Float_t r = (layer>0)? 7:4;
//
for (Int_t i=0;i<entries;i++){
- AliITSRecPoint* cl0 = (AliITSRecPoint*)ClusterArray->At(i);
+ AliITSRecPoint* cl0 = (AliITSRecPoint*)clusterArray->At(i);
Float_t nz = 1+TMath::Abs((cl0->GetZ()-vz)/r);
if (cl0->GetNy()+cl0->GetNz()<=5+2*layer+nz) continue;
index[ncandidates] = i; //candidate to belong to delta electron track
//
//
for (Int_t i=0;i<ncandidates;i++){
- AliITSRecPoint* cl0 = (AliITSRecPoint*)ClusterArray->At(index[i]);
+ AliITSRecPoint* cl0 = (AliITSRecPoint*)clusterArray->At(index[i]);
if (cl0->GetDeltaProbability()>0.8) continue;
//
Int_t ncl = 0;
sumy=sumz=sumy2=sumyz=sumw=0.0;
for (Int_t j=0;j<ncandidates;j++){
if (i==j) continue;
- AliITSRecPoint* cl1 = (AliITSRecPoint*)ClusterArray->At(index[j]);
+ AliITSRecPoint* cl1 = (AliITSRecPoint*)clusterArray->At(index[j]);
//
Float_t dz = cl0->GetZ()-cl1->GetZ();
Float_t dy = cl0->GetY()-cl1->GetY();
void AliITStrackerMI::UpdateESDtrack(AliITStrackMI* track, ULong_t flags) const
{
//
+ // Update ESD track
//
track->UpdateESDtrack(flags);
AliITStrackMI * oldtrack = (AliITStrackMI*)(track->GetESDtrack()->GetITStrack());
}
return res;
}
+
//------------------------------------------------------------------------
-void AliITStrackerMI::UpdateTPCV0(AliESDEvent *event){
+void AliITStrackerMI::UpdateTPCV0(const AliESDEvent *event){
//
//try to update, or reject TPC V0s
//
if (forbidden[itrack0]) continue;
AliITStrackMI * btrack0 = (AliITStrackMI*)trackarray.At(itrack0);
if (!btrack0) continue;
- if (btrack0->GetSign()>0) continue;
+ if (btrack0->GetSign()>0 && !AliITSReconstructor::GetRecoParam()->GetStoreLikeSignV0s()) continue;
AliITStrackMI *trackc0 = (AliITStrackMI*)trackarrayc.At(itrack0);
//
- for (Int_t iesd1=0;iesd1<ntracks;iesd1++){
+ for (Int_t iesd1=iesd0+1;iesd1<ntracks;iesd1++){
Int_t itrack1 = itsmap[iesd1];
if (forbidden[itrack1]) continue;
AliITStrackMI * btrack1 = (AliITStrackMI*)trackarray.At(itrack1);
if (!btrack1) continue;
- if (btrack1->GetSign()<0) continue;
+ if (btrack1->GetSign()<0 && !AliITSReconstructor::GetRecoParam()->GetStoreLikeSignV0s()) continue;
Bool_t isGold = kFALSE;
if (TMath::Abs(TMath::Abs(btrack0->GetLabel())-TMath::Abs(btrack1->GetLabel()))==1){
isGold = kTRUE;
delete pvertex;
}
//------------------------------------------------------------------------
-void AliITStrackerMI::RefitV02(AliESDEvent *event)
+void AliITStrackerMI::RefitV02(const AliESDEvent *event)
{
//
//try to refit V0s in the third path of the reconstruction
}
}
}
+
//------------------------------------------------------------------------
void AliITStrackerMI::BuildMaterialLUT(TString material) {
//--------------------------------------------------------------------
return;
}
//------------------------------------------------------------------------
-Int_t AliITStrackerMI::CheckSkipLayer(AliITStrackMI *track,
+Int_t AliITStrackerMI::CheckSkipLayer(const AliITStrackMI *track,
Int_t ilayer,Int_t idet) const {
//-----------------------------------------------------------------
// This method is used to decide whether to allow a prolongation
} else if (ilayer==4 || ilayer==5) { // ---------- SSD
detType = 2;
}
- AliITSsegmentation *segm = (AliITSsegmentation*)fDetTypeRec->GetSegmentationModel(detType);
+ AliITSsegmentation *segm = (AliITSsegmentation*)fkDetTypeRec->GetSegmentationModel(detType);
if (detType==2) segm->SetLayer(ilayer+1);
Float_t detSizeX = detSizeFactorX*segm->Dx();
Float_t detSizeZ = detSizeFactorZ*segm->Dz();
}
//------------------------------------------------------------------------
Bool_t AliITStrackerMI::LocalModuleCoord(Int_t ilayer,Int_t idet,
- AliITStrackMI *track,
+ const AliITStrackMI *track,
Float_t &xloc,Float_t &zloc) const {
//-----------------------------------------------------------------
// Gives position of track in local module ref. frame
return kTRUE;
}
//------------------------------------------------------------------------
-Bool_t AliITStrackerMI::IsOKForPlaneEff(AliITStrackMI* track, const Int_t *clusters, Int_t ilayer) const {
+Bool_t AliITStrackerMI::IsOKForPlaneEff(const AliITStrackMI* track, const Int_t *clusters, Int_t ilayer) const {
//
// Method to be optimized further:
// Aim: decide whether a track can be used for PlaneEff evaluation
return kTRUE;
}
//------------------------------------------------------------------------
-void AliITStrackerMI::UseTrackForPlaneEff(AliITStrackMI* track, Int_t ilayer) {
+void AliITStrackerMI::UseTrackForPlaneEff(const AliITStrackMI* track, Int_t ilayer) {
//
// This Method has to be optimized! For the time-being it uses the same criteria
// as those used in the search of extra clusters for overlapping modules.
}
return;
}
-