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