Adding PiKP-only histograms and eliminating a number of switches where histograms...
[u/mrichter/AliRoot.git] / MUON / AliMUONESDInterface.cxx
index 3c12995..63c73b9 100644 (file)
@@ -23,7 +23,9 @@
 #include "AliMUONVDigit.h"
 #include "AliMUONVDigitStore.h"
 #include "AliMUONLocalTrigger.h"
+#include "AliMUONTriggerTrack.h"
 #include "AliMUONVTriggerStore.h"
+#include "AliMUONVTriggerTrackStore.h"
 #include "AliMUON2DMapIterator.h"
 #include "AliMUONTrackParam.h"
 #include "AliMUONTrackExtrap.h"
@@ -35,7 +37,6 @@
 #include "AliMpExMapIterator.h"
 #include "AliMpVSegmentation.h"
 #include "AliMpSegmentation.h"
-#include "AliMpIntPair.h"
 #include "AliMpPad.h"
 
 #include "AliESDEvent.h"
@@ -49,6 +50,8 @@
 #include <TMath.h>
 #include <TMatrixD.h>
 #include <Riostream.h>
+#include <TGeoGlobalMagField.h>
+#include <TVirtualMagField.h>
 
 //-----------------------------------------------------------------------------
 /// \class AliMUONESDInterface
@@ -61,6 +64,9 @@
 /// 2) loading a whole ESDEvent and using the finders and/or the iterators
 ///    to access the corresponding MUON objects
 ///
+/// note: You can set the recoParam used to refit the MUON track with ResetTracker(...);
+///       By default we use Kalman filter + Smoother
+///
 /// \author Philippe Pillot
 //-----------------------------------------------------------------------------
 
 ClassImp(AliMUONESDInterface)
 /// \endcond
 
+AliMUONRecoParam* AliMUONESDInterface::fgRecoParam = 0x0;
 AliMUONVTrackReconstructor* AliMUONESDInterface::fgTracker = 0x0;
 
 TString AliMUONESDInterface::fgTrackStoreName = "AliMUONTrackStoreV1";
 TString AliMUONESDInterface::fgClusterStoreName = "AliMUONClusterStoreV2";
 TString AliMUONESDInterface::fgDigitStoreName = "AliMUONDigitStoreV2R";
 TString AliMUONESDInterface::fgTriggerStoreName = "AliMUONTriggerStoreV1";
+TString AliMUONESDInterface::fgTriggerTrackStoreName = "AliMUONTriggerTrackStoreV1";
 
 //_____________________________________________________________________________
-AliMUONESDInterface::AliMUONESDInterface(AliMUONRecoParam* recoParam)
+AliMUONESDInterface::AliMUONESDInterface()
 : TObject(),
-fRecoParam(recoParam),
 fTracks(0x0),
 fDigits(0x0),
 fTriggers(0x0),
@@ -138,7 +145,7 @@ void AliMUONESDInterface::Reset()
 }
 
 //_____________________________________________________________________________
-void AliMUONESDInterface::LoadEvent(AliESDEvent& esdEvent)
+void AliMUONESDInterface::LoadEvent(AliESDEvent& esdEvent, Bool_t refit)
 {
   /// Extract MUON data from the given ESD event
   
@@ -159,7 +166,7 @@ void AliMUONESDInterface::LoadEvent(AliESDEvent& esdEvent)
     if (!esdTrack->ContainTrackerData()) continue;
     
     // add it to track store
-    AliMUONTrack* track = Add(GetRecoParam(),*esdTrack, *fTracks);
+    AliMUONTrack* track = Add(*esdTrack, *fTracks, refit);
     
     // prepare cluster map
     AliMpExMap* cMap = new AliMpExMap;
@@ -432,6 +439,45 @@ AliMUONVCluster* AliMUONESDInterface::FindClusterInTrack(const AliMUONTrack& tra
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
 
 //_____________________________________________________________________________
+void AliMUONESDInterface::ResetTracker(const AliMUONRecoParam* recoParam, Bool_t info)
+{
+  /// Reset the MUON tracker using "recoParam" if provided.
+  /// If not provided, will use Kalman filter + Smoother
+  
+  delete fgTracker;
+  delete fgRecoParam;
+  
+  if (recoParam) {
+    
+    fgRecoParam = new AliMUONRecoParam(*recoParam);
+    
+    if (info) cout<<"I-AliMUONESDInterface::ResetTracker: will refit tracks with provided RecoParam:"<<endl;
+    
+  } else {
+    
+    fgRecoParam = AliMUONRecoParam::GetLowFluxParam();
+    
+    cout<<"W-AliMUONESDInterface::ResetTracker: RecoParam not provided. Will use default LowFlux parametrization:"<<endl;
+    
+  }
+  
+  // print useful parameters for refitting
+  if (info) {
+    cout<<"                                     --> Tracking mode = "<<fgRecoParam->GetTrackingMode()<<endl;
+    if (fgRecoParam->UseSmoother()) cout<<"                                     --> Use Smoother"<<endl;
+    else cout<<"                                     --> Do not use smoother"<<endl;
+    cout<<"                                     --> Vertex dispersion in bending direction = "
+    <<fgRecoParam->GetBendingVertexDispersion()<<" cm"<<endl;
+  }
+  
+  if (!TGeoGlobalMagField::Instance()->GetField())
+    cout<<"W-AliMUONESDInterface::ResetTracker: Magnetic field has not been set --> assume field is OFF"<<endl;
+  
+  fgTracker = AliMUONTracker::CreateTrackReconstructor(fgRecoParam,0x0);
+  
+}
+
+//_____________________________________________________________________________
 AliMUONVTrackStore* AliMUONESDInterface::NewTrackStore()
 {
   /// Create an empty track store of type fgTrackStoreName
@@ -479,6 +525,18 @@ AliMUONVTriggerStore* AliMUONESDInterface::NewTriggerStore()
   return reinterpret_cast<AliMUONVTriggerStore*>(classPtr->New());
 }
 
+//_____________________________________________________________________________
+AliMUONVTriggerTrackStore* AliMUONESDInterface::NewTriggerTrackStore()
+{
+  /// Create an empty trigger track store of type fgTriggerTrackStoreName
+  TClass* classPtr = TClass::GetClass(fgTriggerTrackStoreName);
+  if (!classPtr || !classPtr->InheritsFrom("AliMUONVTriggerTrackStore")) {
+    cout<<"E-AliMUONESDInterface::NewTriggerTrackStore: Unable to create store of type "<<fgTriggerTrackStoreName.Data()<<endl;
+    return 0x0;
+  }
+  return reinterpret_cast<AliMUONVTriggerTrackStore*>(classPtr->New());
+}
+
 //_________________________________________________________________________
 void AliMUONESDInterface::GetParamAtVertex(const AliESDMuonTrack& esdTrack, AliMUONTrackParam& trackParam)
 {
@@ -609,9 +667,14 @@ void AliMUONESDInterface::SetParamCov(const AliMUONTrackParam& trackParam, AliES
 }
 
 //_____________________________________________________________________________
-void AliMUONESDInterface::ESDToMUON(const AliMUONRecoParam* recoParam, const AliESDMuonTrack& esdTrack, AliMUONTrack& track)
+void AliMUONESDInterface::ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONTrack& track, Bool_t refit)
 {
-  /// Transfert data from ESDMuon track to MUON track
+  /// Transfert data from ESDMuon track to MUON track.
+  /// If refit = kTRUE, the track parameters at each cluster are obtained by refitting the track
+  /// or by extrapolating the parameters at the first one if the refit failed.
+  /// If refit = kFALSE, only the track parameters at first cluster are valid.
+  /// note: You can set the recoParam used to refit the MUON track with ResetTracker(...);
+  ///       By default we use Kalman filter + Smoother
   
   // if the ESDMuon track is a ghost then return an empty MUON track
   if (!esdTrack.ContainTrackerData()) {
@@ -630,12 +693,12 @@ void AliMUONESDInterface::ESDToMUON(const AliMUONRecoParam* recoParam, const Ali
   track.SetVertexErrXY2(0.,0.);
   track.SetGlobalChi2(esdTrack.GetChi2());
   track.SetMatchTrigger(esdTrack.GetMatchTrigger());
-  track.SetLoTrgNum(-1);
   track.SetChi2MatchTrigger(esdTrack.GetChi2MatchTrigger());
-  track.SetTrackID(0);
   track.SetHitsPatternInTrigCh(esdTrack.GetHitsPatternInTrigCh());
   track.SetLocalTrigger(esdTrack.LoCircuit(), esdTrack.LoStripX(), esdTrack.LoStripY(),
-                       esdTrack.LoDev(), esdTrack.LoLpt(), esdTrack.LoHpt());
+                       esdTrack.LoDev(), esdTrack.LoLpt(), esdTrack.LoHpt(),
+                       esdTrack.GetTriggerWithoutChamber());
+  track.Connected(esdTrack.IsConnected());
   
   // track parameters at vertex
   AliMUONTrackParam paramAtVertex;
@@ -672,22 +735,26 @@ void AliMUONESDInterface::ESDToMUON(const AliMUONRecoParam* recoParam, const Ali
       esdCluster = (AliESDMuonCluster*) esdTrack.GetClusters().After(esdCluster);
     }
     
-    // recompute parameters at first cluster in case of those stored
-    // in ESD are not related to the most upstream cluster
-    AliMUONTrackParam *firstTrackParam = (AliMUONTrackParam*) track.GetTrackParamAtCluster()->First();
-    firstTrackParam->SetZ(esdTrack.GetZUncorrected()); // reset the z to the one stored in ESD
-    AliMUONTrackExtrap::ExtrapToZCov(firstTrackParam,firstTrackParam->GetClusterPtr()->GetZ());
-    
     // refit the track to get better parameters and covariances at each cluster (temporary disable track improvement)
-    if (!fgTracker) fgTracker = AliMUONTracker::CreateTrackReconstructor(recoParam,0x0);
-    if (!fgTracker->RefitTrack(track, kFALSE)) track.UpdateCovTrackParamAtCluster();
+    if (refit) {
+      
+      AliMUONTrackParam *firstTrackParam = (AliMUONTrackParam*) track.GetTrackParamAtCluster()->First();
+      AliMUONTrackParam paramSave(*firstTrackParam);
+      
+      if (!fgTracker) ResetTracker();
+      
+      if (!fgTracker->RefitTrack(track, kFALSE) && track.GetGlobalChi2() < AliMUONTrack::MaxChi2()) {
+       *firstTrackParam = paramSave;
+       track.UpdateCovTrackParamAtCluster();
+      }
+      
+    }
     
   } else {
     
-    // get number of the first hit chamber (according to the MUONClusterMap if not empty)
+    // get number of the first hit chamber according to the MUONClusterMap
     Int_t firstCh = 0;
-    if (esdTrack.GetMuonClusterMap() != 0) while (!esdTrack.IsInMuonClusterMap(firstCh)) firstCh++;
-    else firstCh = AliMUONConstants::ChamberNumber(param.GetZ());
+    while (firstCh < 10 && !esdTrack.IsInMuonClusterMap(firstCh)) firstCh++;
     
     // produce fake cluster at this chamber
     cluster->SetUniqueID(AliMUONVCluster::BuildUniqueID(firstCh, 0, 0));
@@ -699,6 +766,9 @@ void AliMUONESDInterface::ESDToMUON(const AliMUONRecoParam* recoParam, const Ali
     
   }
   
+  // set the MC label from ESD track
+  track.SetMCLabel(esdTrack.GetLabel());
+  
   delete cluster;
   delete cStore;
   
@@ -716,13 +786,14 @@ void AliMUONESDInterface::ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONLoca
     return;
   }
   
+  locTrg.SetUniqueID(esdTrack.GetUniqueID());
   locTrg.SetLoCircuit(esdTrack.LoCircuit());
   locTrg.SetLoStripX(esdTrack.LoStripX());
   locTrg.SetLoStripY(esdTrack.LoStripY());
-  locTrg.SetLoDev(esdTrack.LoDev());
+  locTrg.SetDeviation(esdTrack.LoDev());
   locTrg.SetLoLpt(esdTrack.LoLpt());
   locTrg.SetLoHpt(esdTrack.LoHpt());
-  locTrg.SetLoSdev(1);
+  locTrg.SetTriggerWithoutChamber(esdTrack.GetTriggerWithoutChamber());
   locTrg.SetLoTrigY(1);
   locTrg.SetX1Pattern(esdTrack.GetTriggerX1Pattern());
   locTrg.SetX2Pattern(esdTrack.GetTriggerX2Pattern());
@@ -747,6 +818,7 @@ void AliMUONESDInterface::ESDToMUON(const AliESDMuonCluster& esdCluster, AliMUON
   cluster.SetErrXY(esdCluster.GetErrX(),esdCluster.GetErrY());
   cluster.SetCharge(esdCluster.GetCharge());
   cluster.SetChi2(esdCluster.GetChi2());
+  cluster.SetMCLabel(esdCluster.GetLabel());
   
   if (esdCluster.PadsStored()) {
     Int_t nPads = esdCluster.GetNPads();
@@ -761,8 +833,13 @@ void AliMUONESDInterface::ESDToMUON(const AliESDMuonPad& esdPad, AliMUONVDigit&
 {
   /// Transfert data from ESDMuon pad to MUON digit
   
+  if (!AliMpSegmentation::Instance(kFALSE)) {
+    cout<<"E-AliMUONESDInterface::ESDToMUON: need mapping segmentation to convert ESD pad to MUON digit"<<endl;
+    return;
+  }
+  
   const AliMpVSegmentation* seg = AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(esdPad.GetDetElemId(), esdPad.GetManuId());  
-  AliMpPad pad = seg->PadByLocation(AliMpIntPair(esdPad.GetManuId(), esdPad.GetManuChannel()), kFALSE);
+  AliMpPad pad = seg->PadByLocation(esdPad.GetManuId(), esdPad.GetManuChannel(), kFALSE);
   
   digit.Saturated(esdPad.IsSaturated());
   digit.Used(kFALSE);
@@ -770,7 +847,7 @@ void AliMUONESDInterface::ESDToMUON(const AliESDMuonPad& esdPad, AliMUONVDigit&
   digit.SetUniqueID(esdPad.GetUniqueID());
   digit.SetCharge(esdPad.GetCharge());
   digit.SetADC(esdPad.GetADC());
-  digit.SetPadXY(pad.GetIndices().GetFirst(), pad.GetIndices().GetSecond());
+  digit.SetPadXY(pad.GetIx(), pad.GetIy());
   
 }
 
@@ -799,12 +876,20 @@ void AliMUONESDInterface::MUONToESD(const AliMUONTrack& track, AliESDMuonTrack&
   esdTrack.SetUniqueID(track.GetUniqueID());
   esdTrack.SetChi2(track.GetGlobalChi2());
   esdTrack.SetNHit(track.GetNClusters());
+  esdTrack.SetLabel(track.GetMCLabel());
   
   // set param at first cluster
   AliMUONTrackParam* trackParam = static_cast<AliMUONTrackParam*>((track.GetTrackParamAtCluster())->First());
   SetParamAtFirstCluster(*trackParam, esdTrack);
   SetParamCov(*trackParam, esdTrack);
   
+  // set transverse position at the end of the absorber
+  AliMUONTrackParam trackParamAtAbsEnd(*trackParam);
+  AliMUONTrackExtrap::ExtrapToZ(&trackParamAtAbsEnd, AliMUONConstants::AbsZEnd());
+  Double_t xAbs = trackParamAtAbsEnd.GetNonBendingCoor();
+  Double_t yAbs = trackParamAtAbsEnd.GetBendingCoor();
+  esdTrack.SetRAtAbsorberEnd(TMath::Sqrt(xAbs*xAbs + yAbs*yAbs));
+  
   // set param at vertex
   AliMUONTrackParam trackParamAtVtx(*trackParam);
   AliMUONTrackExtrap::ExtrapToVertex(&trackParamAtVtx, vertex[0], vertex[1], vertex[2], 0., 0.);
@@ -825,6 +910,9 @@ void AliMUONESDInterface::MUONToESD(const AliMUONTrack& track, AliESDMuonTrack&
     trackParam = static_cast<AliMUONTrackParam*>(track.GetTrackParamAtCluster()->After(trackParam));
   }
   
+  // set connected flag
+  esdTrack.Connected(track.IsConnected());
+  
   // set trigger info
   esdTrack.SetLocalTrigger(track.GetLocalTrigger());
   esdTrack.SetChi2MatchTrigger(track.GetChi2MatchTrigger());
@@ -852,7 +940,8 @@ void AliMUONESDInterface::MUONToESD(const AliMUONTrack& track, AliESDMuonTrack&
 }
 
 //_____________________________________________________________________________
-void AliMUONESDInterface::MUONToESD(const AliMUONLocalTrigger& locTrg, AliESDMuonTrack& esdTrack, UInt_t trackId)
+void AliMUONESDInterface::MUONToESD(const AliMUONLocalTrigger& locTrg, AliESDMuonTrack& esdTrack,
+                                   UInt_t trackId, const AliMUONTriggerTrack* triggerTrack)
 {
   /// Build ghost ESDMuon track containing only informations about trigger track
   
@@ -864,12 +953,12 @@ void AliMUONESDInterface::MUONToESD(const AliMUONLocalTrigger& locTrg, AliESDMuo
   muonTrack.SetLocalTrigger(locTrg.LoCircuit(),
                            locTrg.LoStripX(),
                            locTrg.LoStripY(),
-                           locTrg.LoDev(),
+                           locTrg.GetDeviation(),
                            locTrg.LoLpt(),
-                           locTrg.LoHpt());
+                           locTrg.LoHpt(),
+                           locTrg.GetTriggerWithoutChamber());
   esdTrack.SetLocalTrigger(muonTrack.GetLocalTrigger());
   esdTrack.SetChi2MatchTrigger(0.);
-  esdTrack.SetHitsPatternInTrigCh(0);
   esdTrack.SetTriggerX1Pattern(locTrg.GetX1Pattern());
   esdTrack.SetTriggerY1Pattern(locTrg.GetY1Pattern());
   esdTrack.SetTriggerX2Pattern(locTrg.GetX2Pattern());
@@ -878,7 +967,16 @@ void AliMUONESDInterface::MUONToESD(const AliMUONLocalTrigger& locTrg, AliESDMuo
   esdTrack.SetTriggerY3Pattern(locTrg.GetY3Pattern());
   esdTrack.SetTriggerX4Pattern(locTrg.GetX4Pattern());
   esdTrack.SetTriggerY4Pattern(locTrg.GetY4Pattern());
-  
+  UShort_t hitPattern = 0;
+  if(triggerTrack){
+    hitPattern = triggerTrack->GetHitsPatternInTrigCh();
+    esdTrack.SetHitsPatternInTrigCh(hitPattern);
+    esdTrack.SetThetaXUncorrected(triggerTrack->GetThetax());
+    esdTrack.SetThetaYUncorrected(triggerTrack->GetThetay());
+    esdTrack.SetNonBendingCoorUncorrected(triggerTrack->GetX11());
+    esdTrack.SetBendingCoorUncorrected(triggerTrack->GetY11());
+    esdTrack.SetZUncorrected(triggerTrack->GetZ11());
+  }
 }
 
 //_____________________________________________________________________________
@@ -894,6 +992,7 @@ void AliMUONESDInterface::MUONToESD(const AliMUONVCluster& cluster, AliESDMuonCl
   esdCluster.SetErrXY(cluster.GetErrX(), cluster.GetErrY());
   esdCluster.SetCharge(cluster.GetCharge());
   esdCluster.SetChi2(cluster.GetChi2());
+  esdCluster.SetLabel(cluster.GetMCLabel());
   
   if (digits) { // transfert all data if required
     
@@ -924,14 +1023,14 @@ void AliMUONESDInterface::MUONToESD(const AliMUONVDigit& digit, AliESDMuonPad& e
 }
 
 //___________________________________________________________________________
-AliMUONTrack* 
-AliMUONESDInterface::Add(const AliMUONRecoParam* recoParam, const AliESDMuonTrack& esdTrack, AliMUONVTrackStore& trackStore)
+AliMUONTrack* AliMUONESDInterface::Add(const AliESDMuonTrack& esdTrack, AliMUONVTrackStore& trackStore, Bool_t refit)
 {
   /// Create MUON track from ESDMuon track and add it to the store
+  /// Track parameters at each clusters are recomputed or not depending on the flag "refit"
   /// return a pointer to the track into the store (0x0 if the track already exist)
   if(trackStore.FindObject(esdTrack.GetUniqueID())) return 0x0;
   AliMUONTrack* track = trackStore.Add(AliMUONTrack());
-  ESDToMUON(recoParam,esdTrack, *track);
+  ESDToMUON(esdTrack, *track, refit);
   return track;
 }
 
@@ -939,7 +1038,7 @@ AliMUONESDInterface::Add(const AliMUONRecoParam* recoParam, const AliESDMuonTrac
 void AliMUONESDInterface::Add(const AliESDMuonTrack& esdTrack, AliMUONVTriggerStore& triggerStore)
 {
   /// Create MUON local trigger from ESDMuon track and add it to the store if not already there
-  if (triggerStore.FindLocal(esdTrack.LoCircuit())) return;
+  if (!triggerStore.FindLocal(esdTrack.LoCircuit())->IsNull()) return;
   AliMUONLocalTrigger locTrg;
   ESDToMUON(esdTrack, locTrg);
   triggerStore.Add(locTrg);