Changes for #93172: Improve trigger chamber efficiency calculation
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 30 Mar 2012 16:41:46 +0000 (16:41 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 30 Mar 2012 16:41:46 +0000 (16:41 +0000)
19 files changed:
MUON/AliMUONDigitMaker.cxx
MUON/AliMUONDigitMaker.h
MUON/AliMUONDigitizerV3.cxx
MUON/AliMUONESDInterface.cxx
MUON/AliMUONTrack.cxx
MUON/AliMUONTrack.h
MUON/AliMUONTrackHitPattern.cxx
MUON/AliMUONTrackHitPattern.h
MUON/AliMUONTriggerEfficiencyCells.cxx
MUON/AliMUONTriggerUtilities.cxx
MUON/AliMUONTriggerUtilities.h
MUON/MUONTriggerChamberEfficiency.C
PWG/muon/AliAnalysisTaskESDMuonFilter.cxx
PWGPP/MUON/lite/AliAnalysisTaskTrigChEff.cxx
PWGPP/MUON/lite/AliAnalysisTaskTrigChEff.h
STEER/AOD/AliAODTrack.cxx
STEER/AOD/AliAODTrack.h
STEER/ESD/AliESDMuonTrack.cxx
STEER/ESD/AliESDMuonTrack.h

index 159b99b..f3ae770 100644 (file)
@@ -397,7 +397,7 @@ AliMUONDigitMaker::ReadTriggerDDL(AliRawReader* rawReader)
 //____________________________________________________________________
 Int_t AliMUONDigitMaker::TriggerDigits(Int_t nBoard, 
                                        const TArrayS* xyPattern,
-                                       AliMUONVDigitStore& digitStore) const
+                                       AliMUONVDigitStore& digitStore, Bool_t warn) const
 {
   /// make digits for trigger from pattern, and add them to digitStore
 
@@ -433,7 +433,7 @@ Int_t AliMUONDigitMaker::TriggerDigits(Int_t nBoard,
             Int_t offset = 0;
             if (iCath && localBoard->GetSwitch(AliMpLocalBoard::kZeroAllYLSB)) offset = -8;
             
-            AliMpPad pad = seg->PadByLocation(nBoard,ibitxy+offset,kTRUE);
+            AliMpPad pad = seg->PadByLocation(nBoard,ibitxy+offset,warn);
                         
             if (!pad.IsValid()) 
             {
index 0db6117..8624d4d 100644 (file)
@@ -52,7 +52,7 @@ class AliMUONDigitMaker : public TObject
   Int_t  ReadTriggerDDL(AliRawReader* rawReader);
   
   Int_t TriggerDigits(Int_t nBoard, const TArrayS* xyPattern, 
-                      AliMUONVDigitStore& digitStore) const;
+                      AliMUONVDigitStore& digitStore, Bool_t warn = kTRUE) const;
 
   Bool_t TriggerToDigitsStore(const AliMUONVTriggerStore& triggerStore, 
                               AliMUONVDigitStore& digitStore) const;
index c50c325..748508b 100644 (file)
@@ -243,6 +243,17 @@ AliMUONDigitizerV3::ApplyResponseToTriggerDigit(AliMUONVDigit& digit)
   Int_t cathode = digit.Cathode();
   Int_t trigCh = detElemId/100 - 11;
   
+  // Masked channels
+  Bool_t isMasked = fTriggerUtilities->IsMasked(digit);
+  AliDebug(1,Form("detElemId %i  cath %i  board %i  strip %i  is masked %i\n", detElemId, cathode, localCircuit, strip, isMasked));
+  if ( isMasked ) {
+    digit.SetCharge(0);
+    digit.SetADC(0);
+    //AliDebug(1,Form("ch %i  cath %i  board %i  strip %i  masked\n", trigCh, cathode, localCircuit, strip));
+    return;
+  }
+  
+  
   Int_t arrayIndex = GetArrayIndex(cathode, trigCh, localCircuit);
   
   // Trigger chamber efficiency
@@ -255,24 +266,14 @@ AliMUONDigitizerV3::ApplyResponseToTriggerDigit(AliMUONVDigit& digit)
       fEfficiencyResponse[arrayIndexBend] = isTrig[0];
       fEfficiencyResponse[arrayIndexNonBend] = isTrig[1];
     }
-    AliDebug(1,Form("ch %i  cath %i  board %i  strip %i  efficiency %i\n", trigCh, cathode, localCircuit, strip, fEfficiencyResponse[arrayIndex]));
+    AliDebug(1,Form("detElemId %i  cath %i  board %i  strip %i  efficiency %i\n", detElemId, cathode, localCircuit, strip, fEfficiencyResponse[arrayIndex]));
     if ( fEfficiencyResponse[arrayIndex] == 0 ) {
       digit.SetCharge(0);
       digit.SetADC(0);
       //AliDebug(1,Form("ch %i  cath %i  board %i  strip %i  NOT efficient\n", trigCh, cathode, localCircuit, strip));
       return;
     }
-  }
-  
-  // Masked channels
-  Bool_t isMasked = fTriggerUtilities->IsMasked(digit);
-  AliDebug(1,Form("ch %i  cath %i  board %i  strip %i  mask %i\n", trigCh, cathode, localCircuit, strip, !isMasked));
-  if ( isMasked ) {
-    digit.SetCharge(0);
-    digit.SetADC(0);
-    //AliDebug(1,Form("ch %i  cath %i  board %i  strip %i  masked\n", trigCh, cathode, localCircuit, strip));
-    return;
-  }
+  }  
 }
 
 
@@ -361,7 +362,7 @@ AliMUONDigitizerV3::DecalibrateTrackerDigit(const AliMUONVCalibParam& pedestals,
   Float_t pedestalMean = pedestals.ValueAsFloat(channel,0);
   Float_t pedestalSigma = pedestals.ValueAsFloat(channel,1);
   
-  AliDebugClass(1,Form("DE %04d MANU %04d CH %02d PEDMEAN %7.2f PEDSIGMA %7.2f",
+  AliDebugClass(2,Form("DE %04d MANU %04d CH %02d PEDMEAN %7.2f PEDSIGMA %7.2f",
                       pedestals.ID0(),pedestals.ID1(),channel,pedestalMean,pedestalSigma));
   
   if ( qual <= 0 ) return 0;
index 87bd127..0d06afe 100644 (file)
@@ -717,6 +717,7 @@ void AliMUONESDInterface::ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONTrac
   track.SetMatchTrigger(esdTrack.GetMatchTrigger());
   track.SetChi2MatchTrigger(esdTrack.GetChi2MatchTrigger());
   track.SetHitsPatternInTrigCh(esdTrack.GetHitsPatternInTrigCh());
+  track.SetHitsPatternInTrigChTrk(esdTrack.GetHitsPatternInTrigChTrk());
   track.SetLocalTrigger(esdTrack.LoCircuit(), esdTrack.LoStripX(), esdTrack.LoStripY(),
                        esdTrack.LoDev(), esdTrack.LoLpt(), esdTrack.LoHpt(),
                        esdTrack.GetTriggerWithoutChamber());
@@ -958,6 +959,7 @@ void AliMUONESDInterface::MUONToESD(const AliMUONTrack& track, AliESDMuonTrack&
   esdTrack.SetLocalTrigger(track.GetLocalTrigger());
   esdTrack.SetChi2MatchTrigger(track.GetChi2MatchTrigger());
   esdTrack.SetHitsPatternInTrigCh(track.GetHitsPatternInTrigCh());
+  esdTrack.SetHitsPatternInTrigChTrk(track.GetHitsPatternInTrigChTrk());
   if (locTrg) {
     esdTrack.SetTriggerX1Pattern(locTrg->GetX1Pattern());
     esdTrack.SetTriggerY1Pattern(locTrg->GetY1Pattern());
@@ -1018,6 +1020,7 @@ void AliMUONESDInterface::MUONToESD(const AliMUONLocalTrigger& locTrg, AliESDMuo
   esdTrack.SetTriggerX4Pattern(locTrg.GetX4Pattern());
   esdTrack.SetTriggerY4Pattern(locTrg.GetY4Pattern());
   UShort_t hitPattern = 0;
+  esdTrack.SetHitsPatternInTrigChTrk(hitPattern);
   if(triggerTrack){
     hitPattern = triggerTrack->GetHitsPatternInTrigCh();
     esdTrack.SetHitsPatternInTrigCh(hitPattern);
index ecdcf55..130eb7e 100644 (file)
@@ -61,6 +61,7 @@ AliMUONTrack::AliMUONTrack()
     fTrackID(-1),
     fTrackParamAtVertex(0x0),
     fHitsPatternInTrigCh(0),
+    fHitsPatternInTrigChTrk(0),
     fLocalTrigger(0),
     fConnected(kFALSE)
 {
@@ -85,6 +86,7 @@ AliMUONTrack::AliMUONTrack(AliMUONObjectPair *segment, Double_t bendingVertexDis
     fTrackID(-1),
     fTrackParamAtVertex(0x0),
     fHitsPatternInTrigCh(0),
+    fHitsPatternInTrigChTrk(0),
     fLocalTrigger(0),
     fConnected(kFALSE)
 {
@@ -196,6 +198,7 @@ AliMUONTrack::AliMUONTrack(const AliMUONTrack& track)
     fTrackID(track.fTrackID),
     fTrackParamAtVertex(0x0),
     fHitsPatternInTrigCh(track.fHitsPatternInTrigCh),
+    fHitsPatternInTrigChTrk(track.fHitsPatternInTrigChTrk),
     fLocalTrigger(track.fLocalTrigger),
     fConnected(track.fConnected)
 {
@@ -276,6 +279,7 @@ AliMUONTrack & AliMUONTrack::operator=(const AliMUONTrack& track)
   fChi2MatchTrigger   =  track.fChi2MatchTrigger;
   fTrackID            =  track.fTrackID; 
   fHitsPatternInTrigCh = track.fHitsPatternInTrigCh;
+  fHitsPatternInTrigChTrk = track.fHitsPatternInTrigChTrk;
   fLocalTrigger        = track.fLocalTrigger;
   fConnected          =  track.fConnected;
 
@@ -317,6 +321,7 @@ void AliMUONTrack::Reset()
   fChi2MatchTrigger = 0.;
   fTrackID = -1;
   fHitsPatternInTrigCh = 0;
+  fHitsPatternInTrigChTrk = 0;
   fLocalTrigger = 0;
   fConnected = kFALSE;
   delete fTrackParamAtCluster; fTrackParamAtCluster = 0x0;
@@ -1183,7 +1188,7 @@ void AliMUONTrack::Print(Option_t*) const
       ", Match2Trig=" << setw(1) << GetMatchTrigger()  << 
       ", LoTrgNum=" << setw(3) << LoCircuit()  << 
     ", Chi2-tracking-trigger=" << setw(8) << setprecision(5) <<  GetChi2MatchTrigger();
-  cout << Form(" HitTriggerPattern %x",fHitsPatternInTrigCh);
+  cout << Form(" HitTriggerPattern trig %x  track %x",fHitsPatternInTrigCh, fHitsPatternInTrigChTrk);
   cout << Form(" MClabel=%d",fTrackID) << endl;
   if (fTrackParamAtCluster) fTrackParamAtCluster->First()->Print("FULL");
   cout.width(curW);
index 720f215..ce17711 100644 (file)
@@ -102,6 +102,10 @@ class AliMUONTrack : public TObject
   UShort_t GetHitsPatternInTrigCh() const {return fHitsPatternInTrigCh;}
   /// set word telling which trigger chambers where hit by track
   void     SetHitsPatternInTrigCh(UShort_t hitsPatternInTrigCh) {fHitsPatternInTrigCh = hitsPatternInTrigCh;}
+  /// set word telling which trigger chambers where hit by track (from tracker track extrapolation)
+  UInt_t GetHitsPatternInTrigChTrk() const {return fHitsPatternInTrigChTrk;}
+  /// set word telling which trigger chambers where hit by track (from tracker track extrapolation)
+  void     SetHitsPatternInTrigChTrk(UInt_t hitsPatternInTrigChTrk) {fHitsPatternInTrigChTrk = hitsPatternInTrigChTrk;}
 
   /// set local trigger information for the matched trigger track
   void  SetLocalTrigger(Int_t loCirc, Int_t loStripX, Int_t loStripY, Int_t loDev, Int_t loLpt, Int_t loHpt, UChar_t respWithoutChamber=0);
@@ -176,6 +180,7 @@ class AliMUONTrack : public TObject
   AliMUONTrackParam* fTrackParamAtVertex; //!< Track parameters at vertex
   
   UShort_t fHitsPatternInTrigCh; ///< Word containing info on the hits left in trigger chambers
+  UInt_t fHitsPatternInTrigChTrk; ///< Word containing info on the hits left in trigger chambers (calculated from extrapolated tracker track)
 
   Int_t fLocalTrigger;    ///< packed local trigger information
   
@@ -187,7 +192,7 @@ class AliMUONTrack : public TObject
   void   ComputeMCSCovariances(TMatrixD& mcsCovariances) const;
   
   
-  ClassDef(AliMUONTrack, 10) // Reconstructed track in ALICE dimuon spectrometer
+  ClassDef(AliMUONTrack, 11) // Reconstructed track in ALICE dimuon spectrometer
 };
        
 #endif
index f9827de..5ff8e94 100644 (file)
@@ -82,7 +82,7 @@ fkRecoParam(recoParam),
 fkTransformer(transformer),
 fkDigitStore(digitStore),
 fkTriggerUtilities(triggerUtilities),
-fkMaxDistance(99999.)
+fkMaxDistance(99999.) // obsolete
 {
   /// Default constructor
   AliMUONTrackExtrap::SetField();
@@ -97,6 +97,24 @@ AliMUONTrackHitPattern::~AliMUONTrackHitPattern(void)
 
 
 //______________________________________________________________________________
+void 
+AliMUONTrackHitPattern::ApplyMCSCorrections(AliMUONTrackParam& trackParam) const
+{
+  //
+  /// Returns uncertainties on extrapolated position.
+  /// Takes into account Branson plane corrections in the iron wall.
+  //
+  
+  const Float_t kZFilterOut = AliMUONConstants::MuonFilterZEnd();
+  const Float_t kFilterThickness = kZFilterOut-AliMUONConstants::MuonFilterZBeg(); // cm
+  
+  AliMUONTrackExtrap::ExtrapToZCov(&trackParam, kZFilterOut); // Extrap to muon filter end
+  AliMUONTrackExtrap::AddMCSEffect(&trackParam, kFilterThickness, AliMUONConstants::MuonFilterX0()); // Add MCS effects
+  return;
+}
+
+
+//______________________________________________________________________________
 void AliMUONTrackHitPattern::ExecuteValidation(const AliMUONVTrackStore& trackStore,
                                               const AliMUONVTriggerTrackStore& triggerTrackStore,
                                               const AliMUONVTriggerStore& triggerStore) const
@@ -111,11 +129,17 @@ void AliMUONTrackHitPattern::ExecuteValidation(const AliMUONVTrackStore& trackSt
   AliMUONTriggerTrack* triggerTrack;
   TIter itTriggerTrack(triggerTrackStore.CreateIterator());
   while ( ( triggerTrack = static_cast<AliMUONTriggerTrack*>(itTriggerTrack() ) ) ){
-    UShort_t pattern = GetHitPattern(triggerTrack);
-    triggerTrack->SetHitsPatternInTrigCh(pattern);
-    AliDebug(1, Form("Hit pattern: hits 0x%x  slat %2i  board %3i  effFlag %i",
-                    pattern & 0xFF, AliESDMuonTrack::GetSlatOrInfo(pattern),
-                    triggerTrack->GetLoTrgNum(), AliESDMuonTrack::GetEffFlag(pattern)));
+    AliMUONTrackParam trackParam;
+    trackParam.SetNonBendingCoor(triggerTrack->GetX11());
+    trackParam.SetBendingCoor(triggerTrack->GetY11());
+    trackParam.SetZ(triggerTrack->GetZ11());
+    trackParam.SetNonBendingSlope(triggerTrack->GetSlopeX());
+    trackParam.SetBendingSlope(triggerTrack->GetSlopeY());
+    trackParam.SetInverseBendingMomentum(1.);
+    UInt_t pattern = GetHitPattern(trackParam, kTRUE);
+    triggerTrack->SetHitsPatternInTrigCh(pattern);    
+    AliDebug(1, Form("Hit pattern (MTR): hits 0x%x  slat %2i  board %3i  effFlag %i",
+                     pattern & 0xFF, AliESDMuonTrack::GetSlatOrInfo(pattern),triggerTrack->GetLoTrgNum(), AliESDMuonTrack::GetEffFlag(pattern)));
   }
 
   // Match tracker tracks with trigger tracks.
@@ -132,16 +156,328 @@ void AliMUONTrackHitPattern::ExecuteValidation(const AliMUONVTrackStore& trackSt
     AliMUONTrackExtrap::ExtrapToZCov(&trackParam, AliMUONConstants::DefaultChamberZ(kFirstTrigCh)); // extrap to 1st trigger chamber
 
     AliMUONTriggerTrack *matchedTriggerTrack = MatchTriggerTrack(track, trackParam, triggerTrackStore, triggerStore);
+    if ( matchedTriggerTrack ) track->SetHitsPatternInTrigCh(matchedTriggerTrack->GetHitsPatternInTrigCh());
+
+    UInt_t pattern = GetHitPattern(trackParam, kFALSE);
+    track->SetHitsPatternInTrigChTrk(pattern);
+    AliDebug(1, Form("Hit pattern (MTK): hits 0x%x  slat %2i  board %3i  effFlag %i",
+                     pattern & 0xFF, AliESDMuonTrack::GetSlatOrInfo(pattern), AliESDMuonTrack::GetCrossedBoard(pattern), AliESDMuonTrack::GetEffFlag(pattern)));
+  }
+}
 
-    // Copy trigger tracks hit pattern if there is matching,
-    // otherwise calculate the hit pattern directly from tracker track:
-    // the obtained pattern is good for check, but not good for efficiency determination.
-    UShort_t pattern = matchedTriggerTrack ?
-      matchedTriggerTrack->GetHitsPatternInTrigCh() : 
-      GetHitPattern(&trackParam);
 
-    track->SetHitsPatternInTrigCh(pattern);
+//______________________________________________________________________________
+Bool_t AliMUONTrackHitPattern::FindMatchingPads(const AliMUONTrackParam* trackParam,
+                                                TArrayI& matchedDetElemId, TObjArray& pads,
+                                                const AliMUONVDigitStore& digitStore,
+                                                Bool_t isTriggerTrack) const
+{
+  //
+  /// Search for matching digits in trigger chamber
+  //
+  enum {kBending, kNonBending};
+  
+  Double_t minMatchDist[2];
+  Int_t padsInCheckArea[2];
+  
+  AliMUONTrackParam trackParamAtPadZ(*trackParam);
+  
+  Int_t inputDetElemId = matchedDetElemId[0];
+  
+  for(Int_t cath=0; cath<2; cath++){
+    minMatchDist[cath] = 99999.;
+    padsInCheckArea[cath] = 0;
   }
+  
+  Int_t iChamber = AliMpDEManager::GetChamberId(inputDetElemId);  
+  Int_t iSlat = inputDetElemId%100;
+  
+  TIter next(digitStore.CreateTriggerIterator());
+  AliMUONVDigit* mDigit;
+  
+  Double_t xPad = 0., yPad = 0., zPad = 0.;
+  Double_t sigmaX = 0., sigmaY = 0.;
+  
+  Double_t nSigmas = ( isTriggerTrack ) ? GetRecoParam()->GetStripCutForTrigger() : GetRecoParam()->GetSigmaCutForTrigger();
+  Bool_t goodForEff = kTRUE;
+  
+  while ( ( mDigit = static_cast<AliMUONVDigit*>(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));
+    AliMpPad pad = seg->PadByIndices(ix,iy,kTRUE);
+    
+    // Get local pad coordinates
+    Double_t xPadLocal = pad.GetPositionX();
+    Double_t yPadLocal = pad.GetPositionY();
+    Double_t dpx = pad.GetDimensionX();
+    Double_t dpy = pad.GetDimensionY();
+    Double_t xWidth = 2. * dpx;
+    Double_t yWidth = 2. * dpy;
+    
+    // Get global pad coordinates
+    fkTransformer.Local2Global(currDetElemId, xPadLocal, yPadLocal, 0., xPad, yPad, zPad);
+    
+    // Get track parameters at pad z
+    if ( trackParamAtPadZ.CovariancesExist() ) AliMUONTrackExtrap::LinearExtrapToZCov(&trackParamAtPadZ, zPad);
+    else AliMUONTrackExtrap::LinearExtrapToZ(&trackParamAtPadZ, zPad);
+    
+    Double_t deltaX = TMath::Abs(xPad-trackParamAtPadZ.GetNonBendingCoor()) - dpx;
+    Double_t deltaY = TMath::Abs(yPad-trackParamAtPadZ.GetBendingCoor()) - dpy;
+    
+    
+    // Get sigmas
+    if ( isTriggerTrack ) {
+      Double_t checkWidth = TMath::Min(xWidth, yWidth);
+      Double_t maxCheckArea = GetRecoParam()->GetMaxStripAreaForTrigger() * checkWidth;
+      Double_t sigma = TMath::Max(checkWidth, 2.);
+      sigmaX = sigma; // in cm
+      sigmaY = sigma; // in cm
+      if ( deltaX <= maxCheckArea && deltaY <= maxCheckArea ) {
+        padsInCheckArea[cathode]++;
+        if ( padsInCheckArea[cathode] > 2 ) {
+          goodForEff = kFALSE;
+          AliDebug(2, Form("padsInCheckArea[%i] = %i\n",cathode,padsInCheckArea[cathode]));
+        }
+      }
+    }
+    else {
+      const TMatrixD& kCovParam = trackParamAtPadZ.GetCovariances();
+      sigmaX = TMath::Sqrt(kCovParam(0,0)); // in cm
+      sigmaY = TMath::Sqrt(kCovParam(2,2)); // in cm
+    }
+    
+    AliDebug(2, Form("\nDetElemId %i  Cath %i  Dim = (%.2f,%.2f)  Pad (%i,%i) = (%.2f,%.2f)  Track = (%.2f,%.2f)  Delta (%.2f,%.2f)  Sigma (%.2f,%.2f)  p %g\n",
+                      currDetElemId,cathode,dpx,dpy,ix,iy,xPad,yPad,trackParamAtPadZ.GetNonBendingCoor(),trackParamAtPadZ.GetBendingCoor(),deltaX,deltaY,sigmaX,sigmaY,trackParamAtPadZ.P()));
+    //if ( deltaX <= maxCheckArea && deltaY <= maxCheckArea ) padsInCheckArea[cathode]++;
+    if ( deltaX > nSigmas * sigmaX || deltaY > nSigmas * sigmaY ) continue;
+    Double_t matchDist = TMath::Max(deltaX, deltaY);
+    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(2, Form("padsInCheckArea[%i] = %i\n",cath,padsInCheckArea[cath]));
+//      return kFALSE;
+//    }
+//  }
+  
+  return goodForEff;
+}
+
+
+//_____________________________________________________________________________
+UInt_t AliMUONTrackHitPattern::GetHitPattern(const AliMUONTrackParam& trackParam, Bool_t isTriggerTrack) const
+{
+  //
+  /// Searches for matching digits around the track.
+  //
+  
+  AliCodeTimerAuto("",0);
+  
+  TArrayI digitPerTrack(2);
+  digitPerTrack.Reset();
+  
+  UInt_t pattern = 0;
+  
+  TObjArray trackParamList, matchedPads(2), maskedPads(2), padsFromPos(4), validPads(2);
+  trackParamList.SetOwner(); matchedPads.SetOwner(); maskedPads.SetOwner(); padsFromPos.SetOwner();
+  
+  Int_t firstSlat = -1, firstBoard = -1;
+  AliESDMuonTrack::EAliTriggerChPatternFlag goodForEff = AliESDMuonTrack::kBoardEff;
+  TArrayI matchedDetElemId(2), maskedDetElemId(2), detElemIdFromTrack(2), validDetElemId(2);
+  
+  for(Int_t ich=0; ich<AliMUONConstants::NTriggerCh(); ich++) { // chamber loop
+    
+    trackParamList.Delete(); matchedPads.Delete(); maskedPads.Delete(); padsFromPos.Delete(); validPads.Clear();
+    
+    Int_t nFound = GetTrackParamAtChamber(trackParam, 11+ich, trackParamList, detElemIdFromTrack, padsFromPos);
+    if ( nFound == 0 ) {
+      // track is rejected since the extrapolated track
+      // does not match a slat (border effects)
+      AliESDMuonTrack::AddEffInfo(pattern, AliESDMuonTrack::kTrackOutsideGeometry);
+      goodForEff = AliESDMuonTrack::kNoEff;
+      AliDebug(2, "Warning: trigger track outside trigger chamber\n");
+      continue;
+    }
+    
+    // Search for masked pads
+    maskedDetElemId.Reset(detElemIdFromTrack[0]);
+    FindMatchingPads((AliMUONTrackParam*)trackParamList.At(0), maskedDetElemId, maskedPads, *(fkTriggerUtilities->GetMaskedDigits()), isTriggerTrack);
+    if ( maskedPads.GetEntries() > 0 ) {
+      AliESDMuonTrack::AddEffInfo(pattern,AliESDMuonTrack::kTrackMatchesMasks); // pad is masked
+      goodForEff = AliESDMuonTrack::kNoEff;
+      for ( Int_t icath=0; icath<2; icath++ ) {
+        AliMpPad* currPad = (AliMpPad*)maskedPads.UncheckedAt(icath);
+        if ( ! currPad ) continue;
+        AliDebug(2,Form("DetElemId %i  cath %i  board %i  strip %i is masked: effFlag 0", matchedDetElemId[icath], icath, currPad->GetLocalBoardId(0), currPad->GetLocalBoardChannel(0)));
+      }
+      //      continue;
+      // We want to calculate the hit pattern in any case, so we do not "continue"
+      // However we set the flag in such a way not to use the track for efficiency calculations
+    }
+    
+    // If no masked pads matched, search for active pads
+    matchedDetElemId.Reset(detElemIdFromTrack[0]);
+    if ( ! FindMatchingPads((AliMUONTrackParam*)trackParamList.At(0), matchedDetElemId, matchedPads, fkDigitStore, isTriggerTrack) ) {
+      // if ! FindPadMatchingTrig => too many digits matching pad =>
+      //                          => Event not clear => Do not use for efficiency calculation
+      AliESDMuonTrack::AddEffInfo(pattern, AliESDMuonTrack::kTrackMatchesManyPads);
+      goodForEff = AliESDMuonTrack::kNoEff;
+      AliDebug(2, Form("Warning: track in %i matches many pads. Rejected!\n", matchedDetElemId[0]));
+    }
+    
+    Int_t nMatched = 0;
+    
+    Int_t mostProbDEmatched = detElemIdFromTrack[0];
+    for ( Int_t icath=0; icath<2; icath++ ) {
+      if ( matchedPads.UncheckedAt(icath) ) {
+        nMatched++;
+        // Fill pattern anyway
+        AliESDMuonTrack::SetFiredChamber(pattern, icath, ich);
+        digitPerTrack[icath]++;
+        mostProbDEmatched = matchedDetElemId[icath];
+      }
+    }
+    Int_t mostProbDEindex = 0;
+    for ( Int_t ifound=0; ifound<nFound; ifound++ ) {
+      if ( detElemIdFromTrack[ifound] == mostProbDEmatched ) {
+        mostProbDEindex = ifound;
+        break;
+      }
+    }
+    
+    if ( goodForEff == AliESDMuonTrack::kNoEff ) continue;
+    
+    for ( Int_t icath=0; icath<2; icath++ ) {
+      if ( matchedPads.UncheckedAt(icath) ) {
+        validPads.AddAt(matchedPads.UncheckedAt(icath),icath);
+        validDetElemId[icath] = matchedDetElemId[icath];
+      }
+      else {
+        validPads.AddAt(padsFromPos.UncheckedAt(2*mostProbDEindex + icath),icath);
+        validDetElemId[icath] = detElemIdFromTrack[mostProbDEindex];
+      }
+    }
+        
+    Int_t currSlat = mostProbDEmatched%100;
+    if ( firstSlat < 0 ) firstSlat = currSlat;
+    
+    if ( currSlat != firstSlat || validDetElemId[0] != validDetElemId[1] ) {
+      goodForEff = AliESDMuonTrack::kChEff;
+      firstSlat = AliESDMuonTrack::kCrossDifferentSlats;
+    }
+    
+    if ( firstBoard < 0 ) firstBoard = ((AliMpPad*)validPads.UncheckedAt(0))->GetLocalBoardId(0);
+    
+    for ( Int_t icath=0; icath<2; icath++ ){      
+      
+      if ( goodForEff == AliESDMuonTrack::kBoardEff) {
+        Bool_t atLeastOneLoc = kFALSE;
+        AliMpPad* currPad = (AliMpPad*)validPads.UncheckedAt(icath);
+        for ( Int_t iloc=0; iloc<currPad->GetNofLocations(); 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
+  } // end chamber loop
+  
+  if ( goodForEff == AliESDMuonTrack::kNoEff ) return pattern;
+  
+  for(Int_t cath=0; cath<2; cath++){
+    if(digitPerTrack[cath]<3) {
+      // track is rejected since the number of associated
+      // digits found is less than 3.
+      AliESDMuonTrack::AddEffInfo(pattern, AliESDMuonTrack::kTrackMatchesFewPads);
+      goodForEff = AliESDMuonTrack::kNoEff;
+      AliDebug(2, Form("Warning: found %i digits for trigger track cathode %i.\nRejecting event\n", digitPerTrack[cath],cath));
+    }
+  } // loop on cathodes 
+  
+  if ( goodForEff == AliESDMuonTrack::kNoEff ) return pattern;
+  
+  AliESDMuonTrack::AddEffInfo(pattern, firstSlat, firstBoard, goodForEff);
+  return pattern;
+}
+
+
+
+//_____________________________________________________________________________
+Int_t AliMUONTrackHitPattern::GetTrackParamAtChamber(const AliMUONTrackParam& inputTrackParam, Int_t chamber,
+                                                     TObjArray& trackParamList, TArrayI& foundDetElemId,
+                                                     TObjArray& padsFromPos) const
+{
+  //
+  /// Return the extrapolated the track parameter at the given chamber
+  /// and returns the matching DetElemId
+  /// CAVEAT: at the border the result is not univoque
+  //
+  
+  Int_t nFound = 0;
+  foundDetElemId[0] = foundDetElemId[1] = 0;
+  AliMUONTrackParam trackParamCopy(inputTrackParam);
+  TVector3 globalPoint1(trackParamCopy.GetNonBendingCoor(), trackParamCopy.GetBendingCoor(), trackParamCopy.GetZ());
+  AliMUONTrackExtrap::LinearExtrapToZ(&trackParamCopy, trackParamCopy.GetZ() + 20.);
+  TVector3 globalPoint2(trackParamCopy.GetNonBendingCoor(), trackParamCopy.GetBendingCoor(), trackParamCopy.GetZ());
+  TVector3 localCoor;
+  
+  //  AliMpArea pointArea(x, y, 2.*AliMpConstants::LengthTolerance(), 2.*AliMpConstants::LengthTolerance());
+  AliMpDEIterator it;
+  Double_t xGlobal, yGlobal, zGlobal;
+  for ( it.First(chamber-1); ! it.IsDone(); it.Next() ){
+    Int_t detElemId = it.CurrentDEId();
+    PosInDetElemIdLocal(localCoor, globalPoint1, globalPoint2, detElemId);
+    fkTransformer.Local2Global(detElemId, localCoor.X(), localCoor.Y(), localCoor.Z(), xGlobal, yGlobal, zGlobal);
+    AliMpArea pointArea(xGlobal, yGlobal, 2.*AliMpConstants::LengthTolerance(), 2.*AliMpConstants::LengthTolerance());
+    AliMpArea* deArea = fkTransformer.GetDEArea(detElemId);
+    if ( deArea->Contains(pointArea) ) {
+      // Check if track matches valid pads
+      // (this is not trivial for cut RPC)
+      Int_t validPads = 0;
+      for ( Int_t icath=0; icath<2; icath++ ) {
+        const AliMpVSegmentation* seg = 
+        AliMpSegmentation::Instance()
+        ->GetMpSegmentation(detElemId,AliMp::GetCathodType(icath));
+        AliMpPad pad = seg->PadByPosition(localCoor.X(),localCoor.Y(),kFALSE);
+        if ( pad.IsValid() ) {
+          padsFromPos.AddAt(pad.Clone(), 2*nFound + icath);
+          validPads++;
+        }
+      }
+      if ( validPads < 2 ) continue;
+      AliMUONTrackParam* extrapTrackParam = new AliMUONTrackParam(inputTrackParam);
+      if ( extrapTrackParam->CovariancesExist() ) AliMUONTrackExtrap::LinearExtrapToZCov(extrapTrackParam, zGlobal);
+      else AliMUONTrackExtrap::LinearExtrapToZ(extrapTrackParam, zGlobal);
+      trackParamList.AddAt(extrapTrackParam,nFound);
+      foundDetElemId[nFound] = detElemId;
+      nFound++;
+      if ( nFound == 2 ) break;
+    }
+    else if ( nFound > 0 ) break;
+  } // loop on detElemId
+  
+  return nFound;
 }
 
 
@@ -275,28 +611,48 @@ AliMUONTrackHitPattern::MatchTriggerTrack(AliMUONTrack* track,
 }
 
 
+//_____________________________________________________________________________
+Bool_t AliMUONTrackHitPattern::PosInDetElemIdLocal(TVector3& localCoor, const TVector3& globalPoint1,
+                                                   const TVector3& globalPoint2, Int_t detElemId) const
+{
+  /// 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;
+}
+
+
+// THE FOLLOWING METHODS ARE OBSOLETE
+
 //______________________________________________________________________________
-UShort_t AliMUONTrackHitPattern::GetHitPattern(const AliMUONTriggerTrack* matchedTriggerTrack) const
+UInt_t AliMUONTrackHitPattern::GetHitPattern(const AliMUONTriggerTrack* matchedTriggerTrack) const
 {
   //
   /// Get hit pattern on trigger chambers for the current trigger track
   //
-  UShort_t pattern = 0;
+  UInt_t pattern = 0;
   PerformTrigTrackMatch(pattern, matchedTriggerTrack);
   return pattern;
 }
 
 
 //______________________________________________________________________________
-UShort_t AliMUONTrackHitPattern::GetHitPattern(AliMUONTrackParam* trackParam) const
+UInt_t AliMUONTrackHitPattern::GetHitPattern(AliMUONTrackParam* trackParam) const
 {
   //
   /// Get hit pattern on trigger chambers for the current tracker track
   //
-  UShort_t pattern = 0;
+  UInt_t pattern = 0;
   Bool_t isMatch[2];
   const Int_t kNTrackingCh = AliMUONConstants::NTrackingCh();
-
+  
   for(Int_t ch=0; ch<4; ++ch)
   {
     Int_t iChamber = kNTrackingCh+ch;
@@ -307,31 +663,14 @@ UShort_t AliMUONTrackHitPattern::GetHitPattern(AliMUONTrackParam* trackParam) co
       if(isMatch[cath]) AliESDMuonTrack::SetFiredChamber(pattern, cath, ch);
     }
   }
-
+  
   // pattern obtained by propagation of tracker track
   // when it does not match the trigger.
   AliESDMuonTrack::AddEffInfo(pattern, AliESDMuonTrack::kTrackerTrackPattern);
-
+  
   return pattern;
 }
 
-//______________________________________________________________________________
-void 
-AliMUONTrackHitPattern::ApplyMCSCorrections(AliMUONTrackParam& trackParam) const
-{
-  //
-  /// Returns uncertainties on extrapolated position.
-  /// Takes into account Branson plane corrections in the iron wall.
-  //
-
-  const Float_t kZFilterOut = AliMUONConstants::MuonFilterZEnd();
-  const Float_t kFilterThickness = kZFilterOut-AliMUONConstants::MuonFilterZBeg(); // cm
-
-  AliMUONTrackExtrap::ExtrapToZCov(&trackParam, kZFilterOut); // Extrap to muon filter end
-  AliMUONTrackExtrap::AddMCSEffect(&trackParam, kFilterThickness, AliMUONConstants::MuonFilterX0()); // Add MCS effects
-  return;
-}
-
 
 //______________________________________________________________________________
 void 
@@ -467,7 +806,7 @@ Bool_t AliMUONTrackHitPattern::FindPadMatchingTrig(const TVector3& vec11, const
       previousDetElemId = currDetElemId;
     }
     
-    AliDebug(2, Form("\nDetElemId = %i  Cathode = %i  Pad = (%i,%i) = (%.2f,%.2f)  Dim = (%.2f,%.2f)  Track = (%.2f,%.2f)\n",
+    AliDebug(11, 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]++;
@@ -482,7 +821,7 @@ Bool_t AliMUONTrackHitPattern::FindPadMatchingTrig(const TVector3& vec11, const
   // 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]));
+      AliDebug(10, Form("padsInCheckArea[%i] = %i\n",cath,padsInCheckArea[cath]));
       return kFALSE;
     }
   }
@@ -579,24 +918,6 @@ Bool_t AliMUONTrackHitPattern::PadsFromPos(const TVector3& vec11, const TVector3
 
 
 //_____________________________________________________________________________
-Bool_t AliMUONTrackHitPattern::PosInDetElemIdLocal(TVector3& localCoor, const TVector3& globalPoint1,
-                                                   const TVector3& globalPoint2, Int_t detElemId) const
-{
-  /// 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;
-}
-
-
-//_____________________________________________________________________________
 Bool_t AliMUONTrackHitPattern::IsCloseToAccEdge(TObjArray& pads, Int_t detElemId, Float_t coor[2]) const
 {
   AliMpArea* deArea = fkTransformer.GetDEArea(detElemId);
@@ -679,7 +1000,7 @@ Bool_t AliMUONTrackHitPattern::IsMasked(const AliMpPad& pad, Int_t detElemId, In
 
 
 //_____________________________________________________________________________
-Bool_t AliMUONTrackHitPattern::PerformTrigTrackMatch(UShort_t &pattern,
+Bool_t AliMUONTrackHitPattern::PerformTrigTrackMatch(UInt_t &pattern,
                                                     const AliMUONTriggerTrack* matchedTrigTrack) const
 {
   //
@@ -712,7 +1033,6 @@ Bool_t AliMUONTrackHitPattern::PerformTrigTrackMatch(UShort_t &pattern,
   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);
@@ -731,7 +1051,7 @@ Bool_t AliMUONTrackHitPattern::PerformTrigTrackMatch(UShort_t &pattern,
       // does not match a slat (border effects)
       AliESDMuonTrack::AddEffInfo(pattern, AliESDMuonTrack::kTrackOutsideGeometry);
       goodForEff = AliESDMuonTrack::kNoEff;
-      AliDebug(1, "Warning: trigger track outside trigger chamber\n");
+      AliDebug(10, "Warning: trigger track outside trigger chamber\n");
       continue;
     }
     
@@ -742,7 +1062,7 @@ Bool_t AliMUONTrackHitPattern::PerformTrigTrackMatch(UShort_t &pattern,
       //                          => Event not clear => Do not use for efficiency calculation
       AliESDMuonTrack::AddEffInfo(pattern, AliESDMuonTrack::kTrackMatchesManyPads);
       goodForEff = AliESDMuonTrack::kNoEff;
-      AliDebug(1, Form("Warning: track = %p (%i) matches many pads. Rejected!\n",(void *)matchedTrigTrack, matchedDetElemId[0]));
+      AliDebug(10, Form("Warning: track = %p (%i) matches many pads. Rejected!\n",(void *)matchedTrigTrack, matchedDetElemId[0]));
     }
     
     Int_t nMatched = 0;
@@ -776,8 +1096,8 @@ Bool_t AliMUONTrackHitPattern::PerformTrigTrackMatch(UShort_t &pattern,
         validPads.AddAt(currPad,cath);
         if ( IsMasked(*currPad, mostProbDEfromTrack, cath, vec11, vec21) ) {
           // Check if strip was masked (if inefficient strip is found)
-          AliESDMuonTrack::AddEffInfo(pattern,25,AliESDMuonTrack::kNoEff); // pad is masked
-          AliDebug(1,Form("DetElemId %i  cath %i  strip %i is masked: effFlag 0", mostProbDEfromTrack, cath, currPad->GetLocalBoardId(0)));
+          AliESDMuonTrack::AddEffInfo(pattern,AliESDMuonTrack::kTrackMatchesMasks); // pad is masked
+          AliDebug(10,Form("DetElemId %i  cath %i  board %i  strip %i is masked: effFlag 0", mostProbDEfromTrack, cath, currPad->GetLocalBoardId(0), currPad->GetLocalBoardChannel(0)));
           goodForEff = AliESDMuonTrack::kNoEff;
         }
       }
@@ -792,7 +1112,7 @@ Bool_t AliMUONTrackHitPattern::PerformTrigTrackMatch(UShort_t &pattern,
         // 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");
+        AliDebug(10, "Warning: trigger track at the edge of the chamber\n");
       }
       
       Int_t currSlat = mostProbDEmatched%100;
@@ -831,12 +1151,12 @@ Bool_t AliMUONTrackHitPattern::PerformTrigTrackMatch(UShort_t &pattern,
       // digits found is less than 3.
       AliESDMuonTrack::AddEffInfo(pattern, AliESDMuonTrack::kTrackMatchesFewPads);
       goodForEff = AliESDMuonTrack::kNoEff;
-      AliDebug(1, Form("Warning: found %i digits for trigger track cathode %i.\nRejecting event\n", digitPerTrack[cath],cath));
+      AliDebug(10, Form("Warning: found %i digits for trigger track cathode %i.\nRejecting event\n", digitPerTrack[cath],cath));
     }
   } // loop on cathodes 
 
   if ( goodForEff == AliESDMuonTrack::kNoEff ) return kFALSE;
   
-  AliESDMuonTrack::AddEffInfo(pattern, firstSlat, goodForEff);
+  AliESDMuonTrack::AddEffInfo(pattern, firstSlat, firstBoard, goodForEff);
   return kTRUE;
 }
index 167d164..596fc46 100644 (file)
@@ -26,6 +26,7 @@ class AliMUONRecoParam;
 class AliMUONTriggerUtilities;
 class AliMpPad;
 class TVector3;
+class TArrayI;
 
 class AliMUONTrackHitPattern : public TObject 
 {
@@ -45,46 +46,52 @@ public:
                                         AliMUONTrackParam& trackParam,
                                         const AliMUONVTriggerTrackStore& triggerTrackStore,
                                         const AliMUONVTriggerStore& triggerStore) const;
-
-  UShort_t GetHitPattern(const AliMUONTriggerTrack* matchedTriggerTrack) const;
   
-  UShort_t GetHitPattern(AliMUONTrackParam* trackParam) const;
+  UInt_t GetHitPattern(const AliMUONTrackParam& trackParam, Bool_t isTriggerTrack) const;
+  
+  UInt_t GetHitPattern(const AliMUONTriggerTrack* matchedTriggerTrack) const; // obsolete
+  UInt_t GetHitPattern(AliMUONTrackParam* trackParam) const; // obsolete
 
 protected:
   void ApplyMCSCorrections(AliMUONTrackParam& trackParam) const;
   
+  Int_t GetTrackParamAtChamber(const AliMUONTrackParam& inputTrackParam, Int_t chamber,
+                               TObjArray& trackParamList, TArrayI& foundDetElemId, TObjArray& padsFromPos) const;
+  
+  Bool_t FindMatchingPads(const AliMUONTrackParam* trackParam,
+                          TArrayI& matchedDetElemId, TObjArray& pads,
+                          const AliMUONVDigitStore& digitStore, Bool_t isTriggerTrack) const;
+  
+  Bool_t PosInDetElemIdLocal(TVector3& localCoor, const TVector3& globalPoint1, const TVector3& globalPoint2, Int_t detElemId) const;
+  
+  /// Return reco parameters
+  const AliMUONRecoParam* GetRecoParam() const { return fkRecoParam; }
+  
+  // THE FOLLOWING METHODS ARE OBSOLETE
+  
   // Methods for hit pattern from tracker track
   void FindPadMatchingTrack(const AliMUONTrackParam& trackParam,
-                           Bool_t isMatch[2], Int_t iChamber) const;
+                            Bool_t isMatch[2], Int_t iChamber) const;
 
   Float_t MinDistanceFromPad(Float_t xPad, Float_t yPad, Float_t zPad,
                              Float_t dpx, Float_t dpy, 
                              const AliMUONTrackParam& trackParam) const;
 
   // Methods for hit pattern from matched trigger track
-  Bool_t PerformTrigTrackMatch(UShort_t &pattern,
-                              const AliMUONTriggerTrack* matchedTrigTrack) const;
-  
-  Bool_t FindPadMatchingTrig(const TVector3& vec11, const TVector3& vec21,
-                             Int_t matchedDetElemId[2], TObjArray& matchedPads) const;
-  
+  Bool_t PerformTrigTrackMatch(UInt_t &pattern, const AliMUONTriggerTrack* matchedTrigTrack) const; // obsolete
   
-  Float_t PadMatchTrack(const AliMpPad& pad, const TVector3& trackPosAtPad) const;
+  Bool_t FindPadMatchingTrig(const TVector3& vec11, const TVector3& vec21, Int_t matchedDetElemId[2], TObjArray& matchedPads) const; // obsolete
   
-  Int_t DetElemIdFromPos(Float_t x, Float_t y, Int_t chamber, Int_t foundDetElemId[2]) const;
+  Float_t PadMatchTrack(const AliMpPad& pad, const TVector3& trackPosAtPad) const; // obsolete
   
-  Bool_t PadsFromPos(const TVector3& vec11, const TVector3& vec21,
-                     Int_t detElemId, TObjArray& pads) const;
+  Int_t DetElemIdFromPos(Float_t x, Float_t y, Int_t chamber, Int_t foundDetElemId[2]) const; // obsolete
   
-  Bool_t PosInDetElemIdLocal(TVector3& localCoor, const TVector3& globalPoint1, const TVector3& globalPoint2, Int_t detElemId) const;
+  Bool_t PadsFromPos(const TVector3& vec11, const TVector3& vec21, Int_t detElemId, TObjArray& pads) const; // obsolete
   
-
-  /// Return reco parameters
-  const AliMUONRecoParam* GetRecoParam() const { return fkRecoParam; }
   
-  Bool_t IsCloseToAccEdge(TObjArray& pads, Int_t detElemId, Float_t coor[2]) const;
+  Bool_t IsCloseToAccEdge(TObjArray& pads, Int_t detElemId, Float_t coor[2]) const; // obsolete
   
-  Bool_t IsMasked(const AliMpPad& pad, Int_t detElemId, Int_t cathode, const TVector3& vec11, const TVector3& vec21) const;
+  Bool_t IsMasked(const AliMpPad& pad, Int_t detElemId, Int_t cathode, const TVector3& vec11, const TVector3& vec21) const; // obsolete
   
 private:
   /// Not implemented
@@ -97,7 +104,7 @@ private:
   const AliMUONVDigitStore& fkDigitStore; //!< digitStore
   const AliMUONTriggerUtilities* fkTriggerUtilities; //!< trigger utilities for mapping
 
-  const Float_t fkMaxDistance; //!< Maximum distance for reference
+  const Float_t fkMaxDistance; //!< Maximum distance for reference // obsolete
   
   ClassDef(AliMUONTrackHitPattern, 0) // MUON track hit pattern
 };
index 29d2dce..db113c6 100755 (executable)
 
 // $Id$
 
+#include "AliMUONTriggerEfficiencyCells.h"
+
 #include "AliLog.h"
 #include "AliMpConstants.h"
 
-#include "TH1F.h"
+#include "TH1.h"
+#include "TList.h"
 #include "TFile.h"
 
 #include <fstream>
 #include <cassert>
 
-#include "AliMUONTriggerEfficiencyCells.h"
-
 
 //-----------------------------------------------------------------------------
 /// \class AliMUONTriggerEfficiencyCells
index 0f56fc0..4b94e66 100644 (file)
  **************************************************************************/
 
 
+#include "AliMUONTriggerUtilities.h"
+
+#include "TArrayS.h"
+
 #include "AliLog.h"
 
 #include "AliMUONCalibrationData.h"
-#include "AliMUONTriggerCrateStore.h"
-#include "AliMUONTriggerCrate.h"
-#include "AliMUONTriggerCrateConfig.h"
-#include "AliMUONVCalibParam.h"
-#include "AliMUONRegionalTriggerConfig.h"
-#include "AliMUONLocalTriggerBoard.h"
+//#include "AliMUONTriggerCrateStore.h"
+//#include "AliMUONTriggerCrate.h"
+//#include "AliMUONTriggerCrateConfig.h"
+//#include "AliMUONVCalibParam.h"
+//#include "AliMUONRegionalTriggerConfig.h"
+//#include "AliMUONLocalTriggerBoard.h"
 #include "AliMUONVDigit.h"
 #include "AliMUONConstants.h"
+#include "AliMUONTriggerElectronics.h"
+#include "AliMUONDigitStoreV2R.h"
+#include "AliMUONDigitMaker.h"
+#include "AliMUONTriggerStoreV1.h"
 
 #include "AliMpDDLStore.h"
 #include "AliMpPad.h"
-#include "AliMpLocalBoard.h"
-
-#include "AliMUONTriggerUtilities.h"
+//#include "AliMpLocalBoard.h"
+#include "AliMpConstants.h"
+#include "AliMpVSegmentation.h"
+#include "AliMpSegmentation.h"
 
 /// \cond CLASSIMP
 ClassImp(AliMUONTriggerUtilities)
@@ -41,7 +50,8 @@ ClassImp(AliMUONTriggerUtilities)
 AliMUONTriggerUtilities::AliMUONTriggerUtilities(AliMUONCalibrationData* calibData):
 TObject(),
 fCalibrationData(calibData),
-fTriggerStatusMap(2*AliMUONConstants::NTriggerCh()*AliMUONConstants::NTriggerCircuit())
+fTriggerStatusMap(2*AliMUONConstants::NTriggerCh()*AliMUONConstants::NTriggerCircuit()),
+fMaskedDigitsStore(new AliMUONDigitStoreV2R())
 {
   /// Ctor.
   Init();
@@ -51,7 +61,7 @@ fTriggerStatusMap(2*AliMUONConstants::NTriggerCh()*AliMUONConstants::NTriggerCir
 AliMUONTriggerUtilities::~AliMUONTriggerUtilities()
 {
   /// Destructor. Note we're the owner of some pointers.
-  
+  delete fMaskedDigitsStore;
 }
 
 
@@ -59,41 +69,91 @@ AliMUONTriggerUtilities::~AliMUONTriggerUtilities()
 Bool_t AliMUONTriggerUtilities::Init()
 {
   /// Build trigger status map from masks
-  AliMUONTriggerCrateStore crates;
-  crates.ReadFromFile(fCalibrationData);
+  AliMUONTriggerElectronics trigElectronics(fCalibrationData);
+  AliMUONDigitMaker digitMaker(kFALSE);
+  AliMUONDigitStoreV2R digitStore;
+  AliMUONTriggerStoreV1 triggerStore;
+  
+  TArrayS xyPatternAll[2];      
+  for(Int_t icath=0; icath<AliMpConstants::NofCathodes(); icath++){     
+    xyPatternAll[icath].Set(AliMpConstants::NofTriggerChambers());      
+    xyPatternAll[icath].Reset(0xFFFF);
+  }
+  
+  // Create a store with all digits in trigger
+  for ( Int_t iboard=1; iboard<=AliMpConstants::NofLocalBoards(); iboard++ ) {
+    digitMaker.TriggerDigits(iboard, xyPatternAll, digitStore, kFALSE);
+  }
+  
+  // Create trigger with electronics (it applies masks)
+  trigElectronics.Digits2Trigger(digitStore, triggerStore);
   
-  AliMUONRegionalTriggerConfig* regionalConfig = fCalibrationData->RegionalTriggerConfig();
-  if ( ! regionalConfig ) AliFatal("no valid regional trigger configuration in CDB\n");
+  // Re-compute digits from triggerStore
+  // Since the masks were applied in the response,
+  // the new store do not contain masked channels
+  AliMUONDigitStoreV2R digitStoreMasked;
+  digitMaker.TriggerToDigitsStore(triggerStore, digitStoreMasked);
   
-  // Loop on crates
-  AliMUONTriggerCrate* cr = 0x0;
-  TIter next ( crates.CreateCrateIterator() );
-  while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) ) {
-    TObjArray *boards = cr->Boards();
-    
-    AliMUONTriggerCrateConfig* crateConfig = regionalConfig->FindTriggerCrate(cr->GetName());
-    
-    if ( ! crateConfig ) AliFatal(Form("Crate %s not present in configuration !!!\n", cr->GetName()));
-    
-    UShort_t regionalMask = crateConfig->GetMask();
-    
-    // Loop on boards
-    for (Int_t iboard = 1; iboard < boards->GetEntries(); iboard++ ) {      
-      Bool_t activeBoard = ( ( regionalMask >> ( iboard - 1) ) & 1 );
-      AliMUONLocalTriggerBoard* board = (AliMUONLocalTriggerBoard*)boards->At(iboard);
-      Int_t cardNumber = board->GetNumber();
-      if ( cardNumber <= 0 ) continue; // interface board are not interested
-      AliMUONVCalibParam* localBoardMask = fCalibrationData->LocalTriggerBoardMasks(cardNumber);
-      for ( Int_t icath = 0; icath < 2; ++icath ) {
-        for ( Int_t ich = 0; ich < 4; ++ich ) {
-          Int_t planeIndex = icath * 4 + ich;
-          Int_t localMask = ( activeBoard ) ? localBoardMask->ValueAsInt(planeIndex) : 0;
-          Int_t arrayIndex = GetArrayIndex(icath, ich, cardNumber);
-          fTriggerStatusMap[arrayIndex] = localMask;
-        } // loop on chambers
-      } // loop on planes
-    } // loop on boards
-  } // loop on crates
+  // Loop on non-masked digit store
+  // Search for digits in the masked one:
+  // if digit is not found, it means it was masked
+  TIter next(digitStore.CreateIterator());
+  AliMUONVDigit* dig = 0x0;
+  while ( ( dig = static_cast<AliMUONVDigit*>(next()) ) ) {
+    Int_t cath = dig->Cathode();
+    Int_t detElemId = dig->DetElemId();
+    Int_t board = dig->ManuId();
+    Int_t strip = dig->ManuChannel();
+    AliMUONVDigit* currDigit = digitStoreMasked.FindObject(detElemId, board, strip, cath);
+    Bool_t isMasked = ( currDigit ) ? kFALSE : kTRUE;
+    if ( isMasked ) fMaskedDigitsStore->Add(*((AliMUONVDigit*)dig->Clone()), AliMUONVDigitStore::kDeny);
+    else {
+      Int_t ich = detElemId/100-11;
+      const AliMpVSegmentation* seg = AliMpSegmentation::Instance()->GetMpSegmentation(detElemId, AliMp::GetCathodType(cath));
+      AliMpPad pad = seg->PadByIndices(dig->PadX(), dig->PadY(), kTRUE);
+      for (Int_t iloc=0; iloc<pad.GetNofLocations(); iloc++) {
+        Int_t currBoard = pad.GetLocalBoardId(iloc);
+        Int_t arrayIndex = GetArrayIndex(cath, ich, currBoard);
+        fTriggerStatusMap[arrayIndex] |= ( 0x1 << strip );
+      } // loop on locations (in bending plane we have to fill all copy boards)
+    }
+  }
+
+//  AliMUONTriggerCrateStore crates;
+//  crates.ReadFromFile(fCalibrationData);
+//  
+//  AliMUONRegionalTriggerConfig* regionalConfig = fCalibrationData->RegionalTriggerConfig();
+//  if ( ! regionalConfig ) AliFatal("no valid regional trigger configuration in CDB\n");
+//  
+//  // Loop on crates
+//  AliMUONTriggerCrate* cr = 0x0;
+//  TIter next ( crates.CreateCrateIterator() );
+//  while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) ) {
+//    TObjArray *boards = cr->Boards();
+//    
+//    AliMUONTriggerCrateConfig* crateConfig = regionalConfig->FindTriggerCrate(cr->GetName());
+//    
+//    if ( ! crateConfig ) AliFatal(Form("Crate %s not present in configuration !!!\n", cr->GetName()));
+//    
+//    UShort_t regionalMask = crateConfig->GetMask();
+//    
+//    // Loop on boards
+//    for (Int_t iboard = 1; iboard < boards->GetEntries(); iboard++ ) {      
+//      Bool_t activeBoard = ( ( regionalMask >> ( iboard - 1) ) & 1 );
+//      AliMUONLocalTriggerBoard* board = (AliMUONLocalTriggerBoard*)boards->At(iboard);
+//      Int_t cardNumber = board->GetNumber();
+//      if ( cardNumber <= 0 ) continue; // interface board are not interested
+//      AliMUONVCalibParam* localBoardMask = fCalibrationData->LocalTriggerBoardMasks(cardNumber);
+//      for ( Int_t icath = 0; icath < 2; ++icath ) {
+//        for ( Int_t ich = 0; ich < 4; ++ich ) {
+//          Int_t planeIndex = icath * 4 + ich;
+//          Int_t localMask = ( activeBoard ) ? localBoardMask->ValueAsInt(planeIndex) : 0;
+//          Int_t arrayIndex = GetArrayIndex(icath, ich, cardNumber);
+//          fTriggerStatusMap[arrayIndex] = localMask;
+//        } // loop on chambers
+//      } // loop on planes
+//    } // loop on boards
+//  } // loop on crates
   
   return kTRUE;
 }
@@ -101,36 +161,32 @@ Bool_t AliMUONTriggerUtilities::Init()
 //_____________________________________________________________________________
 Bool_t AliMUONTriggerUtilities::IsMasked(const AliMUONVDigit& digit) const
 {
-  /// Check if pad is masked
-  Int_t detElemId = digit.DetElemId();
-  Int_t localCircuit = digit.ManuId();
-  Int_t strip = digit.ManuChannel();
-  Int_t cathode = digit.Cathode();
-  Int_t trigCh = detElemId/100 - 11;
-  
-  AliMpLocalBoard* localBoard = AliMpDDLStore::Instance()->GetLocalBoard(localCircuit);
-  Int_t ibitxy = strip;
-  if (cathode && localBoard->GetSwitch(AliMpLocalBoard::kZeroAllYLSB)) ibitxy += 8;
-  Int_t arrayIndex = GetArrayIndex(cathode, trigCh, localCircuit);
-  AliDebug(1,Form("ch %i  cath %i  board %i  strip %i  mask %i\n", trigCh, cathode, localCircuit, strip, (fTriggerStatusMap[arrayIndex] >> ibitxy ) & 0x1));
-  return ((( fTriggerStatusMap[arrayIndex] >> ibitxy ) & 0x1 ) == 0 );
+  /// Check if pad is masked  
+  return IsMasked(digit.DetElemId(), digit.Cathode(), digit.ManuId(), digit.ManuChannel());
 }
 
 
 //_____________________________________________________________________________
 Bool_t AliMUONTriggerUtilities::IsMasked(const AliMpPad& pad, Int_t detElemId, Int_t cathode) const
 {
+  /// Check if pad is masked  
+  return IsMasked(detElemId, cathode, pad.GetLocalBoardId(0), pad.GetLocalBoardChannel(0));
+}
+
+
+//_____________________________________________________________________________
+Bool_t AliMUONTriggerUtilities::IsMasked(Int_t detElemId, Int_t cathode, Int_t localCircuit, Int_t strip) const
+{
   /// Check if pad is masked
-  Int_t localCircuit = pad.GetLocalBoardId(0);
-  Int_t strip = pad.GetLocalBoardChannel(0);
   Int_t trigCh = detElemId/100 - 11;
   
-  AliMpLocalBoard* localBoard = AliMpDDLStore::Instance()->GetLocalBoard(localCircuit);
-  Int_t ibitxy = strip;
-  if (cathode && localBoard->GetSwitch(AliMpLocalBoard::kZeroAllYLSB)) ibitxy += 8;
+//  Int_t ibitxy = strip;
+//  AliMpLocalBoard* localBoard = AliMpDDLStore::Instance()->GetLocalBoard(localCircuit);
+//  if ( cathode && localBoard->GetSwitch(AliMpLocalBoard::kZeroAllYLSB) ) ibitxy += 8;
   Int_t arrayIndex = GetArrayIndex(cathode, trigCh, localCircuit);
-  AliDebug(1,Form("ch %i  cath %i  board %i  strip %i  mask %i\n", trigCh, cathode, localCircuit, strip, (fTriggerStatusMap[arrayIndex] >> ibitxy ) & 0x1));
-  return ((( fTriggerStatusMap[arrayIndex] >> ibitxy ) & 0x1 ) == 0 );
+  Bool_t isMasked = ( ( ( fTriggerStatusMap[arrayIndex] >> strip ) & 0x1 ) == 0 );
+  AliDebug(1,Form("detElemId %i  cath %i  board %i  strip %i  is active %i\n", detElemId, cathode, localCircuit, strip, ! isMasked));
+  return isMasked;
 }
 
 
index 0466858..39b20b9 100644 (file)
@@ -16,6 +16,7 @@
 class AliMUONCalibrationData;
 class AliMUONVDigit;
 class AliMpPad;
+class AliMUONVDigitStore;
 
 class AliMUONTriggerUtilities : public TObject
 {
@@ -25,6 +26,8 @@ public:
   
   Bool_t IsMasked(const AliMUONVDigit& digit) const;
   Bool_t IsMasked(const AliMpPad& pad, Int_t detElemId, Int_t cathode) const;
+  Bool_t IsMasked(Int_t detElemId, Int_t cathode, Int_t localCircuit, Int_t strip) const;
+  AliMUONVDigitStore* GetMaskedDigits() const { return fMaskedDigitsStore; }
 
 private:
   /// Not implemented
@@ -37,6 +40,7 @@ private:
   
   AliMUONCalibrationData* fCalibrationData; //!< pointer to access calib parameters
   TArrayI fTriggerStatusMap; //!< Trigger masks
+  AliMUONVDigitStore* fMaskedDigitsStore; //!< Masked digits store
   
   ClassDef(AliMUONTriggerUtilities,0) // MUON Trigger utilities
 };
index 1ec8664..61a7d99 100644 (file)
@@ -194,3 +194,88 @@ void BuildDefaultMap(TString outFilename="/tmp/defTrigChEff.root", Double_t glob
   histoList->Write("triggerChamberEff",TObject::kSingleKey);
   outFile->Close();
 }
+
+
+//____________________________________________________________
+void CompleteEfficiency(TString effFileWithHoles, TString effFileCompatible, TString outFilename)
+{
+  //
+  /// When a local board or RPC is missing, the efficiency of other boards cannot be calculated
+  /// If an efficiency file of the same period is available, it could be used to fill the missing information
+  //
+  
+  TList* histoList[2] = {0x0, 0x0};
+  TString filenames[2] = {effFileWithHoles, effFileCompatible};
+  for ( Int_t ifile=0; ifile<2; ifile++ ) {
+    TFile* file = TFile::Open(filenames[ifile].Data());
+    if ( ! file ) {
+      printf("Fatal: cannot find %s\n", filenames[ifile].Data());
+      return;
+    }
+    histoList[ifile] = static_cast<TList*> (file->FindObjectAny("triggerChamberEff"));
+    if ( ! histoList[ifile] ) {
+      printf("Cannot find histo list in file %s\n", filenames[ifile].Data());
+      return;
+    }
+  }
+  
+  TString detElemName[2] = {"Slat", "Board"};
+  enum { kBendingEff, kNonBendingEff, kBothPlanesEff, kAllTracks, kNcounts};
+  TString countTypeName[kNcounts] = {"bendPlane", "nonBendPlane","bothPlanes", "allTracks"};
+  
+  Bool_t isChanged = kFALSE;
+  TString histoName = "";
+  for ( Int_t idet=0; idet<2; idet++ ) {
+    for ( Int_t ich=11; ich<=14; ich++ ) {
+      histoName = Form("%sCount%sCh%i", countTypeName[kAllTracks].Data(), detElemName[idet].Data(), ich);
+      TH1* allTracksHisto = static_cast<TH1*> (histoList[0]->FindObject(histoName.Data()));
+      for ( Int_t ibin=1; ibin<=allTracksHisto->GetXaxis()->GetNbins(); ibin++ ) {
+        if ( allTracksHisto->GetBinContent(ibin) > 0. ) continue;
+        isChanged = kTRUE;
+        printf("Modifying info for Ch %i %s %3i\n", ich, detElemName[idet].Data(), (Int_t)allTracksHisto->GetXaxis()->GetBinCenter(ibin));
+        // If allTracks has no entries, it means that efficiency could not be calculated for this bin:
+        // fill information from the compatible histogram
+        
+        // Check the statistics collected by the switched off detection element
+        Double_t nTracks = 0;
+        for ( Int_t jch=11; jch<=14; jch++ ) {
+          histoName = Form("%sCount%sCh%i", countTypeName[kAllTracks].Data(), detElemName[idet].Data(), jch);
+          TH1* allTracksOtherCh = static_cast<TH1*> (histoList[0]->FindObject(histoName.Data()));
+          nTracks = allTracksOtherCh->GetBinContent(ibin);
+          if ( nTracks > 0. ) {
+            //printf("Statistics for %s : %g\n", histoName.Data(), nTracks); // REMEMBER TO CUT
+            break;
+          }
+        }
+        
+        histoName = Form("%sCount%sCh%i", countTypeName[kAllTracks].Data(), detElemName[idet].Data(), ich);
+        TH1* allTracksHistoAux = static_cast<TH1*> (histoList[1]->FindObject(histoName.Data()));
+        Double_t nTracksNew = allTracksHistoAux->GetBinContent(ibin);
+        if ( nTracksNew == 0.) {
+          printf("Warning: new histogram has no entries for Ch %i %s %3i\n", ich, detElemName[idet].Data(), (Int_t)allTracksHisto->GetXaxis()->GetBinCenter(ibin));
+          continue;
+        }
+        Double_t scaleFactor = TMath::Min(nTracksNew, nTracks) / nTracksNew;
+        //printf("Statistics ineff %g  new %g  scaleFactor %g\n", nTracks, nTracksNew, scaleFactor); // REMEMBER TO CUT
+        
+        for ( Int_t icount=0; icount<kNcounts; icount++ ) {
+          histoName = Form("%sCount%sCh%i", countTypeName[icount].Data(), detElemName[idet].Data(), ich);
+          TH1* auxHisto = static_cast<TH1*> (histoList[1]->FindObject(histoName.Data()));
+          TH1* histo = static_cast<TH1*> (histoList[0]->FindObject(histoName.Data()));
+          histo->SetBinContent(ibin, auxHisto->GetBinContent(ibin) * scaleFactor);
+          if ( histo->GetSumw2N() > 0 ) histo->SetBinError(ibin, auxHisto->GetBinError(ibin)*scaleFactor);
+        } // loop on cont types
+      } // loop on histogram bins
+    } // loop on chamber
+  } // loop on detection element (slat or board)
+  
+  if ( ! isChanged ) {
+    printf("Input histograms not modified\n");
+    return;
+  }
+  TFile* outFile = TFile::Open(outFilename,"create");
+  histoList[0]->Write("triggerChamberEff",TObject::kSingleKey);
+  outFile->Close();  
+}
+
+
index d7a49e9..6d2e906 100644 (file)
@@ -332,6 +332,10 @@ void AliAnalysisTaskESDMuonFilter::ConvertESDtoAOD()
     aodTrack->SetChi2perNDF(esdMuTrack->GetChi2() / (2.*esdMuTrack->GetNHit() - 5.));
     aodTrack->SetChi2MatchTrigger(esdMuTrack->GetChi2MatchTrigger());
     aodTrack->SetHitsPatternInTrigCh(esdMuTrack->GetHitsPatternInTrigCh());
+    UInt_t pattern = esdMuTrack->GetHitsPatternInTrigCh();
+    AliESDMuonTrack::AddEffInfo(pattern, 0, esdMuTrack->LoCircuit(), (AliESDMuonTrack::EAliTriggerChPatternFlag)0);
+    aodTrack->SetMUONtrigHitsMapTrg(pattern);
+    aodTrack->SetMUONtrigHitsMapTrk(esdMuTrack->GetHitsPatternInTrigChTrk());
     aodTrack->SetMuonClusterMap(esdMuTrack->GetMuonClusterMap());
     aodTrack->SetMatchTrigger(esdMuTrack->GetMatchTrigger());
     aodTrack->Connected(esdMuTrack->IsConnected());
index 9ed4e7f..bab47d9 100644 (file)
@@ -38,6 +38,8 @@
 
 // ANALYSIS includes
 #include "AliAnalysisManager.h"
+#include "AliAnalysisDataSlot.h"
+#include "AliAnalysisDataContainer.h"
 
 // PWG3 includes
 #include "AliVAnalysisMuon.h"
@@ -56,6 +58,7 @@ AliAnalysisTaskTrigChEff::AliAnalysisTaskTrigChEff() :
   fTrackSelKeys(0x0),
   fCountTypeKeys(0x0),
   fHistoTypeKeys(0x0),
+  fEffMethodKeys(0x0),
   fUseGhosts(kFALSE),
   fList(0x0)
 {
@@ -68,6 +71,7 @@ AliAnalysisTaskTrigChEff::AliAnalysisTaskTrigChEff(const char *name, const AliMu
   fTrackSelKeys(0x0),
   fCountTypeKeys(0x0),
   fHistoTypeKeys(0x0),
+  fEffMethodKeys(0x0),
   fUseGhosts(kFALSE),
   fList(0x0)
 {
@@ -90,6 +94,7 @@ AliAnalysisTaskTrigChEff::~AliAnalysisTaskTrigChEff()
   delete fTrackSelKeys;
   delete fCountTypeKeys;
   delete fHistoTypeKeys;
+  delete fEffMethodKeys;
   if ( ! AliAnalysisManager::GetAnalysisManager() || ! AliAnalysisManager::GetAnalysisManager()->IsProofMode() ) {
     delete fList;
   }
@@ -122,7 +127,7 @@ Bool_t AliAnalysisTaskTrigChEff::FillEffHistoList(TString physSel, TString trigC
   TH1* histo = 0x0;
   Bool_t isOk = kTRUE;
   for ( Int_t icount=0; icount<kNcounts; ++icount ) {
-    histoName = GetHistoName(kHchamberEff, icount, -1, -1);
+    histoName = GetHistoName(kHchamberEff, icount, -1, -1, -1);
     histoPattern = Form("%s&%s", histoName.Data(), trackSelection.Data());
     histo = (TH1*)GetSum(physSel, trigClassNames, centrality, histoPattern);
     if ( histo ) {
@@ -135,7 +140,7 @@ Bool_t AliAnalysisTaskTrigChEff::FillEffHistoList(TString physSel, TString trigC
   }
   for ( Int_t icount=0; icount<kNcounts; ++icount ) {
     for ( Int_t ich=0; ich<4; ++ich ) {
-      histoName = GetHistoName(kHslatEff, icount, ich, -1);
+      histoName = GetHistoName(kHslatEff, icount, ich, -1, -1);
       histoPattern = Form("%s&%s", histoName.Data(), trackSelection.Data());
       histo = (TH1*)GetSum(physSel, trigClassNames, centrality, histoPattern);
       if ( histo ) {
@@ -149,7 +154,7 @@ Bool_t AliAnalysisTaskTrigChEff::FillEffHistoList(TString physSel, TString trigC
   }
   for ( Int_t icount=0; icount<kNcounts; ++icount ) {
     for ( Int_t ich=0; ich<4; ++ich ) {
-      histoName = GetHistoName(kHboardEff, icount, ich, -1);
+      histoName = GetHistoName(kHboardEff, icount, ich, -1, -1);
       histoPattern = Form("%s&%s", histoName.Data(), trackSelection.Data());
       histo = (TH1*)GetSum(physSel, trigClassNames, centrality, histoPattern);
       if ( histo ) {
@@ -162,7 +167,7 @@ Bool_t AliAnalysisTaskTrigChEff::FillEffHistoList(TString physSel, TString trigC
     }
   }
   
-  histoName = GetHistoName(kHcheckBoard, -1, -1, -1);
+  histoName = GetHistoName(kHcheckBoard, -1, -1, -1, -1);
   histoPattern = Form("%s&%s", histoName.Data(), trackSelection.Data());
   histo = (TH1*)GetSum(physSel, trigClassNames, centrality, histoPattern);
   if ( histo ) {
@@ -188,24 +193,26 @@ void AliAnalysisTaskTrigChEff::FinishTaskOutput()
   for ( Int_t isel=0; isel<kNselections; ++isel ) {
     for ( Int_t itrig=0; itrig<fTriggerClasses->GetEntries(); ++itrig ) {
       for ( Int_t icent=1; icent<=fCentralityClasses->GetNbins(); ++icent ) {
-        for ( Int_t itype=0; itype<kNhistoTypes; ++itype ) {
-          for ( Int_t icount=-1; icount<kNcounts; ++icount ) {
-            for ( Int_t ich=-1; ich<4; ++ich ) {
-              for ( Int_t imatch=kMatchApt; imatch<kMatchHpt; ++imatch ) {
-                TH1* histo = 0x0;
-                for ( Int_t jmatch=imatch+1; jmatch<=kMatchHpt; ++jmatch ) {
-                  histoName = GetHistoName(itype, icount, ich, jmatch);
-                  TH1* histoAdd = (TH1*)fMergeableCollection->GetObject(Form("/%s/%s/%s/",fPhysSelKeys->At(isel)->GetName(), fTriggerClasses->At(itrig)->GetName(), fCentralityClasses->GetBinLabel(icent)), histoName);
-                  if ( ! histoAdd ) continue;
-                  histoName = GetHistoName(itype, icount, ich, imatch);
-                  if ( ! histo ) histo = (TH1*)GetMergeableObject(fPhysSelKeys->At(isel)->GetName(), fTriggerClasses->At(itrig)->GetName(), fCentralityClasses->GetBinLabel(icent), histoName);
-                  AliDebug(2,Form("Adding %s (%g) to %s (%g)", histoAdd->GetName(), histoAdd->Integral(), histo->GetName(), histo->Integral()));
-                  histo->Add(histoAdd);
-                } // loop on higher pt matching
-              } // loop on match trigger
-            } // loop on chamber
-          } // loop on count type
-        } // loop on histo type
+        for ( Int_t imethod=0; imethod<kNeffMethods; ++imethod ) {
+          for ( Int_t itype=0; itype<kNhistoTypes; ++itype ) {
+            for ( Int_t icount=-1; icount<kNcounts; ++icount ) {
+              for ( Int_t ich=-1; ich<4; ++ich ) {
+                for ( Int_t imatch=kMatchApt; imatch<kMatchHpt; ++imatch ) {
+                  TH1* histo = 0x0;
+                  for ( Int_t jmatch=imatch+1; jmatch<=kMatchHpt; ++jmatch ) {
+                    histoName = GetHistoName(itype, icount, ich, jmatch, imethod);
+                    TH1* histoAdd = (TH1*)fMergeableCollection->GetObject(Form("/%s/%s/%s/",fPhysSelKeys->At(isel)->GetName(), fTriggerClasses->At(itrig)->GetName(), fCentralityClasses->GetBinLabel(icent)), histoName);
+                    if ( ! histoAdd ) continue;
+                    histoName = GetHistoName(itype, icount, ich, imatch, imethod);
+                    if ( ! histo ) histo = (TH1*)GetMergeableObject(fPhysSelKeys->At(isel)->GetName(), fTriggerClasses->At(itrig)->GetName(), fCentralityClasses->GetBinLabel(icent), histoName);
+                    AliDebug(2,Form("Adding %s (%g) to %s (%g)", histoAdd->GetName(), histoAdd->Integral(), histo->GetName(), histo->Integral()));
+                    histo->Add(histoAdd);
+                  } // loop on higher pt matching
+                } // loop on match trigger
+              } // loop on chamber
+            } // loop on count type
+          } // loop on histo type
+        } // loop on eff method
       } // loop on centrality
     } // loop on trigger classes
   } // loop on physics selection
@@ -213,16 +220,7 @@ void AliAnalysisTaskTrigChEff::FinishTaskOutput()
   TString physSel = fPhysSelKeys->At(kPhysSelPass)->GetName();
   TString trigClass = "ANY";
   TString centrality = "all";
-  TString histoPattern = fTrackSelKeys->At(kMatchApt)->GetName();
-  
-  //  for ( Int_t isel=0; isel<kNselections; ++isel ) {
-  //    if ( ! physSel.IsNull() ) physSel.Append(",");
-  //    physSel += ((TObjString*)fPhysSelKeys->At(isel))->GetString();
-  //  }
-  //  for ( Int_t itrig=0; itrig<fTriggerClasses->GetEntries(); ++itrig ) {
-  //    if ( ! trigClass.IsNull() ) trigClass.Append(",");
-  //    trigClass += ((TObjString*)fTriggerClasses->At(itrig))->GetString();
-  //  }
+  TString histoPattern = Form("%s&%s",fTrackSelKeys->At(kMatchApt)->GetName(),fEffMethodKeys->At(kEffFromTrack)->GetName());
   
   FillEffHistoList(physSel, trigClass, centrality, histoPattern, fList);
 
@@ -245,6 +243,9 @@ void AliAnalysisTaskTrigChEff::InitLocalKeys()
   
   TString histoTypeKeys = "Chamber Slat Board checkRejectedBoard";
   fHistoTypeKeys = histoTypeKeys.Tokenize(" ");
+  
+  TString effMethodKeys = "FromTrk FromTrg";
+  fEffMethodKeys = effMethodKeys.Tokenize(" ");
 }
 
 //___________________________________________________________________________
@@ -273,49 +274,51 @@ void AliAnalysisTaskTrigChEff::MyUserCreateOutputObjects()
   TH1* histo;
   TH2F* histo2D;
   
-  for ( Int_t itrackSel = 0; itrackSel<kNtrackSel; ++itrackSel ) {
-    for ( Int_t icount=0; icount<kNcounts; ++icount ) {
-      histoName = GetHistoName(kHchamberEff, icount, -1, itrackSel);
-      histo = new TH1F(histoName, histoName,
-                       nChamberBins, chamberLow, chamberHigh);
-      histo->GetXaxis()->SetTitle(chamberName);
-      histo->GetYaxis()->SetTitle(yAxisTitle);
-      AddObjectToCollection(histo);
-    } // loop on counts
-    
-    for ( Int_t icount=0; icount<kNcounts; ++icount ) {
-      for ( Int_t ich=0; ich<4; ++ich ) {
-        histoName = GetHistoName(kHslatEff, icount, ich, itrackSel);
-        histo = new TH1F(histoName, histoName,
-                         nSlatBins, slatLow, slatHigh);
-        histo->GetXaxis()->SetTitle(slatName);
-        histo->GetYaxis()->SetTitle(yAxisTitle);
-        AddObjectToCollection(histo);
-      } // loop on chamber
-    } // loop on counts
-    
-    for ( Int_t icount=0; icount<kNcounts; ++icount ) {
-      for ( Int_t ich=0; ich<4; ++ich ) {
-        histoName = GetHistoName(kHboardEff, icount, ich, itrackSel);
+  for ( Int_t imethod=0; imethod<kNeffMethods; ++imethod ) {
+    for ( Int_t itrackSel = 0; itrackSel<kNtrackSel; ++itrackSel ) {
+      for ( Int_t icount=0; icount<kNcounts; ++icount ) {
+        histoName = GetHistoName(kHchamberEff, icount, -1, itrackSel, imethod);
         histo = new TH1F(histoName, histoName,
-                         nBoardBins, boardLow, boardHigh);
-        histo->GetXaxis()->SetTitle(boardName);
+                         nChamberBins, chamberLow, chamberHigh);
+        histo->GetXaxis()->SetTitle(chamberName);
         histo->GetYaxis()->SetTitle(yAxisTitle);
         AddObjectToCollection(histo);
-      } // loop on chamber
-    } // loop on counts
-    
-    histoName = GetHistoName(kHcheckBoard, -1, -1, itrackSel);
-    histo2D = new TH2F(histoName.Data(), "Rejected tracks motivation", 
-                       5, 20.5, 25.5, nBoardBins, boardLow, boardHigh);
-    histo2D->GetXaxis()->SetBinLabel(1,"Many pads");
-    histo2D->GetXaxis()->SetBinLabel(2,"Few pads");
-    histo2D->GetXaxis()->SetBinLabel(3,"Outside geom");
-    histo2D->GetXaxis()->SetBinLabel(4,"Tracker track");
-    histo2D->GetXaxis()->SetBinLabel(5,"Masked board");
-    histo2D->GetYaxis()->SetTitle(boardName);
-    AddObjectToCollection(histo2D);
-  } // loop on track selection
+      } // loop on counts
+      
+      for ( Int_t icount=0; icount<kNcounts; ++icount ) {
+        for ( Int_t ich=0; ich<4; ++ich ) {
+          histoName = GetHistoName(kHslatEff, icount, ich, itrackSel, imethod);
+          histo = new TH1F(histoName, histoName,
+                           nSlatBins, slatLow, slatHigh);
+          histo->GetXaxis()->SetTitle(slatName);
+          histo->GetYaxis()->SetTitle(yAxisTitle);
+          AddObjectToCollection(histo);
+        } // loop on chamber
+      } // loop on counts
+      
+      for ( Int_t icount=0; icount<kNcounts; ++icount ) {
+        for ( Int_t ich=0; ich<4; ++ich ) {
+          histoName = GetHistoName(kHboardEff, icount, ich, itrackSel, imethod);
+          histo = new TH1F(histoName, histoName,
+                           nBoardBins, boardLow, boardHigh);
+          histo->GetXaxis()->SetTitle(boardName);
+          histo->GetYaxis()->SetTitle(yAxisTitle);
+          AddObjectToCollection(histo);
+        } // loop on chamber
+      } // loop on counts
+      
+      histoName = GetHistoName(kHcheckBoard, -1, -1, itrackSel, imethod);
+      histo2D = new TH2F(histoName.Data(), "Rejected tracks motivation", 
+                         5, 20.5, 25.5, nBoardBins, boardLow, boardHigh);
+      histo2D->GetXaxis()->SetBinLabel(1,"Many pads");
+      histo2D->GetXaxis()->SetBinLabel(2,"Few pads");
+      histo2D->GetXaxis()->SetBinLabel(3,"Outside geom");
+      histo2D->GetXaxis()->SetBinLabel(4,"Tracker track");
+      histo2D->GetXaxis()->SetBinLabel(5,"Masked board");
+      histo2D->GetYaxis()->SetTitle(boardName);
+      AddObjectToCollection(histo2D);
+    } // loop on track selection
+  } // loop on eff method
 
   fMuonTrackCuts->Print("mask");
   
@@ -326,7 +329,7 @@ void AliAnalysisTaskTrigChEff::MyUserCreateOutputObjects()
 }
 
 //___________________________________________________________________________
-TString AliAnalysisTaskTrigChEff::GetHistoName(Int_t itype, Int_t icount, Int_t ichamber, Int_t itrackSel)
+TString AliAnalysisTaskTrigChEff::GetHistoName(Int_t itype, Int_t icount, Int_t ichamber, Int_t itrackSel, Int_t imethod)
 {
   /// Get histogram index
   TString histoName = "";
@@ -334,6 +337,7 @@ TString AliAnalysisTaskTrigChEff::GetHistoName(Int_t itype, Int_t icount, Int_t
   histoName += ((TObjString*)fHistoTypeKeys->At(itype))->GetString();
   if ( ichamber >= 0 ) histoName += Form("Ch%i", 11+ichamber);
   if ( itrackSel >= 0 ) histoName += ((TObjString*)fTrackSelKeys->At(itrackSel))->GetString();
+  if ( imethod >= 0 ) histoName += ((TObjString*)fEffMethodKeys->At(imethod))->GetString();
   return histoName;
 }
 
@@ -344,13 +348,8 @@ void AliAnalysisTaskTrigChEff::ProcessEvent(TString physSel, const TObjArray& se
   /// Fill histogram
   //
 
-  if ( fAODEvent ) {
-    AliError("Analysis can be done on AliESD only!!!!");
-    return;
-  }
-
   Int_t slat = 0, board = 0;
-  UShort_t pattern = 0;
+  UInt_t pattern = 0;
   TString histoName = "";
 
   TArrayI othersEfficient(4);
@@ -374,82 +373,91 @@ void AliAnalysisTaskTrigChEff::ProcessEvent(TString physSel, const TObjArray& se
     if ( matchTrig == 2 && ( ( selection & AliMuonTrackCuts::kMuMatchLpt ) == 0 ) ) isSelected = kFALSE;
     if ( matchTrig == 3 && ( ( selection & AliMuonTrackCuts::kMuMatchHpt ) == 0 ) ) isSelected = kFALSE;
     if ( ! isSelected ) itrackSel = kNoSelCutApt;
-        
-    pattern = ( fAODEvent ) ? ((AliAODTrack*)track)->GetHitsPatternInTrigCh() :  ((AliESDMuonTrack*)track)->GetHitsPatternInTrigCh();
-    Int_t effFlag = AliESDMuonTrack::GetEffFlag(pattern);
-
-    board = ( fAODEvent ) ? 0 : ((AliESDMuonTrack*)track)->LoCircuit();
-
-    if ( effFlag < AliESDMuonTrack::kChEff ) {
-      for ( Int_t itrig=0; itrig<selectTrigClasses.GetEntries(); ++itrig ) {
-        TString trigClassName = ((TObjString*)selectTrigClasses.At(itrig))->GetString();
 
-        histoName = GetHistoName(kHcheckBoard, -1, -1, itrackSel);
-        ((TH2F*)GetMergeableObject(physSel, trigClassName, centrality, histoName))->Fill(AliESDMuonTrack::GetSlatOrInfo(pattern), board);
+    for ( Int_t imethod=0; imethod<kNeffMethods; ++imethod ) {
+      if ( imethod == kEffFromTrack ) {
+        if ( track->P() < 10. ) continue;
+        pattern = ( fAODEvent ) ? ((AliAODTrack*)track)->GetMUONTrigHitsMapTrk() :  ((AliESDMuonTrack*)track)->GetHitsPatternInTrigChTrk();
+        board = AliESDMuonTrack::GetCrossedBoard(pattern);
       }
-      continue; // Track not good for efficiency calculation
-    }
-
-    othersEfficient.Reset(1);
-    for ( Int_t cath=0; cath<2; ++cath ) {
-      for ( Int_t ich=0; ich<4; ++ich ) {
-        if ( ! AliESDMuonTrack::IsChamberHit(pattern, cath, ich) ) {
-          for ( Int_t jch=0; jch<4; jch++ ) {
-            if ( jch != ich ) othersEfficient[jch] = 0;
-          } // loop on other chambers
-          break;
-        } // if chamber not efficient
-      } // loop on chambers
-    } // loop on cathodes
-
-    Bool_t rejectTrack = kTRUE;
-    for ( Int_t ich=0; ich<4; ++ich ) {
-      if ( othersEfficient[ich] > 0 ) {
-        rejectTrack = kFALSE;
-        break;
+      else {
+        pattern = ( fAODEvent ) ? ((AliAODTrack*)track)->GetMUONTrigHitsMapTrg() :  ((AliESDMuonTrack*)track)->GetHitsPatternInTrigCh();
+        board = ( fAODEvent ) ? AliESDMuonTrack::GetCrossedBoard(pattern) : ((AliESDMuonTrack*)track)->LoCircuit();
       }
-    }
-    
-    if ( rejectTrack ) continue;
-
-    slat = AliESDMuonTrack::GetSlatOrInfo(pattern);
-
-    for ( Int_t ich=0; ich<4; ++ich ) {
-      if ( ! othersEfficient[ich] )
-        continue; // Reject track if the info of the chamber under study 
-                  // is necessary to create the track itself
-      
-      Int_t iChamber = 11 + ich;
       
-      Bool_t hitsBend = AliESDMuonTrack::IsChamberHit(pattern, 0, ich);
-      Bool_t hitsNonBend = AliESDMuonTrack::IsChamberHit(pattern, 1, ich);
+      Int_t effFlag = AliESDMuonTrack::GetEffFlag(pattern);
       
-      Bool_t fillHisto[kNcounts] = {
-        hitsBend,
-        hitsNonBend,
-        ( hitsBend && hitsNonBend ),
-        kTRUE
-      };
-      
-      for (Int_t icount=0; icount<kNcounts; ++icount){
-        if ( ! fillHisto[icount] ) continue;
+      if ( effFlag < AliESDMuonTrack::kChEff ) {
         for ( Int_t itrig=0; itrig<selectTrigClasses.GetEntries(); ++itrig ) {
           TString trigClassName = ((TObjString*)selectTrigClasses.At(itrig))->GetString();
           
-          histoName = GetHistoName(kHchamberEff, icount, -1, itrackSel);
-          ((TH1*)GetMergeableObject(physSel, trigClassName, centrality, histoName))->Fill(iChamber);
-          
-          if ( effFlag < AliESDMuonTrack::kSlatEff ) continue; // Track crossed different slats
-          histoName = GetHistoName(kHslatEff, icount, ich, itrackSel);
-          ((TH1*)GetMergeableObject(physSel, trigClassName, centrality, histoName))->Fill(slat);
-          
-          if ( effFlag < AliESDMuonTrack::kBoardEff ) continue; // Track crossed different boards
-          histoName = GetHistoName(kHboardEff, icount, ich, itrackSel);
-          ((TH1*)GetMergeableObject(physSel, trigClassName, centrality, histoName))->Fill(board);
-        } // loop on trigger classes
-      } // loop on chambers
-    } // loop on count types
-  } // loop on tracks
+          histoName = GetHistoName(kHcheckBoard, -1, -1, itrackSel, imethod);
+          ((TH2F*)GetMergeableObject(physSel, trigClassName, centrality, histoName))->Fill(AliESDMuonTrack::GetSlatOrInfo(pattern), board);
+        }
+        continue; // Track not good for efficiency calculation
+      }
+      
+      othersEfficient.Reset(1);
+      for ( Int_t cath=0; cath<2; ++cath ) {
+        for ( Int_t ich=0; ich<4; ++ich ) {
+          if ( ! AliESDMuonTrack::IsChamberHit(pattern, cath, ich) ) {
+            for ( Int_t jch=0; jch<4; jch++ ) {
+              if ( jch != ich ) othersEfficient[jch] = 0;
+            } // loop on other chambers
+            break;
+          } // if chamber not efficient
+        } // loop on chambers
+      } // loop on cathodes
+      
+      Bool_t rejectTrack = kTRUE;
+      for ( Int_t ich=0; ich<4; ++ich ) {
+        if ( othersEfficient[ich] > 0 ) {
+          rejectTrack = kFALSE;
+          break;
+        }
+      }
+      
+      if ( rejectTrack ) continue;
+      
+      slat = AliESDMuonTrack::GetSlatOrInfo(pattern);
+      
+      for ( Int_t ich=0; ich<4; ++ich ) {
+        if ( ! othersEfficient[ich] )
+          continue; // Reject track if the info of the chamber under study 
+        // is necessary to create the track itself
+        
+        Int_t iChamber = 11 + ich;
+        
+        Bool_t hitsBend = AliESDMuonTrack::IsChamberHit(pattern, 0, ich);
+        Bool_t hitsNonBend = AliESDMuonTrack::IsChamberHit(pattern, 1, ich);
+        
+        Bool_t fillHisto[kNcounts] = {
+          hitsBend,
+          hitsNonBend,
+          ( hitsBend && hitsNonBend ),
+          kTRUE
+        };
+        
+        for (Int_t icount=0; icount<kNcounts; ++icount){
+          if ( ! fillHisto[icount] ) continue;
+          for ( Int_t itrig=0; itrig<selectTrigClasses.GetEntries(); ++itrig ) {
+            TString trigClassName = ((TObjString*)selectTrigClasses.At(itrig))->GetString();
+            
+            histoName = GetHistoName(kHchamberEff, icount, -1, itrackSel, imethod);
+            ((TH1*)GetMergeableObject(physSel, trigClassName, centrality, histoName))->Fill(iChamber);
+            
+            if ( effFlag < AliESDMuonTrack::kSlatEff ) continue; // Track crossed different slats
+            histoName = GetHistoName(kHslatEff, icount, ich, itrackSel, imethod);
+            ((TH1*)GetMergeableObject(physSel, trigClassName, centrality, histoName))->Fill(slat);
+            
+            if ( effFlag < AliESDMuonTrack::kBoardEff ) continue; // Track crossed different boards
+            histoName = GetHistoName(kHboardEff, icount, ich, itrackSel, imethod);
+            ((TH1*)GetMergeableObject(physSel, trigClassName, centrality, histoName))->Fill(board);
+          } // loop on trigger classes
+        } // loop on chambers
+      } // loop on count types
+    } // loop on tracks
+  } // loop on eff methods
   
   PostData(2, fList);
 }
@@ -481,15 +489,20 @@ void AliAnalysisTaskTrigChEff::Terminate(Option_t *)
 
   TString currName = "";
   TObjArray* optArr = furtherOpt.Tokenize(" ");
-  TObjArray trackSel;
+  TObjArray trackSel, methodSel;
   trackSel.SetOwner();
+  methodSel.SetOwner();
   TString outFileOpt = "";
   for ( Int_t iopt=0; iopt<optArr->GetEntries(); iopt++ ) {
     currName = optArr->At(iopt)->GetName();
     if ( currName.Contains(".root") ) outFileOpt = currName;
     else if ( currName.Contains("Match") ) trackSel.Add(new TObjString(currName));
+    else if ( currName.Contains("From") ) methodSel.Add(new TObjString(currName));
   }
   delete optArr;
+  
+  if ( trackSel.GetEntries() == 0 ) trackSel.Add(new TObjString(fTrackSelKeys->At(kMatchApt)->GetName()));
+  if ( methodSel.GetEntries() == 0 ) methodSel.Add(new TObjString(fEffMethodKeys->At(kEffFromTrack)->GetName()));
 
   furtherOpt.ToUpper();
   
@@ -523,78 +536,80 @@ void AliAnalysisTaskTrigChEff::Terminate(Option_t *)
       for ( Int_t isel=0; isel<physSel->GetEntries(); ++isel ) {
         for ( Int_t itrig=0; itrig<trigClasses->GetEntries(); ++itrig ) {
           for ( Int_t icent=0; icent<centrality->GetEntries(); ++icent ) {
-            for ( Int_t itrackSel=0; itrackSel<trackSel.GetEntries(); ++itrackSel ) {
-              histoName = GetHistoName(chosenType, kAllTracks, ich, -1); // partial name
-              histoName += Form("&%s",trackSel.At(itrackSel)->GetName());
-              den = (TH1*)GetSum(physSel->At(isel)->GetName(), trigClasses->At(itrig)->GetName(), centrality->At(icent)->GetName(), histoName.Data());
-              if ( ! den ) continue;
-              histoName = GetHistoName(chosenType, icount, ich, -1); // partial name
-              histoName += Form("&%s",trackSel.At(itrackSel)->GetName());
-              num = (TH1*)GetSum(physSel->At(isel)->GetName(), trigClasses->At(itrig)->GetName(), centrality->At(icent)->GetName(), histoName.Data());
-              if ( ! num ) continue;
-              effGraph = new TGraphAsymmErrors(num, den);
-              currName = Form("%s_%s_%s_%s", physSel->At(isel)->GetName(), trigClasses->At(itrig)->GetName(), centrality->At(icent)->GetName(), trackSel.At(itrackSel)->GetName());
-              effGraph->SetTitle(currName.Data());
-
-              Double_t ymin = 0.;
-              Double_t ymax = 1.1;
-              yAxisTitle = "Efficiency";
-
-              if ( furtherOpt.Contains("DIFF") || furtherOpt.Contains("PULL") ) {
-                if ( ! refGraph ) {
-                  refGraph = effGraph;
-                  continue;
-                }
-                Double_t currX, currY, baseX, baseY, errYlow = 0., errYhigh = 0., newY = 0.;
-                Double_t refVal = 1., errY = 0.; 
-                for ( Int_t ipoint=0; ipoint<effGraph->GetN(); ipoint++ ) {
-                  refGraph->GetPoint(ipoint, baseX, baseY);
-                  effGraph->GetPoint(ipoint, currX, currY);
-                  Double_t errX = effGraph->GetErrorXlow(ipoint);
-                  if ( furtherOpt.Contains("DIFF") ) {
-                    refVal = ( baseY > 0. ) ? baseY : 1.;
-                    newY = ( currY - baseY ) / refVal;
-                    Double_t errYlow1 = effGraph->GetErrorYlow(ipoint);
-                    Double_t errYlow2 = refGraph->GetErrorYlow(ipoint);
-                    Double_t errYhigh1 = effGraph->GetErrorYhigh(ipoint);
-                    Double_t errYhigh2 = refGraph->GetErrorYhigh(ipoint);
-                    errYlow = TMath::Sqrt(errYlow1*errYlow1 + errYlow2*errYlow2) / refVal;
-                    errYhigh = TMath::Sqrt(errYhigh1*errYhigh1 + errYhigh2*errYhigh2) / refVal;
-                    //yAxisTitle = Form("(%s - %s) / %s", effGraph->GetTitle(), refGraph->GetTitle(), refGraph->GetTitle());
-                    yAxisTitle = "(eff - ref ) / ref";
-                    effGraph->SetTitle(Form("Rel. diff. w.r.t. %s", refGraph->GetTitle()));
-                    ymin = -0.1;
-                    ymax = 0.1;
+            for ( Int_t imethodSel=0; imethodSel<methodSel.GetEntries(); ++imethodSel ) {
+              for ( Int_t itrackSel=0; itrackSel<trackSel.GetEntries(); ++itrackSel ) {
+                histoName = GetHistoName(chosenType, kAllTracks, ich, -1, -1); // partial name
+                histoName += Form("&%s&%s",trackSel.At(itrackSel)->GetName(),methodSel.At(imethodSel)->GetName());
+                den = (TH1*)GetSum(physSel->At(isel)->GetName(), trigClasses->At(itrig)->GetName(), centrality->At(icent)->GetName(), histoName.Data());
+                if ( ! den ) continue;
+                histoName = GetHistoName(chosenType, icount, ich, -1, -1); // partial name
+                histoName += Form("&%s&%s",trackSel.At(itrackSel)->GetName(),methodSel.At(imethodSel)->GetName());
+                num = (TH1*)GetSum(physSel->At(isel)->GetName(), trigClasses->At(itrig)->GetName(), centrality->At(icent)->GetName(), histoName.Data());
+                if ( ! num ) continue;
+                effGraph = new TGraphAsymmErrors(num, den);
+                currName = Form("%s_%s_%s_%s_%s", physSel->At(isel)->GetName(), trigClasses->At(itrig)->GetName(), centrality->At(icent)->GetName(), trackSel.At(itrackSel)->GetName(), methodSel.At(imethodSel)->GetName());
+                effGraph->SetTitle(currName.Data());
+
+                Double_t ymin = 0.;
+                Double_t ymax = 1.1;
+                yAxisTitle = "Efficiency";
+
+                if ( furtherOpt.Contains("DIFF") || furtherOpt.Contains("PULL") ) {
+                  if ( ! refGraph ) {
+                    refGraph = effGraph;
+                    continue;
                   }
-                  else if ( furtherOpt.Contains("PULL") ) {
-                    errY = 0.5 * ( effGraph->GetErrorYlow(ipoint) + effGraph->GetErrorYhigh(ipoint));
-                    newY = ( errY > 0. ) ? ( currY - baseY ) / errY : 0.;
-                    errYlow = 1.;
-                    errYhigh = 1.;
-                    //yAxisTitle = Form("( %s - %s ) / err", effGraph->GetTitle(), refGraph->GetTitle());
-                    yAxisTitle = "(eff - ref ) / err";
-                    effGraph->SetTitle(Form("Pull w.r.t. %s", refGraph->GetTitle()));
-                    ymin = -4.;
-                    ymax = 4.;
-                  }
-                  effGraph->SetPoint(ipoint, currX, newY);
-                  effGraph->SetPointError(ipoint, errX, errX, errYlow, errYhigh);
-                } // loop on points
-              }
-              effGraph->GetYaxis()->SetRangeUser(ymin, ymax);
-              effGraph->GetYaxis()->SetTitle(yAxisTitle.Data());
-              effGraph->SetLineColor(icolor);
-              effGraph->SetMarkerColor(icolor);
-              effGraph->SetMarkerStyle(20 + istyle);
-              //effGraph->SetMarkerSize(0.3);
-              icolor++;
-              if ( icolor == 5 || icolor == 10 ) icolor++;
-              istyle++;
-              effGraph->Draw(drawOpt.Data());
-              drawOpt = "P";
-              if ( ich < 3 ) continue;
-              leg->AddEntry(effGraph, currName.Data(), "lp");
-            } // loop on match trigger
+                  Double_t currX, currY, baseX, baseY, errYlow = 0., errYhigh = 0., newY = 0.;
+                  Double_t refVal = 1., errY = 0.; 
+                  for ( Int_t ipoint=0; ipoint<effGraph->GetN(); ipoint++ ) {
+                    refGraph->GetPoint(ipoint, baseX, baseY);
+                    effGraph->GetPoint(ipoint, currX, currY);
+                    Double_t errX = effGraph->GetErrorXlow(ipoint);
+                    if ( furtherOpt.Contains("DIFF") ) {
+                      refVal = ( baseY > 0. ) ? baseY : 1.;
+                      newY = ( currY - baseY ) / refVal;
+                      Double_t errYlow1 = effGraph->GetErrorYlow(ipoint);
+                      Double_t errYlow2 = refGraph->GetErrorYlow(ipoint);
+                      Double_t errYhigh1 = effGraph->GetErrorYhigh(ipoint);
+                      Double_t errYhigh2 = refGraph->GetErrorYhigh(ipoint);
+                      errYlow = TMath::Sqrt(errYlow1*errYlow1 + errYlow2*errYlow2) / refVal;
+                      errYhigh = TMath::Sqrt(errYhigh1*errYhigh1 + errYhigh2*errYhigh2) / refVal;
+                      //yAxisTitle = Form("(%s - %s) / %s", effGraph->GetTitle(), refGraph->GetTitle(), refGraph->GetTitle());
+                      yAxisTitle = "(eff - ref ) / ref";
+                      effGraph->SetTitle(Form("Rel. diff. w.r.t. %s", refGraph->GetTitle()));
+                      ymin = -0.1;
+                      ymax = 0.1;
+                    }
+                    else if ( furtherOpt.Contains("PULL") ) {
+                      errY = 0.5 * ( effGraph->GetErrorYlow(ipoint) + effGraph->GetErrorYhigh(ipoint));
+                      newY = ( errY > 0. ) ? ( currY - baseY ) / errY : 0.;
+                      errYlow = 1.;
+                      errYhigh = 1.;
+                      //yAxisTitle = Form("( %s - %s ) / err", effGraph->GetTitle(), refGraph->GetTitle());
+                      yAxisTitle = "(eff - ref ) / err";
+                      effGraph->SetTitle(Form("Pull w.r.t. %s", refGraph->GetTitle()));
+                      ymin = -4.;
+                      ymax = 4.;
+                    }
+                    effGraph->SetPoint(ipoint, currX, newY);
+                    effGraph->SetPointError(ipoint, errX, errX, errYlow, errYhigh);
+                  } // loop on points
+                }
+                effGraph->GetYaxis()->SetRangeUser(ymin, ymax);
+                effGraph->GetYaxis()->SetTitle(yAxisTitle.Data());
+                effGraph->SetLineColor(icolor);
+                effGraph->SetMarkerColor(icolor);
+                effGraph->SetMarkerStyle(20 + istyle);
+                //effGraph->SetMarkerSize(0.3);
+                icolor++;
+                if ( icolor == 5 || icolor == 10 ) icolor++;
+                istyle++;
+                effGraph->Draw(drawOpt.Data());
+                drawOpt = "P";
+                if ( ich < 3 ) continue;
+                leg->AddEntry(effGraph, currName.Data(), "lp");
+              } // loop on match trigger
+            } // loop on eff method
           } // loop on centrality
         } // loop on trigger classes
       } // loop on physics selection
@@ -627,9 +642,9 @@ void AliAnalysisTaskTrigChEff::Terminate(Option_t *)
           can->Divide(2,2);
         
         for ( Int_t ich=-1; ich<4; ich++ ) {
-          histoName = GetHistoName(baseIndex[itype], icount, ich, -1);
+          histoName = GetHistoName(baseIndex[itype], icount, ich, -1, -1);
           num = (TH1*)fList->FindObject(histoName.Data());
-          histoName = GetHistoName(baseIndex[itype], kNcounts-1, ich, -1);
+          histoName = GetHistoName(baseIndex[itype], kNcounts-1, ich, -1, -1);
           den = (TH1*)fList->FindObject(histoName.Data());
           if ( ! num || ! den ) continue;
           effGraph = new TGraphAsymmErrors(num, den);
@@ -649,9 +664,9 @@ void AliAnalysisTaskTrigChEff::Terminate(Option_t *)
     TObjArray* outFileOptList = outFileOpt.Tokenize("?");
     AliInfo(Form("Creating file %s", outFileOptList->At(0)->GetName()));
     TList* effList = GetEffHistoList(outFileOptList->At(1)->GetName(), outFileOptList->At(2)->GetName(), outFileOptList->At(3)->GetName(), outFileOptList->At(4)->GetName());
-    effList->SetName("triggerChamberEff");
+    effList->SetName(GetOutputSlot(2)->GetContainer()->GetName());
     TFile* outFile = TFile::Open(outFileOptList->At(0)->GetName(), "RECREATE");
-    effList->Write(fList->GetName(),TObject::kSingleKey);
+    effList->Write(effList->GetName(),TObject::kSingleKey);
     outFile->Close();
     delete effList;
     delete outFileOptList;
index 69c0b39..96ff65c 100644 (file)
@@ -63,19 +63,26 @@ class AliAnalysisTaskTrigChEff : public AliVAnalysisMuon {
     kMatchHpt,      ///< Match High Pt
     kNtrackSel      ///< Total number of selection types
   };
+  
+  enum {
+    kEffFromTrack,  ///< Hit pattern from tracker track extrapolation
+    kEffFromTrig,   ///< Hit pattern from trigger
+    kNeffMethods    ///< Total number of efficiency methods
+  };
 
-  TString GetHistoName(Int_t itype, Int_t icount, Int_t ichamber, Int_t imatch);
+  TString GetHistoName(Int_t itype, Int_t icount, Int_t ichamber, Int_t imatch, Int_t imethod);
   Bool_t FillEffHistoList(TString physSel, TString trigClassNames, TString centrality, TString trackSelection, TList* outList = 0x0);
   void InitLocalKeys();
  
   TObjArray* fTrackSelKeys;  ///< Selection names
   TObjArray* fCountTypeKeys; ///< Count type keys
   TObjArray* fHistoTypeKeys; ///< Base histogram name
+  TObjArray* fEffMethodKeys; ///< Efficiency methods keys
 
   Bool_t fUseGhosts; ///< Flag to use also the trigger tracks not matching the tracker in eff. calculation
   TList*  fList;     //!<TList output object
 
-  ClassDef(AliAnalysisTaskTrigChEff, 2); // Trigger chamber efficiencies
+  ClassDef(AliAnalysisTaskTrigChEff, 3); // Trigger chamber efficiencies
 };
 
 #endif
index 130117d..fea3dcb 100644 (file)
@@ -38,6 +38,8 @@ AliAODTrack::AliAODTrack() :
   fFlags(0),
   fLabel(-999),
   fITSMuonClusterMap(0),
+  fMUONtrigHitsMapTrg(0),
+  fMUONtrigHitsMapTrk(0),
   fFilterMap(0),
   fTPCFitMap(),
   fTPCClusterMap(),
@@ -86,6 +88,8 @@ AliAODTrack::AliAODTrack(Short_t id,
   fFlags(0),
   fLabel(label),
   fITSMuonClusterMap(0),
+  fMUONtrigHitsMapTrg(0),
+  fMUONtrigHitsMapTrk(0),
   fFilterMap(selectInfo),
   fTPCFitMap(),
   fTPCClusterMap(),
@@ -138,6 +142,8 @@ AliAODTrack::AliAODTrack(Short_t id,
   fFlags(0),
   fLabel(label),
   fITSMuonClusterMap(0),
+  fMUONtrigHitsMapTrg(0),
+  fMUONtrigHitsMapTrk(0),
   fFilterMap(selectInfo),
   fTPCFitMap(),
   fTPCClusterMap(),
@@ -184,6 +190,8 @@ AliAODTrack::AliAODTrack(const AliAODTrack& trk) :
   fFlags(trk.fFlags),
   fLabel(trk.fLabel),
   fITSMuonClusterMap(trk.fITSMuonClusterMap),
+  fMUONtrigHitsMapTrg(trk.fMUONtrigHitsMapTrg),
+  fMUONtrigHitsMapTrk(trk.fMUONtrigHitsMapTrk),
   fFilterMap(trk.fFilterMap),
   fTPCFitMap(trk.fTPCFitMap),
   fTPCClusterMap(trk.fTPCClusterMap),
@@ -231,6 +239,8 @@ AliAODTrack& AliAODTrack::operator=(const AliAODTrack& trk)
     fFlags             = trk.fFlags;
     fLabel             = trk.fLabel;    
     fITSMuonClusterMap = trk.fITSMuonClusterMap;
+    fMUONtrigHitsMapTrg = trk.fMUONtrigHitsMapTrg;
+    fMUONtrigHitsMapTrk = trk.fMUONtrigHitsMapTrk;
     fFilterMap         = trk.fFilterMap;
     fTPCFitMap         = trk.fTPCFitMap;
     fTPCClusterMap     = trk.fTPCClusterMap;
index 804f28b..8e0b2e6 100644 (file)
@@ -332,6 +332,10 @@ class AliAODTrack : public AliVTrack {
   void SetHitsPatternInTrigCh(UShort_t hitsPatternInTrigCh) { fITSMuonClusterMap = (fITSMuonClusterMap&0xffff00ff)|((((UInt_t)hitsPatternInTrigCh)&0xff)<<8); }
   void SetMuonClusterMap(UInt_t muonClusMap)                { fITSMuonClusterMap = (fITSMuonClusterMap&0xfc00ffff)|((muonClusMap&0x3ff)<<16); }
   void SetITSMuonClusterMap(UInt_t itsMuonClusMap)          { fITSMuonClusterMap = itsMuonClusMap; }
+  void SetMUONtrigHitsMapTrg(UInt_t muonTrigHitsMap) { fMUONtrigHitsMapTrg = muonTrigHitsMap; }
+  UInt_t GetMUONTrigHitsMapTrg() { return fMUONtrigHitsMapTrg; }
+  void SetMUONtrigHitsMapTrk(UInt_t muonTrigHitsMap) { fMUONtrigHitsMapTrk = muonTrigHitsMap; }
+  UInt_t GetMUONTrigHitsMapTrk() { return fMUONtrigHitsMapTrk; }
 
   Int_t GetMatchTrigger() const {return fITSMuonClusterMap>>30;}
                                        //  0 Muon track does not match trigger
@@ -379,6 +383,8 @@ class AliAODTrack : public AliVTrack {
   
   UInt_t        fITSMuonClusterMap; // map of ITS and muon clusters, one bit per layer
                                     // (ITS: bit 1-8, muon trigger: bit 9-16, muon tracker: bit 17-26, muon match trigger: bit 31-32) 
+  UInt_t        fMUONtrigHitsMapTrg; // Muon trigger hits map from trigger
+  UInt_t        fMUONtrigHitsMapTrk; // Muon trigger hits map from tracker track extrapolation
   UInt_t        fFilterMap;         // filter information, one bit per set of cuts
 
   TBits         fTPCFitMap;      // Map of clusters, one bit per padrow; if has a cluster on given padrow which is used in the fit   
index e2c73bd..16d0391 100644 (file)
@@ -69,6 +69,7 @@ AliESDMuonTrack::AliESDMuonTrack ():
   fY4Pattern(0),
   fMuonClusterMap(0),
   fHitsPatternInTrigCh(0),
+  fHitsPatternInTrigChTrk(0),
   fNHit(0),
   fClusters(0x0),
   fClustersId(0x0),
@@ -117,6 +118,7 @@ AliESDMuonTrack::AliESDMuonTrack (const AliESDMuonTrack& muonTrack):
   fY4Pattern(muonTrack.fY4Pattern),
   fMuonClusterMap(muonTrack.fMuonClusterMap),
   fHitsPatternInTrigCh(muonTrack.fHitsPatternInTrigCh),
+  fHitsPatternInTrigChTrk(muonTrack.fHitsPatternInTrigChTrk),
   fNHit(muonTrack.fNHit),
   fClusters(0x0),
   fClustersId(0x0),
@@ -194,6 +196,7 @@ AliESDMuonTrack& AliESDMuonTrack::operator=(const AliESDMuonTrack& muonTrack)
   fChi2MatchTrigger       = muonTrack.fChi2MatchTrigger; 
 
   fHitsPatternInTrigCh    = muonTrack.fHitsPatternInTrigCh;
+  fHitsPatternInTrigChTrk    = muonTrack.fHitsPatternInTrigChTrk;
  
   fMuonClusterMap        = muonTrack.fMuonClusterMap;
 
@@ -295,6 +298,7 @@ void AliESDMuonTrack::Reset()
   fY4Pattern = 0;
   fMuonClusterMap = 0;
   fHitsPatternInTrigCh = 0;
+  fHitsPatternInTrigChTrk = 0;
   fNHit = 0;
   delete fClusters; fClusters = 0x0;
   delete fClustersId; fClustersId = 0x0;
@@ -580,14 +584,15 @@ Int_t AliESDMuonTrack::GetMatchTrigger() const
 }
 
 //_____________________________________________________________________________
-Bool_t AliESDMuonTrack::MatchTriggerDigits() const
+Bool_t AliESDMuonTrack::MatchTriggerDigits(Bool_t fromTrack) const
 {
   // return kTRUE if the track matches a digit on both planes of at least 2 trigger chambers
   
+  UShort_t pattern = ( fromTrack ) ? fHitsPatternInTrigChTrk : fHitsPatternInTrigCh;
   Int_t nMatchedChambers = 0;
   for (Int_t ich=0; ich<4; ich++)
-    if (IsChamberHit(fHitsPatternInTrigCh, 0, ich) &&
-       IsChamberHit(fHitsPatternInTrigCh, 1, ich)) nMatchedChambers++;
+    if (IsChamberHit(pattern, 0, ich) &&
+       IsChamberHit(pattern, 1, ich)) nMatchedChambers++;
   
   return (nMatchedChambers >= 2);
 }
@@ -619,37 +624,45 @@ void AliESDMuonTrack::MoveClustersToESD(AliESDEvent &esd)
 }
 
 //_____________________________________________________________________________
-void AliESDMuonTrack::SetFiredChamber(UShort_t& pattern, Int_t cathode, Int_t chamber)
+void AliESDMuonTrack::SetFiredChamber(UInt_t& pattern, Int_t cathode, Int_t chamber)
 {
   /// Turn on the bit corresponding to fired chameber
   pattern |= (0x1 << ( 7 - ( 4*cathode + chamber )));
 }
 
 //_____________________________________________________________________________
-void AliESDMuonTrack::AddEffInfo(UShort_t& pattern, Int_t slatOrInfo, EAliTriggerChPatternFlag effType)
+void AliESDMuonTrack::AddEffInfo(UInt_t& pattern, Int_t slatOrInfo, Int_t board, EAliTriggerChPatternFlag effType)
 {
   /// Add efficiency flag and crossed RPC or info on rejected track
   pattern |= effType << 8;
   pattern |= slatOrInfo << 10;
+  pattern |= board << 15;
 }
 
 //_____________________________________________________________________________
-Bool_t AliESDMuonTrack::IsChamberHit(UShort_t pattern, Int_t cathode, Int_t chamber)
+Bool_t AliESDMuonTrack::IsChamberHit(UInt_t pattern, Int_t cathode, Int_t chamber)
 { 
   /// Check if chamber was was hit
   return (pattern >> (7 - ( 4*cathode + chamber ))) & 0x1;
 }
 
 //_____________________________________________________________________________
-Int_t AliESDMuonTrack::GetEffFlag(UShort_t pattern)
+Int_t AliESDMuonTrack::GetEffFlag(UInt_t pattern)
 {
   /// Get Efficiency flag
   return (pattern >> 8) & 0x03;
 }
 
 //_____________________________________________________________________________
-Int_t AliESDMuonTrack::GetSlatOrInfo(UShort_t pattern) 
+Int_t AliESDMuonTrack::GetSlatOrInfo(UInt_t pattern) 
 {
   /// Getting crossed slat or info
   return (pattern >> 10) & 0x1F;
 }
+
+//_____________________________________________________________________________
+Int_t AliESDMuonTrack::GetCrossedBoard(UInt_t pattern) 
+{
+  /// Getting crossed board
+  return ( pattern >> 15 ) & 0xFF;
+}
index 2f27d6c..6d73497 100644 (file)
@@ -102,11 +102,13 @@ public:
   
   // Get and Set methods for trigger matching
   Int_t    GetMatchTrigger() const;
-  Bool_t   MatchTriggerDigits() const;
+  Bool_t   MatchTriggerDigits(Bool_t fromTrack) const;
   Double_t GetChi2MatchTrigger() const {return fChi2MatchTrigger;}
   void     SetChi2MatchTrigger(Double_t Chi2MatchTrigger) {fChi2MatchTrigger = Chi2MatchTrigger;}
   UShort_t GetHitsPatternInTrigCh() const {return fHitsPatternInTrigCh;}
   void     SetHitsPatternInTrigCh(UShort_t hitsPatternInTrigCh) {fHitsPatternInTrigCh = hitsPatternInTrigCh;}
+  UInt_t   GetHitsPatternInTrigChTrk() const {return fHitsPatternInTrigChTrk;}
+  void     SetHitsPatternInTrigChTrk(UInt_t hitsPatternInTrigChTrk) {fHitsPatternInTrigChTrk = hitsPatternInTrigChTrk;}
   void     SetLocalTrigger(Int_t locTrig) { fLocalTrigger = locTrig; }
   Int_t    LoCircuit(void) const { return fLocalTrigger & 0xFF;       }
   Int_t    LoStripX(void) const  { return fLocalTrigger >>  8 & 0x1F; }
@@ -220,18 +222,21 @@ public:
     kTrackMatchesManyPads = 21, ///< Track not good for effciency calculation since it matches many pads
     kTrackMatchesFewPads  = 22, ///< Track not good for effciency calculation since it matches pads in less than 3/4 chambers
     kTrackOutsideGeometry = 23, ///< Problems in pattern determination since track extrapolation is outside trigger chambers
-    kTrackerTrackPattern  = 24  ///< The pattern was calculated from a tracker track not matching trigger track
+    kTrackerTrackPattern  = 24, ///< The pattern was calculated from a tracker track not matching trigger track
+    kTrackMatchesMasks    = 25  ///< Track not good for effciency calculation since it matches masked pads
   };
   /// Set hits pattern
-  static void SetFiredChamber(UShort_t& pattern, Int_t cathode, Int_t chamber);
+  static void SetFiredChamber(UInt_t& pattern, Int_t cathode, Int_t chamber);
   /// Add efficiency flag and crossed RPC or info on rejected track
-  static void AddEffInfo(UShort_t& pattern, Int_t slatOrInfo, EAliTriggerChPatternFlag effType = kNoEff);
+  static void AddEffInfo(UInt_t& pattern, Int_t slatOrInfo, Int_t board = 0, EAliTriggerChPatternFlag effType = kNoEff);
   /// Chamber was hit
-  static Bool_t IsChamberHit(UShort_t pattern, Int_t cathode, Int_t chamber);
+  static Bool_t IsChamberHit(UInt_t pattern, Int_t cathode, Int_t chamber);
   /// Get Efficiency flag
-  static Int_t GetEffFlag(UShort_t pattern);
+  static Int_t GetEffFlag(UInt_t pattern);
   /// Getting crossed slat or info
-  static Int_t GetSlatOrInfo(UShort_t pattern);
+  static Int_t GetSlatOrInfo(UInt_t pattern);
+  /// Getting crossed board
+  static Int_t GetCrossedBoard(UInt_t pattern);
 
   AliESDEvent* GetESDEvent() const {return fESDEvent;}
   void         SetESDEvent(AliESDEvent* evt) {fESDEvent = evt;}  
@@ -287,6 +292,7 @@ protected:
   
   UInt_t   fMuonClusterMap;        ///< Map of clusters in tracking chambers
   UShort_t fHitsPatternInTrigCh;   ///< Word containing info on the hits left in trigger chambers
+  UInt_t  fHitsPatternInTrigChTrk; ///< Trigger hit map from tracker track extrapolation
   UChar_t  fNHit;                  ///< number of clusters attached to the track
   
   mutable TClonesArray* fClusters; ///< Array of clusters attached to the track -- deprecated
@@ -297,7 +303,7 @@ protected:
 
   AliESDEvent*   fESDEvent; //!Pointer back to event to which the track belongs
   
-  ClassDef(AliESDMuonTrack,14) // MUON ESD track class 
+  ClassDef(AliESDMuonTrack,15) // MUON ESD track class 
 };
 
 #endif