X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=MUON%2FAliMUONTrackHitPattern.cxx;h=f9827de2187f4c238839b1a38750159f4291a32e;hb=7bf353da0b857a295b8c6a6e02168c835c92d210;hp=582b7bff0393eabdcfefeee5f249e09463d01179;hpb=ad30b53f61e916929c98b2d5c6b8ec75f936dfbc;p=u%2Fmrichter%2FAliRoot.git diff --git a/MUON/AliMUONTrackHitPattern.cxx b/MUON/AliMUONTrackHitPattern.cxx index 582b7bff039..f9827de2187 100644 --- a/MUON/AliMUONTrackHitPattern.cxx +++ b/MUON/AliMUONTrackHitPattern.cxx @@ -38,39 +38,34 @@ #include "AliMUONVDigitStore.h" #include "AliMUONGeometryTransformer.h" #include "AliMUONLocalTrigger.h" -#include "AliMUONLocalTriggerBoard.h" #include "AliMUONRecoParam.h" #include "AliMUONTrack.h" #include "AliMUONTrackExtrap.h" #include "AliMUONTrackParam.h" #include "AliMUONVTrackStore.h" #include "AliMUONVTriggerStore.h" +#include "AliMUONTriggerTrack.h" +#include "AliMUONVTriggerTrackStore.h" +#include "AliMUONTriggerUtilities.h" + #include "AliMpPad.h" #include "AliMpSegmentation.h" #include "AliMpVSegmentation.h" #include "AliMpDEManager.h" -#include "AliMUONReconstructor.h" -#include "AliMUONTriggerTrack.h" -#include "AliMUONVTriggerTrackStore.h" - +#include "AliMpArea.h" #include "AliMpConstants.h" #include "AliLog.h" -#include "AliTracker.h" #include "AliESDMuonTrack.h" +#include "AliCodeTimer.h" #include -#include -#include +#include #include #include -#include -#include -#include -#include -#include - -#include +#include +#include +#include /// \cond CLASSIMP ClassImp(AliMUONTrackHitPattern) // Class implementation in ROOT context @@ -80,15 +75,17 @@ ClassImp(AliMUONTrackHitPattern) // Class implementation in ROOT context //______________________________________________________________________________ AliMUONTrackHitPattern::AliMUONTrackHitPattern(const AliMUONRecoParam* recoParam, const AliMUONGeometryTransformer& transformer, - const AliMUONVDigitStore& digitStore) + const AliMUONVDigitStore& digitStore, + const AliMUONTriggerUtilities* triggerUtilities) : TObject(), fkRecoParam(recoParam), fkTransformer(transformer), fkDigitStore(digitStore), +fkTriggerUtilities(triggerUtilities), fkMaxDistance(99999.) { - /// Default constructor - AliMUONTrackExtrap::SetField(); + /// Default constructor + AliMUONTrackExtrap::SetField(); } @@ -98,16 +95,6 @@ AliMUONTrackHitPattern::~AliMUONTrackHitPattern(void) /// Destructor } -//_____________________________________________________________________________ -void AliMUONTrackHitPattern::CheckConstants() const -{ -/// Check consistence of redefined constants - - assert(fgkNcathodes == AliMpConstants::NofCathodes()); - assert(fgkNchambers == AliMpConstants::NofTriggerChambers()); - assert(fgkNplanes == AliMpConstants::NofTriggerChambers() * fgkNcathodes); -} - //______________________________________________________________________________ void AliMUONTrackHitPattern::ExecuteValidation(const AliMUONVTrackStore& trackStore, @@ -289,7 +276,7 @@ AliMUONTrackHitPattern::MatchTriggerTrack(AliMUONTrack* track, //______________________________________________________________________________ -UShort_t AliMUONTrackHitPattern::GetHitPattern(AliMUONTriggerTrack* matchedTriggerTrack) const +UShort_t AliMUONTrackHitPattern::GetHitPattern(const AliMUONTriggerTrack* matchedTriggerTrack) const { // /// Get hit pattern on trigger chambers for the current trigger track @@ -431,229 +418,263 @@ AliMUONTrackHitPattern::MinDistanceFromPad(Float_t xPad, Float_t yPad, Float_t z //_____________________________________________________________________________ -Int_t AliMUONTrackHitPattern::FindPadMatchingTrig(Int_t &detElemId, - Float_t coor[2], Bool_t isMatch[2], - TArrayI nboard[2], TArrayF &zRealMatch, Float_t y11) const +Bool_t AliMUONTrackHitPattern::FindPadMatchingTrig(const TVector3& vec11, const TVector3& vec21, + Int_t matchedDetElemId[2], TObjArray& pads) const { - // - /// Check slat and board number of digit matching trigger track - // - - enum {kBending, kNonBending}; - - Float_t minMatchDist[fgkNcathodes]; - Int_t padsInCheckArea[fgkNcathodes]; - - for(Int_t cath=0; cath(next()) ) ) + { + Int_t currDetElemId = mDigit->DetElemId(); + Int_t currCh = AliMpDEManager::GetChamberId(currDetElemId); + if ( currCh != iChamber ) continue; + Int_t currSlat = currDetElemId%100; + Int_t slatDiff = TMath::Abs(currSlat-iSlat); + if ( slatDiff>1 && slatDiff<17 ) continue; // Check neighbour slats + Int_t cathode = mDigit->Cathode(); + Int_t ix = mDigit->PadX(); + Int_t iy = mDigit->PadY(); + const AliMpVSegmentation* seg = AliMpSegmentation::Instance() + ->GetMpSegmentation(currDetElemId,AliMp::GetCathodType(cathode)); - Int_t iChamber = AliMpDEManager::GetChamberId(detElemId); - if ( iChamber < 0 ) { - AliErrorStream() << "Cannot get chamberId from detElemId=" << detElemId << endl; - return -1; - } - - Int_t ch = iChamber-10; - Float_t oldDeltaZ = AliMUONConstants::DefaultChamberZ(iChamber) - AliMUONConstants::DefaultChamberZ(10); - Float_t y = coor[1]; - Int_t iSlat = detElemId%100; - Int_t trigDigitBendPlane = -1; - Int_t foundDetElemId = detElemId; - Float_t foundZmatch=999.; - Float_t yCoorAtPadZ=999.; - - TIter next(fkDigitStore.CreateTriggerIterator()); - AliMUONVDigit* mDigit; - Int_t idigit=0; + AliMpPad pad = seg->PadByIndices(ix,iy,kTRUE); - while ( ( mDigit = static_cast(next()) ) ) - { - idigit++; - Int_t currDetElemId = mDigit->DetElemId(); - Int_t currCh = AliMpDEManager::GetChamberId(currDetElemId); - if(currCh!=iChamber) continue; - Int_t currSlat = currDetElemId%100; - Int_t slatDiff = TMath::Abs(currSlat-iSlat); - if(slatDiff>1 && slatDiff<17) continue; // Check neighbour slats - Int_t cathode = mDigit->Cathode(); - Int_t ix = mDigit->PadX(); - Int_t iy = mDigit->PadY(); - Float_t xpad, ypad, zpad; - const AliMpVSegmentation* seg = AliMpSegmentation::Instance() - ->GetMpSegmentation(currDetElemId,AliMp::GetCathodType(cathode)); - - AliMpPad pad = seg->PadByIndices(ix,iy,kTRUE); - Float_t xlocal1 = pad.GetPositionX(); - Float_t ylocal1 = pad.GetPositionY(); - Float_t dpx = pad.GetDimensionX(); - Float_t dpy = pad.GetDimensionY(); - - fkTransformer.Local2Global(currDetElemId, xlocal1, ylocal1, 0, xpad, ypad, zpad); - AliDebug(2, Form("\nDetElemId = %i Cathode = %i Pad = (%i,%i) = (%.2f,%.2f) Dim = (%.2f,%.2f) Track = (%.2f,%.2f)\n",currDetElemId,cathode,ix,iy,xpad,ypad,dpx,dpy,coor[0],coor[1])); - // searching track intersection with chambers (second approximation) - if(ch%2==1){ - //if(iChamber%2==1){ - Float_t deltaZ = zpad - zRealMatch[0]; - y = (coor[1]-y11)*deltaZ/oldDeltaZ + y11; - if(TMath::Abs(y-coor[1])>0.1) AliDebug(3, Form("oldDeltaZ = %7.2f newDeltaZ = %7.2f\toldY = %7.2f new y = %7.2f\n",oldDeltaZ,deltaZ,coor[1],y)); - } - Float_t matchDist = PadMatchTrack(xpad, ypad, dpx, dpy, coor[0], y); - if(matchDistminMatchDist[cathode])continue; - isMatch[cathode] = kTRUE; - minMatchDist[cathode] = matchDist; - foundDetElemId = currDetElemId; - foundZmatch=zpad; - yCoorAtPadZ=y; - if(cathode==kBending) trigDigitBendPlane = idigit; - for (Int_t loc=0; loc2) { - AliDebug(1, Form("padsInCheckArea[%i] = %i\n",cath,padsInCheckArea[cath])); - return -500; - } + + AliDebug(2, Form("\nDetElemId = %i Cathode = %i Pad = (%i,%i) = (%.2f,%.2f) Dim = (%.2f,%.2f) Track = (%.2f,%.2f)\n", + currDetElemId,cathode,ix,iy,pad.GetPositionX(),pad.GetPositionY(),pad.GetDimensionX(),pad.GetDimensionY(),localExtrap.X(),localExtrap.Y())); + Float_t matchDist = PadMatchTrack(pad, localExtrap); + if ( matchDist < fkMaxDistance/2. ) padsInCheckArea[cathode]++; + if ( matchDist > minMatchDist[cathode] ) continue; + if ( pads.At(cathode) ) delete pads.RemoveAt(cathode); + pads.AddAt((AliMpPad*)pad.Clone(),cathode); + minMatchDist[cathode] = matchDist; + matchedDetElemId[cathode] = currDetElemId; // Set the input detection element id to the matched one + } // loop on digits + + // If track matches many pads, it is not good for effciency determination. + // However we still want to calculate the hit pattern. + for ( Int_t cath=0; cath<2; cath++ ){ + if ( padsInCheckArea[cath] > 2 ) { + AliDebug(1, Form("padsInCheckArea[%i] = %i\n",cath,padsInCheckArea[cath])); + return kFALSE; } - - return trigDigitBendPlane; + } + + return kTRUE; } //_____________________________________________________________________________ -Float_t AliMUONTrackHitPattern::PadMatchTrack(Float_t xPad, Float_t yPad, - Float_t dpx, Float_t dpy, - Float_t xTrackAtPad, Float_t yTrackAtPad) const +Float_t AliMUONTrackHitPattern::PadMatchTrack(const AliMpPad& pad, const TVector3& trackPosAtPad) const { - // - /// Decides if the digit belongs to the trigger track. - // + // + /// Decides if the digit belongs to the trigger track. + // + + Float_t xPad = pad.GetPositionX(); + Float_t yPad = pad.GetPositionY(); + Float_t dpx = pad.GetDimensionX(); + Float_t dpy = pad.GetDimensionY(); + Float_t maxDist = GetRecoParam()->GetStripCutForTrigger() * 2. * TMath::Min(dpx,dpy); // cm - if(maxDist<2.) maxDist = 2.; + if ( maxDist<2. ) maxDist = 2.; Float_t maxDistCheckArea = GetRecoParam()->GetMaxStripAreaForTrigger() * 2. * TMath::Min(dpx,dpy); // cm - Float_t matchDist = fkMaxDistance; + Float_t matchDist = fkMaxDistance; - Float_t deltaX = TMath::Abs(xPad-xTrackAtPad)-dpx; - Float_t deltaY = TMath::Abs(yPad-yTrackAtPad)-dpy; - Float_t maxDistX = maxDist; - Float_t maxDistY = maxDist; + Float_t deltaX = TMath::Abs(xPad-trackPosAtPad.X())-dpx; + Float_t deltaY = TMath::Abs(yPad-trackPosAtPad.Y())-dpy; + Float_t maxDistX = maxDist; + Float_t maxDistY = maxDist; - if(deltaX<=maxDistX && deltaY<=maxDistY) matchDist = TMath::Max(deltaX, deltaY); - else if(deltaX<=maxDistCheckArea && deltaY<=maxDistCheckArea) matchDist = fkMaxDistance/5.; - return matchDist; + if(deltaX<=maxDistX && deltaY<=maxDistY) matchDist = TMath::Max(deltaX, deltaY); + else if(deltaX<=maxDistCheckArea && deltaY<=maxDistCheckArea) matchDist = fkMaxDistance/5.; + return matchDist; } //_____________________________________________________________________________ Int_t AliMUONTrackHitPattern::DetElemIdFromPos(Float_t x, Float_t y, - Int_t chamber, Int_t cathode) const + Int_t chamber, Int_t foundDetElemId[2]) const { - // - /// Given the (x,y) position in the chamber, - /// it returns the corresponding slat - // + // + /// Given the (x,y) position in the chamber, + /// it returns the corresponding slats + /// Caveat: at the border the result is not univoque + // + + Int_t nFound = 0; + + foundDetElemId[0] = foundDetElemId[1] = 0; + AliMpArea pointArea(x, y, 2.*AliMpConstants::LengthTolerance(), 2.*AliMpConstants::LengthTolerance()); + AliMpDEIterator it; + for ( it.First(chamber-1); ! it.IsDone(); it.Next() ){ + Int_t detElemId = it.CurrentDEId(); + AliMpArea* deArea = fkTransformer.GetDEArea(detElemId); + + if ( deArea->Contains(pointArea) ) { + foundDetElemId[nFound++] = detElemId; + if ( nFound == 2 ) break; + } + else if ( nFound > 0 ) break; + } // loop on detElemId + + return nFound; +} - Int_t resultingDetElemId = -1; - AliMpDEIterator it; - Float_t minDist = 999.; - for ( it.First(chamber-1); ! it.IsDone(); it.Next() ){ - Int_t detElemId = it.CurrentDEId(); - Int_t ich = detElemId/100-10; - Float_t tolerance=0.2*((Float_t)ich); - Float_t currDist=9999.; - - const AliMpVSegmentation* seg = - AliMpSegmentation::Instance() - ->GetMpSegmentation(detElemId,AliMp::GetCathodType(cathode)); - if (!seg) continue; - - Float_t deltax = seg->GetDimensionX(); - Float_t deltay = seg->GetDimensionY(); - Float_t xlocal1 = -deltax; - Float_t ylocal1 = -deltay; - Float_t xlocal2 = +deltax; - Float_t ylocal2 = +deltay; - Float_t xg01, yg01, zg1, xg02, yg02, zg2; - fkTransformer.Local2Global(detElemId, xlocal1, ylocal1, 0, xg01, yg01, zg1); - fkTransformer.Local2Global(detElemId, xlocal2, ylocal2, 0, xg02, yg02, zg2); - - Float_t xg1 = xg01, xg2 = xg02, yg1 = yg01, yg2 = yg02; - - if(xg01>xg02){ - xg1 = xg02; - xg2 = xg01; - } - if(yg01>yg02){ - yg1 = yg02; - yg2 = yg01; - } - if(x>=xg1-tolerance && x<=xg2+tolerance && y>=yg1-tolerance && y<=yg2+tolerance){ // takes into account errors in extrapolation - if(yyg2) currDist = y-yg2; - if(currDistGetMpSegmentation(detElemId,AliMp::GetCathodType(icath)); + AliMpPad pad = seg->PadByPosition(localCoor.X(),localCoor.Y(),kFALSE); + if ( pad.IsValid() ) { + pads.AddAt(pad.Clone(), icath); + } + } + + return pads.GetEntries(); } //_____________________________________________________________________________ -void AliMUONTrackHitPattern::LocalBoardFromPos(Float_t x, Float_t y, - Int_t detElemId, Int_t cathode, - Int_t localBoard[4]) const +Bool_t AliMUONTrackHitPattern::PosInDetElemIdLocal(TVector3& localCoor, const TVector3& globalPoint1, + const TVector3& globalPoint2, Int_t detElemId) const { - // - /// Given the (x,y) position in the chamber, - /// it returns the corresponding local board - // + /// Given two points belonging to a line (global coordinates) + /// it returns the intersection point with the detElemId (local coordinates) + + Double_t xloc, yloc, zloc; + fkTransformer.Global2Local(detElemId, globalPoint1.X(), globalPoint1.Y(), globalPoint1.Z(), xloc, yloc, zloc); + TVector3 localPoint1(xloc, yloc, zloc); + fkTransformer.Global2Local(detElemId, globalPoint2.X(), globalPoint2.Y(), globalPoint2.Z(), xloc, yloc, zloc); + TVector3 localPoint2(xloc, yloc, zloc); + localCoor = localPoint1 - ( localPoint1.Z() / ( localPoint2.Z() - localPoint1.Z() ) ) * ( localPoint2 - localPoint1 ); + + return kTRUE; +} - for(Int_t loc=0; locGetMpSegmentation(detElemId,AliMp::GetCathodType(cathode)); - if ( ! seg ) return; - AliMpPad pad = seg->PadByPosition(xl,yl,kFALSE); - if ( ! pad.IsValid() ){ - AliWarning(Form("Pad not found! DetElemId %i position global (%f, %f, %f) local (%f, %f, %f)\n", detElemId, x, y, z, xl, yl, zl)); - return; - } - AliDebug(2, Form("\nWould match: DetElemId = %i Pad = (%i,%i) = (%.2f,%.2f,%.2f) Board %3i\n",detElemId,pad.GetIx(),pad.GetIy(),xl,yl,zl,pad.GetLocalBoardId(0))); +//_____________________________________________________________________________ +Bool_t AliMUONTrackHitPattern::IsCloseToAccEdge(TObjArray& pads, Int_t detElemId, Float_t coor[2]) const +{ + AliMpArea* deArea = fkTransformer.GetDEArea(detElemId); + Float_t dpx = ((AliMpPad*)pads.At(1))->GetDimensionX(); + Float_t dpy = ((AliMpPad*)pads.At(0))->GetDimensionY(); + Float_t resolution[2] = { 0.75*dpx, 0.75*dpy }; + Float_t sign[3] = {0., 1., -1.}; + for ( Int_t ineighx=0; ineighx<3; ineighx++ ) { + for ( Int_t ineighy=0; ineighy<3; ineighy++ ) { + AliMpArea pointArea(coor[0]+sign[ineighx]*resolution[0], + coor[1]+sign[ineighy]*resolution[1], + 2.*AliMpConstants::LengthTolerance(), + 2.*AliMpConstants::LengthTolerance()); + if ( ! deArea->Contains(pointArea) ) return kTRUE; + } // loop on y neighbours + } // loop on x neighbours + return kFALSE; +} - for (Int_t loc=0; locIsMasked(pad, detElemId, cathode) ) ++nMasked; + + // Check closest neighbour + + TVector3 localCoor; + PosInDetElemIdLocal(localCoor, vec11, vec21, detElemId); + + Float_t padPos[2] = { pad.GetPositionX(), pad.GetPositionY()}; + Float_t padDim[2] = { pad.GetDimensionX(), pad.GetDimensionY()}; + Float_t inpactPos[2] = { localCoor.X(), localCoor.Y()}; + Float_t sign[2] = {-1., 1.}; + Int_t icoor = 1-cathode; + Int_t addSlatSign[3] = {0,1,-1}; + Int_t inputCh = AliMpDEManager::GetChamberId(detElemId)+1; + Int_t inputSlat = detElemId%100; + + Float_t newPos[2]; + for ( Int_t ineigh=0; ineigh<2; ineigh++ ) { + newPos[1-icoor] = inpactPos[1-icoor]; + newPos[icoor] = inpactPos[icoor] + 1.05 * sign[ineigh] * padDim[icoor]; + if ( TMath::Abs(newPos[icoor] - padPos[icoor]) < padDim[icoor] ) continue; + const AliMpVSegmentation* seg = + AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,AliMp::GetCathodType(cathode)); + AliMpPad neighPad = seg->PadByPosition(newPos[0],newPos[1],kFALSE); + if ( neighPad.IsValid() ) { + if ( fkTriggerUtilities->IsMasked(neighPad, detElemId, cathode) ) ++nMasked; } + else { + TVector3 deltaVec(newPos[0]-inpactPos[0],newPos[1]-inpactPos[1],0.); + TVector3 transVec11 = vec11+deltaVec; + TVector3 transVec21 = vec21+deltaVec; + TObjArray padsFromPos; + padsFromPos.SetOwner(); + for ( Int_t iAddSlat=0; iAddSlat<2; iAddSlat++ ) { + Int_t currSlat = (inputSlat + addSlatSign[iAddSlat])%18; + Int_t currDetElemId = 100 * inputCh + currSlat; + PadsFromPos(transVec11,transVec21,currDetElemId,padsFromPos); + AliMpPad* currPad = (AliMpPad*)padsFromPos.UncheckedAt(cathode); + Bool_t isMasked = ( currPad ) ? fkTriggerUtilities->IsMasked(*currPad, currDetElemId, cathode) : kFALSE; + padsFromPos.Delete(); + if ( isMasked ) ++nMasked; + } + } // loop on slats + } // loop on neigbours + + Double_t maskedProb = ((Double_t)nMasked)/3.; + if ( gRandom->Rndm() < maskedProb ) return kTRUE; + + return kFALSE; } @@ -664,159 +685,157 @@ Bool_t AliMUONTrackHitPattern::PerformTrigTrackMatch(UShort_t &pattern, // /// It searches for matching digits around the trigger track. // + + AliCodeTimerAuto("",0); enum {kBending, kNonBending}; - Int_t chOrder[fgkNchambers] = {0,2,1,3}; - - TArrayF zRealMatch(fgkNchambers); - - Bool_t isMatch[fgkNcathodes]; - for(Int_t cath=0; cathGetZ11(); zMeanChamber[1] = matchedTrigTrack->GetZ11() + AliMUONConstants::DefaultChamberZ(11) - AliMUONConstants::DefaultChamberZ(10); zMeanChamber[2] = matchedTrigTrack->GetZ21(); zMeanChamber[3] = matchedTrigTrack->GetZ21() + AliMUONConstants::DefaultChamberZ(13) - AliMUONConstants::DefaultChamberZ(12); - TArrayI digitPerTrack(fgkNcathodes); - - Float_t trackIntersectCh[fgkNchambers][fgkNcathodes]; - - TArrayI triggeredDigits; - triggeredDigits.Set(fgkNchambers); - triggeredDigits.Reset(-1); - - TArrayI trigScheme[fgkNcathodes]; - TArrayI slatThatTriggered[fgkNcathodes]; - for(Int_t cath=0; cathGetY11();// y position (info from bending plane) Float_t slopeX = matchedTrigTrack->GetSlopeX(); Float_t slopeY = matchedTrigTrack->GetSlopeY(); - - for(Int_t ch=0; chGetZ11(); + Float_t x11 = slopeX * z11; + Float_t y11 = matchedTrigTrack->GetY11(); + Float_t z21 = matchedTrigTrack->GetZ21(); + Float_t x21 = slopeX * z21; + Float_t y21 = y11 + slopeY * (z21-z11); + TVector3 vec11(x11, y11, z11), vec21(x21, y21, z21); + + + Int_t firstSlat = -1, firstBoard = -1; + AliESDMuonTrack::EAliTriggerChPatternFlag goodForEff = AliESDMuonTrack::kBoardEff; + TObjArray matchedPads(2), padsFromPos(2), validPads(2); + matchedPads.SetOwner(); padsFromPos.SetOwner(); + Int_t matchedDetElemId[2], detElemIdFromTrack[2]; + + for(Int_t ich=0; ich too many digits matching pad => - // => Event not clear => Do not use for efficiency calculation - if(triggeredDigits[currCh]<-100){ - isClearEvent = kFALSE; - // track is rejected since it matches many pads + + matchedDetElemId[0] = matchedDetElemId[1] = detElemIdFromTrack[0]; + + if ( ! FindPadMatchingTrig(vec11, vec21, matchedDetElemId, matchedPads) ) { + // if ! FindPadMatchingTrig => too many digits matching pad => + // => Event not clear => Do not use for efficiency calculation AliESDMuonTrack::AddEffInfo(pattern, AliESDMuonTrack::kTrackMatchesManyPads); - AliDebug(1, Form("Warning: track = %p (%i) matches many pads. Rejected!\n",(void *)matchedTrigTrack, detElemIdFromTrack)); + goodForEff = AliESDMuonTrack::kNoEff; + AliDebug(1, Form("Warning: track = %p (%i) matches many pads. Rejected!\n",(void *)matchedTrigTrack, matchedDetElemId[0])); } - - for(Int_t cath=0; cathGetLocalBoardId(0))); + goodForEff = AliESDMuonTrack::kNoEff; + } + } + else goodForEff = AliESDMuonTrack::kNoEff; + } // loop on cathodes + + if ( goodForEff != AliESDMuonTrack::kNoEff ) { + + if ( nMatched == 0 && IsCloseToAccEdge(padsFromPos, mostProbDEfromTrack, trackIntersectCh) ) { + // Non of cathodes is fired. + // If we are close to the edge of the RPC + // it could be a problem of acceptance + AliESDMuonTrack::AddEffInfo(pattern, AliESDMuonTrack::kTrackOutsideGeometry); + goodForEff = AliESDMuonTrack::kNoEff; + AliDebug(1, "Warning: trigger track at the edge of the chamber\n"); + } + + Int_t currSlat = mostProbDEmatched%100; + if ( firstSlat < 0 ) firstSlat = currSlat; + else if ( currSlat != firstSlat ) { + goodForEff = AliESDMuonTrack::kChEff; + firstSlat = AliESDMuonTrack::kCrossDifferentSlats; + } + + if ( firstBoard < 0 ) firstBoard = ((AliMpPad*)validPads[kBending])->GetLocalBoardId(0); + + for ( Int_t cath=0; cath<2; cath++ ){ + + if ( goodForEff == AliESDMuonTrack::kBoardEff) { + Bool_t atLeastOneLoc = kFALSE; + AliMpPad* currPad = (AliMpPad*)validPads.UncheckedAt(cath); + for ( Int_t iloc=0; ilocGetNofLocations(); iloc++) { + if ( currPad->GetLocalBoardId(iloc) == firstBoard ) { + atLeastOneLoc = kTRUE; + break; + } + } // loop on locations + if ( ! atLeastOneLoc ) goodForEff = AliESDMuonTrack::kSlatEff; + } + } // loop on cathodes + } // if track good for efficiency + matchedPads.Delete(); + padsFromPos.Delete(); } // end chamber loop + + if ( goodForEff == AliESDMuonTrack::kNoEff ) return kFALSE; - for(Int_t cath=0; cath