later). Also, some bugfixes.
-This line, and those below, will be ignored--
M PWG3/dielectron/AliDielectron.cxx
M PWG3/dielectron/AliDielectronPair.h
M PWG3/dielectron/AliAnalysisTaskMultiDielectron.cxx
M PWG3/dielectron/AliDielectronVarManager.cxx
M PWG3/dielectron/AliDielectronMC.h
M PWG3/dielectron/AliDielectronCF.cxx
A PWG3/dielectron/AliDielectronCFdraw.h
M PWG3/dielectron/AliAnalysisTaskDielectronSE.cxx
M PWG3/dielectron/AliDielectronMC.cxx
M PWG3/dielectron/AliDielectron.h
A PWG3/dielectron/AliDielectronCFdraw.cxx
M PWG3/dielectron/AliDielectronVarManager.h
M PWG3/dielectron/AliAnalysisTaskDielectronFilter.cxx
M PWG3/dielectron/AliDielectronCF.h
M PWG3/libPWG3dielectron.pkg
M PWG3/PWG3dielectronLinkDef.h
#pragma link C++ class AliDielectronPair+;
#pragma link C++ class AliDielectronHistos+;
#pragma link C++ class AliDielectronCF+;
+#pragma link C++ class AliDielectronCFdraw+;
#pragma link C++ class AliDielectronMC+;
#pragma link C++ class AliDielectronVarManager+;
#pragma link C++ class AliAnalysisTaskDielectronSE+;
AliKFParticle::SetField( bz );
fDielectron->Process(InputEvent());
- fDielectron->FillHistograms();
if(fDielectron->HasCandidates()){
AliAODExtension *extDielectron = dynamic_cast<AliAODHandler*>
AliKFParticle::SetField( bz );
fDielectron->Process(InputEvent());
- fDielectron->FillHistograms();
if (fDielectron->GetHistogramList()){
PostData(1, const_cast<THashList*>(fDielectron->GetHistogramList()));
TIter nextDie(&fListDielectron);
AliDielectron *die=0;
while ( (die=static_cast<AliDielectron*>(nextDie())) ){
-// printf("Processing '%s'\n",die->GetName());
die->Process(InputEvent());
- die->FillHistograms();
}
PostData(1, &fListHistos);
// Initialise objects
//
if (fCfManagerPair) fCfManagerPair->InitialiseContainer(fPairFilter);
+ AliDielectronVarManager::InitESDpid(); //currently this will take the values for MC
}
//________________________________________________________________
// Process the events
//
+ AliDielectronVarManager::SetEvent(0x0);
+
//in case we have MC load the MC event and process the MC particles
if (AliDielectronMC::Instance()->ConnectMCEvent()) ProcessMC();
//apply event cuts
if ((ev1&&fEventFilter.IsSelected(ev1)!=selectedMask) ||
(ev2&&fEventFilter.IsSelected(ev2)!=selectedMask)) return;
-
+
+ AliDielectronVarManager::SetEvent(ev1);
+
//fill track arrays for the first event
if (ev1) FillTrackArrays(ev1);
FillPairArrays(itrackArr1, itrackArr2);
}
}
+
+ //in case there is a histogram manager, fill the QA histograms
+ if (fHistos) FillHistograms(ev1);
+
}
//________________________________________________________________
}
//________________________________________________________________
-void AliDielectron::FillHistograms()
+void AliDielectron::FillHistograms(const AliVEvent *ev)
{
//
// Fill Histogram information for tracks and pairs
//
- if (!fHistos) return;
TString className;
-
+ Double_t values[AliDielectronVarManager::kNMaxValues];
+ //Fill event information
+ AliDielectronVarManager::Fill(ev, values);
+ fHistos->FillClass("Event", AliDielectronVarManager::kNMaxValues, values);
+
//Fill track information, separately for the track array candidates
- Double_t trackValues[AliDielectronVarManager::kNMaxValues];
for (Int_t i=0; i<4; ++i){
className.Form("Track_%s",fgkTrackClassNames[i]);
Int_t ntracks=fTracks[i].GetEntriesFast();
for (Int_t itrack=0; itrack<ntracks; ++itrack){
- AliDielectronVarManager::Fill(fTracks[i].UncheckedAt(itrack), trackValues);
- fHistos->FillClass(className, AliDielectronVarManager::kNMaxValues, trackValues);
+ AliDielectronVarManager::Fill(fTracks[i].UncheckedAt(itrack), values);
+ fHistos->FillClass(className, AliDielectronVarManager::kNMaxValues, values);
}
}
//Fill Pair information, separately for all pair candidate arrays
- Double_t pairValues[AliDielectronVarManager::kNMaxValues];
for (Int_t i=0; i<10; ++i){
className.Form("Pair_%s",fgkPairClassNames[i]);
Int_t ntracks=PairArray(i)->GetEntriesFast();
for (Int_t ipair=0; ipair<ntracks; ++ipair){
- AliDielectronVarManager::Fill(PairArray(i)->UncheckedAt(ipair), pairValues);
- fHistos->FillClass(className, AliDielectronVarManager::kNMaxValues, pairValues);
+ AliDielectronVarManager::Fill(PairArray(i)->UncheckedAt(ipair), values);
+ fHistos->FillClass(className, AliDielectronVarManager::kNMaxValues, values);
}
}
void Process(AliVEvent *ev1, AliVEvent *ev2=0);
- void FillHistograms();
+ void FillHistograms(const AliVEvent *ev);
const AliAnalysisFilter& GetEventFilter() const { return fEventFilter; }
const AliAnalysisFilter& GetTrackFilter() const { return fTrackFilter; }
#include <AliCFContainer.h>
#include <AliAnalysisFilter.h>
#include <AliAnalysisCuts.h>
+#include <AliVParticle.h>
#include <AliLog.h>
#include "AliDielectronCF.h"
#include "AliDielectronMC.h"
+#include "AliDielectronPair.h"
ClassImp(AliDielectronCF)
TNamed("DielectronCF","DielectronCF"),
fNSteps(0),
fNVars(0),
+ fNVarsLeg(0),
fNCuts(0),
+ fValues(0x0),
fStepForMCtruth(kFALSE),
fStepForNoCutsMCmotherPid(kFALSE),
fStepForAfterAllCuts(kTRUE),
fNBins[i]=0;
fVarLoLimit[i]=0.;
fVarUpLimit[i]=0.;
+ fNBinsLeg[i]=0;
+ fVarLoLimitLeg[i]=0.;
+ fVarUpLimitLeg[i]=0.;
fStepMasks[i]=0xFFFFFF;
}
}
TNamed(name, title),
fNSteps(0),
fNVars(0),
+ fNVarsLeg(0),
fNCuts(0),
+ fValues(0x0),
fStepForMCtruth(kFALSE),
fStepForNoCutsMCmotherPid(kFALSE),
fStepForAfterAllCuts(kTRUE),
fNBins[i]=0;
fVarLoLimit[i]=0.;
fVarUpLimit[i]=0.;
+ fNBinsLeg[i]=0;
+ fVarLoLimitLeg[i]=0.;
+ fVarUpLimitLeg[i]=0.;
fStepMasks[i]=0xFFFFFF;
}
}
//
// Destructor
//
-
+ if (fValues) delete [] fValues;
}
//________________________________________________________________
-void AliDielectronCF::AddVariable(AliDielectronVarManager::ValueTypes type, Int_t nbins, Double_t min, Double_t max)
+void AliDielectronCF::AddVariable(AliDielectronVarManager::ValueTypes type, Int_t nbins, Double_t min, Double_t max, Bool_t leg)
{
//
// Add a variable to the CF configuration
//
- fVariables[fNVars] = (UInt_t)type;
- fVarLoLimit[fNVars] = min;
- fVarUpLimit[fNVars] = max;
- fNBins[fNVars] = nbins;
- ++fNVars;
+
+ if (!leg){
+ fVariables[fNVars] = (UInt_t)type;
+ fVarLoLimit[fNVars] = min;
+ fVarUpLimit[fNVars] = max;
+ fNBins[fNVars] = nbins;
+ ++fNVars;
+ } else {
+ fVariablesLeg[fNVarsLeg] = (UInt_t)type;
+ fVarLoLimitLeg[fNVarsLeg] = min;
+ fVarUpLimitLeg[fNVarsLeg] = max;
+ fNBinsLeg[fNVarsLeg] = nbins;
+ ++fNVarsLeg;
+ }
}
//________________________________________________________________
// e.g. cut2&cut3, cut2&cut3&cut4
fNSteps+=(2*fNStepMasks); // cuts for the additional cut masks
// create the container
- fCfContainer = new AliCFContainer(GetName(), GetTitle(), fNSteps, fNVars, fNBins);
+ Int_t *nbins=new Int_t[fNVars+2*fNVarsLeg];
+ for (Int_t i=0;i<fNVars;++i) nbins[i]=fNBins[i];
+ for (Int_t i=0;i<fNVarsLeg;++i) nbins[i+fNVars]=fNBinsLeg[i];
+ for (Int_t i=0;i<fNVarsLeg;++i) nbins[i+fNVars+fNVarsLeg]=fNBinsLeg[i];
+
+ fCfContainer = new AliCFContainer(GetName(), GetTitle(), fNSteps, fNVars+2*fNVarsLeg, nbins);
+ delete [] nbins;
// initialize the variables and their bin limits
for (Int_t iVar=0; iVar<fNVars; iVar++) {
fCfContainer->SetBinLimits(iVar, binLim);
fCfContainer->SetVarTitle(iVar, AliDielectronVarManager::GetValueName(type));
- delete binLim;
+ delete [] binLim;
+ }
+
+ // initialize the variables and their bin limits for the Legs
+ for (Int_t iVar=0; iVar<fNVarsLeg; iVar++) {
+ UInt_t type=fVariablesLeg[iVar];
+ Int_t nBins = fNBinsLeg[iVar];
+ Double_t loLim = fVarLoLimitLeg[iVar];
+ Double_t upLim = fVarUpLimitLeg[iVar];
+ Double_t *binLim = new Double_t[nBins+1];
+
+ // set the bin limits
+ for(Int_t iBin=0; iBin<=nBins; iBin++) binLim[iBin] = loLim + (upLim-loLim) / nBins*(Double_t)iBin;
+
+ //Leg1
+ fCfContainer->SetBinLimits(iVar+fNVars, binLim);
+ fCfContainer->SetVarTitle(iVar+fNVars, Form("Leg1_%s",AliDielectronVarManager::GetValueName(type)));
+
+ //Leg2
+ fCfContainer->SetBinLimits(iVar+fNVars+fNVarsLeg, binLim);
+ fCfContainer->SetVarTitle(iVar+fNVars+fNVarsLeg, Form("Leg2_%s",AliDielectronVarManager::GetValueName(type)));
+
+ delete [] binLim;
}
+
+ // array for storing values
+ fValues = new Double_t[fNVars+2*fNVarsLeg];
//=================//
// Set step titles //
}
//________________________________________________________________
-void AliDielectronCF::Fill(UInt_t mask, const TObject *particle)
+void AliDielectronCF::Fill(UInt_t mask, const AliDielectronPair *particle)
{
//
// Fill the containers
Bool_t isMCTruth=kFALSE;
if (fPdgMother>=0) isMCTruth=AliDielectronMC::Instance()->IsMotherPdg(particle,fPdgMother);
- Double_t valuesAll[AliDielectronVarManager::kNMaxValues];
- AliDielectronVarManager::Fill(particle,valuesAll);
+ Double_t valuesPair[AliDielectronVarManager::kNMaxValues];
+ AliDielectronVarManager::Fill(particle,valuesPair);
- Double_t values[AliDielectronVarManager::kNMaxValues];
for (Int_t iVar=0; iVar<fNVars; ++iVar){
Int_t var=fVariables[iVar];
- values[iVar]=valuesAll[var];
+ fValues[iVar]=valuesPair[var];
}
+ if (fNVarsLeg>0){
+ Double_t valuesLeg1[AliDielectronVarManager::kNMaxValues];
+ AliDielectronVarManager::Fill(particle->GetFirstDaughter(),valuesLeg1);
+ Double_t valuesLeg2[AliDielectronVarManager::kNMaxValues];
+ AliDielectronVarManager::Fill(particle->GetSecondDaughter(),valuesLeg2);
+
+ for (Int_t iVar=0; iVar<fNVarsLeg; ++iVar){
+ Int_t var=fVariablesLeg[iVar];
+ fValues[iVar+fNVars]=valuesLeg1[var];
+ fValues[iVar+fNVars+fNVarsLeg]=valuesLeg2[var];
+ }
+ }
+
UInt_t selectedMask=(1<<fNCuts)-1;
//============//
//No cuts (MC truth)
if (fStepForNoCutsMCmotherPid){
- if (isMCTruth) fCfContainer->Fill(values,step);
+ if (isMCTruth) fCfContainer->Fill(fValues,step);
++step;
}
//All cuts
if (fStepForAfterAllCuts){
if (mask == selectedMask){
- fCfContainer->Fill(values,step);
+ fCfContainer->Fill(fValues,step);
++step;
- if (isMCTruth) fCfContainer->Fill(values,step);
+ if (isMCTruth) fCfContainer->Fill(fValues,step);
++step;
} else {
step+=2;
if (fStepsForEachCut&&fNCuts>1){
for (Int_t iCut=0; iCut<fNCuts;++iCut) {
if (mask&(1<<iCut)) {
- fCfContainer->Fill(values,step);
+ fCfContainer->Fill(fValues,step);
++step;
- if (isMCTruth) fCfContainer->Fill(values,step);
+ if (isMCTruth) fCfContainer->Fill(fValues,step);
++step;
} else {
step+=2;
if (fStepsForCutsIncreasing&&fNCuts>2){
for (Int_t iCut=1; iCut<fNCuts-1;++iCut) {
if (mask&(1<<((iCut+1)-1))) {
- fCfContainer->Fill(values,step);
+ fCfContainer->Fill(fValues,step);
++step;
- if (isMCTruth) fCfContainer->Fill(values,step);
+ if (isMCTruth) fCfContainer->Fill(fValues,step);
++step;
} else {
step+=2;
for (UInt_t iComb=0; iComb<fNStepMasks; ++iComb){
UInt_t userMask=fStepMasks[iComb];
if (mask&userMask) {
- fCfContainer->Fill(values,step);
+ fCfContainer->Fill(fValues,step);
++step;
- if (isMCTruth) fCfContainer->Fill(values,step);
+ if (isMCTruth) fCfContainer->Fill(fValues,step);
++step;
} else {
step+=2;
//
if (!fStepForMCtruth) return;
- Double_t valuesAll[AliDielectronVarManager::kNMaxValues];
- AliDielectronVarManager::Fill(particle,valuesAll);
+ Double_t valuesPair[AliDielectronVarManager::kNMaxValues];
+ AliDielectronVarManager::Fill(particle,valuesPair);
+
+ //TODO: temporary solution, set manually the pair type to 1: mixed e+-
+ valuesPair[AliDielectronVarManager::kPairType]=1;
- Double_t values[AliDielectronVarManager::kNMaxValues];
for (Int_t iVar=0; iVar<fNVars; ++iVar){
Int_t var=fVariables[iVar];
- values[iVar]=valuesAll[var];
+ fValues[iVar]=valuesPair[var];
}
- //TODO: temporary solution, set manually the pair type to 1: mixed e+-
- values[AliDielectronVarManager::kPairType]=1;
- fCfContainer->Fill(values,0);
+
+ if (fNVarsLeg>0){
+ AliVParticle *d1=0x0;
+ 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);
+
+ for (Int_t iVar=0; iVar<fNVarsLeg; ++iVar){
+ Int_t var=fVariablesLeg[iVar];
+ fValues[iVar+fNVars]=valuesLeg1[var];
+ fValues[iVar+fNVars+fNVarsLeg]=valuesLeg2[var];
+ }
+ }
+
+ fCfContainer->Fill(fValues,0);
}
class AliAnalysisCuts;
class AliAnalysisFilter;
class AliCFContainer;
+class AliDielectronPair;
class AliDielectronCF : public TNamed {
public:
void AddStepMask(UInt_t mask) { fStepMasks[fNStepMasks++]=mask; }
- void AddVariable(AliDielectronVarManager::ValueTypes type, Int_t nbins, Double_t min, Double_t max);
+ void AddVariable(AliDielectronVarManager::ValueTypes type, Int_t nbins, Double_t min, Double_t max, Bool_t leg=kFALSE);
void InitialiseContainer(const AliAnalysisFilter& filter);
- void Fill(UInt_t mask, const TObject *particle);
+// void Fill(UInt_t mask, const TObject *particle);
+ void Fill(UInt_t mask, const AliDielectronPair *particle);
void FillMC(const TObject *particle);
AliCFContainer* GetContainer() const { return fCfContainer; }
-// private:
+private:
UInt_t fVariables[AliDielectronVarManager::kNMaxValues]; //configured variables
+ UInt_t fVariablesLeg[AliDielectronVarManager::kNMaxValues]; //configured variables for the legs
Int_t fNSteps; // number of selection steps
+
Int_t fNVars; // number of variables
Int_t fNBins[kNmaxAddSteps]; // array of numbers ob bins of the vars
Double_t fVarLoLimit[kNmaxAddSteps]; // array of the lower limits of the vars
Double_t fVarUpLimit[kNmaxAddSteps]; // array of the upper limits of the vars
- Int_t fNCuts; // Number of cuts in the filter concerned
+ Int_t fNVarsLeg; // number of variables for the legs
+ Int_t fNBinsLeg[kNmaxAddSteps]; // array of numbers ob bins of the vars for the legs
+ Double_t fVarLoLimitLeg[kNmaxAddSteps]; // array of the lower limits of the vars for the legs
+ Double_t fVarUpLimitLeg[kNmaxAddSteps]; // array of the upper limits of the vars for the legs
+
+ Int_t fNCuts; // Number of cuts in the filter concerned
+ Double_t *fValues; // Value array for filling the container
+
Bool_t fStepForMCtruth; //create a step for the MC truth
Bool_t fStepForNoCutsMCmotherPid; //create a step for before cuts, but with MC truth of the mother
Bool_t fStepForAfterAllCuts; //create a step for before cuts, but with MC truth of the mother
AliDielectronCF(const AliDielectronCF &c);
AliDielectronCF &operator=(const AliDielectronCF &c);
- ClassDef(AliDielectronCF,2) //Dielectron Correction Framework handler
+ ClassDef(AliDielectronCF,3) //Dielectron Correction Framework handler
};
#endif
--- /dev/null
+/*************************************************************************
+* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
+* *
+* Author: The ALICE Off-line Project. *
+* Contributors are mentioned in the code where appropriate. *
+* *
+* Permission to use, copy, modify and distribute this software and its *
+* documentation strictly for non-commercial purposes is hereby granted *
+* without fee, provided that the above copyright notice appears in all *
+* copies and that both the copyright notice and this permission notice *
+* appear in the supporting documentation. The authors make no claims *
+* about the suitability of this software for any purpose. It is *
+* provided "as is" without express or implied warranty. *
+**************************************************************************/
+
+///////////////////////////////////////////////////////////////////////////
+// Dielectron Correction framework draw helper //
+// //
+/*
+
+
+
+
+
+
+
+
+
+*/
+// //
+///////////////////////////////////////////////////////////////////////////
+
+#include <TSeqCollection.h>
+#include <TObjArray.h>
+#include <TKey.h>
+#include <TList.h>
+#include <TObject.h>
+#include <TFile.h>
+#include <TString.h>
+#include <TObjString.h>
+#include <TMath.h>
+#include <TH1.h>
+#include <TH2.h>
+#include <TH3.h>
+#include <TPad.h>
+#include <TCanvas.h>
+
+#include <AliLog.h>
+
+#include "AliDielectronCFdraw.h"
+
+ClassImp(AliDielectronCFdraw)
+
+AliDielectronCFdraw::AliDielectronCFdraw() :
+ TNamed(),
+ fCfContainer(0x0)
+{
+ //
+ // Ctor
+ //
+}
+
+//________________________________________________________________
+AliDielectronCFdraw::AliDielectronCFdraw(const char*name, const char* title) :
+ TNamed(name,title),
+ fCfContainer(0x0)
+{
+ //
+ // Named Ctor
+ //
+
+}
+
+//________________________________________________________________
+void AliDielectronCFdraw::SetCFContainers(const TSeqCollection *arr)
+{
+ //
+ // Merge CF Container out of several containers
+ //
+
+ TIter next(arr);
+ TObject *o=0x0;
+
+ Int_t nstep=0;
+ while ( (o=next()) ){
+ AliCFContainer *cf=dynamic_cast<AliCFContainer*>(o);
+ if (!o) continue;
+ nstep+=cf->GetNStep();
+ }
+ Int_t nbins[1]={1};
+ fCfContainer=new AliCFContainer(GetName(), GetTitle(), nstep, 1, nbins);
+
+ //delete unneeded steps
+ for (Int_t istep=0; istep<nstep; ++istep) delete fCfContainer->GetGrid(istep);
+
+ //add step to the new container
+ Int_t istep=0;
+ for (Int_t icf=0; icf<arr->GetEntries(); ++icf){
+ AliCFContainer *cf=dynamic_cast<AliCFContainer*>(arr->At(icf));
+ if (!cf) continue;
+ for (Int_t istepCurr=0; istepCurr<cf->GetNStep(); ++istepCurr){
+ fCfContainer->SetGrid(istep, cf->GetGrid(istepCurr));
+ fCfContainer->SetStepTitle(istep,Form("%s: %s",cf->GetName(),cf->GetStepTitle(istepCurr)));
+ ++istep;
+ }
+ }
+}
+
+//________________________________________________________________
+void AliDielectronCFdraw::SetCFContainers(const char* filename)
+{
+ //
+ // get CF containers from file
+ //
+
+ TFile f(filename);
+ TList *l=f.GetListOfKeys();
+ Int_t entries=l->GetEntries();
+ if (entries==0) return;
+
+ TKey *k=(TKey*)l->At(0);
+ TSeqCollection *arr=dynamic_cast<TSeqCollection*>(k->ReadObj());
+ if (!arr) return;
+
+ SetCFContainers(arr);
+}
+
+//________________________________________________________________
+void AliDielectronCFdraw::SetRangeUser(Int_t ivar, Double_t min, Double_t max, const char* slices)
+{
+ //
+ // Set range of cut steps defined in slices
+ // Steps may be separated by one the the characteres ,;:
+ //
+ TObjArray *arr=TString(slices).Tokenize(",:;");
+
+ if (arr->GetEntriesFast()==0){
+ // all slices in case of 0 entries
+ for (Int_t istep=0; istep<fCfContainer->GetNStep(); ++istep){
+ fCfContainer->SetRangeUser(ivar,min,max,istep);
+ }
+ } else {
+ TIter next(arr);
+ TObjString *ostr=0x0;
+ while ( (ostr=static_cast<TObjString*>(next())) ) {
+ Int_t istep=ostr->GetString().Atoi();
+ fCfContainer->SetRangeUser(ivar,min,max,istep);
+ }
+ }
+ delete arr;
+}
+
+//________________________________________________________________
+void AliDielectronCFdraw::UnsetRangeUser(Int_t ivar, const char* slices)
+{
+ //
+ // Unset range of cut steps defined in slices
+ // Steps may be separated by one the the characteres ,;:
+ //
+ TObjArray *arr=TString(slices).Tokenize(",:;");
+
+ if (arr->GetEntriesFast()==0){
+ // all slices in case of 0 entries
+ for (Int_t istep=0; istep<fCfContainer->GetNStep(); ++istep){
+ fCfContainer->SetRangeUser(ivar,fCfContainer->GetAxis(ivar,istep)->GetXmin(),
+ fCfContainer->GetAxis(ivar,istep)->GetXmax(),istep);
+ }
+ } else {
+ TIter next(arr);
+ TObjString *ostr=0x0;
+ while ( (ostr=static_cast<TObjString*>(next())) ) {
+ Int_t istep=ostr->GetString().Atoi();
+ fCfContainer->SetRangeUser(ivar,fCfContainer->GetAxis(ivar,istep)->GetXmin(),
+ fCfContainer->GetAxis(ivar,istep)->GetXmax(),istep);
+ }
+ }
+ delete arr;
+}
+
+//________________________________________________________________
+void AliDielectronCFdraw::Draw(const Option_t* varnames, const char* slices, const char* opt)
+{
+ //
+ // Draw 'variables' of 'slices'
+ // for multidimensional draw variables may be separated by a ':'
+ // slice numbers may be separated by any of ,:;
+ //
+ // variables may be called by either their name or number
+ //
+
+ 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:
+ Draw(ivar[0],slices,opt);
+ break;
+ case 2:
+ Draw(ivar[0],ivar[1],slices,opt);
+ break;
+ case 3:
+ Draw(ivar[0],ivar[1],ivar[2],slices,opt);
+ break;
+ }
+ delete arrVars;
+}
+
+//________________________________________________________________
+void AliDielectronCFdraw::Draw(Int_t var, const char* opt, const char* slices)
+{
+ //
+ // Draw variable var for all slices
+ // slices 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=CollectHistos(ndim,vars,slices);
+ Draw(arr,opt);
+ delete arr;
+}
+
+//________________________________________________________________
+void AliDielectronCFdraw::Draw(Int_t var0, Int_t var1, const char* opt, const char* slices)
+{
+ //
+ // Draw 2D case
+ //
+ const Int_t ndim=2;
+ Int_t vars[ndim]={var0,var1};
+ TObjArray *arr=CollectHistos(ndim,vars,slices);
+ Draw(arr,opt);
+ delete arr;
+}
+
+//________________________________________________________________
+void AliDielectronCFdraw::Draw(Int_t var0, Int_t var1, Int_t var2, const char* opt, const char* slices)
+{
+ //
+ // Draw 3D case
+ //
+ const Int_t ndim=3;
+ Int_t vars[ndim]={var0,var1,var2};
+ TObjArray *arr=CollectHistos(ndim,vars,slices);
+ Draw(arr,opt);
+ delete arr;
+}
+
+//________________________________________________________________
+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");
+ 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* AliDielectronCFdraw::CollectHistos(Int_t dim, Int_t *vars, const char* slices)
+{
+ //
+ // Collect histos with 'dim'ension of the 'slices' separated by one of "':;'"
+ // in a TObjArray and return it
+ //
+ 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){
+ arrHists->Add(Project(dim,vars,istep));
+ }
+ } else {
+ arrHists=new TObjArray(arr->GetEntriesFast());
+ TIter next(arr);
+ TObjString *ostr=0x0;
+ while ( (ostr=static_cast<TObjString*>(next())) ) {
+ Int_t istep=ostr->GetString().Atoi();
+ arrHists->Add(Project(dim,vars,istep));
+ }
+ }
+ 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;
+}
+
--- /dev/null
+#ifndef ALIDIELECTRONCFDRAW_H
+#define ALIDIELECTRONCFDRAW_H
+/* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+//#############################################################
+//# #
+//# Class AliDielectronCF #
+//# Dielectron Correction Framework Draw helper #
+//# #
+//# Authors: #
+//# Anton Andronic, GSI / A.Andronic@gsi.de #
+//# Ionut C. Arsene, GSI / I.C.Arsene@gsi.de #
+//# Julian Book, Uni Ffm / Julian.Book@cern.ch #
+//# Frederick Kramer, Uni Ffm, / Frederick.Kramer@cern.ch #
+//# Magnus Mager, CERN / Magnus.Mager@cern.ch #
+//# WooJin J. Park, GSI / W.J.Park@gsi.de #
+//# Jens Wiechula, Uni HD / Jens.Wiechula@cern.ch #
+//# #
+//#############################################################
+
+
+
+#include <TNamed.h>
+#include <AliCFContainer.h>
+
+class TObjArray;
+class TSeqCollection;
+class TH1;
+
+class AliCFContainer;
+
+class AliDielectronCFdraw : public TNamed {
+public:
+ AliDielectronCFdraw();
+ AliDielectronCFdraw(const char* name, const char* title);
+
+ void SetCFContainer(AliCFContainer * const container) {fCfContainer=container;}
+ void SetCFContainers(const TSeqCollection *arr);
+
+ void SetCFContainers(const char* filename);
+
+ AliCFContainer* GetCFContainer() const {return fCfContainer;}
+
+ void SetRangeUser(Int_t ivar, Double_t min, Double_t max, const char* slices="");
+ void SetRangeUser(const char* varname, Double_t min, Double_t max, const char* slices="");
+
+ void UnsetRangeUser(Int_t ivar, const char* slices="");
+ void UnsetRangeUser(const char* varname, const char* slices="");
+
+// virtual void Draw(const Option_t* /*option*/ = "") {;}
+ 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);
+ TH1* Project(Int_t ndim, Int_t *vars, Int_t slice);
+
+private:
+ AliCFContainer *fCfContainer; // CF container
+
+ AliDielectronCFdraw(const AliDielectronCFdraw &c);
+ AliDielectronCFdraw &operator=(const AliDielectronCFdraw &c);
+
+ ClassDef(AliDielectronCFdraw,0) // CF draw helper class
+};
+
+//
+// Inline functions
+//
+inline void AliDielectronCFdraw::SetRangeUser(const char* varname, Double_t min, Double_t max, const char* slices)
+{
+ SetRangeUser(fCfContainer->GetVar(varname),min,max,slices);
+}
+
+//________________________________________________________________
+inline void AliDielectronCFdraw::UnsetRangeUser(const char* varname, const char* slices)
+{
+ UnsetRangeUser(fCfContainer->GetVar(varname),slices);
+}
+#endif
+
return kTRUE;
}
+//____________________________________________________________
+void AliDielectronMC::GetDaughters(const TObject *mother, AliVParticle* &d1, AliVParticle* &d2)
+{
+ //
+ // Get First two daughters of the mother
+ //
+
+ Int_t lblD1=-1;
+ Int_t lblD2=-1;
+ d1=0;
+ d2=0;
+ if (!fMCEvent) return;
+ if (fAnaType==kAOD){
+ const AliAODMCParticle *aodMother=static_cast<const AliAODMCParticle*>(mother);
+ lblD1=aodMother->GetDaughter(0);
+ lblD2=aodMother->GetDaughter(1);
+ } else if (fAnaType==kESD){
+ const AliMCParticle *aodMother=static_cast<const AliMCParticle*>(mother);
+ lblD1=aodMother->GetFirstDaughter();
+ lblD2=aodMother->GetLastDaughter();
+ }
+ d1=fMCEvent->GetTrack(lblD1);
+ d2=fMCEvent->GetTrack(lblD2);
+}
AliMCParticle* GetMCTrack(AliESDtrack* _track); // return MC track associated with reco track
TParticle* GetMCTrackMotherFromStack(AliESDtrack* _track); // return MC mother track from stack
AliMCParticle* GetMCTrackMother(AliESDtrack* _track); // return MC mother track from stack
+
+ void GetDaughters(const TObject *mother, AliVParticle* &d1, AliVParticle* &d2);
private:
AliMCEvent *fMCEvent; // MC event object
virtual Double_t M() const { return fPair.GetMass(); }
virtual Double_t Eta() const { return fPair.GetEta();}
- virtual Double_t Y() const { return TLorentzVector(Px(),Py(),Pz(),E()).Y();}
+ 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
"PdgCode",
"P from InnerParam",
"TPC signal",
+ "TPC nSigma Electrons",
//
"Chi2NDF",
"DecayLength",
"YRes",
"ZRes",
"NTrk",
- "Tracks"
+ "Tracks",
+ "Nevents"
};
-
+AliESDpid* AliDielectronVarManager::fgESDpid = new AliESDpid;
+AliVEvent* AliDielectronVarManager::fgEvent = 0x0;
//________________________________________________________________
AliDielectronVarManager::AliDielectronVarManager() :
TNamed("AliDielectronVarManager","AliDielectronVarManager")
//# Anton Andronic, GSI / A.Andronic@gsi.de #
//# Ionut C. Arsene, GSI / I.C.Arsene@gsi.de #
//# Julian Book, Uni Ffm / Julian.Book@cern.ch #
-//# Frederick Kramer, Uni Ffm, / Frederick.Kramer@cern.ch #
+//# Frederick Kramer, Uni Ffm / Frederick.Kramer@cern.ch #
//# Magnus Mager, CERN / Magnus.Mager@cern.ch #
//# WooJin J. Park, GSI / W.J.Park@gsi.de #
//# Jens Wiechula, Uni HD / Jens.Wiechula@cern.ch #
#include <AliVEvent.h>
#include <AliESDEvent.h>
+#include <AliAODEvent.h>
+#include <AliMCEvent.h>
+#include <AliVVertex.h>
+#include <AliESDVertex.h>
#include <AliVParticle.h>
-#include <AliExternalTrackParam.h>
#include <AliESDtrack.h>
#include <AliAODTrack.h>
#include <AliKFParticle.h>
#include <AliAODMCParticle.h>
#include <AliVTrack.h> // ?
+#include <AliExternalTrackParam.h>
+#include <AliESDpid.h>
+
#include "AliDielectronPair.h"
class AliVEvent;
kPdgCode, // PDG code
kPIn, // momentum at inner wall of TPC (if available), used for PID
kTPCsignal, // TPC dE/dx signal
+ kTPCnSigmaEle, // number of sigmas to the dE/dx electron line in the TPC
kParticleMax, //
// TODO: kRNClusters ??
// AliDielectronPair specific variables
kPairType, // type of the pair, like like sign ++ unlikesign ...
kPairMax, //
// Event specific variables
- kXvPrim=kPairMax, // TODO: prim vertex
- kYvPrim, // TODO: prim vertex
- kZvPrim, // TODO: prim vertex
- kXRes, // primary vertex x-resolution (AliESDVertex)
- kYRes, // primary vertex y-resolution (AliESDVertex)
- kZRes, // primary vertex z-resolution (AliESDVertex)
+ kXvPrim=kPairMax, // prim vertex
+ kYvPrim, // prim vertex
+ kZvPrim, // prim vertex
+ kXRes, // primary vertex x-resolution
+ kYRes, // primary vertex y-resolution
+ kZRes, // primary vertex z-resolution
kNTrk, // number of tracks (or tracklets)
- kTracks, // ESD tracks (AliESDEvent)
+ kTracks, // ESD tracks
+ kNevents, // event counter
kNMaxValues //
// TODO: (for A+A) ZDCEnergy, impact parameter, Iflag??
};
virtual ~AliDielectronVarManager();
static void Fill(const TObject* particle, Double_t * const values);
+ static void InitESDpid(Int_t type=0);
+ static void SetEvent(AliVEvent * const ev) { fgEvent = ev; }
+
static const char* GetValueName(Int_t i) { return (i>=0&&i<kNMaxValues)?fgkParticleNames[i]:""; }
private:
static void FillVarVParticle(const AliVParticle *particle, Double_t * const values);
static void FillVarESDtrack(const AliESDtrack *particle, Double_t * const values);
static void FillVarAODTrack(const AliAODTrack *particle, Double_t * const values);
- static void FillVarMCParticle(const AliMCParticle *particle, Double_t * const values);
+ static void FillVarMCParticle(const AliMCParticle *particle, Double_t * const values);
static void FillVarAODMCParticle(const AliAODMCParticle *particle, Double_t * const values);
static void FillVarDielectronPair(const AliDielectronPair *pair, Double_t * const values);
+ static void FillVarVEvent(const AliVEvent *event, Double_t * const values);
+ static void FillVarESDEvent(const AliESDEvent *event, Double_t * const values);
+ static void FillVarAODEvent(const AliAODEvent *event, Double_t * const values);
+ static void FillVarMCEvent(const AliMCEvent *event, Double_t * const values);
+
+ static AliESDpid* fgESDpid; // ESD pid object
+ static AliVEvent* fgEvent; // current event pointer
AliDielectronVarManager(const AliDielectronVarManager &c);
AliDielectronVarManager &operator=(const AliDielectronVarManager &c);
//Inline functions
-inline void AliDielectronVarManager::Fill(const TObject* particle, Double_t * const values)
+inline void AliDielectronVarManager::Fill(const TObject* object, Double_t * const values)
{
//
// Main function to fill all available variables according to the type of particle
//
- if (particle->IsA() == AliESDtrack::Class()) FillVarESDtrack(static_cast<const AliESDtrack*>(particle), values);
- else if (particle->IsA() == AliAODTrack::Class()) FillVarAODTrack(static_cast<const AliAODTrack*>(particle), values);
- else if (particle->IsA() == AliMCParticle::Class()) FillVarMCParticle(static_cast<const AliMCParticle*>(particle), values);
- else if (particle->IsA() == AliAODMCParticle::Class()) FillVarAODMCParticle(static_cast<const AliAODMCParticle*>(particle), values);
- else if (particle->IsA() == AliDielectronPair::Class()) FillVarDielectronPair(static_cast<const AliDielectronPair*>(particle), values);
-// else Error("Fill",Form("Type %s is not supported by AliDielectronVarManager!", particle->ClassName())); //TODO: implement without object needed
+ if (object->IsA() == AliESDtrack::Class()) FillVarESDtrack(static_cast<const AliESDtrack*>(object), values);
+ else if (object->IsA() == AliAODTrack::Class()) FillVarAODTrack(static_cast<const AliAODTrack*>(object), values);
+ else if (object->IsA() == AliMCParticle::Class()) FillVarMCParticle(static_cast<const AliMCParticle*>(object), values);
+ else if (object->IsA() == AliAODMCParticle::Class()) FillVarAODMCParticle(static_cast<const AliAODMCParticle*>(object), values);
+ else if (object->IsA() == AliDielectronPair::Class()) FillVarDielectronPair(static_cast<const AliDielectronPair*>(object), values);
+
+ // Main function to fill all available variables according to the type of event
+
+ else if (object->IsA() == AliVEvent::Class()) FillVarVEvent(static_cast<const AliVEvent*>(object), values);
+ else if (object->IsA() == AliESDEvent::Class()) FillVarESDEvent(static_cast<const AliESDEvent*>(object), values);
+ else if (object->IsA() == AliAODEvent::Class()) FillVarAODEvent(static_cast<const AliAODEvent*>(object), values);
+ else if (object->IsA() == AliMCEvent::Class()) FillVarMCEvent(static_cast<const AliMCEvent*>(object), values);
+// else Error("Fill",Form("Type %s is not supported by AliDielectronVarManager!", object->ClassName())); //TODO: implement without object needed
}
inline void AliDielectronVarManager::FillVarVParticle(const AliVParticle *particle, Double_t * const values)
values[AliDielectronVarManager::kE] = particle->E();
values[AliDielectronVarManager::kM] = particle->M();
values[AliDielectronVarManager::kCharge] = particle->Charge();
+
+ if ( fgEvent ) AliDielectronVarManager::Fill(fgEvent, values);
}
inline void AliDielectronVarManager::FillVarESDtrack(const AliESDtrack *particle, Double_t * const values)
values[AliDielectronVarManager::kImpactParZ] = impactParZ;
values[AliDielectronVarManager::kTrackLength] = particle->GetIntegratedLength();
-
//dEdx information
Double_t mom = particle->GetP();
const AliExternalTrackParam *in=particle->GetInnerParam();
if (in) mom = in->GetP();
values[AliDielectronVarManager::kPIn]=mom;
values[AliDielectronVarManager::kTPCsignal]=particle->GetTPCsignal();
-
+ // nsigma to Electron band
+ // TODO: for the moment we set the bethe bloch parameters manually
+ // this should be changed in future!
+ values[AliDielectronVarManager::kTPCnSigmaEle]=fgESDpid->NumberOfSigmasTPC(particle,AliPID::kElectron);
}
inline void AliDielectronVarManager::FillVarAODTrack(const AliAODTrack *particle, Double_t * const values)
values[AliDielectronVarManager::kPairType] = pair->GetType();
}
+
+inline void AliDielectronVarManager::FillVarVEvent(const AliVEvent *event, Double_t * const values)
+{
+ //
+ // Fill event information available for histogramming into an array
+ //
+ const AliVVertex *primVtx = event->GetPrimaryVertex();
+ values[AliDielectronVarManager::kXvPrim] = primVtx->GetX();
+ values[AliDielectronVarManager::kYvPrim] = primVtx->GetY();
+ values[AliDielectronVarManager::kZvPrim] = primVtx->GetZ();
+ values[AliDielectronVarManager::kChi2NDF] = primVtx->GetChi2perNDF();
+
+ values[AliDielectronVarManager::kNTrk] = event->GetNumberOfTracks();
+ values[AliDielectronVarManager::kNevents] = 0; //always fill bin 0;
+}
+
+inline void AliDielectronVarManager::FillVarESDEvent(const AliESDEvent *event, Double_t * const values)
+{
+ //
+ // Fill event information available for histogramming into an array
+ //
+
+ // Fill common AliVEvent interface information
+ FillVarVEvent(event, values);
+
+ // Fill AliESDEvent interface specific information
+ const AliESDVertex *primVtx = event->GetPrimaryVertex();
+ values[AliDielectronVarManager::kXRes] = primVtx->GetXRes();
+ values[AliDielectronVarManager::kYRes] = primVtx->GetYRes();
+ values[AliDielectronVarManager::kZRes] = primVtx->GetZRes();
+}
+
+inline void AliDielectronVarManager::FillVarAODEvent(const AliAODEvent *event, Double_t * const values)
+{
+ //
+ // Fill event information available for histogramming into an array
+ //
+
+ // Fill common AliVEvent interface information
+ FillVarVEvent(event, values);
+
+ // Fill AliAODEvent interface specific information
+}
+
+inline void AliDielectronVarManager::FillVarMCEvent(const AliMCEvent *event, Double_t * const values)
+{
+ //
+ // Fill event information available for histogramming into an array
+ //
+
+ // Fill common AliVEvent interface information
+ FillVarVEvent(event, values);
+
+ // Fill AliMCEvent interface specific information
+}
+
+inline void AliDielectronVarManager::InitESDpid(Int_t type)
+{
+ //
+ // initialize PID parameters
+ // type=0 is simulation
+ // type=1 is data
+
+ Double_t alephParameters[5];
+ // simulation
+ alephParameters[0] = 2.15898e+00/50.;
+ alephParameters[1] = 1.75295e+01;
+ alephParameters[2] = 3.40030e-09;
+ alephParameters[3] = 1.96178e+00;
+ alephParameters[4] = 3.91720e+00;
+
+ // data
+ if (type==1){
+ alephParameters[0] = 0.0283086;
+ alephParameters[1] = 2.63394e+01;
+ alephParameters[2] = 5.04114e-11;
+ alephParameters[3] = 2.12543e+00;
+ alephParameters[4] = 4.88663e+00;
+ }
+
+ fgESDpid->GetTPCResponse().SetBetheBlochParameters(
+ alephParameters[0],alephParameters[1],alephParameters[2],
+ alephParameters[3],alephParameters[4]);
+
+}
+
/*
inline void AliDielectronVarManager::FillValues(const TParticle *particle, Double_t *values)
{
dielectron/AliDielectronPair.cxx \
dielectron/AliDielectronHistos.cxx \
dielectron/AliDielectronCF.cxx \
+ dielectron/AliDielectronCFdraw.cxx \
dielectron/AliDielectronMC.cxx \
dielectron/AliDielectronVarManager.cxx \
dielectron/AliAnalysisTaskDielectronSE.cxx \
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff