AliAODEvent::GetHeader() returns AliVHeader
[u/mrichter/AliRoot.git] / PWG / muon / AliAnalysisTaskESDMuonFilter.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-2013, 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 ///
19 /// Add the muon tracks to the generic AOD track branch during the
20 /// filtering of the ESD.
21 ///
22 ///
23 /// Note that we :
24 ///
25 ///   - completely disable all the branches that are not required by (most) the muon analyses,
26 ///     e.g. cascades, v0s, kinks, jets, etc...
27 ///   - filter severely the tracks (keep only muon tracks) and vertices (keep only primary -including
28 ///     pile-up - vertices) branches
29 ///
30 /// \see AliAODMuonReplicator
31 ///
32 /// (see AddFilteredAOD method)
33 ///
34
35 #include "AliAnalysisTaskESDMuonFilter.h"
36
37 #include "AliAnalysisFilter.h"
38 #include "AliAnalysisManager.h"
39 #include "AliAnalysisNonMuonTrackCuts.h"
40 #include "AliAnalysisNonPrimaryVertices.h"
41 #include "AliAODDimuon.h"
42 #include "AliAODEvent.h"
43 #include "AliAODExtension.h"
44 #include "AliAODHandler.h"
45 #include "AliAODMCParticle.h"
46 #include "AliAODMuonReplicator.h"
47 #include "AliAODVertex.h"
48 #include "AliCodeTimer.h"
49 #include "AliESDEvent.h"
50 #include "AliESDInputHandler.h"
51 #include "AliESDMuonTrack.h"
52 #include "AliESDtrack.h"
53 #include "AliESDMuonGlobalTrack.h"   // AU
54 #include "AliESDVertex.h"
55 #include "AliLog.h"
56 #include "AliMCEvent.h"
57 #include "AliMCEventHandler.h"
58 #include "AliMultiplicity.h"
59 #include <TChain.h>
60 #include <TFile.h>
61 #include <TParticle.h>
62
63 using std::cout;
64 using std::endl;
65 ClassImp(AliAnalysisTaskESDMuonFilter)
66
67 AliAnalysisTaskESDMuonFilter::AliAnalysisTaskESDMuonFilter(Bool_t onlyMuon, Bool_t keepAllEvents, Int_t mcMode, Bool_t withSPDtracklets):
68   AliAnalysisTaskSE(),
69   fTrackFilter(0x0),
70   fEnableMuonAOD(kFALSE),
71   fEnableDimuonAOD(kFALSE),
72   fOnlyMuon(onlyMuon),
73   fKeepAllEvents(keepAllEvents),
74   fMCMode(mcMode),
75   fWithSPDTracklets(withSPDtracklets)
76 {
77   /// Default constructor
78 }
79
80 AliAnalysisTaskESDMuonFilter::AliAnalysisTaskESDMuonFilter(const char* name, Bool_t onlyMuon, Bool_t keepAllEvents, Int_t mcMode, Bool_t withSPDtracklets):
81   AliAnalysisTaskSE(name),
82   fTrackFilter(0x0),
83   fEnableMuonAOD(kFALSE),
84   fEnableDimuonAOD(kFALSE),
85   fOnlyMuon(onlyMuon),
86   fKeepAllEvents(keepAllEvents),
87   fMCMode(mcMode),
88   fWithSPDTracklets(withSPDtracklets)
89 {
90   /// Constructor
91 }
92
93 //______________________________________________________________________________
94 void AliAnalysisTaskESDMuonFilter::UserCreateOutputObjects()
95 {
96   /// Create the output container
97   if (fTrackFilter) OutputTree()->GetUserInfo()->Add(fTrackFilter);
98 }
99
100 //______________________________________________________________________________
101 void AliAnalysisTaskESDMuonFilter::PrintTask(Option_t *option, Int_t indent) const
102 {
103   /// Specify how we are configured
104   
105   AliAnalysisTaskSE::PrintTask(option,indent);
106   
107   TString spaces(' ',indent+3);
108   
109   if ( fOnlyMuon ) 
110   {
111     cout << spaces.Data() << "Keep only muon information " << endl;        
112   }
113   else 
114   {
115     cout << spaces.Data() << "Keep all information from standard AOD" << endl;
116   }
117
118   if ( fKeepAllEvents ) 
119   {
120     cout << spaces.Data() << "Keep all events, regardless of number of muons" << endl;    
121   }
122   else 
123   {
124     cout << spaces.Data() << "Keep only events with at least one muon" << endl;
125   }
126   
127   if ( fMCMode > 0 ) 
128   {
129     cout << spaces.Data() << "Assuming work on MC data (i.e. will transmit MC branches)" << endl;
130     if ( fMCMode == 1 )
131     {
132       cout << spaces.Data() << "  (will write MC information irrespective of whether or not we have reconstructed muons in the event)" << endl;
133     }
134     else
135     {
136       cout << spaces.Data() << "  (will write MC information only if we have reconstructed muons in the event)" << endl;
137     }
138   }
139   
140   if ( fWithSPDTracklets )
141   {
142     cout << spaces.Data() << "Will also keep SPD tracklets" << endl;
143   }
144 }
145
146 //______________________________________________________________________________
147 void AliAnalysisTaskESDMuonFilter::AddFilteredAOD(const char* aodfilename, const char* title)
148 {
149   /// Add an output filtered and replicated aod
150   
151   AliAODHandler *aodH = (AliAODHandler*)((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
152   if (!aodH) Fatal("UserCreateOutputObjects", "No AOD handler");
153
154   AliAODExtension* ext = aodH->AddFilteredAOD(aodfilename,title);
155
156   if (!ext) return;
157   
158   if ( fOnlyMuon ) 
159   {    
160     
161     AliAODMuonReplicator* murep = new AliAODMuonReplicator("MuonReplicator",
162                                                            "remove non muon tracks and non primary or pileup vertices",
163                                                            new AliAnalysisNonMuonTrackCuts,
164                                                            new AliAnalysisNonPrimaryVertices,
165                                                            fMCMode,
166                                                            kFALSE,
167                                                            fWithSPDTracklets);
168     
169     ext->DropUnspecifiedBranches(); // all branches not part of a FilterBranch call (below) will be dropped
170     
171     ext->FilterBranch("tracks",murep);    
172     ext->FilterBranch("vertices",murep);  
173     ext->FilterBranch("dimuons",murep);
174     ext->FilterBranch("AliAODVZERO",murep);
175     ext->FilterBranch("AliAODTZERO",murep);
176     ext->FilterBranch("AliAODZDC",murep);
177     
178     if ( fWithSPDTracklets )
179     {
180       ext->FilterBranch("tracklets",murep);
181     }
182     
183     if ( fMCMode > 0 )
184     {
185       // MC branches will be copied (if present), as they are, but only
186       // for events with at least one muon. 
187       // For events w/o muon, mcparticles array will be empty and mcheader will be dummy
188       // (e.g. strlen(GetGeneratorName())==0)
189       
190       ext->FilterBranch("mcparticles",murep);
191       ext->FilterBranch("mcHeader",murep);
192     }
193   }  
194 }
195
196 //______________________________________________________________________________
197 void AliAnalysisTaskESDMuonFilter::Init()
198 {
199   /// Initialization
200   if(fEnableMuonAOD) AddFilteredAOD("AliAOD.Muons.root", "MuonEvents");
201   if(fEnableDimuonAOD) AddFilteredAOD("AliAOD.Dimuons.root", "DimuonEvents");    
202 }
203
204
205 //______________________________________________________________________________
206 void AliAnalysisTaskESDMuonFilter::UserExec(Option_t */*option*/)
207 {
208   /// Execute analysis for current event
209   
210   Long64_t ientry = Entry();
211   if(fDebug)printf("Muon Filter: Analysing event # %5d\n", (Int_t) ientry);
212   
213   ConvertESDtoAOD();
214 }
215
216 //______________________________________________________________________________
217 void AliAnalysisTaskESDMuonFilter::ConvertESDtoAOD() 
218 {
219   /// ESD Muon Filter analysis task executed for each event
220   
221   AliCodeTimerAuto("",0);
222   
223   AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent());
224   if (!esd) 
225   {
226     AliError("Could not get input ESD event");
227     return;    
228   }
229   
230   AliMCEventHandler *mcH = static_cast<AliMCEventHandler*>((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler());
231     
232   // Define arrays for muons
233   Double_t pos[3];
234   Double_t p[3];
235   //  Double_t pid[10];
236   
237   // has to be changed once the muon pid is provided by the ESD
238   //  for (Int_t i = 0; i < 10; pid[i++] = 0.) {}
239   //  pid[AliAODTrack::kMuon]=1.;
240   
241   AliAODHeader* header = dynamic_cast<AliAODHeader*>(AODEvent()->GetHeader());
242   if(!header) AliFatal("Not a standard AOD");
243   AliAODTrack *aodTrack = 0x0;
244   AliESDMuonTrack *esdMuTrack = 0x0;
245   
246   // Access to the AOD container of tracks
247   TClonesArray &tracks = *(AODEvent()->GetTracks());
248   Int_t jTracks = tracks.GetEntriesFast();
249   
250   // Read primary vertex from AOD event 
251   AliAODVertex *primary = AODEvent()->GetPrimaryVertex();
252   if (fDebug && primary) primary->Print();
253   
254   // ----------------- MUON TRACKS -----------------------------------------------------
255
256   // Loop on muon tracks to fill the AOD track branch
257   Int_t nMuTracks = esd->GetNumberOfMuonTracks();
258
259   for (Int_t iTrack=0; iTrack<nMuTracks; ++iTrack) esd->GetMuonTrack(iTrack)->SetESDEvent(esd);
260   
261   // Update number of positive and negative tracks from AOD event (M.G.)
262   Int_t nTracks    = header->GetRefMultiplicity();
263   Int_t nPosTracks = header->GetRefMultiplicityPos();
264   Int_t nNegTracks = header->GetRefMultiplicityNeg();
265   
266   // Access to the AOD container of dimuons
267   TClonesArray &dimuons = *(AODEvent()->GetDimuons());
268   
269   Int_t nMuons=0;
270   Int_t nDimuons=0;
271   Int_t jDimuons=0;
272   Int_t nMuonTrack[100];
273   UChar_t itsClusMap(0);
274   
275   for(int imuon=0;imuon<100;imuon++) nMuonTrack[imuon]=0;
276   
277   for (Int_t nMuTrack = 0; nMuTrack < nMuTracks; ++nMuTrack)
278   {
279     esdMuTrack = esd->GetMuonTrack(nMuTrack);
280     
281     if (!esdMuTrack->ContainTrackerData()) continue;
282     
283     UInt_t selectInfo(0);
284     
285     // Track selection
286     if (fTrackFilter) {
287         selectInfo = fTrackFilter->IsSelected(esdMuTrack);
288         if (!selectInfo) {
289           continue;
290         }  
291     }
292     
293     p[0] = esdMuTrack->Px(); 
294     p[1] = esdMuTrack->Py(); 
295     p[2] = esdMuTrack->Pz();
296     
297     pos[0] = esdMuTrack->GetNonBendingCoor(); 
298     pos[1] = esdMuTrack->GetBendingCoor(); 
299     pos[2] = esdMuTrack->GetZ();
300     
301     if (mcH) mcH->SelectParticle(esdMuTrack->GetLabel()); // to insure that particle's ancestors will be in output MC branches
302     
303     aodTrack = new(tracks[jTracks++]) AliAODTrack(esdMuTrack->GetUniqueID(), // ID
304                                                   esdMuTrack->GetLabel(), // label
305                                                   p, // momentum
306                                                   kTRUE, // cartesian coordinate system
307                                                   pos, // position
308                                                   kFALSE, // isDCA
309                                                   0x0, // covariance matrix
310                                                   esdMuTrack->Charge(), // charge
311                                                   itsClusMap, // ITSClusterMap
312                                                   //pid, // pid
313                                                   primary, // primary vertex
314                                                   kFALSE, // used for vertex fit?
315                                                   kFALSE, // used for primary vertex fit?
316                                                   AliAODTrack::kPrimary,// track type
317                                                   selectInfo); 
318     
319     aodTrack->SetPIDForTracking(AliPID::kMuon);
320     aodTrack->SetXYAtDCA(esdMuTrack->GetNonBendingCoorAtDCA(), esdMuTrack->GetBendingCoorAtDCA());
321     aodTrack->SetPxPyPzAtDCA(esdMuTrack->PxAtDCA(), esdMuTrack->PyAtDCA(), esdMuTrack->PzAtDCA());
322     aodTrack->SetRAtAbsorberEnd(esdMuTrack->GetRAtAbsorberEnd());
323     aodTrack->ConvertAliPIDtoAODPID();
324     aodTrack->SetChi2perNDF(esdMuTrack->GetChi2() / (2.*esdMuTrack->GetNHit() - 5.));
325     aodTrack->SetChi2MatchTrigger(esdMuTrack->GetChi2MatchTrigger());
326     aodTrack->SetHitsPatternInTrigCh(esdMuTrack->GetHitsPatternInTrigCh());
327     UInt_t pattern = esdMuTrack->GetHitsPatternInTrigCh();
328     AliESDMuonTrack::AddEffInfo(pattern, 0, esdMuTrack->LoCircuit(), (AliESDMuonTrack::EAliTriggerChPatternFlag)0);
329     esdMuTrack->AddMuonTrigDevSignInfo(pattern);
330     aodTrack->SetMUONtrigHitsMapTrg(pattern);
331     aodTrack->SetMUONtrigHitsMapTrk(esdMuTrack->GetHitsPatternInTrigChTrk());
332     aodTrack->SetMuonClusterMap(esdMuTrack->GetMuonClusterMap());
333     aodTrack->SetMatchTrigger(esdMuTrack->GetMatchTrigger());
334     aodTrack->Connected(esdMuTrack->IsConnected());
335     primary->AddDaughter(aodTrack);
336     
337     ++nTracks;
338     if (esdMuTrack->Charge() > 0) nPosTracks++;
339     else nNegTracks++;
340     
341     nMuonTrack[nMuons]= jTracks-1;
342     ++nMuons;
343   }
344   
345   if(nMuons>=2) 
346   { 
347     for(int i=0;i<nMuons;i++){
348       Int_t index0 = nMuonTrack[i];
349       for(int j=i+1;j<nMuons;j++){
350         Int_t index1 = nMuonTrack[j];
351         new(dimuons[jDimuons++]) AliAODDimuon(tracks.At(index0),tracks.At(index1));
352         ++nDimuons;
353         if (fDebug > 1){
354           AliAODDimuon *dimuon0 = (AliAODDimuon*)dimuons.At(jDimuons-1);
355           printf("Dimuon: mass = %f, px=%f, py=%f, pz=%f\n",dimuon0->M(),dimuon0->Px(),dimuon0->Py(),dimuon0->Pz());  
356           AliAODTrack  *mu0 = (AliAODTrack*) dimuon0->GetMu(0);
357           AliAODTrack  *mu1 = (AliAODTrack*) dimuon0->GetMu(1);
358           printf("Muon0 px=%f py=%f pz=%f\n",mu0->Px(),mu0->Py(),mu0->Pz());
359           printf("Muon1 px=%f py=%f pz=%f\n",mu1->Px(),mu1->Py(),mu1->Pz());
360         }  
361       }
362     }
363   }
364   
365   
366   header->SetRefMultiplicity(nTracks); 
367   header->SetRefMultiplicityPos(nPosTracks);
368   header->SetRefMultiplicityNeg(nNegTracks);
369   header->SetNumberOfMuons(nMuons);
370   header->SetNumberOfDimuons(nDimuons);
371   
372   // ----------------- MFT + MUON TRACKS -----------------------------------------------------
373
374   AliESDMuonGlobalTrack *esdMuGlobalTrack = 0x0;
375
376   // Loop on muon global tracks to fill the AOD track branch. 
377   // We won't update the number of total, pos and neg tracks in the event
378
379   Int_t nMuGlobalTracks = esd->GetNumberOfMuonGlobalTracks();
380
381   for (Int_t iTrack=0; iTrack<nMuGlobalTracks; ++iTrack) esd->GetMuonGlobalTrack(iTrack)->SetESDEvent(esd);
382   
383   Int_t nGlobalMuons=0;
384   Int_t nGlobalDimuons=0;
385   Int_t jGlobalDimuons=0;
386   Int_t nMuonGlobalTrack[100];
387   itsClusMap = 0;
388   
389   for (Int_t iMuon=0; iMuon<100; iMuon++) nMuonGlobalTrack[iMuon]=0;    // position of the i-th muon track in the tracks array of the AOD event  
390
391   for (Int_t nMuTrack=0; nMuTrack<nMuGlobalTracks; ++nMuTrack) {
392
393     esdMuGlobalTrack = esd->GetMuonGlobalTrack(nMuTrack);
394
395     if (!esdMuGlobalTrack->ContainTrackerData()) continue;
396     
397     UInt_t selectInfo(0);
398     
399     // Track selection
400     if (fTrackFilter) {
401       selectInfo = fTrackFilter->IsSelected(esdMuGlobalTrack);
402       if (!selectInfo) {
403         continue;
404       }  
405     }
406     
407     p[0] = esdMuGlobalTrack->Px(); 
408     p[1] = esdMuGlobalTrack->Py(); 
409     p[2] = esdMuGlobalTrack->Pz();
410     
411     esdMuGlobalTrack -> GetFirstTrackingPoint(pos);
412
413     if (mcH) mcH->SelectParticle(esdMuGlobalTrack->GetLabel()); // to insure that particle's ancestors will be in output MC branches
414
415     Double_t covTr[21] = {0};
416     ConvertCovMatrixMUON2AOD(esdMuGlobalTrack->GetCovariances(), covTr);
417     
418     aodTrack = new(tracks[jTracks++]) AliAODTrack(esdMuGlobalTrack->GetUniqueID(), // ID
419                                                   esdMuGlobalTrack->GetLabel(),    // label
420                                                   p,                               // momentum
421                                                   kTRUE,                           // cartesian coordinate system
422                                                   pos,                             // position
423                                                   kFALSE,                          // isDCA
424                                                   covTr,                           // covariance matrix
425                                                   esdMuGlobalTrack->Charge(),      // charge
426                                                   itsClusMap,                      // ITSClusterMap
427                                                   primary,                         // origin vertex
428                                                   kFALSE,                          // used for vertex fit?
429                                                   kFALSE,                          // used for primary vertex fit?
430                                                   AliAODTrack::kPrimary,           // track type
431                                                   selectInfo);
432
433
434     aodTrack->SetPIDForTracking(AliPID::kMuon);
435
436     Double_t xyAtVertex[2] = {0};
437     esdMuGlobalTrack -> GetXYAtVertex(xyAtVertex);
438     
439     aodTrack->SetIsMuonGlobalTrack(kTRUE);
440
441     aodTrack->SetMFTClusterPattern(esdMuGlobalTrack->GetMFTClusterPattern());
442     aodTrack->SetXYAtDCA(xyAtVertex[0], xyAtVertex[1]);
443     aodTrack->SetPxPyPzAtDCA(p[0], p[1], p[2]);
444     aodTrack->SetRAtAbsorberEnd(esdMuGlobalTrack->GetRAtAbsorberEnd());
445     aodTrack->ConvertAliPIDtoAODPID();
446     aodTrack->SetChi2perNDF(esdMuGlobalTrack->GetChi2OverNdf());
447     aodTrack->SetChi2MatchTrigger(esdMuGlobalTrack->GetChi2MatchTrigger());
448     aodTrack->SetHitsPatternInTrigCh(esdMuGlobalTrack->GetHitsPatternInTrigCh());
449     UInt_t pattern = esdMuGlobalTrack->GetHitsPatternInTrigCh();
450     AliESDMuonTrack::AddEffInfo(pattern, 0, esdMuGlobalTrack->GetLoCircuit(), (AliESDMuonTrack::EAliTriggerChPatternFlag)0);
451 //    esdMuGlobalTrack->AddTrigDevSignInfo(pattern);
452     aodTrack->SetMUONtrigHitsMapTrg(pattern);
453     aodTrack->SetMUONtrigHitsMapTrk(esdMuGlobalTrack->GetHitsPatternInTrigChTrk());
454     aodTrack->SetMuonClusterMap(esdMuGlobalTrack->GetMuonClusterMap());
455     aodTrack->SetMatchTrigger(esdMuGlobalTrack->GetMatchTrigger());
456     aodTrack->Connected(esdMuGlobalTrack->IsConnected());
457
458     printf("Added Muon Global Track %d of %d\n",nMuTrack,nMuGlobalTracks);
459     aodTrack->Print();     // to be removed!!!
460
461     primary->AddDaughter(aodTrack);
462     
463     nMuonGlobalTrack[nGlobalMuons] = jTracks-1;
464     ++nGlobalMuons;
465   }
466
467   if (nGlobalMuons >= 2) { 
468     for (Int_t i=0; i<nGlobalMuons; i++) {
469       Int_t index0 = nMuonGlobalTrack[i];
470       for (Int_t j=i+1; j<nGlobalMuons; j++) {
471         Int_t index1 = nMuonGlobalTrack[j];
472         new (dimuons[jGlobalDimuons++]) AliAODDimuon(tracks.At(index0), tracks.At(index1));
473         ++nDimuons;
474         if (fDebug > 1) {
475           AliAODDimuon *dimuon0 = (AliAODDimuon*)dimuons.At(jGlobalDimuons-1);
476           printf("Dimuon: mass = %f, px=%f, py=%f, pz=%f\n",dimuon0->M(),dimuon0->Px(),dimuon0->Py(),dimuon0->Pz());  
477           AliAODTrack  *mu0 = (AliAODTrack*) dimuon0->GetMu(0);
478           AliAODTrack  *mu1 = (AliAODTrack*) dimuon0->GetMu(1);
479           printf("Muon0 px=%f py=%f pz=%f\n",mu0->Px(),mu0->Py(),mu0->Pz());
480           printf("Muon1 px=%f py=%f pz=%f\n",mu1->Px(),mu1->Py(),mu1->Pz());
481         }  
482       }
483     }
484   }
485   
486   header->SetNumberOfGlobalMuons(nGlobalMuons);
487   header->SetNumberOfGlobalDimuons(nGlobalDimuons);
488   
489   // -----------------------------------------------------------------------
490
491   AliAODHandler* handler = dynamic_cast<AliAODHandler*>(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler());
492   
493   if ( handler && fEnableMuonAOD && ( (nMuons>0) || fKeepAllEvents ) )
494   {
495     AliAODExtension *extMuons = handler->GetFilteredAOD("AliAOD.Muons.root");
496     if ( extMuons ) extMuons->SelectEvent();
497   }
498   
499   if ( handler && fEnableDimuonAOD && ( (nMuons>1) || fKeepAllEvents )  )
500   {
501     AliAODExtension *extDimuons = handler->GetFilteredAOD("AliAOD.Dimuons.root");
502     if ( extDimuons ) extDimuons->SelectEvent();
503   }
504   
505 }
506
507 //====================================================================================================================================================
508
509 void AliAnalysisTaskESDMuonFilter::ConvertCovMatrixMUON2AOD(const TMatrixD& covMUON, Double_t covAOD[21]) {
510
511   // Converts the cov matrix from the MUON format (TMatrixD) to the AOD one (Double_t[21])
512   // 
513   // Cov(x,x)       ... :   cv[0]
514   // Cov(x,slopeX)  ... :   cv[1]  cv[2]
515   // Cov(x,y)       ... :   cv[3]  cv[4]  cv[5]
516   // Cov(x,slopeY)  ... :   cv[6]  cv[7]  cv[8]  cv[9]
517   // Cov(x,invP_yz) ... :   cv[10] cv[11] cv[12] cv[13] cv[14]
518   // not-used       ... :   cv[15] cv[16] cv[17] cv[18] cv[19] cv[20]
519
520   covAOD[0]  = covMUON(0,0);
521
522   covAOD[1]  = covMUON(1,0);
523   covAOD[2]  = covMUON(1,1);
524
525   covAOD[3]  = covMUON(2,0);  
526   covAOD[4]  = covMUON(2,1);  
527   covAOD[5]  = covMUON(2,2);  
528
529   covAOD[6]  = covMUON(3,0);  
530   covAOD[7]  = covMUON(3,1);  
531   covAOD[8]  = covMUON(3,2);  
532   covAOD[9]  = covMUON(3,3);  
533
534   covAOD[10] = covMUON(4,0);  
535   covAOD[11] = covMUON(4,1);  
536   covAOD[12] = covMUON(4,2);  
537   covAOD[13] = covMUON(4,3);  
538   covAOD[14] = covMUON(4,4);  
539
540   covAOD[15] = 0;  
541   covAOD[16] = 0;  
542   covAOD[17] = 0;  
543   covAOD[18] = 0;  
544   covAOD[19] = 0;  
545   covAOD[20] = 0;  
546
547 }
548
549 //====================================================================================================================================================