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