#include "AliLog.h"
#include "AliPicoTrack.h"
#include "AliVTrack.h"
+#include "AliAODMCParticle.h"
ClassImp(AliEmcalPicoTrackMaker)
AliAnalysisTaskSE("AliEmcalPicoTrackMaker"),
fTracksOutName("PicoTracks"),
fTracksInName("tracks"),
+ fMCParticlesName("mcparticles"),
fMinTrackPt(0),
fMaxTrackPt(1000),
fMinTrackEta(-10),
fMinTrackPhi(-10),
fMaxTrackPhi(10),
fTrackEfficiency(1),
+ fCopyMCFlag(kFALSE),
fTracksIn(0),
- fTracksOut(0)
+ fTracksOut(0),
+ fMCParticles(0),
+ fInit(kFALSE)
{
// Constructor.
AliAnalysisTaskSE(name),
fTracksOutName("PicoTracks"),
fTracksInName("tracks"),
+ fMCParticlesName("mcparticles"),
fMinTrackPt(0),
fMaxTrackPt(1000),
fMinTrackEta(-10),
fMinTrackPhi(-10),
fMaxTrackPhi(10),
fTrackEfficiency(1),
+ fCopyMCFlag(kFALSE),
fTracksIn(0),
- fTracksOut(0)
+ fTracksOut(0),
+ fMCParticles(0),
+ fInit(kFALSE)
{
// Constructor.
void AliEmcalPicoTrackMaker::UserCreateOutputObjects()
{
// Create my user objects.
-
- fTracksOut = new TClonesArray("AliPicoTrack");
- fTracksOut->SetName(fTracksOutName);
}
//________________________________________________________________________
{
// Main loop, called for each event.
- AliAnalysisManager *am = AliAnalysisManager::GetAnalysisManager();
- if (!am) {
- AliError("Manager zero, returning");
- return;
- }
-
- // retrieve tracks from input.
- if (!fTracksIn) {
+ if (!fInit) {
fTracksIn = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fTracksInName));
if (!fTracksIn) {
AliError(Form("Could not retrieve tracks %s!", fTracksInName.Data()));
AliError(Form("%s: Collection %s does not contain AliVParticle objects!", GetName(), fTracksInName.Data()));
return;
}
+
+ fTracksOut = new TClonesArray("AliPicoTrack");
+ fTracksOut->SetName(fTracksOutName);
+
+ // add tracks to event if not yet there
+ if (InputEvent()->FindListObject(fTracksOutName)) {
+ AliFatal(Form("Object %s already present in the event!",fTracksOutName.Data()));
+ }
+ else {
+ InputEvent()->AddObject(fTracksOut);
+ }
+
+ if (fCopyMCFlag) {
+ fMCParticles = dynamic_cast<TClonesArray*>(InputEvent()->FindListObject(fMCParticlesName));
+ if (!fMCParticles) {
+ AliError(Form("Could not retrieve MC particles %s!", fMCParticlesName.Data()));
+ }
+ if (!fMCParticles->GetClass()->GetBaseClass("AliVParticle")) {
+ AliError(Form("%s: Collection %s does not contain AliVParticle objects!", GetName(), fMCParticlesName.Data()));
+ fMCParticles = 0;
+ }
+ }
+
+ fInit = kTRUE;
}
- // add tracks to event if not yet there
fTracksOut->Delete();
- if (!(InputEvent()->FindListObject(fTracksOutName))) {
- InputEvent()->AddObject(fTracksOut);
- }
// loop over tracks
const Int_t Ntracks = fTracksIn->GetEntriesFast();
track->GetTrackPtOnEMCal(),
isEmc);
picotrack->SetTrack(track);
+
+ if (fCopyMCFlag && track->GetLabel() != 0) {
+ AliVParticle *mcpart = GetMCParticle(TMath::Abs(track->GetLabel()));
+ if (mcpart) {
+ UInt_t mcFlag = mcpart->GetFlag();
+ picotrack->SetFlag(mcFlag);
+ Short_t genIndex = mcpart->GetGeneratorIndex();
+ picotrack->SetGeneratorIndex(genIndex);
+ }
+ }
+
++nacc;
}
}
+
+//________________________________________________________________________
+AliVParticle* AliEmcalPicoTrackMaker::GetMCParticle(Int_t label)
+{
+ if (!fMCParticles) return 0;
+ AliVParticle *part = static_cast<AliVParticle*>(fMCParticles->At(label));
+ return part;
+}
#ifndef ALIEMCALPICOTRACKMAKER_H
#define ALIEMCALPICOTRACKMAKER_H
-// $Id: AliEmcalPicoTrackMaker.h | Fri Dec 6 10:29:04 2013 +0100 | Constantin Loizides $
-
class TClonesArray;
-class AliVTrack;
+class AliVParticle;
#include "AliAnalysisTaskSE.h"
void SetTrackPtLimits(Double_t min, Double_t max) { fMaxTrackPt = max ; fMinTrackPt = min ; }
void SetTracksInName(const char *name) { fTracksInName = name; }
void SetTracksOutName(const char *name) { fTracksOutName = name; }
+ void SetMCParticlesName(const char *name) { fMCParticlesName = name; }
+ void SetCopyMCFlag(Bool_t c, const char* name) { fCopyMCFlag = c ; fMCParticlesName = name; }
+
protected:
void UserCreateOutputObjects();
void UserExec(Option_t *option);
+ AliVParticle* GetMCParticle(Int_t label);
+
Int_t fAODfilterBits[2]; // AOD track filter bit map
TString fTracksOutName; // name of output track array
TString fTracksInName; // name of input track array
+ TString fMCParticlesName; // name of MC particle array, used by IsHIJINGParticle
Double_t fMinTrackPt; // mix pt of tracks
Double_t fMaxTrackPt; // max pt of tracks
Double_t fMinTrackEta; // cut on track eta
Double_t fMinTrackPhi; // cut on track phi
Double_t fMaxTrackPhi; // cut on track phi
Double_t fTrackEfficiency; // track efficiency
+ Bool_t fCopyMCFlag; // copy MC flag
TClonesArray *fTracksIn; //!track array in
TClonesArray *fTracksOut; //!track array out
+ TClonesArray *fMCParticles; //!MC particle array, used by IsHIJINGParticle
+ Bool_t fInit; //!true = task initialized
private:
AliEmcalPicoTrackMaker(const AliEmcalPicoTrackMaker&); // not implemented
AliEmcalPicoTrackMaker &operator=(const AliEmcalPicoTrackMaker&); // not implemented
- ClassDef(AliEmcalPicoTrackMaker, 7); // Task to make PicoTracks in AOD/ESD events
+ ClassDef(AliEmcalPicoTrackMaker, 8); // Task to make PicoTracks in AOD/ESD events
};
#endif
-// $Id$
//
// Track class with minimal number of information
// (targets at selection of primary tracks).
AliPicoTrack::AliPicoTrack() :
AliVTrack(),
fPt(0), fEta(0), fPhi(0), fM(0.13957), fQ(0), fLabel(-1), fTrackType(0),
- fEtaEmc(0), fPhiEmc(0), fPtEmc(0), fEmcal(0), fClusId(-1), fOrig(0)
+ fEtaEmc(0), fPhiEmc(0), fPtEmc(0), fEmcal(0), fFlag(0), fGeneratorIndex(-1), fClusId(-1), fOrig(0)
{
// Default constructor.
}
Double_t etaemc, Double_t phiemc, Double_t ptemc, Bool_t ise, Double_t mass) :
AliVTrack(),
fPt(pt), fEta(eta), fPhi(phi), fM(mass), fQ(q), fLabel(lab), fTrackType(type),
- fEtaEmc(etaemc), fPhiEmc(phiemc), fPtEmc(ptemc), fEmcal(ise), fClusId(-1), fOrig(0)
+ fEtaEmc(etaemc), fPhiEmc(phiemc), fPtEmc(ptemc), fEmcal(ise), fFlag(0), fGeneratorIndex(-1), fClusId(-1), fOrig(0)
{
// Constructor.
}
AliVTrack(pc),
fPt(pc.fPt), fEta(pc.fEta), fPhi(pc.fPhi), fM(pc.fM),
fQ(pc.fQ), fLabel(pc.fLabel), fTrackType(pc.fTrackType),
- fEtaEmc(pc.fEtaEmc), fPhiEmc(pc.fPhiEmc), fPtEmc(pc.fPtEmc), fEmcal(pc.fEmcal),
+ fEtaEmc(pc.fEtaEmc), fPhiEmc(pc.fPhiEmc), fPtEmc(pc.fPtEmc), fEmcal(pc.fEmcal), fFlag(pc.fFlag), fGeneratorIndex(pc.fGeneratorIndex),
fClusId(pc.fClusId), fOrig(pc.fOrig)
{
// Constructor.
fPhiEmc = pc.fPhiEmc;
fPtEmc = pc.fPtEmc;
fEmcal = pc.fEmcal;
+ fFlag = pc.fFlag;
+ fGeneratorIndex = pc.fGeneratorIndex;
fClusId = pc.fClusId;
fOrig = pc.fOrig;
}
#ifndef AliPicoTrack_H
#define AliPicoTrack_H
-// $Id$
+#include <TMath.h>
#include "AliVTrack.h"
-#include <TMath.h>
+#include "AliAODMCParticle.h"
+
class AliVCluster;
class AliPicoTrack: public AliVTrack {
void Clear(Option_t * /*option*/ ="") { fClusId = -1; fOrig = 0; }
Int_t Compare(const TObject* obj) const;
Bool_t PropagateToDCA(const AliVVertex *, Double_t, Double_t, Double_t *, Double_t *) { return 0; }
+ void SetFlag(UInt_t flag) {fFlag = flag;}
+ UInt_t GetFlag() const {return fFlag;}
+ void SetPrimary(Bool_t b = kTRUE){
+ if(b)fFlag |= AliAODMCParticle::kPrimary;
+ else fFlag &= ~AliAODMCParticle::kPrimary;
+ }
+ Bool_t IsPrimary() const {return ((fFlag&AliAODMCParticle::kPrimary)==AliAODMCParticle::kPrimary);}
+
+ void SetPhysicalPrimary(Bool_t b = kTRUE){
+ if(b)fFlag |= AliAODMCParticle::kPhysicalPrim;
+ else fFlag &= ~AliAODMCParticle::kPhysicalPrim;
+ }
+ Bool_t IsPhysicalPrimary() const {return ((fFlag&AliAODMCParticle::kPhysicalPrim)==AliAODMCParticle::kPhysicalPrim);}
+
+ void SetSecondaryFromWeakDecay(Bool_t b = kTRUE){
+ if(b)fFlag |= AliAODMCParticle::kSecondaryFromWeakDecay;
+ else fFlag &= ~AliAODMCParticle::kSecondaryFromWeakDecay;
+ }
+ Bool_t IsSecondaryFromWeakDecay() const {return ((fFlag&AliAODMCParticle::kSecondaryFromWeakDecay)==AliAODMCParticle::kSecondaryFromWeakDecay);}
+
+ void SetSecondaryFromMaterial(Bool_t b = kTRUE){
+ if(b)fFlag |= AliAODMCParticle::kSecondaryFromMaterial;
+ else fFlag &= ~AliAODMCParticle::kSecondaryFromMaterial;
+ }
+ Bool_t IsSecondaryFromMaterial() const {return ((fFlag&AliAODMCParticle::kSecondaryFromMaterial)==AliAODMCParticle::kSecondaryFromMaterial);}
+
+ Bool_t IsFromHIJING() const { return (fGeneratorIndex == 0); }
+ void SetGeneratorIndex(Short_t i) {fGeneratorIndex = i;}
+ Short_t GetGeneratorIndex() const {return fGeneratorIndex;}
static void GetEtaPhiDiff(const AliVTrack *t, const AliVCluster *v, Double_t &phidiff, Double_t &etadiff);
static Byte_t GetTrackType(const AliVTrack *t);
protected:
- Double32_t fPt; //[0,0,12] pt at vertex
- Double32_t fEta; //[-1,1,12] eta at vertex
- Double32_t fPhi; //[0,6.3,12] phi at vertex
- Double32_t fM; // mass
- Byte_t fQ; // charge
- Int_t fLabel; // label
- Byte_t fTrackType;// 0=global track; 1=w/o SPD, w/ ITS refit; 2=w/o SPD, w/o ITS refit
- Double32_t fEtaEmc; //[-1,1,12] eta at emcal surface
- Double32_t fPhiEmc; //[0,6.3,12] phi at emcal surface
- Double32_t fPtEmc; //[0,0,12] pt at emcal surface
- Bool_t fEmcal; // is true if track propagated to emcal
- Short_t fClusId; //! cluster id of matched cluster; -1 if not set
- AliVTrack *fOrig; //! ptr to original track
+ Double32_t fPt; //[0,0,12] pt at vertex
+ Double32_t fEta; //[-1,1,12] eta at vertex
+ Double32_t fPhi; //[0,6.3,12] phi at vertex
+ Double32_t fM; // mass
+ Byte_t fQ; // charge
+ Int_t fLabel; // label
+ Byte_t fTrackType; // 0=global track; 1=w/o SPD, w/ ITS refit; 2=w/o SPD, w/o ITS refit
+ Double32_t fEtaEmc; //[-1,1,12] eta at emcal surface
+ Double32_t fPhiEmc; //[0,6.3,12] phi at emcal surface
+ Double32_t fPtEmc; //[0,0,12] pt at emcal surface
+ Bool_t fEmcal; // is true if track propagated to emcal
+ UInt_t fFlag; //! Flag for indication of primary etc (MC)
+ Short_t fGeneratorIndex; //! Index of generator in cocktail
+ Short_t fClusId; //! cluster id of matched cluster; -1 if not set
+ AliVTrack *fOrig; //! ptr to original track
- ClassDef(AliPicoTrack, 7) // Pico track class
+ ClassDef(AliPicoTrack, 8) // Pico track class
};
#endif
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff