X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITStrackerMI.cxx;h=97cc085c21f050df658e7353ea8a79913ff2aaf1;hb=c58d9e7d2d8604c70b4c25fd28b037dcdc2b1671;hp=f0478708ea8fbe08bcf502d73f776dca0ddf6df7;hpb=aad72f45c9c3fa068d01f3542578bc05ca9ee907;p=u%2Fmrichter%2FAliRoot.git diff --git a/ITS/AliITStrackerMI.cxx b/ITS/AliITStrackerMI.cxx index f0478708ea8..97cc085c21f 100644 --- a/ITS/AliITStrackerMI.cxx +++ b/ITS/AliITStrackerMI.cxx @@ -1,5 +1,5 @@ /************************************************************************** - * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. * * * * Author: The ALICE Off-line Project. * * Contributors are mentioned in the code where appropriate. * @@ -12,7 +12,6 @@ * about the suitability of this software for any purpose. It is * * provided "as is" without express or implied warranty. * **************************************************************************/ - /* $Id$ */ //------------------------------------------------------------------------- @@ -20,31 +19,43 @@ // It reads AliITSRecPoint clusters and creates AliITStrackMI tracks // and fills with them the ESD // Origin: Marian Ivanov, CERN, Marian.Ivanov@cern.ch -// dEdx analysis by: Boris Batyunya, JINR, Boris.Batiounia@cern.ch -// +// dE/dx analysis by: Boris Batyunya, JINR, Boris.Batiounia@cern.ch +// Params moved to AliITSRecoParam by: Andrea Dainese, INFN +// Material budget from TGeo by: Ludovic Gaudichet & Andrea Dainese, INFN //------------------------------------------------------------------------- #include #include #include -#include +#include +#include +#include #include "AliESDEvent.h" #include "AliESDtrack.h" +#include "AliESDVertex.h" #include "AliV0.h" #include "AliHelix.h" #include "AliITSRecPoint.h" #include "AliITSgeomTGeo.h" -#include "AliITStrackerMI.h" #include "AliITSReconstructor.h" #include "AliTrackPointArray.h" #include "AliAlignObj.h" +#include "AliITSClusterParam.h" +#include "AliCDBManager.h" +#include "AliCDBEntry.h" +#include "AliITSCalibrationSPD.h" +#include "AliITSCalibrationSDD.h" +#include "AliITSCalibrationSSD.h" +#include "AliITSPlaneEff.h" +#include "AliITSPlaneEffSPD.h" +#include "AliITSPlaneEffSDD.h" +#include "AliITSPlaneEffSSD.h" +#include "AliITStrackerMI.h" ClassImp(AliITStrackerMI) - - -AliITStrackerMI::AliITSlayer AliITStrackerMI::fgLayers[kMaxLayer]; // ITS layers +AliITStrackerMI::AliITSlayer AliITStrackerMI::fgLayers[AliITSgeomTGeo::kNLayers]; // ITS layers AliITStrackerMI::AliITStrackerMI():AliTracker(), fI(0), @@ -57,14 +68,30 @@ fCurrentEsdTrack(), fPass(0), fAfterV0(kFALSE), fLastLayerToTrackTo(0), -fCoeficients(0), +fCoefficients(0), fEsd(0), -fDebugStreamer(0){ +fTrackingPhase("Default"), +fUseTGeo(3), +fNtracks(0), +fxOverX0Pipe(-1.), +fxTimesRhoPipe(-1.), +fxOverX0PipeTrks(0), +fxTimesRhoPipeTrks(0), +fxOverX0ShieldTrks(0), +fxTimesRhoShieldTrks(0), +fxOverX0LayerTrks(0), +fxTimesRhoLayerTrks(0), +fDebugStreamer(0), +fPlaneEff(0) { //Default constructor + Int_t i; + for(i=0;i<4;i++) fSPDdetzcentre[i]=0.; + for(i=0;i<2;i++) {fxOverX0Shield[i]=-1.;fxTimesRhoShield[i]=-1.;} + for(i=0;i<6;i++) {fxOverX0Layer[i]=-1.;fxTimesRhoLayer[i]=-1.;} } //------------------------------------------------------------------------ AliITStrackerMI::AliITStrackerMI(const Char_t *geom) : AliTracker(), -fI(kMaxLayer), +fI(AliITSgeomTGeo::GetNLayers()), fBestTrack(), fTrackToFollow(), fTrackHypothesys(), @@ -73,10 +100,22 @@ fOriginal(), fCurrentEsdTrack(), fPass(0), fAfterV0(kFALSE), -fLastLayerToTrackTo(kLastLayerToTrackTo), -fCoeficients(0), +fLastLayerToTrackTo(AliITSRecoParam::GetLastLayerToTrackTo()), +fCoefficients(0), fEsd(0), -fDebugStreamer(0){ +fTrackingPhase("Default"), +fUseTGeo(3), +fNtracks(0), +fxOverX0Pipe(-1.), +fxTimesRhoPipe(-1.), +fxOverX0PipeTrks(0), +fxTimesRhoPipeTrks(0), +fxOverX0ShieldTrks(0), +fxTimesRhoShieldTrks(0), +fxOverX0LayerTrks(0), +fxTimesRhoLayerTrks(0), +fDebugStreamer(0), +fPlaneEff(0) { //-------------------------------------------------------------------- //This is the AliITStrackerMI constructor //-------------------------------------------------------------------- @@ -84,10 +123,10 @@ fDebugStreamer(0){ AliWarning("\"geom\" is actually a dummy argument !"); } - fCoeficients = 0; + fCoefficients = 0; fAfterV0 = kFALSE; - for (Int_t i=1; iGetXVdef(), - AliITSReconstructor::GetRecoParam()->GetYVdef(), - AliITSReconstructor::GetRecoParam()->GetZVdef()}; - Double_t ers[]={AliITSReconstructor::GetRecoParam()->GetSigmaXVdef(), - AliITSReconstructor::GetRecoParam()->GetSigmaYVdef(), - AliITSReconstructor::GetRecoParam()->GetSigmaZVdef()}; - SetVertex(xyz,ers); + Double_t xyzVtx[]={AliITSReconstructor::GetRecoParam()->GetXVdef(), + AliITSReconstructor::GetRecoParam()->GetYVdef(), + AliITSReconstructor::GetRecoParam()->GetZVdef()}; + Double_t ersVtx[]={AliITSReconstructor::GetRecoParam()->GetSigmaXVdef(), + AliITSReconstructor::GetRecoParam()->GetSigmaYVdef(), + AliITSReconstructor::GetRecoParam()->GetSigmaZVdef()}; + SetVertex(xyzVtx,ersVtx); - for (Int_t i=0; iGetUseTGeoInTracker(); + if(AliITSReconstructor::GetRecoParam()->GetExtendedEtaAcceptance() && fUseTGeo!=1 && fUseTGeo!=3) { + AliWarning("fUseTGeo changed to 3 because fExtendedEtaAcceptance is kTRUE"); + fUseTGeo = 3; + } + + for(Int_t i=0;i<2;i++) {fxOverX0Shield[i]=-1.;fxTimesRhoShield[i]=-1.;} + for(Int_t i=0;i<6;i++) {fxOverX0Layer[i]=-1.;fxTimesRhoLayer[i]=-1.;} + fDebugStreamer = new TTreeSRedirector("ITSdebug.root"); + // only for plane efficiency evaluation + if (AliITSReconstructor::GetRecoParam()->GetComputePlaneEff()) { + for(Int_t ilay=0;ilay<6;ilay++) { + if(AliITSReconstructor::GetRecoParam()->GetLayersToSkip(ilay)) { + if (ilay<2) fPlaneEff = new AliITSPlaneEffSPD(); + else if (ilay<4) fPlaneEff = new AliITSPlaneEffSDD(); + else fPlaneEff = new AliITSPlaneEffSSD(); + break; // only one layer type to skip at once + } + } + if(AliITSReconstructor::GetRecoParam()->GetReadPlaneEffFromOCDB()) + if(!fPlaneEff->ReadFromCDB()) {AliWarning("AliITStrackerMI reading of AliITSPlaneEff from OCDB failed") ;} + if(AliITSReconstructor::GetRecoParam()->GetHistoPlaneEff()) { + fPlaneEff->SetCreateHistos(kTRUE); + //fPlaneEff->ReadHistosFromFile(); + } + } } //------------------------------------------------------------------------ AliITStrackerMI::AliITStrackerMI(const AliITStrackerMI &tracker):AliTracker(tracker), @@ -161,10 +237,34 @@ fCurrentEsdTrack(tracker.fCurrentEsdTrack), fPass(tracker.fPass), fAfterV0(tracker.fAfterV0), fLastLayerToTrackTo(tracker.fLastLayerToTrackTo), -fCoeficients(tracker.fCoeficients), +fCoefficients(tracker.fCoefficients), fEsd(tracker.fEsd), -fDebugStreamer(tracker.fDebugStreamer){ +fTrackingPhase(tracker.fTrackingPhase), +fUseTGeo(tracker.fUseTGeo), +fNtracks(tracker.fNtracks), +fxOverX0Pipe(tracker.fxOverX0Pipe), +fxTimesRhoPipe(tracker.fxTimesRhoPipe), +fxOverX0PipeTrks(0), +fxTimesRhoPipeTrks(0), +fxOverX0ShieldTrks(0), +fxTimesRhoShieldTrks(0), +fxOverX0LayerTrks(0), +fxTimesRhoLayerTrks(0), +fDebugStreamer(tracker.fDebugStreamer), +fPlaneEff(tracker.fPlaneEff) { //Copy constructor + Int_t i; + for(i=0;i<4;i++) { + fSPDdetzcentre[i]=tracker.fSPDdetzcentre[i]; + } + for(i=0;i<6;i++) { + fxOverX0Layer[i]=tracker.fxOverX0Layer[i]; + fxTimesRhoLayer[i]=tracker.fxTimesRhoLayer[i]; + } + for(i=0;i<2;i++) { + fxOverX0Shield[i]=tracker.fxOverX0Shield[i]; + fxTimesRhoShield[i]=tracker.fxTimesRhoShield[i]; + } } //------------------------------------------------------------------------ AliITStrackerMI & AliITStrackerMI::operator=(const AliITStrackerMI &tracker){ @@ -179,7 +279,8 @@ AliITStrackerMI::~AliITStrackerMI() // //destructor // - if (fCoeficients) delete []fCoeficients; + if (fCoefficients) delete [] fCoefficients; + DeleteTrksMaterialLUT(); if (fDebugStreamer) { //fDebugStreamer->Close(); delete fDebugStreamer; @@ -190,7 +291,7 @@ void AliITStrackerMI::SetLayersNotToSkip(Int_t *l) { //-------------------------------------------------------------------- //This function set masks of the layers which must be not skipped //-------------------------------------------------------------------- - for (Int_t i=0; iDelete(); - //add dead zone virtual "cluster" - if (i<2){ - for (Float_t ydead = 0; ydead < 1.31 ; ydead+=(i+1.)*0.018){ - Int_t lab[4] = {0,0,0,detector}; - Int_t info[3] = {0,0,i}; - Float_t hit[5]={0,0,0.004/12.,0.001/12.,0}; - if (i==0) hit[0] =ydead-0.4; - if (i==1) hit[0]=ydead-3.75; - hit[1] =-0.04; - if (TMath::Abs(fgLayers[i].GetDetector(detector).GetZmax()-hit[1])<2.) - fgLayers[i].InsertCluster(new AliITSRecPoint(lab, hit, info)); - hit[1]=-7.05; - if (TMath::Abs(fgLayers[i].GetDetector(detector).GetZmax()-hit[1])<2.) - fgLayers[i].InsertCluster(new AliITSRecPoint(lab, hit, info)); - hit[1]=-7.15; - if (TMath::Abs(fgLayers[i].GetDetector(detector).GetZmax()-hit[1])<2.) - fgLayers[i].InsertCluster(new AliITSRecPoint(lab, hit, info)); - hit[1] =0.06; - if (TMath::Abs(fgLayers[i].GetDetector(detector).GetZmax()-hit[1])<2.) - fgLayers[i].InsertCluster(new AliITSRecPoint(lab, hit, info)); - hit[1]=7.05; - if (TMath::Abs(fgLayers[i].GetDetector(detector).GetZmax()-hit[1])<2.) - fgLayers[i].InsertCluster(new AliITSRecPoint(lab, hit, info)); - hit[1]=7.25; - if (TMath::Abs(fgLayers[i].GetDetector(detector).GetZmax()-hit[1])<2.) - fgLayers[i].InsertCluster(new AliITSRecPoint(lab, hit, info)); + // add dead zone "virtual" cluster in SPD, if there is a cluster within + // zwindow cm from the dead zone + if (i<2 && AliITSReconstructor::GetRecoParam()->GetAddVirtualClustersInDeadZone()) { + for (Float_t xdead = 0; xdead < AliITSRecoParam::GetSPDdetxlength(); xdead += (i+1.)*AliITSReconstructor::GetRecoParam()->GetXPassDeadZoneHits()) { + Int_t lab[4] = {0,0,0,detector}; + Int_t info[3] = {0,0,i}; + Float_t q = 0.; // this identifies virtual clusters + Float_t hit[5] = {xdead, + 0., + AliITSReconstructor::GetRecoParam()->GetSigmaXDeadZoneHit2(), + AliITSReconstructor::GetRecoParam()->GetSigmaZDeadZoneHit2(), + q}; + Bool_t local = kTRUE; + Double_t zwindow = AliITSReconstructor::GetRecoParam()->GetZWindowDeadZone(); + hit[1] = fSPDdetzcentre[0]+0.5*AliITSRecoParam::GetSPDdetzlength(); + if (TMath::Abs(fgLayers[i].GetDetector(detector).GetZmax()-hit[1])GetX() > riw) { - if (!t->PropagateTo(riw,diw,x0iw)) return 1; - if (TMath::Abs(t->GetY())>yr) t->CorrectForMaterial(dr); - if (TMath::Abs(t->GetZ())CorrectForMaterial(dm); - if (!t->PropagateTo(rcd,dcd,x0cd)) return 1; - //Double_t x,y,z; t->GetGlobalXYZat(rr,x,y,z); - //if (TMath::Abs(y)PropagateTo(rr,dr,x0r); - if (!t->PropagateTo(rs,ds)) return 1; - } else if (t->GetX() < rs) { - if (!t->PropagateTo(rs,-ds)) return 1; - //Double_t x,y,z; t->GetGlobalXYZat(rr,x,y,z); - //if (TMath::Abs(y)PropagateTo(rr,-dr,x0r); - if (!t->PropagateTo(rcd,-dcd,x0cd)) return 1; - if (!t->PropagateTo(riw+0.001,-diw,x0iw)) return 1; + if (t->GetX() > AliITSRecoParam::Getriw()) { // inward direction + if (!t->PropagateToTGeo(AliITSRecoParam::Getriw(),1)) return 0;// TPC inner wall + if (!t->PropagateToTGeo(AliITSRecoParam::Getrcd(),1)) return 0;// TPC central drum + if (!t->PropagateToTGeo(AliITSRecoParam::Getrs(),1)) return 0;// ITS screen + } else if (t->GetX() < AliITSRecoParam::Getrs()) { // outward direction + if (!t->PropagateToTGeo(AliITSRecoParam::Getrs(),1)) return 0;// ITS screen + 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("CorrectForDeadZoneMaterial","track is already in the dead zone !"); - return 1; + Error("CorrectForTPCtoITSDeadZoneMaterial","Track is already in the dead zone !"); + return 0; } - return 0; + return 1; } //------------------------------------------------------------------------ Int_t AliITStrackerMI::Clusters2Tracks(AliESDEvent *event) { @@ -309,10 +402,27 @@ Int_t AliITStrackerMI::Clusters2Tracks(AliESDEvent *event) { // This functions reconstructs ITS tracks // The clusters must be already loaded ! //-------------------------------------------------------------------- + + + fTrackingPhase="Clusters2Tracks"; + TObjArray itsTracks(15000); fOriginal.Clear(); fEsd = event; // store pointer to the esd + + // temporary (for cosmics) + if(event->GetVertex()) { + TString title = event->GetVertex()->GetTitle(); + if(title.Contains("cosmics")) { + Double_t xyz[3]={GetX(),GetY(),GetZ()}; + Double_t exyz[3]={0.1,0.1,0.1}; + SetVertex(xyz,exyz); + } + } + // temporary + {/* Read ESD tracks */ + Double_t pimass = TDatabasePDG::Instance()->GetParticle(211)->Mass(); Int_t nentr=event->GetNumberOfTracks(); Info("Clusters2Tracks", "Number of ESD tracks: %d\n", nentr); while (nentr--) { @@ -330,35 +440,31 @@ Int_t AliITStrackerMI::Clusters2Tracks(AliESDEvent *event) { delete t; continue; } - //t->fD[0] = t->GetD(GetX(),GetY()); - //t->fD[1] = t->GetZat(GetX())-GetZ(); t->GetDZ(GetX(),GetY(),GetZ(),t->GetDP()); //I.B. Double_t vdist = TMath::Sqrt(t->GetD(0)*t->GetD(0)+t->GetD(1)*t->GetD(1)); - if (t->GetMass()<0.13) t->SetMass(0.13957); // MI look to the esd - mass hypothesys !!!!!!!!!!! + + + // look at the ESD mass hypothesys ! + if (t->GetMass()<0.9*pimass) t->SetMass(pimass); // write expected q t->SetExpQ(TMath::Max(0.8*t->GetESDtrack()->GetTPCsignal(),30.)); - if (esd->GetV0Index(0)>0 && t->GetD(0)<30){ + if (esd->GetV0Index(0)>0 && t->GetD(0)GetMaxDforV0dghtrForProlongation()){ //track - can be V0 according to TPC - } - else{ - if (TMath::Abs(t->GetD(0))>10) { + } else { + if (TMath::Abs(t->GetD(0))>AliITSReconstructor::GetRecoParam()->GetMaxDForProlongation()) { delete t; continue; - } - - if (TMath::Abs(vdist)>20) { + } + if (TMath::Abs(vdist)>AliITSReconstructor::GetRecoParam()->GetMaxDZForProlongation()) { delete t; continue; } - if (TMath::Abs(1/t->Get1Pt())<0.120) { + if (t->Pt()GetMinPtForProlongation()) { delete t; continue; } - - if (CorrectForDeadZoneMaterial(t)!=0) { - //Warning("Clusters2Tracks", - // "failed to correct for the material in the dead zone !\n"); + if (!CorrectForTPCtoITSDeadZoneMaterial(t)) { delete t; continue; } @@ -374,31 +480,33 @@ Int_t AliITStrackerMI::Clusters2Tracks(AliESDEvent *event) { Int_t nentr=itsTracks.GetEntriesFast(); fTrackHypothesys.Expand(nentr); fBestHypothesys.Expand(nentr); - MakeCoeficients(nentr); + MakeCoefficients(nentr); + if(fUseTGeo==3 || fUseTGeo==4) MakeTrksMaterialLUT(event->GetNumberOfTracks()); Int_t ntrk=0; + // THE TWO TRACKING PASSES for (fPass=0; fPass<2; fPass++) { Int_t &constraint=fConstraint[fPass]; if (constraint<0) continue; - for (Int_t i=0; iGetReconstructed()&&(t->GetNUsed()<1.5)) continue; //this track was already "succesfully" reconstructed - //if ( (TMath::Abs(t->GetD(GetX(),GetY())) >3.) && fConstraint[fPass]) continue; - //if ( (TMath::Abs(t->GetZat(GetX())-GetZ())>3.) && fConstraint[fPass]) continue; Float_t dz[2]; t->GetDZ(GetX(),GetY(),GetZ(),dz); //I.B. - if ( (TMath::Abs(dz[0])>3.) && fConstraint[fPass]) continue; - if ( (TMath::Abs(dz[1])>3.) && fConstraint[fPass]) continue; + if (fConstraint[fPass]) { + if (TMath::Abs(dz[0])>AliITSReconstructor::GetRecoParam()->GetMaxDZToUseConstraint() || + TMath::Abs(dz[1])>AliITSReconstructor::GetRecoParam()->GetMaxDZToUseConstraint()) continue; + } Int_t tpcLabel=t->GetLabel(); //save the TPC track label fI = 6; ResetTrackToFollow(*t); ResetBestTrack(); - FollowProlongationTree(t,i,fConstraint[fPass]); + + FollowProlongationTree(t,fCurrentEsdTrack,fConstraint[fPass]); SortTrackHypothesys(fCurrentEsdTrack,20,0); //MI change // - AliITStrackMI * besttrack = GetBestHypothesys(fCurrentEsdTrack,t,15); + AliITStrackMI *besttrack = GetBestHypothesys(fCurrentEsdTrack,t,15); if (!besttrack) continue; besttrack->SetLabel(tpcLabel); // besttrack->CookdEdx(); @@ -407,33 +515,22 @@ Int_t AliITStrackerMI::Clusters2Tracks(AliESDEvent *event) { CookLabel(besttrack,0.); //For comparison only UpdateESDtrack(besttrack,AliESDtrack::kITSin); - /* - if ( besttrack->GetNumberOfClusters()<6 && fConstraint[fPass]) { - continue; - } - if (besttrack->fChi2MIP[0]+besttrack->fNUsed>3.5) continue; - if ( (TMath::Abs(besttrack->fD[0]*besttrack->fD[0]+besttrack->fD[1]*besttrack->fD[1])>0.1) && fConstraint[fPass]) continue; - //delete itsTracks.RemoveAt(i); - */ if (fConstraint[fPass]&&(!besttrack->IsGoldPrimary())) continue; //to be tracked also without vertex constrain - t->SetReconstructed(kTRUE); ntrk++; } GetBestHypothesysMIP(itsTracks); - } + } // end loop on the two tracking passes - //GetBestHypothesysMIP(itsTracks); - UpdateTPCV0(event); - FindV02(event); + if(event->GetNumberOfV0s()>0) UpdateTPCV0(event); + if(AliITSReconstructor::GetRecoParam()->GetFindV0s()) FindV02(event); fAfterV0 = kTRUE; - //GetBestHypothesysMIP(itsTracks); // itsTracks.Delete(); // Int_t entries = fTrackHypothesys.GetEntriesFast(); - for (Int_t ientry=0;ientryDelete(); delete fTrackHypothesys.RemoveAt(ientry); @@ -442,9 +539,13 @@ Int_t AliITStrackerMI::Clusters2Tracks(AliESDEvent *event) { fTrackHypothesys.Delete(); fBestHypothesys.Delete(); fOriginal.Clear(); - delete []fCoeficients; - fCoeficients=0; + delete [] fCoefficients; + fCoefficients=0; + DeleteTrksMaterialLUT(); + Info("Clusters2Tracks","Number of prolonged tracks: %d\n",ntrk); + + fTrackingPhase="Default"; return 0; } @@ -454,6 +555,7 @@ Int_t AliITStrackerMI::PropagateBack(AliESDEvent *event) { // This functions propagates reconstructed ITS tracks back // The clusters must be loaded ! //-------------------------------------------------------------------- + fTrackingPhase="PropagateBack"; Int_t nentr=event->GetNumberOfTracks(); Info("PropagateBack", "Number of ESD tracks: %d\n", nentr); @@ -476,20 +578,18 @@ Int_t AliITStrackerMI::PropagateBack(AliESDEvent *event) { ResetTrackToFollow(*t); - // propagete to vertex [SR, GSI 17.02.2003] + // propagate to vertex [SR, GSI 17.02.2003] // Start Time measurement [SR, GSI 17.02.2003], corrected by I.Belikov - if (fTrackToFollow.PropagateTo(3.,0.0028,65.19)) { - if (fTrackToFollow.PropagateToVertex(event->GetVertex())) { - fTrackToFollow.StartTimeIntegral(); - } - fTrackToFollow.PropagateTo(3.,-0.0028,65.19); + if (CorrectForPipeMaterial(&fTrackToFollow,"inward")) { + if (fTrackToFollow.PropagateToVertex(event->GetVertex())) + fTrackToFollow.StartTimeIntegral(); + // from vertex to outside pipe + CorrectForPipeMaterial(&fTrackToFollow,"outward"); } fTrackToFollow.ResetCovariance(10.); fTrackToFollow.ResetClusters(); - if (RefitAt(49.,&fTrackToFollow,t)) { - if (CorrectForDeadZoneMaterial(&fTrackToFollow)!=0) { - //Warning("PropagateBack", - // "failed to correct for the material in the dead zone !\n"); + if (RefitAt(AliITSRecoParam::GetrInsideITSscreen(),&fTrackToFollow,t)) { + if (!CorrectForTPCtoITSDeadZoneMaterial(&fTrackToFollow)) { delete t; continue; } @@ -505,6 +605,8 @@ Int_t AliITStrackerMI::PropagateBack(AliESDEvent *event) { Info("PropagateBack","Number of back propagated ITS tracks: %d\n",ntrk); + fTrackingPhase="Default"; + return 0; } //------------------------------------------------------------------------ @@ -514,7 +616,8 @@ Int_t AliITStrackerMI::RefitInward(AliESDEvent *event) { // "inward propagated" TPC tracks // The clusters must be loaded ! //-------------------------------------------------------------------- - RefitV02(event); + fTrackingPhase="RefitInward"; + if(AliITSReconstructor::GetRecoParam()->GetFindV0s()) RefitV02(event); Int_t nentr=event->GetNumberOfTracks(); Info("RefitInward", "Number of ESD tracks: %d\n", nentr); @@ -536,9 +639,7 @@ Int_t AliITStrackerMI::RefitInward(AliESDEvent *event) { continue; } t->SetExpQ(TMath::Max(0.8*t->GetESDtrack()->GetTPCsignal(),30.)); - if (CorrectForDeadZoneMaterial(t)!=0) { - //Warning("RefitInward", - // "failed to correct for the material in the dead zone !\n"); + if (!CorrectForTPCtoITSDeadZoneMaterial(t)) { delete t; continue; } @@ -550,20 +651,24 @@ Int_t AliITStrackerMI::RefitInward(AliESDEvent *event) { fTrackToFollow.ResetCovariance(10.); //Refitting... - if (RefitAt(3.7, &fTrackToFollow, t,kTRUE)) { + Bool_t pe=AliITSReconstructor::GetRecoParam()->GetComputePlaneEff(); + if (RefitAt(AliITSRecoParam::GetrInsideSPD1(),&fTrackToFollow,t,kTRUE,pe)) { fTrackToFollow.SetLabel(t->GetLabel()); // fTrackToFollow.CookdEdx(); CookdEdx(&fTrackToFollow); CookLabel(&fTrackToFollow,0.0); //For comparison only - if (fTrackToFollow.PropagateTo(3.,0.0028,65.19)) {//The beam pipe - AliESDtrack *esdTrack =fTrackToFollow.GetESDtrack(); - esdTrack->UpdateTrackParams(&fTrackToFollow,AliESDtrack::kITSrefit); - Float_t r[3]={0.,0.,0.}; - Double_t maxD=3.; + //The beam pipe + if (CorrectForPipeMaterial(&fTrackToFollow,"inward")) { + fTrackToFollow.UpdateESDtrack(AliESDtrack::kITSrefit); + AliESDtrack *esdTrack =fTrackToFollow.GetESDtrack(); + //printf(" %d\n",esdTrack->GetITSModuleIndex(0)); + //esdTrack->UpdateTrackParams(&fTrackToFollow,AliESDtrack::kITSrefit); //original line + Float_t r[3]={0.,0.,0.}; + Double_t maxD=3.; esdTrack->RelateToVertex(event->GetVertex(),GetBz(r),maxD); - ntrk++; + ntrk++; } } delete t; @@ -571,6 +676,8 @@ Int_t AliITStrackerMI::RefitInward(AliESDEvent *event) { Info("RefitInward","Number of refitted tracks: %d\n",ntrk); + fTrackingPhase="Default"; + return 0; } //------------------------------------------------------------------------ @@ -582,11 +689,11 @@ AliCluster *AliITStrackerMI::GetCluster(Int_t index) const { Int_t c=(index & 0x0fffffff) >> 00; return fgLayers[l].GetCluster(c); } - +//------------------------------------------------------------------------ Bool_t AliITStrackerMI::GetTrackPoint(Int_t index, AliTrackPoint& p) const { - // + //-------------------------------------------------------------------- // Get track space point with index i - // + //-------------------------------------------------------------------- Int_t l=(index & 0xf0000000) >> 28; Int_t c=(index & 0x0fffffff) >> 00; @@ -628,17 +735,88 @@ Bool_t AliITStrackerMI::GetTrackPoint(Int_t index, AliTrackPoint& p) const { return kTRUE; } //------------------------------------------------------------------------ +Bool_t AliITStrackerMI::GetTrackPointTrackingError(Int_t index, + AliTrackPoint& p, const AliESDtrack *t) { + //-------------------------------------------------------------------- + // Get track space point with index i + // (assign error estimated during the tracking) + //-------------------------------------------------------------------- + + Int_t l=(index & 0xf0000000) >> 28; + Int_t c=(index & 0x0fffffff) >> 00; + const AliITSRecPoint *cl = fgLayers[l].GetCluster(c); + Int_t idet = cl->GetDetectorIndex(); + const AliITSdetector &det=fgLayers[l].GetDetector(idet); + + // tgphi and tglambda of the track in tracking frame with alpha=det.GetPhi + Float_t detxy[2]; + detxy[0] = det.GetR()*TMath::Cos(det.GetPhi()); + detxy[1] = det.GetR()*TMath::Sin(det.GetPhi()); + Double_t alpha = t->GetAlpha(); + Double_t xdetintrackframe = detxy[0]*TMath::Cos(alpha)+detxy[1]*TMath::Sin(alpha); + Float_t phi = TMath::ASin(t->GetSnpAt(xdetintrackframe,AliTracker::GetBz())); + phi += alpha-det.GetPhi(); + Float_t tgphi = TMath::Tan(phi); + + Float_t tgl = t->GetTgl(); // tgl about const along track + Float_t expQ = TMath::Max(0.8*t->GetTPCsignal(),30.); + + Float_t errlocalx,errlocalz; + AliITSClusterParam::GetError(l,cl,tgl,tgphi,expQ,errlocalx,errlocalz); + + Float_t xyz[3]; + Float_t cov[6]; + cl->GetGlobalXYZ(xyz); + // cl->GetGlobalCov(cov); + Float_t pos[3] = {0.,0.,0.}; + AliCluster tmpcl((UShort_t)cl->GetVolumeId(),pos[0],pos[1],pos[2],errlocalx*errlocalx,errlocalz*errlocalz,0); + tmpcl.GetGlobalCov(cov); + + p.SetXYZ(xyz, cov); + + AliGeomManager::ELayerID iLayer = AliGeomManager::kInvalidLayer; + switch (l) { + case 0: + iLayer = AliGeomManager::kSPD1; + break; + case 1: + iLayer = AliGeomManager::kSPD2; + break; + case 2: + iLayer = AliGeomManager::kSDD1; + break; + case 3: + iLayer = AliGeomManager::kSDD2; + break; + case 4: + iLayer = AliGeomManager::kSSD1; + break; + case 5: + iLayer = AliGeomManager::kSSD2; + break; + default: + AliWarning(Form("Wrong layer index in ITS (%d) !",l)); + break; + }; + UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,idet); + p.SetVolumeID((UShort_t)volid); + return kTRUE; +} +//------------------------------------------------------------------------ void AliITStrackerMI::FollowProlongationTree(AliITStrackMI * otrack, Int_t esdindex, Bool_t constrain) { //-------------------------------------------------------------------- // Follow prolongation tree //-------------------------------------------------------------------- // + Double_t xyzVtx[]={GetX(),GetY(),GetZ()}; + Double_t ersVtx[]={GetSigmaX(),GetSigmaY(),GetSigmaZ()}; + + AliESDtrack * esd = otrack->GetESDtrack(); - if (esd->GetV0Index(0)>0){ - // + if (esd->GetV0Index(0)>0) { // TEMPORARY SOLLUTION: map V0 indexes to point to proper track - // mapping of esd track is different as its track in Containers + // mapping of ESD track is different as ITS track in Containers // Need something more stable // Indexes are set back again to the ESD track indexes in UpdateTPCV0 for (Int_t i=0;i<3;i++){ @@ -647,12 +825,11 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackMI * otrack, Int_t esdin AliESDv0 * vertex = fEsd->GetV0(index); if (vertex->GetStatus()<0) continue; // rejected V0 // - if (esd->GetSign()>0) { - vertex->SetIndex(0,esdindex); - } - else{ - vertex->SetIndex(1,esdindex); - } + if (esd->GetSign()>0) { + vertex->SetIndex(0,esdindex); + } else { + vertex->SetIndex(1,esdindex); + } } } TObjArray *bestarray = (TObjArray*)fBestHypothesys.At(esdindex); @@ -677,19 +854,22 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackMI * otrack, Int_t esdin new (&(tracks[6][0])) AliITStrackMI(*otrack); ntracks[6]=1; for (Int_t i=0;i<7;i++) nindexes[i][0]=0; + Int_t modstatus = 1; // found + Float_t xloc,zloc; // // // follow prolongations - for (Int_t ilayer=5;ilayer>=0;ilayer--){ + for (Int_t ilayer=5; ilayer>=0; ilayer--) { + fI = ilayer; // - AliITSlayer &layer=fgLayers[ilayer]; - Double_t r=layer.GetR(); + AliITSlayer &layer=fgLayers[ilayer]; + Double_t r = layer.GetR(); ntracks[ilayer]=0; // // - Int_t nskipped=0; + Int_t nskipped=0; Float_t nused =0; - for (Int_t itrack =0;itrack=100) break; if (tracks[ilayer+1][nindexes[ilayer+1][itrack]].GetNSkipped()>0) nskipped++; @@ -701,37 +881,57 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackMI * otrack, Int_t esdin new(¤ttrack1) AliITStrackMI(tracks[ilayer+1][nindexes[ilayer+1][itrack]]); - // material between SSD and SDD, SDD and SPD (to be done with TGeo) //AD - if (ilayer==3 || ilayer==1) { - Double_t rshield,dshield,x0shield; - if(ilayer==3) { // SDDouter - rshield=0.5*(fgLayers[ilayer+1].GetR() + r); - dshield=0.0034; - x0shield=38.6; - } else { // SPDouter - rshield=9.; - dshield=0.0097; - x0shield=42.; - } - if (!currenttrack1.PropagateTo(rshield,dshield,x0shield)) continue; - } + // material between SSD and SDD, SDD and SPD + if (ilayer==3) + if(!CorrectForShieldMaterial(¤ttrack1,"SDD","inward")) continue; + if (ilayer==1) + if(!CorrectForShieldMaterial(¤ttrack1,"SPD","inward")) continue; + // detector number Double_t phi,z; if (!currenttrack1.GetPhiZat(r,phi,z)) continue; - Int_t idet=layer.FindDetectorIndex(phi,z); + + Double_t trackGlobXYZ1[3]; + currenttrack1.GetXYZ(trackGlobXYZ1); + + // Get the budget to the primary vertex for the current track being prolonged + Double_t budgetToPrimVertex = GetEffectiveThickness(); + + // check if we allow a prolongation without point + Int_t skip = CheckSkipLayer(¤ttrack1,ilayer,idet); + if (skip) { + AliITStrackMI* vtrack = new (&tracks[ilayer][ntracks[ilayer]]) AliITStrackMI(currenttrack1); + // propagate to the layer radius + Double_t xToGo; vtrack->GetLocalXat(r,xToGo); + vtrack->AliExternalTrackParam::PropagateTo(xToGo,GetBz()); + // apply correction for material of the current layer + CorrectForLayerMaterial(vtrack,ilayer,trackGlobXYZ1,"inward"); + vtrack->SetNDeadZone(vtrack->GetNDeadZone()+1); + vtrack->SetClIndex(ilayer,0); + modstatus = (skip==1 ? 3 : 4); // skipped : out in z + LocalModuleCoord(ilayer,idet,vtrack,xloc,zloc); // local module coords + vtrack->SetModuleIndexInfo(ilayer,idet,modstatus,xloc,zloc); + if(constrain) vtrack->Improve(budgetToPrimVertex,xyzVtx,ersVtx); + ntracks[ilayer]++; + continue; + } + + // track outside layer acceptance in z if (idet<0) continue; - //propagate to the intersection + //propagate to the intersection with the detector plane const AliITSdetector &det=layer.GetDetector(idet); new(¤ttrack2) AliITStrackMI(currenttrack1); if (!currenttrack1.Propagate(det.GetPhi(),det.GetR())) continue; + LocalModuleCoord(ilayer,idet,¤ttrack1,xloc,zloc); // local module coords currenttrack2.Propagate(det.GetPhi(),det.GetR()); currenttrack1.SetDetectorIndex(idet); currenttrack2.SetDetectorIndex(idet); - + + //*************** + // DEFINITION OF SEARCH ROAD FOR CLUSTERS SELECTION // - // definition of search road for clusters selection Double_t dz=AliITSReconstructor::GetRecoParam()->GetNSigmaRoadZ()* TMath::Sqrt(currenttrack1.GetSigmaZ2() + AliITSReconstructor::GetRecoParam()->GetNSigmaZLayerForRoadZ()* @@ -742,31 +942,33 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackMI * otrack, Int_t esdin AliITSReconstructor::GetRecoParam()->GetNSigmaYLayerForRoadY()* AliITSReconstructor::GetRecoParam()->GetNSigmaYLayerForRoadY()* AliITSReconstructor::GetRecoParam()->GetSigmaY2(ilayer)); - // + // track at boundary between detectors, enlarge road - if ( (currenttrack1.GetY()-dy < det.GetYmin()+0.2) || - (currenttrack1.GetY()+dy > det.GetYmax()-0.2) || - (currenttrack1.GetZ()-dz < det.GetZmin()+0.2) || - (currenttrack1.GetZ()+dz > det.GetZmax()-0.2) ) { - Float_t maxtgl = TMath::Abs(currenttrack1.GetTgl()); - if (maxtgl > 1.) maxtgl=1.; - dz = TMath::Sqrt(dz*dz+0.5*0.5*maxtgl*maxtgl); //AD - // - Float_t maxsnp = TMath::Abs(currenttrack1.GetSnp()); - if (maxsnp > AliITSReconstructor::GetRecoParam()->GetMaxSnp()) continue; - //if (maxsnp>0.5) maxsnp=0.5; - dy = TMath::Sqrt(dy*dy+0.5*0.5*maxsnp*maxsnp); //AD + Double_t boundaryWidth=AliITSRecoParam::GetBoundaryWidth(); + if ( (currenttrack1.GetY()-dy < det.GetYmin()+boundaryWidth) || + (currenttrack1.GetY()+dy > det.GetYmax()-boundaryWidth) || + (currenttrack1.GetZ()-dz < det.GetZmin()+boundaryWidth) || + (currenttrack1.GetZ()+dz > det.GetZmax()-boundaryWidth) ) { + Float_t tgl = TMath::Abs(currenttrack1.GetTgl()); + if (tgl > 1.) tgl=1.; + Double_t deltaXNeighbDets=AliITSRecoParam::GetDeltaXNeighbDets(); + dz = TMath::Sqrt(dz*dz+deltaXNeighbDets*deltaXNeighbDets*tgl*tgl); + Float_t snp = TMath::Abs(currenttrack1.GetSnp()); + if (snp > AliITSReconstructor::GetRecoParam()->GetMaxSnp()) continue; + dy = TMath::Sqrt(dy*dy+deltaXNeighbDets*deltaXNeighbDets*snp*snp); } // boundary - // road in global (rphi,z) + // road in global (rphi,z) [i.e. in tracking ref. system] Double_t zmin = currenttrack1.GetZ() - dz; Double_t zmax = currenttrack1.GetZ() + dz; Double_t ymin = currenttrack1.GetY() + r*det.GetPhi() - dy; Double_t ymax = currenttrack1.GetY() + r*det.GetPhi() + dy; - // select clusters + + // select clusters in road layer.SelectClusters(zmin,zmax,ymin,ymax); + //******************** - // road for track-cluster association + // Define criteria for track-cluster association Double_t msz = currenttrack1.GetSigmaZ2() + AliITSReconstructor::GetRecoParam()->GetNSigmaZLayerForRoadZ()* AliITSReconstructor::GetRecoParam()->GetNSigmaZLayerForRoadZ()* @@ -786,163 +988,241 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackMI * otrack, Int_t esdin msy = 1./msy; // 1/RoadY^2 // // - // loop over all possible prolongations + // LOOP OVER ALL POSSIBLE TRACK PROLONGATIONS ON THIS LAYER // - const AliITSRecPoint *c=0; Int_t ci=-1; - Double_t chi2=AliITSReconstructor::GetRecoParam()->GetMaxChi2(); - Int_t deadzone=0; + const AliITSRecPoint *cl=0; + Int_t clidx=-1; + Double_t chi2trkcl=AliITSReconstructor::GetRecoParam()->GetMaxChi2(); // init with big value + Bool_t deadzoneSPD=kFALSE; currenttrack = ¤ttrack1; - while ((c=layer.GetNextCluster(ci))!=0) { + + // check if the road contains a dead zone + Int_t dead = CheckDeadZone(ilayer,idet,zmin,zmax); + // create a prolongation without clusters (check also if there are no clusters in the road) + if (dead || + ((layer.GetNextCluster(clidx,kTRUE))==0 && + AliITSReconstructor::GetRecoParam()->GetAllowProlongationWithEmptyRoad())) { + AliITStrackMI * updatetrack = new (&tracks[ilayer][ntracks[ilayer]]) AliITStrackMI(*currenttrack); + updatetrack->SetClIndex(ilayer,0); + if (dead==0) { + modstatus = 5; // no cls in road + } else if (dead==1) { + modstatus = 7; // holes in z in SPD + } else if (dead==2) { + modstatus = 2; // dead from OCDB + } + updatetrack->SetModuleIndexInfo(ilayer,idet,modstatus,xloc,zloc); + // apply correction for material of the current layer + CorrectForLayerMaterial(updatetrack,ilayer,trackGlobXYZ1,"inward"); + if (constrain) { // apply vertex constrain + updatetrack->SetConstrain(constrain); + Bool_t isPrim = kTRUE; + if (ilayer<4) { // check that it's close to the vertex + updatetrack->GetDZ(GetX(),GetY(),GetZ(),updatetrack->GetDP()); //I.B. + if (TMath::Abs(updatetrack->GetD(0)/(1.+ilayer)) > // y + AliITSReconstructor::GetRecoParam()->GetMaxDZforPrimTrk() || + TMath::Abs(updatetrack->GetD(1)/(1.+ilayer)) > // z + AliITSReconstructor::GetRecoParam()->GetMaxDZforPrimTrk()) isPrim=kFALSE; + } + if (isPrim) updatetrack->Improve(budgetToPrimVertex,xyzVtx,ersVtx); + } + if (dead) { + updatetrack->SetNDeadZone(updatetrack->GetNDeadZone()+1); + if (dead==1) { // dead zone at z=0,+-7cm in SPD + updatetrack->SetDeadZoneProbability(GetSPDDeadZoneProbability(updatetrack->GetZ(),TMath::Sqrt(updatetrack->GetSigmaZ2()))); + deadzoneSPD=kTRUE; + } + } + ntracks[ilayer]++; + } + + clidx=-1; + // loop over clusters in the road + while ((cl=layer.GetNextCluster(clidx))!=0) { if (ntracks[ilayer]>95) break; //space for skipped clusters - Bool_t change =kFALSE; - if (c->GetQ()==0 && (deadzone==1)) continue; - Int_t idet=c->GetDetectorIndex(); - if (currenttrack->GetDetectorIndex()!=idet) { // move track to cluster's detector + Bool_t changedet =kFALSE; + if (cl->GetQ()==0 && deadzoneSPD==kTRUE) continue; + Int_t idet=cl->GetDetectorIndex(); + + if (currenttrack->GetDetectorIndex()==idet) { // track already on the cluster's detector + // a first cut on track-cluster distance + if ( (currenttrack->GetZ()-cl->GetZ())*(currenttrack->GetZ()-cl->GetZ())*msz + + (currenttrack->GetY()-cl->GetY())*(currenttrack->GetY()-cl->GetY())*msy > 1. ) + continue; // cluster not associated to track + } else { // have to move track to cluster's detector const AliITSdetector &det=layer.GetDetector(idet); + // a first cut on track-cluster distance Double_t y,z; if (!currenttrack2.GetProlongationFast(det.GetPhi(),det.GetR(),y,z)) continue; - if ( (z-c->GetZ())*(z-c->GetZ())*msz + - (y-c->GetY())*(y-c->GetY())*msy > 1. ) + if ( (z-cl->GetZ())*(z-cl->GetZ())*msz + + (y-cl->GetY())*(y-cl->GetY())*msy > 1. ) continue; // cluster not associated to track // new (&backuptrack) AliITStrackMI(currenttrack2); - change = kTRUE; + changedet = kTRUE; currenttrack =¤ttrack2; if (!currenttrack->Propagate(det.GetPhi(),det.GetR())) { new (currenttrack) AliITStrackMI(backuptrack); - change = kFALSE; + changedet = kFALSE; continue; } currenttrack->SetDetectorIndex(idet); - } else { // track already on the cluster's detector - if ( (currenttrack->GetZ()-c->GetZ())*(currenttrack->GetZ()-c->GetZ())*msz + - (currenttrack->GetY()-c->GetY())*(currenttrack->GetY()-c->GetY())*msy > 1. ) - continue; // cluster not associated to track + // Get again the budget to the primary vertex + // for the current track being prolonged, if had to change detector + //budgetToPrimVertex = GetEffectiveThickness();// not needed at the moment because anyway we take a mean material for this correction } - chi2 = GetPredictedChi2MI(currenttrack,c,ilayer); - if (chi2 < AliITSReconstructor::GetRecoParam()->GetMaxChi2s(ilayer)) { - if (c->GetQ()==0) deadzone=1; // take dead zone only once + // calculate track-clusters chi2 + chi2trkcl = GetPredictedChi2MI(currenttrack,cl,ilayer); + // chi2 cut + if (chi2trkcl < AliITSReconstructor::GetRecoParam()->GetMaxChi2s(ilayer)) { + if (cl->GetQ()==0) deadzoneSPD=kTRUE; // only 1 prolongation with virtual cluster if (ntracks[ilayer]>=100) continue; AliITStrackMI * updatetrack = new (&tracks[ilayer][ntracks[ilayer]]) AliITStrackMI(*currenttrack); updatetrack->SetClIndex(ilayer,0); - if (change){ - new (¤ttrack2) AliITStrackMI(backuptrack); + if (changedet) new (¤ttrack2) AliITStrackMI(backuptrack); + + if (cl->GetQ()!=0) { // real cluster + if (!UpdateMI(updatetrack,cl,chi2trkcl,(ilayer<<28)+clidx)) continue; + updatetrack->SetSampledEdx(cl->GetQ(),updatetrack->GetNumberOfClusters()-1); //b.b. + modstatus = 1; // found + } else { // virtual cluster in dead zone + updatetrack->SetNDeadZone(updatetrack->GetNDeadZone()+1); + updatetrack->SetDeadZoneProbability(GetSPDDeadZoneProbability(updatetrack->GetZ(),TMath::Sqrt(updatetrack->GetSigmaZ2()))); + modstatus = 7; // holes in z in SPD } - if (c->GetQ()!=0){ - if (!UpdateMI(updatetrack,c,chi2,(ilayer<<28)+ci)) continue; - updatetrack->SetSampledEdx(c->GetQ(),updatetrack->GetNumberOfClusters()-1); //b.b. + + if (changedet) { + Float_t xlocnewdet,zlocnewdet; + LocalModuleCoord(ilayer,idet,updatetrack,xlocnewdet,zlocnewdet); // local module coords + updatetrack->SetModuleIndexInfo(ilayer,idet,modstatus,xlocnewdet,zlocnewdet); } else { - updatetrack->SetNDeadZone(updatetrack->GetNDeadZone()+1); - updatetrack->SetDeadZoneProbability(GetDeadZoneProbability(updatetrack->GetZ(),TMath::Sqrt(updatetrack->GetSigmaZ2()))); + updatetrack->SetModuleIndexInfo(ilayer,idet,modstatus,xloc,zloc); } - if (c->IsUsed()) updatetrack->IncrementNUsed(); - Double_t x0; - Double_t d=layer.GetThickness(updatetrack->GetY(),updatetrack->GetZ(),x0); - updatetrack->CorrectForMaterial(d,x0); - if (constrain) { + if (cl->IsUsed()) updatetrack->IncrementNUsed(); + + // apply correction for material of the current layer + CorrectForLayerMaterial(updatetrack,ilayer,trackGlobXYZ1,"inward"); + + if (constrain) { // apply vertex constrain updatetrack->SetConstrain(constrain); - fI = ilayer; - Double_t d=GetEffectiveThickness(0,0); //Think of this !!!! - Double_t xyz[]={GetX(),GetY(),GetZ()}; - Double_t ptfactor = 1;//AD - Double_t ers[]={GetSigmaX()*ptfactor,GetSigmaY()*ptfactor,GetSigmaZ()}; Bool_t isPrim = kTRUE; - if (ilayer<4){ - //updatetrack->fD[0] = updatetrack->GetD(GetX(),GetY()); - //updatetrack->fD[1] = updatetrack->GetZat(GetX())-GetZ(); + if (ilayer<4) { // check that it's close to the vertex updatetrack->GetDZ(GetX(),GetY(),GetZ(),updatetrack->GetDP()); //I.B. - if ( TMath::Abs(updatetrack->GetD(0)/(1.+ilayer))>0.4 || TMath::Abs(updatetrack->GetD(1)/(1.+ilayer))>0.4) isPrim=kFALSE; //AD + if (TMath::Abs(updatetrack->GetD(0)/(1.+ilayer)) > // y + AliITSReconstructor::GetRecoParam()->GetMaxDZforPrimTrk() || + TMath::Abs(updatetrack->GetD(1)/(1.+ilayer)) > // z + AliITSReconstructor::GetRecoParam()->GetMaxDZforPrimTrk()) isPrim=kFALSE; } - if (isPrim) updatetrack->Improve(d,xyz,ers); //AD + if (isPrim) updatetrack->Improve(budgetToPrimVertex,xyzVtx,ersVtx); } //apply vertex constrain ntracks[ilayer]++; - } // create new hypothesy - } // loop over possible cluster prolongation - // if (constrain&&itrack<2&¤ttrack1.fNSkipped==0 && deadzone==0){ - if (constrain&&itrack<2&¤ttrack1.GetNSkipped()==0 && deadzone==0&&ntracks[ilayer]<100){ + } // create new hypothesis + } // loop over possible prolongations + + // allow one prolongation without clusters + if (constrain && itrack<=1 && currenttrack1.GetNSkipped()==0 && deadzoneSPD==kFALSE && ntracks[ilayer]<100) { AliITStrackMI* vtrack = new (&tracks[ilayer][ntracks[ilayer]]) AliITStrackMI(currenttrack1); + // apply correction for material of the current layer + CorrectForLayerMaterial(vtrack,ilayer,trackGlobXYZ1,"inward"); vtrack->SetClIndex(ilayer,0); - fI = ilayer; - Double_t d=GetEffectiveThickness(0,0); //Think of this !!!! - Double_t xyz[]={GetX(),GetY(),GetZ()}; - Double_t ers[]={GetSigmaX(),GetSigmaY(),GetSigmaZ()}; - vtrack->Improve(d,xyz,ers); + modstatus = 3; // skipped + vtrack->SetModuleIndexInfo(ilayer,idet,modstatus,xloc,zloc); + vtrack->Improve(budgetToPrimVertex,xyzVtx,ersVtx); vtrack->IncrementNSkipped(); ntracks[ilayer]++; } - if (constrain&&itrack<1&&TMath::Abs(currenttrack1.GetTgl())>1.1){ //big theta -- for low mult. runs + // allow one prolongation without clusters for tracks with |tgl|>1.1 + if (constrain && itrack==0 && TMath::Abs(currenttrack1.GetTgl())>1.1) { //big theta - for low flux AliITStrackMI* vtrack = new (&tracks[ilayer][ntracks[ilayer]]) AliITStrackMI(currenttrack1); + // apply correction for material of the current layer + CorrectForLayerMaterial(vtrack,ilayer,trackGlobXYZ1,"inward"); vtrack->SetClIndex(ilayer,0); - fI = ilayer; - Double_t d=GetEffectiveThickness(0,0); //Think of this !!!! - Double_t xyz[]={GetX(),GetY(),GetZ()}; - Double_t ers[]={GetSigmaX(),GetSigmaY(),GetSigmaZ()}; - vtrack->Improve(d,xyz,ers); + modstatus = 3; // skipped + vtrack->SetModuleIndexInfo(ilayer,idet,modstatus,xloc,zloc); + vtrack->Improve(budgetToPrimVertex,xyzVtx,ersVtx); vtrack->SetNDeadZone(vtrack->GetNDeadZone()+1); ntracks[ilayer]++; } - } //loop over track candidates + } // loop over tracks in layer ilayer+1 + + //loop over track candidates for the current layer // // Int_t accepted=0; - Int_t golds=0; + Int_t golden=0; for (Int_t itrack=0;itrackGetMaxNormChi2ForGolden(ilayer)) golden++; if (ilayer>4) { accepted++; } else { if (constrain) { // constrain - if (normalizedchi2[itrack]GetMaxNormChi2C(ilayer)+1) accepted++; + if (normalizedchi2[itrack]GetMaxNormChi2C(ilayer)+1) + accepted++; } else { // !constrain - if (normalizedchi2[itrack]GetMaxNormChi2NonC(ilayer)+1) accepted++; + if (normalizedchi2[itrack]GetMaxNormChi2NonC(ilayer)+1) + accepted++; } } } - TMath::Sort(ntracks[ilayer],normalizedchi2,nindexes[ilayer],kFALSE); + // sort tracks by increasing normalized chi2 + TMath::Sort(ntracks[ilayer],normalizedchi2,nindexes[ilayer],kFALSE); ntracks[ilayer] = TMath::Min(accepted,7+2*ilayer); - if (ntracks[ilayer]90) ntracks[ilayer]=90; - } // endloop over layers - //printf("%d\t%d\t%d\t%d\t%d\t%d\n",ntracks[0],ntracks[1],ntracks[2],ntracks[3],ntracks[4],ntracks[5]); + } // end loop over layers + + + // + // Now select tracks to be kept + // Int_t max = constrain ? 20 : 5; + // tracks that reach layer 0 (SPD inner) for (Int_t i=0; i7.)continue; //AD + if (!constrain && track.GetNormChi2(0) > + AliITSReconstructor::GetRecoParam()->GetMaxNormChi2NonCForHypothesis()) { + continue; + } AddTrackHypothesys(new AliITStrackMI(track), esdindex); } + + // tracks that reach layer 1 (SPD outer) for (Int_t i=0;i7.)continue; //AD + if (!constrain && track.GetNormChi2(1) > + AliITSReconstructor::GetRecoParam()->GetMaxNormChi2NonCForHypothesis()) continue; if (constrain) track.IncrementNSkipped(); if (!constrain) { track.SetD(0,track.GetD(GetX(),GetY())); - track.SetNSkipped(track.GetNSkipped()+4./(4.+8.*TMath::Abs(track.GetD(0)))); //AD + track.SetNSkipped(track.GetNSkipped()+4./(4.+8.*TMath::Abs(track.GetD(0)))); if (track.GetNumberOfClusters()+track.GetNDeadZone()+track.GetNSkipped()>6) { track.SetNSkipped(6-track.GetNumberOfClusters()+track.GetNDeadZone()); } } AddTrackHypothesys(new AliITStrackMI(track), esdindex); } - - + + // tracks that reach layer 2 (SDD inner), only during non-constrained pass if (!constrain){ for (Int_t i=0;i7.)continue; //AD + if (!constrain && track.GetNormChi2(2) > + AliITSReconstructor::GetRecoParam()->GetMaxNormChi2NonCForHypothesis()) continue; if (constrain) track.SetNSkipped(track.GetNSkipped()+2); if (!constrain){ track.SetD(0,track.GetD(GetX(),GetY())); - track.SetNSkipped(track.GetNSkipped()+7./(7.+8.*TMath::Abs(track.GetD(0)))); //AD + track.SetNSkipped(track.GetNSkipped()+7./(7.+8.*TMath::Abs(track.GetD(0)))); if (track.GetNumberOfClusters()+track.GetNDeadZone()+track.GetNSkipped()>6) { track.SetNSkipped(6-track.GetNumberOfClusters()+track.GetNDeadZone()); } @@ -951,9 +1231,9 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackMI * otrack, Int_t esdin } } - if (!constrain){ + if (!constrain) { // - // register best tracks - important for V0 finder + // register best track of each layer - important for V0 finder // for (Int_t ilayer=0;ilayer<5;ilayer++){ if (ntracks[ilayer]==0) continue; @@ -1010,17 +1290,9 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackMI * otrack, Int_t esdin //vertex->SetStatus(-2); // reject V0 - not enough clusters } } - //if (nearestold>3){ - // Int_t indexlayer = (ntracks[0]>0)? 0:1; - // if (ntracks[indexlayer]>0){ - // AliITStrackMI & track= tracks[indexlayer][nindexes[indexlayer][0]]; - // if (track.GetNumberOfClusters()>4&&track.fNormChi2[indexlayer]<4){ - // vertex->SetStatus(-1); // reject V0 - clusters before - // } - // } - //} } - } + } + } //------------------------------------------------------------------------ AliITStrackerMI::AliITSlayer & AliITStrackerMI::GetLayer(Int_t layer) const @@ -1059,7 +1331,7 @@ fRoad(0){ //-------------------------------------------------------------------- //default AliITSlayer constructor //-------------------------------------------------------------------- - for (Int_t i=0; iGetZ())1) fRoad=2*fR*TMath::Sqrt(3.14/n); - if (n>1) fRoad=2*fR*TMath::Sqrt(3.14/n); + if (n>1) fRoad=2*fR*TMath::Sqrt(TMath::Pi()/n); } //------------------------------------------------------------------------ -Int_t AliITStrackerMI::AliITSlayer::InsertCluster(AliITSRecPoint *c) { +Int_t AliITStrackerMI::AliITSlayer::InsertCluster(AliITSRecPoint *cl) { //-------------------------------------------------------------------- //This function adds a cluster to this layer //-------------------------------------------------------------------- - if (fN==kMaxClusterPerLayer) { + if (fN==AliITSRecoParam::GetMaxClusterPerLayer()) { ::Error("InsertCluster","Too many clusters !\n"); return 1; } fCurrentSlice=-1; - fClusters[fN]=c; + fClusters[fN]=cl; fN++; - AliITSdetector &det=GetDetector(c->GetDetectorIndex()); - if (c->GetY()GetY()); - if (c->GetY()>det.GetYmax()) det.SetYmax(c->GetY()); - if (c->GetZ()GetZ()); - if (c->GetZ()>det.GetZmax()) det.SetZmax(c->GetZ()); + AliITSdetector &det=GetDetector(cl->GetDetectorIndex()); + if (cl->GetY()GetY()); + if (cl->GetY()>det.GetYmax()) det.SetYmax(cl->GetY()); + if (cl->GetZ()GetZ()); + if (cl->GetZ()>det.GetZmax()) det.SetZmax(cl->GetZ()); return 0; } @@ -1267,7 +1538,7 @@ void AliITStrackerMI::AliITSlayer::SortClusters() Float_t curY = fY[i]+irot*TMath::TwoPi()*fR; // slice 5 for (Int_t slice=0; slice<6;slice++){ - if (fBy5[slice][0]fZ[i+1]){ - printf("Bugg\n"); + printf("Bug\n"); } } // for (Int_t slice=0;slice<21;slice++) for (Int_t i=0;ifZ20[slice][i+1]){ - printf("Bugg\n"); + printf("Bug\n"); } } @@ -1350,10 +1621,12 @@ SelectClusters(Double_t zmin,Double_t zmax,Double_t ymin, Double_t ymax) { Double_t circle=2*TMath::Pi()*fR; fYmin = ymin; fYmax =ymax; Float_t ymiddle = (fYmin+fYmax)*0.5; - if (ymiddlefYB[1]) {fYmin-=circle; fYmax-=circle;ymiddle-=circle;} + if (ymiddlefYB[1]) { + fYmin-=circle; fYmax-=circle; ymiddle-=circle; } + // fCurrentSlice =-1; // defualt take all @@ -1401,7 +1674,7 @@ SelectClusters(Double_t zmin,Double_t zmax,Double_t ymin, Double_t ymax) { if (slice<0) slice=0; if (slice>5) slice=5; Bool_t isOK = (fYmin>fBy5[slice][0]&&fYmax= 2*TMath::Pi()) dphi -= 2*TMath::Pi(); Int_t np=Int_t(dphi*fNladders*0.5/TMath::Pi()+0.5); if (np>=fNladders) np-=fNladders; if (np<0) np+=fNladders; + Double_t dz=fZOffset-z; - Int_t nz=Int_t(dz*(fNdetectors-1)*0.5/fZOffset+0.5); + Double_t nnz = dz*(fNdetectors-1)*0.5/fZOffset+0.5; + Int_t nz = (nnz<0 ? -1 : (Int_t)nnz); if (nz>=fNdetectors) return -1; if (nz<0) return -1; return np*fNdetectors + nz; } //------------------------------------------------------------------------ -const AliITSRecPoint *AliITStrackerMI::AliITSlayer::GetNextCluster(Int_t &ci){ +const AliITSRecPoint *AliITStrackerMI::AliITSlayer::GetNextCluster(Int_t &ci,Bool_t test) +{ //-------------------------------------------------------------------- // This function returns clusters within the "window" //-------------------------------------------------------------------- - if (fCurrentSlice<0){ + if (fCurrentSlice<0) { Double_t rpi2 = 2.*fR*TMath::Pi(); for (Int_t i=fI; ifYmax) continue; if (fClusters[i]->GetQ()==0&&fSkip==2) continue; ci=i; - fI=i+1; + if (!test) fI=i+1; return fClusters[i]; } - } - else{ + } else { for (Int_t i=fI; ifYmax) continue; if (fClustersCs[i]->GetQ()==0&&fSkip==2) continue; ci=fClusterIndexCs[i]; - fI=i+1; + if (!test) fI=i+1; return fClustersCs[i]; } } @@ -1477,10 +1755,10 @@ const AliITSRecPoint *AliITStrackerMI::AliITSlayer::GetNextCluster(Int_t &ci){ Double_t AliITStrackerMI::AliITSlayer::GetThickness(Double_t y,Double_t z,Double_t &x0) const { //-------------------------------------------------------------------- - //This function returns the layer thickness at this point (units X0) + // This function returns the layer thickness at this point (units X0) //-------------------------------------------------------------------- Double_t d=0.0085; - x0=21.82; + x0=AliITSRecoParam::GetX0Air(); if (430.5) d+=dd; - //if (TMath::Abs(y-3.08)>0.45) d+=dd; - if (TMath::Abs(y-3.03)<0.10) {d+=0.014;} + if (TMath::Abs(y-3.03)<0.10) d+=0.014; } else if (30.6) d+=dd; - //if (TMath::Abs(y+0.21)>0.45) d+=dd; - if (TMath::Abs(y+0.10)<0.10) {d+=0.014;} + if (TMath::Abs(y+0.10)<0.10) d+=0.014; } return d; } //------------------------------------------------------------------------ -Double_t AliITStrackerMI::GetEffectiveThickness(Double_t y,Double_t z) const +Double_t AliITStrackerMI::GetEffectiveThickness() { //-------------------------------------------------------------------- - //Returns the thickness between the current layer and the vertex (units X0) + // Returns the thickness between the current layer and the vertex (units X0) //-------------------------------------------------------------------- - Double_t d=0.0028*3*3; //beam pipe - Double_t x0=0; + if(fUseTGeo!=0) { + if(fxOverX0Layer[0]<0) BuildMaterialLUT("Layers"); + if(fxOverX0Shield[0]<0) BuildMaterialLUT("Shields"); + if(fxOverX0Pipe<0) BuildMaterialLUT("Pipe"); + } + + // beam pipe + Double_t dPipe = (fUseTGeo==0 ? AliITSRecoParam::GetdPipe() : fxOverX0Pipe); + Double_t d=dPipe*AliITSRecoParam::GetrPipe()*AliITSRecoParam::GetrPipe(); + + // layers + Double_t x0=0; Double_t xn=fgLayers[fI].GetR(); for (Int_t i=0; i1) { - Double_t xi=9.; - d+=0.0097*xi*xi; + Double_t dshieldSPD = (fUseTGeo==0 ? AliITSRecoParam::Getdshield(0) : fxOverX0Shield[0]); + d+=dshieldSPD*AliITSRecoParam::GetrInsideShield(0)*AliITSRecoParam::GetrInsideShield(0); } - if (fI>3) { - Double_t xi=0.5*(fgLayers[3].GetR()+fgLayers[4].GetR()); - d+=0.0034*xi*xi; + Double_t dshieldSDD = (fUseTGeo==0 ? AliITSRecoParam::Getdshield(1) : fxOverX0Shield[1]); + d+=dshieldSDD*AliITSRecoParam::GetrInsideShield(1)*AliITSRecoParam::GetrInsideShield(1); } - return d/(xn*xn); } //------------------------------------------------------------------------ Int_t AliITStrackerMI::AliITSlayer::InRoad() const { - //-------------------------------------------------------------------- + //------------------------------------------------------------------- // This function returns number of clusters within the "window" //-------------------------------------------------------------------- Int_t ncl=0; @@ -1623,288 +1909,241 @@ Int_t AliITStrackerMI::AliITSlayer::InRoad() const { return ncl; } //------------------------------------------------------------------------ -Bool_t AliITStrackerMI::RefitAt(Double_t xx,AliITStrackMI *t, - const AliITStrackMI *c, Bool_t extra) { +Bool_t AliITStrackerMI::RefitAt(Double_t xx,AliITStrackMI *track, + const AliITStrackMI *clusters,Bool_t extra, Bool_t planeeff) +{ //-------------------------------------------------------------------- - // This function refits the track "t" at the position "x" using - // the clusters from "c" + // This function refits the track "track" at the position "x" using + // the clusters from "clusters" // If "extra"==kTRUE, - // the clusters from overlapped modules get attached to "t" + // the clusters from overlapped modules get attached to "track" + // If "planeff"==kTRUE, + // special approach for plane efficiency evaluation is applyed //-------------------------------------------------------------------- - Int_t index[kMaxLayer]; + + Int_t index[AliITSgeomTGeo::kNLayers]; Int_t k; - for (k=0; kGetNumberOfClusters(); + for (k=0; kGetNumberOfClusters(); for (k=0; kGetClusterIndex(k),nl=(idx&0xf0000000)>>28; - index[nl]=idx; - } - - Int_t from, to, step; - if (xx > t->GetX()) { - from=0; to=kMaxLayer; - step=+1; - } else { - from=kMaxLayer-1; to=-1; - step=-1; - } - - for (Int_t i=from; i != to; i += step) { - AliITSlayer &layer=fgLayers[i]; - Double_t r=layer.GetR(); - - { - Double_t hI=i-0.5*step; - if (TMath::Abs(hI-1.5)<0.01 || TMath::Abs(hI-3.5)<0.01) { - Double_t rs=0.5*(fgLayers[i-step].GetR() + r); - Double_t d=0.0034, x0=38.6; - if (TMath::Abs(hI-1.5)<0.01) {rs=9.; d=0.0097; x0=42;} - if (!t->PropagateTo(rs,-step*d,x0)) { - return kFALSE; - } - } - } - - // remember old position [SR, GSI 18.02.2003] - Double_t oldX=0., oldY=0., oldZ=0.; - if (t->IsStartedTimeIntegral() && step==1) { - t->GetGlobalXYZat(t->GetX(),oldX,oldY,oldZ); - } - // - - Double_t phi,z; - if (!t->GetPhiZat(r,phi,z)) return kFALSE; - - Int_t idet=layer.FindDetectorIndex(phi,z); - if (idet<0) { - return kFALSE; - } - - const AliITSdetector &det=layer.GetDetector(idet); - phi=det.GetPhi(); - if (!t->Propagate(phi,det.GetR())) { - return kFALSE; - } - t->SetDetectorIndex(idet); - - const AliITSRecPoint *cl=0; - Double_t maxchi2=1000.*AliITSReconstructor::GetRecoParam()->GetMaxChi2(); - - Int_t idx=index[i]; - if (idx>=0) { - const AliITSRecPoint *c=(AliITSRecPoint *)GetCluster(idx); - if (c){ - if (idet != c->GetDetectorIndex()) { - idet=c->GetDetectorIndex(); - const AliITSdetector &det=layer.GetDetector(idet); - if (!t->Propagate(det.GetPhi(),det.GetR())) { - return kFALSE; - } - t->SetDetectorIndex(idet); - } - //Double_t chi2=t->GetPredictedChi2(c); - Int_t layer = (idx & 0xf0000000) >> 28;; - Double_t chi2=GetPredictedChi2MI(t,c,layer); - if (chi2Update(cl,maxchi2,idx)) { - if (!UpdateMI(t,cl,maxchi2,idx)) { - return kFALSE; - } - t->SetSampledEdx(cl->GetQ(),t->GetNumberOfClusters()-1); - } - - { - Double_t x0; - Double_t d=layer.GetThickness(t->GetY(),t->GetZ(),x0); - t->CorrectForMaterial(-step*d,x0); - } - - if (extra) { //search for extra clusters - AliITStrackV2 tmp(*t); - Double_t dz=4*TMath::Sqrt(tmp.GetSigmaZ2()+AliITSReconstructor::GetRecoParam()->GetSigmaZ2(i)); - if (dz < 0.5*TMath::Abs(tmp.GetTgl())) dz=0.5*TMath::Abs(tmp.GetTgl()); - Double_t dy=4*TMath::Sqrt(t->GetSigmaY2()+AliITSReconstructor::GetRecoParam()->GetSigmaY2(i)); - if (dy < 0.5*TMath::Abs(tmp.GetSnp())) dy=0.5*TMath::Abs(tmp.GetSnp()); - Double_t zmin=t->GetZ() - dz; - Double_t zmax=t->GetZ() + dz; - Double_t ymin=t->GetY() + phi*r - dy; - Double_t ymax=t->GetY() + phi*r + dy; - layer.SelectClusters(zmin,zmax,ymin,ymax); - - const AliITSRecPoint *c=0; Int_t ci=-1,cci=-1; - Double_t maxchi2=1000.*AliITSReconstructor::GetRecoParam()->GetMaxChi2(), tolerance=0.1; - while ((c=layer.GetNextCluster(ci))!=0) { - if (idet == c->GetDetectorIndex()) continue; - - const AliITSdetector &det=layer.GetDetector(c->GetDetectorIndex()); - - if (!tmp.Propagate(det.GetPhi(),det.GetR())) continue; - - if (TMath::Abs(tmp.GetZ() - c->GetZ()) > tolerance) continue; - if (TMath::Abs(tmp.GetY() - c->GetY()) > tolerance) continue; - - Double_t chi2=tmp.GetPredictedChi2(c); - if (chi2=0) t->SetExtraCluster(i,(i<<28)+cci); - } - - // track time update [SR, GSI 17.02.2003] - if (t->IsStartedTimeIntegral() && step==1) { - Double_t newX, newY, newZ; - t->GetGlobalXYZat(t->GetX(),newX,newY,newZ); - Double_t dL2 = (oldX-newX)*(oldX-newX) + (oldY-newY)*(oldY-newY) + - (oldZ-newZ)*(oldZ-newZ); - t->AddTimeStep(TMath::Sqrt(dL2)); - } - // - + Int_t idx=clusters->GetClusterIndex(k); + Int_t ilayer=(idx&0xf0000000)>>28; + index[ilayer]=idx; } - if (!t->PropagateTo(xx,0.,0.)) return kFALSE; - return kTRUE; + return RefitAt(xx,track,index,extra,planeeff); // call the method below } //------------------------------------------------------------------------ -Bool_t -AliITStrackerMI::RefitAt(Double_t xx,AliITStrackMI *t,const Int_t *clindex) { +Bool_t AliITStrackerMI::RefitAt(Double_t xx,AliITStrackMI *track, + const Int_t *clusters,Bool_t extra, Bool_t planeeff) +{ //-------------------------------------------------------------------- - // This function refits the track "t" at the position "x" using + // This function refits the track "track" at the position "x" using // the clusters from array + // If "extra"==kTRUE, + // the clusters from overlapped modules get attached to "track" + // If "planeff"==kTRUE, + // special approach for plane efficiency evaluation is applyed //-------------------------------------------------------------------- - Int_t index[kMaxLayer]; + Int_t index[AliITSgeomTGeo::kNLayers]; Int_t k; - for (k=0; kGetD(0.,0.)); + for(innermostlayer=0; innermostlayer t->GetX()) { - from=0; to=kMaxLayer; + if (xx > track->GetX()) { + from=innermostlayer; to=AliITSgeomTGeo::GetNLayers(); step=+1; } else { - from=kMaxLayer-1; to=-1; + from=AliITSgeomTGeo::GetNLayers()-1; to=innermostlayer-1; step=-1; } + TString dir = (step>0 ? "outward" : "inward"); - for (Int_t i=from; i != to; i += step) { - AliITSlayer &layer=fgLayers[i]; + for (Int_t ilayer = from; ilayer != to; ilayer += step) { + AliITSlayer &layer=fgLayers[ilayer]; Double_t r=layer.GetR(); - if (step<0 && xx>r) break; // - { - Double_t hI=i-0.5*step; - if (TMath::Abs(hI-1.5)<0.01 || TMath::Abs(hI-3.5)<0.01) { - Double_t rs=0.5*(fgLayers[i-step].GetR() + r); - Double_t d=0.0034, x0=38.6; - if (TMath::Abs(hI-1.5)<0.01) {rs=9.; d=0.0097; x0=42;} - if (!t->PropagateTo(rs,-step*d,x0)) { - return kFALSE; - } - } - } + if (step<0 && xx>r) break; + + // material between SSD and SDD, SDD and SPD + Double_t hI=ilayer-0.5*step; + if (TMath::Abs(hI-3.5)<0.01) // SDDouter + if(!CorrectForShieldMaterial(track,"SDD",dir)) return kFALSE; + if (TMath::Abs(hI-1.5)<0.01) // SPDouter + if(!CorrectForShieldMaterial(track,"SPD",dir)) return kFALSE; // remember old position [SR, GSI 18.02.2003] Double_t oldX=0., oldY=0., oldZ=0.; - if (t->IsStartedTimeIntegral() && step==1) { - t->GetGlobalXYZat(t->GetX(),oldX,oldY,oldZ); + if (track->IsStartedTimeIntegral() && step==1) { + track->GetGlobalXYZat(track->GetX(),oldX,oldY,oldZ); } // + + Double_t oldGlobXYZ[3]; + track->GetXYZ(oldGlobXYZ); + Double_t phi,z; - if (!t->GetPhiZat(r,phi,z)) return kFALSE; + if (!track->GetPhiZat(r,phi,z)) return kFALSE; Int_t idet=layer.FindDetectorIndex(phi,z); - if (idet<0) { - return kFALSE; + + // check if we allow a prolongation without point for large-eta tracks + Int_t skip = CheckSkipLayer(track,ilayer,idet); + if (skip==2) { + // propagate to the layer radius + Double_t xToGo; track->GetLocalXat(r,xToGo); + track->AliExternalTrackParam::PropagateTo(xToGo,GetBz()); + // apply correction for material of the current layer + CorrectForLayerMaterial(track,ilayer,oldGlobXYZ,dir); + modstatus = 4; // out in z + LocalModuleCoord(ilayer,idet,track,xloc,zloc); // local module coords + track->SetModuleIndexInfo(ilayer,idet,modstatus,xloc,zloc); + // track time update [SR, GSI 17.02.2003] + if (track->IsStartedTimeIntegral() && step==1) { + Double_t newX, newY, newZ; + track->GetGlobalXYZat(track->GetX(),newX,newY,newZ); + Double_t dL2 = (oldX-newX)*(oldX-newX) + (oldY-newY)*(oldY-newY) + + (oldZ-newZ)*(oldZ-newZ); + track->AddTimeStep(TMath::Sqrt(dL2)); + } + continue; } + + if (idet<0) return kFALSE; + const AliITSdetector &det=layer.GetDetector(idet); phi=det.GetPhi(); - if (!t->Propagate(phi,det.GetR())) { - return kFALSE; - } - t->SetDetectorIndex(idet); + if (!track->Propagate(phi,det.GetR())) return kFALSE; + track->SetDetectorIndex(idet); + LocalModuleCoord(ilayer,idet,track,xloc,zloc); // local module coords - const AliITSRecPoint *cl=0; + Double_t dz,zmin,zmax; + + const AliITSRecPoint *clAcc=0; Double_t maxchi2=1000.*AliITSReconstructor::GetRecoParam()->GetMaxChi2(); - Int_t idx=index[i]; - if (idx>=0) { - const AliITSRecPoint *c=(AliITSRecPoint *)GetCluster(idx); - if (c){ - if (idet != c->GetDetectorIndex()) { - idet=c->GetDetectorIndex(); - const AliITSdetector &det=layer.GetDetector(idet); - if (!t->Propagate(det.GetPhi(),det.GetR())) { - return kFALSE; - } - t->SetDetectorIndex(idet); - } - //Double_t chi2=t->GetPredictedChi2(c); - Int_t layer = (idx & 0xf0000000) >> 28;; - Double_t chi2=GetPredictedChi2MI(t,c,layer); - if (chi2GetNumberOfClusters()>2) { - Double_t dz=4*TMath::Sqrt(t->GetSigmaZ2()+AliITSReconstructor::GetRecoParam()->GetSigmaZ2(i)); - Double_t dy=4*TMath::Sqrt(t->GetSigmaY2()+AliITSReconstructor::GetRecoParam()->GetSigmaY2(i)); - Double_t zmin=t->GetZ() - dz; - Double_t zmax=t->GetZ() + dz; - Double_t ymin=t->GetY() + phi*r - dy; - Double_t ymax=t->GetY() + phi*r + dy; - layer.SelectClusters(zmin,zmax,ymin,ymax); - - const AliITSRecPoint *c=0; Int_t ci=-1; - while ((c=layer.GetNextCluster(ci))!=0) { - if (idet != c->GetDetectorIndex()) continue; - Double_t chi2=t->GetPredictedChi2(c); - if (chi2Update(cl,maxchi2,idx)) { - if (!UpdateMI(t,cl,maxchi2,idx)) { - return kFALSE; + Int_t idx=index[ilayer]; + if (idx>=0) { // cluster in this layer + modstatus = 6; // no refit + const AliITSRecPoint *cl=(AliITSRecPoint *)GetCluster(idx); + if (cl) { + if (idet != cl->GetDetectorIndex()) { + idet=cl->GetDetectorIndex(); + const AliITSdetector &det=layer.GetDetector(idet); + if (!track->Propagate(det.GetPhi(),det.GetR())) return kFALSE; + track->SetDetectorIndex(idet); + LocalModuleCoord(ilayer,idet,track,xloc,zloc); // local module coords + } + //Double_t chi2=track->GetPredictedChi2(cl); + Int_t cllayer = (idx & 0xf0000000) >> 28;; + Double_t chi2=GetPredictedChi2MI(track,cl,cllayer); + if (chi2GetLayersToSkip(ilayer)) { + if (IsOKForPlaneEff(track,ilayer)) // only adequate track for plane eff. evaluation + UseTrackForPlaneEff(track,ilayer); + } + } else { + modstatus = 5; // no cls in road + // check dead + dz=AliITSReconstructor::GetRecoParam()->GetNSigmaRoadZ()* + TMath::Sqrt(track->GetSigmaZ2() + + AliITSReconstructor::GetRecoParam()->GetNSigmaZLayerForRoadZ()* + AliITSReconstructor::GetRecoParam()->GetNSigmaZLayerForRoadZ()* + AliITSReconstructor::GetRecoParam()->GetSigmaZ2(ilayer)); + zmin=track->GetZ() - dz; + zmax=track->GetZ() + dz; + Int_t dead = CheckDeadZone(ilayer,idet,zmin,zmax); + if (dead==1) modstatus = 7; // holes in z in SPD + if (dead==2) modstatus = 2; // dead from OCDB } - t->SetSampledEdx(cl->GetQ(),t->GetNumberOfClusters()-1); } - - { - Double_t x0; - Double_t d=layer.GetThickness(t->GetY(),t->GetZ(),x0); - t->CorrectForMaterial(-step*d,x0); + + if (clAcc) { + if (!UpdateMI(track,clAcc,maxchi2,idx)) return kFALSE; + track->SetSampledEdx(clAcc->GetQ(),track->GetNumberOfClusters()-1); } + track->SetModuleIndexInfo(ilayer,idet,modstatus,xloc,zloc); + + + if (extra) { // search for extra clusters in overlapped modules + AliITStrackV2 tmp(*track); + Double_t dy,ymin,ymax; + dz=4*TMath::Sqrt(tmp.GetSigmaZ2()+AliITSReconstructor::GetRecoParam()->GetSigmaZ2(ilayer)); + if (dz < 0.5*TMath::Abs(tmp.GetTgl())) dz=0.5*TMath::Abs(tmp.GetTgl()); + dy=4*TMath::Sqrt(track->GetSigmaY2()+AliITSReconstructor::GetRecoParam()->GetSigmaY2(ilayer)); + if (dy < 0.5*TMath::Abs(tmp.GetSnp())) dy=0.5*TMath::Abs(tmp.GetSnp()); + zmin=track->GetZ() - dz; + zmax=track->GetZ() + dz; + ymin=track->GetY() + phi*r - dy; + ymax=track->GetY() + phi*r + dy; + layer.SelectClusters(zmin,zmax,ymin,ymax); + + const AliITSRecPoint *clExtra=0; Int_t ci=-1,cci=-1; + Int_t idetExtra=-1; + Double_t maxchi2=1000.*AliITSReconstructor::GetRecoParam()->GetMaxChi2(), tolerance=0.1; + while ((clExtra=layer.GetNextCluster(ci))!=0) { + // only clusters in another module! (overlaps) + idetExtra = clExtra->GetDetectorIndex(); + if (idet == idetExtra) continue; + + const AliITSdetector &det=layer.GetDetector(idetExtra); + + if (!tmp.Propagate(det.GetPhi(),det.GetR())) continue; + + if (TMath::Abs(tmp.GetZ() - clExtra->GetZ()) > tolerance) continue; + if (TMath::Abs(tmp.GetY() - clExtra->GetY()) > tolerance) continue; + + Double_t chi2=tmp.GetPredictedChi2(clExtra); + if (chi2=0) { + track->SetExtraCluster(ilayer,(ilayer<<28)+cci); + track->SetExtraModule(ilayer,idetExtra); + } + } // end search for extra clusters in overlapped modules + + // Correct for material of the current layer + if(!CorrectForLayerMaterial(track,ilayer,oldGlobXYZ,dir)) return kFALSE; // track time update [SR, GSI 17.02.2003] - if (t->IsStartedTimeIntegral() && step==1) { + if (track->IsStartedTimeIntegral() && step==1) { Double_t newX, newY, newZ; - t->GetGlobalXYZat(t->GetX(),newX,newY,newZ); + track->GetGlobalXYZat(track->GetX(),newX,newY,newZ); Double_t dL2 = (oldX-newX)*(oldX-newX) + (oldY-newY)*(oldY-newY) + (oldZ-newZ)*(oldZ-newZ); - t->AddTimeStep(TMath::Sqrt(dL2)); + track->AddTimeStep(TMath::Sqrt(dL2)); } // - } + } // end loop on layers + + if (!track->PropagateTo(xx,0.,0.)) return kFALSE; - if (!t->PropagateTo(xx,0.,0.)) return kFALSE; return kTRUE; } //------------------------------------------------------------------------ @@ -1929,7 +2168,7 @@ Double_t AliITStrackerMI::GetNormalizedChi2(AliITStrackMI * track, Int_t mode) cerry*=cerry; cerrz*=cerrz; Float_t cchi2 = (track->GetDy(i)*track->GetDy(i)/cerry)+(track->GetDz(i)*track->GetDz(i)/cerrz); - if (i>1){ + if (i>1 && AliITSReconstructor::GetRecoParam()->GetUseAmplitudeInfo(i)) { Float_t ratio = track->GetNormQ(i)/track->GetExpQ(); if (ratio<0.5) { cchi2+=(0.5-ratio)*10.; @@ -1994,7 +2233,13 @@ Double_t AliITStrackerMI::GetNormalizedChi2(AliITStrackMI * track, Int_t mode) // Double_t match = TMath::Sqrt(track->GetChi22()); if (track->GetConstrain()) match/=track->GetNumberOfClusters(); - if (!track->GetConstrain()) match/=track->GetNumberOfClusters()-2.; + if (!track->GetConstrain()) { + if (track->GetNumberOfClusters()>2) { + match/=track->GetNumberOfClusters()-2.; + } else { + match=0; + } + } if (match<0) match=0; Float_t deadzonefactor = (track->GetNDeadZone()>0) ? 3*(1.1-track->GetDeadZoneProbability()):0.; Double_t normchi2 = 2*track->GetNSkipped()+match+deadzonefactor+(1+(2*track->GetNSkipped()+deadzonefactor)/track->GetNumberOfClusters())* @@ -2015,7 +2260,7 @@ Double_t AliITStrackerMI::GetMatchingChi2(AliITStrackMI * track1, AliITStrackMI vec(1,0)=track1->GetZ() - track3.GetZ(); vec(2,0)=track1->GetSnp() - track3.GetSnp(); vec(3,0)=track1->GetTgl() - track3.GetTgl(); - vec(4,0)=track1->Get1Pt() - track3.Get1Pt(); + vec(4,0)=track1->GetSigned1Pt() - track3.GetSigned1Pt(); // TMatrixD cov(5,5); cov(0,0) = track1->GetSigmaY2()+track3.GetSigmaY2(); @@ -2044,26 +2289,35 @@ Double_t AliITStrackerMI::GetMatchingChi2(AliITStrackMI * track1, AliITStrackMI return chi2(0,0); } //------------------------------------------------------------------------ -Double_t AliITStrackerMI::GetDeadZoneProbability(Double_t zpos, Double_t zerr) +Double_t AliITStrackerMI::GetSPDDeadZoneProbability(Double_t zpos, Double_t zerr) { // - // return probability that given point - characterized by z position and error is in dead zone + // return probability that given point (characterized by z position and error) + // is in SPD dead zone // - Double_t probability =0; + Double_t probability = 0.; Double_t absz = TMath::Abs(zpos); - Double_t nearestz = (absz<2)? 0.:7.1; - if (TMath::Abs(absz-nearestz)>0.25+3*zerr) return 0; - Double_t zmin=0, zmax=0; - if (zpos<-6.){ - zmin = -7.25; zmax = -6.95; - } - if (zpos>6){ - zmin = 7.0; zmax =7.3; - } - if (absz<2){ - zmin = -0.75; zmax = 1.5; + Double_t nearestz = (absz<2.) ? 0.5*(fSPDdetzcentre[1]+fSPDdetzcentre[2]) : + 0.5*(fSPDdetzcentre[2]+fSPDdetzcentre[3]); + if (TMath::Abs(absz-nearestz)>0.25+3.*zerr) return probability; + Double_t zmin, zmax; + if (zpos<-6.) { // dead zone at z = -7 + zmin = fSPDdetzcentre[0] + 0.5*AliITSRecoParam::GetSPDdetzlength(); + zmax = fSPDdetzcentre[1] - 0.5*AliITSRecoParam::GetSPDdetzlength(); + } else if (zpos>6.) { // dead zone at z = +7 + zmin = fSPDdetzcentre[2] + 0.5*AliITSRecoParam::GetSPDdetzlength(); + zmax = fSPDdetzcentre[3] - 0.5*AliITSRecoParam::GetSPDdetzlength(); + } else if (absz<2.) { // dead zone at z = 0 + zmin = fSPDdetzcentre[1] + 0.5*AliITSRecoParam::GetSPDdetzlength(); + zmax = fSPDdetzcentre[2] - 0.5*AliITSRecoParam::GetSPDdetzlength(); + } else { + zmin = 0.; + zmax = 0.; } - probability = (TMath::Erf((zpos-zmin)/zerr) - TMath::Erf((zpos-zmax)/zerr))*0.5; + // probability that the true z is in the range [zmin,zmax] (i.e. inside + // dead zone) + probability = 0.5*( TMath::Erf((zpos-zmin)/zerr/TMath::Sqrt(2.)) - + TMath::Erf((zpos-zmax)/zerr/TMath::Sqrt(2.)) ); return probability; } //------------------------------------------------------------------------ @@ -2120,7 +2374,7 @@ Double_t AliITStrackerMI::GetInterpolatedChi2(AliITStrackMI * forwardtrack, AliI npoints++; } if (npoints>1) return - TMath::Max(TMath::Abs(0.3*forwardtrack->Get1Pt())-0.5,0.)+ + TMath::Max(0.3*forwardtrack->OneOverPt()-0.5,0.)+ //2*forwardtrack->fNUsed+ res/TMath::Max(double(npoints-forwardtrack->GetNSkipped()), 1./(1.+forwardtrack->GetNSkipped())); @@ -2199,7 +2453,8 @@ Float_t AliITStrackerMI::GetNumberOfSharedClusters(AliITStrackMI* track,Int_t id // Float_t deltan = 0; if (l>3&&cl->GetNy()+cl->GetNz()>6) continue; - if (l>2&&track->GetNormQ(l)/track->GetExpQ()>3.5) continue; + if (l>2&&AliITSReconstructor::GetRecoParam()->GetUseAmplitudeInfo(l)) + if (track->GetNormQ(l)/track->GetExpQ()>3.5) continue; if (l<2 || l>3){ deltan = (cl->GetNy()+cl->GetNz()-ny[l]-nz[l]); } @@ -2249,7 +2504,8 @@ Int_t AliITStrackerMI::GetOverlapTrack(AliITStrackMI *track, Int_t trackID, Int_ // Float_t deltan = 0; if (l>3&&cl->GetNy()+cl->GetNz()>6) continue; - if (l>2&&track->GetNormQ(l)/track->GetExpQ()>3.5) continue; + if (l>2&&AliITSReconstructor::GetRecoParam()->GetUseAmplitudeInfo(l)) + if (track->GetNormQ(l)/track->GetExpQ()>3.5) continue; if (l<2 || l>3){ deltan = (cl->GetNy()+cl->GetNz()-ny[l]-nz[l]); } @@ -2344,7 +2600,7 @@ AliITStrackMI * AliITStrackerMI::GetBest2Tracks(Int_t trackID1, Int_t trackID2, // AliITStrackMI * track10=(AliITStrackMI*) arr1->UncheckedAt(0); AliITStrackMI * track20=(AliITStrackMI*) arr2->UncheckedAt(0); - if (TMath::Abs(1./track10->Get1Pt())>0.5+TMath::Abs(1/track20->Get1Pt())) return track10; + if (track10->Pt()>0.5+track20->Pt()) return track10; for (Int_t itrack=0;itrackUncheckedAt(itrack); @@ -2407,11 +2663,11 @@ AliITStrackMI * AliITStrackerMI::GetBest2Tracks(Int_t trackID1, Int_t trackID2, // w1 = (d2/(d1+d2)+ 2*s2/(s1+s2)+ +s2/(s1+s2)*0.5*(chi22+2.)/(chi21+chi22+4.) - +1.*TMath::Abs(1./track10->Get1Pt())/(TMath::Abs(1./track10->Get1Pt())+TMath::Abs(1./track20->Get1Pt())) + +1.*track10->Pt()/(track10->Pt()+track20->Pt()) ); w2 = (d1/(d1+d2)+ 2*s1/(s1+s2)+ s1/(s1+s2)*0.5*(chi21+2.)/(chi21+chi22+4.) - +1.*TMath::Abs(1./track20->Get1Pt())/(TMath::Abs(1./track10->Get1Pt())+TMath::Abs(1./track20->Get1Pt())) + +1.*track20->Pt()/(track10->Pt()+track20->Pt()) ); Double_t sumw = w1+w2; @@ -2600,7 +2856,8 @@ void AliITStrackerMI::AddTrackHypothesys(AliITStrackMI * track, Int_t esdindex) // add track to the list of hypothesys //------------------------------------------------------------------ - if (esdindex>=fTrackHypothesys.GetEntriesFast()) fTrackHypothesys.Expand(esdindex*2+10); + if (esdindex>=fTrackHypothesys.GetEntriesFast()) + fTrackHypothesys.Expand(TMath::Max(fTrackHypothesys.GetSize(),esdindex*2+10)); // TObjArray * array = (TObjArray*) fTrackHypothesys.At(esdindex); if (!array) { @@ -2793,8 +3050,8 @@ AliITStrackMI * AliITStrackerMI::GetBestHypothesys(Int_t esdindex, AliITStrackMI // AliITStrackMI * backtrack = new AliITStrackMI(*original); AliITStrackMI * forwardtrack = new AliITStrackMI(*original); - Double_t xyzv[]={GetX(),GetY(),GetZ()}; - Double_t ersv[]={GetSigmaX()/3.,GetSigmaY()/3.,GetSigmaZ()/3.}; + Double_t xyzVtx[]={GetX(),GetY(),GetZ()}; + Double_t ersVtx[]={GetSigmaX()/3.,GetSigmaY()/3.,GetSigmaZ()/3.}; // for (Int_t i=0;iAt(i); @@ -2810,16 +3067,10 @@ AliITStrackMI * AliITStrackerMI::GetBestHypothesys(Int_t esdindex, AliITStrackMI // // backtrack backtrack = new(backtrack) AliITStrackMI(*track); - if (track->GetConstrain()){ - if (!backtrack->PropagateTo(3.,0.0028,65.19)) continue; - if (!backtrack->Improve(0,xyzv,ersv)) continue; - //if (!backtrack->PropagateTo(2.,0.0028,0)) continue; // This - //if (!backtrack->Improve(0,xyzv,ersv)) continue; // is - //if (!backtrack->PropagateTo(1.,0.0028,0)) continue; // an over-kill - //if (!backtrack->Improve(0,xyzv,ersv)) continue; // (I.B.) - //if (!backtrack->PropagateToVertex()) continue; // + if (track->GetConstrain()) { + if (!CorrectForPipeMaterial(backtrack,"inward")) continue; + if (!backtrack->Improve(0,xyzVtx,ersVtx)) continue; backtrack->ResetCovariance(10.); - //if (!backtrack->Improve(0,xyzv,ersv)) continue; }else{ backtrack->ResetCovariance(10.); } @@ -2839,8 +3090,6 @@ AliITStrackMI * AliITStrackerMI::GetBestHypothesys(Int_t esdindex, AliITStrackMI if (!(track->GetConstrain())&&track->GetChi2MIP(1)>AliITSReconstructor::GetRecoParam()->GetMaxChi2PerCluster(1)) continue; - Bool_t isOK=kTRUE; - if(!isOK) continue; // //forward track - without constraint forwardtrack = new(forwardtrack) AliITStrackMI(*original); @@ -2889,7 +3138,8 @@ AliITStrackMI * AliITStrackerMI::GetBestHypothesys(Int_t esdindex, AliITStrackMI delete forwardtrack; Int_t accepted=0; for (Int_t i=0;iAt(i); + AliITStrackMI * track = (AliITStrackMI*)array->At(i); + if (!track) continue; if (accepted>checkmax || track->GetChi2MIP(3)>AliITSReconstructor::GetRecoParam()->GetMaxChi2PerCluster(3)*6. || @@ -2907,6 +3157,7 @@ AliITStrackMI * AliITStrackerMI::GetBestHypothesys(Int_t esdindex, AliITStrackMI // array->Compress(); SortTrackHypothesys(esdindex,checkmax,1); + array = (TObjArray*) fTrackHypothesys.At(esdindex); if (!array) return 0; // PH What can be the reason? Check SortTrackHypothesys besttrack = (AliITStrackMI*)array->At(0); @@ -2917,7 +3168,7 @@ AliITStrackMI * AliITStrackerMI::GetBestHypothesys(Int_t esdindex, AliITStrackMI AliITStrackMI *longtrack =0; minchi2 =1000; Float_t minn=besttrack->GetNumberOfClusters()+besttrack->GetNDeadZone(); - for (Int_t itrack=entries-1;itrack>0;itrack--){ + for (Int_t itrack=entries-1;itrack>0;itrack--) { AliITStrackMI * track = (AliITStrackMI*)array->At(itrack); if (!track->GetConstrain()) continue; if (track->GetNumberOfClusters()+track->GetNDeadZone()3&&c->GetNy()+c->GetNz()>6) continue; if ( (c->GetNy()+c->GetNz() )> ny[i]+nz[i]+0.7) continue; //shared track if ( c->GetNz()> nz[i]+0.7) continue; //shared track - if ( ilayer>2&& besttrack->GetNormQ(ilayer)/besttrack->GetExpQ()>1.5) continue; + if ( ilayer>2&& AliITSReconstructor::GetRecoParam()->GetUseAmplitudeInfo(ilayer)) + if (besttrack->GetNormQ(ilayer)/besttrack->GetExpQ()>1.5) continue; //if ( c->GetNy()> ny[i]+0.7) continue; //shared track Bool_t cansign = kTRUE; @@ -3040,7 +3292,7 @@ void AliITStrackerMI::GetBestHypothesysMIP(TObjArray &itsTracks) if (!longtrack) {longtrack = besttrack;} else besttrack= longtrack; // - if (besttrack){ + if (besttrack) { Int_t list[6]; AliITSRecPoint * clist[6]; Float_t shared = GetNumberOfSharedClusters(longtrack,i,list,clist); @@ -3048,30 +3300,25 @@ void AliITStrackerMI::GetBestHypothesysMIP(TObjArray &itsTracks) track->SetNUsed(shared); track->SetNSkipped(besttrack->GetNSkipped()); track->SetChi2MIP(0,besttrack->GetChi2MIP(0)); - if (shared>0){ + if (shared>0) { + if(!AliITSReconstructor::GetRecoParam()->GetAllowSharedClusters()) continue; Int_t nshared; Int_t overlist[6]; // Int_t sharedtrack = GetOverlapTrack(longtrack, i, nshared, list, overlist); //if (sharedtrack==-1) sharedtrack=0; - if (sharedtrack>=0){ + if (sharedtrack>=0) { besttrack = GetBest2Tracks(i,sharedtrack,10,5.5); } } - if (besttrack&&fAfterV0){ + if (besttrack&&fAfterV0) { UpdateESDtrack(besttrack,AliESDtrack::kITSin); } if (besttrack&&fConstraint[fPass]) UpdateESDtrack(besttrack,AliESDtrack::kITSin); - //if (besttrack&&besttrack->fConstrain) - // UpdateESDtrack(besttrack,AliESDtrack::kITSin); - if (besttrack->GetChi2MIP(0)+besttrack->GetNUsed()>1.5){ - if ( (TMath::Abs(besttrack->GetD(0))>0.1) && fConstraint[fPass]) { - track->SetReconstructed(kFALSE); - } - if ( (TMath::Abs(besttrack->GetD(1))>0.1) && fConstraint[fPass]){ - track->SetReconstructed(kFALSE); - } + if (besttrack->GetChi2MIP(0)+besttrack->GetNUsed()>1.5 && fConstraint[fPass]) { + if ( TMath::Abs(besttrack->GetD(0))>0.1 || + TMath::Abs(besttrack->GetD(1))>0.1 ) track->SetReconstructed(kFALSE); } } @@ -3100,7 +3347,9 @@ void AliITStrackerMI::CookLabel(AliITStrackMI *track,Float_t wrong) const { track->SetChi2MIP(9,track->GetChi2MIP(9)+isWrong*(2<SetFakeRatio(double(nwrong)/double(track->GetNumberOfClusters())); + Int_t nclusters = track->GetNumberOfClusters(); + if (nclusters > 0) //PH Some tracks don't have any cluster + track->SetFakeRatio(double(nwrong)/double(nclusters)); if (tpcLabel>0){ if (track->GetFakeRatio()>wrong) track->SetLabel(-tpcLabel); else @@ -3158,12 +3407,12 @@ void AliITStrackerMI::CookdEdx(AliITStrackMI* track) track->SetdEdx(sumamp/sumweight); } //------------------------------------------------------------------------ -void AliITStrackerMI::MakeCoeficients(Int_t ntracks){ +void AliITStrackerMI::MakeCoefficients(Int_t ntracks){ // // - if (fCoeficients) delete []fCoeficients; - fCoeficients = new Float_t[ntracks*48]; - for (Int_t i=0;iGetTgl(); Float_t phi = track->GetSnp(); phi = TMath::Sqrt(phi*phi/(1.-phi*phi)); - GetError(layer,cluster,theta,phi,track->GetExpQ(),erry,errz); + AliITSClusterParam::GetError(layer,cluster,theta,phi,track->GetExpQ(),erry,errz); Double_t chi2 = track->GetPredictedChi2MI(cluster->GetY(),cluster->GetZ(),erry,errz); Float_t ny,nz; - GetNTeor(layer,cluster, theta,phi,ny,nz); + AliITSClusterParam::GetNTeor(layer,cluster,theta,phi,ny,nz); Double_t delta = cluster->GetNy()+cluster->GetNz()-nz-ny; if (delta>1){ chi2+=0.5*TMath::Min(delta/2,2.); @@ -3194,221 +3443,51 @@ Double_t AliITStrackerMI::GetPredictedChi2MI(AliITStrackMI* track, const AliITSR return chi2; } - -Int_t AliITStrackerMI::UpdateMI(AliITStrackMI* track, const AliITSRecPoint* cl,Double_t chi2,Int_t index) const +//------------------------------------------------------------------------ +Int_t AliITStrackerMI::UpdateMI(AliITStrackMI* track, const AliITSRecPoint* cl,Double_t chi2,Int_t index) const { // // // Int_t layer = (index & 0xf0000000) >> 28; track->SetClIndex(layer, index); - if ( (layer>1) &&track->GetNormQ(layer)/track->GetExpQ()<0.5 ) { - chi2+= (0.5-track->GetNormQ(layer)/track->GetExpQ())*10.; - track->SetdEdxMismatch(track->GetdEdxMismatch()+(0.5-track->GetNormQ(layer)/track->GetExpQ())*10.); + if (layer>1&&AliITSReconstructor::GetRecoParam()->GetUseAmplitudeInfo(layer)) { + if (track->GetNormQ(layer)/track->GetExpQ()<0.5 ) { + chi2+= (0.5-track->GetNormQ(layer)/track->GetExpQ())*10.; + track->SetdEdxMismatch(track->GetdEdxMismatch()+(0.5-track->GetNormQ(layer)/track->GetExpQ())*10.); + } } if (cl->GetQ()<=0) return 0; // ingore the "virtual" clusters + // Float_t clxyz[3]; cl->GetGlobalXYZ(clxyz);Double_t trxyz[3]; track->GetXYZ(trxyz);//printf("gtr %f %f %f\n",trxyz[0],trxyz[1],trxyz[2]);printf("gcl %f %f %f\n",clxyz[0],clxyz[1],clxyz[2]); + + // Take into account the mis-alignment Double_t x=track->GetX()+cl->GetX(); if (!track->PropagateTo(x,0.,0.)) return 0; - - return track->UpdateMI(cl->GetY(),cl->GetZ(),track->GetSigmaY(layer),track->GetSigmaZ(layer),chi2,index); -} - -void AliITStrackerMI::GetNTeor(Int_t layer, const AliITSRecPoint* /*cl*/, Float_t theta, Float_t phi, Float_t &ny, Float_t &nz) -{ - // - //get "mean shape" - // - if (layer==0){ - ny = 1.+TMath::Abs(phi)*3.2; - nz = 1.+TMath::Abs(theta)*0.34; - return; - } - if (layer==1){ - ny = 1.+TMath::Abs(phi)*3.2; - nz = 1.+TMath::Abs(theta)*0.28; - return; - } - - if (layer>3){ - ny = 2.02+TMath::Abs(phi)*1.95; - nz = 2.02+TMath::Abs(phi)*2.35; - return; - } - ny = 6.6-2.7*TMath::Abs(phi); - nz = 2.8-3.11*TMath::Abs(phi)+0.45*TMath::Abs(theta); -} - - - -Int_t AliITStrackerMI::GetError(Int_t layer, const AliITSRecPoint*cl, Float_t theta, Float_t phi,Float_t expQ, Float_t &erry, Float_t &errz) -{ - //calculate cluster position error - // - Float_t nz,ny; - GetNTeor(layer, cl,theta,phi,ny,nz); - erry = TMath::Sqrt(cl->GetSigmaY2()); - errz = TMath::Sqrt(cl->GetSigmaZ2()); - // - // PIXELS - if (layer<2){ - - if (TMath::Abs(ny-cl->GetNy())>0.6) { - if (nyGetNy()){ - erry*=0.4+TMath::Abs(ny-cl->GetNy()); - errz*=0.4+TMath::Abs(ny-cl->GetNy()); - }else{ - erry*=0.7+0.5*TMath::Abs(ny-cl->GetNy()); - errz*=0.7+0.5*TMath::Abs(ny-cl->GetNy()); - } - } - if (TMath::Abs(nz-cl->GetNz())>1.) { - erry*=TMath::Abs(nz-cl->GetNz()); - errz*=TMath::Abs(nz-cl->GetNz()); - } - erry*=0.85; - errz*=0.85; - erry= TMath::Min(erry,float(0.005)); - errz= TMath::Min(errz,float(0.03)); - return 10; - } - -//STRIPS - if (layer>3){ - //factor 1.8 appears in new simulation - // - Float_t scale=1.8; - if (cl->GetNy()==100||cl->GetNz()==100){ - erry = 0.004*scale; - errz = 0.2*scale; - return 100; - } - if (cl->GetNy()+cl->GetNz()>12){ - erry = 0.06*scale; - errz = 0.57*scale; - return 100; - } - Float_t normq = cl->GetQ()/(TMath::Sqrt(1+theta*theta+phi*phi)); - Float_t chargematch = TMath::Max(double(normq/expQ),2.); - // - if (cl->GetType()==1 || cl->GetType()==10 ){ - if (chargematch<1.0 || (cl->GetNy()+cl->GetNz()GetNy()+cl->GetNz()GetNy()+cl->GetNz()-nz+ny),0.15)*scale; - return 103; - } - if (cl->GetType()==2 || cl->GetType()==11 ){ - erry = TMath::Min(0.0010*(1+chargematch+cl->GetNy()+cl->GetNz()-nz+ny),0.05)*scale; - errz = TMath::Min(0.025*(1+chargematch+cl->GetNy()+cl->GetNz()-nz+ny),0.5)*scale; - return 104; - } - - if (cl->GetType()>100 ){ - if ((chargematch+cl->GetNy()+cl->GetNz()-nz-ny<1.5)){ - errz = 0.05*scale; - erry = 0.00096*scale; - return 105; - } - if (cl->GetNy()+cl->GetNz()-nz-ny<1){ - errz = 0.10*scale; - erry = 0.0025*scale; - return 106; - } - errz = TMath::Min(0.05*(chargematch+cl->GetNy()+cl->GetNz()-nz-ny),0.4)*scale; - erry = TMath::Min(0.003*(chargematch+cl->GetNy()+cl->GetNz()-nz-ny),0.05)*scale; - return 107; - } - Float_t diff = cl->GetNy()+cl->GetNz()-ny-nz; - if (diff<1) diff=1; - if (diff>4) diff=4; - - if (cl->GetType()==5||cl->GetType()==6||cl->GetType()==7||cl->GetType()==8){ - errz = 0.14*diff; - erry = 0.003*diff; - return 108; - } - erry = 0.04*diff; - errz = 0.06*diff; - return 109; - } - //DRIFTS - Float_t normq = cl->GetQ()/(TMath::Sqrt(1+theta*theta+phi*phi)); - Float_t chargematch = normq/expQ; - Float_t factorz=1; - Int_t cnz = cl->GetNz()%10; - //charge match - if (cl->GetType()==1){ - if (chargematch<1.25){ - erry = 0.0028*(1.+6./cl->GetQ()); // gold clusters - } - else{ - erry = 0.003*chargematch; - if (cl->GetNz()==3) erry*=1.5; - } - if (chargematch<1.0){ - errz = 0.0011*(1.+6./cl->GetQ()); - } - else{ - errz = 0.002*(1+2*(chargematch-1.)); - } - if (cnz>nz+0.6) { - erry*=(cnz-nz+0.5); - errz*=1.4*(cnz-nz+0.5); - } - } - if (cl->GetType()>1){ - if (chargematch<1){ - erry = 0.00385*(1.+6./cl->GetQ()); // gold clusters - errz = 0.0016*(1.+6./cl->GetQ()); - } - else{ - errz = 0.0014*(1+3*(chargematch-1.)); - erry = 0.003*(1+3*(chargematch-1.)); - } - if (cnz>nz+0.6) { - erry*=(cnz-nz+0.5); - errz*=1.4*(cnz-nz+0.5); - } - } - if (TMath::Abs(cl->GetY())>2.5){ - factorz*=1+2*(TMath::Abs(cl->GetY())-2.5); - } - if (TMath::Abs(cl->GetY())<1){ - factorz*=1.+0.5*TMath::Abs(TMath::Abs(cl->GetY())-1.); - } - factorz= TMath::Min(factorz,float(4.)); - errz*=factorz; + + AliCluster c(*cl); + c.SetSigmaY2(track->GetSigmaY(layer)*track->GetSigmaY(layer)); + c.SetSigmaZ2(track->GetSigmaZ(layer)*track->GetSigmaZ(layer)); - erry= TMath::Min(erry,float(0.05)); - errz= TMath::Min(errz,float(0.05)); - return 200; + return track->UpdateMI(&c,chi2,index); } + //------------------------------------------------------------------------ -void AliITStrackerMI::GetDCASigma(AliITStrackMI* track, Float_t & sigmarfi, Float_t &sigmaz) +void AliITStrackerMI::GetDCASigma(AliITStrackMI* track, Float_t & sigmarfi, Float_t &sigmaz) { // //DCA sigmas parameterization //to be paramterized using external parameters in future // // - sigmarfi = 0.004+1.4 *TMath::Abs(track->GetC())+332.*track->GetC()*track->GetC(); - sigmaz = 0.011+4.37*TMath::Abs(track->GetC()); + sigmarfi = 0.0040+1.4 *TMath::Abs(track->GetC())+332.*track->GetC()*track->GetC(); + sigmaz = 0.0110+4.37*TMath::Abs(track->GetC()); } - - +//------------------------------------------------------------------------ void AliITStrackerMI::SignDeltas( TObjArray *ClusterArray, Float_t vz) { // @@ -3493,7 +3572,7 @@ void AliITStrackerMI::UpdateESDtrack(AliITStrackMI* track, ULong_t flags) const //------------------------------------------------------------------------ Int_t AliITStrackerMI::GetNearestLayer(const Double_t *xr) const{ // - //Get nearest upper layer close to the point xr. + // Get nearest upper layer close to the point xr. // rough approximation // const Float_t kRadiuses[6]={4,6.5,15.03,24.,38.5,43.7}; @@ -3619,7 +3698,7 @@ void AliITStrackerMI::UpdateTPCV0(AliESDEvent *event){ // } //------------------------------------------------------------------------ -void AliITStrackerMI::FindV02(AliESDEvent *event) +void AliITStrackerMI::FindV02(AliESDEvent *event) { // // V0 finder @@ -3674,7 +3753,7 @@ void AliITStrackerMI::FindV02(AliESDEvent *event) // Float_t primvertex[3]={GetX(),GetY(),GetZ()}; // - // make its - esd map + // make ITS - ESD map // for (Int_t itrack=0;itrack=0) continue; @@ -3700,7 +3779,7 @@ void AliITStrackerMI::FindV02(AliESDEvent *event) if (tpctrack->GetD(0)<20 && tpctrack->GetD(1)<20){ // tracks which can reach inner part of ITS // propagate track to outer its volume - with correction for material - CorrectForDeadZoneMaterial(tpctrack); + CorrectForTPCtoITSDeadZoneMaterial(tpctrack); } itsmap[itrack] = nitstracks; fOriginal.AddAt(tpctrack,nitstracks); @@ -3971,11 +4050,15 @@ void AliITStrackerMI::FindV02(AliESDEvent *event) // // TObjArray * array0b = (TObjArray*)fBestHypothesys.At(itrack0); - if (!array0b&&pvertex->GetRr()<40 && TMath::Abs(track0->GetTgl())<1.1) + if (!array0b&&pvertex->GetRr()<40 && TMath::Abs(track0->GetTgl())<1.1) { + fCurrentEsdTrack = itrack0; FollowProlongationTree((AliITStrackMI*)fOriginal.At(itrack0),itrack0, kFALSE); + } TObjArray * array1b = (TObjArray*)fBestHypothesys.At(itrack1); - if (!array1b&&pvertex->GetRr()<40 && TMath::Abs(track1->GetTgl())<1.1) + if (!array1b&&pvertex->GetRr()<40 && TMath::Abs(track1->GetTgl())<1.1) { + fCurrentEsdTrack = itrack1; FollowProlongationTree((AliITStrackMI*)fOriginal.At(itrack1),itrack1, kFALSE); + } // AliITStrackMI * track0b = (AliITStrackMI*)fOriginal.At(itrack0); AliITStrackMI * track1b = (AliITStrackMI*)fOriginal.At(itrack1); @@ -4137,8 +4220,8 @@ void AliITStrackerMI::FindV02(AliESDEvent *event) pvertex->SetNBefore(maxLayer); } if (pvertex->GetRr()<90){ - pa0 *= TMath::Min(track0->GetESDtrack()->GetTPCdensity(0,60),Float_t(1.)); - pa1 *= TMath::Min(track1->GetESDtrack()->GetTPCdensity(0,60),Float_t(1.)); + pa0 *= TMath::Min(track0->GetESDtrack()->GetTPCdensity(0,60),Double_t(1.)); + pa1 *= TMath::Min(track1->GetESDtrack()->GetTPCdensity(0,60),Double_t(1.)); } if (pvertex->GetRr()<20){ pa0 *= (0.2+TMath::Exp(-TMath::Min(minchi2after0,Float_t(16))/8.))/1.2; @@ -4157,8 +4240,8 @@ void AliITStrackerMI::FindV02(AliESDEvent *event) Float_t sigmap = 0.5*sigmap0*(0.6+0.4*p12); // "resolution: of point angle - as a function of radius and momenta Float_t causalityA = (1.0-pvertex->GetCausalityP()[0])*(1.0-pvertex->GetCausalityP()[1]); - Float_t causalityB = TMath::Sqrt(TMath::Min(pvertex->GetCausalityP()[2],Float_t(0.7))* - TMath::Min(pvertex->GetCausalityP()[3],Float_t(0.7))); + Float_t causalityB = TMath::Sqrt(TMath::Min(pvertex->GetCausalityP()[2],Double_t(0.7))* + TMath::Min(pvertex->GetCausalityP()[3],Double_t(0.7))); // //Bo: Float_t likelihood0 = (TMath::Exp(-pvertex->GetDistNorm())+0.1) *(pvertex->GetDist2()<0.5)*(pvertex->GetDistNorm()<5); Float_t lDistNorm = pvertex->GetDcaV0Daughters()/pvertex->GetDistSigma(); @@ -4226,6 +4309,7 @@ void AliITStrackerMI::FindV02(AliESDEvent *event) // // delete temporary arrays // + delete[] forbidden; delete[] minPointAngle; delete[] maxr; delete[] minr; @@ -4282,8 +4366,8 @@ void AliITStrackerMI::RefitV02(AliESDEvent *event) continue; } if (v0mi->GetRr()>35){ - CorrectForDeadZoneMaterial(&tpc0); - CorrectForDeadZoneMaterial(&tpc1); + CorrectForTPCtoITSDeadZoneMaterial(&tpc0); + CorrectForTPCtoITSDeadZoneMaterial(&tpc1); if (tpc0.Propagate(alpha,v0mi->GetRr())&&tpc1.Propagate(alpha,v0mi->GetRr())){ v0temp.SetParamN(tpc0); v0temp.SetParamP(tpc1); @@ -4303,8 +4387,8 @@ void AliITStrackerMI::RefitV02(AliESDEvent *event) } continue; } - CorrectForDeadZoneMaterial(&tpc0); - CorrectForDeadZoneMaterial(&tpc1); + CorrectForTPCtoITSDeadZoneMaterial(&tpc0); + CorrectForTPCtoITSDeadZoneMaterial(&tpc1); // if (tpc0.Propagate(alpha,v0mi->GetRr())&&tpc1.Propagate(alpha,v0mi->GetRr())){ if (RefitAt(v0mi->GetRr(),&tpc0, v0mi->GetClusters(0)) && RefitAt(v0mi->GetRr(),&tpc1, v0mi->GetClusters(1))){ v0temp.SetParamN(tpc0); @@ -4326,10 +4410,800 @@ void AliITStrackerMI::RefitV02(AliESDEvent *event) } } //------------------------------------------------------------------------ +void AliITStrackerMI::BuildMaterialLUT(TString material) { + //-------------------------------------------------------------------- + // Fill a look-up table with mean material + //-------------------------------------------------------------------- + + Int_t n=1000; + Double_t mparam[7]; + Double_t point1[3],point2[3]; + Double_t phi,cosphi,sinphi,z; + // 0-5 layers, 6 pipe, 7-8 shields + Double_t rmin[9]={ 3.5, 5.5,13.0,22.0,35.0,41.0, 2.0, 7.5,25.0}; + Double_t rmax[9]={ 5.5, 7.3,17.0,26.0,41.0,47.0, 3.0,10.5,30.0}; + + Int_t ifirst=0,ilast=0; + if(material.Contains("Pipe")) { + ifirst=6; ilast=6; + } else if(material.Contains("Shields")) { + ifirst=7; ilast=8; + } else if(material.Contains("Layers")) { + ifirst=0; ilast=5; + } else { + Error("BuildMaterialLUT","Wrong layer name\n"); + } + + for(Int_t imat=ifirst; imat<=ilast; imat++) { + Double_t param[5]={0.,0.,0.,0.,0.}; + for (Int_t i=0; iRndm(); + cosphi = TMath::Cos(phi); sinphi = TMath::Sin(phi); + z = 14.*(-1.+2.*gRandom->Rndm()); // SPD barrel + point1[0] = rmin[imat]*cosphi; + point1[1] = rmin[imat]*sinphi; + point1[2] = z; + point2[0] = rmax[imat]*cosphi; + point2[1] = rmax[imat]*sinphi; + point2[2] = z; + AliTracker::MeanMaterialBudget(point1,point2,mparam); + for(Int_t j=0;j<5;j++) param[j]+=mparam[j]; + } + for(Int_t j=0;j<5;j++) param[j]/=(Float_t)n; + if(imat<=5) { + fxOverX0Layer[imat] = param[1]; + fxTimesRhoLayer[imat] = param[0]*param[4]; + } else if(imat==6) { + fxOverX0Pipe = param[1]; + fxTimesRhoPipe = param[0]*param[4]; + } else if(imat==7) { + fxOverX0Shield[0] = param[1]; + fxTimesRhoShield[0] = param[0]*param[4]; + } else if(imat==8) { + fxOverX0Shield[1] = param[1]; + fxTimesRhoShield[1] = param[0]*param[4]; + } + } + /* + printf("%s\n",material.Data()); + printf("%f %f\n",fxOverX0Pipe,fxTimesRhoPipe); + printf("%f %f\n",fxOverX0Shield[0],fxTimesRhoShield[0]); + printf("%f %f\n",fxOverX0Shield[1],fxTimesRhoShield[1]); + printf("%f %f\n",fxOverX0Layer[0],fxTimesRhoLayer[0]); + printf("%f %f\n",fxOverX0Layer[1],fxTimesRhoLayer[1]); + printf("%f %f\n",fxOverX0Layer[2],fxTimesRhoLayer[2]); + printf("%f %f\n",fxOverX0Layer[3],fxTimesRhoLayer[3]); + printf("%f %f\n",fxOverX0Layer[4],fxTimesRhoLayer[4]); + printf("%f %f\n",fxOverX0Layer[5],fxTimesRhoLayer[5]); + */ + return; +} +//------------------------------------------------------------------------ +Int_t AliITStrackerMI::CorrectForPipeMaterial(AliITStrackMI *t, + TString direction) { + //------------------------------------------------------------------- + // Propagate beyond beam pipe and correct for material + // (material budget in different ways according to fUseTGeo value) + //------------------------------------------------------------------- + + // Define budget mode: + // 0: material from AliITSRecoParam (hard coded) + // 1: material from TGeo (on the fly) + // 2: material from lut + // 3: material from TGeo (same for all hypotheses) + Int_t mode; + switch(fUseTGeo) { + case 0: + mode=0; + break; + case 1: + mode=1; + break; + case 2: + mode=2; + break; + case 3: + if(fTrackingPhase.Contains("Clusters2Tracks")) + { mode=3; } else { mode=1; } + break; + case 4: + if(fTrackingPhase.Contains("Clusters2Tracks")) + { mode=3; } else { mode=2; } + break; + default: + mode=0; + break; + } + if(fTrackingPhase.Contains("Default")) mode=0; + Int_t index=fCurrentEsdTrack; + Float_t dir = (direction.Contains("inward") ? 1. : -1.); + Double_t rToGo=(dir>0 ? AliITSRecoParam::GetrInsidePipe() : AliITSRecoParam::GetrOutsidePipe()); + Double_t xToGo; t->GetLocalXat(rToGo,xToGo); + Double_t xOverX0,x0,lengthTimesMeanDensity; + Bool_t anglecorr=kTRUE; + switch(mode) { + case 0: + xOverX0 = AliITSRecoParam::GetdPipe(); + x0 = AliITSRecoParam::GetX0Be(); + lengthTimesMeanDensity = xOverX0*x0; + break; + case 1: + if (!t->PropagateToTGeo(xToGo,1)) return 0; + return 1; + break; + case 2: + if(fxOverX0Pipe<0) BuildMaterialLUT("Pipe"); + xOverX0 = fxOverX0Pipe; + lengthTimesMeanDensity = fxTimesRhoPipe; + break; + case 3: + if(!fxOverX0PipeTrks || index<0 || index>=fNtracks) Error("CorrectForPipeMaterial","Incorrect usage of UseTGeo option!\n"); + if(fxOverX0PipeTrks[index]<0) { + if (!t->PropagateToTGeo(xToGo,1,xOverX0,lengthTimesMeanDensity)) return 0; + Double_t angle=TMath::Sqrt((1.+t->GetTgl()*t->GetTgl())/ + (1.-t->GetSnp()*t->GetSnp())); + fxOverX0PipeTrks[index] = TMath::Abs(xOverX0)/angle; + fxTimesRhoPipeTrks[index] = TMath::Abs(lengthTimesMeanDensity)/angle; + return 1; + } + xOverX0 = fxOverX0PipeTrks[index]; + lengthTimesMeanDensity = fxTimesRhoPipeTrks[index]; + break; + } + + lengthTimesMeanDensity *= dir; + if (!t->AliExternalTrackParam::PropagateTo(xToGo,GetBz())) return 0; + if (!t->CorrectForMeanMaterial(xOverX0,lengthTimesMeanDensity,anglecorr)) return 0; + return 1; +} +//------------------------------------------------------------------------ +Int_t AliITStrackerMI::CorrectForShieldMaterial(AliITStrackMI *t, + TString shield, + TString direction) { + //------------------------------------------------------------------- + // Propagate beyond SPD or SDD shield and correct for material + // (material budget in different ways according to fUseTGeo value) + //------------------------------------------------------------------- + // Define budget mode: + // 0: material from AliITSRecoParam (hard coded) + // 1: material from TGeo (on the fly) + // 2: material from lut + // 3: material from TGeo (same for all hypotheses) + Int_t mode; + switch(fUseTGeo) { + case 0: + mode=0; + break; + case 1: + mode=1; + break; + case 2: + mode=2; + break; + case 3: + if(fTrackingPhase.Contains("Clusters2Tracks")) + { mode=3; } else { mode=1; } + break; + case 4: + if(fTrackingPhase.Contains("Clusters2Tracks")) + { mode=3; } else { mode=2; } + break; + default: + mode=0; + break; + } + if(fTrackingPhase.Contains("Default")) mode=0; + + Float_t dir = (direction.Contains("inward") ? 1. : -1.); + Double_t rToGo; + Int_t shieldindex=0; + if (shield.Contains("SDD")) { // SDDouter + rToGo=(dir>0 ? AliITSRecoParam::GetrInsideShield(1) : AliITSRecoParam::GetrOutsideShield(1)); + shieldindex=1; + } else if (shield.Contains("SPD")) { // SPDouter + rToGo=(dir>0 ? AliITSRecoParam::GetrInsideShield(0) : AliITSRecoParam::GetrOutsideShield(0)); + shieldindex=0; + } else { + Error("CorrectForShieldMaterial"," Wrong shield name\n"); + return 0; + } + Double_t xToGo; t->GetLocalXat(rToGo,xToGo); + + Int_t index=2*fCurrentEsdTrack+shieldindex; + + Double_t xOverX0,x0,lengthTimesMeanDensity; + Bool_t anglecorr=kTRUE; + + switch(mode) { + case 0: + xOverX0 = AliITSRecoParam::Getdshield(shieldindex); + x0 = AliITSRecoParam::GetX0shield(shieldindex); + lengthTimesMeanDensity = xOverX0*x0; + break; + case 1: + if (!t->PropagateToTGeo(xToGo,1)) return 0; + return 1; + break; + case 2: + if(fxOverX0Shield[shieldindex]<0) BuildMaterialLUT("Shields"); + xOverX0 = fxOverX0Shield[shieldindex]; + lengthTimesMeanDensity = fxTimesRhoShield[shieldindex]; + break; + case 3: + if(!fxOverX0ShieldTrks || index<0 || index>=2*fNtracks) Error("CorrectForShieldMaterial","Incorrect usage of UseTGeo option!\n"); + if(fxOverX0ShieldTrks[index]<0) { + if (!t->PropagateToTGeo(xToGo,1,xOverX0,lengthTimesMeanDensity)) return 0; + Double_t angle=TMath::Sqrt((1.+t->GetTgl()*t->GetTgl())/ + (1.-t->GetSnp()*t->GetSnp())); + fxOverX0ShieldTrks[index] = TMath::Abs(xOverX0)/angle; + fxTimesRhoShieldTrks[index] = TMath::Abs(lengthTimesMeanDensity)/angle; + return 1; + } + xOverX0 = fxOverX0ShieldTrks[index]; + lengthTimesMeanDensity = fxTimesRhoShieldTrks[index]; + break; + } + + lengthTimesMeanDensity *= dir; + + if (!t->AliExternalTrackParam::PropagateTo(xToGo,GetBz())) return 0; + if (!t->CorrectForMeanMaterial(xOverX0,lengthTimesMeanDensity,anglecorr)) return 0; + + return 1; +} +//------------------------------------------------------------------------ +Int_t AliITStrackerMI::CorrectForLayerMaterial(AliITStrackMI *t, + Int_t layerindex, + Double_t oldGlobXYZ[3], + TString direction) { + //------------------------------------------------------------------- + // Propagate beyond layer and correct for material + // (material budget in different ways according to fUseTGeo value) + //------------------------------------------------------------------- + + // Define budget mode: + // 0: material from AliITSRecoParam (hard coded) + // 1: material from TGeo (on the fly) + // 2: material from lut + // 3: material from TGeo (same for all hypotheses) + Int_t mode; + switch(fUseTGeo) { + case 0: + mode=0; + break; + case 1: + mode=1; + break; + case 2: + mode=2; + break; + case 3: + if(fTrackingPhase.Contains("Clusters2Tracks")) + { mode=3; } else { mode=1; } + break; + case 4: + if(fTrackingPhase.Contains("Clusters2Tracks")) + { mode=3; } else { mode=2; } + break; + default: + mode=0; + break; + } + if(fTrackingPhase.Contains("Default")) mode=0; + + Float_t dir = (direction.Contains("inward") ? 1. : -1.); + + Double_t r=fgLayers[layerindex].GetR(); + Double_t deltar=(layerindex<2 ? 0.10*r : 0.05*r); + + Double_t rToGo=TMath::Sqrt(t->GetX()*t->GetX()+t->GetY()*t->GetY())-deltar*dir; + Double_t xToGo; t->GetLocalXat(rToGo,xToGo); + + Int_t index=6*fCurrentEsdTrack+layerindex; + + // Bring the track beyond the material + if (!t->AliExternalTrackParam::PropagateTo(xToGo,GetBz())) return 0; + Double_t globXYZ[3]; + t->GetXYZ(globXYZ); + + Double_t xOverX0=0.0,x0=0.0,lengthTimesMeanDensity=0.0; + Double_t mparam[7]; + Bool_t anglecorr=kTRUE; + + switch(mode) { + case 0: + xOverX0 = fgLayers[layerindex].GetThickness(t->GetY(),t->GetZ(),x0); + lengthTimesMeanDensity = xOverX0*x0; + break; + case 1: + AliTracker::MeanMaterialBudget(oldGlobXYZ,globXYZ,mparam); + if(mparam[1]>900000) return 0; + xOverX0=mparam[1]; + lengthTimesMeanDensity=mparam[0]*mparam[4]; + anglecorr=kFALSE; + break; + case 2: + if(fxOverX0Layer[layerindex]<0) BuildMaterialLUT("Layers"); + xOverX0 = fxOverX0Layer[layerindex]; + lengthTimesMeanDensity = fxTimesRhoLayer[layerindex]; + break; + case 3: + if(!fxOverX0LayerTrks || index<0 || index>=6*fNtracks) Error("CorrectForLayerMaterial","Incorrect usage of UseTGeo option!\n"); + if(fxOverX0LayerTrks[index]<0) { + AliTracker::MeanMaterialBudget(oldGlobXYZ,globXYZ,mparam); + if(mparam[1]>900000) return 0; + Double_t angle=TMath::Sqrt((1.+t->GetTgl()*t->GetTgl())/ + (1.-t->GetSnp()*t->GetSnp())); + xOverX0=mparam[1]/angle; + lengthTimesMeanDensity=mparam[0]*mparam[4]/angle; + fxOverX0LayerTrks[index] = TMath::Abs(xOverX0); + fxTimesRhoLayerTrks[index] = TMath::Abs(lengthTimesMeanDensity); + } + xOverX0 = fxOverX0LayerTrks[index]; + lengthTimesMeanDensity = fxTimesRhoLayerTrks[index]; + break; + } + + lengthTimesMeanDensity *= dir; + + if (!t->CorrectForMeanMaterial(xOverX0,lengthTimesMeanDensity,anglecorr)) return 0; + + return 1; +} +//------------------------------------------------------------------------ +void AliITStrackerMI::MakeTrksMaterialLUT(Int_t ntracks) { + //----------------------------------------------------------------- + // Initialize LUT for storing material for each prolonged track + //----------------------------------------------------------------- + fxOverX0PipeTrks = new Float_t[ntracks]; + fxTimesRhoPipeTrks = new Float_t[ntracks]; + fxOverX0ShieldTrks = new Float_t[ntracks*2]; + fxTimesRhoShieldTrks = new Float_t[ntracks*2]; + fxOverX0LayerTrks = new Float_t[ntracks*6]; + fxTimesRhoLayerTrks = new Float_t[ntracks*6]; + + for(Int_t i=0; i 0: + // return 1: the user requested to skip a layer + // return 2: track outside z acceptance of SSD/SDD and will cross both SPD + //----------------------------------------------------------------- + + if (AliITSReconstructor::GetRecoParam()->GetLayersToSkip(ilayer)) return 1; + + if (idet<0 && ilayer>1 && AliITSReconstructor::GetRecoParam()->GetExtendedEtaAcceptance()) { + // check if track will cross SPD outer layer + Double_t phiAtSPD2,zAtSPD2; + if (track->GetPhiZat(fgLayers[1].GetR(),phiAtSPD2,zAtSPD2)) { + if (TMath::Abs(zAtSPD2)<2.*AliITSRecoParam::GetSPDdetzlength()) return 2; + } + } + + return 0; +} +//------------------------------------------------------------------------ +Int_t AliITStrackerMI::CheckDeadZone(/*AliITStrackMI *track,*/ + Int_t ilayer,Int_t idet, + Double_t zmin,Double_t zmax/*,Double_t ymin,Double_t ymax*/) const { + //----------------------------------------------------------------- + // This method is used to decide whether to allow a prolongation + // without clusters, because there is a dead zone in the road. + // In this case the return value is > 0: + // return 1: dead zone at z=0,+-7cm in SPD + // return 2: dead area from the OCDB // NOT YET IMPLEMENTED + //----------------------------------------------------------------- + + // check dead zones at z=0,+-7cm in the SPD + if (ilayer<2 && !AliITSReconstructor::GetRecoParam()->GetAddVirtualClustersInDeadZone()) { + Double_t zmindead[3]={fSPDdetzcentre[0] + 0.5*AliITSRecoParam::GetSPDdetzlength(), + fSPDdetzcentre[1] + 0.5*AliITSRecoParam::GetSPDdetzlength(), + fSPDdetzcentre[2] + 0.5*AliITSRecoParam::GetSPDdetzlength()}; + Double_t zmaxdead[3]={fSPDdetzcentre[1] - 0.5*AliITSRecoParam::GetSPDdetzlength(), + fSPDdetzcentre[2] - 0.5*AliITSRecoParam::GetSPDdetzlength(), + fSPDdetzcentre[3] - 0.5*AliITSRecoParam::GetSPDdetzlength()}; + for (Int_t i=0; i<3; i++) + if (zminzmindead[i]) return 1; + } + + // check dead zones from OCDB + if (!AliITSReconstructor::GetRecoParam()->GetUseDeadZonesFromOCDB()) return 0; + + if(idet<0) return 0; + + // look in OCDB (only entire dead modules for the moment) + if (ilayer==0 || ilayer==1) { // SPD + AliCDBEntry* cdbEntry = AliCDBManager::Instance()->Get("ITS/Calib/SPDDead"); + if (!cdbEntry) { + Error("CheckDeadZone","Cannot get CDB entry for SPD\n"); + return 0; + } + TObjArray* spdEntry = (TObjArray*)cdbEntry->GetObject(); + if (!spdEntry) { + Error("CheckDeadZone","Cannot get CDB entry for SPD\n"); + return 0; + } + if(ilayer==1) idet += AliITSgeomTGeo::GetNLadders(1)*AliITSgeomTGeo::GetNDetectors(1); + //printf("SPD det: %d\n",idet); + AliITSCalibrationSPD *calibSPD = (AliITSCalibrationSPD*)spdEntry->At(idet); + if (calibSPD->IsBad()) return 2; + } else if (ilayer==2 || ilayer==3) { // SDD + AliCDBEntry* cdbEntry = AliCDBManager::Instance()->Get("ITS/Calib/CalibSDD"); + if (!cdbEntry) { + Error("CheckDeadZone","Cannot get CDB entry for SDD\n"); + return 0; + } + TObjArray* sddEntry = (TObjArray*)cdbEntry->GetObject(); + if (!sddEntry) { + Error("CheckDeadZone","Cannot get CDB entry for SDD\n"); + return 0; + } + if(ilayer==3) idet += AliITSgeomTGeo::GetNLadders(3)*AliITSgeomTGeo::GetNDetectors(3); + //printf("SDD det: %d\n",idet); + AliITSCalibrationSDD *calibSDD = (AliITSCalibrationSDD*)sddEntry->At(idet); + if (calibSDD->IsBad()) return 2; + } else if (ilayer==4 || ilayer==5) { // SSD + } else { + Error("CheckDeadZone","Wrong layer number\n"); + if(ilayer==5) idet += AliITSgeomTGeo::GetNLadders(5)*AliITSgeomTGeo::GetNDetectors(5); + return 0; + } + + return 0; +} +//------------------------------------------------------------------------ +Bool_t AliITStrackerMI::LocalModuleCoord(Int_t ilayer,Int_t idet, + AliITStrackMI *track, + Float_t &xloc,Float_t &zloc) const { + //----------------------------------------------------------------- + // Gives position of track in local module ref. frame + //----------------------------------------------------------------- + + xloc=0.; + zloc=0.; + + if(idet<0) return kFALSE; + + Int_t ndet=AliITSgeomTGeo::GetNDetectors(ilayer+1); // layers from 1 to 6 + + Int_t lad = Int_t(idet/ndet) + 1; + + Int_t det = idet - (lad-1)*ndet + 1; + + Double_t xyzGlob[3],xyzLoc[3]; + + track->GetXYZ(xyzGlob); + + AliITSgeomTGeo::GlobalToLocal(ilayer+1,lad,det,xyzGlob,xyzLoc); + + xloc = (Float_t)xyzLoc[0]; + zloc = (Float_t)xyzLoc[2]; + + return kTRUE; +} +//------------------------------------------------------------------------ +Bool_t AliITStrackerMI::IsOKForPlaneEff(AliITStrackMI* track, Int_t ilayer) const { +// Method still to be implemented: +// +// it will apply a pre-selection to obtain good quality tracks. +// Here also you will have the possibility to put a control on the +// impact point of the track on the basic block, in order to exclude border regions +// this will be done by calling a proper method of the AliITSPlaneEff class. +// +// input: AliITStrackMI* track, ilayer= layer number [0,5] +// output: Bool_t -> kTRUE 2f usable track, kFALSE if not usable. + if(!fPlaneEff) + {AliWarning("IsOKForPlaneEff: null pointer to AliITSPlaneEff"); return kFALSE;} + AliITSlayer &layer=fgLayers[ilayer]; + Double_t r=layer.GetR(); + //AliITStrackV2 tmp(*track); + AliITStrackMI tmp(*track); + +// detector number + Double_t phi,z; + if (!tmp.GetPhiZat(r,phi,z)) return kFALSE; + Int_t idet=layer.FindDetectorIndex(phi,z); + if(idet<0) { AliInfo(Form("cannot find detector")); + return kFALSE;} + + // here check if it has good Chi Square. + + //propagate to the intersection with the detector plane + const AliITSdetector &det=layer.GetDetector(idet); + if (!tmp.Propagate(det.GetPhi(),det.GetR())) return kFALSE; + + Float_t locx; // + Float_t locz; // + LocalModuleCoord(ilayer,idet,&tmp,locx,locz); + UInt_t key=fPlaneEff->GetKeyFromDetLocCoord(ilayer,idet,locx,locz); + if(key>fPlaneEff->Nblock()) return kFALSE; + Float_t blockXmn,blockXmx,blockZmn,blockZmx; + if (!fPlaneEff->GetBlockBoundaries(key,blockXmn,blockXmx,blockZmn,blockZmx)) return kFALSE; + // transform Local boundaries of the basic block into + // Global (i.e. ALICE, not tracking reference) coordinate + // + Double_t a1[3]={blockXmn,0.,blockZmn}; + Double_t a2[3]={blockXmx,0.,blockZmn}; + Double_t a3[3]={blockXmn,0.,blockZmx}; + Int_t ndet=AliITSgeomTGeo::GetNDetectors(ilayer+1); // layers from 1 to 6 + Int_t lad = Int_t(idet/ndet) + 1; + Int_t hdet = idet - (lad-1)*ndet + 1; + Double_t xyzGlob[3]; + AliITSgeomTGeo::LocalToGlobal(ilayer+1,lad,hdet,a1,a1); + AliITSgeomTGeo::LocalToGlobal(ilayer+1,lad,hdet,a2,a2); + AliITSgeomTGeo::LocalToGlobal(ilayer+1,lad,hdet,a3,a3); + Double_t gBlockYmn,gBlockYmx,gBlockZmn,gBlockZmx; + if(a1[1]>a2[1]) {gBlockYmn=a2[1]; gBlockYmx=a1[1];} + else {gBlockYmn=a1[1]; gBlockYmx=a2[1];} + if(a2[2]>a3[2]) {gBlockZmn=a3[2]; gBlockZmx=a2[2];} + else {gBlockZmn=a2[2]; gBlockZmx=a3[2];} + AliDebug(2,Form("Boundaries in Global system Ymin=%f, Ymax=%f, Zmin=%f, Zmax=%f", + gBlockYmn,gBlockYmx,gBlockZmn,gBlockZmx)); + + //*************** + // DEFINITION OF SEARCH ROAD FOR accepting a track + // + //For the time being they are hard-wired, later on from AliITSRecoParam + Double_t dz=4.*TMath::Sqrt(tmp.GetSigmaZ2()); // those are precisions in the tracking reference system + Double_t dy=4.*TMath::Sqrt(tmp.GetSigmaY2()); // dy needs to be reduced (it is max now) if you do + // comparison in Global Reference system + Float_t gdz=dz; + Float_t gdy=dy*TMath::Abs(TMath::Cos(tmp.GetAlpha())); + + // exclude tracks at boundary between detectors + //Double_t boundaryWidth=AliITSRecoParam::GetBoundaryWidth(); + Double_t boundaryWidth=0; // for the time being hard-wired, later on from AliITSRecoParam + AliDebug(2,Form("Tracking: track impact x=%f, y=%f, z=%f",tmp.GetX(), tmp.GetY(), tmp.GetZ())); + tmp.GetXYZ(xyzGlob); + AliDebug(2,Form("Global: track impact x=%f, y=%f, z=%f",xyzGlob[0],xyzGlob[1],xyzGlob[2])); + //AliInfo(Form("TEST GLOBAL track y = %f, z=%f",tmp.GetY(),tmp.GetZ())); + AliDebug(2,Form("Search Road. Tracking: dy=%f , dz=%f",dy,dz)); + AliDebug(2,Form("Search Road. Global: Gdy=%f , Gdz=%f",gdy,gdz)); + if ( (xyzGlob[1]-gdy < gBlockYmn+boundaryWidth) || + (xyzGlob[1]+gdy > gBlockYmx-boundaryWidth) || + (xyzGlob[2]-gdz < gBlockZmn+boundaryWidth) || + (xyzGlob[2]+gdz > gBlockZmx-boundaryWidth) ) return kFALSE; + + return kTRUE; +} +//------------------------------------------------------------------------ +void AliITStrackerMI::UseTrackForPlaneEff(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. +// +// Method Purpose: estabilish whether a track has produced a recpoint or not +// in the layer under study (For Plane efficiency) +// +// inputs: AliITStrackMI* track (pointer to a usable track) +// outputs: none +// side effects: update (by 1 count) the Plane Efficiency statistics of the basic block +// traversed by this very track. In details: +// - if a cluster can be associated to the track then call +// AliITSPlaneEff::UpDatePlaneEff(key,kTRUE); +// - if not, the AliITSPlaneEff::UpDatePlaneEff(key,kFALSE) is called +// + if(!fPlaneEff) + {AliWarning("UseTrackForPlaneEff: null pointer to AliITSPlaneEff"); return;} + AliITSlayer &layer=fgLayers[ilayer]; + Double_t r=layer.GetR(); + //AliITStrackV2 tmp(*track); + AliITStrackMI tmp(*track); + +// detector number + Double_t phi,z; + if (!tmp.GetPhiZat(r,phi,z)) return; + Int_t idet=layer.FindDetectorIndex(phi,z); + + if(idet<0) { AliInfo(Form("cannot find detector")); + return;} + + //Double_t trackGlobXYZ1[3]; + //tmp.GetXYZ(trackGlobXYZ1); + +//propagate to the intersection with the detector plane + const AliITSdetector &det=layer.GetDetector(idet); + if (!tmp.Propagate(det.GetPhi(),det.GetR())) return; + + //Float_t xloc,zloc; + +//*************** +// DEFINITION OF SEARCH ROAD FOR CLUSTERS SELECTION +// + Double_t dz=AliITSReconstructor::GetRecoParam()->GetNSigmaRoadZ()* + TMath::Sqrt(tmp.GetSigmaZ2() + + AliITSReconstructor::GetRecoParam()->GetNSigmaZLayerForRoadZ()* + AliITSReconstructor::GetRecoParam()->GetNSigmaZLayerForRoadZ()* + AliITSReconstructor::GetRecoParam()->GetSigmaZ2(ilayer)); + Double_t dy=AliITSReconstructor::GetRecoParam()->GetNSigmaRoadY()* + TMath::Sqrt(tmp.GetSigmaY2() + + AliITSReconstructor::GetRecoParam()->GetNSigmaYLayerForRoadY()* + AliITSReconstructor::GetRecoParam()->GetNSigmaYLayerForRoadY()* + AliITSReconstructor::GetRecoParam()->GetSigmaY2(ilayer)); + +// road in global (rphi,z) [i.e. in tracking ref. system] + Double_t zmin = tmp.GetZ() - dz; + Double_t zmax = tmp.GetZ() + dz; + Double_t ymin = tmp.GetY() + r*det.GetPhi() - dy; + Double_t ymax = tmp.GetY() + r*det.GetPhi() + dy; + +// select clusters in road + layer.SelectClusters(zmin,zmax,ymin,ymax); + +// Define criteria for track-cluster association + Double_t msz = tmp.GetSigmaZ2() + + AliITSReconstructor::GetRecoParam()->GetNSigmaZLayerForRoadZ()* + AliITSReconstructor::GetRecoParam()->GetNSigmaZLayerForRoadZ()* + AliITSReconstructor::GetRecoParam()->GetSigmaZ2(ilayer); + Double_t msy = tmp.GetSigmaY2() + + AliITSReconstructor::GetRecoParam()->GetNSigmaYLayerForRoadY()* + AliITSReconstructor::GetRecoParam()->GetNSigmaYLayerForRoadY()* + AliITSReconstructor::GetRecoParam()->GetSigmaY2(ilayer); + if (tmp.GetConstrain()) { + msz *= AliITSReconstructor::GetRecoParam()->GetNSigma2RoadZC(); + msy *= AliITSReconstructor::GetRecoParam()->GetNSigma2RoadYC(); + } else { + msz *= AliITSReconstructor::GetRecoParam()->GetNSigma2RoadZNonC(); + msy *= AliITSReconstructor::GetRecoParam()->GetNSigma2RoadYNonC(); + } + msz = 1./msz; // 1/RoadZ^2 + msy = 1./msy; // 1/RoadY^2 +// + + const AliITSRecPoint *cl=0; Int_t clidx=-1, ci=-1; + Int_t idetc=-1; + Double_t chi2trkcl=1000.*AliITSReconstructor::GetRecoParam()->GetMaxChi2(); + //Double_t tolerance=0.2; + /*while ((cl=layer.GetNextCluster(clidx))!=0) { + idetc = cl->GetDetectorIndex(); + if(idet!=idetc) continue; + //Int_t ilay = cl->GetLayer(); + + if (TMath::Abs(tmp.GetZ() - cl->GetZ()) > tolerance) continue; + if (TMath::Abs(tmp.GetY() - cl->GetY()) > tolerance) continue; + + Double_t chi2=tmp.GetPredictedChi2(cl); + if (chi2GetKeyFromDetLocCoord(ilayer,idet,locx,locz); + if(key>fPlaneEff->Nblock()) return; + Bool_t found=kFALSE; + //if (ci>=0) { + Double_t chi2; + while ((cl=layer.GetNextCluster(clidx))!=0) { + idetc = cl->GetDetectorIndex(); + if(idet!=idetc) continue; + // here real control to see whether the cluster can be associated to the track. + // cluster not associated to track + if ( (tmp.GetZ()-cl->GetZ())*(tmp.GetZ()-cl->GetZ())*msz + + (tmp.GetY()-cl->GetY())*(tmp.GetY()-cl->GetY())*msy > 1. ) continue; + // calculate track-clusters chi2 + chi2 = GetPredictedChi2MI(&tmp,cl,ilayer); // note that this method change track tmp + // in particular, the error associated to the cluster + //Double_t chi2 = tmp.GetPredictedChi(cl); // this method does not change track tmp + // chi2 cut + if (chi2 > AliITSReconstructor::GetRecoParam()->GetMaxChi2s(ilayer)) continue; + found=kTRUE; + if (chi2SetExtraCluster(ilayer,(ilayer<<28)+ci); + // track->SetExtraModule(ilayer,idetExtra); + } + if(!fPlaneEff->UpDatePlaneEff(found,key)) + AliWarning(Form("UseTrackForPlaneEff: cannot UpDate PlaneEff for key=%d",key)); + if(fPlaneEff->GetCreateHistos()&& AliITSReconstructor::GetRecoParam()->GetHistoPlaneEff()) { + Float_t tr[4]={99999.,99999.,9999.,9999.}; // initialize to high values + Float_t clu[4]={-99999.,-99999.,9999.,9999.}; // (in some cases GetCov fails) + Int_t cltype[2]={-999,-999}; + Int_t ndet=AliITSgeomTGeo::GetNDetectors(ilayer+1); // layers from 1 to 6 + Int_t lad = Int_t(idet/ndet) + 1; + Int_t hdet = idet - (lad-1)*ndet + 1; + Double_t xyzGlob[3],xyzLoc[3],cv[21],exyzLoc[3],exyzGlob[3]; + if(tmp.GetXYZ(xyzGlob)) { + if (AliITSgeomTGeo::GlobalToLocal(ilayer+1,lad,hdet,xyzGlob,xyzLoc)) { + tr[0]=xyzLoc[0]; + tr[1]=xyzLoc[2]; + } + } + if(tmp.GetCovarianceXYZPxPyPz(cv)) { + exyzGlob[0]=TMath::Sqrt(cv[0]); + exyzGlob[1]=TMath::Sqrt(cv[2]); + exyzGlob[2]=TMath::Sqrt(cv[5]); + if (AliITSgeomTGeo::GlobalToLocalVect(AliITSgeomTGeo::GetModuleIndex(ilayer+1,lad,hdet),exyzGlob,exyzLoc)) { + tr[2]=TMath::Abs(exyzLoc[0]); + tr[3]=TMath::Abs(exyzLoc[2]); + } + } + if (found){ + clu[0]=layer.GetCluster(ci)->GetDetLocalX(); + clu[1]=layer.GetCluster(ci)->GetDetLocalZ(); + cltype[0]=layer.GetCluster(ci)->GetNy(); + cltype[1]=layer.GetCluster(ci)->GetNz(); + + // Without the following 6 lines you would retrieve the nominal error of a cluster (e.g. for the SPD: + // X->50/sqrt(12)=14 micron Z->450/sqrt(12)= 120 micron) + // Within AliTrackerMI/AliTrackMI the error on the cluster is associated to the AliITStrackMI (fSigmaY,Z) + // It is computed properly by calling the method + // AliITStrackerMI::GetPredictedChi2MI(AliITStrackMI* track, const AliITSRecPoint *cluster,Int_t layer) + // T + //Double_t x=0.5*(tmp.GetX()+layer.GetCluster(ci)->GetX()); // Take into account the mis-alignment + //if (tmp.PropagateTo(x,0.,0.)) { + chi2=GetPredictedChi2MI(&tmp,layer.GetCluster(ci),ilayer); + AliCluster c(*layer.GetCluster(ci)); + c.SetSigmaY2(tmp.GetSigmaY(ilayer)*tmp.GetSigmaY(ilayer)); + c.SetSigmaZ2(tmp.GetSigmaZ(ilayer)*tmp.GetSigmaZ(ilayer)); + Float_t cov[6]; + //if (layer.GetCluster(ci)->GetGlobalCov(cov)) // by using this, instead, you got nominal cluster errors + if (c.GetGlobalCov(cov)) + { + exyzGlob[0]=TMath::Sqrt(cov[0]); + exyzGlob[1]=TMath::Sqrt(cov[3]); + exyzGlob[2]=TMath::Sqrt(cov[5]); + if (AliITSgeomTGeo::GlobalToLocalVect(AliITSgeomTGeo::GetModuleIndex(ilayer+1,lad,hdet),exyzGlob,exyzLoc)) { + clu[2]=TMath::Abs(exyzLoc[0]); + clu[3]=TMath::Abs(exyzLoc[2]); + } + } + //} + } + fPlaneEff->FillHistos(key,found,tr,clu,cltype); + } +return; +}