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

/**************************************************************************
 * Copyright(c) 1998-2008, 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$ */

/////////////////////////////////////////////////////////////
//
// AliAnalysisTaskSE for the single muon and dimuon from HF analysis,
// using the classes AliMuonsHFHeader,
//                   AliMuonInfoStoreRD,
//                   AliDimuInfoStoreRD,
//                   AliMuonInfoStoreMC,
//                   AliDimuInfoStoreMC.
//
// Author: X-M. Zhang, zhang@clermont.in2p3.fr
//                     zhangxm@iopp.ccnu.edu.cn
/////////////////////////////////////////////////////////////

#include <TList.h>
#include <TClonesArray.h>

#include "AliESDEvent.h"
#include "AliAODEvent.h"
#include "AliESDHeader.h"
#include "AliAODHeader.h"
#include "AliESDMuonTrack.h"
#include "AliAODTrack.h"
#include "AliCentrality.h"
#include "AliMuonsHFHeader.h"
#include "AliMuonInfoStoreRD.h"
#include "AliMuonInfoStoreMC.h"
#include "AliDimuInfoStoreRD.h"
#include "AliDimuInfoStoreMC.h"
#include "AliAnalysisManager.h"
#include "AliInputEventHandler.h"
#include "AliMuonTrackCuts.h"
#include "AliMuonPairCuts.h"
#include "AliAnalysisTaskSEMuonsHF.h"

ClassImp(AliAnalysisTaskSEMuonsHF)

//_____________________________________________________________________________
AliAnalysisTaskSEMuonsHF::AliAnalysisTaskSEMuonsHF() :
AliAnalysisTaskSE(),
fAnaMode(0),
fIsOutputTree(kFALSE),
fIsMC(kFALSE),
fCutsMuon(0x0),
fCutsDimu(0x0),
fHeader(0),
fMuonClArr(0),
fDimuClArr(0),
fListOutput(0)
{
  //
  // Default constructor
  //
}

//_____________________________________________________________________________
AliAnalysisTaskSEMuonsHF::AliAnalysisTaskSEMuonsHF(const char *name, const AliMuonTrackCuts& cutsMuon, const AliMuonPairCuts& cutsDimu) :
AliAnalysisTaskSE(name),
fAnaMode(0),
fIsOutputTree(kFALSE),
fIsMC(kFALSE),
fCutsMuon(new AliMuonTrackCuts(cutsMuon)),
fCutsDimu(new AliMuonPairCuts(cutsDimu)),
fHeader(0),
fMuonClArr(0),
fDimuClArr(0),
fListOutput(0)
{
  //
  // Constructor
  //
  DefineOutput(1, TList::Class());
}

//_____________________________________________________________________________
AliAnalysisTaskSEMuonsHF::~AliAnalysisTaskSEMuonsHF()
{
  //
  // Default destructor
  //
  if (fCutsMuon)   { delete fCutsMuon;   fCutsMuon  =NULL; }
  if (fCutsDimu)   { delete fCutsDimu;   fCutsDimu  =NULL; }
  if (fHeader)     { delete fHeader;     fHeader    =NULL; }
  if (fMuonClArr)  { delete fMuonClArr;  fMuonClArr =NULL; }
  if (fDimuClArr)  { delete fDimuClArr;  fDimuClArr =NULL; }
  if (fListOutput) { delete fListOutput; fListOutput=NULL; }
}

//_____________________________________________________________________________
void AliAnalysisTaskSEMuonsHF::Init()
{
  // Initialization
  // Setting and initializing the running mode and status

  AliMuonsHFHeader::SetAnaMode(fAnaMode);
  AliMuonsHFHeader::SetIsMC(fIsMC);
  if (!fHeader) {
    fHeader = new AliMuonsHFHeader();
    fHeader->SetName(AliMuonsHFHeader::StdBranchName());
  }

  if (!fMuonClArr) {
    if (fIsMC) { 
      fMuonClArr = new TClonesArray("AliMuonInfoStoreMC", 0);
      fMuonClArr->SetName(AliMuonInfoStoreMC::StdBranchName());
    } else {
      fMuonClArr = new TClonesArray("AliMuonInfoStoreRD", 0);
      fMuonClArr->SetName(AliMuonInfoStoreRD::StdBranchName());
    }
  }

  if (fAnaMode!=1 && !fDimuClArr) {
    if (fIsMC) {
      fDimuClArr = new TClonesArray("AliDimuInfoStoreMC", 0);
      fDimuClArr->SetName(AliDimuInfoStoreMC::StdBranchName());
    } else {
      fDimuClArr = new TClonesArray("AliDimuInfoStoreRD", 0);
      fDimuClArr->SetName(AliDimuInfoStoreRD::StdBranchName());
    }
  }

  return;
}

//_____________________________________________________________________________
void AliAnalysisTaskSEMuonsHF::UserCreateOutputObjects()
{
  // Create the output container

  if (!fListOutput) fListOutput = new TList();
  fHeader->CreateHistograms(fListOutput);

  if (fIsOutputTree) {
    AddAODBranch("AliMuonsHFHeader", &fHeader);
    AddAODBranch("TClonesArray", &fMuonClArr);
    if (fAnaMode!=1) AddAODBranch("TClonesArray", &fDimuClArr);
  }

  fCutsMuon->Print("mask");
  fCutsDimu->Print("mask");
  return;
}

//_____________________________________________________________________________
void AliAnalysisTaskSEMuonsHF::UserExec(Option_t *)
{
  // Execute analysis for current event:
  // muon event header & (di)muon info store

  if (fIsMC) {
    if (MCEvent()) {
      if (MCEvent()->GetNumberOfTracks()<=0)
           { AliError("MC event not found. Nothing done!"); return; }
    } else { AliError("MC event not found. Nothing done!"); return; }
  }

  if ( !fCutsMuon) { AliError("AliMuonTrackCuts should be loaded!"); return;}
  if ((!fCutsDimu) && (fAnaMode!=1)) { AliError("AliMuonPairCuts should be loaded!"); return; }

  Int_t ntrks = 0;
  AliAODEvent *aod = 0;
  AliESDEvent *esd = 0;
  if (((TString)InputEvent()->IsA()->GetName())=="AliAODEvent") {
    aod = dynamic_cast<AliAODEvent*>(InputEvent());
    if (!aod) { AliError("AOD event not found. Nothing done!"); return; }
    if (!fIsMC && (aod->GetHeader()->GetEventType()!=7)) return;
    ntrks = aod->GetNTracks();
  } else {
    esd = dynamic_cast<AliESDEvent*>(InputEvent());
    if (!esd) { AliError("ESD event not found. Nothing done!"); return; }
    if (!fIsMC && (esd->GetHeader()->GetEventType()!=7)) return;
    ntrks = esd->GetNumberOfMuonTracks();
  } if (fIsOutputTree) AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillAOD(kTRUE);

  fHeader->SetEventInfo(fInputHandler, MCEvent());
  fHeader->FillHistosEvnH(fListOutput);

  fMuonClArr->Delete();
  TClonesArray &muonRef = *fMuonClArr;
  Int_t countN = fMuonClArr->GetEntriesFast();

  Int_t trkID[ntrks];
  AliAODTrack        *trkAOD = 0;
  AliESDMuonTrack    *trkESD = 0;
  AliMuonInfoStoreRD *muonRD = 0;
  AliMuonInfoStoreMC *muonMC = 0;
  for (Int_t itrk=0; itrk<ntrks; itrk++) {  // loop over all tracks
    if (aod) {
      trkAOD = (AliAODTrack*)aod->GetTrack(itrk);
      if (!trkAOD->IsMuonTrack())        { trkAOD=0; continue; }
      if (fIsMC) muonMC = new AliMuonInfoStoreMC(trkAOD,MCEvent(),fCutsMuon->GetSelectionMask(trkAOD));
      else muonRD = new AliMuonInfoStoreRD(trkAOD,fCutsMuon->GetSelectionMask(trkAOD));
      trkAOD = 0;
    } else {
      trkESD = (AliESDMuonTrack*)esd->GetMuonTrack(itrk);
      if (!trkESD->ContainTrackerData()) { trkESD=0; continue; }
      if (fIsMC) muonMC = new AliMuonInfoStoreMC(trkESD,MCEvent(),fCutsMuon->GetSelectionMask(trkESD));
      else muonRD = new AliMuonInfoStoreRD(trkESD,fCutsMuon->GetSelectionMask(trkESD));
      trkESD = 0;
    } if (muonRD) {
      new(muonRef[countN++]) AliMuonInfoStoreRD(*muonRD);
      if (fAnaMode!=2) fHeader->FillHistosMuon(fListOutput, muonRD);
    } if (muonMC) {
      new(muonRef[countN++]) AliMuonInfoStoreMC(*muonMC);
      if (fAnaMode!=2) fHeader->FillHistosMuon(fListOutput, muonMC, muonMC->Source());
    } trkID[countN-1] = itrk;

    if (muonRD) { delete muonRD; muonRD=0; }
    if (muonMC) { delete muonMC; muonMC=0; }
  }  // end loop of all tracks

  if (fAnaMode==1) { aod=0; esd=0; PostData(1,fListOutput); return; }

  fDimuClArr->Delete();
  countN = fDimuClArr->GetEntriesFast();
  TClonesArray &dimuRef = *fDimuClArr;

  AliDimuInfoStoreRD *dimuRD = 0;
  AliDimuInfoStoreMC *dimuMC = 0;
  ntrks = fMuonClArr->GetEntriesFast();
  for (Int_t itrk=0; itrk<ntrks-1; itrk++) {  // 1st loop over muon tracks
    for (Int_t jtrk=itrk+1; jtrk<ntrks; jtrk++) {  // 2nd loop ofver muon tracks
      UInt_t selMask = 0;
      if (aod) selMask = fCutsDimu->GetSelectionMask(aod->GetTrack(    trkID[itrk]),aod->GetTrack(    trkID[jtrk]));
      else     selMask = fCutsDimu->GetSelectionMask(esd->GetMuonTrack(trkID[itrk]),esd->GetMuonTrack(trkID[jtrk]));

      if (fIsMC) dimuMC = new AliDimuInfoStoreMC((AliMuonInfoStoreMC*)fMuonClArr->At(itrk),(AliMuonInfoStoreMC*)fMuonClArr->At(jtrk),selMask);
      else       dimuRD = new AliDimuInfoStoreRD((AliMuonInfoStoreRD*)fMuonClArr->At(itrk),(AliMuonInfoStoreRD*)fMuonClArr->At(jtrk),selMask);

      if (dimuRD) {
        fHeader->FillHistosDimu(fListOutput, dimuRD);
        if (fIsOutputTree) new(dimuRef[countN++]) AliDimuInfoStoreRD(*dimuRD);
      }
      if (dimuMC) {
        fHeader->FillHistosDimu(fListOutput, dimuMC, dimuMC->Source());
        if (fIsOutputTree) new(dimuRef[countN++]) AliDimuInfoStoreMC(*dimuMC);
      }

      if (dimuRD) { delete dimuRD; dimuRD=0; }
      if (dimuMC) { delete dimuMC; dimuMC=0; }
    }  // end 2nd loop of muon tracks
  }  // end 1st loop of muon tracks

  aod = 0; esd = 0;
  PostData(1, fListOutput);
  return;
}

//_____________________________________________________________________________
void AliAnalysisTaskSEMuonsHF::Terminate(Option_t *)
{
  // Terminate analysis

  // add the correction matrix

  return;
}

void AliAnalysisTaskSEMuonsHF::NotifyRun()
{
  // Notify of the current run number

  if (fCutsMuon) fCutsMuon->SetRun(fCurrentRunNumber);
  if (fCutsDimu) fCutsDimu->SetRun(fCurrentRunNumber);
  return;
}
Commit	Line	Data
fd1d0cb9	1	/**************************************************************************
	2	* Copyright(c) 1998-2008, 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
fd1d0cb9	18	/////////////////////////////////////////////////////////////
	19	//
	20	// AliAnalysisTaskSE for the single muon and dimuon from HF analysis,
	21	// using the classes AliMuonsHFHeader,
	22	// AliMuonInfoStoreRD,
	23	// AliDimuInfoStoreRD,
	24	// AliMuonInfoStoreMC,
	25	// AliDimuInfoStoreMC.
	26	//
	27	// Author: X-M. Zhang, zhang@clermont.in2p3.fr
	28	// zhangxm@iopp.ccnu.edu.cn
	29	/////////////////////////////////////////////////////////////
	30
	31	#include <TList.h>
4292b3b6	32	#include <TClonesArray.h>
4292b3b6	33
4292b3b6	34	#include "AliESDEvent.h"
4292b3b6	35	#include "AliAODEvent.h"
9bcac085	36	#include "AliESDHeader.h"
9bcac085	37	#include "AliAODHeader.h"
4292b3b6	38	#include "AliESDMuonTrack.h"
4292b3b6	39	#include "AliAODTrack.h"
9bcac085	40	#include "AliCentrality.h"
4292b3b6	41	#include "AliMuonsHFHeader.h"
fd1d0cb9	42	#include "AliMuonInfoStoreRD.h"
	43	#include "AliMuonInfoStoreMC.h"
	44	#include "AliDimuInfoStoreRD.h"
	45	#include "AliDimuInfoStoreMC.h"
6709e09d	46	#include "AliAnalysisManager.h"
9bcac085	47	#include "AliInputEventHandler.h"
9bbc42ca	48	#include "AliMuonTrackCuts.h"
9bbc42ca	49	#include "AliMuonPairCuts.h"
9bcac085	50	#include "AliAnalysisTaskSEMuonsHF.h"
4292b3b6	51
	52	ClassImp(AliAnalysisTaskSEMuonsHF)
	53
	54	//_____________________________________________________________________________
	55	AliAnalysisTaskSEMuonsHF::AliAnalysisTaskSEMuonsHF() :
	56	AliAnalysisTaskSE(),
	57	fAnaMode(0),
	58	fIsOutputTree(kFALSE),
1195bb6f	59	fIsMC(kFALSE),
9bbc42ca	60	fCutsMuon(0x0),
9bbc42ca	61	fCutsDimu(0x0),
4292b3b6	62	fHeader(0),
fd1d0cb9	63	fMuonClArr(0),
fd1d0cb9	64	fDimuClArr(0),
1195bb6f	65	fListOutput(0)
4292b3b6	66	{
	67	//
	68	// Default constructor
	69	//
4292b3b6	70	}
	71
	72	//_____________________________________________________________________________
9bbc42ca	73	AliAnalysisTaskSEMuonsHF::AliAnalysisTaskSEMuonsHF(const char *name, const AliMuonTrackCuts& cutsMuon, const AliMuonPairCuts& cutsDimu) :
4292b3b6	74	AliAnalysisTaskSE(name),
	75	fAnaMode(0),
	76	fIsOutputTree(kFALSE),
1195bb6f	77	fIsMC(kFALSE),
9bbc42ca	78	fCutsMuon(new AliMuonTrackCuts(cutsMuon)),
9bbc42ca	79	fCutsDimu(new AliMuonPairCuts(cutsDimu)),
4292b3b6	80	fHeader(0),
fd1d0cb9	81	fMuonClArr(0),
fd1d0cb9	82	fDimuClArr(0),
1195bb6f	83	fListOutput(0)
4292b3b6	84	{
	85	//
	86	// Constructor
	87	//
1195bb6f	88	DefineOutput(1, TList::Class());
4292b3b6	89	}
	90
	91	//_____________________________________________________________________________
	92	AliAnalysisTaskSEMuonsHF::~AliAnalysisTaskSEMuonsHF()
	93	{
	94	//
	95	// Default destructor
	96	//
9bbc42ca	97	if (fCutsMuon) { delete fCutsMuon; fCutsMuon =NULL; }
9bbc42ca	98	if (fCutsDimu) { delete fCutsDimu; fCutsDimu =NULL; }
1195bb6f	99	if (fHeader) { delete fHeader; fHeader =NULL; }
	100	if (fMuonClArr) { delete fMuonClArr; fMuonClArr =NULL; }
	101	if (fDimuClArr) { delete fDimuClArr; fDimuClArr =NULL; }
	102	if (fListOutput) { delete fListOutput; fListOutput=NULL; }
4292b3b6	103	}
	104
	105	//_____________________________________________________________________________
fd1d0cb9	106	void AliAnalysisTaskSEMuonsHF::Init()
4292b3b6	107	{
fd1d0cb9	108	// Initialization
fd1d0cb9	109	// Setting and initializing the running mode and status
4292b3b6	110
fd1d0cb9	111	AliMuonsHFHeader::SetAnaMode(fAnaMode);
1195bb6f	112	AliMuonsHFHeader::SetIsMC(fIsMC);
4292b3b6	113	if (!fHeader) {
4292b3b6	114	fHeader = new AliMuonsHFHeader();
fd1d0cb9	115	fHeader->SetName(AliMuonsHFHeader::StdBranchName());
4292b3b6	116	}
fd1d0cb9	117
fd1d0cb9	118	if (!fMuonClArr) {
1195bb6f	119	if (fIsMC) {
fd1d0cb9	120	fMuonClArr = new TClonesArray("AliMuonInfoStoreMC", 0);
	121	fMuonClArr->SetName(AliMuonInfoStoreMC::StdBranchName());
	122	} else {
	123	fMuonClArr = new TClonesArray("AliMuonInfoStoreRD", 0);
	124	fMuonClArr->SetName(AliMuonInfoStoreRD::StdBranchName());
	125	}
4292b3b6	126	}
4292b3b6	127
fd1d0cb9	128	if (fAnaMode!=1 && !fDimuClArr) {
1195bb6f	129	if (fIsMC) {
fd1d0cb9	130	fDimuClArr = new TClonesArray("AliDimuInfoStoreMC", 0);
	131	fDimuClArr->SetName(AliDimuInfoStoreMC::StdBranchName());
	132	} else {
	133	fDimuClArr = new TClonesArray("AliDimuInfoStoreRD", 0);
	134	fDimuClArr->SetName(AliDimuInfoStoreRD::StdBranchName());
	135	}
	136	}
	137
	138	return;
	139	}
	140
	141	//_____________________________________________________________________________
	142	void AliAnalysisTaskSEMuonsHF::UserCreateOutputObjects()
	143	{
	144	// Create the output container
	145
1195bb6f	146	if (!fListOutput) fListOutput = new TList();
1195bb6f	147	fHeader->CreateHistograms(fListOutput);
4292b3b6	148
	149	if (fIsOutputTree) {
	150	AddAODBranch("AliMuonsHFHeader", &fHeader);
fd1d0cb9	151	AddAODBranch("TClonesArray", &fMuonClArr);
fd1d0cb9	152	if (fAnaMode!=1) AddAODBranch("TClonesArray", &fDimuClArr);
4292b3b6	153	}
4292b3b6	154
9bbc42ca	155	fCutsMuon->Print("mask");
9bbc42ca	156	fCutsDimu->Print("mask");
4292b3b6	157	return;
	158	}
	159
	160	//_____________________________________________________________________________
	161	void AliAnalysisTaskSEMuonsHF::UserExec(Option_t *)
	162	{
fd1d0cb9	163	// Execute analysis for current event:
	164	// muon event header & (di)muon info store
	165
1195bb6f	166	if (fIsMC) {
	167	if (MCEvent()) {
	168	if (MCEvent()->GetNumberOfTracks()<=0)
	169	{ AliError("MC event not found. Nothing done!"); return; }
	170	} else { AliError("MC event not found. Nothing done!"); return; }
	171	}
	172
9bbc42ca	173	if ( !fCutsMuon) { AliError("AliMuonTrackCuts should be loaded!"); return;}
	174	if ((!fCutsDimu) && (fAnaMode!=1)) { AliError("AliMuonPairCuts should be loaded!"); return; }
	175
4292b3b6	176	Int_t ntrks = 0;
	177	AliAODEvent *aod = 0;
	178	AliESDEvent *esd = 0;
1195bb6f	179	if (((TString)InputEvent()->IsA()->GetName())=="AliAODEvent") {
4292b3b6	180	aod = dynamic_cast<AliAODEvent*>(InputEvent());
fd1d0cb9	181	if (!aod) { AliError("AOD event not found. Nothing done!"); return; }
9bcac085	182	if (!fIsMC && (aod->GetHeader()->GetEventType()!=7)) return;
4292b3b6	183	ntrks = aod->GetNTracks();
	184	} else {
	185	esd = dynamic_cast<AliESDEvent*>(InputEvent());
fd1d0cb9	186	if (!esd) { AliError("ESD event not found. Nothing done!"); return; }
9bcac085	187	if (!fIsMC && (esd->GetHeader()->GetEventType()!=7)) return;
4292b3b6	188	ntrks = esd->GetNumberOfMuonTracks();
9bbc42ca	189	} if (fIsOutputTree) AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillAOD(kTRUE);
4292b3b6	190
9bbc42ca	191	fHeader->SetEventInfo(fInputHandler, MCEvent());
9bcac085	192	fHeader->FillHistosEvnH(fListOutput);
9bcac085	193
fd1d0cb9	194	fMuonClArr->Delete();
	195	TClonesArray &muonRef = *fMuonClArr;
	196	Int_t countN = fMuonClArr->GetEntriesFast();
4292b3b6	197
9bbc42ca	198	Int_t trkID[ntrks];
fd1d0cb9	199	AliAODTrack *trkAOD = 0;
fd1d0cb9	200	AliESDMuonTrack *trkESD = 0;
1195bb6f	201	AliMuonInfoStoreRD *muonRD = 0;
1195bb6f	202	AliMuonInfoStoreMC *muonMC = 0;
4292b3b6	203	for (Int_t itrk=0; itrk<ntrks; itrk++) { // loop over all tracks
1195bb6f	204	if (aod) {
4292b3b6	205	trkAOD = (AliAODTrack*)aod->GetTrack(itrk);
1195bb6f	206	if (!trkAOD->IsMuonTrack()) { trkAOD=0; continue; }
9bbc42ca	207	if (fIsMC) muonMC = new AliMuonInfoStoreMC(trkAOD,MCEvent(),fCutsMuon->GetSelectionMask(trkAOD));
9bbc42ca	208	else muonRD = new AliMuonInfoStoreRD(trkAOD,fCutsMuon->GetSelectionMask(trkAOD));
fd1d0cb9	209	trkAOD = 0;
4292b3b6	210	} else {
4292b3b6	211	trkESD = (AliESDMuonTrack*)esd->GetMuonTrack(itrk);
1195bb6f	212	if (!trkESD->ContainTrackerData()) { trkESD=0; continue; }
9bbc42ca	213	if (fIsMC) muonMC = new AliMuonInfoStoreMC(trkESD,MCEvent(),fCutsMuon->GetSelectionMask(trkESD));
9bbc42ca	214	else muonRD = new AliMuonInfoStoreRD(trkESD,fCutsMuon->GetSelectionMask(trkESD));
fd1d0cb9	215	trkESD = 0;
9bbc42ca	216	} if (muonRD) {
1195bb6f	217	new(muonRef[countN++]) AliMuonInfoStoreRD(*muonRD);
1195bb6f	218	if (fAnaMode!=2) fHeader->FillHistosMuon(fListOutput, muonRD);
9bbc42ca	219	} if (muonMC) {
1195bb6f	220	new(muonRef[countN++]) AliMuonInfoStoreMC(*muonMC);
1195bb6f	221	if (fAnaMode!=2) fHeader->FillHistosMuon(fListOutput, muonMC, muonMC->Source());
9bbc42ca	222	} trkID[countN-1] = itrk;
4292b3b6	223
1195bb6f	224	if (muonRD) { delete muonRD; muonRD=0; }
1195bb6f	225	if (muonMC) { delete muonMC; muonMC=0; }
4292b3b6	226	} // end loop of all tracks
fd1d0cb9	227
9bbc42ca	228	if (fAnaMode==1) { aod=0; esd=0; PostData(1,fListOutput); return; }
1195bb6f	229
fd1d0cb9	230	fDimuClArr->Delete();
	231	countN = fDimuClArr->GetEntriesFast();
	232	TClonesArray &dimuRef = *fDimuClArr;
4292b3b6	233
fd1d0cb9	234	AliDimuInfoStoreRD *dimuRD = 0;
	235	AliDimuInfoStoreMC *dimuMC = 0;
	236	ntrks = fMuonClArr->GetEntriesFast();
4292b3b6	237	for (Int_t itrk=0; itrk<ntrks-1; itrk++) { // 1st loop over muon tracks
fd1d0cb9	238	for (Int_t jtrk=itrk+1; jtrk<ntrks; jtrk++) { // 2nd loop ofver muon tracks
9bbc42ca	239	UInt_t selMask = 0;
	240	if (aod) selMask = fCutsDimu->GetSelectionMask(aod->GetTrack( trkID[itrk]),aod->GetTrack( trkID[jtrk]));
	241	else selMask = fCutsDimu->GetSelectionMask(esd->GetMuonTrack(trkID[itrk]),esd->GetMuonTrack(trkID[jtrk]));
	242
	243	if (fIsMC) dimuMC = new AliDimuInfoStoreMC((AliMuonInfoStoreMC)fMuonClArr->At(itrk),(AliMuonInfoStoreMC)fMuonClArr->At(jtrk),selMask);
	244	else dimuRD = new AliDimuInfoStoreRD((AliMuonInfoStoreRD)fMuonClArr->At(itrk),(AliMuonInfoStoreRD)fMuonClArr->At(jtrk),selMask);
4292b3b6	245
fd1d0cb9	246	if (dimuRD) {
1195bb6f	247	fHeader->FillHistosDimu(fListOutput, dimuRD);
fd1d0cb9	248	if (fIsOutputTree) new(dimuRef[countN++]) AliDimuInfoStoreRD(*dimuRD);
	249	}
	250	if (dimuMC) {
1195bb6f	251	fHeader->FillHistosDimu(fListOutput, dimuMC, dimuMC->Source());
fd1d0cb9	252	if (fIsOutputTree) new(dimuRef[countN++]) AliDimuInfoStoreMC(*dimuMC);
4292b3b6	253	}
4292b3b6	254
fd1d0cb9	255	if (dimuRD) { delete dimuRD; dimuRD=0; }
	256	if (dimuMC) { delete dimuMC; dimuMC=0; }
	257	} // end 2nd loop of muon tracks
4292b3b6	258	} // end 1st loop of muon tracks
4292b3b6	259
9bbc42ca	260	aod = 0; esd = 0;
1195bb6f	261	PostData(1, fListOutput);
4292b3b6	262	return;
	263	}
	264
	265	//_____________________________________________________________________________
	266	void AliAnalysisTaskSEMuonsHF::Terminate(Option_t *)
	267	{
fd1d0cb9	268	// Terminate analysis
4292b3b6	269
1195bb6f	270	// add the correction matrix
4292b3b6	271
4292b3b6	272	return;
4292b3b6	273	}
9bbc42ca	274
	275	void AliAnalysisTaskSEMuonsHF::NotifyRun()
	276	{
	277	// Notify of the current run number
	278
	279	if (fCutsMuon) fCutsMuon->SetRun(fCurrentRunNumber);
	280	if (fCutsDimu) fCutsDimu->SetRun(fCurrentRunNumber);
	281	return;
	282	}