PWG3/muon/AliAnalysisTaskSingleMuESD.cxx

   1 #include "TChain.h"
   2 #include "TTree.h"
   3 #include "TNtuple.h"
   4 #include "TH1F.h"
   5 #include "TString.h"
   6
   7 #include "AliAnalysisTask.h"
   8 #include "AliAnalysisManager.h"
   9
  10 #include "AliESDEvent.h"
  11 #include "AliESDInputHandler.h"
  12 #include "AliESDVertex.h"
  13 #include "AliESDMuonTrack.h"
  14
  15 #include "AliAnalysisTaskSingleMuESD.h"
  16
  17 // analysis task for single muon analysis of the ESD events
  18 // Authors: Bogdan Vulpescu, Nicole Bastid, LPC Clermont-Ferrand
  19
  20 ClassImp(AliAnalysisTaskSingleMuESD)
  21
  22 //________________________________________________________________________
  23 AliAnalysisTaskSingleMuESD::AliAnalysisTaskSingleMuESD(const char *name)
  24   : AliAnalysisTask(name, ""),
  25     fESD(0),
  26     fNtuple(0),
  27     fTrigger(0),
  28     fMaskTrig1MuL(1),
  29     fMaskTrig1MuH(2),
  30     fMaskTrigUSL(4),
  31     fMaskTrigLSL(16),
  32     fMaskTrigUSH(8),
  33     fMaskTrigLSH(32),
  34     fTriggerType(kFALSE)
  35 {
  36   // Constructor
  37
  38   // Define input and output slots here
  39   // Input slot #0 works with a TChain
  40   DefineInput(0, TChain::Class());
  41   // Output slot #0 writes into a TNtuple container
  42   DefineOutput(0, TNtuple::Class());
  43   // Output slot #1 writes into a TH1F container
  44   DefineOutput(1, TH1F::Class());
  45 }
  46
  47 //________________________________________________________________________
  48 void AliAnalysisTaskSingleMuESD::ConnectInputData(Option_t *)
  49 {
  50   // Connect ESD or AOD here
  51   // Called once
  52
  53   TTree* tree = dynamic_cast<TTree*> (GetInputData(0));
  54   if (!tree) {
  55     Printf("ERROR: Could not read chain from input slot 0");
  56   } else {
  57     // Disable all branches and enable only the needed ones
  58     // The next two lines are different when data produced as AliESDEvent is read
  59     tree->SetBranchStatus("*", kFALSE);
  60     tree->SetBranchStatus("MuonTracks.*", kTRUE);
  61     tree->SetBranchStatus("SPDVertex.*", kTRUE);
  62     tree->SetBranchStatus("AliESDHeader.*", kTRUE);
  63
  64     AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
  65
  66     if (!esdH) {
  67       Printf("ERROR: Could not get ESDInputHandler");
  68     } else
  69       fESD = esdH->GetEvent();
  70   }
  71 }
  72
  73 //________________________________________________________________________
  74 void AliAnalysisTaskSingleMuESD::CreateOutputObjects()
  75 {
  76   // Create output ntuple
  77
  78   fNtuple = new TNtuple("ntEsd1mu","ntEsd1mu","VtZ:Mult:TMask:Z:Pt:P:Eta:Theta:Phi:Zpos:Hits:Xi2:Eff:TrigMatch:TrigXi2");
  79   // histogram with trigger classes
  80   fTrigger = new TH1F("TriggerMask","L/H/USL/USH/LSL/LSH",6,0,6);
  81
  82 }
  83
  84 //________________________________________________________________________
  85 void AliAnalysisTaskSingleMuESD::Exec(Option_t *)
  86 {
  87   // Main loop
  88   // Called for each event
  89   // Fill the ntuple with variables and the trigger histogram
  90
  91   Float_t  ntvar[15], pt, p, eta, thetad, phid, charge, chi2, zcoor, chi2MatchTrig;
  92   ULong64_t mask = 0;
  93   Int_t masksave = 0, hits, matchTrig;
  94   Double_t rEff[2];
  95   Double_t fZVertex = 0;
  96   Double_t fYVertex = 0;
  97   Double_t fXVertex = 0;
  98   Double_t fErXVertex = 0;
  99   Double_t fErYVertex = 0;
 100
 101   if (!fESD) {
 102     Printf("ERROR: fESD not available");
 103     return;
 104   }
 105
 106   // Trigger checks
 107   // mask values: L/H/USL/USH/LSL/LSH
 108   // Bit position    Histogram bin     Trigger class
 109   // 1 (less)        1 ("L")           MULow          single low pt
 110   // 2               2 ("H")           MUHigh         single high pt
 111   // 3               3 ("USL")         MULU           unlike-sign low pt
 112   // 4               4 ("USH")         MUHU           unlike-sign high pt
 113   // 5               5 ("LSL")         MULL           like-sign low pt
 114   // 6 (most)        6 ("LSH")         MUHL           like-sign high pt
 115   if (fTriggerType) {
 116     mask = fESD->GetTriggerMask();
 117     if (mask & fMaskTrig1MuL) {
 118       fTrigger->Fill(0.5);
 119       masksave |= 0x01;
 120     }
 121     if (mask & fMaskTrig1MuH) {
 122       fTrigger->Fill(1.5);
 123       masksave |= 0x02;
 124     }
 125     if (mask & fMaskTrigUSL)  {
 126       fTrigger->Fill(2.5);
 127       masksave |= 0x04;
 128     }
 129     if (mask & fMaskTrigUSH)  {
 130       fTrigger->Fill(3.5);
 131       masksave |= 0x08;
 132     }
 133     if (mask & fMaskTrigLSL)  {
 134       fTrigger->Fill(4.5);
 135       masksave |= 0x10;
 136     }
 137     if (mask & fMaskTrigLSH)  {
 138       fTrigger->Fill(5.5);
 139       masksave |= 0x20;
 140     }
 141   } else {
 142     TString firedTC = fESD->GetFiredTriggerClasses();
 143     if (firedTC.Contains("MULow")) {
 144       fTrigger->Fill(0.5);
 145       masksave |= 0x01;
 146     }
 147     if (firedTC.Contains("MUHigh")) {
 148       fTrigger->Fill(1.5);
 149       masksave |= 0x02;
 150     }
 151     if (firedTC.Contains("MULU")) {
 152       fTrigger->Fill(2.5);
 153       masksave |= 0x04;
 154     }
 155     if (firedTC.Contains("MUHU")) {
 156       fTrigger->Fill(3.5);
 157       masksave |= 0x08;
 158     }
 159     if (firedTC.Contains("MULL")) {
 160       fTrigger->Fill(4.5);
 161       masksave |= 0x10;
 162     }
 163     if (firedTC.Contains("MUHL")) {
 164       fTrigger->Fill(5.5);
 165       masksave |= 0x20;
 166     }
 167   }
 168
 169   // get the SPD reconstructed vertex (vertexer)
 170   AliESDVertex* vertex = (AliESDVertex*) fESD->GetVertex();
 171   if (vertex->GetNContributors()) {
 172     fZVertex = vertex->GetZv();
 173     fYVertex = vertex->GetYv();
 174     fXVertex = vertex->GetXv();
 175     fErXVertex = vertex->GetXRes();
 176     fErYVertex = vertex->GetYRes();
 177   }
 178
 179   Int_t nTracks = (Int_t)fESD->GetNumberOfMuonTracks() ;
 180   for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
 181
 182     AliESDMuonTrack* muonTrack = new AliESDMuonTrack(*(fESD->GetMuonTrack(iTrack)));
 183     if (!muonTrack) {
 184       Printf("ERROR: Could not receive track %d", iTrack);
 185       continue;
 186     }
 187
 188     pt = muonTrack->Pt();
 189     p = muonTrack->P();
 190     eta = muonTrack->Eta();
 191     thetad =  muonTrack->Theta()*180./TMath::Pi();
 192     phid = muonTrack->Phi()*180./TMath::Pi();
 193     charge = muonTrack->Charge();
 194     hits = muonTrack->GetNHit();
 195     chi2 = muonTrack->GetChi2() / (2.0 * hits - 5);
 196     zcoor = muonTrack->GetZ();
 197     matchTrig = muonTrack->GetMatchTrigger();
 198     chi2MatchTrig = muonTrack->GetChi2MatchTrigger();
 199
 200     rEff[0] = rEff[1] = 0.0;
 201     GetEffFitted(eta,pt,rEff);
 202
 203     ntvar[0] = fZVertex;
 204     ntvar[1] = nTracks;
 205     ntvar[2] = masksave;
 206     ntvar[3] = charge;
 207     ntvar[4] = pt;
 208     ntvar[5] = p;
 209     ntvar[6] = eta;
 210     ntvar[7] = thetad;
 211     ntvar[8] = phid;
 212     ntvar[9] = zcoor;
 213     ntvar[10] = hits;
 214     ntvar[11] = chi2;
 215     ntvar[12] = rEff[0];
 216     ntvar[13] = matchTrig;
 217     ntvar[14] = chi2MatchTrig;
 218
 219     fNtuple->Fill(ntvar);
 220
 221
 222   } //track loop
 223
 224   // Post output data.
 225   PostData(0, fNtuple);
 226   PostData(1, fTrigger);
 227
 228 }
 229
 230 //________________________________________________________________________
 231 void AliAnalysisTaskSingleMuESD::Terminate(Option_t *)
 232 {
 233   // the end
 234 }
 235
 236 //________________________________________________________________________
 237 void AliAnalysisTaskSingleMuESD::GetEffFitted(Double_t eta, Double_t pt, Double_t rEff[2])
 238 {
 239   // tracking efficiency
 240
 241   Int_t nbinEta =15;
 242   Float_t etaMin = -4.;
 243   Float_t etaBin = 0.1;
 244   Int_t numBin = -1;
 245   rEff[0]=1.;rEff[1]=0.;
 246
 247   // nbinEta = number of eta bins startig at etaMin = -4 and binning of 0.1 (etaBin)
 248   Float_t p0[15] = {-0.9338,-0.9441,-0.9397,-0.9586,-0.9713,-0.9752,-0.9711,-0.9751,-0.9746,-0.9729,-0.9754,-0.9722,-0.9722,-0.971,-0.9709};
 249   Float_t p1[15] = {-0.6383,-1.4729,-1.0109,-1.4316,-1.5926,-1.367,-1.1895,-1.2834,-1.3289,-1.5916,-1.4258,-1.0983,-1.0812,-0.7179, -0.4613};
 250
 251   Float_t etaInf, etaSup;
 252   for (Int_t i = 1; i < nbinEta+1; i++){
 253     etaInf = etaMin + (i-1)*etaBin;
 254     etaSup = etaMin + i*etaBin;
 255     if(eta > etaInf && eta <= etaSup) numBin = i-1;
 256   }
 257
 258   if(numBin>=0 && pt >=1.) rEff[0] = p0[numBin] * TMath::TanH(p1[numBin]*pt);
 259   rEff[1] = 0;
 260
 261 }
 262
 263 //________________________________________________________________________
 264 void AliAnalysisTaskSingleMuESD::SetTriggerType(const Char_t *trig)
 265 {
 266   // set the trigger masks according to the trigger type used in the
 267   // simulations
 268
 269   TString triggerType(trig);
 270
 271   if (!triggerType.CompareTo("MUON")) {
 272     fMaskTrig1MuL =  1;  // MULow
 273     fMaskTrig1MuH =  2;  // MUHigh
 274     fMaskTrigUSL  =  4;  // MULU
 275     fMaskTrigLSL  = 16;  // MULL
 276     fMaskTrigUSH  =  8;  // MUHU
 277     fMaskTrigLSH  = 32;  // MUHL
 278   } else if (!triggerType.CompareTo("p-p")) {
 279     fMaskTrig1MuL =    128;  // MULow
 280     fMaskTrig1MuH =    256;  // MUHigh
 281     fMaskTrigUSL  =  65536;  // MULU
 282     fMaskTrigLSL  = 131072;  // MULL
 283     fMaskTrigUSH  = 262144;  // MUHU
 284     fMaskTrigLSH  = 524288;  // MUHL
 285   } else {
 286     // MUON trigger, values by default in the constructor
 287   }
 288
 289   fTriggerType = kTRUE;
 290
 291 }
 292