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