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