// $Id$
//
-// Calculation of rho
+// Calculation of rho from a collection of jets.
+// If scale function is given the scaled rho will be exported
+// with the name as "fRhoName".apppend("_Scaled").
//
// Authors: R.Reed, S.Aiola
fNExclLeadJets(0),
fScaleFunction(0),
fCreateHisto(kFALSE),
- fOutputList(0),
- fHistCentrality(0),
- fHistJetPt(0),
- fHistJetArea(0),
- fHistRhovsCent(0),
- fHistDeltaRhovsCent(0),
- fHistDeltaRhoScalevsCent(0),
- fHistJetPtvsCent(0),
- fHistJetAreavsCent(0),
- fHistNjetvsCent(0),
- fHistRhovsNtrack(0),
- fHistDeltaRhovsNtrack(0),
- fHistDeltaRhoScalevsNtrack(0),
- fHistJetPtvsNtrack(0),
- fHistJetAreavsNtrack(0),
- fHistNjetvsNtrack(0),
- fRhoScaled(0)
-{
- // Constructor
-}
-
-//________________________________________________________________________
-AliAnalysisTaskRho::AliAnalysisTaskRho(const char *name) :
- AliAnalysisTaskRhoBase(name),
- fTracksName("tracks"),
- fJetsName("KtJets"),
- fRhoScaledName(""),
- fPhiMin(0),
- fPhiMax(0),
- fEtaMin(0),
- fEtaMax(0),
- fAreaCut(0),
- fNExclLeadJets(0),
- fScaleFunction(0),
- fCreateHisto(kFALSE),
+ fTracks(0),
+ fJets(0),
fOutputList(0),
fHistCentrality(0),
fHistJetPt(0),
fJetsName("KtJets"),
fRhoScaledName(""),
fPhiMin(0),
- fPhiMax(0),
- fEtaMin(0),
- fEtaMax(0),
- fAreaCut(0),
- fNExclLeadJets(0),
+ fPhiMax(TMath::TwoPi()),
+ fEtaMin(-0.5),
+ fEtaMax(+0.5),
+ fAreaCut(0.01),
+ fNExclLeadJets(1),
fScaleFunction(0),
fCreateHisto(histo),
+ fTracks(0),
+ fJets(0),
fOutputList(0),
fHistCentrality(0),
fHistJetPt(0),
DefineOutput(1, TList::Class());
}
-
//________________________________________________________________________
void AliAnalysisTaskRho::UserCreateOutputObjects()
{
AliAnalysisTaskRhoBase::UserCreateOutputObjects();
- fRhoScaledName = fRhoName;
- fRhoScaledName += "_Scaled";
- fRhoScaled = new AliRhoParameter(fRhoScaledName, 0);
+ if (fScaleFunction) {
+ fRhoScaledName = fRhoName;
+ fRhoScaledName += "_Scaled";
+ fRhoScaled = new AliRhoParameter(fRhoScaledName, 0);
+ }
if (!fCreateHisto)
return;
fOutputList = new TList();
fOutputList->SetOwner();
- if (!fCreateHisto) {
- PostData(1, fOutputList);
- return;
- }
-
fHistCentrality = new TH1F("Centrality", "Centrality", 101, -1, 100);
fHistRhovsCent = new TH2F("RhovsCent", "RhovsCent", 101, -1, 100, 500, 0, 500);
fHistDeltaRhovsCent = new TH2F("DeltaRhovsCent", "DetlaRhovsCent", 101, -1, 100, 500, -250, 250);
PostData(1, fOutputList);
}
-//________________________________________________________________________
-Double_t AliAnalysisTaskRho::GetScaleFactor(Double_t cent)
-{
- // Get scale factor.
-
- Double_t scale = 1;
- if (fScaleFunction)
- scale = fScaleFunction->Eval(cent);
- return scale;
-}
-
//________________________________________________________________________
void AliAnalysisTaskRho::UserExec(Option_t *)
{
// Main loop, called for each event.
- AliAnalysisTaskRhoBase::UserExec("");
+ if (!fIsInit) {
+ ExecOnce();
+ fIsInit = 1;
+ }
fRho->SetVal(-1);
-
- // add rho to event if not yet there
- if (!(InputEvent()->FindListObject(fRhoScaledName))) {
- InputEvent()->AddObject(fRhoScaled);
- }
- else {
+ if (fRhoScaled)
fRhoScaled->SetVal(-1);
- }
- // optimization in case autobranch loading is off
- AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
- if (fTracksName == "Tracks")
- am->LoadBranch("Tracks");
+ DetermineCent();
- TClonesArray *jets = 0;
- TClonesArray *tracks = 0;
+ const Int_t Njets = fJets->GetEntries();
- tracks = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fTracksName));
- if (!tracks) {
- AliError(Form("%s: Pointer to tracks %s == 0", GetName(), fTracksName.Data() ));
- return;
- }
-
- jets = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fJetsName));
- if (!jets) {
- AliError(Form("%s: Pointer to jets %s == 0", GetName(), fJetsName.Data() ));
- return;
- }
-
- if (fCreateHisto)
- fHistCentrality->Fill(fCent);
-
- const Int_t Ntracks = tracks->GetEntries();
- const Int_t Njets = jets->GetEntries();
+ Int_t maxJetIds[] = {-1, -1};
+ Float_t maxJetPts[] = { 0, 0};
- Int_t maxJetIds[] = {-1, -1};
- Float_t maxJetPts[] = {0, 0};
if (fNExclLeadJets > 0) {
- for (Int_t ij = 0; ij < Njets; ij++) {
-
- AliEmcalJet *jet = static_cast<AliEmcalJet*>(jets->At(ij));
-
+ for (Int_t ij = 0; ij < Njets; ++ij) {
+ AliEmcalJet *jet = static_cast<AliEmcalJet*>(fJets->At(ij));
if (!jet) {
- AliError(Form("Could not receive jet %d", ij));
+ AliError(Form("%s: Could not receive jet %d", GetName(), ij));
continue;
}
-
if (jet->Pt() > maxJetPts[0]) {
maxJetPts[1] = maxJetPts[0];
maxJetIds[1] = maxJetIds[0];
maxJetPts[0] = jet->Pt();
maxJetIds[0] = ij;
- }
-
- if (jet->Pt() > maxJetPts[1]) {
+ } else if (jet->Pt() > maxJetPts[1]) {
maxJetPts[1] = jet->Pt();
maxJetIds[1] = ij;
}
}
-
if (fNExclLeadJets < 2) {
maxJetIds[1] = -1;
maxJetPts[1] = -1;
// push all jets within selected acceptance into stack
for (Int_t iJets = 0; iJets < Njets; ++iJets) {
-
+
// exlcuding lead jets
if (iJets == maxJetIds[0] || iJets == maxJetIds[1])
continue;
- AliEmcalJet *jet = static_cast<AliEmcalJet*>(jets->At(iJets));
-
+ AliEmcalJet *jet = static_cast<AliEmcalJet*>(fJets->At(iJets));
if (!jet)
continue;
continue;
if ((jet->Eta() < fEtaMin) || (jet->Eta() > fEtaMax))
continue;
- if (jet->Area() == 0)
- continue;
rhovec[NjetAcc] = jet->Pt() / jet->Area();
- NjetAcc++;
+ ++NjetAcc;
if (fCreateHisto) {
// filling histograms
+ const Int_t Ntracks = fTracks->GetEntriesFast();
fHistJetPt->Fill(jet->Pt());
fHistJetArea->Fill(jet->Area());
fHistJetPtvsCent->Fill(fCent, jet->Pt());
fHistJetAreavsNtrack->Fill(Ntracks, jet->Area());
}
}
-
- if (fCreateHisto) {
- fHistNjetvsCent->Fill(fCent, NjetAcc);
- fHistNjetvsNtrack->Fill(Ntracks, NjetAcc);
- }
-
- Double_t scale = GetScaleFactor(fCent);
- Double_t rhochem = GetRhoFactor(fCent);
- Double_t rho0 = -1;
-
- if (NjetAcc > 0){
+ if (NjetAcc > 0) {
//find median value
- rho0 = TMath::Median(NjetAcc, rhovec);
-
- Double_t rhoScaled = rho0 * scale;
-
+ Double_t rho0 = TMath::Median(NjetAcc, rhovec);
fRho->SetVal(rho0);
- fRhoScaled->SetVal(rhoScaled);
+
+ Double_t rhoScaled = rho0;
+ if (fRhoScaled) {
+ rhoScaled *= GetScaleFactor(fCent);
+ fRhoScaled->SetVal(rhoScaled);
+ }
if (fCreateHisto) {
// filling other histograms
+ Double_t rho = GetRhoFactor(fCent);
+ const Int_t Ntracks = fTracks->GetEntriesFast();
fHistRhovsCent->Fill(fCent, rho0);
- fHistDeltaRhovsCent->Fill(fCent, rho0 - rhochem);
- fHistDeltaRhoScalevsCent->Fill(fCent, rhoScaled - rhochem);
+ fHistDeltaRhovsCent->Fill(fCent, rho0 - rho);
+ fHistDeltaRhoScalevsCent->Fill(fCent, rhoScaled - rho);
fHistRhovsNtrack->Fill(Ntracks, rho0);
- fHistDeltaRhovsNtrack->Fill(Ntracks, rho0 - rhochem);
- fHistDeltaRhoScalevsNtrack->Fill(Ntracks, rhoScaled - rhochem);
+ fHistDeltaRhovsNtrack->Fill(Ntracks, rho0 - rho);
+ fHistDeltaRhoScalevsNtrack->Fill(Ntracks, rhoScaled - rho);
}
}
- if (fCreateHisto)
+ if (fCreateHisto) {
+ const Int_t Ntracks = fTracks->GetEntriesFast();
+ fHistCentrality->Fill(fCent);
+ fHistNjetvsCent->Fill(fCent, NjetAcc);
+ fHistNjetvsNtrack->Fill(Ntracks, NjetAcc);
PostData(1, fOutputList);
+ }
}
//________________________________________________________________________
{
// Called at the end of the analysis.
}
+
+//________________________________________________________________________
+void AliAnalysisTaskRho::ExecOnce()
+{
+ // Initialize some settings that need to be determined in UserExec.
+
+ AliAnalysisTaskRhoBase::ExecOnce();
+
+ if (fRhoScaled) {
+ // add rho to event if not yet there
+ if (!(InputEvent()->FindListObject(fRhoScaledName))) {
+ InputEvent()->AddObject(fRhoScaled);
+ } else {
+ AliFatal(Form("%s: Container with same name %s already present. Aborting", GetName(), fRhoScaledName.Data()));
+ return;
+ }
+ }
+
+ if (fCreateHisto) {
+ fTracks = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fTracksName));
+ if (!fTracks) {
+ AliError(Form("%s: Pointer to tracks %s == 0", GetName(), fTracksName.Data() ));
+ return;
+ }
+ }
+
+ fJets = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fJetsName));
+ if (!fJets) {
+ AliError(Form("%s: Pointer to jets %s == 0", GetName(), fJetsName.Data() ));
+ return;
+ }
+}
+
+//________________________________________________________________________
+Double_t AliAnalysisTaskRho::GetScaleFactor(Double_t cent)
+{
+ // Get scale factor.
+
+ Double_t scale = 1;
+ if (fScaleFunction)
+ scale = fScaleFunction->Eval(cent);
+ return scale;
+}
public:
AliAnalysisTaskRho();
- AliAnalysisTaskRho(const char *name);
- AliAnalysisTaskRho(const char *name, Bool_t histo);
+ AliAnalysisTaskRho(const char *name, Bool_t histo=kFALSE);
virtual ~AliAnalysisTaskRho() {}
virtual void UserCreateOutputObjects();
virtual void UserExec(Option_t*);
virtual void Terminate(Option_t*);
+ const char *GetRhoScaled() const { return fRhoScaledName; }
void SetAreaCut(Double_t a = 0.0) { fAreaCut = a ; }
+ void SetExcludeLeadJets(UInt_t n) { fNExclLeadJets = n ; }
void SetJetEta(Double_t emin, Double_t emax) { fEtaMin = emin ; fEtaMax = emax ; }
void SetJetPhi(Double_t pmin, Double_t pmax) { fPhiMin = pmin ; fPhiMax = pmax ; }
void SetJetsName(const char *n) { fJetsName = n ; }
void SetScaleFunction(TF1* sf) { fScaleFunction = sf ; }
void SetTracksName(const char *n) { fTracksName = n ; }
- void SetExcludeLeadJets(UInt_t n) { fNExclLeadJets = n ; }
-
+ void SetRhoName(const char *name) { fRhoName = name ;
+ fRhoScaledName = name;
+ fRhoScaledName += "_Scaled"; }
+
protected:
+ virtual void ExecOnce();
virtual Double_t GetScaleFactor(Double_t cent);
TString fTracksName; // name of track collection
UInt_t fNExclLeadJets; // number of leading jets to be excluded from the median calculation
TF1 *fScaleFunction; // pre-computed scale factor as a function of centrality
Bool_t fCreateHisto; // whether or not create histograms
+ TClonesArray *fTracks; //!ptr to input tracks
+ TClonesArray *fJets; //!ptr to input jets
TList *fOutputList; //!output list
TH1F *fHistCentrality; //!centrality distribution
TH1F *fHistJetPt; //!jet pt distribution
TH2F *fHistJetPtvsCent; //!jet pt vs. centrality
TH2F *fHistJetAreavsCent; //!jet area vs. centrality
TH2F *fHistNjetvsCent; //!no. of jets vs. centrality
-
TH2F *fHistRhovsNtrack; //!rho vs. no. of tracks
TH2F *fHistDeltaRhovsNtrack; //!delta rho vs. no. of tracks
TH2F *fHistDeltaRhoScalevsNtrack; //!delta rho scaled vs. no. of tracks
AliAnalysisTaskRho(const AliAnalysisTaskRho&); // not implemented
AliAnalysisTaskRho& operator=(const AliAnalysisTaskRho&); // not implemented
- ClassDef(AliAnalysisTaskRho, 5); // Rho task
+ ClassDef(AliAnalysisTaskRho, 6); // Rho task
};
#endif
// $Id$
//
-// Calculation of rho, method: sum of all particle pt / full acceptance area
+// Calculation of rho, method: sum of all particle pt / full acceptance area.
//
// Authors: S. Aiola
-#include <TList.h>
+#include "AliAnalysisTaskRhoAverage.h"
+
#include <TClonesArray.h>
+#include <TList.h>
#include <TMath.h>
#include "AliAnalysisManager.h"
#include "AliVCluster.h"
#include "AliVEventHandler.h"
#include "AliVTrack.h"
-#include "AliAnalysisTaskRhoAverage.h"
ClassImp(AliAnalysisTaskRhoAverage)
//________________________________________________________________________
AliAnalysisTaskRhoAverage::AliAnalysisTaskRhoAverage() :
AliAnalysisTaskRhoBase(),
- fTracksName("tracks"),
- fClustersName("caloClusters"),
- fJetsName("KtJets"),
- fEtaMin(-0.9),
- fEtaMax(0.9),
+ fTracksName(),
+ fClustersName(),
+ fJetsName(),
+ fEtaMin(0),
+ fEtaMax(0),
fPhiMin(0),
- fPhiMax(2 * TMath::Pi()),
- fPtMin(0.15)
+ fPhiMax(0),
+ fPtMin(0),
+ fClusters(0),
+ fJets(0),
+ fTracks(0)
{
- // Constructor
+ // Default constructor.
}
//________________________________________________________________________
fEtaMax(0.9),
fPhiMin(0),
fPhiMax(2 * TMath::Pi()),
- fPtMin(0.15)
+ fPtMin(0.15),
+ fClusters(0),
+ fJets(0),
+ fTracks(0)
{
- // Constructor
-
+ // Constructor.
}
//________________________________________________________________________
{
// Main loop, called for each event.
- AliAnalysisTaskRhoBase::UserExec("");
-
- fRho->SetVal(-1);
-
- TClonesArray *jets = 0;
- TClonesArray *tracks = 0;
- TClonesArray *clusters = 0;
-
- tracks = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fTracksName));
- if (!tracks) {
- AliError(Form("Pointer to tracks %s == 0", fTracksName.Data() ));
- return;
- }
-
- if (fClustersName != "") {
- clusters = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fClustersName));
- if (!clusters) {
- AliError(Form("Pointer to clusters %s == 0", fClustersName.Data() ));
- return;
- }
+ if (!fIsInit) {
+ ExecOnce();
+ fIsInit = 1;
}
- if (fJetsName != "") {
- jets = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fJetsName));
- if (!jets) {
- AliError(Form("Pointer to jets %s == 0", fJetsName.Data() ));
- return;
- }
- }
+ fRho->SetVal(-1);
Double_t rho = 0;
- Int_t Ntracks = tracks->GetEntries();
+ Int_t Ntracks = 0;
+ if (fTracks)
+ Ntracks = fTracks->GetEntriesFast();
Int_t Nclusters = 0;
- if (clusters)
- Nclusters = clusters->GetEntries();
+ if (fClusters)
+ Nclusters = fClusters->GetEntriesFast();
Int_t Njets = 0;
- if (jets)
- Njets = jets->GetEntries();
+ if (fJets)
+ Njets = fJets->GetEntriesFast();
- Float_t maxJetPt = 0;
+ Double_t maxJetPt = 0;
Int_t maxJetId = -1;
AliEmcalJet *maxJet = 0;
for (Int_t ij = 0; ij < Njets; ij++) {
- AliEmcalJet *jet = static_cast<AliEmcalJet*>(jets->At(ij));
+ AliEmcalJet *jet = static_cast<AliEmcalJet*>(fJets->At(ij));
if (!jet) {
- AliError(Form("Could not receive jet %d", ij));
+ AliError(Form("%s: Could not receive jet %d", GetName(), ij));
continue;
}
}
if (maxJetId >= 0)
- maxJet = static_cast<AliEmcalJet*>(jets->At(maxJetId));
+ maxJet = static_cast<AliEmcalJet*>(fJets->At(maxJetId));
- for (Int_t it = 0; it < Ntracks; it++) {
+ for (Int_t it = 0; it < Ntracks; ++it) {
- AliVTrack *track = static_cast<AliVTrack*>(tracks->At(it));
+ AliVTrack *track = static_cast<AliVTrack*>(fTracks->At(it));
if (!track) {
- AliError(Form("Could not receive track %d", it));
+ AliError(Form("%s: Could not receive track %d", GetName(), it));
continue;
}
Double_t vertex[] = {0, 0, 0};
InputEvent()->GetPrimaryVertex()->GetXYZ(vertex);
- for (Int_t ic = 0; ic < Nclusters; ic++) {
+ for (Int_t ic = 0; ic < Nclusters; ++ic) {
- AliVCluster *cluster = static_cast<AliVCluster*>(clusters->At(ic));
+ AliVCluster *cluster = static_cast<AliVCluster*>(fClusters->At(ic));
if (!cluster) {
- AliError(Form("Could not receive cluster %d", ic));
+ AliError(Form("%s: Could not receive cluster %d", GetName(), ic));
continue;
}
if (maxJet)
area -= maxJet->Area();
- rho /= area;
-
- fRho->SetVal(rho);
+ if (area>0) {
+ rho /= area;
+ fRho->SetVal(rho);
+ } else {
+ AliError(Form("%s: Area negative %f", GetName(), area));
+ }
}
+//________________________________________________________________________
+void AliAnalysisTaskRhoAverage::Terminate(Option_t *)
+{
+ // Called at the end of the analysis.
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskRhoAverage::ExecOnce()
+{
+ // Initialize some settings that need to be determined in UserExec.
+
+ AliAnalysisTaskRhoBase::ExecOnce();
+
+ fClusters = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fClustersName));
+ if (!fClusters) {
+ AliError(Form("%s: Pointer to jets %s == 0", GetName(), fClustersName.Data() ));
+ return;
+ }
+
+ fJets = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fJetsName));
+ if (!fJets) {
+ AliError(Form("%s: Pointer to jets %s == 0", GetName(), fJetsName.Data() ));
+ return;
+ }
+
+ fTracks = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fTracksName));
+ if (!fTracks) {
+ AliError(Form("%s: Pointer to tracks %s == 0", GetName(), fTracksName.Data() ));
+ return;
+ }
+}
+
//________________________________________________________________________
Bool_t AliAnalysisTaskRhoAverage::IsJetTrack(AliEmcalJet* jet, Int_t itrack) const
{
}
return kFALSE;
}
-
-
-//________________________________________________________________________
-void AliAnalysisTaskRhoAverage::Terminate(Option_t *)
-{
- // Called at the end of the analysis.
-}
// $Id$
-class TList;
-class TH1F;
-class TH2F;
class TClonesArray;
-class TString;
-class TF1;
+class TList;
+class AliEmcalJet;
#include "AliAnalysisTaskRhoBase.h"
public:
AliAnalysisTaskRhoAverage();
AliAnalysisTaskRhoAverage(const char *name);
- AliAnalysisTaskRhoAverage(const char *name, Bool_t histo);
virtual ~AliAnalysisTaskRhoAverage() {}
- virtual void UserExec(Option_t*);
- virtual void Terminate(Option_t*);
+ void UserExec(Option_t*);
+ void Terminate(Option_t*);
- void SetTracksName(const char *n) { fTracksName = n ; }
void SetClustersName(const char *n) { fClustersName = n ; }
- void SetJetsName(const char *n) { fJetsName = n ; }
void SetEtaLimits(Double_t emin, Double_t emax) { fEtaMin = emin ; fEtaMax = emax ; }
+ void SetJetsName(const char *n) { fJetsName = n ; }
void SetPhiLimits(Double_t pmin, Double_t pmax) { fPhiMin = pmin ; fPhiMax = pmax ; }
void SetPtMin(Double_t pt) { fPtMin = pt ; }
+ void SetTracksName(const char *n) { fTracksName = n ; }
protected:
+ void ExecOnce();
Bool_t IsJetCluster(AliEmcalJet* jet, Int_t iclus) const;
Bool_t IsJetTrack(AliEmcalJet* jet, Int_t itrack) const;
Double_t fPhiMin; // minimum phi
Double_t fPhiMax; // maximum phi
Double_t fPtMin; // minimum pt
+ TClonesArray *fClusters; //!input clusters
+ TClonesArray *fJets; //!input jets
+ TClonesArray *fTracks; //!input tracks
AliAnalysisTaskRhoAverage(const AliAnalysisTaskRhoAverage&); // not implemented
AliAnalysisTaskRhoAverage& operator=(const AliAnalysisTaskRhoAverage&); // not implemented
- ClassDef(AliAnalysisTaskRhoAverage, 1); // Rho task, method: sum of all particle pt / full acceptance area
+ ClassDef(AliAnalysisTaskRhoAverage, 2); // Rho task, method: sum of all particle pt / full acceptance area
};
#endif
// $Id$
//
-// Base class for rho calculation
+// Base class for rho calculation.
+// Calculates parameterized rho for given centrality independent of input.
//
// Author: S.Aiola
fRhoName("Rho"),
fRhoFunction(0x0),
fCent(-1),
- fRho(0)
+ fRho(0),
+ fDoCent(0),
+ fIsInit(0)
{
// Constructor.
}
fRhoName("Rho"),
fRhoFunction(0x0),
fCent(-1),
- fRho(0)
+ fRho(0),
+ fDoCent(0),
+ fIsInit(0)
{
// Constructor.
}
}
//________________________________________________________________________
-Double_t AliAnalysisTaskRhoBase::GetRhoFactor(Double_t cent)
+void AliAnalysisTaskRhoBase::UserExec(Option_t *)
{
- // Return rho per centrality.
+ // Main loop, called for each event.
- Double_t rho = -1;
- if (fRhoFunction)
- rho = fRhoFunction->Eval(cent);
- return rho;
+ if (!fIsInit) {
+ ExecOnce();
+ fIsInit = 1;
+ }
+
+ DetermineCent();
+
+ Double_t rho = GetRhoFactor(fCent);
+ fRho->SetVal(rho);
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskRhoBase::DetermineCent()
+{
+ // Determine centrality.
+
+ fCent = 99;
+
+ if (fDoCent) {
+ AliCentrality *centrality = InputEvent()->GetCentrality();
+
+ if (centrality)
+ fCent = centrality->GetCentralityPercentile("V0M");
+ else
+ fCent = 99; // probably pp data
+
+ if (fCent < 0) {
+ AliWarning(Form("%s: Centrality negative: %f, assuming 99", GetName(), fCent));
+ fCent = 99;
+ }
+ }
+}
+
+//________________________________________________________________________
+void AliAnalysisTaskRhoBase::ExecOnce()
+{
+ // Initialize some settings that need to be determined in UserExec.
+
+ // add rho to event if not yet there
+ if (!(InputEvent()->FindListObject(fRhoName))) {
+ InputEvent()->AddObject(fRho);
+ } else {
+ AliFatal(Form("%s: Container with same name %s already present. Aborting", GetName(), fRhoName.Data()));
+ return;
+ }
+
+ // determine if centrality should be used
+ TString bt(GetBeamType());
+ if (bt == "A-A")
+ fDoCent = 1;
+ else fDoCent = 0;
}
//_____________________________________________________
// ESDs have it directly, AODs get it from hardcoded run number ranges
AliVEvent *event = InputEvent();
-
if (!event) {
- AliError("Couldn't retrieve event!");
+ AliError(Form("%s: Couldn't retrieve event!", GetName()));
return "";
}
if (esd) {
const AliESDRun *run = esd->GetESDRun();
beamType = run->GetBeamType();
- }
- else
- {
+ } else {
Int_t runNumber = event->GetRunNumber();
if ((runNumber >= 136851 && runNumber <= 139517) || // LHC10h
- (runNumber >= 166529 && runNumber <= 170593)) // LHC11h
- {
+ (runNumber >= 166529 && runNumber <= 170593)) { // LHC11h
beamType = "A-A";
- }
- else
- {
+ } else {
beamType = "p-p";
}
}
}
//________________________________________________________________________
-void AliAnalysisTaskRhoBase::UserExec(Option_t *)
+Double_t AliAnalysisTaskRhoBase::GetRhoFactor(Double_t cent)
{
- // Main loop, called for each event.
-
- // add rho to event if not yet there
- if (!(InputEvent()->FindListObject(fRhoName))) {
- InputEvent()->AddObject(fRho);
- }
-
- // determine centrality
- fCent = 99;
-
- if (GetBeamType() == "A-A") {
- AliCentrality *centrality = InputEvent()->GetCentrality();
-
- if (centrality)
- fCent = centrality->GetCentralityPercentile("V0M");
- else
- fCent = 99; // probably pp data
-
- if (fCent < 0) {
- AliWarning(Form("Centrality negative: %f, assuming 99", fCent));
- fCent = 99;
- }
- }
-
- Double_t rhochem = GetRhoFactor(fCent);
- fRho->SetVal(rhochem);
-}
+ // Return rho per centrality.
-//________________________________________________________________________
-void AliAnalysisTaskRhoBase::Terminate(Option_t *)
-{
- // Run at the end of the task.
+ Double_t rho = -1;
+ if (fRhoFunction)
+ rho = fRhoFunction->Eval(cent);
+ return rho;
}
virtual void UserExec(Option_t*);
virtual void Terminate(Option_t*);
+ const char *GetRhoName() const { return fRhoName ; }
void SetRhoFunction(TF1* rf) { fRhoFunction = rf ; }
void SetRhoName(const char *name) { fRhoName = name ; }
-
+
protected:
- virtual Double_t GetRhoFactor(Double_t cent);
+ virtual void DetermineCent();
+ virtual void ExecOnce();
TString GetBeamType();
+ virtual Double_t GetRhoFactor(Double_t cent);
TString fRhoName; // name of rho
TF1 *fRhoFunction; // pre-computed rho as a function of centrality
Double_t fCent; //!event centrality
AliRhoParameter *fRho; //!per event calculated rho
+ Bool_t fDoCent; //!==1 then do centrality
+ Bool_t fIsInit; //!==1 then do init
AliAnalysisTaskRhoBase(const AliAnalysisTaskRhoBase&); // not implemented
AliAnalysisTaskRhoBase& operator=(const AliAnalysisTaskRhoBase&); // not implemented
- ClassDef(AliAnalysisTaskRhoBase, 2); // Rho base task
+ ClassDef(AliAnalysisTaskRhoBase, 3); // Rho base task
};
#endif