#include <TRandom.h>
#include <TTreeStream.h>
#include <TVector3.h>
+#include <TBits.h>
#include "AliLog.h"
#include "AliGeomManager.h"
#include "AliITSPlaneEff.h"
#include "AliTrackPointArray.h"
#include "AliESDEvent.h"
+#include "AliESDV0Params.h"
#include "AliESDtrack.h"
#include "AliV0.h"
#include "AliITSChannelStatus.h"
fDebugStreamer(0),
fITSChannelStatus(0),
fkDetTypeRec(0),
-fPlaneEff(0) {
+fPlaneEff(0),
+fSPDChipIntPlaneEff(0),
+fITSPid(0)
+
+ {
//Default constructor
Int_t i;
for(i=0;i<4;i++) fSPDdetzcentre[i]=0.;
fOriginal.SetOwner();
for(i=0;i<AliITSgeomTGeo::kNLayers;i++)fForceSkippingOfLayer[i]=0;
for(i=0;i<100000;i++)fBestTrackIndex[i]=0;
+ fITSPid=new AliITSPIDResponse();
}
//------------------------------------------------------------------------
fDebugStreamer(0),
fITSChannelStatus(0),
fkDetTypeRec(0),
-fPlaneEff(0) {
+fPlaneEff(0),
+fSPDChipIntPlaneEff(0),
+fITSPid(0) {
//--------------------------------------------------------------------
//This is the AliITStrackerMI constructor
//--------------------------------------------------------------------
Int_t iplane=AliITSReconstructor::GetRecoParam()->GetIPlanePlaneEff();
if(!AliITSReconstructor::GetRecoParam()->GetLayersToSkip(iplane)==1)
AliWarning(Form("Evaluation of Plane Eff for layer %d will be attempted without removing it from tracker",iplane));
- if (iplane<2) fPlaneEff = new AliITSPlaneEffSPD();
+ if (iplane<2) {
+ fPlaneEff = new AliITSPlaneEffSPD();
+ fSPDChipIntPlaneEff = new Bool_t[AliITSPlaneEffSPD::kNModule*AliITSPlaneEffSPD::kNChip];
+ for (UInt_t i=0; i<AliITSPlaneEffSPD::kNModule*AliITSPlaneEffSPD::kNChip; i++) fSPDChipIntPlaneEff[i]=kFALSE;
+ }
else if (iplane<4) fPlaneEff = new AliITSPlaneEffSDD();
else fPlaneEff = new AliITSPlaneEffSSD();
if(AliITSReconstructor::GetRecoParam()->GetReadPlaneEffFromOCDB())
}
//
// RS
- fSelectBestMIP03 = AliITSReconstructor::GetRecoParam()->GetSelectBestMIP03();
+ fSelectBestMIP03 = kFALSE;//AliITSReconstructor::GetRecoParam()->GetSelectBestMIP03();
fFlagFakes = AliITSReconstructor::GetRecoParam()->GetFlagFakes();
fUseImproveKalman = AliITSReconstructor::GetRecoParam()->GetUseImproveKalman();
//
+ fITSPid=new AliITSPIDResponse();
}
/*
//------------------------------------------------------------------------
}
if(fITSChannelStatus) delete fITSChannelStatus;
if(fPlaneEff) delete fPlaneEff;
+ if(fITSPid) delete fITSPid;
+ if (fSPDChipIntPlaneEff) delete [] fSPDChipIntPlaneEff;
+
}
//------------------------------------------------------------------------
void AliITStrackerMI::ReadBadFromDetTypeRec() {
AliDebug(2,Form("SKIPPING %d %d %d %d %d %d",ForceSkippingOfLayer(0),ForceSkippingOfLayer(1),ForceSkippingOfLayer(2),ForceSkippingOfLayer(3),ForceSkippingOfLayer(4),ForceSkippingOfLayer(5)));
fTrackingPhase="Clusters2Tracks";
-
+ //
+ // RS
+ fSelectBestMIP03 = kFALSE;//AliITSReconstructor::GetRecoParam()->GetSelectBestMIP03();
+ fFlagFakes = AliITSReconstructor::GetRecoParam()->GetFlagFakes();
+ fUseImproveKalman = AliITSReconstructor::GetRecoParam()->GetUseImproveKalman();
+ //
TObjArray itsTracks(15000);
fOriginal.Clear();
fEsd = event; // store pointer to the esd
SortTrackHypothesys(fCurrentEsdTrack,20,0); //MI change
//
AliITStrackMI *besttrack = GetBestHypothesys(fCurrentEsdTrack,t,15);
- t->SetWinner(besttrack);
if (!besttrack) continue;
besttrack->SetLabel(tpcLabel);
// besttrack->CookdEdx();
//
Int_t entries = fTrackHypothesys.GetEntriesFast();
for (Int_t ientry=0; ientry<entries; ientry++) {
- TObjArray * array =(TObjArray*)fTrackHypothesys.UncheckedAt(ientry);
+ TObjArray * array =(TObjArray*)fTrackHypothesys.At(ientry);
if (array) array->Delete();
delete fTrackHypothesys.RemoveAt(ientry);
}
fTrackHypothesys.Delete();
entries = fBestHypothesys.GetEntriesFast();
for (Int_t ientry=0; ientry<entries; ientry++) {
- TObjArray * array =(TObjArray*)fBestHypothesys.UncheckedAt(ientry);
+ TObjArray * array =(TObjArray*)fBestHypothesys.At(ientry);
if (array) array->Delete();
delete fBestHypothesys.RemoveAt(ientry);
}
for (Int_t i=0; i<nentr; i++) {
AliESDtrack *esd=event->GetTrack(i);
- if ((esd->GetStatus()&AliESDtrack::kITSin)==0) continue;
- if (esd->GetStatus()&AliESDtrack::kITSout) continue;
-
- AliITStrackMI *t = new AliITStrackMI(*esd);
-
- t->SetExpQ(TMath::Max(0.8*t->GetESDtrack()->GetTPCsignal(),30.));
-
- ResetTrackToFollow(*t);
-
- /*
- // propagate to vertex [SR, GSI 17.02.2003]
- // Start Time measurement [SR, GSI 17.02.2003], corrected by I.Belikov
- if (CorrectForPipeMaterial(&fTrackToFollow,"inward")) {
- if (fTrackToFollow.PropagateToVertex(event->GetVertex()))
- fTrackToFollow.StartTimeIntegral();
- // from vertex to outside pipe
- CorrectForPipeMaterial(&fTrackToFollow,"outward");
- }*/
// Start time integral and add distance from current position to vertex
+ if (esd->GetStatus()&AliESDtrack::kITSout) continue;
+ AliITStrackMI t(*esd);
Double_t xyzTrk[3],xyzVtx[3]={GetX(),GetY(),GetZ()};
- fTrackToFollow.GetXYZ(xyzTrk);
+ t.GetXYZ(xyzTrk);
Double_t dst2 = 0.;
- for (Int_t icoord=0; icoord<3; icoord++) {
- Double_t di = xyzTrk[icoord] - xyzVtx[icoord];
- dst2 += di*di;
- }
- fTrackToFollow.StartTimeIntegral();
- fTrackToFollow.AddTimeStep(TMath::Sqrt(dst2));
+ for (Int_t icoord=0; icoord<3; icoord++) {Double_t di = xyzTrk[icoord] - xyzVtx[icoord];dst2 += di*di; }
+ t.StartTimeIntegral();
+ t.AddTimeStep(TMath::Sqrt(dst2));
+ //
+ // transfer the time integral to ESD track
+ esd->SetStatus(AliESDtrack::kTIME);
+ Double_t times[10];t.GetIntegratedTimes(times); esd->SetIntegratedTimes(times);
+ esd->SetIntegratedLength(t.GetIntegratedLength());
+ //
+ if ((esd->GetStatus()&AliESDtrack::kITSin)==0) continue;
+ t.SetExpQ(TMath::Max(0.8*t.GetESDtrack()->GetTPCsignal(),30.));
+ ResetTrackToFollow(t);
+ //
fTrackToFollow.ResetCovariance(10.); fTrackToFollow.ResetClusters();
- if (RefitAt(AliITSRecoParam::GetrInsideITSscreen(),&fTrackToFollow,t)) {
- if (!CorrectForTPCtoITSDeadZoneMaterial(&fTrackToFollow)) {
- delete t;
- continue;
- }
- fTrackToFollow.SetLabel(t->GetLabel());
- //fTrackToFollow.CookdEdx();
- CookLabel(&fTrackToFollow,0.); //For comparison only
- fTrackToFollow.UpdateESDtrack(AliESDtrack::kITSout);
- //UseClusters(&fTrackToFollow);
- ntrk++;
+ if (RefitAt(AliITSRecoParam::GetrInsideITSscreen(),&fTrackToFollow,&t)) {
+ if (!CorrectForTPCtoITSDeadZoneMaterial(&fTrackToFollow)) continue;
+ fTrackToFollow.SetLabel(t.GetLabel());
+ //fTrackToFollow.CookdEdx();
+ CookLabel(&fTrackToFollow,0.); //For comparison only
+ fTrackToFollow.UpdateESDtrack(AliESDtrack::kITSout);
+ //UseClusters(&fTrackToFollow);
+ ntrk++;
}
- delete t;
}
AliInfo(Form("Number of back propagated ITS tracks: %d out of %d ESD tracks",ntrk,nentr));
Int_t nentr=event->GetNumberOfTracks();
// Info("RefitInward", "Number of ESD tracks: %d\n", nentr);
+ // only for PlaneEff and in case of SPD (for FO studies)
+ if( AliITSReconstructor::GetRecoParam()->GetComputePlaneEff() &&
+ AliITSReconstructor::GetRecoParam()->GetIPlanePlaneEff()>=0 &&
+ AliITSReconstructor::GetRecoParam()->GetIPlanePlaneEff()<2) {
+ for (UInt_t i=0; i<AliITSPlaneEffSPD::kNModule*AliITSPlaneEffSPD::kNChip; i++) fSPDChipIntPlaneEff[i]=kFALSE;
+ }
+
Int_t ntrk=0;
for (Int_t i=0; i<nentr; i++) {
AliESDtrack *esd=event->GetTrack(i);
//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;
if (!currenttrack2.Propagate(det.GetPhi(),det.GetR())) continue;
currenttrack1.SetDetectorIndex(idet);
currenttrack2.SetDetectorIndex(idet);
- */
- if (!currenttrack1.Propagate(det.GetPhi(),det.GetR())) continue;
- currenttrack1.SetDetectorIndex(idet);
- new(¤ttrack2) AliITStrackMI(currenttrack1);
- //
if(!LocalModuleCoord(ilayer,idet,¤ttrack1,xloc,zloc)) continue; // local module coords
//***************
ntracks[ilayer] = TMath::Min(accepted,7+2*ilayer);
if (ntracks[ilayer]<golden+2+ilayer) ntracks[ilayer]=TMath::Min(golden+2+ilayer,accepted);
// if (ntracks[ilayer]>90) ntracks[ilayer]=90;
- if (ntracks[ilayer]>=int(kMaxTr*0.9)) ntracks[ilayer]=int(kMaxTr*0.9);
+ if (ntracks[ilayer]>int(kMaxTr*0.9)) ntracks[ilayer]=int(kMaxTr*0.9);
} // end loop over layers
fYB[0]=0;
fYB[1]=0;
- for (Int_t j=0; j<AliITSRecoParam::fgkMaxClusterPerLayer5; j++) {
+ for (Int_t j=0; j<AliITSRecoParam::kMaxClusterPerLayer5; j++) {
for (Int_t j1=0; j1<6; j1++) {
fClusters5[j1][j]=0;
fClusterIndex5[j1][j]=-1;
}
}
- for (Int_t j=0; j<AliITSRecoParam::fgkMaxClusterPerLayer10; j++) {
+ for (Int_t j=0; j<AliITSRecoParam::kMaxClusterPerLayer10; j++) {
for (Int_t j1=0; j1<11; j1++) {
fClusters10[j1][j]=0;
fClusterIndex10[j1][j]=-1;
}
}
- for (Int_t j=0; j<AliITSRecoParam::fgkMaxClusterPerLayer20; j++) {
+ for (Int_t j=0; j<AliITSRecoParam::kMaxClusterPerLayer20; j++) {
for (Int_t j1=0; j1<21; j1++) {
fClusters20[j1][j]=0;
fClusterIndex20[j1][j]=-1;
fBy20[j1][1]=0;
}
}
- for(Int_t i=0;i<AliITSRecoParam::fgkMaxClusterPerLayer;i++){
+ for(Int_t i=0;i<AliITSRecoParam::kMaxClusterPerLayer;i++){
fClusters[i]=NULL;
fClusterIndex[i]=0;
}
fYB[0]=0;
fYB[1]=0;
- for (Int_t j=0; j<AliITSRecoParam::fgkMaxClusterPerLayer5; j++) {
+ for (Int_t j=0; j<AliITSRecoParam::kMaxClusterPerLayer5; j++) {
for (Int_t j1=0; j1<6; j1++) {
fClusters5[j1][j]=0;
fClusterIndex5[j1][j]=-1;
}
}
- for (Int_t j=0; j<AliITSRecoParam::fgkMaxClusterPerLayer10; j++) {
+ for (Int_t j=0; j<AliITSRecoParam::kMaxClusterPerLayer10; j++) {
for (Int_t j1=0; j1<11; j1++) {
fClusters10[j1][j]=0;
fClusterIndex10[j1][j]=-1;
}
}
- for (Int_t j=0; j<AliITSRecoParam::fgkMaxClusterPerLayer20; j++) {
+ for (Int_t j=0; j<AliITSRecoParam::kMaxClusterPerLayer20; j++) {
for (Int_t j1=0; j1<21; j1++) {
fClusters20[j1][j]=0;
fClusterIndex20[j1][j]=-1;
fBy20[j1][1]=0;
}
}
- for(Int_t i=0;i<AliITSRecoParam::fgkMaxClusterPerLayer;i++){
+ for(Int_t i=0;i<AliITSRecoParam::kMaxClusterPerLayer;i++){
fClusters[i]=NULL;
fClusterIndex[i]=0;
}
return sharedtrack;
}
//------------------------------------------------------------------------
-AliITStrackMI * AliITStrackerMI::GetBest2Tracks(Int_t trackID1, Int_t trackID2, Float_t th0, Float_t th1){
+AliITStrackMI * AliITStrackerMI::GetBest2Tracks(Int_t trackID1, Int_t trackID2, Float_t th0, Float_t th1,AliITStrackMI* original){
//
// try to find track hypothesys without conflicts
// with minimal chi2;
AliITStrackMI * track10=(AliITStrackMI*) arr1->UncheckedAt(0);
AliITStrackMI * track20=(AliITStrackMI*) arr2->UncheckedAt(0);
if (track10->Pt()>0.5+track20->Pt()) return track10;
- AliITStrackMI* win = track10;
//
for (Int_t itrack=0;itrack<entries1;itrack++){
AliITStrackMI * track=(AliITStrackMI*) arr1->UncheckedAt(itrack);
track1->SetChi2MIP(8,index1);
fBestTrackIndex[trackID1] =index1;
UpdateESDtrack(track1, AliESDtrack::kITSin);
- win = track1; // RS
+ original->SetWinner(track1);
}
else if (track10->GetChi2MIP(0)<th1){
track10->SetChi2MIP(5,maxconflicts);
track10->SetChi2MIP(6,maxchi2);
// track10->UpdateESDtrack(AliESDtrack::kITSin);
UpdateESDtrack(track10,AliESDtrack::kITSin);
- win = track10; // RS
+ original->SetWinner(track10);
}
for (Int_t itrack=0;itrack<entries1;itrack++){
// &&track20->fChi2MIP[2]<AliITSReconstructor::GetRecoParam()->GetMaxChi2PerCluster(2)&&track20->fChi2MIP[3]<AliITSReconstructor::GetRecoParam()->GetMaxChi2PerCluster(3)){
RegisterClusterTracks(track20,trackID2);
}
- return win;
+ return track10;
}
//------------------------------------------------------------------------
Int_t entries = array->GetEntriesFast();
//
//- find preliminary besttrack as a reference
- Float_t minchi2=1e6;
+ Float_t minchi2=10000;
Int_t maxn=0;
AliITStrackMI * besttrack=0;
//
//
Float_t * chi2 = new Float_t[entries];
Int_t * index = new Int_t[entries];
- for (Int_t i=0;i<entries;i++) chi2[i] =1e6;
+ for (Int_t i=0;i<entries;i++) chi2[i] =10000;
for (Int_t itrack=0;itrack<entries;itrack++){
AliITStrackMI * track = (AliITStrackMI*)array->At(itrack);
if (track){
}
//
// calculate one more time with updated normalized errors
- for (Int_t i=0;i<entries;i++) chi2[i] =1e6;
+ for (Int_t i=0;i<entries;i++) chi2[i] =10000;
for (Int_t itrack=0;itrack<entries;itrack++){
AliITStrackMI * track = (AliITStrackMI*)array->At(itrack);
if (track){
if (!array) return 0;
Int_t entries = array->GetEntriesFast();
if (!entries) return 0;
- Float_t minchi2 = 1e6;
+ Float_t minchi2 = 100000;
AliITStrackMI * besttrack=0;
//
AliITStrackMI * backtrack = new AliITStrackMI(*original);
}
Double_t chi2 = track->GetChi2MIP(0); // +track->GetNUsed(); //RS
if (fSelectBestMIP03) chi2 *= track->GetChi2MIP(3);
- else chi2 += +track->GetNUsed();
+ else chi2 += track->GetNUsed();
//
for (Int_t ichi=0;ichi<5;ichi++){
forwardtrack->SetChi2MIP(ichi, track->GetChi2MIP(ichi));
//if (longtrack) besttrack=longtrack;
//
// RS do shared cluster analysis here only if the new sharing analysis is not requested
- if (fFlagFakes) return besttrack;
+ //RRR if (fFlagFakes) return besttrack;
Int_t list[6];
AliITSRecPoint * clist[6];
Int_t sharedtrack = GetOverlapTrack(besttrack, esdindex, nshared, list, overlist);
if (sharedtrack>=0){
//
- besttrack = GetBest2Tracks(esdindex,sharedtrack,10,5.5);
+ besttrack = GetBest2Tracks(esdindex,sharedtrack,10,5.5,original);
if (besttrack){
shared = GetNumberOfSharedClusters(besttrack,esdindex,list,clist);
}
//
AliITStrackMI* longtrack=0;
Float_t minn=0;
- Float_t maxchi2=1e6;
+ Float_t maxchi2=1000;
for (Int_t j=0;j<array->GetEntriesFast();j++){
AliITStrackMI* trackHyp = (AliITStrackMI*)array->At(j);
if (!trackHyp) continue;
else besttrack= longtrack;
//
if (besttrack) {
+ Int_t list[6];
+ AliITSRecPoint * clist[6];
+ Float_t shared = GetNumberOfSharedClusters(longtrack,i,list,clist);
+ //
+ track->SetNUsed(shared);
track->SetNSkipped(besttrack->GetNSkipped());
track->SetChi2MIP(0,besttrack->GetChi2MIP(0));
- //
- if (!fFlagFakes) { // will flag them in separate analysis
- Int_t list[6];
- AliITSRecPoint * clist[6];
- Float_t shared = GetNumberOfSharedClusters(longtrack,i,list,clist);
+ if (shared>0) {
+ if(!AliITSReconstructor::GetRecoParam()->GetAllowSharedClusters()) continue;
+ Int_t nshared;
+ Int_t overlist[6];
//
- track->SetNUsed(shared);
- 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) {
- besttrack = GetBest2Tracks(i,sharedtrack,10,5.5);
- if (besttrack) track->SetWinner(besttrack);
- }
- }
- }
- //
- if (fAfterV0) {
+ Int_t sharedtrack = GetOverlapTrack(longtrack, i, nshared, list, overlist);
+ //if (sharedtrack==-1) sharedtrack=0;
+ if (sharedtrack>=0) {
+ besttrack = GetBest2Tracks(i,sharedtrack,10,5.5,track);
+ }
+ }
+ if (besttrack&&fAfterV0) {
UpdateESDtrack(besttrack,AliESDtrack::kITSin);
track->SetWinner(besttrack);
}
- if (fConstraint[fPass]) {
- UpdateESDtrack(besttrack,AliESDtrack::kITSin);
- track->SetWinner(besttrack);
- double chicut = besttrack->GetChi2MIP(0);
- if (fSelectBestMIP03) chicut *= besttrack->GetChi2MIP(3);
- else chicut += besttrack->GetNUsed();
- if (chicut>1.5) {
+ if (besttrack) {
+ if (fConstraint[fPass]) {
+ UpdateESDtrack(besttrack,AliESDtrack::kITSin);
+ track->SetWinner(besttrack);
+ }
+ 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);
}
- }
+ }
}
}
}
//------------------------------------------------------------------------
-void AliITStrackerMI::FlagFakes(TObjArray &itsTracks)
+void AliITStrackerMI::FlagFakes(const TObjArray &itsTracks)
{
//
// RS: flag those tracks which are suxpected to have fake clusters
}
}
+ if(zlocmin>zlocmax)return 0;
Int_t nChipsInRoad = segm->GetChipsInLocalWindow(chipsInRoad,zlocmin,zlocmax,xlocmin,xlocmax);
AliDebug(2,Form("lay %d nChipsInRoad %d",ilayer,nChipsInRoad));
if (!nChipsInRoad) return 0;
AliITStrackMI tmp(*track);
// require a minimal number of cluster in other layers and eventually clusters in closest layers
- Int_t ncl_out=0; Int_t ncl_in=0;
+ Int_t nclout=0; Int_t nclin=0;
for(Int_t lay=AliITSgeomTGeo::kNLayers-1;lay>ilayer;lay--) { // count n. of cluster in outermost layers
AliDebug(2,Form("trak=%d lay=%d ; index=%d ESD label= %d",tmp.GetLabel(),lay,
tmp.GetClIndex(lay),((AliESDtrack*)tmp.GetESDtrack())->GetLabel())) ;
- // if (tmp.GetClIndex(lay)>=0) ncl_out++;
-if(index[lay]>=0)ncl_out++;
+ // if (tmp.GetClIndex(lay)>=0) nclout++;
+if(index[lay]>=0)nclout++;
}
for(Int_t lay=ilayer-1; lay>=0;lay--) { // count n. of cluster in innermost layers
AliDebug(2,Form("trak=%d lay=%d ; index=%d ESD label= %d",tmp.GetLabel(),lay,
tmp.GetClIndex(lay),((AliESDtrack*)tmp.GetESDtrack())->GetLabel())) ;
- if (index[lay]>=0) ncl_in++;
+ if (index[lay]>=0) nclin++;
}
- Int_t ncl=ncl_out+ncl_in;
+ Int_t ncl=nclout+nclin;
Bool_t nextout = kFALSE;
if(ilayer==AliITSgeomTGeo::kNLayers-1) nextout=kTRUE; // you are already on the outermost layer
else nextout = ((tmp.GetClIndex(ilayer+1)>=0)? kTRUE : kFALSE );
if(ilayer==0) nextin=kTRUE; // you are already on the innermost layer
else nextin = ((index[ilayer-1]>=0)? kTRUE : kFALSE );
// maximum number of missing clusters allowed in outermost layers
- if(ncl
_out<AliITSgeomTGeo::kNLayers-(ilayer+1)-AliITSReconstructor::GetRecoParam()->GetMaxMissingClustersOutPlaneEff())
+ if(nclout<AliITSgeomTGeo::kNLayers-(ilayer+1)-AliITSReconstructor::GetRecoParam()->GetMaxMissingClustersOutPlaneEff())
return kFALSE;
// maximum number of missing clusters allowed (both in innermost and in outermost layers)
if(ncl<AliITSgeomTGeo::kNLayers-1-AliITSReconstructor::GetRecoParam()->GetMaxMissingClustersPlaneEff())
}
if(!fPlaneEff->UpDatePlaneEff(found,key))
AliWarning(Form("UseTrackForPlaneEff: cannot UpDate PlaneEff for key=%d",key));
+
+// this for FO efficiency studies (only for SPD) //
+ UInt_t keyFO=999999;
+ Bool_t foundFO=kFALSE;
+ if(ilayer<2){ //ONLY SPD layers for FastOr studies
+ TBits mapFO = fkDetTypeRec->GetFastOrFiredMap();
+ Int_t phase = (fEsd->GetBunchCrossNumber())%4;
+ if(!fSPDChipIntPlaneEff[key]){
+ AliITSPlaneEffSPD spd;
+ keyFO = spd.SwitchChipKeyNumbering(key);
+ if(mapFO.TestBitNumber(keyFO))foundFO=kTRUE;
+ keyFO = key + (AliITSPlaneEffSPD::kNModule*AliITSPlaneEffSPD::kNChip)*(phase+1);
+ if(keyFO<AliITSPlaneEffSPD::kNModule*AliITSPlaneEffSPD::kNChip) {
+ AliWarning(Form("UseTrackForPlaneEff: too small keyF0 (= %d), setting it to 999999",keyFO));
+ keyFO=999999;
+ }
+ if(!fPlaneEff->UpDatePlaneEff(foundFO,keyFO))
+ AliWarning(Form("UseTrackForPlaneEff: cannot UpDate PlaneEff for FastOR for key=%d",keyFO));
+ }
+ }
+
+
+
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};
// and the module
-Float_t AngleModTrack[3]={99999.,99999.,99999.}; // angles (phi, z and "absolute angle") between the track and the mormal to the module (see below)
+ Float_t angleModTrack[3]={99999.,99999.,99999.}; // angles (phi, z and "absolute angle") between the track and the mormal to the module (see below)
tr[0]=locx;
tr[1]=locz;
if((phiNorm-phiPt)>TMath::Pi()) anglet*=-1.;
anglet *= 180./TMath::Pi();
- AngleModTrack[2]=(Float_t) angle;
- AngleModTrack[0]=(Float_t) anglet;
+ angleModTrack[2]=(Float_t) angle;
+ angleModTrack[0]=(Float_t) anglet;
// now the "angle in z" (much easier, i.e. the angle between the z axis and the track momentum + 90)
- AngleModTrack[1]=TMath::ACos(tgl/TMath::Sqrt(tgl*tgl+1.));
- AngleModTrack[1]-=TMath::Pi()/2.; // range of angle is -pi/2 , pi/2
- AngleModTrack[1]*=180./TMath::Pi(); // in degree
+ angleModTrack[1]=TMath::ACos(tgl/TMath::Sqrt(tgl*tgl+1.));
+ angleModTrack[1]-=TMath::Pi()/2.; // range of angle is -pi/2 , pi/2
+ angleModTrack[1]*=180./TMath::Pi(); // in degree
+
+ fPlaneEff->FillHistos(key,found,tr,clu,cltype,angleModTrack);
- fPlaneEff->FillHistos(key,found,tr,clu,cltype,AngleModTrack);
+ // For FO efficiency studies of SPD
+ if(ilayer<2 && !fSPDChipIntPlaneEff[key]) fPlaneEff->FillHistos(keyFO,foundFO,tr,clu,cltype,angleModTrack);
}
+ if(ilayer<2) fSPDChipIntPlaneEff[key]=kTRUE;
return;
}
return fgLayers[lr].FindClusterForLabel(label,store);
}
+/*
Int_t AliITStrackerMI::GetPattern(const AliITStrackMI* track, char* patt)
{
// creates pattarn of hits marking fake/corrects by f/c. Used for debugging (RS)
}
return nwrong;
}
-
+*/
//------------------------------------------------------------------------
-Int_t AliITStrackerMI::AliITSlayer::FindClusterForLabel(Int_t label, Int_t *store) { //RS
+Int_t AliITStrackerMI::AliITSlayer::FindClusterForLabel(Int_t label, Int_t *store) const
+{ //RS
//--------------------------------------------------------------------
int nfound = 0;
}
return nfound;
}
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff