MUON/AliMUONESDInterface.cxx

   1 /**************************************************************************
   2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3 *                                                                        *
   4 * Author: The ALICE Off-line Project.                                    *
   5 * Contributors are mentioned in the code where appropriate.              *
   6 *                                                                        *
   7 * Permission to use, copy, modify and distribute this software and its   *
   8 * documentation strictly for non-commercial purposes is hereby granted   *
   9 * without fee, provided that the above copyright notice appears in all   *
  10 * copies and that both the copyright notice and this permission notice   *
  11 * appear in the supporting documentation. The authors make no claims     *
  12 * about the suitability of this software for any purpose. It is          *
  13 * provided "as is" without express or implied warranty.                  *
  14 **************************************************************************/
  15
  16 // $Id$
  17
  18 #include "AliMUONESDInterface.h"
  19 #include "AliMUONTrack.h"
  20 #include "AliMUONVTrackStore.h"
  21 #include "AliMUONVCluster.h"
  22 #include "AliMUONVClusterStore.h"
  23 #include "AliMUONVDigit.h"
  24 #include "AliMUONVDigitStore.h"
  25 #include "AliMUONLocalTrigger.h"
  26 #include "AliMUONVTriggerStore.h"
  27 #include "AliMUON2DMapIterator.h"
  28 #include "AliMUONTrackParam.h"
  29 #include "AliMUONTrackExtrap.h"
  30 #include "AliMUONConstants.h"
  31 #include "AliMUONTracker.h"
  32 #include "AliMUONRecoParam.h"
  33 #include "AliMUONVTrackReconstructor.h"
  34
  35 #include "AliMpExMapIterator.h"
  36 #include "AliMpVSegmentation.h"
  37 #include "AliMpSegmentation.h"
  38 #include "AliMpIntPair.h"
  39 #include "AliMpPad.h"
  40
  41 #include "AliESDEvent.h"
  42 #include "AliESDMuonTrack.h"
  43 #include "AliESDMuonCluster.h"
  44 #include "AliESDMuonPad.h"
  45 #include "AliLog.h"
  46
  47 #include <TClass.h>
  48 #include <TIterator.h>
  49 #include <TMath.h>
  50 #include <TMatrixD.h>
  51 #include <Riostream.h>
  52
  53 //-----------------------------------------------------------------------------
  54 /// \class AliMUONESDInterface
  55 ///
  56 /// There are 2 way of using thid converter between MUON track/cluster/digit
  57 /// and ESDMuon track/cluster/pad:
  58 ///
  59 /// 1) using the static methods converting the objects one by one
  60 ///
  61 /// 2) loading a whole ESDEvent and using the finders and/or the iterators
  62 ///    to access the corresponding MUON objects
  63 ///
  64 /// note: You can set the recoParam used to refit the MUON track with ResetTracker(...);
  65 ///       By default we use Kalman filter + Smoother
  66 ///
  67 /// \author Philippe Pillot
  68 //-----------------------------------------------------------------------------
  69
  70 /// \cond CLASSIMP
  71 ClassImp(AliMUONESDInterface)
  72 /// \endcond
  73
  74 AliMUONRecoParam* AliMUONESDInterface::fgRecoParam = 0x0;
  75 AliMUONVTrackReconstructor* AliMUONESDInterface::fgTracker = 0x0;
  76
  77 TString AliMUONESDInterface::fgTrackStoreName = "AliMUONTrackStoreV1";
  78 TString AliMUONESDInterface::fgClusterStoreName = "AliMUONClusterStoreV2";
  79 TString AliMUONESDInterface::fgDigitStoreName = "AliMUONDigitStoreV2R";
  80 TString AliMUONESDInterface::fgTriggerStoreName = "AliMUONTriggerStoreV1";
  81
  82 //_____________________________________________________________________________
  83 AliMUONESDInterface::AliMUONESDInterface()
  84 : TObject(),
  85 fTracks(0x0),
  86 fDigits(0x0),
  87 fTriggers(0x0),
  88 fClusterMap(0x0),
  89 fDigitMap(0x0)
  90 {
  91   /// Default constructor
  92 }
  93
  94 //_____________________________________________________________________________
  95 AliMUONESDInterface::~AliMUONESDInterface()
  96 {
  97   /// Destructor
  98   delete fTracks;
  99   delete fDigits;
 100   delete fTriggers;
 101   delete fClusterMap;
 102   delete fDigitMap;
 103 }
 104
 105 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
 106 //                    methods to play with internal objects                    //
 107 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
 108
 109 //_____________________________________________________________________________
 110 void AliMUONESDInterface::Clear(Option_t*)
 111 {
 112   /// clear memory
 113   delete fTracks; fTracks = 0x0;
 114   delete fDigits; fDigits = 0x0;
 115   delete fTriggers; fTriggers = 0x0;
 116   delete fClusterMap; fClusterMap = 0x0;
 117   delete fDigitMap; fDigitMap = 0x0;
 118 }
 119
 120 //_____________________________________________________________________________
 121 void AliMUONESDInterface::Reset()
 122 {
 123   /// reset stores and maps
 124
 125   if (fTracks) fTracks->Clear("C");
 126   else fTracks = NewTrackStore();
 127
 128   if (fDigits) fDigits->Clear("C");
 129   else fDigits = NewDigitStore();
 130
 131   if (fTriggers) fTriggers->Clear("C");
 132   else fTriggers = NewTriggerStore();
 133
 134   if (fClusterMap) fClusterMap->Clear();
 135   else fClusterMap = new AliMpExMap;
 136   fClusterMap->SetOwner(kTRUE);
 137
 138   if (fDigitMap) fDigitMap->Clear();
 139   else fDigitMap = new AliMpExMap;
 140   fDigitMap->SetOwner(kTRUE);
 141 }
 142
 143 //_____________________________________________________________________________
 144 void AliMUONESDInterface::LoadEvent(AliESDEvent& esdEvent)
 145 {
 146   /// Extract MUON data from the given ESD event
 147
 148   // reset data members
 149   Reset();
 150
 151   // loop over ESD tracks and fill the stores
 152   Int_t nTracks = (Int_t) esdEvent.GetNumberOfMuonTracks();
 153   for (Int_t iTrack = 0; iTrack <  nTracks; iTrack++) {
 154
 155     // get ESD track
 156     AliESDMuonTrack* esdTrack = esdEvent.GetMuonTrack(iTrack);
 157
 158     // fill trigger store if related info are availables
 159     if (esdTrack->ContainTriggerData()) Add(*esdTrack, *fTriggers);
 160
 161     // fill tracker data if availables
 162     if (!esdTrack->ContainTrackerData()) continue;
 163
 164     // add it to track store
 165     AliMUONTrack* track = Add(*esdTrack, *fTracks);
 166
 167     // prepare cluster map
 168     AliMpExMap* cMap = new AliMpExMap;
 169     cMap->SetOwner(kFALSE);
 170     fClusterMap->Add(esdTrack->GetUniqueID(), cMap);
 171
 172     // prepare digit maps
 173     AliMpExMap* dMaps = new AliMpExMap;
 174     dMaps->SetOwner(kTRUE);
 175     fDigitMap->Add(esdTrack->GetUniqueID(), dMaps);
 176
 177     // loop over ESD clusters
 178     Int_t nClusters = esdTrack->GetNClusters();
 179     for (Int_t iCluster = 0; iCluster <  nClusters; iCluster++) {
 180
 181       // get ESD cluster
 182       AliESDMuonCluster *esdCluster = (AliESDMuonCluster*) esdTrack->GetClusters().UncheckedAt(iCluster);
 183
 184       // get the corresponding MUON cluster
 185       AliMUONVCluster* cluster = FindClusterInTrack(*track, esdCluster->GetUniqueID());
 186
 187       // fill cluster map
 188       cMap->Add(cluster->GetUniqueID(), cluster);
 189
 190       // prepare digit map
 191       AliMpExMap* dMap =new AliMpExMap;
 192       dMap->SetOwner(kFALSE);
 193       dMaps->Add(esdCluster->GetUniqueID(), dMap);
 194
 195       // loop over ESD pads
 196       Int_t nPads = esdCluster->GetNPads();
 197       for (Int_t iPad = 0; iPad < nPads; iPad++) {
 198
 199         // get ESD pad
 200         AliESDMuonPad *esdPad = (AliESDMuonPad*) esdCluster->GetPads().UncheckedAt(iPad);
 201
 202         // add it to digit store
 203         AliMUONVDigit* digit = Add(*esdPad, *fDigits);
 204
 205         // fill digit map
 206         if (digit) dMap->Add(esdPad->GetUniqueID(), digit);
 207         else dMap->Add(esdPad->GetUniqueID(), fDigits->FindObject(esdPad->GetUniqueID()));
 208
 209       } // end of loop over pads
 210
 211     } // end of loop over clusters
 212
 213   } // end of loop over tracks
 214
 215 }
 216
 217 //___________________________________________________________________________
 218 Int_t AliMUONESDInterface::GetNTracks() const
 219 {
 220   /// return the number of tracks
 221   return fTracks ? fTracks->GetSize() : 0;
 222 }
 223
 224 //___________________________________________________________________________
 225 Int_t AliMUONESDInterface::GetNClusters() const
 226 {
 227   /// return the number of clusters
 228   Int_t nClusters = 0;
 229   AliMUONTrack *track;
 230   TIter next(CreateTrackIterator());
 231   while ((track = static_cast<AliMUONTrack*>(next()))) nClusters += track->GetNClusters();
 232   return nClusters;
 233 }
 234
 235 //___________________________________________________________________________
 236 Int_t AliMUONESDInterface::GetNClusters(UInt_t trackId) const
 237 {
 238   /// return the number of clusters in track "trackId"
 239   AliMUONTrack* track = FindTrack(trackId);
 240   return track ? track->GetNClusters() : 0;
 241 }
 242
 243 //___________________________________________________________________________
 244 Int_t AliMUONESDInterface::GetNDigits() const
 245 {
 246   /// return the number of digits
 247   return fDigits ? fDigits->GetSize() : 0;
 248 }
 249
 250 //___________________________________________________________________________
 251 Int_t AliMUONESDInterface::GetNDigits(UInt_t trackId) const
 252 {
 253   /// return the number of digits in all clusters of track "trackId"
 254   Int_t nDigits = 0;
 255   AliMUONVCluster *cluster;
 256   TIter next(CreateClusterIterator(trackId));
 257   while ((cluster = static_cast<AliMUONVCluster*>(next()))) nDigits += cluster->GetNDigits();
 258   return nDigits;
 259 }
 260
 261 //___________________________________________________________________________
 262 Int_t AliMUONESDInterface::GetNDigits(UInt_t trackId, UInt_t clusterId) const
 263 {
 264   /// return the number of digits in cluster numbered "iCluster" of track "iTrack"
 265   AliMUONVCluster* cluster = FindCluster(trackId, clusterId);
 266   return cluster ? cluster->GetNDigits() : 0;
 267 }
 268
 269 //___________________________________________________________________________
 270 Int_t AliMUONESDInterface::GetNDigitsInCluster(UInt_t clusterId) const
 271 {
 272   /// return the number of digits in cluster "clusterId"
 273   AliMUONVCluster* cluster = FindCluster(clusterId);
 274   return cluster ? cluster->GetNDigits() : 0;
 275 }
 276
 277 //___________________________________________________________________________
 278 Int_t AliMUONESDInterface::GetNTriggers() const
 279 {
 280   /// return the number of triggers
 281   return fTriggers ? fTriggers->GetSize() : 0;
 282 }
 283
 284 //___________________________________________________________________________
 285 AliMUONTrack* AliMUONESDInterface::FindTrack(UInt_t trackId) const
 286 {
 287   /// return track "trackId" (0x0 if not found)
 288   AliMUONTrack *track = fTracks ? static_cast<AliMUONTrack*>(fTracks->FindObject(trackId)) : 0x0;
 289   if (!track) AliWarning(Form("track %d does not exist",trackId));
 290   return track;
 291 }
 292
 293 //___________________________________________________________________________
 294 AliMUONVCluster* AliMUONESDInterface::FindCluster(UInt_t clusterId) const
 295 {
 296   /// loop over tracks and return the first cluster "clusterId" found (0x0 if not found)
 297   AliMpExMap *cMap;
 298   AliMUONVCluster* cluster = 0x0;
 299
 300   if (fClusterMap) {
 301
 302     TIter next(fClusterMap->CreateIterator());
 303     while ((cMap = static_cast<AliMpExMap*>(next()))) {
 304
 305       cluster = static_cast<AliMUONVCluster*>(cMap->GetValue(clusterId));
 306       if (cluster) return cluster;
 307
 308     }
 309
 310   }
 311
 312   if (!cluster) AliWarning(Form("cluster %d does not exist",clusterId));
 313   return 0x0;
 314 }
 315
 316 //___________________________________________________________________________
 317 AliMUONVCluster* AliMUONESDInterface::FindCluster(UInt_t trackId, UInt_t clusterId) const
 318 {
 319   /// return cluster "clusterId" in track "trackId" (0x0 if not found)
 320   AliMpExMap *cMap = fClusterMap ? static_cast<AliMpExMap*>(fClusterMap->GetValue(trackId)) : 0x0;
 321   AliMUONVCluster* cluster = cMap ? static_cast<AliMUONVCluster*>(cMap->GetValue(clusterId)) : 0x0;
 322   if (!cluster) AliWarning(Form("cluster %d does not exist in track %d", clusterId, trackId));
 323   return cluster;
 324 }
 325
 326 //___________________________________________________________________________
 327 AliMUONVDigit* AliMUONESDInterface::FindDigit(UInt_t digitId) const
 328 {
 329   /// return digit "digitId" (0x0 if not found)
 330   AliMUONVDigit *digit = fDigits ? fDigits->FindObject(digitId) : 0x0;
 331   if (!digit) AliWarning(Form("digit %d does not exist",digitId));
 332   return digit;
 333 }
 334
 335 //___________________________________________________________________________
 336 AliMUONLocalTrigger* AliMUONESDInterface::FindLocalTrigger(Int_t boardNumber) const
 337 {
 338   /// return MUON local trigger "boardNumber"
 339   return (fTriggers) ? fTriggers->FindLocal(boardNumber) : 0x0;
 340 }
 341
 342 //___________________________________________________________________________
 343 TIterator* AliMUONESDInterface::CreateTrackIterator() const
 344 {
 345   /// return iterator over all tracks
 346   return fTracks ? fTracks->CreateIterator() : 0x0;
 347 }
 348
 349 //___________________________________________________________________________
 350 TIterator* AliMUONESDInterface::CreateClusterIterator() const
 351 {
 352   /// return iterator over all clusters
 353   return fClusterMap ? new AliMUON2DMapIterator(*fClusterMap) : 0x0;
 354 }
 355
 356 //___________________________________________________________________________
 357 TIterator* AliMUONESDInterface::CreateClusterIterator(UInt_t trackId) const
 358 {
 359   /// return iterator over clusters of track "trackId"
 360   AliMpExMap *cMap = fClusterMap ? static_cast<AliMpExMap*>(fClusterMap->GetValue(trackId)) : 0x0;
 361   return cMap ? cMap->CreateIterator() : 0x0;
 362 }
 363
 364 //___________________________________________________________________________
 365 TIterator* AliMUONESDInterface::CreateDigitIterator() const
 366 {
 367   /// return iterator over all digits
 368   return fDigits ? fDigits->CreateIterator() : 0x0;
 369 }
 370
 371 //___________________________________________________________________________
 372 TIterator* AliMUONESDInterface::CreateDigitIterator(UInt_t trackId) const
 373 {
 374   /// return iterator over all digits of track "trackId"
 375   AliMpExMap* dMaps = fDigitMap ? static_cast<AliMpExMap*>(fDigitMap->GetValue(trackId)) : 0x0;
 376   return dMaps ? new AliMUON2DMapIterator(*dMaps) : 0x0;
 377 }
 378
 379 //___________________________________________________________________________
 380 TIterator* AliMUONESDInterface::CreateDigitIterator(UInt_t trackId, UInt_t clusterId) const
 381 {
 382   /// return iterator over digits of cluster "clusterId" in track "trackId"
 383   AliMpExMap* dMaps = fDigitMap ? static_cast<AliMpExMap*>(fDigitMap->GetValue(trackId)) : 0x0;
 384   AliMpExMap* dMap = dMaps ? static_cast<AliMpExMap*>(dMaps->GetValue(clusterId)) : 0x0;
 385   return dMap ? dMap->CreateIterator() : 0x0;
 386 }
 387
 388 //___________________________________________________________________________
 389 TIterator* AliMUONESDInterface::CreateDigitIteratorInCluster(UInt_t clusterId) const
 390 {
 391   /// return iterator over digits of the first cluster "clusterId" found by looping over all tracks
 392   AliMpExMap *dMaps;
 393   AliMpExMap* dMap = 0x0;
 394
 395   if (fDigitMap) {
 396
 397     TIter next(fDigitMap->CreateIterator());
 398     while ((dMaps = static_cast<AliMpExMap*>(next()))) {
 399
 400       dMap = static_cast<AliMpExMap*>(dMaps->GetValue(clusterId));
 401       if (dMap) return dMap->CreateIterator();
 402
 403     }
 404
 405   }
 406
 407   return 0x0;
 408 }
 409
 410 //___________________________________________________________________________
 411 TIterator* AliMUONESDInterface::CreateLocalTriggerIterator() const
 412 {
 413   /// return iterator over all local trigger
 414   return fTriggers ? fTriggers->CreateLocalIterator() : 0x0;
 415 }
 416
 417 //___________________________________________________________________________
 418 AliMUONVCluster* AliMUONESDInterface::FindClusterInTrack(const AliMUONTrack& track, UInt_t clusterId) const
 419 {
 420   /// find the cluster with the given Id into the track
 421
 422   Int_t nClusters = track.GetNClusters();
 423   for (Int_t iCluster = 0; iCluster < nClusters; iCluster++) {
 424
 425     AliMUONVCluster* cluster = ((AliMUONTrackParam*) track.GetTrackParamAtCluster()->UncheckedAt(iCluster))->GetClusterPtr();
 426     if (cluster->GetUniqueID() == clusterId) return cluster;
 427
 428   }
 429
 430   return 0x0;
 431 }
 432
 433 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
 434 //                                static methods                               //
 435 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
 436
 437 //_____________________________________________________________________________
 438 void AliMUONESDInterface::ResetTracker(const AliMUONRecoParam* recoParam)
 439 {
 440   /// Reset the MUON tracker using "recoParam" if provided.
 441   /// If not provided, will use Kalman filter + Smoother
 442
 443   delete fgTracker;
 444   delete fgRecoParam;
 445
 446   if (recoParam) {
 447
 448     fgRecoParam = new AliMUONRecoParam(*recoParam);
 449
 450   } else {
 451
 452     fgRecoParam = AliMUONRecoParam::GetLowFluxParam();
 453     fgRecoParam->SetTrackingMode("KALMAN");
 454     fgRecoParam->UseSmoother(kTRUE);
 455     fgRecoParam->SetBendingVertexDispersion(10.);
 456
 457   }
 458
 459   fgTracker = AliMUONTracker::CreateTrackReconstructor(fgRecoParam,0x0);
 460
 461 }
 462
 463 //_____________________________________________________________________________
 464 AliMUONVTrackStore* AliMUONESDInterface::NewTrackStore()
 465 {
 466   /// Create an empty track store of type fgTrackStoreName
 467   TClass* classPtr = TClass::GetClass(fgTrackStoreName);
 468   if (!classPtr || !classPtr->InheritsFrom("AliMUONVTrackStore")) {
 469     cout<<"E-AliMUONESDInterface::NewTrackStore: Unable to create store of type "<<fgTrackStoreName.Data()<<endl;
 470     return 0x0;
 471   }
 472   return reinterpret_cast<AliMUONVTrackStore*>(classPtr->New());
 473 }
 474
 475 //_____________________________________________________________________________
 476 AliMUONVClusterStore* AliMUONESDInterface::NewClusterStore()
 477 {
 478   /// Create an empty cluster store of type fgClusterStoreName
 479   TClass* classPtr = TClass::GetClass(fgClusterStoreName);
 480   if (!classPtr || !classPtr->InheritsFrom("AliMUONVClusterStore")) {
 481     cout<<"E-AliMUONESDInterface::NewClusterStore: Unable to create store of type "<<fgClusterStoreName.Data()<<endl;
 482     return 0x0;
 483   }
 484   return reinterpret_cast<AliMUONVClusterStore*>(classPtr->New());
 485 }
 486
 487 //_____________________________________________________________________________
 488 AliMUONVDigitStore* AliMUONESDInterface::NewDigitStore()
 489 {
 490   /// Create an empty digit store of type fgDigitStoreName
 491   TClass* classPtr = TClass::GetClass(fgDigitStoreName);
 492   if (!classPtr || !classPtr->InheritsFrom("AliMUONVDigitStore")) {
 493     cout<<"E-AliMUONESDInterface::NewDigitStore: Unable to create store of type "<<fgDigitStoreName.Data()<<endl;
 494     return 0x0;
 495   }
 496   return reinterpret_cast<AliMUONVDigitStore*>(classPtr->New());
 497 }
 498
 499 //_____________________________________________________________________________
 500 AliMUONVTriggerStore* AliMUONESDInterface::NewTriggerStore()
 501 {
 502   /// Create an empty trigger store of type fgTriggerStoreName
 503   TClass* classPtr = TClass::GetClass(fgTriggerStoreName);
 504   if (!classPtr || !classPtr->InheritsFrom("AliMUONVTriggerStore")) {
 505     cout<<"E-AliMUONESDInterface::NewTriggerStore: Unable to create store of type "<<fgTriggerStoreName.Data()<<endl;
 506     return 0x0;
 507   }
 508   return reinterpret_cast<AliMUONVTriggerStore*>(classPtr->New());
 509 }
 510
 511 //_________________________________________________________________________
 512 void AliMUONESDInterface::GetParamAtVertex(const AliESDMuonTrack& esdTrack, AliMUONTrackParam& trackParam)
 513 {
 514   /// Get parameters at vertex from ESDMuon track
 515   trackParam.SetZ(esdTrack.GetZ());
 516   trackParam.SetNonBendingCoor(esdTrack.GetNonBendingCoor());
 517   trackParam.SetNonBendingSlope(TMath::Tan(esdTrack.GetThetaX()));
 518   trackParam.SetBendingCoor(esdTrack.GetBendingCoor());
 519   trackParam.SetBendingSlope(TMath::Tan(esdTrack.GetThetaY()));
 520   trackParam.SetInverseBendingMomentum(esdTrack.GetInverseBendingMomentum());
 521 }
 522
 523 //_________________________________________________________________________
 524 void AliMUONESDInterface::GetParamAtDCA(const AliESDMuonTrack& esdTrack, AliMUONTrackParam& trackParam)
 525 {
 526   /// Get parameters at DCA from ESDMuon track
 527   trackParam.SetZ(esdTrack.GetZ());
 528   trackParam.SetNonBendingCoor(esdTrack.GetNonBendingCoorAtDCA());
 529   trackParam.SetNonBendingSlope(TMath::Tan(esdTrack.GetThetaXAtDCA()));
 530   trackParam.SetBendingCoor(esdTrack.GetBendingCoorAtDCA());
 531   trackParam.SetBendingSlope(TMath::Tan(esdTrack.GetThetaYAtDCA()));
 532   trackParam.SetInverseBendingMomentum(esdTrack.GetInverseBendingMomentumAtDCA());
 533 }
 534
 535 //_________________________________________________________________________
 536 void AliMUONESDInterface::GetParamAtFirstCluster(const AliESDMuonTrack& esdTrack, AliMUONTrackParam& trackParam)
 537 {
 538   /// Get parameters at first cluster from ESDMuon track
 539   trackParam.SetZ(esdTrack.GetZUncorrected());
 540   trackParam.SetNonBendingCoor(esdTrack.GetNonBendingCoorUncorrected());
 541   trackParam.SetNonBendingSlope(TMath::Tan(esdTrack.GetThetaXUncorrected()));
 542   trackParam.SetBendingCoor(esdTrack.GetBendingCoorUncorrected());
 543   trackParam.SetBendingSlope(TMath::Tan(esdTrack.GetThetaYUncorrected()));
 544   trackParam.SetInverseBendingMomentum(esdTrack.GetInverseBendingMomentumUncorrected());
 545 }
 546
 547 //_________________________________________________________________________
 548 void AliMUONESDInterface::GetParamCov(const AliESDMuonTrack& esdTrack, AliMUONTrackParam& trackParam)
 549 {
 550   /// Get parameters covariances from ESD track
 551
 552   // get ESD covariance matrix
 553   TMatrixD covariances(5,5);
 554   esdTrack.GetCovariances(covariances);
 555
 556   // compute Jacobian to change the coordinate system
 557   // from (X,thetaX,Y,thetaY,c/pYZ) to (X,slopeX,Y,slopeY,c/pYZ)
 558   Double_t cosThetaX = TMath::Cos(esdTrack.GetThetaXUncorrected());
 559   Double_t cosThetaY = TMath::Cos(esdTrack.GetThetaYUncorrected());
 560   TMatrixD jacob(5,5);
 561   jacob.Zero();
 562   jacob(0,0) = 1.;
 563   jacob(1,1) = 1. / cosThetaX / cosThetaX;
 564   jacob(2,2) = 1.;
 565   jacob(3,3) = 1. / cosThetaY / cosThetaY;
 566   jacob(4,4) = 1.;
 567
 568   // compute covariance matrix in ESD coordinate system
 569   TMatrixD tmp(covariances,TMatrixD::kMultTranspose,jacob);
 570   trackParam.SetCovariances(TMatrixD(jacob,TMatrixD::kMult,tmp));
 571
 572 }
 573
 574 //_________________________________________________________________________
 575 void AliMUONESDInterface::SetParamAtVertex(const AliMUONTrackParam& trackParam, AliESDMuonTrack& esdTrack)
 576 {
 577   /// Set parameters in ESD track
 578   esdTrack.SetZ(trackParam.GetZ());
 579   esdTrack.SetNonBendingCoor(trackParam.GetNonBendingCoor());
 580   esdTrack.SetThetaX(TMath::ATan(trackParam.GetNonBendingSlope()));
 581   esdTrack.SetBendingCoor(trackParam.GetBendingCoor());
 582   esdTrack.SetThetaY(TMath::ATan(trackParam.GetBendingSlope()));
 583   esdTrack.SetInverseBendingMomentum(trackParam.GetInverseBendingMomentum());
 584 }
 585
 586 //_________________________________________________________________________
 587 void AliMUONESDInterface::SetParamAtDCA(const AliMUONTrackParam& trackParam, AliESDMuonTrack& esdTrack)
 588 {
 589   /// Set parameters in ESD track
 590   esdTrack.SetNonBendingCoorAtDCA(trackParam.GetNonBendingCoor());
 591   esdTrack.SetThetaXAtDCA(TMath::ATan(trackParam.GetNonBendingSlope()));
 592   esdTrack.SetBendingCoorAtDCA(trackParam.GetBendingCoor());
 593   esdTrack.SetThetaYAtDCA(TMath::ATan(trackParam.GetBendingSlope()));
 594   esdTrack.SetInverseBendingMomentumAtDCA(trackParam.GetInverseBendingMomentum());
 595 }
 596
 597 //_________________________________________________________________________
 598 void AliMUONESDInterface::SetParamAtFirstCluster(const AliMUONTrackParam& trackParam, AliESDMuonTrack& esdTrack)
 599 {
 600   /// Set parameters in ESD track
 601   esdTrack.SetZUncorrected(trackParam.GetZ());
 602   esdTrack.SetNonBendingCoorUncorrected(trackParam.GetNonBendingCoor());
 603   esdTrack.SetThetaXUncorrected(TMath::ATan(trackParam.GetNonBendingSlope()));
 604   esdTrack.SetBendingCoorUncorrected(trackParam.GetBendingCoor());
 605   esdTrack.SetThetaYUncorrected(TMath::ATan(trackParam.GetBendingSlope()));
 606   esdTrack.SetInverseBendingMomentumUncorrected(trackParam.GetInverseBendingMomentum());
 607 }
 608
 609 //_________________________________________________________________________
 610 void AliMUONESDInterface::SetParamCov(const AliMUONTrackParam& trackParam, AliESDMuonTrack& esdTrack)
 611 {
 612   /// Set parameters covariances in ESD track
 613
 614   // set null matrix if covariances does not exist
 615   if (!trackParam.CovariancesExist()) {
 616     TMatrixD tmp(5,5);
 617     tmp.Zero();
 618     esdTrack.SetCovariances(tmp);
 619     return;
 620   }
 621
 622   // compute Jacobian to change the coordinate system
 623   // from (X,slopeX,Y,slopeY,c/pYZ) to (X,thetaX,Y,thetaY,c/pYZ)
 624   Double_t cosThetaX = TMath::Cos(TMath::ATan(trackParam.GetNonBendingSlope()));
 625   Double_t cosThetaY = TMath::Cos(TMath::ATan(trackParam.GetBendingSlope()));
 626   TMatrixD jacob(5,5);
 627   jacob.Zero();
 628   jacob(0,0) = 1.;
 629   jacob(1,1) = cosThetaX * cosThetaX;
 630   jacob(2,2) = 1.;
 631   jacob(3,3) = cosThetaY * cosThetaY;
 632   jacob(4,4) = 1.;
 633
 634   // compute covariance matrix in ESD coordinate system
 635   TMatrixD tmp(trackParam.GetCovariances(),TMatrixD::kMultTranspose,jacob);
 636   esdTrack.SetCovariances(TMatrixD(jacob,TMatrixD::kMult,tmp));
 637
 638 }
 639
 640 //_____________________________________________________________________________
 641 void AliMUONESDInterface::ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONTrack& track)
 642 {
 643   /// Transfert data from ESDMuon track to MUON track.
 644   /// The track parameters at each cluster are obtained by refitting the track
 645   /// or by extrapolating the parameters at the first one if the refit failed.
 646   /// note: You can set the recoParam used to refit the MUON track with ResetTracker(...);
 647   ///       By default we use Kalman filter + Smoother
 648
 649   // if the ESDMuon track is a ghost then return an empty MUON track
 650   if (!esdTrack.ContainTrackerData()) {
 651     track.Reset();
 652     track.SetUniqueID(esdTrack.GetUniqueID());
 653     return;
 654   }
 655
 656   track.Clear("C");
 657
 658   // global info
 659   track.SetUniqueID(esdTrack.GetUniqueID());
 660   track.FitWithVertex(kFALSE);
 661   track.FitWithMCS(kFALSE);
 662   track.SetImproved(kFALSE);
 663   track.SetVertexErrXY2(0.,0.);
 664   track.SetGlobalChi2(esdTrack.GetChi2());
 665   track.SetMatchTrigger(esdTrack.GetMatchTrigger());
 666   track.SetLoTrgNum(-1);
 667   track.SetChi2MatchTrigger(esdTrack.GetChi2MatchTrigger());
 668   track.SetTrackID(0);
 669   track.SetHitsPatternInTrigCh(esdTrack.GetHitsPatternInTrigCh());
 670   track.SetLocalTrigger(esdTrack.LoCircuit(), esdTrack.LoStripX(), esdTrack.LoStripY(),
 671                         esdTrack.LoDev(), esdTrack.LoLpt(), esdTrack.LoHpt());
 672
 673   // track parameters at vertex
 674   AliMUONTrackParam paramAtVertex;
 675   GetParamAtVertex(esdTrack, paramAtVertex);
 676   track.SetTrackParamAtVertex(&paramAtVertex);
 677
 678   // track parameters at first cluster
 679   AliMUONTrackParam param;
 680   GetParamAtFirstCluster(esdTrack, param);
 681   GetParamCov(esdTrack, param);
 682
 683   // create empty cluster
 684   AliMUONVClusterStore* cStore = NewClusterStore();
 685   if (!cStore) return;
 686   AliMUONVCluster* cluster = cStore->CreateCluster(0,0,0);
 687
 688   // fill TrackParamAtCluster with track parameters at each cluster if available
 689   // or with only track parameters at first (fake) cluster if not
 690   if(esdTrack.ClustersStored()) {
 691
 692     // loop over ESD clusters
 693     AliESDMuonCluster *esdCluster = (AliESDMuonCluster*) esdTrack.GetClusters().First();
 694     while (esdCluster) {
 695
 696       // copy cluster information
 697       ESDToMUON(*esdCluster, *cluster);
 698
 699       // only set the Z parameter to avoid error in the AddTrackParamAtCluster(...) method
 700       param.SetZ(cluster->GetZ());
 701
 702       // add common track parameters at current cluster
 703       track.AddTrackParamAtCluster(param, *cluster, kTRUE);
 704
 705       esdCluster = (AliESDMuonCluster*) esdTrack.GetClusters().After(esdCluster);
 706     }
 707
 708     // recompute parameters at first cluster in case of those stored
 709     // in ESD are not related to the most upstream cluster
 710     AliMUONTrackParam *firstTrackParam = (AliMUONTrackParam*) track.GetTrackParamAtCluster()->First();
 711     firstTrackParam->SetZ(esdTrack.GetZUncorrected()); // reset the z to the one stored in ESD
 712     AliMUONTrackExtrap::ExtrapToZCov(firstTrackParam,firstTrackParam->GetClusterPtr()->GetZ());
 713
 714     // refit the track to get better parameters and covariances at each cluster (temporary disable track improvement)
 715     if (!fgTracker) ResetTracker();
 716     if (!fgTracker->RefitTrack(track, kFALSE)) track.UpdateCovTrackParamAtCluster();
 717
 718   } else {
 719
 720     // get number of the first hit chamber according to the MUONClusterMap
 721     Int_t firstCh = 0;
 722     while (firstCh < 10 && !esdTrack.IsInMuonClusterMap(firstCh)) firstCh++;
 723
 724     // produce fake cluster at this chamber
 725     cluster->SetUniqueID(AliMUONVCluster::BuildUniqueID(firstCh, 0, 0));
 726     cluster->SetXYZ(param.GetNonBendingCoor(), param.GetBendingCoor(), param.GetZ());
 727     cluster->SetErrXY(0., 0.);
 728
 729     // add track parameters at first (fake) cluster
 730     track.AddTrackParamAtCluster(param, *cluster, kTRUE);
 731
 732   }
 733
 734   delete cluster;
 735   delete cStore;
 736
 737 }
 738
 739 //_____________________________________________________________________________
 740 void AliMUONESDInterface::ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONLocalTrigger& locTrg)
 741 {
 742   /// Transfert trigger data from ESDMuon track to the MUONLocalTtrigger object
 743
 744   // if the ESDMuon track is a ghost then return an empty MUON track
 745   if (!esdTrack.ContainTriggerData()) {
 746     AliMUONLocalTrigger emptyLocTrg;
 747     locTrg = emptyLocTrg;
 748     return;
 749   }
 750
 751   locTrg.SetLoCircuit(esdTrack.LoCircuit());
 752   locTrg.SetLoStripX(esdTrack.LoStripX());
 753   locTrg.SetLoStripY(esdTrack.LoStripY());
 754   locTrg.SetDeviation(esdTrack.LoDev());
 755   locTrg.SetLoLpt(esdTrack.LoLpt());
 756   locTrg.SetLoHpt(esdTrack.LoHpt());
 757   locTrg.SetLoTrigY(1);
 758   locTrg.SetX1Pattern(esdTrack.GetTriggerX1Pattern());
 759   locTrg.SetX2Pattern(esdTrack.GetTriggerX2Pattern());
 760   locTrg.SetX3Pattern(esdTrack.GetTriggerX3Pattern());
 761   locTrg.SetX4Pattern(esdTrack.GetTriggerX4Pattern());
 762   locTrg.SetY1Pattern(esdTrack.GetTriggerY1Pattern());
 763   locTrg.SetY2Pattern(esdTrack.GetTriggerY2Pattern());
 764   locTrg.SetY3Pattern(esdTrack.GetTriggerY3Pattern());
 765   locTrg.SetY4Pattern(esdTrack.GetTriggerY4Pattern());
 766
 767 }
 768
 769 //_____________________________________________________________________________
 770 void AliMUONESDInterface::ESDToMUON(const AliESDMuonCluster& esdCluster, AliMUONVCluster& cluster)
 771 {
 772   /// Transfert data from ESDMuon cluster to MUON cluster
 773
 774   cluster.Clear("C");
 775
 776   cluster.SetUniqueID(esdCluster.GetUniqueID());
 777   cluster.SetXYZ(esdCluster.GetX(), esdCluster.GetY(), esdCluster.GetZ());
 778   cluster.SetErrXY(esdCluster.GetErrX(),esdCluster.GetErrY());
 779   cluster.SetCharge(esdCluster.GetCharge());
 780   cluster.SetChi2(esdCluster.GetChi2());
 781
 782   if (esdCluster.PadsStored()) {
 783     Int_t nPads = esdCluster.GetNPads();
 784     for (Int_t iPad = 0; iPad < nPads; iPad++)
 785       cluster.AddDigitId(((AliESDMuonPad*)esdCluster.GetPads().UncheckedAt(iPad))->GetUniqueID());
 786   }
 787
 788 }
 789
 790 //___________________________________________________________________________
 791 void AliMUONESDInterface::ESDToMUON(const AliESDMuonPad& esdPad, AliMUONVDigit& digit)
 792 {
 793   /// Transfert data from ESDMuon pad to MUON digit
 794
 795   const AliMpVSegmentation* seg = AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(esdPad.GetDetElemId(), esdPad.GetManuId());
 796   AliMpPad pad = seg->PadByLocation(AliMpIntPair(esdPad.GetManuId(), esdPad.GetManuChannel()), kFALSE);
 797
 798   digit.Saturated(esdPad.IsSaturated());
 799   digit.Used(kFALSE);
 800   digit.Calibrated(esdPad.IsCalibrated());
 801   digit.SetUniqueID(esdPad.GetUniqueID());
 802   digit.SetCharge(esdPad.GetCharge());
 803   digit.SetADC(esdPad.GetADC());
 804   digit.SetPadXY(pad.GetIndices().GetFirst(), pad.GetIndices().GetSecond());
 805
 806 }
 807
 808 //_____________________________________________________________________________
 809 void AliMUONESDInterface::MUONToESD(const AliMUONTrack& track, AliESDMuonTrack& esdTrack, const Double_t vertex[3],
 810                                     const AliMUONVDigitStore* digits, const AliMUONLocalTrigger* locTrg)
 811 {
 812   /// Transfert data from MUON track to ESDMuon track
 813   /// Incorporate the ESDPads if the digits are provided
 814   /// Add trigger info if the MUON track is matched with a trigger track
 815
 816   // empty MUON track -> produce a ghost ESDMuon track if trigger info are available otherwise produce an empty track
 817   if (track.GetNClusters() == 0) {
 818     if (locTrg) MUONToESD(*locTrg, esdTrack, track.GetUniqueID());
 819     else {
 820       cout<<"W-AliMUONESDInterface::MUONToESD: will produce an empty ESDMuon track"<<endl;
 821       esdTrack.Reset();
 822       esdTrack.SetUniqueID(0xFFFFFFFF);
 823     }
 824     return;
 825   }
 826
 827   esdTrack.Clear("C");
 828
 829   // set global info
 830   esdTrack.SetUniqueID(track.GetUniqueID());
 831   esdTrack.SetChi2(track.GetGlobalChi2());
 832   esdTrack.SetNHit(track.GetNClusters());
 833
 834   // set param at first cluster
 835   AliMUONTrackParam* trackParam = static_cast<AliMUONTrackParam*>((track.GetTrackParamAtCluster())->First());
 836   SetParamAtFirstCluster(*trackParam, esdTrack);
 837   SetParamCov(*trackParam, esdTrack);
 838
 839   // set param at vertex
 840   AliMUONTrackParam trackParamAtVtx(*trackParam);
 841   AliMUONTrackExtrap::ExtrapToVertex(&trackParamAtVtx, vertex[0], vertex[1], vertex[2], 0., 0.);
 842   SetParamAtVertex(trackParamAtVtx, esdTrack);
 843
 844   // set param at Distance of Closest Approach
 845   AliMUONTrackParam trackParamAtDCA(*trackParam);
 846   AliMUONTrackExtrap::ExtrapToVertexWithoutBranson(&trackParamAtDCA, vertex[2]);
 847   SetParamAtDCA(trackParamAtDCA, esdTrack);
 848
 849   // set muon cluster info
 850   AliESDMuonCluster esdCluster;
 851   esdTrack.SetMuonClusterMap(0);
 852   while (trackParam) {
 853     MUONToESD(*(trackParam->GetClusterPtr()), esdCluster, digits);
 854     esdTrack.AddCluster(esdCluster);
 855     esdTrack.AddInMuonClusterMap(esdCluster.GetChamberId());
 856     trackParam = static_cast<AliMUONTrackParam*>(track.GetTrackParamAtCluster()->After(trackParam));
 857   }
 858
 859   // set trigger info
 860   esdTrack.SetLocalTrigger(track.GetLocalTrigger());
 861   esdTrack.SetChi2MatchTrigger(track.GetChi2MatchTrigger());
 862   esdTrack.SetHitsPatternInTrigCh(track.GetHitsPatternInTrigCh());
 863   if (locTrg) {
 864     esdTrack.SetTriggerX1Pattern(locTrg->GetX1Pattern());
 865     esdTrack.SetTriggerY1Pattern(locTrg->GetY1Pattern());
 866     esdTrack.SetTriggerX2Pattern(locTrg->GetX2Pattern());
 867     esdTrack.SetTriggerY2Pattern(locTrg->GetY2Pattern());
 868     esdTrack.SetTriggerX3Pattern(locTrg->GetX3Pattern());
 869     esdTrack.SetTriggerY3Pattern(locTrg->GetY3Pattern());
 870     esdTrack.SetTriggerX4Pattern(locTrg->GetX4Pattern());
 871     esdTrack.SetTriggerY4Pattern(locTrg->GetY4Pattern());
 872   } else {
 873     esdTrack.SetTriggerX1Pattern(0);
 874     esdTrack.SetTriggerY1Pattern(0);
 875     esdTrack.SetTriggerX2Pattern(0);
 876     esdTrack.SetTriggerY2Pattern(0);
 877     esdTrack.SetTriggerX3Pattern(0);
 878     esdTrack.SetTriggerY3Pattern(0);
 879     esdTrack.SetTriggerX4Pattern(0);
 880     esdTrack.SetTriggerY4Pattern(0);
 881   }
 882
 883 }
 884
 885 //_____________________________________________________________________________
 886 void AliMUONESDInterface::MUONToESD(const AliMUONLocalTrigger& locTrg, AliESDMuonTrack& esdTrack, UInt_t trackId)
 887 {
 888   /// Build ghost ESDMuon track containing only informations about trigger track
 889
 890   esdTrack.Reset();
 891   esdTrack.SetUniqueID(trackId);
 892
 893   // set trigger info
 894   AliMUONTrack muonTrack;
 895   muonTrack.SetLocalTrigger(locTrg.LoCircuit(),
 896                             locTrg.LoStripX(),
 897                             locTrg.LoStripY(),
 898                             locTrg.GetDeviation(),
 899                             locTrg.LoLpt(),
 900                             locTrg.LoHpt());
 901   esdTrack.SetLocalTrigger(muonTrack.GetLocalTrigger());
 902   esdTrack.SetChi2MatchTrigger(0.);
 903   esdTrack.SetHitsPatternInTrigCh(0);
 904   esdTrack.SetTriggerX1Pattern(locTrg.GetX1Pattern());
 905   esdTrack.SetTriggerY1Pattern(locTrg.GetY1Pattern());
 906   esdTrack.SetTriggerX2Pattern(locTrg.GetX2Pattern());
 907   esdTrack.SetTriggerY2Pattern(locTrg.GetY2Pattern());
 908   esdTrack.SetTriggerX3Pattern(locTrg.GetX3Pattern());
 909   esdTrack.SetTriggerY3Pattern(locTrg.GetY3Pattern());
 910   esdTrack.SetTriggerX4Pattern(locTrg.GetX4Pattern());
 911   esdTrack.SetTriggerY4Pattern(locTrg.GetY4Pattern());
 912
 913 }
 914
 915 //_____________________________________________________________________________
 916 void AliMUONESDInterface::MUONToESD(const AliMUONVCluster& cluster, AliESDMuonCluster& esdCluster, const AliMUONVDigitStore* digits)
 917 {
 918   /// Transfert data from MUON cluster to ESDMuon cluster
 919   /// Incorporate the ESDPads if the digits are provided
 920
 921   esdCluster.Clear("C");
 922
 923   esdCluster.SetUniqueID(cluster.GetUniqueID());
 924   esdCluster.SetXYZ(cluster.GetX(), cluster.GetY(), cluster.GetZ());
 925   esdCluster.SetErrXY(cluster.GetErrX(), cluster.GetErrY());
 926   esdCluster.SetCharge(cluster.GetCharge());
 927   esdCluster.SetChi2(cluster.GetChi2());
 928
 929   if (digits) { // transfert all data if required
 930
 931     AliESDMuonPad esdPad;
 932     for (Int_t i=0; i<cluster.GetNDigits(); i++) {
 933       AliMUONVDigit* digit = digits->FindObject(cluster.GetDigitId(i));
 934       if (!digit) {
 935         cout<<"E-AliMUONESDInterface::MUONToESD: digit "<<cluster.GetDigitId(i)<<" not found"<<endl;
 936         continue;
 937       }
 938       MUONToESD(*digit, esdPad);
 939       esdCluster.AddPad(esdPad);
 940     }
 941
 942   }
 943
 944 }
 945
 946 //_____________________________________________________________________________
 947 void AliMUONESDInterface::MUONToESD(const AliMUONVDigit& digit, AliESDMuonPad& esdPad)
 948 {
 949   /// Transfert data from MUON digit to ESDMuon pad
 950   esdPad.SetUniqueID(digit.GetUniqueID());
 951   esdPad.SetADC(digit.ADC());
 952   esdPad.SetCharge(digit.Charge());
 953   esdPad.SetCalibrated(digit.IsCalibrated());
 954   esdPad.SetSaturated(digit.IsSaturated());
 955 }
 956
 957 //___________________________________________________________________________
 958 AliMUONTrack* AliMUONESDInterface::Add(const AliESDMuonTrack& esdTrack, AliMUONVTrackStore& trackStore)
 959 {
 960   /// Create MUON track from ESDMuon track and add it to the store
 961   /// return a pointer to the track into the store (0x0 if the track already exist)
 962   if(trackStore.FindObject(esdTrack.GetUniqueID())) return 0x0;
 963   AliMUONTrack* track = trackStore.Add(AliMUONTrack());
 964   ESDToMUON(esdTrack, *track);
 965   return track;
 966 }
 967
 968 //___________________________________________________________________________
 969 void AliMUONESDInterface::Add(const AliESDMuonTrack& esdTrack, AliMUONVTriggerStore& triggerStore)
 970 {
 971   /// Create MUON local trigger from ESDMuon track and add it to the store if not already there
 972   if (triggerStore.FindLocal(esdTrack.LoCircuit())) return;
 973   AliMUONLocalTrigger locTrg;
 974   ESDToMUON(esdTrack, locTrg);
 975   triggerStore.Add(locTrg);
 976 }
 977
 978 //___________________________________________________________________________
 979 AliMUONVCluster* AliMUONESDInterface::Add(const AliESDMuonCluster& esdCluster, AliMUONVClusterStore& clusterStore)
 980 {
 981   /// Create MUON cluster from ESDMuon cluster and add it to the store
 982   /// return a pointer to the cluster into the store (0x0 if the cluster already exist)
 983   AliMUONVCluster* cluster = clusterStore.Add(esdCluster.GetChamberId(), esdCluster.GetDetElemId(), esdCluster.GetClusterIndex());
 984   if (cluster) ESDToMUON(esdCluster, *cluster);
 985   return cluster;
 986 }
 987
 988 //___________________________________________________________________________
 989 AliMUONVDigit* AliMUONESDInterface::Add(const AliESDMuonPad& esdPad, AliMUONVDigitStore& digitStore)
 990 {
 991   /// Create MUON digit from ESDMuon digit and add it to the store
 992   /// return a pointer to the digit into the store (0x0 if the digit already exist)
 993   AliMUONVDigit* digit = digitStore.Add(esdPad.GetDetElemId(), esdPad.GetManuId(), esdPad.GetManuChannel(), esdPad.GetCathode(), AliMUONVDigitStore::kDeny);
 994   if (digit) ESDToMUON(esdPad, *digit);
 995   return digit;
 996 }
 997