//loop over all MC data and Fill the CF container if it exist
if (!fCfManagerPair) return;
fCfManagerPair->SetPdgMother(fPdgMother);
-
AliDielectronMC *dieMC=AliDielectronMC::Instance();
for (Int_t ipart=0; ipart<dieMC->GetNMCTracks();++ipart){
//TODO: MC truth cut properly!!!
candidate->SetTracks(static_cast<AliVTrack*>(fTracks[arr1].UncheckedAt(itrack1)), 11,
static_cast<AliVTrack*>(fTracks[arr2].UncheckedAt(itrack2)), 11);
candidate->SetType(pairIndex);
+ candidate->SetLabel(AliDielectronMC::Instance()->GetLabelMotherWithPdg(candidate,fPdgMother));
//pair cuts
UInt_t cutMask=fPairFilter.IsSelected(candidate);
void Process(AliVEvent *ev1, AliVEvent *ev2=0);
- void FillHistograms(const AliVEvent *ev);
-
const AliAnalysisFilter& GetEventFilter() const { return fEventFilter; }
const AliAnalysisFilter& GetTrackFilter() const { return fTrackFilter; }
const AliAnalysisFilter& GetPairFilter() const { return fPairFilter; }
void ProcessMC();
+ void FillHistograms(const AliVEvent *ev);
+
AliDielectron(const AliDielectron &c);
AliDielectron &operator=(const AliDielectron &c);
if (fStepForNoCutsMCmotherPid) ++fNSteps;
if (fStepForAfterAllCuts) fNSteps+=2;
- if (fStepsForEachCut&&fNCuts>1) fNSteps+=(2*fNCuts); //one step for each cut + MC truth
- if (fStepsForCutsIncreasing&&fNCuts>2) fNSteps+=(2*(fNCuts-2)); //one step for the increasing cuts + MC truth
+ if (fStepsForEachCut&&fNCuts>1) fNSteps+=(2*fNCuts); //one step for each cut + Signal (MC)
+ if (fStepsForCutsIncreasing&&fNCuts>2) fNSteps+=(2*(fNCuts-2)); //one step for the increasing cuts + Signal (MC)
// e.g. cut2&cut3, cut2&cut3&cut4
fNSteps+=(2*fNStepMasks); // cuts for the additional cut masks
// create the container
//before cuts (MC truth)
if (fStepForNoCutsMCmotherPid){
- fCfContainer->SetStepTitle(step++,"No cuts (MC mother)");
+ fCfContainer->SetStepTitle(step++,"No cuts (Signal)");
}
//After All cuts
if (fStepForAfterAllCuts){
cutName="All Cuts"; //TODO: User GetTitle???
fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut
- cutName+=" (MC truth)";
+ cutName+=" (Signal)";
fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut with MC truth
}
for (Int_t iCut=0; iCut<fNCuts;++iCut) {
cutName=filter.GetCuts()->At(iCut)->GetName(); //TODO: User GetTitle???
fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut
- cutName+=" (MC mother)";
+ cutName+=" (Signal)";
fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut with MC truth
}
}
cutName+="&";
cutName+=filter.GetCuts()->At(iCut)->GetName();
fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut
- cutName+=" (MC mother)";
+ cutName+=" (Signal)";
fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut with MC truth
}
}
}
}
fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut
- cutName+=" (MC mother)";
+ cutName+=" (Signal)";
fCfContainer->SetStepTitle(step++, cutName.Data()); //Step for the cut with MC truth
}
Double_t valuesPair[AliDielectronVarManager::kNMaxValues];
AliDielectronVarManager::Fill(particle,valuesPair);
- //TODO: temporary solution, set manually the pair type to 1: mixed e+-
+ //TODO: temporary solution, set manually the pair type to 1: unlikesign SE
valuesPair[AliDielectronVarManager::kPairType]=1;
for (Int_t iVar=0; iVar<fNVars; ++iVar){
AliVParticle *d2=0x0;
AliDielectronMC::Instance()->GetDaughters(particle,d1,d2);
Double_t valuesLeg1[AliDielectronVarManager::kNMaxValues];
- AliDielectronVarManager::Fill(d1,valuesLeg1);
Double_t valuesLeg2[AliDielectronVarManager::kNMaxValues];
- AliDielectronVarManager::Fill(d2,valuesLeg2);
+ if (d1->Pt()>d2->Pt()){
+ AliDielectronVarManager::Fill(d1,valuesLeg1);
+ AliDielectronVarManager::Fill(d2,valuesLeg2);
+ } else {
+ AliDielectronVarManager::Fill(d2,valuesLeg1);
+ AliDielectronVarManager::Fill(d1,valuesLeg2);
+ }
for (Int_t iVar=0; iVar<fNVarsLeg; ++iVar){
Int_t var=fVariablesLeg[iVar];
#include <TObjArray.h>
#include <TKey.h>
#include <TList.h>
+#include <TClass.h>
#include <TObject.h>
#include <TFile.h>
#include <TString.h>
#include <TH3.h>
#include <TPad.h>
#include <TCanvas.h>
+#include <TLegend.h>
+#include <AliCFEffGrid.h>
#include <AliLog.h>
AliDielectronCFdraw::AliDielectronCFdraw() :
TNamed(),
- fCfContainer(0x0)
+ fCfContainer(0x0),
+ fEffGrid(0x0)
{
//
// Ctor
//________________________________________________________________
AliDielectronCFdraw::AliDielectronCFdraw(const char*name, const char* title) :
TNamed(name,title),
- fCfContainer(0x0)
+ fCfContainer(0x0),
+ fEffGrid(0x0)
{
//
// Named Ctor
}
+//________________________________________________________________
+AliDielectronCFdraw::AliDielectronCFdraw(AliCFContainer *cont) :
+ TNamed(cont->GetName(), cont->GetTitle()),
+ fCfContainer(cont),
+ fEffGrid(new AliCFEffGrid("eff","eff",*cont))
+{
+ //
+ // directly set the CF container
+ //
+
+}
+
+//________________________________________________________________
+AliDielectronCFdraw::AliDielectronCFdraw(const char* filename) :
+ TNamed(),
+ fCfContainer(0x0),
+ fEffGrid(0x0)
+{
+ //
+ // get CF container(s) from file 'filename'
+ //
+ SetCFContainers(filename);
+}
+
//________________________________________________________________
void AliDielectronCFdraw::SetCFContainers(const TSeqCollection *arr)
{
++istep;
}
}
+ if (fEffGrid) delete fEffGrid;
+ fEffGrid=new AliCFEffGrid("eff","eff",*fCfContainer);
}
//________________________________________________________________
if (entries==0) return;
TKey *k=(TKey*)l->At(0);
- TSeqCollection *arr=dynamic_cast<TSeqCollection*>(k->ReadObj());
- if (!arr) return;
-
- SetCFContainers(arr);
+ if (!k) return;
+ TObject *o=k->ReadObj();
+ if (o->IsA()->InheritsFrom(TSeqCollection::Class())){
+ TSeqCollection *arr=static_cast<TSeqCollection*>(o);
+ SetCFContainers(arr);
+ } else if (o->IsA()==AliCFContainer::Class()){
+ fCfContainer=static_cast<AliCFContainer*>(o);
+ if (fEffGrid) delete fEffGrid;
+ fEffGrid=new AliCFEffGrid("eff","eff",*fCfContainer);
+ }
}
//________________________________________________________________
Draw(ivar[0],slices,opt);
break;
case 2:
- Draw(ivar[0],ivar[1],slices,opt);
+ Draw(ivar[1],ivar[0],slices,opt);
break;
case 3:
- Draw(ivar[0],ivar[1],ivar[2],slices,opt);
+ Draw(ivar[2],ivar[1],ivar[0],slices,opt);
break;
}
delete arrVars;
const Int_t ndim=1;
Int_t vars[ndim]={var};
- TObjArray *arr=CollectHistos(ndim,vars,slices);
+ TObjArray *arr=CollectHistosProj(ndim,vars,slices);
Draw(arr,opt);
delete arr;
}
//
const Int_t ndim=2;
Int_t vars[ndim]={var0,var1};
- TObjArray *arr=CollectHistos(ndim,vars,slices);
+ TObjArray *arr=CollectHistosProj(ndim,vars,slices);
Draw(arr,opt);
delete arr;
}
//
const Int_t ndim=3;
Int_t vars[ndim]={var0,var1,var2};
- TObjArray *arr=CollectHistos(ndim,vars,slices);
+ TObjArray *arr=CollectHistosProj(ndim,vars,slices);
Draw(arr,opt);
delete arr;
}
//________________________________________________________________
-void AliDielectronCFdraw::Draw(const TObjArray *arr, const char* opt)
+TObjArray* AliDielectronCFdraw::CollectHistosProj(Int_t dim, Int_t *vars, const char* slices)
{
//
- // draw all objects in arr
+ // Collect histos with 'dim'ension of the 'slices' separated by one of "':;'"
+ // in a TObjArray and return it
//
- TString optStr(opt);
- optStr.ToLower();
- Bool_t drawSame=optStr.Contains("same");
- optStr.ReplaceAll("same","");
- if (!gPad) new TCanvas;
- TCanvas *c=gPad->GetCanvas();
- c->Clear();
- if (!drawSame){
- //optimised division
- Int_t nPads = arr->GetEntries();
- Int_t nCols = (Int_t)TMath::Ceil( TMath::Sqrt(nPads) );
- Int_t nRows = (Int_t)TMath::Ceil( (Double_t)nPads/(Double_t)nCols );
- c->Divide(nCols,nRows);
- for (Int_t i=0; i<nPads; ++i){
- c->cd(i+1);
- arr->UncheckedAt(i)->Draw(optStr.Data());
+ TObjArray *arr=TString(slices).Tokenize(",:;");
+ TObjArray *arrHists=0x0;
+ if (arr->GetEntriesFast()==0){
+ // all slices in case of 0 entries
+ arrHists=new TObjArray(fCfContainer->GetNStep());
+ for (Int_t istep=0; istep<fCfContainer->GetNStep(); ++istep){
+ TH1 *hproj=Project(dim,vars,istep);
+ hproj->SetName(fCfContainer->GetStepTitle(istep));
+ arrHists->Add(hproj);
+ }
+ } else {
+ arrHists=new TObjArray(arr->GetEntriesFast());
+ TIter next(arr);
+ TObjString *ostr=0x0;
+ while ( (ostr=static_cast<TObjString*>(next())) ) {
+ Int_t istep=ostr->GetString().Atoi();
+ TH1 *hproj=Project(dim,vars,istep);
+ hproj->SetName(fCfContainer->GetStepTitle(istep));
+ arrHists->Add(hproj);
+ }
+ }
+ delete arr;
+
+ return arrHists;
+}
+
+//________________________________________________________________
+TH1* AliDielectronCFdraw::Project(Int_t ndim, Int_t *vars, Int_t slice)
+{
+ //
+ // Do an nim projection
+ //
+ switch (ndim){
+ case 1:
+ return fCfContainer->Project(vars[0],slice);
+ break;
+ case 2:
+ return fCfContainer->Project(vars[0],vars[1],slice);
+ break;
+ case 3:
+ return fCfContainer->Project(vars[0],vars[1],vars[2],slice);
+ break;
+ }
+ return 0x0;
+}
+
+//________________________________________________________________
+void AliDielectronCFdraw::DrawEfficiency(const char* varnames, const char* nominators, Int_t denominator, const char* opt)
+{
+ //
+ // plot efficiencies for variables. Variable may be up to 3 dim, separated by a ':'
+ // you may have several nominators, sparated by one of ',:;'
+ //
+
+ TObjArray *arrVars=TString(varnames).Tokenize(":");
+ Int_t entries=arrVars->GetEntriesFast();
+ if (entries<1||entries>3){
+ AliError("Wrong number of variables, supported are 1 - 3 dimensions");
+ delete arrVars;
+ return;
+ }
+
+ TIter next(arrVars);
+ TObjString *ostr=0x0;
+ Int_t ivar[3]={-1,-1,-1};
+ for (Int_t i=0; i<entries; ++i){
+ ostr=static_cast<TObjString*>(next());
+ if (ostr->GetString().IsDigit()){
+ ivar[i]=ostr->GetString().Atoi();
+ } else {
+ ivar[i]=fCfContainer->GetVar(ostr->GetName());
}
}
+
+ switch (entries){
+ case 1:
+ DrawEfficiency(ivar[0],nominators, denominator,opt);
+ break;
+ case 2:
+ DrawEfficiency(ivar[1],ivar[0], nominators, denominator,opt);
+ break;
+ case 3:
+ DrawEfficiency(ivar[2],ivar[1],ivar[0],nominators, denominator,opt);
+ break;
+ }
+ delete arrVars;
+}
+
+//________________________________________________________________
+void AliDielectronCFdraw::DrawEfficiency(Int_t var, const char* nominators, Int_t denominator, const char* opt)
+{
+ //
+ // Draw Efficiencies for all nominators
+ // nominators may be divided by and of ,;:
+ //
+ // if opt contains 'same' all histograms are drawn in the same pad
+ // otherwise the pad will be divided in sub pads and the histograms
+ // are drawn in each sub pad
+ //
+
+ const Int_t ndim=1;
+ Int_t vars[ndim]={var};
+ TObjArray *arr=CollectHistosEff(ndim,vars,nominators,denominator);
+ Draw(arr,opt);
+ delete arr;
+}
+
+//________________________________________________________________
+void AliDielectronCFdraw::DrawEfficiency(Int_t var0, Int_t var1, const char* nominators, Int_t denominator, const char* opt)
+{
+ //
+ // Draw 2D case
+ //
+ const Int_t ndim=2;
+ Int_t vars[ndim]={var0,var1};
+ TObjArray *arr=CollectHistosEff(ndim,vars,nominators,denominator);
+ Draw(arr,opt);
+ delete arr;
+}
+
+//________________________________________________________________
+void AliDielectronCFdraw::DrawEfficiency(Int_t var0, Int_t var1, Int_t var2, const char* nominators, Int_t denominator, const char* opt)
+{
+ //
+ // Draw 3D case
+ //
+ const Int_t ndim=3;
+ Int_t vars[ndim]={var0,var1,var2};
+ TObjArray *arr=CollectHistosEff(ndim,vars,nominators,denominator);
+ Draw(arr,opt);
+ delete arr;
}
//________________________________________________________________
-TObjArray* AliDielectronCFdraw::CollectHistos(Int_t dim, Int_t *vars, const char* slices)
+TObjArray* AliDielectronCFdraw::CollectHistosEff(Int_t dim, Int_t *vars, const char* nominators, Int_t denominator)
{
//
// Collect histos with 'dim'ension of the 'slices' separated by one of "':;'"
// in a TObjArray and return it
//
- TObjArray *arr=TString(slices).Tokenize(",:;");
+ TObjArray *arr=TString(nominators).Tokenize(",:;");
TObjArray *arrHists=0x0;
if (arr->GetEntriesFast()==0){
// all slices in case of 0 entries
arrHists=new TObjArray(fCfContainer->GetNStep());
for (Int_t istep=0; istep<fCfContainer->GetNStep(); ++istep){
- arrHists->Add(Project(dim,vars,istep));
+ fEffGrid->CalculateEfficiency(istep,denominator);
+ TH1 *hproj=ProjectEff(dim,vars);
+ Float_t eff=fEffGrid->GetAverage();
+ hproj->SetName(Form("%s (%f)",fCfContainer->GetStepTitle(istep),eff));
+ arrHists->Add(hproj);
}
} else {
arrHists=new TObjArray(arr->GetEntriesFast());
TObjString *ostr=0x0;
while ( (ostr=static_cast<TObjString*>(next())) ) {
Int_t istep=ostr->GetString().Atoi();
- arrHists->Add(Project(dim,vars,istep));
+ fEffGrid->CalculateEfficiency(istep,denominator);
+ TH1 *hproj=ProjectEff(dim,vars);
+ Float_t eff=fEffGrid->GetAverage();
+ hproj->SetName(Form("%s (%f)",fCfContainer->GetStepTitle(istep),eff));
+ arrHists->Add(hproj);
}
}
delete arr;
-
+
return arrHists;
}
//________________________________________________________________
-TH1* AliDielectronCFdraw::Project(Int_t ndim, Int_t *vars, Int_t slice)
+TH1* AliDielectronCFdraw::ProjectEff(Int_t ndim, Int_t *vars)
{
//
// Do an nim projection
//
switch (ndim){
case 1:
- return fCfContainer->Project(vars[0],slice);
+ return fEffGrid->Project(vars[0]);
break;
case 2:
- return fCfContainer->Project(vars[0],vars[1],slice);
+ return fEffGrid->Project(vars[0],vars[1]);
break;
case 3:
- return fCfContainer->Project(vars[0],vars[1],vars[2],slice);
+ return fEffGrid->Project(vars[0],vars[1],vars[2]);
break;
}
return 0x0;
}
+//________________________________________________________________
+void AliDielectronCFdraw::Draw(const TObjArray *arr, const char* opt)
+{
+ //
+ // draw all objects in arr
+ //
+ TString optStr(opt);
+ optStr.ToLower();
+ Bool_t drawSame=optStr.Contains("same");
+ Bool_t optLeg=optStr.Contains("leg");
+ optStr.ReplaceAll("same","");
+
+ if (!gPad) new TCanvas;
+
+ Int_t nPads = arr->GetEntriesFast();
+ if (nPads==0) return;
+
+ if (nPads==1){
+ arr->UncheckedAt(0)->Draw(optStr.Data());
+ return;
+ }
+
+ TCanvas *c=gPad->GetCanvas();
+ c->Clear();
+
+
+ if (!drawSame){
+ //optimised division
+ Int_t nCols = (Int_t)TMath::Ceil( TMath::Sqrt(nPads) );
+ Int_t nRows = (Int_t)TMath::Ceil( (Double_t)nPads/(Double_t)nCols );
+ c->Divide(nCols,nRows);
+ for (Int_t i=0; i<nPads; ++i){
+ c->cd(i+1);
+ arr->UncheckedAt(i)->Draw(optStr.Data());
+ }
+ } else {
+ TLegend *leg=0;
+ if (optLeg) leg=new TLegend(.8,.3,.99,.9);
+ for (Int_t i=0; i<nPads; ++i){
+ if (i==1) optStr+="same";
+ TH1 *hist=static_cast<TH1*>(arr->UncheckedAt(i));
+ hist->SetLineColor(i+1);
+ hist->SetMarkerColor(i+1);
+ hist->Draw(optStr.Data());
+ if (leg) leg->AddEntry(hist,hist->GetName(),"lp");
+ }
+ if (leg){
+ leg->SetFillColor(10);
+ leg->SetY1(.9-nPads*.05);
+ leg->Draw();
+ }
+ }
+
+}
class TObjArray;
class TSeqCollection;
+class AliCFEffGrid;
class TH1;
class AliCFContainer;
public:
AliDielectronCFdraw();
AliDielectronCFdraw(const char* name, const char* title);
-
+ AliDielectronCFdraw(AliCFContainer *cont);
+ AliDielectronCFdraw(const char* filename);
+
+ virtual ~AliDielectronCFdraw() {;}
+
void SetCFContainer(AliCFContainer * const container) {fCfContainer=container;}
void SetCFContainers(const TSeqCollection *arr);
void UnsetRangeUser(const char* varname, const char* slices="");
// virtual void Draw(const Option_t* /*option*/ = "") {;}
+ //Draw Projections
void Draw(const Option_t* varnames, const char* opt="", const char* slices="");
void Draw(Int_t var, const char* opt="", const char* slices="");
void Draw(Int_t var0, Int_t var1, const char* opt="", const char* slices="");
void Draw(Int_t var0, Int_t var1, Int_t var2, const char* opt="", const char* slices="");
- void Draw(const TObjArray *arr, const char* opt="");
-
- TObjArray* CollectHistos(Int_t dim, Int_t *vars, const char* slices);
+
+ TObjArray* CollectHistosProj(Int_t dim, Int_t *vars, const char* slices);
TH1* Project(Int_t ndim, Int_t *vars, Int_t slice);
+
+ //Draw efficiencies
+ void DrawEfficiency(const char* varnames, const char* nominators, Int_t denominator=0, const char* opt="sameleg");
+ void DrawEfficiency(Int_t var, const char* nominators, Int_t denominator=0, const char* opt="sameleg");
+ void DrawEfficiency(Int_t var0, Int_t var1, const char* nominators, Int_t denominator=0, const char* opt="sameleg");
+ void DrawEfficiency(Int_t var0, Int_t var1, Int_t var2, const char* nominators, Int_t denominator=0, const char* opt="sameleg");
+
+ TObjArray* CollectHistosEff(Int_t dim, Int_t *vars, const char* nominators, Int_t denominator);
+ TH1* ProjectEff(Int_t ndim, Int_t *vars);
+
+ void Draw(const TObjArray *arr, const char* opt="");
private:
AliCFContainer *fCfContainer; // CF container
-
+ AliCFEffGrid *fEffGrid; // Efficiency calculation
+
AliDielectronCFdraw(const AliDielectronCFdraw &c);
AliDielectronCFdraw &operator=(const AliDielectronCFdraw &c);
}
//____________________________________________________________
-Bool_t AliDielectronMC::IsMotherPdg(const AliVParticle *particle1, const AliVParticle *particle2, Int_t pdgMother)
+Int_t AliDielectronMC::GetLabelMotherWithPdg(const AliVParticle *particle1, const AliVParticle *particle2, Int_t pdgMother)
{
//
// test if mother of particle 1 and 2 has pdgCode pdgMother and is the same;
//
- if (!fMCEvent) return kFALSE;
+ if (!fMCEvent) return -1;
- if (fAnaType==kESD) return IsMotherPdgESD(particle1, particle2, pdgMother);
- else if (fAnaType==kAOD) return IsMotherPdgAOD(particle1, particle2, pdgMother);
+ if (fAnaType==kESD) return GetLabelMotherWithPdgESD(particle1, particle2, pdgMother);
+ else if (fAnaType==kAOD) return GetLabelMotherWithPdgAOD(particle1, particle2, pdgMother);
- return kFALSE;
+ return -1;
}
//____________________________________________________________
-Bool_t AliDielectronMC::IsMotherPdgESD(const AliVParticle *particle1, const AliVParticle *particle2, Int_t pdgMother)
+Int_t AliDielectronMC::GetLabelMotherWithPdgESD(const AliVParticle *particle1, const AliVParticle *particle2, Int_t pdgMother)
{
//
- // test if mother of particle 1 and 2 has pdgCode pdgMother and is the same;
+ // test if mother of particle 1 and 2 has pdgCode +-11 (electron),
+ // have the same mother and the mother had pdg code pdgMother
// ESD case
//
AliMCParticle *mcPart1=static_cast<AliMCParticle*>(GetMCTrackFromMCEvent(particle1->GetLabel()));
AliMCParticle *mcPart2=static_cast<AliMCParticle*>(GetMCTrackFromMCEvent(particle2->GetLabel()));
- if (!mcPart1||!mcPart2) return kFALSE;
+ if (!mcPart1||!mcPart2) return -1;
Int_t lblMother1=mcPart1->GetMother();
Int_t lblMother2=mcPart2->GetMother();
AliMCParticle *mcMother1=static_cast<AliMCParticle*>(GetMCTrackFromMCEvent(lblMother1));
- if (!mcMother1) return kFALSE;
- if (lblMother1!=lblMother2) return kFALSE;
- if (mcMother1->PdgCode()!=pdgMother) return kFALSE;
+ if (!mcMother1) return -1;
+ if (lblMother1!=lblMother2) return -1;
+ if (TMath::Abs(mcPart1->PdgCode())!=11) return -1;
+ if (mcMother1->PdgCode()!=pdgMother) return -1;
- return kTRUE;
+ return lblMother1;
}
//____________________________________________________________
-Bool_t AliDielectronMC::IsMotherPdgAOD(const AliVParticle *particle1, const AliVParticle *particle2, Int_t pdgMother)
+Int_t AliDielectronMC::GetLabelMotherWithPdgAOD(const AliVParticle *particle1, const AliVParticle *particle2, Int_t pdgMother)
{
//
- // test if mother of particle 1 and 2 has pdgCode pdgMother and is the same;
+ // test if mother of particle 1 and 2 has pdgCode +-11 (electron),
+ // have the same mother and the mother had pdg code pdgMother
// AOD case
//
AliAODMCParticle *mcPart1=static_cast<AliAODMCParticle*>(GetMCTrackFromMCEvent(particle1->GetLabel()));
AliAODMCParticle *mcPart2=static_cast<AliAODMCParticle*>(GetMCTrackFromMCEvent(particle2->GetLabel()));
- if (!mcPart1||!mcPart2) return kFALSE;
+ if (!mcPart1||!mcPart2) return -1;
Int_t lblMother1=mcPart1->GetMother();
Int_t lblMother2=mcPart2->GetMother();
AliAODMCParticle *mcMother1=static_cast<AliAODMCParticle*>(GetMCTrackFromMCEvent(lblMother1));
- if (!mcMother1) return kFALSE;
- if (lblMother1!=lblMother2) return kFALSE;
- if (mcMother1->GetPdgCode()!=pdgMother) return kFALSE;
+ if (!mcMother1) return -1;
+ if (lblMother1!=lblMother2) return -1;
+ if (TMath::Abs(mcPart1->GetPdgCode())!=11) return -1;
+ if (mcMother1->GetPdgCode()!=pdgMother) return -1;
- return kTRUE;
+ return lblMother1;
}
//____________________________________________________________
Bool_t ConnectMCEvent();
Bool_t UpdateStack();
- Bool_t IsMotherPdg(const TObject* particle, Int_t pdgMother);
+ Bool_t IsMotherPdg(const AliDielectronPair* pair, Int_t pdgMother);
Bool_t IsMotherPdg(const AliVParticle *particle1, const AliVParticle *particle2, Int_t pdgMother);
Bool_t IsMCMotherToEE(const AliVParticle *particle, Int_t pdgMother);
+ Int_t GetLabelMotherWithPdg(const AliDielectronPair* pair, Int_t pdgMother);
+ Int_t GetLabelMotherWithPdg(const AliVParticle *particle1, const AliVParticle *particle2, Int_t pdgMother);
+
AliVParticle* GetMCTrackFromMCEvent(AliVParticle *track); // return MC track directly from MC event
AliVParticle* GetMCTrackFromMCEvent(Int_t _itrk); // return MC track directly from MC event
TParticle* GetMCTrackFromStack(AliESDtrack* _track); // return MC track from stack
Bool_t IsMCMotherToEEesd(const AliMCParticle *particle, Int_t pdgMother);
Bool_t IsMCMotherToEEaod(const AliAODMCParticle *particle, Int_t pdgMother);
- Bool_t IsMotherPdgESD(const AliVParticle *particle1, const AliVParticle *particle2, Int_t pdgMother);
- Bool_t IsMotherPdgAOD(const AliVParticle *particle1, const AliVParticle *particle2, Int_t pdgMother);
+ Int_t GetLabelMotherWithPdgESD(const AliVParticle *particle1, const AliVParticle *particle2, Int_t pdgMother);
+ Int_t GetLabelMotherWithPdgAOD(const AliVParticle *particle1, const AliVParticle *particle2, Int_t pdgMother);
ClassDef(AliDielectronMC, 0)
};
-inline Bool_t AliDielectronMC::IsMotherPdg(const TObject* particle, Int_t pdgMother)
+//
+// inline functions
+//
+inline Bool_t AliDielectronMC::IsMotherPdg(const AliDielectronPair* pair, Int_t pdgMother)
{
- //
- //
- //
- if (particle->IsA()!=AliDielectronPair::Class()) return kFALSE;
- const AliDielectronPair *pair=static_cast<const AliDielectronPair*>(particle);
return IsMotherPdg(pair->GetFirstDaughter(),pair->GetSecondDaughter(),pdgMother);
}
+//___________________________________________________________
+inline Bool_t AliDielectronMC::IsMotherPdg(const AliVParticle *particle1, const AliVParticle *particle2, Int_t pdgMother){
+ return GetLabelMotherWithPdg(particle1,particle2,pdgMother)>=0;
+}
+//___________________________________________________________
+inline Int_t AliDielectronMC::GetLabelMotherWithPdg(const AliDielectronPair* pair, Int_t pdgMother){
+ return GetLabelMotherWithPdg(pair->GetFirstDaughter(),pair->GetSecondDaughter(),pdgMother);
+}
#endif
AliDielectronPair::AliDielectronPair() :
fOpeningAngle(-1),
fType(-1),
+ fLabel(-1),
fPair(),
fRefD1(),
fRefD2()
AliVTrack * const particle2, Int_t pid2, Char_t type) :
fOpeningAngle(-1),
fType(type),
+ fLabel(-1),
fPair(),
fRefD1(),
fRefD2()
fPair.AddDaughter(kf1);
fPair.AddDaughter(kf2);
- fRefD1 = particle1;
- fRefD2 = particle2;
+ if (particle1->Pt()>particle2->Pt()){
+ fRefD1 = particle1;
+ fRefD2 = particle2;
+ } else {
+ fRefD1 = particle2;
+ fRefD2 = particle1;
+ }
fOpeningAngle=kf1.GetAngle(kf2);
}
virtual Double_t Y() const { return TLorentzVector(Px(),Py(),Pz(),E()).Rapidity();}
virtual Short_t Charge() const { return fPair.GetQ();}
- virtual Int_t GetLabel() const { return -1; } //TODO: check
+ virtual Int_t GetLabel() const { return fLabel; }
// PID
virtual const Double_t *PID() const { return 0;} //TODO: check
-
+ // Dummy
+ Int_t PdgCode() const {return 0;}
+
Double_t OpeningAngle() const { return fOpeningAngle; }
UChar_t GetType() const { return fType; }
void SetType(Char_t type) { fType=type; }
+
+ void SetLabel(Int_t label) {fLabel=label;}
// internal KF particle
const AliKFParticle& GetKFParticle() const { return fPair; }
// daughter references
AliVParticle* GetFirstDaughter() const { return dynamic_cast<AliVParticle*>(fRefD1.GetObject()); }
AliVParticle* GetSecondDaughter() const { return dynamic_cast<AliVParticle*>(fRefD2.GetObject()); }
- // Dummy
- Int_t PdgCode() const {return 0;}
+
private:
Double_t fOpeningAngle; // opening angle of the pair
- Char_t fType; // type of the pair e.g. like sign SE, unlike sign SE, ... see AliDielectron
-
+ Char_t fType; // type of the pair e.g. like sign SE, unlike sign SE, ... see AliDielectron
+ Int_t fLabel; // MC label
+
AliKFParticle fPair; // KF particle internally used for pair calculation
TRef fRefD1; // Reference to first daughter
TRef fRefD2; // Reference to second daughter
- ClassDef(AliDielectronPair,1)
+ ClassDef(AliDielectronPair,2)
};
#endif
virtual ~AliDielectronVarCuts();
//TODO: make copy constructor and assignment operator public
void AddCut(AliDielectronVarManager::ValueTypes type, Double_t min, Double_t max);
-
+ void AddCut(AliDielectronVarManager::ValueTypes type, Double_t value);
+
// setters
void SetCutOnMCtruth(Bool_t mc=kTRUE) { fCutOnMCtruth=mc; }
void SetCutType(CutType type) { fCutType=type; }
//
//Inline functions
//
+inline void AliDielectronVarCuts::AddCut(AliDielectronVarManager::ValueTypes type, Double_t value)
+{
+ //
+ // Set cut in a small delta around value
+ //
+ const Double_t kDelta=1e-20;
+ AddCut(type,value-kDelta,value+kDelta);
+}
#endif
"ImpactParZ",
"TrackLength",
"PdgCode",
- "P from InnerParam",
- "TPC signal",
- "TPC nSigma Electrons",
+ "P_InnerParam",
+ "TPC_signal",
+ "TPC_nSigma_Electrons",
//
"Chi2NDF",
"DecayLength",
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff