PWG/muon/AliAnalysisTaskSEMuonsHF.cxx

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