[u/mrichter/AliRoot.git] / PWG / muon / AliAnalysisTaskESDMuonFilter.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

//
// Add the muon tracks to the generic AOD track branch during the 
// filtering of the ESD. 
//
// Authors: R. Arnaldi 5/5/08 and L. Aphecetche January 2011
//
// Note that we :
//   - completely disable all the branches that are not required by (most) the muon analyses,
//     e.g. cascades, v0s, kinks, jets, etc...
//   - filter severely the tracks (keep only muon tracks) and vertices (keep only primary -including
//     pile-up - vertices) branches 
// 
// (see AddFilteredAOD method)
//

#include "AliAnalysisTaskESDMuonFilter.h"

#include "AliAODDimuon.h"
#include "AliAODEvent.h"
#include "AliAODHandler.h"
#include "AliAODExtension.h"
#include "AliAODMCParticle.h"
#include "AliAODMuonReplicator.h"
#include "AliAODVertex.h"
#include "AliAnalysisFilter.h"
#include "AliAnalysisManager.h"
#include "AliCodeTimer.h"
#include "AliESDEvent.h"
#include "AliESDInputHandler.h"
#include "AliESDMuonTrack.h"
#include "AliESDVertex.h"
#include "AliESDtrack.h"
#include "AliLog.h"
#include "AliMCEvent.h"
#include "AliMCEventHandler.h"
#include "AliMultiplicity.h"
#include <TChain.h>
#include <TFile.h>
#include <TParticle.h>

ClassImp(AliAnalysisTaskESDMuonFilter)
ClassImp(AliAnalysisNonMuonTrackCuts)

////////////////////////////////////////////////////////////////////////

AliAnalysisNonMuonTrackCuts::AliAnalysisNonMuonTrackCuts()
{
  // default ctor 
}

Bool_t AliAnalysisNonMuonTrackCuts::IsSelected(TObject* obj)
{
  // Returns true if the object is a muon track
  AliAODTrack* track = dynamic_cast<AliAODTrack*>(obj);
  if (track && track->IsMuonTrack()) return kTRUE;
  return kFALSE;
}

AliAnalysisNonPrimaryVertices::AliAnalysisNonPrimaryVertices()
{
  // default ctor   
}

Bool_t AliAnalysisNonPrimaryVertices::IsSelected(TObject* obj)
{
  // Returns true if the object is a primary vertex

  AliAODVertex* vertex = dynamic_cast<AliAODVertex*>(obj);
  if (vertex)
  {
    if ( vertex->GetType() == AliAODVertex::kPrimary ||
        vertex->GetType() == AliAODVertex::kMainSPD ||
        vertex->GetType() == AliAODVertex::kPileupSPD ||
        vertex->GetType() == AliAODVertex::kPileupTracks ||
        vertex->GetType() == AliAODVertex::kMainTPC )
    {
      return kTRUE;
    }
  }
  
//  enum AODVtx_t {kUndef=-1, kPrimary, kKink, kV0, kCascade, kMulti, kMainSPD, kPileupSPD, kPileupTracks,kMainTPC};

  return kFALSE;
  
}

AliAnalysisTaskESDMuonFilter::AliAnalysisTaskESDMuonFilter(Bool_t onlyMuon, Bool_t keepAllEvents, Int_t mcMode):
  AliAnalysisTaskSE(),
  fTrackFilter(0x0),
  fEnableMuonAOD(kFALSE),
  fEnableDimuonAOD(kFALSE),
  fOnlyMuon(onlyMuon),
  fKeepAllEvents(keepAllEvents),
  fMCMode(mcMode)
{
  // Default constructor
}

AliAnalysisTaskESDMuonFilter::AliAnalysisTaskESDMuonFilter(const char* name, Bool_t onlyMuon, Bool_t keepAllEvents, Int_t mcMode):
  AliAnalysisTaskSE(name),
  fTrackFilter(0x0),
  fEnableMuonAOD(kFALSE),
  fEnableDimuonAOD(kFALSE),
  fOnlyMuon(onlyMuon),
  fKeepAllEvents(keepAllEvents),
  fMCMode(mcMode)
{
  // Constructor
}

//______________________________________________________________________________
void AliAnalysisTaskESDMuonFilter::UserCreateOutputObjects()
{
  // Create the output container
  if (fTrackFilter) OutputTree()->GetUserInfo()->Add(fTrackFilter);
}

//______________________________________________________________________________
void AliAnalysisTaskESDMuonFilter::PrintTask(Option_t *option, Int_t indent) const
{
  // Specify how we are configured
  
  AliAnalysisTaskSE::PrintTask(option,indent);
  
  TString spaces(' ',indent+3);
  
  if ( fOnlyMuon ) 
  {
    cout << spaces.Data() << "Keep only muon information " << endl;        
  }
  else 
  {
    cout << spaces.Data() << "Keep all information from standard AOD" << endl;
  }

  if ( fKeepAllEvents ) 
  {
    cout << spaces.Data() << "Keep all events, regardless of number of muons" << endl;    
  }
  else 
  {
    cout << spaces.Data() << "Keep only events with at least one muon" << endl;
  }
  
  if ( fMCMode > 0 ) 
  {
    cout << spaces.Data() << "Assuming work on MC data (i.e. will transmit MC branches)" << endl;
  }
}

//______________________________________________________________________________
void AliAnalysisTaskESDMuonFilter::AddFilteredAOD(const char* aodfilename, const char* title)
{
  // Add an output filtered and replicated aod
  
  AliAODHandler *aodH = (AliAODHandler*)((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
  if (!aodH) Fatal("UserCreateOutputObjects", "No AOD handler");

  AliAODExtension* ext = aodH->AddFilteredAOD(aodfilename,title);

  if (!ext) return;
  
  if ( fOnlyMuon ) 
  {    
    
    AliAODMuonReplicator* murep = new AliAODMuonReplicator("MuonReplicator",
                                                           "remove non muon tracks and non primary or pileup vertices",
                                                           new AliAnalysisNonMuonTrackCuts,
                                                           new AliAnalysisNonPrimaryVertices,
                                                           fMCMode);
    
    ext->DropUnspecifiedBranches(); // all branches not part of a FilterBranch call (below) will be dropped
    
    ext->FilterBranch("tracks",murep);    
    ext->FilterBranch("vertices",murep);  
    ext->FilterBranch("dimuons",murep);
    ext->FilterBranch("AliAODVZERO",murep);
    
    if ( fMCMode > 0 ) 
    {
      // MC branches will be copied (if present), as they are, but only
      // for events with at least one muon. 
      // For events w/o muon, mcparticles array will be empty and mcheader will be dummy
      // (e.g. strlen(GetGeneratorName())==0)
      
      ext->FilterBranch("mcparticles",murep);
      ext->FilterBranch("mcHeader",murep);
    }
  }  
}

//______________________________________________________________________________
void AliAnalysisTaskESDMuonFilter::Init()
{
  // Initialization
  if(fEnableMuonAOD) AddFilteredAOD("AliAOD.Muons.root", "MuonEvents");
  if(fEnableDimuonAOD) AddFilteredAOD("AliAOD.Dimuons.root", "DimuonEvents");    
}


//______________________________________________________________________________
void AliAnalysisTaskESDMuonFilter::UserExec(Option_t */*option*/)
{
  // Execute analysis for current event					    
  
  Long64_t ientry = Entry();
  if(fDebug)printf("Muon Filter: Analysing event # %5d\n", (Int_t) ientry);
  
  ConvertESDtoAOD();
}

//______________________________________________________________________________
void AliAnalysisTaskESDMuonFilter::ConvertESDtoAOD() 
{
  // ESD Muon Filter analysis task executed for each event
  
  AliCodeTimerAuto("",0);
  
  AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent());
  if (!esd) 
  {
    AliError("Could not get input ESD event");
    return;    
  }
  
  AliMCEventHandler *mcH = static_cast<AliMCEventHandler*>((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler());
    
  // Define arrays for muons
  Double_t pos[3];
  Double_t p[3];
  Double_t pid[10];
  
  // has to be changed once the muon pid is provided by the ESD
  for (Int_t i = 0; i < 10; pid[i++] = 0.) {}
  pid[AliAODTrack::kMuon]=1.;
  
  AliAODHeader* header = AODEvent()->GetHeader();
  AliAODTrack *aodTrack = 0x0;
  AliESDMuonTrack *esdMuTrack = 0x0;
  
  // Access to the AOD container of tracks
  TClonesArray &tracks = *(AODEvent()->GetTracks());
  Int_t jTracks = header->GetRefMultiplicity();
  
  // Read primary vertex from AOD event 
  AliAODVertex *primary = AODEvent()->GetPrimaryVertex();
  if (fDebug && primary) primary->Print();
  
  // Loop on muon tracks to fill the AOD track branch
  Int_t nMuTracks = esd->GetNumberOfMuonTracks();

  for (Int_t iTrack=0; iTrack<nMuTracks; ++iTrack) esd->GetMuonTrack(iTrack)->SetESDEvent(esd);
  
  // Update number of positive and negative tracks from AOD event (M.G.)
  Int_t nPosTracks = header->GetRefMultiplicityPos();
  Int_t nNegTracks = header->GetRefMultiplicityNeg();
  
  // Access to the AOD container of dimuons
  TClonesArray &dimuons = *(AODEvent()->GetDimuons());
  
  Int_t nMuons=0;
  Int_t nDimuons=0;
  Int_t jDimuons=0;
  Int_t nMuonTrack[100];
  UChar_t itsClusMap(0);
  
  for(int imuon=0;imuon<100;imuon++) nMuonTrack[imuon]=0;
  
  for (Int_t nMuTrack = 0; nMuTrack < nMuTracks; ++nMuTrack)
  {
    esdMuTrack = esd->GetMuonTrack(nMuTrack);
    
    if (!esdMuTrack->ContainTrackerData()) continue;
    
    UInt_t selectInfo(0);
    
    // Track selection
    if (fTrackFilter) {
     	selectInfo = fTrackFilter->IsSelected(esdMuTrack);
     	if (!selectInfo) {
     	  continue;
     	}  
    }
    
    p[0] = esdMuTrack->Px(); 
    p[1] = esdMuTrack->Py(); 
    p[2] = esdMuTrack->Pz();
    
    pos[0] = esdMuTrack->GetNonBendingCoor(); 
    pos[1] = esdMuTrack->GetBendingCoor(); 
    pos[2] = esdMuTrack->GetZ();
    
    if (mcH) mcH->SelectParticle(esdMuTrack->GetLabel()); // to insure that particle's ancestors will be in output MC branches
    
    aodTrack = new(tracks[jTracks++]) AliAODTrack(esdMuTrack->GetUniqueID(), // ID
                                                  esdMuTrack->GetLabel(), // label
                                                  p, // momentum
                                                  kTRUE, // cartesian coordinate system
                                                  pos, // position
                                                  kFALSE, // isDCA
                                                  0x0, // covariance matrix
                                                  esdMuTrack->Charge(), // charge
                                                  itsClusMap, // ITSClusterMap
                                                  pid, // pid
                                                  primary, // primary vertex
                                                  kFALSE, // used for vertex fit?
                                                  kFALSE, // used for primary vertex fit?
                                                  AliAODTrack::kPrimary,// track type
                                                  selectInfo); 
    
    aodTrack->SetXYAtDCA(esdMuTrack->GetNonBendingCoorAtDCA(), esdMuTrack->GetBendingCoorAtDCA());
    aodTrack->SetPxPyPzAtDCA(esdMuTrack->PxAtDCA(), esdMuTrack->PyAtDCA(), esdMuTrack->PzAtDCA());
    aodTrack->SetRAtAbsorberEnd(esdMuTrack->GetRAtAbsorberEnd());
    aodTrack->ConvertAliPIDtoAODPID();
    aodTrack->SetChi2perNDF(esdMuTrack->GetChi2() / (2.*esdMuTrack->GetNHit() - 5.));
    aodTrack->SetChi2MatchTrigger(esdMuTrack->GetChi2MatchTrigger());
    aodTrack->SetHitsPatternInTrigCh(esdMuTrack->GetHitsPatternInTrigCh());
    aodTrack->SetMuonClusterMap(esdMuTrack->GetMuonClusterMap());
    aodTrack->SetMatchTrigger(esdMuTrack->GetMatchTrigger());
    aodTrack->Connected(esdMuTrack->IsConnected());
    primary->AddDaughter(aodTrack);
    
    if (esdMuTrack->Charge() > 0) nPosTracks++;
    else nNegTracks++;
    
    nMuonTrack[nMuons]= jTracks-1;
    ++nMuons;
  }
  
  if(nMuons>=2) 
  { 
    for(int i=0;i<nMuons;i++){
      Int_t index0 = nMuonTrack[i];
      for(int j=i+1;j<nMuons;j++){
        Int_t index1 = nMuonTrack[j];
        new(dimuons[jDimuons++]) AliAODDimuon(tracks.At(index0),tracks.At(index1));
        ++nDimuons;
        if (fDebug > 1){
          AliAODDimuon *dimuon0 = (AliAODDimuon*)dimuons.At(jDimuons-1);
          printf("Dimuon: mass = %f, px=%f, py=%f, pz=%f\n",dimuon0->M(),dimuon0->Px(),dimuon0->Py(),dimuon0->Pz());  
          AliAODTrack  *mu0 = (AliAODTrack*) dimuon0->GetMu(0);
          AliAODTrack  *mu1 = (AliAODTrack*) dimuon0->GetMu(1);
          printf("Muon0 px=%f py=%f pz=%f\n",mu0->Px(),mu0->Py(),mu0->Pz());
          printf("Muon1 px=%f py=%f pz=%f\n",mu1->Px(),mu1->Py(),mu1->Pz());
        }  
      }
    }
  }
  
  
  header->SetRefMultiplicity(jTracks); 
  header->SetRefMultiplicityPos(nPosTracks);
  header->SetRefMultiplicityNeg(nNegTracks);
  header->SetNumberOfMuons(nMuons);
  header->SetNumberOfDimuons(nDimuons);
  
  AliAODHandler* handler = dynamic_cast<AliAODHandler*>(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler());
  
  if ( handler && fEnableMuonAOD && ( (nMuons>0) || fKeepAllEvents ) )
  {
    AliAODExtension *extMuons = handler->GetFilteredAOD("AliAOD.Muons.root");
    if ( extMuons ) extMuons->SelectEvent();
  }
  
  if ( handler && fEnableDimuonAOD && ( (nMuons>1) || fKeepAllEvents )  )
  {
    AliAODExtension *extDimuons = handler->GetFilteredAOD("AliAOD.Dimuons.root");
    if ( extDimuons ) extDimuons->SelectEvent();
  }
  
}

void AliAnalysisTaskESDMuonFilter::Terminate(Option_t */*option*/)
{
  // Terminate analysis
  //
  if (fDebug > 1) printf("AnalysisESDfilter: Terminate() \n");
}
Commit	Line	Data
1d1ea3ce	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
27de2dfb	16	/* $Id$ */
27de2dfb	17
26ba01d4	18	//
1d1ea3ce	19	// Add the muon tracks to the generic AOD track branch during the
26ba01d4	20	// filtering of the ESD.
	21	//
	22	// Authors: R. Arnaldi 5/5/08 and L. Aphecetche January 2011
	23	//
	24	// Note that we :
	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 AddFilteredAOD method)
	31	//
aba11173	32
1d1ea3ce	33	#include "AliAnalysisTaskESDMuonFilter.h"
dcc1f876	34
dcc1f876	35	#include "AliAODDimuon.h"
1d1ea3ce	36	#include "AliAODEvent.h"
1d1ea3ce	37	#include "AliAODHandler.h"
14d6fad5	38	#include "AliAODExtension.h"
dcc1f876	39	#include "AliAODMCParticle.h"
	40	#include "AliAODMuonReplicator.h"
	41	#include "AliAODVertex.h"
1d1ea3ce	42	#include "AliAnalysisFilter.h"
dcc1f876	43	#include "AliAnalysisManager.h"
	44	#include "AliCodeTimer.h"
	45	#include "AliESDEvent.h"
	46	#include "AliESDInputHandler.h"
1d1ea3ce	47	#include "AliESDMuonTrack.h"
1d1ea3ce	48	#include "AliESDVertex.h"
dcc1f876	49	#include "AliESDtrack.h"
1d1ea3ce	50	#include "AliLog.h"
fc3a4c45	51	#include "AliMCEvent.h"
fc3a4c45	52	#include "AliMCEventHandler.h"
dcc1f876	53	#include "AliMultiplicity.h"
dcc1f876	54	#include <TChain.h>
	55	#include <TFile.h>
	56	#include <TParticle.h>
1d1ea3ce	57
1d1ea3ce	58	ClassImp(AliAnalysisTaskESDMuonFilter)
26ba01d4	59	ClassImp(AliAnalysisNonMuonTrackCuts)
1d1ea3ce	60
	61	////////////////////////////////////////////////////////////////////////
	62
26ba01d4	63	AliAnalysisNonMuonTrackCuts::AliAnalysisNonMuonTrackCuts()
	64	{
	65	// default ctor
	66	}
	67
	68	Bool_t AliAnalysisNonMuonTrackCuts::IsSelected(TObject* obj)
	69	{
	70	// Returns true if the object is a muon track
	71	AliAODTrack* track = dynamic_cast<AliAODTrack*>(obj);
	72	if (track && track->IsMuonTrack()) return kTRUE;
	73	return kFALSE;
	74	}
	75
	76	AliAnalysisNonPrimaryVertices::AliAnalysisNonPrimaryVertices()
	77	{
	78	// default ctor
	79	}
	80
	81	Bool_t AliAnalysisNonPrimaryVertices::IsSelected(TObject* obj)
	82	{
	83	// Returns true if the object is a primary vertex
	84
	85	AliAODVertex* vertex = dynamic_cast<AliAODVertex*>(obj);
	86	if (vertex)
	87	{
	88	if ( vertex->GetType() == AliAODVertex::kPrimary \|\|
	89	vertex->GetType() == AliAODVertex::kMainSPD \|\|
	90	vertex->GetType() == AliAODVertex::kPileupSPD \|\|
	91	vertex->GetType() == AliAODVertex::kPileupTracks \|\|
	92	vertex->GetType() == AliAODVertex::kMainTPC )
	93	{
	94	return kTRUE;
	95	}
	96	}
	97
	98	// enum AODVtx_t {kUndef=-1, kPrimary, kKink, kV0, kCascade, kMulti, kMainSPD, kPileupSPD, kPileupTracks,kMainTPC};
	99
	100	return kFALSE;
	101
	102	}
	103
14d6fad5	104	AliAnalysisTaskESDMuonFilter::AliAnalysisTaskESDMuonFilter(Bool_t onlyMuon, Bool_t keepAllEvents, Int_t mcMode):
aba11173	105	AliAnalysisTaskSE(),
f785fc59	106	fTrackFilter(0x0),
4a497116	107	fEnableMuonAOD(kFALSE),
26ba01d4	108	fEnableDimuonAOD(kFALSE),
26ba01d4	109	fOnlyMuon(onlyMuon),
14d6fad5	110	fKeepAllEvents(keepAllEvents),
14d6fad5	111	fMCMode(mcMode)
1d1ea3ce	112	{
	113	// Default constructor
	114	}
	115
14d6fad5	116	AliAnalysisTaskESDMuonFilter::AliAnalysisTaskESDMuonFilter(const char* name, Bool_t onlyMuon, Bool_t keepAllEvents, Int_t mcMode):
aba11173	117	AliAnalysisTaskSE(name),
f785fc59	118	fTrackFilter(0x0),
4a497116	119	fEnableMuonAOD(kFALSE),
26ba01d4	120	fEnableDimuonAOD(kFALSE),
26ba01d4	121	fOnlyMuon(onlyMuon),
14d6fad5	122	fKeepAllEvents(keepAllEvents),
14d6fad5	123	fMCMode(mcMode)
1d1ea3ce	124	{
	125	// Constructor
	126	}
	127
3d270be0	128	//______________________________________________________________________________
1d1ea3ce	129	void AliAnalysisTaskESDMuonFilter::UserCreateOutputObjects()
	130	{
	131	// Create the output container
aba11173	132	if (fTrackFilter) OutputTree()->GetUserInfo()->Add(fTrackFilter);
1d1ea3ce	133	}
1d1ea3ce	134
3d270be0	135	//______________________________________________________________________________
	136	void AliAnalysisTaskESDMuonFilter::PrintTask(Option_t *option, Int_t indent) const
	137	{
	138	// Specify how we are configured
	139
	140	AliAnalysisTaskSE::PrintTask(option,indent);
	141
	142	TString spaces(' ',indent+3);
	143
	144	if ( fOnlyMuon )
	145	{
	146	cout << spaces.Data() << "Keep only muon information " << endl;
	147	}
	148	else
	149	{
	150	cout << spaces.Data() << "Keep all information from standard AOD" << endl;
	151	}
	152
	153	if ( fKeepAllEvents )
	154	{
	155	cout << spaces.Data() << "Keep all events, regardless of number of muons" << endl;
	156	}
	157	else
	158	{
	159	cout << spaces.Data() << "Keep only events with at least one muon" << endl;
	160	}
14d6fad5	161
	162	if ( fMCMode > 0 )
	163	{
	164	cout << spaces.Data() << "Assuming work on MC data (i.e. will transmit MC branches)" << endl;
	165	}
3d270be0	166	}
	167
	168	//______________________________________________________________________________
26ba01d4	169	void AliAnalysisTaskESDMuonFilter::AddFilteredAOD(const char* aodfilename, const char* title)
	170	{
	171	// Add an output filtered and replicated aod
	172
	173	AliAODHandler aodH = (AliAODHandler)((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler());
	174	if (!aodH) Fatal("UserCreateOutputObjects", "No AOD handler");
	175
	176	AliAODExtension* ext = aodH->AddFilteredAOD(aodfilename,title);
	177
3d270be0	178	if (!ext) return;
	179
	180	if ( fOnlyMuon )
	181	{
14d6fad5	182
	183	AliAODMuonReplicator* murep = new AliAODMuonReplicator("MuonReplicator",
	184	"remove non muon tracks and non primary or pileup vertices",
	185	new AliAnalysisNonMuonTrackCuts,
	186	new AliAnalysisNonPrimaryVertices,
	187	fMCMode);
dcc1f876	188
	189	ext->DropUnspecifiedBranches(); // all branches not part of a FilterBranch call (below) will be dropped
	190
26ba01d4	191	ext->FilterBranch("tracks",murep);
3d270be0	192	ext->FilterBranch("vertices",murep);
3d270be0	193	ext->FilterBranch("dimuons",murep);
5393f2c0	194	ext->FilterBranch("AliAODVZERO",murep);
5393f2c0	195
14d6fad5	196	if ( fMCMode > 0 )
	197	{
	198	// MC branches will be copied (if present), as they are, but only
	199	// for events with at least one muon.
	200	// For events w/o muon, mcparticles array will be empty and mcheader will be dummy
	201	// (e.g. strlen(GetGeneratorName())==0)
	202
	203	ext->FilterBranch("mcparticles",murep);
	204	ext->FilterBranch("mcHeader",murep);
	205	}
26ba01d4	206	}
	207	}
	208
3d270be0	209	//______________________________________________________________________________
1d1ea3ce	210	void AliAnalysisTaskESDMuonFilter::Init()
	211	{
	212	// Initialization
26ba01d4	213	if(fEnableMuonAOD) AddFilteredAOD("AliAOD.Muons.root", "MuonEvents");
26ba01d4	214	if(fEnableDimuonAOD) AddFilteredAOD("AliAOD.Dimuons.root", "DimuonEvents");
1d1ea3ce	215	}
	216
	217
3d270be0	218	//______________________________________________________________________________
1d1ea3ce	219	void AliAnalysisTaskESDMuonFilter::UserExec(Option_t /option*/)
	220	{
	221	// Execute analysis for current event
26ba01d4	222
1d1ea3ce	223	Long64_t ientry = Entry();
edee4062	224	if(fDebug)printf("Muon Filter: Analysing event # %5d\n", (Int_t) ientry);
aba11173	225
1d1ea3ce	226	ConvertESDtoAOD();
	227	}
	228
3d270be0	229	//______________________________________________________________________________
1d1ea3ce	230	void AliAnalysisTaskESDMuonFilter::ConvertESDtoAOD()
	231	{
	232	// ESD Muon Filter analysis task executed for each event
dcc1f876	233
	234	AliCodeTimerAuto("",0);
	235
1d1ea3ce	236	AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent());
6fa3e5c7	237	if (!esd)
	238	{
	239	AliError("Could not get input ESD event");
	240	return;
fc3a4c45	241	}
6fa3e5c7	242
6fa3e5c7	243	AliMCEventHandler mcH = static_cast<AliMCEventHandler>((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler());
fc3a4c45	244
1d1ea3ce	245	// Define arrays for muons
	246	Double_t pos[3];
	247	Double_t p[3];
	248	Double_t pid[10];
aba11173	249
aba11173	250	// has to be changed once the muon pid is provided by the ESD
a6e0ebfe	251	for (Int_t i = 0; i < 10; pid[i++] = 0.) {}
aba11173	252	pid[AliAODTrack::kMuon]=1.;
aba11173	253
1d1ea3ce	254	AliAODHeader* header = AODEvent()->GetHeader();
1d1ea3ce	255	AliAODTrack *aodTrack = 0x0;
aba11173	256	AliESDMuonTrack *esdMuTrack = 0x0;
aba11173	257
1d1ea3ce	258	// Access to the AOD container of tracks
	259	TClonesArray &tracks = *(AODEvent()->GetTracks());
	260	Int_t jTracks = header->GetRefMultiplicity();
	261
	262	// Read primary vertex from AOD event
aba11173	263	AliAODVertex *primary = AODEvent()->GetPrimaryVertex();
6fa3e5c7	264	if (fDebug && primary) primary->Print();
aba11173	265
1d1ea3ce	266	// Loop on muon tracks to fill the AOD track branch
1d1ea3ce	267	Int_t nMuTracks = esd->GetNumberOfMuonTracks();
866d8d78	268
daf100e1	269	for (Int_t iTrack=0; iTrack<nMuTracks; ++iTrack) esd->GetMuonTrack(iTrack)->SetESDEvent(esd);
aba11173	270
aba11173	271	// Update number of positive and negative tracks from AOD event (M.G.)
1d1ea3ce	272	Int_t nPosTracks = header->GetRefMultiplicityPos();
1d1ea3ce	273	Int_t nNegTracks = header->GetRefMultiplicityNeg();
aba11173	274
866d8d78	275	// Access to the AOD container of dimuons
866d8d78	276	TClonesArray &dimuons = *(AODEvent()->GetDimuons());
866d8d78	277
866d8d78	278	Int_t nMuons=0;
29e7e51b	279	Int_t nDimuons=0;
866d8d78	280	Int_t jDimuons=0;
397081d5	281	Int_t nMuonTrack[100];
6fa3e5c7	282	UChar_t itsClusMap(0);
87ac315c	283
397081d5	284	for(int imuon=0;imuon<100;imuon++) nMuonTrack[imuon]=0;
26ba01d4	285
	286	for (Int_t nMuTrack = 0; nMuTrack < nMuTracks; ++nMuTrack)
	287	{
aba11173	288	esdMuTrack = esd->GetMuonTrack(nMuTrack);
	289
	290	if (!esdMuTrack->ContainTrackerData()) continue;
daf100e1	291
6fa3e5c7	292	UInt_t selectInfo(0);
6fa3e5c7	293
aba11173	294	// Track selection
	295	if (fTrackFilter) {
	296	selectInfo = fTrackFilter->IsSelected(esdMuTrack);
	297	if (!selectInfo) {
	298	continue;
	299	}
87ac315c	300	}
26ba01d4	301
aba11173	302	p[0] = esdMuTrack->Px();
	303	p[1] = esdMuTrack->Py();
	304	p[2] = esdMuTrack->Pz();
	305
	306	pos[0] = esdMuTrack->GetNonBendingCoor();
	307	pos[1] = esdMuTrack->GetBendingCoor();
	308	pos[2] = esdMuTrack->GetZ();
	309
6fa3e5c7	310	if (mcH) mcH->SelectParticle(esdMuTrack->GetLabel()); // to insure that particle's ancestors will be in output MC branches
fc3a4c45	311
aba11173	312	aodTrack = new(tracks[jTracks++]) AliAODTrack(esdMuTrack->GetUniqueID(), // ID
26ba01d4	313	esdMuTrack->GetLabel(), // label
	314	p, // momentum
	315	kTRUE, // cartesian coordinate system
	316	pos, // position
	317	kFALSE, // isDCA
	318	0x0, // covariance matrix
	319	esdMuTrack->Charge(), // charge
6fa3e5c7	320	itsClusMap, // ITSClusterMap
26ba01d4	321	pid, // pid
	322	primary, // primary vertex
	323	kFALSE, // used for vertex fit?
	324	kFALSE, // used for primary vertex fit?
	325	AliAODTrack::kPrimary,// track type
	326	selectInfo);
aba11173	327
	328	aodTrack->SetXYAtDCA(esdMuTrack->GetNonBendingCoorAtDCA(), esdMuTrack->GetBendingCoorAtDCA());
	329	aodTrack->SetPxPyPzAtDCA(esdMuTrack->PxAtDCA(), esdMuTrack->PyAtDCA(), esdMuTrack->PzAtDCA());
f43586f0	330	aodTrack->SetRAtAbsorberEnd(esdMuTrack->GetRAtAbsorberEnd());
aba11173	331	aodTrack->ConvertAliPIDtoAODPID();
	332	aodTrack->SetChi2perNDF(esdMuTrack->GetChi2() / (2.*esdMuTrack->GetNHit() - 5.));
	333	aodTrack->SetChi2MatchTrigger(esdMuTrack->GetChi2MatchTrigger());
	334	aodTrack->SetHitsPatternInTrigCh(esdMuTrack->GetHitsPatternInTrigCh());
	335	aodTrack->SetMuonClusterMap(esdMuTrack->GetMuonClusterMap());
	336	aodTrack->SetMatchTrigger(esdMuTrack->GetMatchTrigger());
5c15a68b	337	aodTrack->Connected(esdMuTrack->IsConnected());
aba11173	338	primary->AddDaughter(aodTrack);
	339
	340	if (esdMuTrack->Charge() > 0) nPosTracks++;
	341	else nNegTracks++;
866d8d78	342
ca3ff602	343	nMuonTrack[nMuons]= jTracks-1;
26ba01d4	344	++nMuons;
87ac315c	345	}
26ba01d4	346
	347	if(nMuons>=2)
	348	{
	349	for(int i=0;i<nMuons;i++){
	350	Int_t index0 = nMuonTrack[i];
	351	for(int j=i+1;j<nMuons;j++){
	352	Int_t index1 = nMuonTrack[j];
76b26647	353	new(dimuons[jDimuons++]) AliAODDimuon(tracks.At(index0),tracks.At(index1));
26ba01d4	354	++nDimuons;
	355	if (fDebug > 1){
	356	AliAODDimuon dimuon0 = (AliAODDimuon)dimuons.At(jDimuons-1);
	357	printf("Dimuon: mass = %f, px=%f, py=%f, pz=%f\n",dimuon0->M(),dimuon0->Px(),dimuon0->Py(),dimuon0->Pz());
	358	AliAODTrack mu0 = (AliAODTrack) dimuon0->GetMu(0);
	359	AliAODTrack mu1 = (AliAODTrack) dimuon0->GetMu(1);
	360	printf("Muon0 px=%f py=%f pz=%f\n",mu0->Px(),mu0->Py(),mu0->Pz());
	361	printf("Muon1 px=%f py=%f pz=%f\n",mu1->Px(),mu1->Py(),mu1->Pz());
	362	}
87ac315c	363	}
866d8d78	364	}
26ba01d4	365	}
26ba01d4	366
aba11173	367
1d1ea3ce	368	header->SetRefMultiplicity(jTracks);
	369	header->SetRefMultiplicityPos(nPosTracks);
	370	header->SetRefMultiplicityNeg(nNegTracks);
29e7e51b	371	header->SetNumberOfMuons(nMuons);
29e7e51b	372	header->SetNumberOfDimuons(nDimuons);
866d8d78	373
6fa3e5c7	374	AliAODHandler* handler = dynamic_cast<AliAODHandler*>(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler());
	375
	376	if ( handler && fEnableMuonAOD && ( (nMuons>0) \|\| fKeepAllEvents ) )
26ba01d4	377	{
6fa3e5c7	378	AliAODExtension *extMuons = handler->GetFilteredAOD("AliAOD.Muons.root");
6fa3e5c7	379	if ( extMuons ) extMuons->SelectEvent();
866d8d78	380	}
26ba01d4	381
6fa3e5c7	382	if ( handler && fEnableDimuonAOD && ( (nMuons>1) \|\| fKeepAllEvents ) )
26ba01d4	383	{
6fa3e5c7	384	AliAODExtension *extDimuons = handler->GetFilteredAOD("AliAOD.Dimuons.root");
6fa3e5c7	385	if ( extDimuons ) extDimuons->SelectEvent();
f785fc59	386	}
26ba01d4	387
1d1ea3ce	388	}
	389
	390	void AliAnalysisTaskESDMuonFilter::Terminate(Option_t /option*/)
	391	{
aba11173	392	// Terminate analysis
	393	//
	394	if (fDebug > 1) printf("AnalysisESDfilter: Terminate() \n");
1d1ea3ce	395	}