Centrality Analysis
authormorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 21 Oct 2010 15:53:10 +0000 (15:53 +0000)
committermorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 21 Oct 2010 15:53:10 +0000 (15:53 +0000)
(Alberica Toia)

ANALYSIS/ANALYSISaliceLinkDef.h
ANALYSIS/AliAnalysisTaskAODCentralityMaker.cxx [new file with mode: 0644]
ANALYSIS/AliAnalysisTaskAODCentralityMaker.h [new file with mode: 0644]
ANALYSIS/libANALYSISalice.pkg
STEER/AODLinkDef.h
STEER/AliAODCentrality.cxx [new file with mode: 0644]
STEER/AliAODCentrality.h [new file with mode: 0644]
STEER/libAOD.pkg

index 1878e3d..782e326 100644 (file)
@@ -33,6 +33,7 @@
 
 #pragma link C++ class AliCollisionNormalization+;
 #pragma link C++ class AliCollisionNormalizationTask+;
+#pragma link C++ class AliAnalysisTaskAODCentralityMaker+;
 
 #ifdef WITHXML
 #pragma link C++ class AliTagAnalysis+;
diff --git a/ANALYSIS/AliAnalysisTaskAODCentralityMaker.cxx b/ANALYSIS/AliAnalysisTaskAODCentralityMaker.cxx
new file mode 100644 (file)
index 0000000..9791367
--- /dev/null
@@ -0,0 +1,455 @@
+/**************************************************************************
+ * Copyright(c) 1998-2008, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/////////////////////////////////////////////////////////////
+//
+// AliAnalysisTaskSE to make AOD centrality
+// Author: Alberica Toia, CERN, Alberica.Toia@cern.ch
+//
+/////////////////////////////////////////////////////////////
+
+#include <TROOT.h>
+#include <TSystem.h>
+
+#include "AliVEvent.h"
+#include "AliESDEvent.h"
+#include "AliAODEvent.h"
+#include "AliAODCentrality.h"
+#include "AliAnalysisTaskSE.h"
+#include "AliAnalysisManager.h"
+#include "AliESD.h"
+#include "AliESDHeader.h"
+#include "AliESDInputHandler.h"
+#include "AliESDZDC.h"
+#include "AliESDFMD.h"
+#include "AliESDVZERO.h"
+#include "AliMultiplicity.h"
+#include "AliAODHandler.h"
+#include "AliAODEvent.h"
+#include "AliAODVertex.h"
+#include "AliAODMCHeader.h"
+#include "AliMCEvent.h"
+#include "AliMCEventHandler.h"
+#include "AliMCParticle.h"
+#include "AliStack.h"
+#include "AliHeader.h"
+#include "AliAODMCParticle.h"
+#include "AliGenEventHeader.h"
+#include "AliGenHijingEventHeader.h"
+#include "AliPhysicsSelectionTask.h"
+#include "AliPhysicsSelection.h"
+#include "AliBackgroundSelection.h"
+#include "AliAnalysisTaskAODCentralityMaker.h"
+
+ClassImp(AliAnalysisTaskAODCentralityMaker)
+
+
+//________________________________________________________________________
+AliAnalysisTaskAODCentralityMaker::AliAnalysisTaskAODCentralityMaker():
+AliAnalysisTaskSE(),
+fAODCentrality(0),
+fDeltaAODFileName("AliAOD.Centrality.root"),
+fIsMCInput        (0),
+fNev              (0),
+fBeamEnergy       (0), 
+fNmyTracks_gen    (0),
+fxVertex          (0),
+fyVertex          (0),
+fzVertex          (0),
+fVertexer3d       (0),
+fbMC             (0),
+fNpartTargMC     (0),
+fNpartProjMC     (0),
+fNNColl          (0),
+fNNwColl         (0),
+fNwNColl         (0),
+fNwNwColl        (0),
+fNTracklets      (0),
+fNSingleClusters  (0),
+fbZDC             (0),
+fNpartZDC         (0),
+fbZDCA            (0),
+fNpartZDCA        (0), 
+fbZDCC            (0),   
+fNpartZDCC        (0),     
+fESDFlag         (0),
+fZNCEnergy       (0),
+fZPCEnergy       (0),
+fZNAEnergy       (0),
+fZPAEnergy       (0),
+fZEM1Energy      (0),
+fZEM2Energy      (0),
+fNTracks         (0),
+fNPmdTracks      (0),
+fMultV0A         (0),
+fMultV0C         (0),
+fMultFMDA        (0),   
+fMultFMDC         (0)
+{
+  // Default constructor
+    
+  for (int i=0;i<6;i++) fNClusters[i]=0;
+  for (int i=0;i<2;i++) fNChips[i]=0;
+  for (int i=0;i<5;i++) fZNCtower[i]=0;
+  for (int i=0;i<5;i++) fZPCtower[i]=0;
+  for (int i=0;i<5;i++) fZNAtower[i]=0;
+  for (int i=0;i<5;i++) fZPAtower[i]=0;
+  for (int i=0;i<2;i++) fCentrZNC[i]=0;
+  for (int i=0;i<2;i++) fCentrZNA[i]=0;
+}
+
+//________________________________________________________________________
+AliAnalysisTaskAODCentralityMaker::AliAnalysisTaskAODCentralityMaker(const char *name):
+AliAnalysisTaskSE(name),
+fAODCentrality(0),
+fDeltaAODFileName("AliAOD.Centrality.root"),
+fIsMCInput        (0),
+fNev              (0),
+fBeamEnergy       (0), 
+fNmyTracks_gen    (0),
+fxVertex          (0),
+fyVertex          (0),
+fzVertex          (0),
+fVertexer3d       (0),
+fbMC             (0),
+fNpartTargMC     (0),
+fNpartProjMC     (0),
+fNNColl          (0),
+fNNwColl         (0),
+fNwNColl         (0),
+fNwNwColl        (0),
+fNTracklets      (0),
+fNSingleClusters  (0),
+fbZDC             (0),
+fNpartZDC         (0),
+fbZDCA            (0),
+fNpartZDCA        (0), 
+fbZDCC            (0),   
+fNpartZDCC        (0),     
+fESDFlag         (0),
+fZNCEnergy       (0),
+fZPCEnergy       (0),
+fZNAEnergy       (0),
+fZPAEnergy       (0),
+fZEM1Energy      (0),
+fZEM2Energy      (0),
+fNTracks         (0),
+fNPmdTracks      (0),
+fMultV0A         (0),
+fMultV0C         (0),
+fMultFMDA        (0),   
+fMultFMDC         (0)
+{
+  // Standard constructor
+    
+  for (int i=0;i<6;i++) fNClusters[i]=0;
+  for (int i=0;i<2;i++) fNChips[i]=0;
+  for (int i=0;i<5;i++) fZNCtower[i]=0;
+  for (int i=0;i<5;i++) fZPCtower[i]=0;
+  for (int i=0;i<5;i++) fZNAtower[i]=0;
+  for (int i=0;i<5;i++) fZPAtower[i]=0;
+  for (int i=0;i<2;i++) fCentrZNC[i]=0;
+  for (int i=0;i<2;i++) fCentrZNA[i]=0;
+}
+
+
+//________________________________________________________________________
+AliAnalysisTaskAODCentralityMaker::~AliAnalysisTaskAODCentralityMaker()
+{
+  // Destructor
+}  
+
+//________________________________________________________________________
+void AliAnalysisTaskAODCentralityMaker::Init()
+{
+  // Initialization
+  if(fDebug > 1) printf("AnalysisTaskAODCentralityMaker::Init() \n");
+  AliAnalysisManager::GetAnalysisManager()->RegisterExtraFile(fDeltaAODFileName.Data());
+
+  return;
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskAODCentralityMaker::UserCreateOutputObjects()
+{
+  
+  // Create the output container
+  //
+  if(fDebug > 1) printf("AnalysisTaskAODCentralityMaker::UserCreateOutPutData() \n");
+  // Support both the case when the AOD + deltaAOD are produced in an ESD
+  // analysis or if the deltaAOD is produced on an analysis on AOD's. (A.G. 27/04/09)
+  if(!AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()) {
+    Fatal("UserCreateOutputObjects", "This task needs an AOD handler");
+    return;
+  }   
+  TString filename = fDeltaAODFileName;
+  // When running on standard AOD to produce deltas, IsStandardAOD is never set,
+  // If AODEvent is NULL, new branches have to be added to the new file(s) (A.G. 15/01/10)
+  if(!IsStandardAOD() && AODEvent()) filename = "";
+
+  fAODCentrality = new AliAODCentrality();
+  fAODCentrality->SetName("AODCentrality");
+  AddAODBranch("AliAODCentrality", &fAODCentrality, filename);
+  
+  return;
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskAODCentralityMaker::UserExec(Option_t */*option*/)
+{
+  AliVEvent* event = InputEvent();
+  AliESDEvent* esd = dynamic_cast<AliESDEvent*>(event);
+
+  fBeamEnergy = esd->GetBeamEnergy();
+  fNTracks    = event->GetNumberOfTracks();     
+  fNPmdTracks = esd->GetNumberOfPmdTracks();     
+    
+  // ***** V0 info
+  AliESDVZERO* esdV0 = esd->GetVZEROData();
+  fMultV0A=esdV0->GetMTotV0A();
+  fMultV0C=esdV0->GetMTotV0C();
+    
+  // ***** Trigger selection
+  TString triggerClass = esd->GetFiredTriggerClasses();
+  sprintf(fTrigClass,"%s",triggerClass.Data());
+  
+  // ***** vertex info
+  const AliESDVertex *vertex = esd->GetPrimaryVertexSPD();
+  fxVertex = vertex->GetX();
+  fyVertex = vertex->GetY();
+  fzVertex = vertex->GetZ();
+  if(vertex->IsFromVertexer3D()) fVertexer3d = kTRUE;
+  else fVertexer3d = kFALSE;
+  Double_t vertex3[3];
+  vertex->GetXYZ(vertex3);
+  
+  // ***** CB info (tracklets, clusters, chips)
+  const AliMultiplicity *mult = esd->GetMultiplicity();
+  fNTracklets = mult->GetNumberOfTracklets();
+  
+  for(Int_t ilay=0; ilay<6; ilay++){
+    fNClusters[ilay] = mult->GetNumberOfITSClusters(ilay);
+  }
+  fNSingleClusters = mult->GetNumberOfSingleClusters();
+  
+  for(Int_t ilay=0; ilay<2; ilay++){
+    fNChips[ilay] = mult->GetNumberOfFiredChips(ilay);
+  }
+  
+  // ***** FMD info
+  AliESDFMD *fmd = esd->GetFMDData();
+  Float_t totalMultA = 0;
+  Float_t totalMultC = 0;
+  const Float_t fFMDLowCut = 0.4;
+  
+  for(UShort_t det=1;det<=3;det++) {
+    Int_t nRings = (det==1 ? 1 : 2);
+    for (UShort_t ir = 0; ir < nRings; ir++) {   
+      Char_t   ring = (ir == 0 ? 'I' : 'O');
+      UShort_t nsec = (ir == 0 ? 20  : 40);
+      UShort_t nstr = (ir == 0 ? 512 : 256);
+      for(UShort_t sec =0; sec < nsec;  sec++)  {
+       for(UShort_t strip = 0; strip < nstr; strip++) {
+         
+         Float_t FMDmult = fmd->Multiplicity(det,ring,sec,strip);
+         if(FMDmult == 0 || FMDmult == AliESDFMD::kInvalidMult) continue;
+         
+         Float_t nParticles=0;
+         
+         if(FMDmult > fFMDLowCut) {
+           nParticles = 1.;
+         }
+         
+         if (det<3) totalMultA = totalMultA + nParticles;
+         else totalMultC = totalMultC + nParticles;
+         
+       }
+      }
+    }
+  }
+  fMultFMDA = totalMultA;
+  fMultFMDC = totalMultC;
+  
+  // ***** ZDC info
+  AliESDZDC *esdZDC = esd->GetESDZDC();
+  fESDFlag =  esdZDC->GetESDQuality();   
+  
+  fZNCEnergy = (Float_t) (esdZDC->GetZDCN1Energy());
+  fZPCEnergy = (Float_t) (esdZDC->GetZDCP1Energy());
+  fZNAEnergy = (Float_t) (esdZDC->GetZDCN2Energy());
+  fZPAEnergy = (Float_t) (esdZDC->GetZDCP2Energy());
+  fZEM1Energy = (Float_t) (esdZDC->GetZDCEMEnergy(0));
+  fZEM2Energy = (Float_t) (esdZDC->GetZDCEMEnergy(1));
+  
+  fbZDC = esdZDC->GetImpactParameter();
+  fNpartZDC = esdZDC->GetZDCParticipants();
+  fbZDCA = esdZDC->GetImpactParamSideA();
+  fNpartZDCA = esdZDC->GetZDCPartSideA();
+  fbZDCC = esdZDC->GetImpactParamSideC();
+  fNpartZDCC = esdZDC->GetZDCPartSideC();
+  
+  const Double_t * towZNC = esdZDC->GetZN1TowerEnergy();
+  const Double_t * towZPC = esdZDC->GetZP1TowerEnergy();
+  const Double_t * towZNA = esdZDC->GetZN2TowerEnergy();
+  const Double_t * towZPA = esdZDC->GetZP2TowerEnergy();
+  //
+  for(Int_t it=0; it<5; it++){
+    fZNCtower[it] = (Float_t) (towZNC[it]);
+    fZPCtower[it] = (Float_t) (towZPC[it]);
+    fZNAtower[it] = (Float_t) (towZNA[it]); 
+    fZPAtower[it] = (Float_t) (towZPA[it]);  
+  }
+  
+  Double_t xyZNC[2]={-99.,-99.}, xyZNA[2]={-99.,-99.};
+  esdZDC->GetZNCentroidInPbPb(fBeamEnergy, xyZNC, xyZNA);
+  for(Int_t it=0; it<2; it++){
+    fCentrZNC[it] = xyZNC[it];
+    fCentrZNA[it] = xyZNA[it];
+  }
+
+  // ***** MC info
+  if(fIsMCInput){
+    
+    AliMCEvent* mcEvent = MCEvent();
+    if (!mcEvent) {
+      printf("   Could not retrieve MC event!!!\n");
+      return;
+    }
+    
+    fNmyTracks_gen = 0;
+    AliStack *stack = 0x0; // needed for MC studies
+    stack = MCEvent()->Stack();
+    for (Int_t iTrack = 0; iTrack < MCEvent()->GetNumberOfTracks(); iTrack++) {
+      //get properties of mc particle
+      AliMCParticle* mcP = (AliMCParticle*) MCEvent()->GetTrack(iTrack);
+      // Primaries only
+      if (!(stack->IsPhysicalPrimary(mcP->Label()))) continue;
+      //charged tracks only
+      if (mcP->Particle()->GetPDG()->Charge() == 0) continue;
+      //same cuts as on ESDtracks
+      //         if(TMath::Abs(mcP->Eta())>0.9)continue;
+      //         if(mcP->Pt()<0.2)continue;
+      //         if(mcP->Pt()>200)continue;
+      
+      fNmyTracks_gen ++;
+    } 
+    
+    AliGenEventHeader* genHeader = mcEvent->GenEventHeader();
+    if(!genHeader){
+      printf("  Event generator header not available!!!\n");
+      return;
+    }
+       
+    if(genHeader->InheritsFrom(AliGenHijingEventHeader::Class())){
+      fbMC = ((AliGenHijingEventHeader*) genHeader)->ImpactParameter();
+      Int_t specNeutronProj = ((AliGenHijingEventHeader*) genHeader)->ProjSpectatorsn();
+      Int_t specProtonProj  = ((AliGenHijingEventHeader*) genHeader)->ProjSpectatorsp();
+      Int_t specNeutronTarg = ((AliGenHijingEventHeader*) genHeader)->TargSpectatorsn();
+      Int_t specProtonTarg  = ((AliGenHijingEventHeader*) genHeader)->TargSpectatorsp();
+      fNpartTargMC = Int_t (208.-(specNeutronTarg+specProtonTarg));
+      fNpartProjMC = Int_t (208.-(specNeutronProj+specProtonProj));
+      fNNColl   = ((AliGenHijingEventHeader*) genHeader)->NN();
+      fNNwColl  = ((AliGenHijingEventHeader*) genHeader)->NNw();
+      fNwNColl  = ((AliGenHijingEventHeader*) genHeader)->NwN();
+      fNwNwColl = ((AliGenHijingEventHeader*) genHeader)->NwNw();
+    }  
+    
+  }
+  
+  fAODCentrality->SetTrigClass         (fTrigClass[100]);
+  fAODCentrality->SetxVertex          (fxVertex       );
+  fAODCentrality->SetyVertex          (fyVertex       );
+  fAODCentrality->SetzVertex          (fzVertex       );
+  fAODCentrality->SetVertexer3d        (fVertexer3d    );
+  fAODCentrality->SetbMC               (fbMC);
+  fAODCentrality->SetNpartTargMC       (fNpartTargMC);
+  fAODCentrality->SetNpartProjMC       (fNpartProjMC);
+  fAODCentrality->SetNNColl            (fNNColl);
+  fAODCentrality->SetNNwColl           (fNNwColl);
+  fAODCentrality->SetNwNColl           (fNwNColl);
+  fAODCentrality->SetNwNwColl          (fNwNwColl);
+  fAODCentrality->SetNTracklets        (fNTracklets);
+  fAODCentrality->SetNSingleClusters   (fNSingleClusters);
+  fAODCentrality->SetNClusters         (
+                                          fNClusters[0],
+                                          fNClusters[1],
+                                          fNClusters[2],
+                                          fNClusters[3],
+                                          fNClusters[4],
+                                          fNClusters[5]);
+  fAODCentrality->SetNChips            (
+                                          fNChips[0],
+                                          fNChips[1]);
+  fAODCentrality->SetbZDC              (fbZDC);
+  fAODCentrality->SetNpartZDC          (fNpartZDC);
+  fAODCentrality->SetbZDCA             (fbZDCA);
+  fAODCentrality->SetNpartZDCA         (fNpartZDCA);
+  fAODCentrality->SetbZDCC             (fbZDCC);
+  fAODCentrality->SetNpartZDCC         (fNpartZDCC);
+  fAODCentrality->SetESDFlag     (fESDFlag);
+  fAODCentrality->SetZNCEnergy           (fZNCEnergy);
+  fAODCentrality->SetZPCEnergy   (fZPCEnergy);
+  fAODCentrality->SetZNAEnergy   (fZNAEnergy);
+  fAODCentrality->SetZPAEnergy   (fZPAEnergy);
+  fAODCentrality->SetZEM1Energy          (fZEM1Energy);
+  fAODCentrality->SetZEM2Energy          (fZEM2Energy);
+  fAODCentrality->SetZNCtower          (
+                                          fZNCtower[0],
+                                          fZNCtower[1],
+                                          fZNCtower[2],
+                                          fZNCtower[3],
+                                          fZNCtower[4]);
+  fAODCentrality->SetZPCtower          (
+                                        fZPCtower[0],
+                                        fZPCtower[1],
+                                        fZPCtower[2],
+                                        fZPCtower[3],
+                                        fZPCtower[4]);
+  fAODCentrality-> SetZNAtower          (
+                            fZNAtower[0],  
+                            fZNAtower[1], 
+                            fZNAtower[2],  
+                            fZNAtower[3],  
+                            fZNAtower[4]); 
+  fAODCentrality-> SetZPAtower          (
+                                           fZPAtower[0], 
+                                           fZPAtower[1], 
+                                           fZPAtower[2], 
+                                           fZPAtower[3],
+                                           fZPAtower[4]);
+  fAODCentrality-> SetCentrZNC          (
+                                           fCentrZNC[0],
+                                           fCentrZNC[1]);
+  fAODCentrality-> SetCentrZNA          (
+                                           fCentrZNA[0],
+                                           fCentrZNA[1]);
+  fAODCentrality-> SetNTracks           (fNTracks);
+  fAODCentrality-> SetNPmdTracks        (fNPmdTracks);
+  fAODCentrality-> SetMultV0A           (fMultV0A);
+  fAODCentrality-> SetMultV0C           (fMultV0C);
+  fAODCentrality-> SetMultFMDA          (fMultFMDA);
+  fAODCentrality-> SetMultFMDC          (fMultFMDC);
+
+  return;
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskAODCentralityMaker::Terminate(Option_t */*option*/)
+{
+  // Terminate analysis
+  //
+  if(fDebug > 1) printf("AnalysisTaskAODCentralityMaker: Terminate() \n");
+}
diff --git a/ANALYSIS/AliAnalysisTaskAODCentralityMaker.h b/ANALYSIS/AliAnalysisTaskAODCentralityMaker.h
new file mode 100644 (file)
index 0000000..feaa70f
--- /dev/null
@@ -0,0 +1,100 @@
+#ifndef ALIANALYSISTASKAODCENTRALITYMAKER_H
+#define ALIANALYSISTASKAODCENTRALITYMAKER_H
+
+/* Copyright(c) 1998-2008, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+//*************************************************************************
+// Class AliAnalysisTaskAODCentralityMaker
+// AliAnalysisTaskSE to make AOD centrality
+// Author: Alberica Toia, CERN, Alberica.Toia@cern.ch
+//*************************************************************************
+
+#include "AliAnalysisTaskSE.h"
+class AliAODCentrality;
+
+class AliAnalysisTaskAODCentralityMaker : public AliAnalysisTaskSE
+{
+ public:
+
+  AliAnalysisTaskAODCentralityMaker();
+  AliAnalysisTaskAODCentralityMaker(const char *name);
+  virtual ~AliAnalysisTaskAODCentralityMaker();
+
+  // Implementation of interface methods
+  virtual void UserCreateOutputObjects();
+  virtual void Init();
+  virtual void LocalInit() {Init();}
+  virtual void UserExec(Option_t *option);
+  virtual void Terminate(Option_t *option);
+  void SetDeltaAODFileName(const char* name) {fDeltaAODFileName=name;}
+  const char* GetDeltaAODFileName() const {return fDeltaAODFileName.Data();}
+
+  void SetMCInput() {fIsMCInput = kTRUE;}
+
+ private:
+
+  AliAODCentrality *fAODCentrality;
+  AliAnalysisTaskAODCentralityMaker(const AliAnalysisTaskAODCentralityMaker &source);
+  AliAnalysisTaskAODCentralityMaker& operator=(const AliAnalysisTaskAODCentralityMaker& source); 
+  
+  TString       fDeltaAODFileName;     // Name of output file
+
+  Bool_t   fIsMCInput;          // true when input is MC
+
+  Int_t    fNev;               //  event counter
+  Float_t  fBeamEnergy;                //  beam energy
+  Int_t    fNmyTracks_gen;      //  no. generated primary charged tracks 
+  char     fTrigClass[100];    //  fired trigger classes
+  //
+  Double_t fxVertex;           //  X vertex from ITS
+  Double_t fyVertex;           //  Y vertex from ITS
+  Double_t fzVertex;           //  Z vertex from ITS
+  Bool_t   fVertexer3d;                //  Is vertex from 3d vertexer?
+  //
+  Double_t fbMC;               // impact parameter from MC
+  Int_t    fNpartTargMC;       // no. of participants for target nucleus from MC
+  Int_t    fNpartProjMC;       // no. of participants for project nucleus from MC
+  Int_t    fNNColl;             // Number of N-N collisions
+  Int_t    fNNwColl;            // Number of N-Nwounded collisions
+  Int_t    fNwNColl;            // Number of Nwounded-N collisons
+  Int_t    fNwNwColl;           // Number of Nwounded-Nwounded collisions
+  //
+  Int_t    fNTracklets;                //  no. tracklets
+  Int_t    fNSingleClusters;   //  no. single clusters
+  Int_t    fNClusters[6];      //  no. clusters on 6 ITS layers
+  Int_t    fNChips[2];         //  no. chips on 2 SPD layers
+  //
+  Double_t fbZDC;              // impact parameter from ZDC reco
+  Int_t    fNpartZDC;           // no. of participants from ZDC reco
+  Double_t fbZDCA;             // impact parameter from ZDC reco side A
+  Int_t    fNpartZDCA;          // no. of part. from ZDC reco side A
+  Double_t fbZDCC;             // impact parameter from ZDC reco side C
+  Int_t    fNpartZDCC;          // no. of part. from ZDC reco side C
+  //
+  UInt_t   fESDFlag;           //  ZDC ESD flags
+  Float_t  fZNCEnergy;         //  ZNC Energy
+  Float_t  fZPCEnergy;         //  ZPC Energy
+  Float_t  fZNAEnergy;         //  ZNA Energy
+  Float_t  fZPAEnergy;         //  ZPA Energy
+  Float_t  fZEM1Energy;                //  ZEM1 Energy
+  Float_t  fZEM2Energy;                //  ZEM2 Energy
+  Float_t  fZNCtower[5];       //  ZNC 5 tower signals
+  Float_t  fZPCtower[5];       //  ZPC 5 tower signals
+  Float_t  fZNAtower[5];       //  ZNA 5 tower signals
+  Float_t  fZPAtower[5];       //  ZPA 5 tower signals
+  Float_t  fCentrZNC[2];       //  centroid over ZNC
+  Float_t  fCentrZNA[2];       //  centroid over ZNA
+  
+  Int_t    fNTracks;           //  no. tracks
+  Int_t    fNPmdTracks;                //  no. PMD tracks
+  Double_t fMultV0A;           //  multiplicity from V0 reco side A
+  Double_t fMultV0C;           //  multiplicity from V0 reco side C
+  Float_t  fMultFMDA;      //  multiplicity from FMD on detector A
+  Float_t  fMultFMDC;      //  multiplicity from FMD on detector C
+
+  ClassDef(AliAnalysisTaskAODCentralityMaker,1); // AliAnalysisTaskSE to make AOD centrality
+};
+
+#endif
+
index e7af22f..34e60af 100644 (file)
@@ -10,7 +10,8 @@ SRCS =        AliAnalysisTaskSE.cxx AliAnalysisTaskME.cxx \
         AliPhysicsSelection.cxx AliBackgroundSelection.cxx \
         AliPhysicsSelectionTask.cxx \
         AliAnalysisFilter.cxx AliAnalysisCuts.cxx \
-       AliCollisionNormalization.cxx AliCollisionNormalizationTask.cxx
+       AliCollisionNormalization.cxx AliCollisionNormalizationTask.cxx \
+       AliAnalysisTaskAODCentralityMaker.cxx
 
 
 ifeq (yes,$(CHECKALIEN))
index 3844da8..ccf371e 100644 (file)
@@ -45,6 +45,7 @@
 #pragma link C++ class AliAODPWG4ParticleCorrelation+;
 #pragma link C++ class AliAODDimuon+;
 #pragma link C++ class AliAODpidUtil+;
+#pragma link C++ class AliAODCentrality+;
 
 
 #endif
diff --git a/STEER/AliAODCentrality.cxx b/STEER/AliAODCentrality.cxx
new file mode 100644 (file)
index 0000000..160385c
--- /dev/null
@@ -0,0 +1,148 @@
+/**************************************************************************
+ * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+
+//-------------------------------------------------------------------------
+//     AOD centrality class
+//     Author: Alberica Toia, CERN, Alberica.Toia@cern.ch
+//-------------------------------------------------------------------------
+
+#include "AliAODCentrality.h"
+#include "AliAODTrack.h"
+#include "AliLog.h"
+
+ClassImp(AliAODCentrality)
+
+
+//______________________________________________________________________________
+
+//______________________________________________________________________________
+AliAODCentrality::AliAODCentrality(): TNamed(),
+fxVertex          (0),
+fyVertex          (0),
+fzVertex          (0),
+fVertexer3d       (0),
+fbMC             (0),
+fNpartTargMC     (0),
+fNpartProjMC     (0),
+fNNColl          (0),
+fNNwColl         (0),
+fNwNColl         (0),
+fNwNwColl        (0),
+fNTracklets      (0),
+fNSingleClusters  (0),
+fbZDC             (0),
+fNpartZDC         (0),
+fbZDCA            (0),
+fNpartZDCA        (0), 
+fbZDCC            (0),   
+fNpartZDCC        (0),     
+fESDFlag         (0),
+fZNCEnergy       (0),
+fZPCEnergy       (0),
+fZNAEnergy       (0),
+fZPAEnergy       (0),
+fZEM1Energy      (0),
+fZEM2Energy      (0),
+fNTracks         (0),
+fNPmdTracks      (0),
+fMultV0A         (0),
+fMultV0C         (0),
+fMultFMDA        (0),   
+fMultFMDC         (0)
+
+{
+  // constructor
+  for (int i=0;i<6;i++) fNClusters[i]=0;
+  for (int i=0;i<2;i++) fNChips[i]=0;
+  for (int i=0;i<5;i++) fZNCtower[i]=0;
+  for (int i=0;i<5;i++) fZPCtower[i]=0;
+  for (int i=0;i<5;i++) fZNAtower[i]=0;
+  for (int i=0;i<5;i++) fZPAtower[i]=0;
+  for (int i=0;i<2;i++) fCentrZNC[i]=0;
+  for (int i=0;i<2;i++) fCentrZNA[i]=0;
+}
+
+//______________________________________________________________________________
+AliAODCentrality::~AliAODCentrality() 
+{
+  // Destructor
+}
+
+//______________________________________________________________________________
+AliAODCentrality::AliAODCentrality(const AliAODCentrality& cnt) : TNamed(cnt),
+fxVertex          (cnt.fxVertex   ),
+fyVertex          (cnt.fyVertex   ),
+fzVertex          (cnt.fzVertex   ),
+fVertexer3d       (cnt.fVertexer3d),
+fbMC             (cnt.fbMC ),
+fNpartTargMC     (cnt.fNpartTargMC),
+fNpartProjMC     (cnt.fNpartProjMC),
+fNNColl          (cnt.fNNColl     ),
+fNNwColl         (cnt.fNNwColl    ),
+fNwNColl         (cnt.fNwNColl    ),
+fNwNwColl        (cnt.fNwNwColl   ),
+fNTracklets      (cnt.fNTracklets ),
+fNSingleClusters  (cnt.fNSingleClusters),
+fbZDC             (cnt.fbZDC           ),
+fNpartZDC         (cnt.fNpartZDC       ),
+fbZDCA            (cnt.fbZDCA          ),
+fNpartZDCA        (cnt.fNpartZDCA     ), 
+fbZDCC            (cnt.fbZDCC       ),   
+fNpartZDCC        (cnt.fNpartZDCC ),     
+fESDFlag         (cnt.fESDFlag ),
+fZNCEnergy       (cnt.fZNCEnergy),
+fZPCEnergy       (cnt.fZPCEnergy),
+fZNAEnergy       (cnt.fZNAEnergy),
+fZPAEnergy       (cnt.fZPAEnergy),
+fZEM1Energy      (cnt.fZEM1Energy),
+fZEM2Energy      (cnt.fZEM2Energy),
+fNTracks         (cnt.fNTracks    ),
+fNPmdTracks      (cnt.fNPmdTracks ),
+fMultV0A         (cnt.fMultV0A    ),
+fMultV0C         (cnt.fMultV0C    ),
+fMultFMDA        (cnt.fMultFMDA ),   
+fMultFMDC         (cnt.fMultFMDC )
+{
+  // Copy constructor.
+}
+
+//______________________________________________________________________________
+AliAODCentrality& AliAODCentrality::operator=(const AliAODCentrality& cnt) 
+{
+  // Assignment operator
+  if (this != &cnt) {
+
+    // name and type
+    AliAODCentrality::operator=(cnt);
+  }
+  
+  return *this;
+}
+
+//______________________________________________________________________________
+void AliAODCentrality::Print(Option_t* /*option*/) const 
+{
+  // Print information of some data members
+
+  printf("Centrality information:\n");
+  printf("fNTracks    = %d\n",   fNTracks    );
+  printf("fNTracklets = %d\n",   fNTracklets );
+  printf("fMultV0A    = %e\n",   fMultV0A    );
+  printf("fMultV0C    = %e\n",   fMultV0C    );
+  printf("fMultFMDA   = %e\n",           fMultFMDA   );   
+  printf("fMultFMDC   = %e\n",    fMultFMDC   );
+}
+
diff --git a/STEER/AliAODCentrality.h b/STEER/AliAODCentrality.h
new file mode 100644 (file)
index 0000000..60f4be3
--- /dev/null
@@ -0,0 +1,229 @@
+#ifndef AliAODCentrality_H
+#define AliAODCentrality_H
+/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+
+//-------------------------------------------------------------------------
+//     AOD centrality class
+//     Author: Alberica Toia, CERN, Alberica.Toia@cern.ch
+//-------------------------------------------------------------------------
+
+#include <TNamed.h>
+
+class AliAODCentrality : public TNamed {
+  
+ public :
+  
+  AliAODCentrality();
+  virtual ~AliAODCentrality();
+  AliAODCentrality(const AliAODCentrality& cnt); 
+  AliAODCentrality& operator=(const AliAODCentrality& cnt);
+  
+  void SetTrigClass         (char     x) {fTrigClass[100] = x; }
+  void SetxVertex          (Double_t x) {fxVertex       = x; }
+  void SetyVertex          (Double_t x) {fyVertex       = x; }
+  void SetzVertex          (Double_t x) {fzVertex       = x; }
+  void SetVertexer3d        (Bool_t   x) {fVertexer3d   = x; }
+  void SetbMC               (Double_t x) {fbMC = x; } 
+  void SetNpartTargMC       (Int_t    x) {fNpartTargMC = x; }
+  void SetNpartProjMC       (Int_t    x) {fNpartProjMC = x; }
+  void SetNNColl            (Int_t    x) {fNNColl = x; }     
+  void SetNNwColl           (Int_t    x) {fNNwColl = x; }    
+  void SetNwNColl           (Int_t    x) {fNwNColl = x; }    
+  void SetNwNwColl          (Int_t    x) {fNwNwColl = x; }   
+  void SetNTracklets        (Int_t    x) {fNTracklets = x; } 
+  void SetNSingleClusters   (Int_t    x) {fNSingleClusters = x; }
+  void SetNClusters         (Int_t x0, Int_t x1, Int_t x2, Int_t x3, Int_t x4, Int_t x5) {
+    fNClusters[0] = x0; 
+    fNClusters[1] = x1; 
+    fNClusters[2] = x2; 
+    fNClusters[3] = x3; 
+    fNClusters[4] = x4; 
+    fNClusters[5] = x5; 
+  }   
+  void SetNChips            (Int_t x0, Int_t x1) {
+    fNChips[0] = x0;       
+    fNChips[1] = x1; 
+  }      
+  void SetbZDC              (Double_t x) {fbZDC = x; }           
+  void SetNpartZDC          (Int_t    x) {fNpartZDC = x; }       
+  void SetbZDCA             (Double_t x) {fbZDCA = x; }          
+  void SetNpartZDCA         (Int_t    x) {fNpartZDCA = x; }      
+  void SetbZDCC             (Double_t x) {fbZDCC = x; }          
+  void SetNpartZDCC         (Int_t    x) {fNpartZDCC = x; }      
+  void SetESDFlag        (UInt_t   x) {fESDFlag = x; } 
+  void SetZNCEnergy      (Float_t  x) {fZNCEnergy = x; }
+  void SetZPCEnergy      (Float_t  x) {fZPCEnergy = x; }
+  void SetZNAEnergy      (Float_t  x) {fZNAEnergy = x; }
+  void SetZPAEnergy      (Float_t  x) {fZPAEnergy = x; }
+  void SetZEM1Energy     (Float_t  x) {fZEM1Energy = x; }
+  void SetZEM2Energy     (Float_t  x) {fZEM2Energy = x; }
+  void SetZNCtower          (Float_t x0, Float_t x1, Float_t x2, Float_t x3, Float_t x4) {
+    fZNCtower[0] = x0; 
+    fZNCtower[1] = x1; 
+    fZNCtower[2] = x2; 
+    fZNCtower[3] = x3; 
+    fZNCtower[4] = x4; 
+  }   
+  void SetZPCtower          (Float_t x0, Float_t x1, Float_t x2, Float_t x3, Float_t x4) {
+    fZPCtower[0] = x0; 
+    fZPCtower[1] = x1; 
+    fZPCtower[2] = x2; 
+    fZPCtower[3] = x3; 
+    fZPCtower[4] = x4; 
+  }   
+  void SetZNAtower          (Float_t x0, Float_t x1, Float_t x2, Float_t x3, Float_t x4) {
+    fZNAtower[0] = x0; 
+    fZNAtower[1] = x1; 
+    fZNAtower[2] = x2; 
+    fZNAtower[3] = x3; 
+    fZNAtower[4] = x4; 
+  }   
+  void SetZPAtower          (Float_t x0, Float_t x1, Float_t x2, Float_t x3, Float_t x4) {
+    fZPAtower[0] = x0; 
+    fZPAtower[1] = x1; 
+    fZPAtower[2] = x2; 
+    fZPAtower[3] = x3; 
+    fZPAtower[4] = x4; 
+  }   
+  void SetCentrZNC          (Float_t x0, Float_t x1) {
+    fCentrZNC[0] = x0; 
+    fCentrZNC[1] = x1; 
+  }   
+  void SetCentrZNA          (Float_t x0, Float_t x1) {
+    fCentrZNA[0] = x0; 
+    fCentrZNA[1] = x1; 
+  }   
+  void SetNTracks           (Int_t    x) {fNTracks = x; }    
+  void SetNPmdTracks        (Int_t    x) {fNPmdTracks = x; } 
+  void SetMultV0A           (Double_t x) {fMultV0A = x; }    
+  void SetMultV0C           (Double_t x) {fMultV0C = x; }    
+  void SetMultFMDA          (Float_t  x) {fMultFMDA = x; }    
+  void SetMultFMDC          (Float_t  x) {fMultFMDC = x; }
+  
+  char       GetTrigClass         () const {return fTrigClass[100] ; }
+  Double_t   GetxVertex                  () const {return fxVertex      ; }
+  Double_t   GetyVertex                  () const {return fyVertex      ; }
+  Double_t   GetzVertex                  () const {return fzVertex      ; }
+  Bool_t     GetVertexer3d        () const {return fVertexer3d  ; }
+  Double_t   GetbMC               () const {return  fbMC         ;}               
+  Int_t      GetNpartTargMC       () const {return  fNpartTargMC  ;}               
+  Int_t      GetNpartProjMC       () const {return  fNpartProjMC  ;}               
+  Int_t      GetNNColl            () const {return  fNNColl       ;}               
+  Int_t      GetNNwColl           () const {return  fNNwColl      ;}               
+  Int_t      GetNwNColl           () const {return  fNwNColl      ;}               
+  Int_t      GetNwNwColl          () const {return  fNwNwColl     ;}               
+  Int_t      GetNTracklets        () const {return  fNTracklets   ;}               
+  Int_t      GetNSingleClusters   () const {return  fNSingleClusters;}               
+  Int_t      GetNClusters0        () const {return  fNClusters[0];}               
+  Int_t      GetNClusters1        () const {return  fNClusters[1];}               
+  Int_t      GetNClusters2        () const {return  fNClusters[2];}               
+  Int_t      GetNClusters3        () const {return  fNClusters[3];}               
+  Int_t      GetNClusters4        () const {return  fNClusters[4];}               
+  Int_t      GetNClusters5        () const {return  fNClusters[5];}              
+  Int_t      GetNChip0            () const {return  fNChips[0];}               
+  Int_t      GetNChip1            () const {return  fNChips[1];}               
+  Double_t   GetbZDC              () const {return  fbZDC         ;}               
+  Int_t      GetNpartZDC          () const {return  fNpartZDC     ;}               
+  Double_t   GetbZDCA             () const {return  fbZDCA        ;}               
+  Int_t      GetNpartZDCA         () const {return  fNpartZDCA    ;}               
+  Double_t   GetbZDCC             () const {return  fbZDCC        ;}               
+  Int_t      GetNpartZDCC         () const {return  fNpartZDCC    ;}               
+  UInt_t     GetESDFlag          () const {return  fESDFlag      ;}               
+  Float_t    GetZNCEnergy         () const {return  fZNCEnergy    ;}               
+  Float_t    GetZPCEnergy        () const {return  fZPCEnergy    ;}               
+  Float_t    GetZNAEnergy        () const {return  fZNAEnergy    ;}               
+  Float_t    GetZPAEnergy        () const {return  fZPAEnergy    ;}               
+  Float_t    GetZEM1Energy        () const {return  fZEM1Energy   ;}               
+  Float_t    GetZEM2Energy       () const {return  fZEM2Energy   ;}               
+  Float_t    GetZNCtower0         () const {return  fZNCtower[0]  ;}               
+  Float_t    GetZNCtower1         () const {return  fZNCtower[1]  ;}               
+  Float_t    GetZNCtower2         () const {return  fZNCtower[2]  ;}               
+  Float_t    GetZNCtower3         () const {return  fZNCtower[3]  ;}               
+  Float_t    GetZNCtower4         () const {return  fZNCtower[4]  ;}               
+  Float_t    GetZPCtower0         () const {return  fZPCtower[0]  ;}               
+  Float_t    GetZPCtower1         () const {return  fZPCtower[1]  ;}               
+  Float_t    GetZPCtower2         () const {return  fZPCtower[2]  ;}               
+  Float_t    GetZPCtower3         () const {return  fZPCtower[3]  ;}               
+  Float_t    GetZPCtower4         () const {return  fZPCtower[4]  ;}               
+  Float_t    GetZNAtower0         () const {return  fZNAtower[0]  ;}               
+  Float_t    GetZNAtower1         () const {return  fZNAtower[1]  ;}               
+  Float_t    GetZNAtower2         () const {return  fZNAtower[2]  ;}               
+  Float_t    GetZNAtower3         () const {return  fZNAtower[3]  ;}               
+  Float_t    GetZNAtower4         () const {return  fZNAtower[4]  ;}               
+  Float_t    GetZPAtower0         () const {return  fZPAtower[0]  ;}               
+  Float_t    GetZPAtower1         () const {return  fZPAtower[1]  ;}               
+  Float_t    GetZPAtower2         () const {return  fZPAtower[2]  ;}               
+  Float_t    GetZPAtower3         () const {return  fZPAtower[3]  ;}               
+  Float_t    GetZPAtower4         () const {return  fZPAtower[4]  ;}               
+  Float_t    GetCentrZNC0         () const {return  fCentrZNC[0]  ;}               
+  Float_t    GetCentrZNC1         () const {return  fCentrZNC[1]  ;}               
+  Float_t    GetCentrZNA0         () const {return  fCentrZNA[0]  ;}               
+  Float_t    GetCentrZNA1         () const {return  fCentrZNA[1]  ;}               
+  Int_t      GetNTracks           () const {return  fNTracks      ;}               
+  Int_t      GetNPmdTracks        () const {return  fNPmdTracks   ;}               
+  Double_t   GetMultV0A           () const {return  fMultV0A      ;}               
+  Double_t   GetMultV0C           () const {return  fMultV0C      ;}               
+  Float_t    GetMultFMDA          () const {return  fMultFMDA     ;}               
+  Float_t    GetMultFMDC          () const {return  fMultFMDC     ;}               
+  
+  void         Print(Option_t* option = "") const;
+  const char*  GetOutputFileName() const {return TNamed::GetName();}
+  void         SetOutputFileName(const char* fname) {TNamed::SetName(fname);}
+
+  
+ private:
+  char     fTrigClass[100];    //  fired trigger classes
+  //
+  Double_t fxVertex;           //  X vertex from ITS
+  Double_t fyVertex;           //  Y vertex from ITS
+  Double_t fzVertex;           //  Z vertex from ITS
+  Bool_t   fVertexer3d;                //  Is vertex from 3d vertexer?
+  //
+  Double_t fbMC;                // impact parameter from MC
+  Int_t    fNpartTargMC;        // no. of participants for target nucleus from MC
+  Int_t    fNpartProjMC;        // no. of participants for project nucleus from MC
+  Int_t    fNNColl;             // Number of N-N collisions
+  Int_t    fNNwColl;            // Number of N-Nwounded collisions
+  Int_t    fNwNColl;            // Number of Nwounded-N collisons
+  Int_t    fNwNwColl;           // Number of Nwounded-Nwounded collisions
+  //
+  Int_t    fNTracklets;         //  no. tracklets
+  Int_t    fNSingleClusters;    //  no. single clusters
+  Int_t    fNClusters[6];       //  no. clusters on 6 ITS layers
+  Int_t    fNChips[2];          //  no. chips on 2 SPD layers
+  //
+  Double_t fbZDC;               // impact parameter from ZDC reco
+  Int_t    fNpartZDC;           // no. of participants from ZDC reco
+  Double_t fbZDCA;              // impact parameter from ZDC reco side A
+  Int_t    fNpartZDCA;          // no. of part. from ZDC reco side A
+  Double_t fbZDCC;              // impact parameter from ZDC reco side C
+  Int_t    fNpartZDCC;          // no. of part. from ZDC reco side C
+  //
+  UInt_t   fESDFlag;            //  ZDC ESD flags
+  Float_t  fZNCEnergy;          //  ZNC Energy
+  Float_t  fZPCEnergy;          //  ZPC Energy
+  Float_t  fZNAEnergy;          //  ZNA Energy
+  Float_t  fZPAEnergy;          //  ZPA Energy
+  Float_t  fZEM1Energy;         //  ZEM1 Energy
+  Float_t  fZEM2Energy;         //  ZEM2 Energy
+  Float_t  fZNCtower[5];        //  ZNC 5 tower signals
+  Float_t  fZPCtower[5];        //  ZPC 5 tower signals
+  Float_t  fZNAtower[5];        //  ZNA 5 tower signals
+  Float_t  fZPAtower[5];        //  ZPA 5 tower signals
+  Float_t  fCentrZNC[2];        //  centroid over ZNC
+  Float_t  fCentrZNA[2];        //  centroid over ZNA
+  
+  Int_t    fNTracks;            //  no. tracks
+  Int_t    fNPmdTracks;         //  no. PMD tracks
+  Double_t fMultV0A;            //  multiplicity from V0 reco side A
+  Double_t fMultV0C;            //  multiplicity from V0 reco side C
+  Float_t  fMultFMDA;      //  multiplicity from FMD on detector A
+  Float_t  fMultFMDC;      //  multiplicity from FMD on detector C
+  
+  ClassDef(AliAODCentrality, 1);
+};
+
+
+#endif
index 9ae69d0..a71dfff 100644 (file)
@@ -8,7 +8,7 @@ SRCS = AliAODEvent.cxx AliAODHeader.cxx \
        AliAODv0.cxx AliAODcascade.cxx AliAODCaloCells.cxx AliAODInputHandler.cxx \
        AliAODDiJet.cxx AliAODMCParticle.cxx AliAODMCHeader.cxx \
         AliAODPWG4Particle.cxx AliAODPWG4ParticleCorrelation.cxx \
-       AliAODDimuon.cxx AliAODpidUtil.cxx
+       AliAODDimuon.cxx AliAODpidUtil.cxx AliAODCentrality.cxx
 
 HDRS:= $(SRCS:.cxx=.h)