[u/mrichter/AliRoot.git] / PWGJE / EMCALJetTasks / AliAnalysisTaskRhoFlow.cxx

// $Id$
//
// Calculation of rho for flow bias studies
//
// Author: S.Aiola

#include "AliAnalysisTaskRhoFlow.h"

#include <TClonesArray.h>
#include <TMath.h>
#include <TH2F.h>

#include "AliVTrack.h"
#include "AliLog.h"
#include "AliRhoParameter.h"

ClassImp(AliAnalysisTaskRhoFlow)

//________________________________________________________________________
AliAnalysisTaskRhoFlow::AliAnalysisTaskRhoFlow() : 
  AliAnalysisTaskRho("AliAnalysisTaskRhoFlow",kTRUE),
  fRhoNearSide(0),
  fRhoAwaySide(0),
  fRhoPerpSide1(0),
  fRhoPerpSide2(0),
  fHistRhoNearVsCent(0),
  fHistDeltaRhoNearVsCent(0),
  fHistRhoAwayVsCent(0),
  fHistDeltaRhoAwayVsCent(0),
  fHistRhoPerp1VsCent(0),
  fHistDeltaRhoPerp1VsCent(0),
  fHistRhoPerp2VsCent(0),
  fHistDeltaRhoPerp2VsCent(0)
{
  // Constructor.
  SetAttachToEvent(kFALSE);
}

//________________________________________________________________________
AliAnalysisTaskRhoFlow::AliAnalysisTaskRhoFlow(const char *name) :
  AliAnalysisTaskRho(name, kTRUE),
  fRhoNearSide(0),
  fRhoAwaySide(0),
  fRhoPerpSide1(0),
  fRhoPerpSide2(0),
  fHistRhoNearVsCent(0),
  fHistDeltaRhoNearVsCent(0),
  fHistRhoAwayVsCent(0),
  fHistDeltaRhoAwayVsCent(0),
  fHistRhoPerp1VsCent(0),
  fHistDeltaRhoPerp1VsCent(0),
  fHistRhoPerp2VsCent(0),
  fHistDeltaRhoPerp2VsCent(0)
{
  // Constructor.
  SetAttachToEvent(kFALSE);
}

//________________________________________________________________________
void AliAnalysisTaskRhoFlow::UserCreateOutputObjects()
{
  // User create output objects, called at the beginning of the analysis.

  AliAnalysisTaskEmcalJet::UserCreateOutputObjects();

  fHistRhoNearVsCent = new TH2F("RhoNearVsCent", "RhoNearVsCent", 101, -1,  100, fNbins, fMinBinPt, fMaxBinPt*2);
  fOutput->Add(fHistRhoNearVsCent);

  fHistRhoAwayVsCent = new TH2F("RhoAwayVsCent", "RhoAwayVsCent", 101, -1,  100, fNbins, fMinBinPt, fMaxBinPt*2);
  fOutput->Add(fHistRhoAwayVsCent);

  fHistRhoPerp1VsCent = new TH2F("RhoPerp1VsCent", "RhoPerp1VsCent", 101, -1,  100, fNbins, fMinBinPt, fMaxBinPt*2);
  fOutput->Add(fHistRhoPerp1VsCent);

  fHistRhoPerp2VsCent = new TH2F("RhoPerp2VsCent", "RhoPerp2VsCent", 101, -1,  100, fNbins, fMinBinPt, fMaxBinPt*2);
  fOutput->Add(fHistRhoPerp2VsCent);

  if (!fCompareRhoName.IsNull()) {
    fHistDeltaRhoNearVsCent = new TH2F("DeltaRhoNearVsCent", "DeltaRhoNearVsCent", 101, -1, 100, fNbins, -fMaxBinPt, fMaxBinPt);
    fOutput->Add(fHistDeltaRhoNearVsCent);

    fHistDeltaRhoAwayVsCent = new TH2F("DeltaRhoAwayVsCent", "DeltaRhoAwayVsCent", 101, -1, 100, fNbins, -fMaxBinPt, fMaxBinPt);
    fOutput->Add(fHistDeltaRhoAwayVsCent);
    
    fHistDeltaRhoPerp1VsCent = new TH2F("DeltaRhoPerp1VsCent", "DeltaRhoPerp1VsCent", 101, -1, 100, fNbins, -fMaxBinPt, fMaxBinPt);
    fOutput->Add(fHistDeltaRhoPerp1VsCent);

    fHistDeltaRhoPerp2VsCent = new TH2F("DeltaRhoPerp2VsCent", "DeltaRhoPerp2VsCent", 101, -1, 100, fNbins, -fMaxBinPt, fMaxBinPt);
    fOutput->Add(fHistDeltaRhoPerp2VsCent);
  }
}

//________________________________________________________________________
Bool_t AliAnalysisTaskRhoFlow::Run() 
{
  if (!fTracks)
    return kFALSE;
  
  Double_t maxTrackPhi = -1;
  Double_t maxTrackPt  = 0;

  for (Int_t i = 0; i < fTracks->GetEntriesFast(); i++) {
    AliVTrack *track = static_cast<AliVTrack*>(fTracks->At(i));
    if (!track)
      continue;
    if (!AcceptTrack(track))
      continue;

    if (track->Pt() > maxTrackPt) {
      maxTrackPt  = track->Pt();
      maxTrackPhi = track->Phi();
    }
  }

  Double_t minPhi = -1;
  Double_t maxPhi = -1;

  // away side
  minPhi = maxTrackPhi + TMath::Pi() - TMath::Pi()/4 + fJetRadius;
  maxPhi = maxTrackPhi + TMath::Pi() + TMath::Pi()/4 + fJetRadius;
  if (maxPhi > TMath::Pi() * 2) {
    minPhi -= TMath::Pi() * 2;
    maxPhi -= TMath::Pi() * 2;
  }
  SetJetPhiLimits(minPhi, maxPhi);  
  fNExclLeadJets = 1;
  AliAnalysisTaskRho::Run();
  fRhoAwaySide = fRho->GetVal();

  // perp 1 side
  minPhi = maxTrackPhi + TMath::Pi()/2 - TMath::Pi()/4 + fJetRadius;
  maxPhi = maxTrackPhi + TMath::Pi()/2 + TMath::Pi()/4 + fJetRadius;
  if (maxPhi > TMath::Pi() * 2) {
    minPhi -= TMath::Pi() * 2;
    maxPhi -= TMath::Pi() * 2;
  }
  SetJetPhiLimits(minPhi, maxPhi);  
  fNExclLeadJets = 0;
  AliAnalysisTaskRho::Run();
  fRhoPerpSide1 = fRho->GetVal();

  // perp 2 side
  minPhi = maxTrackPhi - TMath::Pi()/2 - TMath::Pi()/4 + fJetRadius;
  maxPhi = maxTrackPhi - TMath::Pi()/2 + TMath::Pi()/4 + fJetRadius;
  if (maxPhi > TMath::Pi() * 2) {
    minPhi -= TMath::Pi() * 2;
    maxPhi -= TMath::Pi() * 2;
  }
  SetJetPhiLimits(minPhi, maxPhi);
  fNExclLeadJets = 0;
  AliAnalysisTaskRho::Run();
  fRhoPerpSide2 = fRho->GetVal();

  // near side
  minPhi = maxTrackPhi - TMath::Pi()/4 + fJetRadius;
  maxPhi = maxTrackPhi + TMath::Pi()/4 + fJetRadius;
  if (maxPhi > TMath::Pi() * 2) {
    minPhi -= TMath::Pi() * 2;
    maxPhi -= TMath::Pi() * 2;
  }
  SetJetPhiLimits(minPhi, maxPhi);
  fNExclLeadJets = 1;
  AliAnalysisTaskRho::Run();
  fRhoNearSide = fRho->GetVal();
  
  return kTRUE;
}

//________________________________________________________________________
Bool_t AliAnalysisTaskRhoFlow::FillHistograms() 
{
  // Fill histograms.

  fHistRhoNearVsCent->Fill(fCent, fRhoNearSide);  
  fHistRhoAwayVsCent->Fill(fCent, fRhoAwaySide);
  fHistRhoPerp1VsCent->Fill(fCent, fRhoPerpSide1);
  fHistRhoPerp2VsCent->Fill(fCent, fRhoPerpSide2);

  if (fCompareRho) {
    fHistDeltaRhoNearVsCent->Fill(fCent, fRhoNearSide - fCompareRho->GetVal());
    fHistDeltaRhoAwayVsCent->Fill(fCent, fRhoAwaySide - fCompareRho->GetVal());
    fHistDeltaRhoPerp1VsCent->Fill(fCent, fRhoPerpSide1 - fCompareRho->GetVal());
    fHistDeltaRhoPerp2VsCent->Fill(fCent, fRhoPerpSide2 - fCompareRho->GetVal());
  }

  return kTRUE;
}
Commit	Line	Data
8628b70c	1	// $Id$
b31a78d4	2	//
	3	// Calculation of rho for flow bias studies
	4	//
	5	// Author: S.Aiola
	6
	7	#include "AliAnalysisTaskRhoFlow.h"
	8
	9	#include <TClonesArray.h>
	10	#include <TMath.h>
	11	#include <TH2F.h>
	12
	13	#include "AliVTrack.h"
	14	#include "AliLog.h"
	15	#include "AliRhoParameter.h"
	16
	17	ClassImp(AliAnalysisTaskRhoFlow)
	18
	19	//________________________________________________________________________
	20	AliAnalysisTaskRhoFlow::AliAnalysisTaskRhoFlow() :
	21	AliAnalysisTaskRho("AliAnalysisTaskRhoFlow",kTRUE),
	22	fRhoNearSide(0),
	23	fRhoAwaySide(0),
	24	fRhoPerpSide1(0),
	25	fRhoPerpSide2(0),
	26	fHistRhoNearVsCent(0),
	27	fHistDeltaRhoNearVsCent(0),
	28	fHistRhoAwayVsCent(0),
	29	fHistDeltaRhoAwayVsCent(0),
	30	fHistRhoPerp1VsCent(0),
	31	fHistDeltaRhoPerp1VsCent(0),
	32	fHistRhoPerp2VsCent(0),
	33	fHistDeltaRhoPerp2VsCent(0)
	34	{
	35	// Constructor.
	36	SetAttachToEvent(kFALSE);
	37	}
	38
	39	//________________________________________________________________________
	40	AliAnalysisTaskRhoFlow::AliAnalysisTaskRhoFlow(const char *name) :
	41	AliAnalysisTaskRho(name, kTRUE),
	42	fRhoNearSide(0),
	43	fRhoAwaySide(0),
	44	fRhoPerpSide1(0),
	45	fRhoPerpSide2(0),
	46	fHistRhoNearVsCent(0),
	47	fHistDeltaRhoNearVsCent(0),
	48	fHistRhoAwayVsCent(0),
	49	fHistDeltaRhoAwayVsCent(0),
	50	fHistRhoPerp1VsCent(0),
	51	fHistDeltaRhoPerp1VsCent(0),
	52	fHistRhoPerp2VsCent(0),
	53	fHistDeltaRhoPerp2VsCent(0)
	54	{
	55	// Constructor.
	56	SetAttachToEvent(kFALSE);
	57	}
	58
	59	//________________________________________________________________________
	60	void AliAnalysisTaskRhoFlow::UserCreateOutputObjects()
	61	{
	62	// User create output objects, called at the beginning of the analysis.
	63
	64	AliAnalysisTaskEmcalJet::UserCreateOutputObjects();
	65
66	fHistRhoNearVsCent = new TH2F("RhoNearVsCent", "RhoNearVsCent", 101, -1, 100, fNbins, fMinBinPt, fMaxBinPt*2);
67	fOutput->Add(fHistRhoNearVsCent);
68
69	fHistRhoAwayVsCent = new TH2F("RhoAwayVsCent", "RhoAwayVsCent", 101, -1, 100, fNbins, fMinBinPt, fMaxBinPt*2);
70	fOutput->Add(fHistRhoAwayVsCent);
71
72	fHistRhoPerp1VsCent = new TH2F("RhoPerp1VsCent", "RhoPerp1VsCent", 101, -1, 100, fNbins, fMinBinPt, fMaxBinPt*2);
73	fOutput->Add(fHistRhoPerp1VsCent);
74
75	fHistRhoPerp2VsCent = new TH2F("RhoPerp2VsCent", "RhoPerp2VsCent", 101, -1, 100, fNbins, fMinBinPt, fMaxBinPt*2);
76	fOutput->Add(fHistRhoPerp2VsCent);
77
78	if (!fCompareRhoName.IsNull()) {
79	fHistDeltaRhoNearVsCent = new TH2F("DeltaRhoNearVsCent", "DeltaRhoNearVsCent", 101, -1, 100, fNbins, -fMaxBinPt, fMaxBinPt);
80	fOutput->Add(fHistDeltaRhoNearVsCent);
81
82	fHistDeltaRhoAwayVsCent = new TH2F("DeltaRhoAwayVsCent", "DeltaRhoAwayVsCent", 101, -1, 100, fNbins, -fMaxBinPt, fMaxBinPt);
83	fOutput->Add(fHistDeltaRhoAwayVsCent);
84
85	fHistDeltaRhoPerp1VsCent = new TH2F("DeltaRhoPerp1VsCent", "DeltaRhoPerp1VsCent", 101, -1, 100, fNbins, -fMaxBinPt, fMaxBinPt);
86	fOutput->Add(fHistDeltaRhoPerp1VsCent);
87
88	fHistDeltaRhoPerp2VsCent = new TH2F("DeltaRhoPerp2VsCent", "DeltaRhoPerp2VsCent", 101, -1, 100, fNbins, -fMaxBinPt, fMaxBinPt);
89	fOutput->Add(fHistDeltaRhoPerp2VsCent);
90	}
91	}
92
93	//________________________________________________________________________
94	Bool_t AliAnalysisTaskRhoFlow::Run()
95	{
96	if (!fTracks)
97	return kFALSE;
98
99	Double_t maxTrackPhi = -1;
100	Double_t maxTrackPt = 0;
101
102	for (Int_t i = 0; i < fTracks->GetEntriesFast(); i++) {
103	AliVTrack track = static_cast<AliVTrack>(fTracks->At(i));
104	if (!track)
105	continue;
106	if (!AcceptTrack(track))
107	continue;
108
109	if (track->Pt() > maxTrackPt) {
110	maxTrackPt = track->Pt();
111	maxTrackPhi = track->Phi();
112	}
113	}
114
115	Double_t minPhi = -1;
116	Double_t maxPhi = -1;
117
118	// away side
119	minPhi = maxTrackPhi + TMath::Pi() - TMath::Pi()/4 + fJetRadius;
120	maxPhi = maxTrackPhi + TMath::Pi() + TMath::Pi()/4 + fJetRadius;
121	if (maxPhi > TMath::Pi() * 2) {
122	minPhi -= TMath::Pi() * 2;
123	maxPhi -= TMath::Pi() * 2;
124	}
125	SetJetPhiLimits(minPhi, maxPhi);
393ec2ad	126	fNExclLeadJets = 1;
b31a78d4	127	AliAnalysisTaskRho::Run();
	128	fRhoAwaySide = fRho->GetVal();
	129
	130	// perp 1 side
	131	minPhi = maxTrackPhi + TMath::Pi()/2 - TMath::Pi()/4 + fJetRadius;
	132	maxPhi = maxTrackPhi + TMath::Pi()/2 + TMath::Pi()/4 + fJetRadius;
	133	if (maxPhi > TMath::Pi() * 2) {
	134	minPhi -= TMath::Pi() * 2;
	135	maxPhi -= TMath::Pi() * 2;
	136	}
	137	SetJetPhiLimits(minPhi, maxPhi);
393ec2ad	138	fNExclLeadJets = 0;
b31a78d4	139	AliAnalysisTaskRho::Run();
	140	fRhoPerpSide1 = fRho->GetVal();
	141
	142	// perp 2 side
	143	minPhi = maxTrackPhi - TMath::Pi()/2 - TMath::Pi()/4 + fJetRadius;
	144	maxPhi = maxTrackPhi - TMath::Pi()/2 + TMath::Pi()/4 + fJetRadius;
	145	if (maxPhi > TMath::Pi() * 2) {
	146	minPhi -= TMath::Pi() * 2;
	147	maxPhi -= TMath::Pi() * 2;
	148	}
	149	SetJetPhiLimits(minPhi, maxPhi);
393ec2ad	150	fNExclLeadJets = 0;
b31a78d4	151	AliAnalysisTaskRho::Run();
	152	fRhoPerpSide2 = fRho->GetVal();
	153
	154	// near side
	155	minPhi = maxTrackPhi - TMath::Pi()/4 + fJetRadius;
	156	maxPhi = maxTrackPhi + TMath::Pi()/4 + fJetRadius;
	157	if (maxPhi > TMath::Pi() * 2) {
	158	minPhi -= TMath::Pi() * 2;
	159	maxPhi -= TMath::Pi() * 2;
	160	}
393ec2ad	161	SetJetPhiLimits(minPhi, maxPhi);
393ec2ad	162	fNExclLeadJets = 1;
b31a78d4	163	AliAnalysisTaskRho::Run();
	164	fRhoNearSide = fRho->GetVal();
	165
	166	return kTRUE;
	167	}
	168
	169	//________________________________________________________________________
	170	Bool_t AliAnalysisTaskRhoFlow::FillHistograms()
	171	{
	172	// Fill histograms.
	173
	174	fHistRhoNearVsCent->Fill(fCent, fRhoNearSide);
	175	fHistRhoAwayVsCent->Fill(fCent, fRhoAwaySide);
	176	fHistRhoPerp1VsCent->Fill(fCent, fRhoPerpSide1);
	177	fHistRhoPerp2VsCent->Fill(fCent, fRhoPerpSide2);
	178
	179	if (fCompareRho) {
	180	fHistDeltaRhoNearVsCent->Fill(fCent, fRhoNearSide - fCompareRho->GetVal());
	181	fHistDeltaRhoAwayVsCent->Fill(fCent, fRhoAwaySide - fCompareRho->GetVal());
	182	fHistDeltaRhoPerp1VsCent->Fill(fCent, fRhoPerpSide1 - fCompareRho->GetVal());
	183	fHistDeltaRhoPerp2VsCent->Fill(fCent, fRhoPerpSide2 - fCompareRho->GetVal());
	184	}
	185
	186	return kTRUE;
	187	}