PWGLF/FORWARD/GEO/AliAnalysisTaskZDCTreeMaker.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 /////////////////////////////////////////////////////////////
  17 //                                                         //
  18 //      Class to analyze ZDC data                          //
  19 //                                                         //
  20 /////////////////////////////////////////////////////////////
  21
  22 #include <TTree.h>
  23 //#include <TList.h>
  24 #include <TFile.h>
  25 #include <TString.h>
  26 #include <TCanvas.h>
  27
  28 #include "AliAnalysisManager.h"
  29 #include "AliInputEventHandler.h"
  30 #include "AliVEvent.h"
  31 #include "AliESD.h"
  32 #include "AliESDEvent.h"
  33 #include "AliESDHeader.h"
  34 #include "AliESDInputHandler.h"
  35 #include "AliESDZDC.h"
  36 #include "AliMultiplicity.h"
  37 #include "AliAODHandler.h"
  38 #include "AliAODEvent.h"
  39 #include "AliAODHeader.h"
  40 #include "AliAODVertex.h"
  41 #include "AliAODVZERO.h"
  42 #include "AliAODZDC.h"
  43 #include "AliAODMCHeader.h"
  44 #include "AliMCEventHandler.h"
  45 #include "AliMCEvent.h"
  46 #include "AliHeader.h"
  47 #include "AliAODMCParticle.h"
  48 #include "AliAnalysisTaskSE.h"
  49 #include "AliGenEventHeader.h"
  50 #include "AliGenHijingEventHeader.h"
  51 #include "AliPhysicsSelectionTask.h"
  52 #include "AliPhysicsSelection.h"
  53 #include "AliTriggerAnalysis.h"
  54 #include "AliCentrality.h"
  55 #include "AliAnalysisTaskZDCTreeMaker.h"
  56
  57 ClassImp(AliAnalysisTaskZDCTreeMaker)
  58
  59
  60 //________________________________________________________________________
  61 AliAnalysisTaskZDCTreeMaker::AliAnalysisTaskZDCTreeMaker():
  62   AliAnalysisTaskSE(),
  63     fDebug(0),
  64     fAnalysisInput("ESD"),
  65     fIsMCInput(kFALSE),
  66     fUseSpecialOutput(kFALSE),
  67     fOutput(0x0),
  68     fCentralityTree(0x0),
  69     fIsEventSelected(kFALSE),
  70     fIsPileupFromSPD(kFALSE),
  71     fxVertex(0),
  72     fyVertex(0),
  73     fzVertex(0),
  74     fVertexer3d(kFALSE),
  75     fNTracklets(0),
  76     fIsV0ATriggered(0),
  77     fIsV0CTriggered(0),
  78     fMultV0A(0),
  79     fMultV0C(0),
  80     fESDFlag(0),
  81     fZNCEnergy(0),
  82     fZPCEnergy(0),
  83     fZNAEnergy(0),
  84     fZPAEnergy(0),
  85     fZEM1Energy(0),
  86     fZEM2Energy(0),
  87     fCentralityV0M(0),
  88     fCentralityV0A(0),
  89     fCentralityV0C(0),
  90     fCentralityCL1(0),
  91     fCentralityZNA(0),
  92     fCentralityZPA(0),
  93     fCentralityZNC(0),
  94     fCentralityZPC(0)
  95 {
  96    // Default constructor
  97
  98   fNClusters[0]=fNClusters[1]=0;
  99   for(Int_t itow=0; itow<5; itow++){
 100      fZNCtower[itow]=0.;
 101      fZPCtower[itow]=0.;
 102      fZNAtower[itow]=0.;
 103      fZPAtower[itow]=0.;
 104      fZNCtowerLG[itow]=0.;
 105      fZPCtowerLG[itow]=0.;
 106      fZNAtowerLG[itow]=0.;
 107      fZPAtowerLG[itow]=0.;
 108
 109   }
 110   for(Int_t ihit=0; ihit<4; ihit++) {
 111      fTDCZNC[ihit] = 9999.;
 112      fTDCZPC[ihit] = 9999.;
 113      fTDCZNA[ihit] = 9999.;
 114      fTDCZPA[ihit] = 9999;
 115   }
 116
 117 }
 118
 119 //________________________________________________________________________
 120 AliAnalysisTaskZDCTreeMaker::AliAnalysisTaskZDCTreeMaker(const char *name):
 121   AliAnalysisTaskSE(name),
 122     fDebug(0),
 123     fAnalysisInput("ESD"),
 124     fIsMCInput(kFALSE),
 125     fUseSpecialOutput(kFALSE),
 126     fOutput(0x0),
 127     fCentralityTree(0x0),
 128     fIsEventSelected(kFALSE),
 129     fIsPileupFromSPD(kFALSE),
 130     fxVertex(0),
 131     fyVertex(0),
 132     fzVertex(0),
 133     fVertexer3d(kFALSE),
 134     fNTracklets(0),
 135     fIsV0ATriggered(0),
 136     fIsV0CTriggered(0),
 137     fMultV0A(0),
 138     fMultV0C(0),
 139     fESDFlag(0),
 140     fZNCEnergy(0),
 141     fZPCEnergy(0),
 142     fZNAEnergy(0),
 143     fZPAEnergy(0),
 144     fZEM1Energy(0),
 145     fZEM2Energy(0),
 146     fCentralityV0M(0),
 147     fCentralityV0A(0),
 148     fCentralityV0C(0),
 149     fCentralityCL1(0),
 150     fCentralityZNA(0),
 151     fCentralityZPA(0),
 152     fCentralityZNC(0),
 153     fCentralityZPC(0)
 154
 155 {
 156   // Default constructor
 157   fNClusters[0]=fNClusters[1]=0;
 158
 159   for(Int_t itow=0; itow<5; itow++){
 160      fZNCtower[itow]=0.;
 161      fZPCtower[itow]=0.;
 162      fZNAtower[itow]=0.;
 163      fZPAtower[itow]=0.;
 164      fZNCtowerLG[itow]=0.;
 165      fZPCtowerLG[itow]=0.;
 166      fZNAtowerLG[itow]=0.;
 167      fZPAtowerLG[itow]=0.;
 168
 169   }
 170   for(Int_t ihit=0; ihit<4; ihit++) {
 171      fTDCZNC[ihit] = 9999.;
 172      fTDCZPC[ihit] = 9999.;
 173      fTDCZNA[ihit] = 9999.;
 174      fTDCZPA[ihit] = 9999;
 175   }
 176
 177   // Output slot #1 writes into a TList container
 178   DefineOutput(1, TList::Class());
 179   //DefineOutput(1, TTree::Class());
 180
 181 }
 182
 183 //________________________________________________________________________
 184 AliAnalysisTaskZDCTreeMaker::~AliAnalysisTaskZDCTreeMaker()
 185 {
 186   // Destructor
 187   if(fOutput && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()){
 188     delete fOutput; fOutput=0;
 189   }
 190   /*if(fCentralityTree && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()){
 191     delete fCentralityTree; fCentralityTree=0;
 192   }
 193   */
 194 }
 195
 196 //________________________________________________________________________
 197 void AliAnalysisTaskZDCTreeMaker::UserCreateOutputObjects()
 198 {
 199   // Create the output containers
 200   if(fDebug>1) printf("AliAnalysisTaskZDCTreeMaker::UserCreateOutputObjects() \n");
 201
 202   if (fUseSpecialOutput) OpenFile(1);
 203
 204   // Several histograms are more conveniently managed in a TList
 205   fOutput = new TList;
 206   fOutput->SetOwner();
 207   //fOutput->SetName("output");
 208
 209     fCentralityTree = new TTree("fCentralityTree", "Centrality vs. multiplicity tree");
 210     //
 211     fCentralityTree->Branch("trigClass",&fTrigClass,"trigClass/C");
 212     fCentralityTree->Branch("eventSelected",&fIsEventSelected,"eventSelected/O");
 213     fCentralityTree->Branch("pileupSPD",&fIsPileupFromSPD,"pileupSPD/O");
 214     fCentralityTree->Branch("xVertex", &fxVertex,"xVertex/D");
 215     fCentralityTree->Branch("yVertex", &fyVertex,"yVertex/D");
 216     fCentralityTree->Branch("zVertex", &fzVertex,"zVertex/D");
 217     fCentralityTree->Branch("vertexer3d", &fVertexer3d,"vertexer3d/O");
 218     fCentralityTree->Branch("nTracklets", &fNTracklets,"nTracklets/I");
 219     fCentralityTree->Branch("nClusters", fNClusters,"nClusters[2]/I");
 220
 221     fCentralityTree->Branch("isV0ATriggered", &fIsV0ATriggered,"isV0ATriggered/I");
 222     fCentralityTree->Branch("isV0CTriggered", &fIsV0CTriggered,"isV0CTriggered/I");
 223     fCentralityTree->Branch("multV0A", &fMultV0A,"multV0A/F");
 224     fCentralityTree->Branch("multV0C", &fMultV0C,"multV0C/F");
 225
 226     fCentralityTree->Branch("esdFlag", &fESDFlag,"esdFlag/i");
 227     fCentralityTree->Branch("zncEnergy",  &fZNCEnergy,  "zncEnergy/F");
 228     fCentralityTree->Branch("zpcEnergy",  &fZPCEnergy,  "zpcEnergy/F");
 229     fCentralityTree->Branch("znaEnergy",  &fZNAEnergy,  "znaEnergy/F");
 230     fCentralityTree->Branch("zpaEnergy",  &fZPAEnergy,  "zpaEnergy/F");
 231     fCentralityTree->Branch("zem1Energy", &fZEM1Energy, "zem1Energy/F");
 232     fCentralityTree->Branch("zem2Energy", &fZEM2Energy, "zem2Energy/F");
 233
 234     fCentralityTree->Branch("znctower", fZNCtower, "znctower[5]/F");
 235     fCentralityTree->Branch("zpctower", fZPCtower, "zpctower[5]/F");
 236     fCentralityTree->Branch("znatower", fZNAtower, "znatower[5]/F");
 237     fCentralityTree->Branch("zpatower", fZPAtower, "zpatower[5]/F");
 238     fCentralityTree->Branch("znctowerLG", fZNCtowerLG, "znctowerLG[5]/F");
 239     fCentralityTree->Branch("zpctowerLG", fZPCtowerLG, "zpctowerLG[5]/F");
 240     fCentralityTree->Branch("znatowerLG", fZNAtowerLG, "znatowerLG[5]/F");
 241     fCentralityTree->Branch("zpatowerLG", fZPAtowerLG, "zpatowerLG[5]/F");
 242
 243 //    fCentralityTree->Branch("tdc", fTDCvalues, "tdc[32][4]/I");
 244 //    fCentralityTree->Branch("tdcCorr", fTDCcorr, "tdcCorr[32][4]/F");
 245     fCentralityTree->Branch("tdcZNC", fTDCZNC, "tdcZNC[4]/I");
 246     fCentralityTree->Branch("tdcZPC", fTDCZPC, "tdcZPC[4]/I");
 247     fCentralityTree->Branch("tdcZNA", fTDCZNA, "tdcZNA[4]/I");
 248     fCentralityTree->Branch("tdcZPA", fTDCZPA, "tdcZPA[4]/I");
 249
 250     fCentralityTree->Branch("centrV0mult", &fCentralityV0M, "centrV0mult/F");
 251     fCentralityTree->Branch("centrV0Amult", &fCentralityV0A, "centrV0Amult/F");
 252     fCentralityTree->Branch("centrV0Cmult", &fCentralityV0C, "centrV0Cmult/F");
 253     fCentralityTree->Branch("centrSPDclu1", &fCentralityCL1, "centrSPDclu1/F");
 254     fCentralityTree->Branch("centrZNA", &fCentralityZNA, "centrZNA/F");
 255     fCentralityTree->Branch("centrZPA", &fCentralityZPA, "centrZPA/F");
 256     fCentralityTree->Branch("centrZNC", &fCentralityZNA, "centrZNC/F");
 257     fCentralityTree->Branch("centrZPC", &fCentralityZPA, "centrZPC/F");
 258
 259     fOutput->Add(fCentralityTree);
 260     PostData(1, fOutput);
 261
 262   //PostData(1, fCentralityTree);
 263 }
 264
 265 //________________________________________________________________________
 266 void AliAnalysisTaskZDCTreeMaker::UserExec(Option_t */*option*/)
 267 {
 268   // Execute analysis for current event:
 269   if(fDebug>1) printf(" **** AliAnalysisTaskZDCTreeMaker::UserExec() \n");
 270
 271   if (!InputEvent()) {
 272     Printf("ERROR: InputEvent not available");
 273     return;
 274   }
 275
 276   if(fAnalysisInput.CompareTo("ESD")==0){
 277
 278       //printf(" \t ***Analizing ESD ev. %d\n",fNev);
 279
 280       AliESDEvent* esd = dynamic_cast<AliESDEvent*> (InputEvent());
 281       if(!esd) return;
 282
 283       // Select PHYSICS events (type=7, for data)
 284       if(!fIsMCInput && esd->GetEventType()!=7) return;
 285
 286       // ***** Trigger selection
 287       TString triggerClass = esd->GetFiredTriggerClasses();
 288       sprintf(fTrigClass,"%s",triggerClass.Data());
 289
 290       // use response of AliPhysicsSelection
 291       fIsEventSelected = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & AliVEvent::kAnyINT);
 292       fIsPileupFromSPD = esd->IsPileupFromSPD(5);
 293
 294       AliCentrality *centrality = esd->GetCentrality();
 295       fCentralityV0M = centrality->GetCentralityPercentile("V0M");
 296       fCentralityV0A = centrality->GetCentralityPercentile("V0A");
 297       fCentralityV0C = centrality->GetCentralityPercentile("V0C");
 298       fCentralityCL1 = centrality->GetCentralityPercentile("CL1");
 299       fCentralityZNA = centrality->GetCentralityPercentile("ZNA");
 300       fCentralityZPA = centrality->GetCentralityPercentile("ZPA");
 301       fCentralityZNC = centrality->GetCentralityPercentile("ZNC");
 302       fCentralityZPC = centrality->GetCentralityPercentile("ZPC");
 303
 304       const AliESDVertex *vertex = esd->GetPrimaryVertexSPD();
 305       fxVertex = vertex->GetX();
 306       fyVertex = vertex->GetY();
 307       fzVertex = vertex->GetZ();
 308       if(vertex->IsFromVertexer3D()) fVertexer3d = kTRUE;
 309       else fVertexer3d = kFALSE;
 310
 311       const AliMultiplicity *mult = esd->GetMultiplicity();
 312       fNTracklets = mult->GetNumberOfTracklets();
 313
 314       for(Int_t ilay=0; ilay<2; ilay++){
 315         fNClusters[ilay] = mult->GetNumberOfITSClusters(ilay);
 316       }
 317
 318       AliESDVZERO *vzeroAOD = esd->GetVZEROData();
 319       fMultV0A = vzeroAOD->GetMTotV0A();
 320       fMultV0C = vzeroAOD->GetMTotV0C();
 321       //
 322       fIsV0ATriggered = vzeroAOD->GetV0ADecision();
 323       fIsV0CTriggered = vzeroAOD->GetV0CDecision();
 324
 325       AliESDZDC *esdZDC = esd->GetESDZDC();
 326
 327       fESDFlag =  esdZDC->GetESDQuality();
 328
 329       fZNCEnergy = (Float_t) (esdZDC->GetZDCN1Energy());
 330       fZPCEnergy = (Float_t) (esdZDC->GetZDCP1Energy());
 331       fZNAEnergy = (Float_t) (esdZDC->GetZDCN2Energy());
 332       fZPAEnergy = (Float_t) (esdZDC->GetZDCP2Energy());
 333       fZEM1Energy = (Float_t) (esdZDC->GetZDCEMEnergy(0));
 334       fZEM2Energy = (Float_t) (esdZDC->GetZDCEMEnergy(1));
 335
 336       const Double_t * towZNC = esdZDC->GetZN1TowerEnergy();
 337       const Double_t * towZPC = esdZDC->GetZP1TowerEnergy();
 338       const Double_t * towZNA = esdZDC->GetZN2TowerEnergy();
 339       const Double_t * towZPA = esdZDC->GetZP2TowerEnergy();
 340       //
 341       const Double_t * towZNCLG = esdZDC->GetZN1TowerEnergyLR();
 342       const Double_t * towZPCLG = esdZDC->GetZP1TowerEnergyLR();
 343       const Double_t * towZNALG = esdZDC->GetZN2TowerEnergyLR();
 344       const Double_t * towZPALG = esdZDC->GetZP2TowerEnergyLR();
 345       //
 346       for(Int_t it=0; it<5; it++){
 347          fZNCtower[it] = (Float_t) (towZNC[it]);
 348          fZPCtower[it] = (Float_t) (towZPC[it]);
 349          fZNAtower[it] = (Float_t) (towZNA[it]);
 350          fZPAtower[it] = (Float_t) (towZPA[it]);
 351          fZNCtowerLG[it] = (Float_t) (towZNCLG[it]);
 352          fZPCtowerLG[it] = (Float_t) (towZPCLG[it]);
 353          fZNAtowerLG[it] = (Float_t) (towZNALG[it]);
 354          fZPAtowerLG[it] = (Float_t) (towZPALG[it]);
 355       }
 356
 357       for(int itdc=0; itdc<4; itdc++){
 358          fTDCZNC[itdc] = esdZDC->GetZDCTDCData(10, itdc);
 359          fTDCZPC[itdc] = esdZDC->GetZDCTDCData(11, itdc);
 360          fTDCZNA[itdc] = esdZDC->GetZDCTDCData(12, itdc);
 361          fTDCZPA[itdc] = esdZDC->GetZDCTDCData(13, itdc);
 362       }
 363
 364   }
 365   else if(fAnalysisInput.CompareTo("AOD")==0){
 366
 367       printf("\n \t *** Running analysis on AODs\n\n");
 368
 369       AliAODEvent *aod =  dynamic_cast<AliAODEvent*> (InputEvent());
 370       if(!aod) return;
 371
 372       // Select PHYSICS events (type=7, for data)
 373       if(!fIsMCInput && aod->GetEventType()!=7) return;
 374
 375       // use response of AliPhysicsSelection
 376       fIsEventSelected = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & AliVEvent::kCINT5);
 377       fIsPileupFromSPD = aod->IsPileupFromSPD(5);
 378
 379       AliCentrality *centrality = aod->GetCentrality();
 380       fCentralityV0M = centrality->GetCentralityPercentile("V0M");
 381       fCentralityV0A = centrality->GetCentralityPercentile("V0A");
 382       fCentralityV0C = centrality->GetCentralityPercentile("V0C");
 383       fCentralityCL1 = centrality->GetCentralityPercentile("CL1");
 384       fCentralityZNA = centrality->GetCentralityPercentile("ZNA");
 385       fCentralityZPA = centrality->GetCentralityPercentile("ZPA");
 386       fCentralityZNC = centrality->GetCentralityPercentile("ZNC");
 387       fCentralityZPC = centrality->GetCentralityPercentile("ZPC");
 388
 389       // ***** Trigger selection
 390       TString triggerClass = aod->GetFiredTriggerClasses();
 391       sprintf(fTrigClass,"%s",triggerClass.Data());
 392
 393       const AliAODVertex *vertex = aod->GetPrimaryVertexSPD();
 394       fxVertex = vertex->GetX();
 395       fyVertex = vertex->GetY();
 396       fzVertex = vertex->GetZ();
 397
 398       AliAODTracklets *trackl = aod->GetTracklets();
 399       fNTracklets = trackl->GetNumberOfTracklets();
 400
 401       AliAODVZERO *vzeroAOD = aod->GetVZEROData();
 402       fMultV0A = vzeroAOD->GetMTotV0A();
 403       fMultV0C = vzeroAOD->GetMTotV0C();
 404
 405       AliAODZDC *aodZDC = aod->GetZDCData();
 406
 407       fZNCEnergy = (Float_t) (aodZDC->GetZNCEnergy());
 408       fZPCEnergy = (Float_t) (aodZDC->GetZPCEnergy());
 409       fZNAEnergy = (Float_t) (aodZDC->GetZNAEnergy());
 410       fZPAEnergy = (Float_t) (aodZDC->GetZPAEnergy());
 411       fZEM1Energy = (Float_t) (aodZDC->GetZEM1Energy());
 412       fZEM2Energy = (Float_t) (aodZDC->GetZEM2Energy());
 413
 414       const Double_t * towZNC = aodZDC->GetZNCTowerEnergy();
 415       const Double_t * towZPC = aodZDC->GetZPCTowerEnergy();
 416       const Double_t * towZNA = aodZDC->GetZNATowerEnergy();
 417       const Double_t * towZPA = aodZDC->GetZPATowerEnergy();
 418       //
 419       for(Int_t it=0; it<5; it++){
 420          fZNCtower[it] = (Float_t) (towZNC[it]);
 421          fZPCtower[it] = (Float_t) (towZPC[it]);
 422          fZNAtower[it] = (Float_t) (towZNA[it]);
 423          fZPAtower[it] = (Float_t) (towZPA[it]);
 424       }
 425
 426   }
 427
 428   fCentralityTree->Fill();
 429
 430   PostData(1, fOutput);
 431
 432   //PostData(1, fCentralityTree);
 433
 434 }
 435
 436
 437
 438 //________________________________________________________________________
 439 void AliAnalysisTaskZDCTreeMaker::Terminate(Option_t */*option*/)
 440 {
 441   // Terminate analysis
 442   //
 443   printf(" **** AliAnalysisTaskZDCTreeMaker::Terminate() \n");
 444 }