MUON/AliMUONReconstructor.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 /* $Id$ */
  16
  17 //-----------------------------
  18 // Class AliMUONReconstructor
  19 //-----------------------------
  20 // Class for the
  21 // MUON track reconstruction
  22
  23 #include "AliMUONReconstructor.h"
  24
  25 #include "AliMUONConstants.h"
  26 #include "AliMUONCalibrationData.h"
  27 #include "AliMUONClusterFinderAZ.h"
  28 #include "AliMUONClusterReconstructor.h"
  29 #include "AliMUONRecData.h"
  30 #include "AliMUONDigitCalibrator.h"
  31 #include "AliMUONEventRecoCombi.h"
  32 #include "AliMUONDigitMaker.h"
  33 #include "AliMUONTrack.h"
  34 #include "AliMUONTrackParam.h"
  35 #include "AliMUONTrackExtrap.h"
  36 #include "AliMUONTracker.h"
  37 #include "AliMUONVTrackReconstructor.h"
  38 #include "AliMUONTrackReconstructor.h"
  39 #include "AliMUONTrackReconstructorK.h"
  40 #include "AliMUONTriggerTrack.h"
  41 #include "AliMUONTriggerCircuit.h"
  42 #include "AliMUONTriggerCrateStore.h"
  43 #include "AliMUONSegFactory.h"
  44 #include "AliMUONSegmentation.h"
  45 #include "AliMUONPreClusterFinder.h"
  46 #include "AliMUONClusterFinderCOG.h"
  47 #include "AliMUONClusterFinderSimpleFit.h"
  48 #include "AliMUONClusterFinderMLEM.h"
  49
  50 #include "AliESD.h"
  51 #include "AliESDMuonTrack.h"
  52 #include "AliLog.h"
  53 #include "AliRawReader.h"
  54 #include "AliRunLoader.h"
  55 #include "AliCDBManager.h"
  56
  57 #include "TTask.h"
  58 #include "TStopwatch.h"
  59 #include "Riostream.h"
  60
  61 /// \cond CLASSIMP
  62 ClassImp(AliMUONReconstructor)
  63 /// \endcond
  64
  65 //_____________________________________________________________________________
  66 AliMUONReconstructor::AliMUONReconstructor()
  67   : AliReconstructor(),
  68     fDigitMaker(new AliMUONDigitMaker()),
  69     fCalibrationData(0x0),
  70     fCrateManager(new AliMUONTriggerCrateStore()),
  71     fTriggerCircuit(new TClonesArray("AliMUONTriggerCircuit", 234)),
  72     fTransformer(new AliMUONGeometryTransformer(kTRUE)),
  73     fSegmentation(0x0),
  74     fMUONData(new AliMUONRecData(0x0,"MUON","MUON"))
  75 {
  76 /// Default constructor
  77
  78     AliDebug(1,"");
  79     // Crate manager
  80     fCrateManager->ReadFromFile();
  81
  82     // set to digit maker
  83     fDigitMaker->SetCrateManager(fCrateManager);
  84
  85     // transformater
  86     fTransformer->ReadGeometryData("volpath.dat", "geometry.root");
  87
  88     // create segmentation and pass it to EventRecoCombi
  89     AliMUONSegFactory factory(fTransformer);
  90     fSegmentation = factory.CreateSegmentation();
  91     AliMUONEventRecoCombi::Instance(fSegmentation);
  92
  93     // trigger circuit
  94     for (Int_t i = 0; i < AliMUONConstants::NTriggerCircuit(); i++)  {
  95       AliMUONTriggerCircuit* c = new AliMUONTriggerCircuit();
  96       c->SetTransformer(fTransformer);
  97       c->Init(i,*fCrateManager);
  98       TClonesArray& circuit = *fTriggerCircuit;
  99       new(circuit[circuit.GetEntriesFast()])AliMUONTriggerCircuit(*c);
 100       delete c;
 101     }
 102
 103
 104 }
 105
 106 //_____________________________________________________________________________
 107 AliMUONReconstructor::~AliMUONReconstructor()
 108 {
 109 /// Destructor
 110
 111   AliDebug(1,"");
 112   delete fCalibrationData;
 113   delete fDigitMaker;
 114   delete fCrateManager;
 115   delete fTriggerCircuit;
 116   delete fTransformer;
 117   delete fSegmentation;
 118   delete fMUONData;
 119 }
 120
 121 //_____________________________________________________________________________
 122 TTask*
 123 AliMUONReconstructor::GetCalibrationTask() const
 124 {
 125 /// Create the calibration task(s).
 126
 127   //const AliRun* run = fRunLoader->GetAliRun();
 128   //Int_t runNumber = run->GetRunNumber();
 129   Int_t runNumber = AliCDBManager::Instance()->GetRun();
 130   AliInfo("Calibration will occur.");
 131
 132   fCalibrationData = new AliMUONCalibrationData(runNumber);
 133   if ( !fCalibrationData->IsValid() )
 134     {
 135       AliError("Could not retrieve calibrations !");
 136       delete fCalibrationData;
 137       fCalibrationData = 0x0;
 138       return 0x0;
 139     }
 140   // Check that we get all the calibrations we'll need
 141   if ( !fCalibrationData->Pedestals() ||
 142        !fCalibrationData->Gains() ||
 143        !fCalibrationData->HV() )
 144   {
 145     AliFatal("Could not access all required calibration data");
 146   }
 147   TTask* calibration = new TTask("MUONCalibrator","MUON Digit calibrator");
 148
 149   TString opt(GetOption());
 150   opt.ToUpper();
 151   Bool_t statusMap(kTRUE);
 152
 153   if ( strstr(opt,"NOSTATUSMAP") )
 154   {
 155     AliWarning("Disconnecting status map : SHOULD BE USED FOR DEBUG ONLY. NOT FOR PRODUCTION !!!");
 156     statusMap = kFALSE;
 157   }
 158   calibration->Add(new AliMUONDigitCalibrator(fMUONData,fCalibrationData,statusMap));
 159   return calibration;
 160 }
 161
 162 //_____________________________________________________________________________
 163 AliMUONClusterReconstructor*
 164 AliMUONReconstructor::CreateClusterReconstructor() const
 165 {
 166 /// Create cluster reconstructor
 167
 168   AliMUONVClusterFinder* clusterFinder(0x0);
 169
 170   TString opt(GetOption());
 171   opt.ToUpper();
 172
 173   if ( strstr(opt,"PRECLUSTER") )
 174   {
 175     clusterFinder = new AliMUONPreClusterFinder;
 176   }
 177   else if ( strstr(opt,"COG") )
 178   {
 179     clusterFinder = new AliMUONClusterFinderCOG;
 180   }
 181   else if ( strstr(opt,"SIMPLEFIT") )
 182   {
 183     clusterFinder = new AliMUONClusterFinderSimpleFit;
 184   }
 185   else if ( strstr(opt,"MLEM:DRAW") )
 186   {
 187     clusterFinder = new AliMUONClusterFinderMLEM(kTRUE);
 188   }
 189   else if ( strstr(opt,"MLEM") )
 190   {
 191     clusterFinder = new AliMUONClusterFinderMLEM(kFALSE);
 192   }
 193
 194   if ( clusterFinder)
 195   {
 196     AliInfo(Form("Will use %s for clusterizing",clusterFinder->ClassName()));
 197   }
 198
 199   AliMUONClusterReconstructor* clusterReco =
 200     new AliMUONClusterReconstructor(fMUONData,clusterFinder,fTransformer);
 201   return clusterReco;
 202 }
 203
 204 //_____________________________________________________________________________
 205 void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader) const
 206 {
 207 /// Reconstruct
 208 /// \todo add more
 209
 210   AliLoader* loader = runLoader->GetLoader("MUONLoader");
 211   Int_t nEvents     = runLoader->GetNumberOfEvents();
 212   Int_t evtNumber   = runLoader->GetEventNumber();
 213
 214   fMUONData->SetLoader(loader);
 215
 216 // passing loader as argument.
 217   AliMUONVTrackReconstructor* recoEvent;
 218   if (strstr(GetOption(),"Original")) recoEvent = new AliMUONTrackReconstructor(fMUONData);
 219   else if (strstr(GetOption(),"Combi")) recoEvent = new AliMUONTrackReconstructorK(fMUONData,"Combi");
 220   else recoEvent = new AliMUONTrackReconstructorK(fMUONData,"Kalman");
 221
 222   recoEvent->SetTriggerCircuit(fTriggerCircuit);
 223
 224   AliMUONClusterReconstructor* recoCluster = CreateClusterReconstructor();
 225
 226   AliMUONClusterFinderVS *recModel = recoCluster->GetRecoModel();
 227
 228   if (!strstr(GetOption(),"VS")) {
 229     recModel = (AliMUONClusterFinderVS*) new AliMUONClusterFinderAZ();
 230     recoCluster->SetRecoModel(recModel);
 231   }
 232   recModel->SetGhostChi2Cut(10);
 233   recModel->SetEventNumber(evtNumber);
 234
 235   loader->LoadDigits("READ");
 236   loader->LoadRecPoints("RECREATE");
 237   loader->LoadTracks("RECREATE");
 238
 239   TTask* calibration = GetCalibrationTask();
 240
 241   Int_t chBeg = (strstr(GetOption(),"Combi") ? 6 : 0);
 242
 243   //   Loop over events
 244   for(Int_t ievent = 0; ievent < nEvents; ievent++) {
 245
 246     AliDebug(1,Form("Event %d",ievent));
 247
 248     runLoader->GetEvent(ievent);
 249
 250     //----------------------- digit2cluster & Trigger2Trigger -------------------
 251     if (!loader->TreeR()) loader->MakeRecPointsContainer();
 252
 253     // tracking branch
 254     if (!strstr(GetOption(),"Combi")) {
 255       fMUONData->MakeBranch("RC");
 256       fMUONData->SetTreeAddress("D,RC");
 257     } else {
 258       fMUONData->SetTreeAddress("D");
 259       fMUONData->SetTreeAddress("RCC");
 260     }
 261     // Important for avoiding a memory leak when reading digits ( to be investigated more in detail)
 262     // In any case the reading of GLT is needed for the Trigger2Tigger method below
 263     fMUONData->SetTreeAddress("GLT");
 264
 265     fMUONData->GetDigits();
 266
 267     if ( calibration )
 268     {
 269       calibration->ExecuteTask();
 270     }
 271
 272     recoCluster->Digits2Clusters(chBeg);
 273
 274     if (strstr(GetOption(),"Combi")) {
 275       // Combined cluster / track finder
 276       AliMUONEventRecoCombi::Instance()->FillEvent(fMUONData, (AliMUONClusterFinderAZ*)recModel);
 277       ((AliMUONClusterFinderAZ*) recModel)->SetReco(2);
 278     }
 279     else fMUONData->Fill("RC");
 280
 281     // trigger branch
 282     fMUONData->MakeBranch("TC");
 283     fMUONData->SetTreeAddress("TC");
 284     recoCluster->Trigger2Trigger();
 285     fMUONData->Fill("TC");
 286
 287     //AZ loader->WriteRecPoints("OVERWRITE");
 288
 289     //---------------------------- Track & TriggerTrack ---------------------
 290     if (!loader->TreeT()) loader->MakeTracksContainer();
 291
 292     // trigger branch
 293     fMUONData->MakeBranch("RL"); //trigger track
 294     fMUONData->SetTreeAddress("RL");
 295     recoEvent->EventReconstructTrigger();
 296     fMUONData->Fill("RL");
 297
 298     // tracking branch
 299     fMUONData->MakeBranch("RT"); //track
 300     fMUONData->SetTreeAddress("RT");
 301     recoEvent->EventReconstruct();
 302     fMUONData->Fill("RT");
 303
 304     loader->WriteTracks("OVERWRITE");
 305
 306     if (strstr(GetOption(),"Combi")) {
 307       // Combined cluster / track
 308       ((AliMUONClusterFinderAZ*) recModel)->SetReco(1);
 309       fMUONData->MakeBranch("RC");
 310       fMUONData->SetTreeAddress("RC");
 311       AliMUONEventRecoCombi::Instance()->FillRecP(fMUONData, (AliMUONTrackReconstructorK*)recoEvent);
 312       fMUONData->Fill("RC");
 313     }
 314     loader->WriteRecPoints("OVERWRITE");
 315
 316     //--------------------------- Resetting branches -----------------------
 317     fMUONData->ResetDigits();
 318     fMUONData->ResetRawClusters();
 319     fMUONData->ResetTrigger();
 320     fMUONData->ResetRecTracks();
 321     fMUONData->ResetRecTriggerTracks();
 322
 323   }
 324   loader->UnloadDigits();
 325   loader->UnloadRecPoints();
 326   loader->UnloadTracks();
 327
 328   delete recoCluster;
 329   delete recoEvent;
 330   delete calibration;
 331 }
 332
 333 //_____________________________________________________________________________
 334 void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader,
 335                                        AliRawReader* rawReader) const
 336 {
 337 /// Recontruct
 338 /// \todo add more
 339
 340   //  AliLoader
 341   AliLoader* loader = runLoader->GetLoader("MUONLoader");
 342   Int_t evtNumber   = runLoader->GetEventNumber();
 343
 344   fMUONData->SetLoader(loader);
 345
 346   // passing loader as argument.
 347   fDigitMaker->SetMUONData(fMUONData);
 348
 349   // disable trigger rawdata reading
 350   if (strstr(GetOption(),"TriggerDisable"))
 351       fDigitMaker->DisableTrigger();
 352
 353   AliMUONClusterReconstructor* recoCluster = CreateClusterReconstructor();
 354
 355   AliMUONClusterFinderVS *recModel = recoCluster->GetRecoModel();
 356
 357   if (!strstr(GetOption(),"VS"))
 358   {
 359     recModel = (AliMUONClusterFinderVS*) new AliMUONClusterFinderAZ();
 360     recoCluster->SetRecoModel(recModel);
 361   }
 362   recModel->SetGhostChi2Cut(10);
 363   recModel->SetEventNumber(evtNumber);
 364
 365   TTask* calibration = GetCalibrationTask();
 366
 367   loader->LoadRecPoints("RECREATE");
 368
 369   // Digits are not stored on disk and created on flight from rawdata.
 370   // In order to write digits on disk the following line should be uncommented
 371   // loader->LoadDigits("RECREATE");
 372
 373   //   Loop over events
 374   Int_t iEvent = 0;
 375
 376   TStopwatch totalTimer;
 377   TStopwatch rawTimer;
 378   TStopwatch calibTimer;
 379   TStopwatch clusterTimer;
 380
 381   rawTimer.Start(kTRUE); rawTimer.Stop();
 382   calibTimer.Start(kTRUE); calibTimer.Stop();
 383   clusterTimer.Start(kTRUE); clusterTimer.Stop();
 384
 385   totalTimer.Start(kTRUE);
 386
 387   while (rawReader->NextEvent())
 388   {
 389     AliDebug(1,Form("Event %d",iEvent));
 390
 391     runLoader->GetEvent(iEvent++);
 392
 393     //----------------------- raw2digits & raw2trigger-------------------
 394     //  if (!loader->TreeD())
 395     //  {
 396     //    AliDebug(1,Form("Making Digit Container for event %d",iEvent));
 397     //    loader->MakeDigitsContainer();
 398     //  }
 399     // Write digits from raw data on disk
 400     if (strstr(GetOption(),"SAVEDIGITS")) {
 401         if (!loader->TreeD())fMUONData->GetLoader()->MakeDigitsContainer();
 402         fMUONData->MakeBranch("D,GLT");
 403         fMUONData->SetTreeAddress("D,GLT");
 404         AliInfo("Digits from raw data will be stored.");
 405     }
 406     else {
 407         fMUONData->SetDataContainer("D, GLT");
 408     }
 409     rawTimer.Start(kFALSE);
 410     fDigitMaker->Raw2Digits(rawReader);
 411     rawTimer.Stop();
 412
 413     if ( calibration )
 414     {
 415       calibTimer.Start(kFALSE);
 416       calibration->ExecuteTask();
 417       calibTimer.Stop();
 418     }
 419
 420     // Write digits from raw data on disk
 421     if (strstr(GetOption(),"SAVEDIGITS")) {
 422         fMUONData->Fill("D,GLT");
 423         loader->WriteDigits("OVERWRITE");
 424     }
 425     //----------------------- digit2cluster & Trigger2Trigger -------------------
 426     clusterTimer.Start(kFALSE);
 427
 428     if (!loader->TreeR()) loader->MakeRecPointsContainer();
 429
 430     // tracking branch
 431     fMUONData->MakeBranch("RC");
 432     fMUONData->SetTreeAddress("RC");
 433     recoCluster->Digits2Clusters();
 434     fMUONData->Fill("RC");
 435
 436     // trigger branch
 437     fMUONData->MakeBranch("TC");
 438     fMUONData->SetTreeAddress("TC");
 439     fMUONData->Fill("TC");
 440
 441     loader->WriteRecPoints("OVERWRITE");
 442
 443     clusterTimer.Stop();
 444
 445
 446     //--------------------------- Resetting branches -----------------------
 447     fMUONData->ResetDigits();
 448     fMUONData->ResetRawClusters();
 449     fMUONData->ResetTrigger();
 450   }
 451
 452   totalTimer.Stop();
 453
 454   loader->UnloadRecPoints();
 455   loader->UnloadDigits();
 456
 457   delete recoCluster;
 458   delete calibration;
 459
 460   AliInfo(Form("Execution time for converting RAW data to digits in MUON : R:%.2fs C:%.2fs",
 461                rawTimer.RealTime(),rawTimer.CpuTime()));
 462   AliInfo(Form("Execution time for calibrating MUON : R:%.2fs C:%.2fs",
 463                calibTimer.RealTime(),calibTimer.CpuTime()));
 464   AliInfo(Form("Execution time for clusterizing MUON : R:%.2fs C:%.2fs",
 465                clusterTimer.RealTime(),clusterTimer.CpuTime()));
 466   AliInfo(Form("Total Execution time for Reconstruct(from raw) MUON : R:%.2fs C:%.2fs",
 467                totalTimer.RealTime(),totalTimer.CpuTime()));
 468 }
 469
 470 //_____________________________________________________________________________
 471 void AliMUONReconstructor::FillESD(AliRunLoader* runLoader, AliESD* esd) const
 472 {
 473 /// Fill ESD
 474 /// \todo add more
 475
 476   TClonesArray* recTracksArray = 0;
 477   TClonesArray* recTrigTracksArray = 0;
 478
 479   AliLoader* loader = runLoader->GetLoader("MUONLoader");
 480   loader->LoadTracks("READ");
 481   fMUONData->SetLoader(loader);
 482
 483    // declaration
 484   Int_t iEvent;// nPart;
 485   Int_t nTrackHits;// nPrimary;
 486   Double_t fitFmin, chi2MatchTrigger;
 487   Double_t xRec, yRec, zRec, bendingSlope, nonBendingSlope, inverseBendingMomentum;
 488   Double_t xVtx, yVtx, zVtx, bendingSlopeAtVtx, nonBendingSlopeAtVtx, inverseBendingMomentumAtVtx;
 489   Int_t matchTrigger;
 490   UShort_t hitsPatternInTrigCh;
 491
 492   // setting pointer for tracks, triggertracks & trackparam at vertex
 493   AliMUONTrack* recTrack = 0;
 494   AliMUONTrackParam trackParamAtVtx;
 495   AliMUONTriggerTrack* recTriggerTrack = 0;
 496
 497   iEvent = runLoader->GetEventNumber();
 498   runLoader->GetEvent(iEvent);
 499
 500   // Get vertex
 501   Double_t vertex[3] = {0};
 502   const AliESDVertex *esdVert = esd->GetVertex();
 503   if (esdVert->GetNContributors()) {
 504     esdVert->GetXYZ(vertex);
 505     AliDebug(1, "find vertex\n");
 506   }
 507   // setting ESD MUON class
 508   AliESDMuonTrack* theESDTrack = new  AliESDMuonTrack() ;
 509
 510   //-------------------- trigger tracks-------------
 511   Long_t trigPat = 0;
 512   fMUONData->SetTreeAddress("RL");
 513   fMUONData->GetRecTriggerTracks();
 514   recTrigTracksArray = fMUONData->RecTriggerTracks();
 515
 516   // ready global trigger pattern from first track
 517   if (recTrigTracksArray)
 518     recTriggerTrack = (AliMUONTriggerTrack*) recTrigTracksArray->First();
 519   if (recTriggerTrack) trigPat = recTriggerTrack->GetGTPattern();
 520
 521   //printf(">>> Event %d Number of Recconstructed tracks %d \n",iEvent, nrectracks);
 522
 523   // -------------------- tracks-------------
 524   fMUONData->SetTreeAddress("RT");
 525   fMUONData->GetRecTracks();
 526   recTracksArray = fMUONData->RecTracks();
 527
 528   Int_t nRecTracks = 0;
 529   if (recTracksArray)
 530     nRecTracks = (Int_t) recTracksArray->GetEntriesFast(); //
 531
 532   // loop over tracks
 533   for (Int_t iRecTracks = 0; iRecTracks <  nRecTracks;  iRecTracks++) {
 534
 535     // reading info from tracks
 536     recTrack = (AliMUONTrack*) recTracksArray->At(iRecTracks);
 537     AliMUONTrackParam *trackParam = (AliMUONTrackParam*) (recTrack->GetTrackParamAtHit())->First();
 538     trackParamAtVtx = *trackParam;
 539
 540     // extrapolate to the vertex if available, else to (0,0,0)
 541     if (esdVert->GetNContributors())
 542       AliMUONTrackExtrap::ExtrapToVertex(&trackParamAtVtx, vertex[0],vertex[1],vertex[2]);
 543     else
 544       AliMUONTrackExtrap::ExtrapToVertex(&trackParamAtVtx, 0.,0.,0.);
 545
 546     // Track parameters at first station
 547     bendingSlope           = trackParam->GetBendingSlope();
 548     nonBendingSlope        = trackParam->GetNonBendingSlope();
 549     inverseBendingMomentum = trackParam->GetInverseBendingMomentum();
 550     xRec = trackParam->GetNonBendingCoor();
 551     yRec = trackParam->GetBendingCoor();
 552     zRec = trackParam->GetZ();
 553
 554     // Track parameters at vertex
 555     bendingSlopeAtVtx           = trackParamAtVtx.GetBendingSlope();
 556     nonBendingSlopeAtVtx        = trackParamAtVtx.GetNonBendingSlope();
 557     inverseBendingMomentumAtVtx = trackParamAtVtx.GetInverseBendingMomentum();
 558     xVtx = trackParamAtVtx.GetNonBendingCoor();
 559     yVtx = trackParamAtVtx.GetBendingCoor();
 560     zVtx = trackParamAtVtx.GetZ();
 561
 562     // Global info
 563     nTrackHits       = recTrack->GetNTrackHits();
 564     fitFmin          = recTrack->GetFitFMin();
 565     matchTrigger     = recTrack->GetMatchTrigger();
 566     chi2MatchTrigger = recTrack->GetChi2MatchTrigger();
 567     hitsPatternInTrigCh = recTrack->GetHitsPatternInTrigCh();
 568
 569     // setting data member of ESD MUON
 570     // at first station
 571     theESDTrack->SetInverseBendingMomentumUncorrected(inverseBendingMomentum);
 572     theESDTrack->SetThetaXUncorrected(TMath::ATan(nonBendingSlope));
 573     theESDTrack->SetThetaYUncorrected(TMath::ATan(bendingSlope));
 574     theESDTrack->SetZUncorrected(zRec);
 575     theESDTrack->SetBendingCoorUncorrected(yRec);
 576     theESDTrack->SetNonBendingCoorUncorrected(xRec);
 577     // at vertex
 578     theESDTrack->SetInverseBendingMomentum(inverseBendingMomentumAtVtx);
 579     theESDTrack->SetThetaX(TMath::ATan(nonBendingSlopeAtVtx));
 580     theESDTrack->SetThetaY(TMath::ATan(bendingSlopeAtVtx));
 581     theESDTrack->SetZ(zVtx);
 582     theESDTrack->SetBendingCoor(yVtx);
 583     theESDTrack->SetNonBendingCoor(xVtx);
 584     // global info
 585     theESDTrack->SetChi2(fitFmin);
 586     theESDTrack->SetNHit(nTrackHits);
 587     theESDTrack->SetMatchTrigger(matchTrigger);
 588     theESDTrack->SetChi2MatchTrigger(chi2MatchTrigger);
 589     theESDTrack->SetHitsPatternInTrigCh(hitsPatternInTrigCh);
 590
 591     // storing ESD MUON Track into ESD Event
 592     if (nRecTracks != 0)
 593       esd->AddMuonTrack(theESDTrack);
 594   } // end loop tracks
 595
 596   // reset muondata
 597   fMUONData->ResetRecTracks();
 598   fMUONData->ResetRecTriggerTracks();
 599
 600   //} // end loop on event
 601   loader->UnloadTracks();
 602
 603   delete theESDTrack;
 604 }
 605
 606 //_____________________________________________________________________________
 607 void AliMUONReconstructor::FillESD(AliRunLoader* runLoader, AliRawReader* /*rawReader*/, AliESD* esd) const
 608 {
 609 /// Fill ESD
 610 /// \todo add more
 611
 612   // don't need rawReader ???
 613   FillESD(runLoader, esd);
 614 }
 615
 616 //_____________________________________________________________________________
 617 AliTracker* AliMUONReconstructor::CreateTracker(AliRunLoader* runLoader) const
 618 {
 619   /// create tracker for MUON
 620   /// go into the tracking framework finally (Ch.F)
 621
 622   AliLoader* loader = runLoader->GetLoader("MUONLoader");
 623
 624   fMUONData->SetLoader(loader);
 625
 626   AliMUONTracker* tracker = new AliMUONTracker();
 627   tracker->SetMUONData(fMUONData);
 628   tracker->SetTriggerCircuit(fTriggerCircuit);
 629   tracker->SetOption(GetOption());
 630
 631   return tracker;
 632
 633 }