999999.0, // up limit of vt
-999999.0, // centrality min
999999.0}; // centrality max
- Double_t cutsMuon[16]={-999999.0, // 0, min of 3-momentum
- 999999.0, // 1, max of 3-momnentum
- -999999.0, // 2, PtMin
- 999999.0, // 3, PtMax
- -999999.0, // 4, EtaMin
- 999999.0, // 5, EtaMax
- -999999.0, // 6, DCAmin
- 999999.0, // 7, DCAmax
- -999999.0, // 8, for trigger
- 999999.0, // 9, for trigger
- -999999.0, // 10, ThetaAbsEndMin
- 999999.0, // 11, ThetaAbsEndMax
- -999999.0, // 12, chi2 tracker Min
- 999999.0, // 13, chi2 tracker Max
- -999999.0, // 14, chi2 trigger Min
- 999999.0}; // 15, chi2 trigger Max
- Double_t cutsDimu[16]={-999999.0, 999999.0, // single muon cuts used for dimuon selection
- -999999.0, 999999.0,
- -999999.0, 999999.0,
- -999999.0, 999999.0,
- -999999.0, 999999.0,
- -999999.0, 999999.0,
- -999999.0, 999999.0,
- -999999.0, 999999.0};
- AliAnalysisTaskSEMuonsHF *taskMuonsHF = new AliAnalysisTaskSEMuonsHF("MuonsHF Analysis Task");
+ AliMuonTrackCuts *cutsMuon = new AliMuonTrackCuts("cutsMuon", "cutsMuon"); cutsMuon->SetIsMC(isMC);
+ AliMuonPairCuts *cutsDimu = new AliMuonPairCuts("cutsDimu", "cutsDimu"); cutsDimu->SetIsMC(isMC);
+ AliAnalysisTaskSEMuonsHF *taskMuonsHF = new AliAnalysisTaskSEMuonsHF("MuonsHF Analysis Task",*cutsMuon,*cutsDimu);
taskMuonsHF->SetAnaMode(mode);
taskMuonsHF->SetUseMC(isMC);
taskMuonsHF->SetIsOutputTree(isTree);
taskMuonsHF->SetEvsHCuts(cutsEvsH);
- taskMuonsHF->SetMuonCuts(cutsMuon);
- taskMuonsHF->SetDimuCuts(cutsDimu);
if (isSel) taskMuonsHF->SelectCollisionCandidates(AliVEvent::kMB | AliVEvent::kMUON);
mgr->AddTask(taskMuonsHF);
#include "AliDimuInfoStoreMC.h"
#include "AliAnalysisManager.h"
#include "AliInputEventHandler.h"
+#include "AliMuonTrackCuts.h"
+#include "AliMuonPairCuts.h"
#include "AliAnalysisTaskSEMuonsHF.h"
ClassImp(AliAnalysisTaskSEMuonsHF)
fAnaMode(0),
fIsOutputTree(kFALSE),
fIsMC(kFALSE),
+fCutsMuon(0x0),
+fCutsDimu(0x0),
fHeader(0),
fMuonClArr(0),
fDimuClArr(0),
}
//_____________________________________________________________________________
-AliAnalysisTaskSEMuonsHF::AliAnalysisTaskSEMuonsHF(const char *name) :
+AliAnalysisTaskSEMuonsHF::AliAnalysisTaskSEMuonsHF(const char *name, const AliMuonTrackCuts& cutsMuon, const AliMuonPairCuts& cutsDimu) :
AliAnalysisTaskSE(name),
fAnaMode(0),
fIsOutputTree(kFALSE),
fIsMC(kFALSE),
+fCutsMuon(new AliMuonTrackCuts(cutsMuon)),
+fCutsDimu(new AliMuonPairCuts(cutsDimu)),
fHeader(0),
fMuonClArr(0),
fDimuClArr(0),
//
// Default destructor
//
+ if (fCutsMuon) { delete fCutsMuon; fCutsMuon =NULL; }
+ if (fCutsDimu) { delete fCutsDimu; fCutsDimu =NULL; }
if (fHeader) { delete fHeader; fHeader =NULL; }
if (fMuonClArr) { delete fMuonClArr; fMuonClArr =NULL; }
if (fDimuClArr) { delete fDimuClArr; fDimuClArr =NULL; }
if (fAnaMode!=1) AddAODBranch("TClonesArray", &fDimuClArr);
}
+ fCutsMuon->Print("mask");
+ fCutsDimu->Print("mask");
return;
}
} else { AliError("MC event not found. Nothing done!"); return; }
}
+ if ( !fCutsMuon) { AliError("AliMuonTrackCuts should be loaded!"); return;}
+ if ((!fCutsDimu) && (fAnaMode!=1)) { AliError("AliMuonPairCuts should be loaded!"); return; }
+
Int_t ntrks = 0;
AliAODEvent *aod = 0;
AliESDEvent *esd = 0;
if (!aod) { AliError("AOD event not found. Nothing done!"); return; }
if (!fIsMC && (aod->GetHeader()->GetEventType()!=7)) return;
ntrks = aod->GetNTracks();
- fHeader->SetFiredTriggerClass(aod->GetFiredTriggerClasses());
} else {
esd = dynamic_cast<AliESDEvent*>(InputEvent());
if (!esd) { AliError("ESD event not found. Nothing done!"); return; }
if (!fIsMC && (esd->GetHeader()->GetEventType()!=7)) return;
ntrks = esd->GetNumberOfMuonTracks();
- fHeader->SetFiredTriggerClass(esd->GetFiredTriggerClasses());
- AliCentrality *cent = esd->GetCentrality();
- fHeader->SetCentrality(cent->GetCentralityPercentile("V0M")); // Just for ESD
- }
+ } if (fIsOutputTree) AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillAOD(kTRUE);
- if (fIsOutputTree) AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillAOD(kTRUE);
- if (fInputHandler && fInputHandler->GetEventSelection()) fHeader->SetSelectionMask(fInputHandler->IsEventSelected());
- fHeader->SetVertex(((AliVVertex*)InputEvent()->GetPrimaryVertex()));
+ fHeader->SetEventInfo(fInputHandler, MCEvent());
fHeader->FillHistosEvnH(fListOutput);
fMuonClArr->Delete();
TClonesArray &muonRef = *fMuonClArr;
Int_t countN = fMuonClArr->GetEntriesFast();
+ Int_t trkID[ntrks];
AliAODTrack *trkAOD = 0;
AliESDMuonTrack *trkESD = 0;
AliMuonInfoStoreRD *muonRD = 0;
if (aod) {
trkAOD = (AliAODTrack*)aod->GetTrack(itrk);
if (!trkAOD->IsMuonTrack()) { trkAOD=0; continue; }
- if (fIsMC) muonMC = new AliMuonInfoStoreMC(trkAOD, MCEvent());
- else muonRD = new AliMuonInfoStoreRD(trkAOD);
+ if (fIsMC) muonMC = new AliMuonInfoStoreMC(trkAOD,MCEvent(),fCutsMuon->GetSelectionMask(trkAOD));
+ else muonRD = new AliMuonInfoStoreRD(trkAOD,fCutsMuon->GetSelectionMask(trkAOD));
trkAOD = 0;
} else {
trkESD = (AliESDMuonTrack*)esd->GetMuonTrack(itrk);
if (!trkESD->ContainTrackerData()) { trkESD=0; continue; }
- if (fIsMC) muonMC = new AliMuonInfoStoreMC(trkESD, MCEvent());
- else muonRD = new AliMuonInfoStoreRD(trkESD);
+ if (fIsMC) muonMC = new AliMuonInfoStoreMC(trkESD,MCEvent(),fCutsMuon->GetSelectionMask(trkESD));
+ else muonRD = new AliMuonInfoStoreRD(trkESD,fCutsMuon->GetSelectionMask(trkESD));
trkESD = 0;
- }
-
- if (muonRD) {
+ } if (muonRD) {
new(muonRef[countN++]) AliMuonInfoStoreRD(*muonRD);
if (fAnaMode!=2) fHeader->FillHistosMuon(fListOutput, muonRD);
- }
- if (muonMC) {
+ } if (muonMC) {
new(muonRef[countN++]) AliMuonInfoStoreMC(*muonMC);
if (fAnaMode!=2) fHeader->FillHistosMuon(fListOutput, muonMC, muonMC->Source());
- }
+ } trkID[countN-1] = itrk;
if (muonRD) { delete muonRD; muonRD=0; }
if (muonMC) { delete muonMC; muonMC=0; }
} // end loop of all tracks
- aod = 0; esd = 0;
- if (fAnaMode==1) { PostData(1,fListOutput); return; }
+ if (fAnaMode==1) { aod=0; esd=0; PostData(1,fListOutput); return; }
fDimuClArr->Delete();
countN = fDimuClArr->GetEntriesFast();
ntrks = fMuonClArr->GetEntriesFast();
for (Int_t itrk=0; itrk<ntrks-1; itrk++) { // 1st loop over muon tracks
for (Int_t jtrk=itrk+1; jtrk<ntrks; jtrk++) { // 2nd loop ofver muon tracks
- if (fIsMC)
- dimuMC = new AliDimuInfoStoreMC((AliMuonInfoStoreMC*)fMuonClArr->At(itrk), (AliMuonInfoStoreMC*)fMuonClArr->At(jtrk));
- else {
- dimuRD = new AliDimuInfoStoreRD((AliMuonInfoStoreRD*)fMuonClArr->At(itrk), (AliMuonInfoStoreRD*)fMuonClArr->At(jtrk));
- }
+ UInt_t selMask = 0;
+ if (aod) selMask = fCutsDimu->GetSelectionMask(aod->GetTrack( trkID[itrk]),aod->GetTrack( trkID[jtrk]));
+ else selMask = fCutsDimu->GetSelectionMask(esd->GetMuonTrack(trkID[itrk]),esd->GetMuonTrack(trkID[jtrk]));
+
+ if (fIsMC) dimuMC = new AliDimuInfoStoreMC((AliMuonInfoStoreMC*)fMuonClArr->At(itrk),(AliMuonInfoStoreMC*)fMuonClArr->At(jtrk),selMask);
+ else dimuRD = new AliDimuInfoStoreRD((AliMuonInfoStoreRD*)fMuonClArr->At(itrk),(AliMuonInfoStoreRD*)fMuonClArr->At(jtrk),selMask);
if (dimuRD) {
fHeader->FillHistosDimu(fListOutput, dimuRD);
} // end 2nd loop of muon tracks
} // end 1st loop of muon tracks
+ aod = 0; esd = 0;
PostData(1, fListOutput);
return;
}
return;
}
+
+void AliAnalysisTaskSEMuonsHF::NotifyRun()
+{
+ // Notify of the current run number
+
+ if (fCutsMuon) fCutsMuon->SetRun(fCurrentRunNumber);
+ if (fCutsDimu) fCutsDimu->SetRun(fCurrentRunNumber);
+ return;
+}
class TList;
class TClonesArray;
class AliMuonsHFHeader;
+class AliMuonTrackCuts;
+class AliMuonPairCuts;
class AliAnalysisTaskSEMuonsHF : public AliAnalysisTaskSE {
public:
AliAnalysisTaskSEMuonsHF();
- AliAnalysisTaskSEMuonsHF(const char *name);
+ AliAnalysisTaskSEMuonsHF(const char *name, const AliMuonTrackCuts& cutsMuon, const AliMuonPairCuts& cutsDimu);
virtual ~AliAnalysisTaskSEMuonsHF();
virtual void Init();
virtual void UserCreateOutputObjects();
virtual void UserExec(Option_t *opt);
virtual void Terminate(Option_t *opt);
+ virtual void NotifyRun();
void SetAnaMode(Int_t mode) { fAnaMode = ((mode>=0 && mode<3) ? mode : 0); }
void SetIsOutputTree(Bool_t ist) { fIsOutputTree = ist; }
void SetUseMC(Bool_t isMC) { fIsMC = isMC; }
- void SetEvsHCuts(Double_t cuts[3]) const { AliMuonsHFHeader::SetSelectionCuts(cuts); }
- void SetMuonCuts(Double_t cuts[12]) const { AliMuonInfoStoreRD::SetSelectionCuts(cuts); }
- void SetDimuCuts(Double_t cuts[12]) const { AliDimuInfoStoreRD::SetSelectionCuts(cuts); }
+ void SetEvsHCuts(Double_t cuts[5]) const { AliMuonsHFHeader::SetSelectionCuts(cuts); }
private:
Bool_t fIsOutputTree; // flag used to switch on/off tree output
Bool_t fIsMC; // flag of whether the input is MC
+ AliMuonTrackCuts *fCutsMuon; // single muon selection cuts
+ AliMuonPairCuts *fCutsDimu; // dimuon selection cuts
+
AliMuonsHFHeader *fHeader; // output for info at ev level
TClonesArray *fMuonClArr; // output clones array for single mu
TClonesArray *fDimuClArr; // output clones array for dimu
TList *fListOutput; // output list of histos
- ClassDef(AliAnalysisTaskSEMuonsHF, 6);
+ ClassDef(AliAnalysisTaskSEMuonsHF, 7);
};
#endif
}
//-----------------------------------------------------------------------------
-AliDimuInfoStoreMC::AliDimuInfoStoreMC(AliMuonInfoStoreMC* const trk0, AliMuonInfoStoreMC* const trk1, Bool_t full) :
+AliDimuInfoStoreMC::AliDimuInfoStoreMC(AliMuonInfoStoreMC* const trk0, AliMuonInfoStoreMC* const trk1, UInt_t selMask, Bool_t full) :
AliDimuInfoStoreRD(),
fIsFull(full),
fLorentzP(),
//
// default constructor
//
+ fSelMask = selMask;
fMuonRef[0] = trk0;
fMuonRef[1] = trk1;
fLorentzP = trk0->LorentzP() + trk1->LorentzP();
public:
AliDimuInfoStoreMC();
- AliDimuInfoStoreMC(AliMuonInfoStoreMC *trk0, AliMuonInfoStoreMC *trk1, Bool_t full=kFALSE);
+ AliDimuInfoStoreMC(AliMuonInfoStoreMC *trk0, AliMuonInfoStoreMC *trk1, UInt_t selMask, Bool_t full=kFALSE);
AliDimuInfoStoreMC(const AliDimuInfoStoreMC &src);
AliDimuInfoStoreMC& operator=(const AliDimuInfoStoreMC &src);
virtual ~AliDimuInfoStoreMC();
static const TString fgkStdBranchName; // Standard branch name
static const Int_t fgkSourcesN; // num. of dimuon sources
- Bool_t fIsFull; // flag of using full analysis (for Pb-Pb)
+ Bool_t fIsFull; // flag of using full analysis (for Pb-Pb)
TLorentzVector fLorentzP; // lorentz momentum of MC particle
Int_t fSource; // = 0, BBdiff
// = 1, Bchain
// = 4, Resonance
// = 5, UnCorr bkg
- ClassDef(AliDimuInfoStoreMC, 5);
+ ClassDef(AliDimuInfoStoreMC, 7);
};
#endif
ClassImp(AliDimuInfoStoreRD)
const TString AliDimuInfoStoreRD::fgkStdBranchName("DimuRD");
-Double_t AliDimuInfoStoreRD::fgCutd[16] = {-999999., 999999.,
- -999999., 999999.,
- -999999., 999999.,
- -999999., 999999.,
- -999999., 999999.,
- -999999., 999999.,
- -999999., 999999.,
- -999999., 999999.};
//-----------------------------------------------------------------------------
AliDimuInfoStoreRD::AliDimuInfoStoreRD() :
TObject(),
+fSelMask(0),
fMomentum(),
fCharge(0),
fInvM(0.)
}
//-----------------------------------------------------------------------------
-AliDimuInfoStoreRD::AliDimuInfoStoreRD(AliMuonInfoStoreRD* const trk0, AliMuonInfoStoreRD* const trk1) :
+AliDimuInfoStoreRD::AliDimuInfoStoreRD(AliMuonInfoStoreRD* const trk0, AliMuonInfoStoreRD* const trk1, UInt_t selMask) :
TObject(),
+fSelMask(selMask),
fMomentum(),
fCharge(0),
fInvM(0.)
//-----------------------------------------------------------------------------
AliDimuInfoStoreRD::AliDimuInfoStoreRD(const AliDimuInfoStoreRD &src) :
TObject(src),
+fSelMask(src.fSelMask),
fMomentum(src.fMomentum),
fCharge(src.fCharge),
fInvM(src.fInvM)
//
if(&src==this) return *this;
+ fSelMask = src.fSelMask;
fMomentum = src.fMomentum;
fCharge = src.fCharge;
fInvM = src.fInvM;
AliMuonInfoStoreRD *trk0 = (AliMuonInfoStoreRD*)fMuonRef[0].GetObject();
AliMuonInfoStoreRD *trk1 = (AliMuonInfoStoreRD*)fMuonRef[1].GetObject();
- fMomentum = trk0->Momentum() + trk1->Momentum();
+ fMomentum = trk0->MomentumAtVtx() + trk1->MomentumAtVtx();
fCharge = trk0->Charge() + trk1->Charge();
Double_t mMu = TDatabasePDG::Instance()->GetParticle(13)->Mass();
TLorentzVector lorentzP0, lorentzP1, lorentzP;
- lorentzP0.SetVectM(trk0->Momentum(), mMu);
- lorentzP1.SetVectM(trk1->Momentum(), mMu);
+ lorentzP0.SetVectM(trk0->MomentumAtVtx(), mMu);
+ lorentzP1.SetVectM(trk1->MomentumAtVtx(), mMu);
lorentzP = lorentzP0 + lorentzP1;
fInvM = lorentzP.Mag();
trk1 = 0;
return;
}
-
-//-----------------------------------------------------------------------------
-Bool_t AliDimuInfoStoreRD::IsSelected()
-{
- // select dimuon candidates according to the corresponding two muon tracks cuts
-
- Double_t cutsOld[16];
- AliMuonInfoStoreRD::SelectionCust(cutsOld);
- AliMuonInfoStoreRD::SetSelectionCuts(AliDimuInfoStoreRD::fgCutd);
- AliMuonInfoStoreRD *trk0 = (AliMuonInfoStoreRD*)fMuonRef[0].GetObject();
- AliMuonInfoStoreRD *trk1 = (AliMuonInfoStoreRD*)fMuonRef[1].GetObject();
- if (!trk0->IsSelected()) { AliMuonInfoStoreRD::SetSelectionCuts(cutsOld); return kFALSE; }
- if (!trk1->IsSelected()) { AliMuonInfoStoreRD::SetSelectionCuts(cutsOld); return kFALSE; }
-
- AliMuonInfoStoreRD::SetSelectionCuts(cutsOld);
- return kTRUE;
-}
public:
AliDimuInfoStoreRD();
- AliDimuInfoStoreRD(AliMuonInfoStoreRD* const trk0, AliMuonInfoStoreRD* const trk1);
+ AliDimuInfoStoreRD(AliMuonInfoStoreRD* const trk0, AliMuonInfoStoreRD* const trk1, UInt_t selMask);
AliDimuInfoStoreRD(const AliDimuInfoStoreRD &src);
AliDimuInfoStoreRD& operator=(const AliDimuInfoStoreRD &src);
virtual ~AliDimuInfoStoreRD();
TVector3 Momentum() const { return fMomentum; }
Short_t Charge() const { return fCharge; }
Double_t InvM() const { return fInvM; }
-
- Bool_t IsSelected();
+ UInt_t SelMask() const { return fSelMask; }
+ Bool_t IsSelected(const UInt_t filter) { return ((fSelMask & filter) == filter); }
static const char* StdBranchName() { return fgkStdBranchName.Data(); }
- static void SetSelectionCuts(Double_t cuts[16]) { for (Int_t i=16; i--;) fgCutd[i]=cuts[i]; }
protected:
void FillDimuInfo();
+ UInt_t fSelMask; // dimuon selection mask
TRef fMuonRef[2]; // ref to the two corresponding muon tracks
private:
static const TString fgkStdBranchName; // Standard branch name
- static Double_t fgCutd[16]; // single muon cuts for dimuon selection
TVector3 fMomentum; // 3-momentum of dimuon
Short_t fCharge; // charge of dimuon
Double_t fInvM; // invariance mass of dimuon
- ClassDef(AliDimuInfoStoreRD, 5);
+ ClassDef(AliDimuInfoStoreRD, 7);
};
#endif
}
//-----------------------------------------------------------------------------
-AliMuonInfoStoreMC::AliMuonInfoStoreMC(AliAODTrack *trkAOD, AliMCEvent *mcEvent, Bool_t full) :
-AliMuonInfoStoreRD(trkAOD),
+AliMuonInfoStoreMC::AliMuonInfoStoreMC(AliAODTrack *trkAOD, AliMCEvent *mcEvent, UInt_t selMask, Bool_t full) :
+AliMuonInfoStoreRD(trkAOD,selMask),
fIsFull(full),
fLorentzP(),
fTrackIndex(-1),
}
//-----------------------------------------------------------------------------
-AliMuonInfoStoreMC::AliMuonInfoStoreMC(AliESDMuonTrack *trkESD, AliMCEvent *mcEvent, Bool_t full) :
-AliMuonInfoStoreRD(trkESD),
+AliMuonInfoStoreMC::AliMuonInfoStoreMC(AliESDMuonTrack *trkESD, AliMCEvent *mcEvent, UInt_t selMask, Bool_t full) :
+AliMuonInfoStoreRD(trkESD,selMask),
fIsFull(full),
fLorentzP(),
fTrackIndex(-1),
public:
AliMuonInfoStoreMC();
- AliMuonInfoStoreMC(AliAODTrack *trkAOD, AliMCEvent *mcEvent, Bool_t full=kFALSE);
- AliMuonInfoStoreMC(AliESDMuonTrack *trkESD, AliMCEvent *mcEvent, Bool_t full=kFALSE);
+ AliMuonInfoStoreMC(AliAODTrack *trkAOD, AliMCEvent *mcEvent, UInt_t selMask, Bool_t full=kFALSE);
+ AliMuonInfoStoreMC(AliESDMuonTrack *trkESD, AliMCEvent *mcEvent, UInt_t selMask, Bool_t full=kFALSE);
AliMuonInfoStoreMC(const AliMuonInfoStoreMC &src);
AliMuonInfoStoreMC& operator=(const AliMuonInfoStoreMC &src);
virtual ~AliMuonInfoStoreMC();
ClassImp(AliMuonInfoStoreRD)
const TString AliMuonInfoStoreRD::fgkStdBranchName("MuonRD");
-Double_t AliMuonInfoStoreRD::fgCuts[16] = {-999999., 999999.,
- -999999., 999999.,
- -999999., 999999.,
- -999999., 999999.,
- -999999., 999999.,
- -999999., 999999.,
- -999999., 999999.,
- -999999., 999999.};
//-----------------------------------------------------------------------------
AliMuonInfoStoreRD::AliMuonInfoStoreRD() :
TObject(),
-fMomentum(),
+fMomentumAtVtx(),
+fMomentumAtDCA(),
+fMomentumUncor(),
fCharge(0),
fMatchTrigger(-1),
fChi2FitMomentum(0.),
fChi2MatchTrigger(0.),
-fRabsEnd(0.)
+fRabsEnd(0.),
+fSelMask(0)
{
//
// default constructor
}
//-----------------------------------------------------------------------------
-AliMuonInfoStoreRD::AliMuonInfoStoreRD(AliAODTrack *trk) :
+AliMuonInfoStoreRD::AliMuonInfoStoreRD(AliAODTrack *trk, UInt_t selMask) :
TObject(),
-fMomentum(),
+fMomentumAtVtx(),
+fMomentumAtDCA(),
+fMomentumUncor(),
fCharge(0),
fMatchTrigger(-1),
fChi2FitMomentum(0.),
fChi2MatchTrigger(0.),
-fRabsEnd(0.)
+fRabsEnd(0.),
+fSelMask(selMask)
{
//
// AOD-base constructor
}
//-----------------------------------------------------------------------------
-AliMuonInfoStoreRD::AliMuonInfoStoreRD(AliESDMuonTrack *trk) :
+AliMuonInfoStoreRD::AliMuonInfoStoreRD(AliESDMuonTrack *trk, UInt_t selMask) :
TObject(),
-fMomentum(),
+fMomentumAtVtx(),
+fMomentumAtDCA(),
+fMomentumUncor(),
fCharge(0),
fMatchTrigger(-1),
fChi2FitMomentum(0.),
fChi2MatchTrigger(0.),
-fRabsEnd(0.)
+fRabsEnd(0.),
+fSelMask(selMask)
{
//
// ESD-base constructor
//-----------------------------------------------------------------------------
AliMuonInfoStoreRD::AliMuonInfoStoreRD(const AliMuonInfoStoreRD &src) :
TObject(src),
-fMomentum(src.fMomentum),
+fMomentumAtVtx(src.fMomentumAtVtx),
+fMomentumAtDCA(src.fMomentumAtDCA),
+fMomentumUncor(src.fMomentumUncor),
fCharge(src.fCharge),
fMatchTrigger(src.fMatchTrigger),
fChi2FitMomentum(src.fChi2FitMomentum),
fChi2MatchTrigger(src.fChi2MatchTrigger),
-fRabsEnd(src.fRabsEnd)
+fRabsEnd(src.fRabsEnd),
+fSelMask(src.fSelMask)
{
//
// copy constructor
//
if(&src==this) return *this;
- fMomentum = src.fMomentum;
+ fMomentumAtVtx = src.fMomentumAtVtx;
+ fMomentumAtDCA = src.fMomentumAtDCA;
+ fMomentumUncor = src.fMomentumUncor;
fCharge = src.fCharge;
fMatchTrigger = src.fMatchTrigger;
fChi2FitMomentum = src.fChi2FitMomentum;
fChi2MatchTrigger = src.fChi2MatchTrigger;
fRabsEnd = src.fRabsEnd;
+ fSelMask = src.fSelMask;
for (Int_t i=3; i--;) fDCA[i]=src.fDCA[i];
// extract reco info of muon track from AOD
Double_t arr[3];
- trk->PxPyPz(arr);
- this->SetMomentum(arr);
-
- trk->XYZAtDCA(arr);
- this->SetDCA(arr);
-
+ trk->PxPyPz(arr); this->SetMomentumAtVtx(arr);
+ trk->PxPyPzAtDCA(arr); this->SetMomentumAtDCA(arr);
+ trk->XYZAtDCA(arr); this->SetDCA(arr);
this->SetCharge(trk->Charge());
this->SetMatchTrigger(trk->GetMatchTrigger());
this->SetChi2FitMomentum(trk->Chi2perNDF());
this->SetChi2MatchTrigger(trk->GetChi2MatchTrigger());
this->SetRabsEnd(trk->GetRAtAbsorberEnd());
-
return;
}
// extract reco info of muon track from ESD
Double_t arr[3];
- trk->PxPyPz(arr);
- this->SetMomentum(arr);
-
- arr[0] = trk->GetNonBendingCoorAtDCA();
- arr[1] = trk->GetBendingCoorAtDCA();
- arr[2] = trk->GetZ();
- this->SetDCA(arr);
-
+ arr[0]=trk->Px(); arr[1]=trk->Py(); arr[2]=trk->Pz(); this->SetMomentumAtVtx(arr);
+ arr[0]=trk->PxAtDCA(); arr[1]=trk->PyAtDCA(); arr[2]=trk->PzAtDCA(); this->SetMomentumAtDCA(arr);
+ arr[0]=trk->PxUncorrected(); arr[1]=trk->PyUncorrected(); arr[2]=trk->PzUncorrected(); this->SetMomentumUncor(arr);
+ arr[0]=trk->GetNonBendingCoorAtDCA(); arr[1]=trk->GetBendingCoorAtDCA(); arr[2]=trk->GetZ(); this->SetDCA(arr);
this->SetCharge(trk->Charge());
this->SetMatchTrigger(trk->GetMatchTrigger());
this->SetChi2FitMomentum(trk->GetChi2()/(2.*trk->GetNHit()-5.));
this->SetChi2MatchTrigger(trk->GetChi2MatchTrigger());
this->SetRabsEnd(trk->GetRAtAbsorberEnd());
-
return;
}
-
-//-----------------------------------------------------------------------------
-Bool_t AliMuonInfoStoreRD::IsSelected()
-{
- // select muon tracks according to the selection cuts
-
- Double_t p = Momentum().Mag();
- if (p<AliMuonInfoStoreRD::fgCuts[0] || p>AliMuonInfoStoreRD::fgCuts[1]) return kFALSE;
-
- Double_t pt = Momentum().Pt();
- if (pt<AliMuonInfoStoreRD::fgCuts[2] || pt>AliMuonInfoStoreRD::fgCuts[3]) return kFALSE;
-
- Double_t eta = Momentum().Eta();
- if (eta<AliMuonInfoStoreRD::fgCuts[4] || eta>AliMuonInfoStoreRD::fgCuts[5]) return kFALSE;
-
- Double_t dca = this->DCA();
- if (dca<AliMuonInfoStoreRD::fgCuts[6] || dca>AliMuonInfoStoreRD::fgCuts[7]) return kFALSE;
-
- Int_t trigger = this->MatchTrigger();
- if (trigger<AliMuonInfoStoreRD::fgCuts[8] || trigger>AliMuonInfoStoreRD::fgCuts[9]) return kFALSE;
-
- Double_t theta = 180.*(1.-TMath::ATan(this->RabsEnd()/505.)/TMath::Pi());
- if (theta<AliMuonInfoStoreRD::fgCuts[10] || theta>AliMuonInfoStoreRD::fgCuts[11]) return kFALSE;
-
- Double_t chi2Trk = this->Chi2Tracker();
- if (chi2Trk<AliMuonInfoStoreRD::fgCuts[12] || chi2Trk>AliMuonInfoStoreRD::fgCuts[13]) return kFALSE;
-
- Double_t chi2Trg = this->Chi2Trigger();
- if (chi2Trg<AliMuonInfoStoreRD::fgCuts[14] || chi2Trg>AliMuonInfoStoreRD::fgCuts[15]) return kFALSE;
-
- return kTRUE;
-}
#include <TObject.h>
#include <TVector3.h>
#include <TString.h>
+#include <TMath.h>
class AliAODTrack;
class AliESDMuonTrack;
public:
AliMuonInfoStoreRD();
- AliMuonInfoStoreRD(AliAODTrack *trk);
- AliMuonInfoStoreRD(AliESDMuonTrack *trk);
+ AliMuonInfoStoreRD(AliAODTrack *trk, UInt_t selMask);
+ AliMuonInfoStoreRD(AliESDMuonTrack *trk, UInt_t selMask);
AliMuonInfoStoreRD(const AliMuonInfoStoreRD &src);
AliMuonInfoStoreRD& operator=(const AliMuonInfoStoreRD &src);
virtual ~AliMuonInfoStoreRD();
- TVector3 Momentum() const { return fMomentum; }
+ TVector3 MomentumAtVtx() const { return fMomentumAtVtx; }
+ TVector3 MomentumAtDCA() const { return fMomentumAtDCA; }
+ TVector3 MomentumUncor() const { return fMomentumUncor; }
void XYZAtDCA(Double_t dca[3]) const { for (Int_t i=3; i--;) dca[i]=fDCA[i]; }
Double_t DCA() const { return TMath::Sqrt(fDCA[0]*fDCA[0]+fDCA[1]*fDCA[1]); }
Double_t Chi2Tracker() const { return fChi2FitMomentum; }
Double_t Chi2Trigger() const { return fChi2MatchTrigger; }
Double_t RabsEnd() const { return fRabsEnd; }
-
- Bool_t IsSelected();
-
- static const char* StdBranchName() { return fgkStdBranchName.Data(); }
- static void SelectionCust(Double_t cuts[16]) { for (Int_t i=16; i--;) cuts[i]=fgCuts[i]; }
- static void SetSelectionCuts(Double_t cuts[16]) { for (Int_t i=16; i--;) fgCuts[i]=cuts[i]; }
+ UInt_t SelMask() const { return fSelMask; }
+ Bool_t IsSelected(const UInt_t filter) { return ((fSelMask & filter) == filter); }
+ static const char* StdBranchName() { return fgkStdBranchName.Data(); }
private:
void FillMuonInfo(AliAODTrack *trk);
void FillMuonInfo(AliESDMuonTrack *trk);
- void SetMomentum(Double_t p[3]) { fMomentum.SetXYZ(p[0],p[1],p[2]); }
-
- void SetDCA(Double_t dca[3]) { for (Int_t i=3; i--;) fDCA[i]=dca[i]; }
+ void SetMomentumAtVtx(Double_t p[3]) { fMomentumAtVtx.SetXYZ(p[0],p[1],p[2]); }
+ void SetMomentumAtDCA(Double_t p[3]) { fMomentumAtDCA.SetXYZ(p[0],p[1],p[2]); }
+ void SetMomentumUncor(Double_t p[3]) { fMomentumUncor.SetXYZ(p[0],p[1],p[2]); }
+ void SetDCA(Double_t dca[3]) { for (Int_t i=3; i--;) fDCA[i]=dca[i]; }
void SetCharge(Short_t charge) { fCharge = charge; }
void SetMatchTrigger(Int_t trigger) { fMatchTrigger = trigger; }
void SetChi2FitMomentum(Double_t chi2) { fChi2FitMomentum = chi2; }
void SetRabsEnd(Double_t rAbsEnd) { fRabsEnd = rAbsEnd; }
static const TString fgkStdBranchName; // Standard branch name
- static Double_t fgCuts[16]; // 0, min of 3-momentum
- // 1, max of 3-momentum
- // 2, pt_Min
- // 3, pt_Max
- // 4, eta_Min
- // 5, eta_Max
- // 6, dca_Min
- // 7, dca_Max
- // 8, about trigger matching
- // 9, about trigger matching
- //10, rAbs_Min
- //11, rAbs_Max
- //12, chi2Tracker Min
- //13, chi2Tracker Max
- //14, chi2Trigger Min
- //15, chi2Trigger Max
-
- TVector3 fMomentum; // momentum corrected w vtx
+
+ TVector3 fMomentumAtVtx; // momentum corrected w vtx
+ TVector3 fMomentumAtDCA; // momentum at DCA in vtx plane
+ TVector3 fMomentumUncor; // momentum at first station
Double_t fDCA[3]; // distance of closet approach
Short_t fCharge; // track charge
Double_t fChi2FitMomentum; // chi2/NDF of momentum fit
Double_t fChi2MatchTrigger; // chi2 of trigger matching
Double_t fRabsEnd; // position at the end of front absorber
+ UInt_t fSelMask; // mask of single muon selection
- ClassDef(AliMuonInfoStoreRD, 5);
+ ClassDef(AliMuonInfoStoreRD, 7);
};
#endif
#include <TH1D.h>
#include <TList.h>
+#include "AliInputEventHandler.h"
+#include "AliAODMCHeader.h"
#include "AliVEvent.h"
+#include "AliAODEvent.h"
+#include "AliESDEvent.h"
+#include "AliVVertex.h"
+#include "AliCentrality.h"
+#include "AliEventplane.h"
+
+#include "AliMuonTrackCuts.h"
#include "AliMuonInfoStoreRD.h"
#include "AliMuonInfoStoreMC.h"
#include "AliDimuInfoStoreRD.h"
#include "AliDimuInfoStoreMC.h"
#include "AliMuonsHFHeader.h"
-class TNamed;
-class AliVVertex;
-
ClassImp(AliMuonsHFHeader)
const TString AliMuonsHFHeader::fgkStdBranchName("MuEvsH");
fSelMask(AliVEvent::kAny),
fIsMB(kFALSE),
fIsMU(kFALSE),
+fIsPileupSPD(kFALSE),
fVtxContrsN(0),
fFiredTriggerClass(),
-fCentrality(0.)
+fCentrality(-1.),
+fCentQA(-1),
+fEventPlane(0.)
{
//
// default constructor
//
for (Int_t i=3; i--;) fVtx[i] = 0.;
+ for (Int_t i=3; i--;) fVMC[i] = 0.;
}
//_____________________________________________________________________________
fSelMask(src.fSelMask),
fIsMB(src.fIsMB),
fIsMU(src.fIsMU),
+fIsPileupSPD(src.fIsPileupSPD),
fVtxContrsN(src.fVtxContrsN),
fFiredTriggerClass(src.fFiredTriggerClass),
-fCentrality(src.fCentrality)
+fCentrality(src.fCentrality),
+fCentQA(src.fCentQA),
+fEventPlane(src.fEventPlane)
{
//
// copy constructor
//
for (Int_t i=3; i--;) fVtx[i] = src.fVtx[i];
+ for (Int_t i=3; i--;) fVMC[i] = src.fVMC[i];
}
//_____________________________________________________________________________
fSelMask = src.fSelMask;
fIsMB = src.fIsMB;
fIsMU = src.fIsMU;
+ fIsPileupSPD = src.fIsPileupSPD;
fVtxContrsN = src.fVtxContrsN;
fFiredTriggerClass = src.fFiredTriggerClass;
fCentrality = src.fCentrality;
+ fCentQA = src.fCentQA;
+ fEventPlane = src.fEventPlane;
for (Int_t i=3; i--;) fVtx[i] = src.fVtx[i];
+ for (Int_t i=3; i--;) fVMC[i] = src.fVMC[i];
return *this;
}
}
//_____________________________________________________________________________
-void AliMuonsHFHeader::SetVertex(AliVVertex *vertex)
+void AliMuonsHFHeader::SetEventInfo(AliInputEventHandler* const handler, AliMCEvent* const eventMC)
{
- // extract event info from AOD event
+ // fill info at event level
+
+ AliVEvent *event = handler->GetEvent();
+ AliAODEvent *aod = dynamic_cast<AliAODEvent*>(event);
+ AliESDEvent *esd = dynamic_cast<AliESDEvent*>(event);
+ fSelMask = handler->IsEventSelected();
+ if (aod) fFiredTriggerClass = aod->GetFiredTriggerClasses();
+ if (esd) fFiredTriggerClass = esd->GetFiredTriggerClasses();
+ fIsMB = fSelMask & AliVEvent::kMB;
+ fIsMU = fSelMask & AliVEvent::kMUON;
+
+ const AliVVertex *vertex = event->GetPrimaryVertex();
vertex->GetXYZ(fVtx);
fVtxContrsN = vertex->GetNContributors();
- this->SetTitle(vertex->GetTitle());
- return;
-}
+ if (fgIsMC) {
+ if (esd) eventMC->GetPrimaryVertex()->GetXYZ(fVMC);
+ if (aod) ((AliAODMCHeader*)aod->FindListObject(AliAODMCHeader::StdBranchName()))->GetVertex(fVMC);
+ } this->SetTitle(vertex->GetTitle());
+ fIsPileupSPD = (aod && !aod->GetTracklets()) ? event->IsPileupFromSPD(3,0.8,3.,2.,5.) : event->IsPileupFromSPDInMultBins();
+
+ AliCentrality *cent = event->GetCentrality();
+ if (cent) {
+ fCentrality = cent->GetCentralityPercentileUnchecked("V0M");
+ fCentQA = cent->GetQuality();
+ }
+
+ AliEventplane *evnP = event->GetEventplane();
+ if (evnP) fEventPlane = evnP->GetEventplane("Q");
+//if (evnP) fEventPlane = evnP->GetEventplane("V0A");
-void AliMuonsHFHeader::SetFiredTriggerClass(TString trigger)
-{
- fFiredTriggerClass = trigger;
- fIsMB=(fFiredTriggerClass.Contains("CINT1B-ABCE-NOPF-ALL") || // p-p min. bias trigger before Aug/2010
- fFiredTriggerClass.Contains("CINT1-B-NOPF-ALLNOTRD") || // p-p min. bias trigger from Aug/2010
- fFiredTriggerClass.Contains("CMBS2A-B-NOPF-ALL") || // Pb-Pb min. bias trigger 2-out-of-3
- fFiredTriggerClass.Contains("CMBS2C-B-NOPF-ALL") || // Pb-Pb min. bias trigger 2-out-of-3
- fFiredTriggerClass.Contains("CMBAC-B-NOPF-ALL") || // Pb-Pb min. bias trigger 2-out-of-3
- fFiredTriggerClass.Contains("CMBACS2-B-NOPF-ALL") || // Pb-Pb min. bias trigger 3-out-of-3 (early)
- fFiredTriggerClass.Contains("CMBACS2-B-NOPF-ALLNOTRD")); // Pb-Pb min. bias trigger 3-out-of-3 (late 2010)
- fIsMU=(fFiredTriggerClass.Contains("CMUS1B-ABCE-NOPF-MUON") || // p-p MUON trigger before Aug/2010
- fFiredTriggerClass.Contains("CMUS1-B-NOPF-ALLNOTRD")); // p-p MUON trigger from Aug/2010
return;
}
{
// fill histograms at event level according to event selection cuts
- if (!list) return;
+ if (!list) return;
if (!this->IsSelected()) return;
const Int_t nhs = 3;
{
// fill histograms for single muon according to event & muon track selection cuts
- if (!list) return;
- if (!this->IsSelected()) return;
- if (!infoStore->IsSelected()) return;
+ if (!list) return;
+ if (!this->IsSelected()) return;
+ if (!infoStore->IsSelected(0)) return;
const Int_t nhs = 7;
TString tName[nhs] = { "P", "Pt", "Eta", "DCA", "TrM", "Charge", "Rabs" };
- Double_t dist[nhs] = { infoStore->Momentum().Mag(),
- infoStore->Momentum().Pt(),
- infoStore->Momentum().Eta(),
- infoStore->DCA(),
- infoStore->MatchTrigger(),
- infoStore->Charge(),
- infoStore->RabsEnd() };
+ Double_t dist[nhs] = { infoStore->MomentumAtVtx().Mag(),
+ infoStore->MomentumAtVtx().Pt(),
+ infoStore->MomentumAtVtx().Eta(),
+ infoStore->DCA(),
+ infoStore->MatchTrigger(),
+ infoStore->Charge(),
+ infoStore->RabsEnd() };
if (fgIsMC && (fSelMask & AliVEvent::kAny)) {
TString sName[7] = { "BottomMu", "CharmMu", "PrimaryMu", "SecondaryMu", "Hadron", "Unidentified", "" };
{
// fill histograms for dimuon according to evnet & dimuon candidates selection cuts
- if (!list) return;
- if (!this->IsSelected()) return;
- if (!infoStore->IsSelected()) return;
+ if (!list) return;
+ if (!this->IsSelected()) return;
+ if (!infoStore->IsSelected(0)) return;
TString dimuName = "DimuNN";
if (infoStore->Charge()==0) dimuName = "DimuNP";
const Int_t nhs = 3;
TString tName[nhs] = { "P", "Pt", "InvM" };
Double_t dist[nhs] = { infoStore->Momentum().Mag(),
- infoStore->Momentum().Pt(),
- infoStore->InvM() };
+ infoStore->Momentum().Pt(),
+ infoStore->InvM() };
if (fgIsMC && (fSelMask & AliVEvent::kAny)) {
TString sName[7] = { "BBdiff", "BBsame", "DDdiff", "DDsame", "Resonance", "Uncorr", "" };
#include <TString.h>
class TList;
-class AliAODEvent;
-class AliESDEvent;
+class AliMCEvent;
+class AliInputEventHandler;
class AliMuonInfoStoreRD;
class AliDimuInfoStoreRD;
AliMuonsHFHeader& operator=(const AliMuonsHFHeader &src);
~AliMuonsHFHeader();
+ void GetVMC(Double_t *vtx) const { for (Int_t i=3; i--;) vtx[i]=fVMC[i]; }
void GetXYZ(Double_t *vtx) const { for (Int_t i=3; i--;) vtx[i]=fVtx[i]; }
Double_t Vx() const { return fVtx[0]; }
Double_t Vy() const { return fVtx[1]; }
Double_t Vt() const { return TMath::Sqrt(fVtx[0]*fVtx[0] + fVtx[1]*fVtx[1]); }
Int_t VtxContrsN() const { return fVtxContrsN; }
TString FiredTriggerClass() const { return fFiredTriggerClass; }
- Float_t Centrality() const { return fCentrality; }
UInt_t SelectionMask() const { return fSelMask; }
Bool_t IsMB() const { return fIsMB; }
Bool_t IsMU() const { return fIsMU; }
+ Bool_t IsPileupSPD() const { return fIsPileupSPD; }
+ Float_t Centrality() const { return fCentrality; }
+ Int_t CentQA() const { return fCentQA;}
+ Double32_t EventPlane() const { return fEventPlane; }
Bool_t IsSelected();
- void SetSelectionMask(UInt_t mask) { fSelMask=mask; }
- void SetVertex(AliVVertex *vertex);
- void SetFiredTriggerClass(TString trigger);
- void SetCentrality(Float_t centr) { fCentrality=centr; }
+ void SetEventInfo(AliInputEventHandler* const handler, AliMCEvent* const eventMC);
void CreateHistograms(TList *list);
void FillHistosEvnH(TList *list);
// 3, centrality max
// 4, centrality min
- UInt_t fSelMask; // mask of physics selection
- Bool_t fIsMB; // is min. bias triggered event (for real data)
- Bool_t fIsMU; // is MUON triggered event (for real data)
- Double_t fVtx[3]; // position of vtx
- Int_t fVtxContrsN; // num. of contributors of vtx rec
+ UInt_t fSelMask; // mask of physics selection
+ Bool_t fIsMB; // is min. bias triggered event (for real data)
+ Bool_t fIsMU; // is MUON triggered event (for real data)
+ Bool_t fIsPileupSPD; // is pileup from SPD
+ Double_t fVtx[3]; // position of vtx
+ Double_t fVMC[3]; // position of vtx in MC
+ Int_t fVtxContrsN; // num. of contributors of vtx rec
TString fFiredTriggerClass; // trigger class
Float_t fCentrality; // event centrality class
+ Int_t fCentQA; // quality of centrality determination
+ Double32_t fEventPlane; // event plane angle
- ClassDef(AliMuonsHFHeader, 5)
+ ClassDef(AliMuonsHFHeader, 7)
};
#endif
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff