fMinEventPlane(-10),
fMaxEventPlane(10),
fCentEst("V0M"),
- fTrackBitMap(0),
- fClusterBitMap(0),
- fMCTrackBitMap(0),
- fMCClusterBitMap(0),
fIsEmbedded(kFALSE),
fIsPythia(kFALSE),
fSelectPtHardBin(-999),
fMinEventPlane(-10),
fMaxEventPlane(10),
fCentEst("V0M"),
- fTrackBitMap(0),
- fClusterBitMap(0),
- fMCTrackBitMap(0),
- fMCClusterBitMap(0),
fIsEmbedded(kFALSE),
fIsPythia(kFALSE),
fSelectPtHardBin(-999),
}
return cont->AcceptParticle(track);
-
- if (!track)
- return kFALSE;
-
-}
-
-//________________________________________________________________________
-Bool_t AliAnalysisTaskEmcalDev::AcceptEmcalPart(AliEmcalParticle *part) const
-{
- // Return true if EMCal particle is accepted.
-
- if (!part)
- return kFALSE;
-
- if (part->IsTrack()) {
- if (part->IsMC()) {
- if (part->TestBits(fMCTrackBitMap) != (Int_t)fMCTrackBitMap)
- return kFALSE;
- }
- else {
- if (part->TestBits(fTrackBitMap) != (Int_t)fTrackBitMap)
- return kFALSE;
- }
-
- if (part->Pt() < fTrackPtCut)
- return kFALSE;
-
- if (part->Eta() < fTrackMinEta || part->Eta() > fTrackMaxEta ||
- part->Phi() < fTrackMinPhi || part->Phi() > fTrackMaxPhi)
- return kFALSE;
- }
-
- if (part->IsCluster()) {
- if (part->IsMC(fMinMCLabel)) {
- if (part->TestBits(fMCClusterBitMap) != (Int_t)fMCClusterBitMap)
- return kFALSE;
- }
- else {
- if (part->TestBits(fClusterBitMap) != (Int_t)fClusterBitMap)
- return kFALSE;
- }
-
- if (!part->IsEMCAL())
- return kFALSE;
-
- if (part->Pt() < fClusPtCut)
- return kFALSE;
- }
-
- return kTRUE;
}
//________________________________________________________________________
//Load all requested track branches - each container knows name already
for(Int_t i =0; i<fParticleCollArray.GetEntriesFast(); i++) {
AliParticleContainer *cont = static_cast<AliParticleContainer*>(fParticleCollArray.At(i));
- cont->SetParticleArray(InputEvent());
+ cont->SetArray(InputEvent());
}
if (fParticleCollArray.GetEntriesFast()>0) {
//Load all requested cluster branches - each container knows name already
for(Int_t i =0; i<fClusterCollArray.GetEntriesFast(); i++) {
AliClusterContainer *cont = static_cast<AliClusterContainer*>(fClusterCollArray.At(i));
- cont->SetClusterArray(InputEvent());
+ cont->SetArray(InputEvent());
}
if(fClusterCollArray.GetEntriesFast()>0) {
void SetMinPtTrackInEmcal(Double_t min) { fMinPtTrackInEmcal = min ; }
void SetEventPlaneVsEmcal(Double_t ep) { fEventPlaneVsEmcal = ep ; }
void SetCentralityEstimator(const char *c) { fCentEst = c ; }
- void SetTrackBitMap(UInt_t m) { fTrackBitMap = m ; }
- void SetClusterBitMap(UInt_t m) { fClusterBitMap = m ; }
- void SetParticleBitMap(UInt_t m) { fClusterBitMap = m ; fTrackBitMap = m ; }
- void SetMCTrackBitMap(UInt_t m) { fMCTrackBitMap = m ; }
- void SetMCClusterBitMap(UInt_t m) { fMCClusterBitMap = m ; }
- void SetMCParticleBitMap(UInt_t m) { fMCClusterBitMap = m ; fMCTrackBitMap = m ; }
void SetMinMCLabel(Int_t s) { fMinMCLabel = s ; }
void SetIsEmbedded(Bool_t i) { fIsEmbedded = i ; }
void SetIsPythia(Bool_t i) { fIsPythia = i ; }
protected:
Bool_t AcceptCluster(AliVCluster *clus, Int_t c = 0) const;
- Bool_t AcceptEmcalPart(AliEmcalParticle *part) const;
Bool_t AcceptTrack(AliVParticle *track, Int_t c = 0) const;
virtual void ExecOnce();
virtual Bool_t FillGeneralHistograms();
Double_t fMinEventPlane; // minimum event plane value
Double_t fMaxEventPlane; // maximum event plane value
TString fCentEst; // name of V0 centrality estimator
- UInt_t fTrackBitMap; // bit map of accepted tracks (non MC)
- UInt_t fClusterBitMap; // bit map of accepted clusters (non MC)
- UInt_t fMCTrackBitMap; // bit map of accepted MC tracks
- UInt_t fMCClusterBitMap; // bit map of accepted MC clusters
Bool_t fIsEmbedded; // trigger, embedded signal
Bool_t fIsPythia; // trigger, if it is a PYTHIA production
Int_t fSelectPtHardBin; // select one pt hard bin for analysis
{
// Default constructor.
+ fClassName = "AliVCluster";
}
//________________________________________________________________________
{
// Standard constructor.
+ fClassName = "AliVCluster";
}
//________________________________________________________________________
-void AliClusterContainer::SetClusterArray(AliVEvent *event)
-{
- // Set jet array
-
- SetArray(event, "AliVCluster");
-}
-
-//________________________________________________________________________
-AliVCluster* AliClusterContainer::GetLeadingCluster(const char* opt) const
+AliVCluster* AliClusterContainer::GetLeadingCluster(const char* opt)
{
// Get the leading cluster; use e if "e" is contained in opt (otherwise et)
TString option(opt);
option.ToLower();
+ Int_t tempID = fCurrentID;
+
AliVCluster *clusterMax = GetNextAcceptCluster(0);
AliVCluster *cluster = 0;
}
}
+ fCurrentID = tempID;
+
return clusterMax;
}
}
//________________________________________________________________________
-AliVCluster* AliClusterContainer::GetNextAcceptCluster(Int_t i) const {
+AliVCluster* AliClusterContainer::GetNextAcceptCluster(Int_t i) {
//Get next accepted cluster; if i >= 0 (re)start counter from i; return 0 if no accepted particle could be found
- static Int_t counter = -1;
- if (i>=0) counter = i;
+ if (i>=0) fCurrentID = i;
const Int_t n = GetNEntries();
AliVCluster *c = 0;
- while (counter < n && !c) {
- c = GetAcceptCluster(counter);
- counter++;
+ while (fCurrentID < n && !c) {
+ c = GetAcceptCluster(fCurrentID);
+ fCurrentID++;
}
return c;
return kTRUE;
}
+
+//________________________________________________________________________
+void AliClusterContainer::SetClassName(const char *clname)
+{
+ // Set the class name
+
+ TClass cls(clname);
+ if (cls.InheritsFrom("AliVCluster")) fClassName = clname;
+ else AliError(Form("Unable to set class name %s for a AliClusterContainer, it must inherits from AliVCluster!",clname));
+}
AliClusterContainer(const char *name);
virtual ~AliClusterContainer(){;}
- void SetClusterArray(AliVEvent *event);
-
void SetClusPtCut(Double_t cut) { fClusPtCut = cut ; }
void SetClusTimeCut(Double_t min, Double_t max) { fClusTimeCutLow = min ; fClusTimeCutUp = max ; }
void SetClusterBitMap(UInt_t m) { fClusterBitMap = m ; }
void SetMCClusterBitMap(UInt_t m) { fMCClusterBitMap = m ; }
void SetMinMCLabel(Int_t s) { fMinMCLabel = s ; }
- AliVCluster *GetLeadingCluster(const char* opt="") const;
+ AliVCluster *GetLeadingCluster(const char* opt="") ;
AliVCluster *GetCluster(Int_t i) const;
AliVCluster *GetAcceptCluster(Int_t i) const;
- AliVCluster *GetNextAcceptCluster(Int_t i=-1) const;
+ AliVCluster *GetNextAcceptCluster(Int_t i=-1) ;
void GetMomentum(TLorentzVector &mom, Int_t i) const;
Bool_t AcceptCluster(AliVCluster *vp) const;
Int_t GetNClusters() const {return GetNEntries();}
+ void SetClassName(const char *clname);
protected:
Double_t fClusPtCut; // cut on cluster pt
#include <TClonesArray.h>
+#include "AliParticleContainer.h"
#include "AliEmcalParticle.h"
#include "AliLog.h"
#include "AliPicoTrack.h"
// Destructor.
}
+//________________________________________________________________________
+void AliEmcalClusTrackMatcherTask::ExecOnce()
+{
+ // Initialize the analysis.
+
+ if (fParticleCollArray.GetEntriesFast()<2) {
+ AliError(Form("Wrong number of particle collections (%d), required 2",fParticleCollArray.GetEntriesFast()));
+ return;
+ }
+
+ for (Int_t i = 0; i < 2; i++) {
+ AliParticleContainer *cont = static_cast<AliParticleContainer*>(fParticleCollArray.At(i));
+ cont->SetClassName("AliEmcalParticle");
+ }
+
+ AliAnalysisTaskEmcalDev::ExecOnce();
+}
+
//________________________________________________________________________
void AliEmcalClusTrackMatcherTask::UserCreateOutputObjects()
{
{
// Run the matching for the selected options.
- const Double_t maxd2 = fMaxDistance*fMaxDistance;
+ AliParticleContainer *tracks = static_cast<AliParticleContainer*>(fParticleCollArray.At(0));
+ AliParticleContainer *clusters = static_cast<AliParticleContainer*>(fParticleCollArray.At(1));
- const Int_t nC = fCaloClusters->GetEntries();
- const Int_t nT = fTracks->GetEntries();
+ const Double_t maxd2 = fMaxDistance*fMaxDistance;
// set the links between tracks and clusters
- for (Int_t c = 0; c < nC; ++c) {
- AliEmcalParticle *partC = static_cast<AliEmcalParticle*>(fCaloClusters->At(c));
- if (!partC)
- continue;
- if (!AcceptEmcalPart(partC))
- continue;
- AliVCluster *clust = partC->GetCluster();
+ AliEmcalParticle *partC = 0;
+ AliEmcalParticle *partT = 0;
- for (Int_t t = 0; t < nT; ++t) {
- AliEmcalParticle *partT = static_cast<AliEmcalParticle*>(fTracks->At(t));
- if (!partT)
- continue;
- if (!AcceptEmcalPart(partT))
- continue;
- AliVTrack *track = partT->GetTrack() ;
+ clusters->ResetCurrentID();
+ while ((partC = static_cast<AliEmcalParticle*>(clusters->GetNextAcceptParticle()))) {
+ AliVCluster *clust = partC->GetCluster();
+ tracks->ResetCurrentID();
+ while ((partT = static_cast<AliEmcalParticle*>(tracks->GetNextAcceptParticle()))) {
+ AliVTrack *track = partT->GetTrack();
Double_t deta = 999;
Double_t dphi = 999;
AliPicoTrack::GetEtaPhiDiff(track, clust, dphi, deta);
continue;
Double_t d = TMath::Sqrt(d2);
- partC->AddMatchedObj(t, d);
- partT->AddMatchedObj(c, d);
+ partC->AddMatchedObj(tracks->GetCurrentID(), d);
+ partT->AddMatchedObj(clusters->GetCurrentID(), d);
if (fCreateHisto) {
Int_t mombin = GetMomBin(track->P());
}
}
- for (Int_t c = 0; c < nC; ++c) {
- AliEmcalParticle *partC = static_cast<AliEmcalParticle*>(fCaloClusters->At(c));
- if (!partC)
- continue;
+
+ clusters->ResetCurrentID();
+ while ((partC = static_cast<AliEmcalParticle*>(clusters->GetNextAcceptParticle()))) {
if (partC->GetNumberOfMatchedObj() <= 0)
continue;
const UInt_t matchedId = partC->GetMatchedObjId();
- AliEmcalParticle *partT = static_cast<AliEmcalParticle*>(fTracks->At(matchedId));
+ partT = static_cast<AliEmcalParticle*>(tracks->GetParticle(matchedId));
AliVCluster *clust = partC->GetCluster();
AliVTrack *track = partT->GetTrack() ;
Double_t deta = 999;
clust->SetEmcCpvDistance(matchedId);
clust->SetTrackDistance(deta, dphi);
}
-
- for (Int_t t = 0; t < nT; ++t) {
- AliEmcalParticle *partT = static_cast<AliEmcalParticle*>(fTracks->At(t));
- if (!partT)
- continue;
+
+ tracks->ResetCurrentID();
+ while ((partT = static_cast<AliEmcalParticle*>(tracks->GetNextAcceptParticle()))) {
if (partT->GetNumberOfMatchedObj() <= 0)
continue;
AliVTrack *track = partT->GetTrack();
void SetMaxDistance(Double_t d) { fMaxDistance = d; }
protected:
-
+ void ExecOnce() ;
Bool_t Run();
Int_t GetMomBin(Double_t p) const;
AliEmcalClusTrackMatcherTask(const AliEmcalClusTrackMatcherTask&); // not implemented
AliEmcalClusTrackMatcherTask &operator=(const AliEmcalClusTrackMatcherTask&); // not implemented
- ClassDef(AliEmcalClusTrackMatcherTask, 4) // Cluster-Track matching task
+ ClassDef(AliEmcalClusTrackMatcherTask, 5) // Cluster-Track matching task
};
#endif
AliEmcalContainer::AliEmcalContainer():
TNamed("AliEmcalContainer","AliEmcalContainer"),
fClArray(0),
- fClArrayName()
+ fClArrayName(),
+ fClassName(),
+ fCurrentID(0)
{
// Default constructor.
AliEmcalContainer::AliEmcalContainer(const char *name):
TNamed(name,name),
fClArray(0),
- fClArrayName()
+ fClArrayName(),
+ fClassName(),
+ fCurrentID(0)
{
// Standard constructor.
}
//________________________________________________________________________
-void AliEmcalContainer::SetArray(AliVEvent *event, const char *clname) {
-
+void AliEmcalContainer::SetArray(AliVEvent *event)
+{
// Get array from event.
const AliVVertex *vertex = event->GetPrimaryVertex();
if (!fClArrayName.IsNull() && !fClArray) {
fClArray = dynamic_cast<TClonesArray*>(event->FindListObject(fClArrayName));
if (!fClArray) {
- AliWarning(Form("%s: Could not retrieve array with name %s!", GetName(), fClArrayName.Data()));
+ AliError(Form("%s: Could not retrieve array with name %s!", GetName(), fClArrayName.Data()));
return;
}
} else {
return;
}
- if (!clname)
- return;
-
- TString objname(fClArray->GetClass()->GetName());
- TClass cls(objname);
- if (!cls.InheritsFrom(clname)) {
- AliWarning(Form("%s: Objects of type %s in %s are not inherited from %s!",
- GetName(), cls.GetName(), fClArrayName.Data(), clname));
- return;
+ if (!fClassName.IsNull()) {
+ TString objname(fClArray->GetClass()->GetName());
+ TClass cls(objname);
+ if (!cls.InheritsFrom(fClassName)) {
+ AliError(Form("%s: Objects of type %s in %s are not inherited from %s!",
+ GetName(), cls.GetName(), fClArrayName.Data(), fClassName.Data()));
+ fClArray = 0;
+ }
}
- return;
}
TClonesArray *GetArray() {return fClArray;}
Int_t GetNEntries() const {return fClArray->GetEntriesFast();}
const TString& GetArrayName() const {return fClArrayName;}
+ Int_t GetCurrentID() const {return fCurrentID-1; }
void SortArray() {fClArray->Sort();}
virtual void GetMomentum(TLorentzVector &mom, Int_t i) const = 0;
+ virtual void SetArray(AliVEvent *event);
+ void ResetCurrentID(Int_t i=0) {fCurrentID = i;}
protected:
- void SetArray(AliVEvent *event, const char *clname=0);
TClonesArray *fClArray; //!TClonesArray
Double_t fVertex[3]; //!event vertex array
TString fClArrayName; // name of branch
+ TString fClassName; // name of the class in the TClonesArray
+ Int_t fCurrentID; //!current ID for automatic loops
private:
AliEmcalContainer(const AliEmcalContainer& obj); // copy constructor
AliEmcalContainer& operator=(const AliEmcalContainer& other); // assignment
- ClassDef(AliEmcalContainer,1);
+ ClassDef(AliEmcalContainer,2);
};
{
// Default constructor.
+ fClassName = "AliVParticle";
}
//________________________________________________________________________
{
// Standard constructor.
+ fClassName = "AliVParticle";
}
//________________________________________________________________________
-void AliParticleContainer::SetParticleArray(AliVEvent *event)
-{
- // Set jet array
-
- SetArray(event, "AliVParticle");
-}
-
-//________________________________________________________________________
-AliVParticle* AliParticleContainer::GetLeadingParticle(const char* opt) const
+AliVParticle* AliParticleContainer::GetLeadingParticle(const char* opt)
{
// Get the leading particle; use p if "p" is contained in opt
TString option(opt);
option.ToLower();
+ Int_t tempID = fCurrentID;
+
AliVParticle *partMax = GetNextAcceptParticle(0);
AliVParticle *part = 0;
}
}
+ fCurrentID = tempID;
+
return partMax;
}
}
//________________________________________________________________________
-AliVParticle* AliParticleContainer::GetNextAcceptParticle(Int_t i) const {
+AliVParticle* AliParticleContainer::GetNextAcceptParticle(Int_t i) {
//Get next accepted particle; if i >= 0 (re)start counter from i; return 0 if no accepted particle could be found
- static Int_t counter = -1;
- if (i>=0) counter = i;
+ if (i>=0) fCurrentID = i;
const Int_t n = GetNEntries();
AliVParticle *p = 0;
- while (counter < n && !p) {
- p = GetAcceptParticle(counter);
- counter++;
+ while (fCurrentID < n && !p) {
+ p = GetAcceptParticle(fCurrentID);
+ fCurrentID++;
}
return p;
return kTRUE;
}
+
+//________________________________________________________________________
+void AliParticleContainer::SetClassName(const char *clname)
+{
+ // Set the class name
+
+ TClass cls(clname);
+ if (cls.InheritsFrom("AliVParticle")) fClassName = clname;
+ else AliError(Form("Unable to set class name %s for a AliParticleContainer, it must inherits from AliVParticle!",clname));
+}
AliParticleContainer(const char *name);
virtual ~AliParticleContainer(){;}
- void SetParticleArray(AliVEvent *event);
-
void SetParticlePtCut(Double_t cut) { fParticlePtCut = cut ; }
void SetParticleEtaLimits(Double_t min, Double_t max) { fParticleMaxEta = max ; fParticleMinEta = min ; }
void SetParticlePhiLimits(Double_t min, Double_t max) { fParticleMaxPhi = max ; fParticleMinPhi = min ; }
void SetMCTrackBitMap(UInt_t m) { fMCTrackBitMap = m ; }
void SetMinMCLabel(Int_t s) { fMinMCLabel = s ; }
- AliVParticle *GetLeadingParticle(const char* opt="") const;
+ AliVParticle *GetLeadingParticle(const char* opt="") ;
AliVParticle *GetParticle(Int_t i) const;
AliVParticle *GetAcceptParticle(Int_t i) const;
- AliVParticle *GetNextAcceptParticle(Int_t i=-1) const;
+ AliVParticle *GetNextAcceptParticle(Int_t i=-1) ;
void GetMomentum(TLorentzVector &mom, Int_t i) const;
Bool_t AcceptParticle(AliVParticle *vp) const;
Int_t GetNParticles() const {return GetNEntries();}
+ void SetClassName(const char *clname);
protected:
Double_t fParticlePtCut; // cut on particle pt
//-------------------------------------------------------
TString name(Form("ClusTrackMatcher_%s_%s",nTracks,nClusters));
AliEmcalClusTrackMatcherTask* matcher = new AliEmcalClusTrackMatcherTask(name, createHisto);
- matcher->SetTracksName(nTracks);
- matcher->SetClusName(nClusters);
+ matcher->AddParticleContainer(nTracks);
+ matcher->AddParticleContainer(nClusters);
matcher->SetMaxDistance(maxDist);
//-------------------------------------------------------
AliAnalysisTaskEmcalDev::ExecOnce();
- //Load all requested track branches - each container knows name already
+ if (!fRhoName.IsNull() && !fRho) { // get rho from the event
+ fRho = dynamic_cast<AliRhoParameter*>(InputEvent()->FindListObject(fRhoName));
+ if (!fRho) {
+ AliError(Form("%s: Could not retrieve rho %s!", GetName(), fRhoName.Data()));
+ fInitialized = kFALSE;
+ return;
+ }
+ }
+
+ //Load all requested jet branches - each container knows name already
if(fJetCollArray.GetEntriesFast()==0) {
AliWarning("There are no jet collections");
return;
AliJetContainer *cont = static_cast<AliJetContainer*>(fJetCollArray.At(i));
cont->SetRunNumber(InputEvent()->GetRunNumber());
cont->SetEMCALGeometry();
- cont->SetJetArray(InputEvent());
+ cont->SetArray(InputEvent());
cont->LoadRho(InputEvent());
}
}
}
- if (fRhoName.IsNull()) { // if rho name is not provided, tries to use the rho object of the first jet branch
+ if (!fRho) { // if rho name is not provided, tries to use the rho object of the first jet branch
fRhoName = cont->GetRhoName();
- if(!cont->GetRhoName().IsNull()) {
- fRho = cont->GetRhoParameter();
- if(!fRho) {
- AliError(Form("%s: Could not retrieve rho of first jet branch!", GetName()));
- fInitialized = kFALSE;
- return;
- }
- }
- }
- else { // get rho from the event
- fRho = dynamic_cast<AliRhoParameter*>(InputEvent()->FindListObject(fRhoName));
- if (!fRho) {
- AliError(Form("%s: Could not retrieve rho %s!", GetName(), fRhoName.Data()));
- return;
- }
+ fRho = cont->GetRhoParameter();
}
}
{
// Default constructor.
+ fClassName = "AliEmcalJet";
}
//________________________________________________________________________
{
// Standard constructor.
+ fClassName = "AliEmcalJet";
}
//________________________________________________________________________
-void AliJetContainer::SetJetArray(AliVEvent *event)
+void AliJetContainer::SetArray(AliVEvent *event)
{
// Set jet array
- SetArray(event, "AliEmcalJet");
+ AliEmcalContainer::SetArray(event);
if(fJetAcceptanceType==kTPC) {
AliDebug(2,Form("%s: set TPC acceptance cuts",GetName()));
}
//________________________________________________________________________
-AliEmcalJet* AliJetContainer::GetLeadingJet(const char* opt) const
+AliEmcalJet* AliJetContainer::GetLeadingJet(const char* opt)
{
// Get the leading jet; if opt contains "rho" the sorting is according to pt-A*rho
TString option(opt);
option.ToLower();
+ Int_t tempID = fCurrentID;
+
AliEmcalJet *jetMax = GetNextAcceptJet(0);
AliEmcalJet *jet = 0;
}
}
+ fCurrentID = tempID;
+
return jetMax;
}
}
//________________________________________________________________________
-AliEmcalJet* AliJetContainer::GetNextAcceptJet(Int_t i) const {
+AliEmcalJet* AliJetContainer::GetNextAcceptJet(Int_t i) {
//Get next accepted jet; if i >= 0 (re)start counter from i; return 0 if no accepted jet could be found
- static Int_t counter = -1;
- if (i>=0) counter = i;
+ if (i>=0) fCurrentID = i;
const Int_t njets = GetNEntries();
AliEmcalJet *jet = 0;
- while (counter < njets && !jet) {
- jet = GetAcceptJet(counter);
- counter++;
+ while (fCurrentID < njets && !jet) {
+ jet = GetAcceptJet(fCurrentID);
+ fCurrentID++;
}
return jet;
fLeadingHadronType = 0;
}
+
+//________________________________________________________________________
+void AliJetContainer::SetClassName(const char *clname)
+{
+ // Set the class name
+
+ TClass cls(clname);
+ if (cls.InheritsFrom("AliEmcalJet")) fClassName = clname;
+ else AliError(Form("Unable to set class name %s for a AliJetContainer, it must inherits from AliEmcalJet!",clname));
+}
AliJetContainer(const char *name);
virtual ~AliJetContainer() {;}
- void SetJetArray(AliVEvent *event);
void SetEMCALGeometry();
void SetEMCALGeometry(AliEMCALGeometry *p) {fGeom = p;}
void LoadRho(AliVEvent *event);
void SetParticleContainer(AliParticleContainer *c) { fParticleContainer = c ; }
void SetClusterContainer(AliClusterContainer *c) { fClusterContainer = c ; }
- AliEmcalJet *GetLeadingJet(const char* opt="") const;
+ AliEmcalJet *GetLeadingJet(const char* opt="") ;
AliEmcalJet *GetJet(Int_t i) const;
AliEmcalJet *GetAcceptJet(Int_t i) const;
- AliEmcalJet *GetNextAcceptJet(Int_t i=-1) const;
+ AliEmcalJet *GetNextAcceptJet(Int_t i=-1) ;
void GetMomentum(TLorentzVector &mom, Int_t i) const;
Bool_t AcceptJet(AliEmcalJet* jet) const;
Bool_t AcceptBiasJet(AliEmcalJet* jet) const;
Float_t GetJetEtaMax() const {return fJetMaxEta;}
Float_t GetJetPhiMin() const {return fJetMinPhi;}
Float_t GetJetPhiMax() const {return fJetMaxPhi;}
+ void SetClassName(const char *clname);
+ void SetArray(AliVEvent *event);
protected:
JetAcceptanceType fJetAcceptanceType; // acceptance type
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff