From 6551594bacbfb878bf120d44d6bf9e5aff4675ad Mon Sep 17 00:00:00 2001 From: andronic Date: Tue, 9 Mar 2010 21:38:06 +0000 Subject: [PATCH] Add a draw class for the CORRFW (produces a warning, will be fixed 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 --- PWG3/PWG3dielectronLinkDef.h | 1 + .../AliAnalysisTaskDielectronFilter.cxx | 1 - .../AliAnalysisTaskDielectronSE.cxx | 1 - .../AliAnalysisTaskMultiDielectron.cxx | 2 - PWG3/dielectron/AliDielectron.cxx | 30 +- PWG3/dielectron/AliDielectron.h | 2 +- PWG3/dielectron/AliDielectronCF.cxx | 141 +++++-- PWG3/dielectron/AliDielectronCF.h | 21 +- PWG3/dielectron/AliDielectronCFdraw.cxx | 344 ++++++++++++++++++ PWG3/dielectron/AliDielectronCFdraw.h | 84 +++++ PWG3/dielectron/AliDielectronMC.cxx | 24 ++ PWG3/dielectron/AliDielectronMC.h | 2 + PWG3/dielectron/AliDielectronPair.h | 2 +- PWG3/dielectron/AliDielectronVarManager.cxx | 7 +- PWG3/dielectron/AliDielectronVarManager.h | 153 +++++++- PWG3/libPWG3dielectron.pkg | 1 + 16 files changed, 744 insertions(+), 72 deletions(-) create mode 100644 PWG3/dielectron/AliDielectronCFdraw.cxx create mode 100644 PWG3/dielectron/AliDielectronCFdraw.h diff --git a/PWG3/PWG3dielectronLinkDef.h b/PWG3/PWG3dielectronLinkDef.h index a514fd4d130..27662d0064d 100644 --- a/PWG3/PWG3dielectronLinkDef.h +++ b/PWG3/PWG3dielectronLinkDef.h @@ -10,6 +10,7 @@ #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+; diff --git a/PWG3/dielectron/AliAnalysisTaskDielectronFilter.cxx b/PWG3/dielectron/AliAnalysisTaskDielectronFilter.cxx index 6037feccd81..89826cf79ec 100644 --- a/PWG3/dielectron/AliAnalysisTaskDielectronFilter.cxx +++ b/PWG3/dielectron/AliAnalysisTaskDielectronFilter.cxx @@ -88,7 +88,6 @@ void AliAnalysisTaskDielectronFilter::UserExec(Option_t *) AliKFParticle::SetField( bz ); fDielectron->Process(InputEvent()); - fDielectron->FillHistograms(); if(fDielectron->HasCandidates()){ AliAODExtension *extDielectron = dynamic_cast diff --git a/PWG3/dielectron/AliAnalysisTaskDielectronSE.cxx b/PWG3/dielectron/AliAnalysisTaskDielectronSE.cxx index 0fef4149978..deded5e636d 100644 --- a/PWG3/dielectron/AliAnalysisTaskDielectronSE.cxx +++ b/PWG3/dielectron/AliAnalysisTaskDielectronSE.cxx @@ -82,7 +82,6 @@ void AliAnalysisTaskDielectronSE::UserExec(Option_t *) AliKFParticle::SetField( bz ); fDielectron->Process(InputEvent()); - fDielectron->FillHistograms(); if (fDielectron->GetHistogramList()){ PostData(1, const_cast(fDielectron->GetHistogramList())); diff --git a/PWG3/dielectron/AliAnalysisTaskMultiDielectron.cxx b/PWG3/dielectron/AliAnalysisTaskMultiDielectron.cxx index db99c113dc1..d2fa05fb5ec 100644 --- a/PWG3/dielectron/AliAnalysisTaskMultiDielectron.cxx +++ b/PWG3/dielectron/AliAnalysisTaskMultiDielectron.cxx @@ -96,9 +96,7 @@ void AliAnalysisTaskMultiDielectron::UserExec(Option_t *) TIter nextDie(&fListDielectron); AliDielectron *die=0; while ( (die=static_cast(nextDie())) ){ -// printf("Processing '%s'\n",die->GetName()); die->Process(InputEvent()); - die->FillHistograms(); } PostData(1, &fListHistos); diff --git a/PWG3/dielectron/AliDielectron.cxx b/PWG3/dielectron/AliDielectron.cxx index 902e3eda7f2..c4dd961d3a3 100644 --- a/PWG3/dielectron/AliDielectron.cxx +++ b/PWG3/dielectron/AliDielectron.cxx @@ -132,6 +132,7 @@ void AliDielectron::Init() // Initialise objects // if (fCfManagerPair) fCfManagerPair->InitialiseContainer(fPairFilter); + AliDielectronVarManager::InitESDpid(); //currently this will take the values for MC } //________________________________________________________________ @@ -141,6 +142,8 @@ void AliDielectron::Process(AliVEvent *ev1, AliVEvent *ev2) // 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(); @@ -157,7 +160,9 @@ void AliDielectron::Process(AliVEvent *ev1, AliVEvent *ev2) //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); @@ -170,6 +175,10 @@ void AliDielectron::Process(AliVEvent *ev1, AliVEvent *ev2) FillPairArrays(itrackArr1, itrackArr2); } } + + //in case there is a histogram manager, fill the QA histograms + if (fHistos) FillHistograms(ev1); + } //________________________________________________________________ @@ -193,34 +202,35 @@ void AliDielectron::ProcessMC() } //________________________________________________________________ -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; itrackFillClass(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; ipairUncheckedAt(ipair), pairValues); - fHistos->FillClass(className, AliDielectronVarManager::kNMaxValues, pairValues); + AliDielectronVarManager::Fill(PairArray(i)->UncheckedAt(ipair), values); + fHistos->FillClass(className, AliDielectronVarManager::kNMaxValues, values); } } diff --git a/PWG3/dielectron/AliDielectron.h b/PWG3/dielectron/AliDielectron.h index 19e0c91cbeb..a20b016095e 100644 --- a/PWG3/dielectron/AliDielectron.h +++ b/PWG3/dielectron/AliDielectron.h @@ -45,7 +45,7 @@ public: 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; } diff --git a/PWG3/dielectron/AliDielectronCF.cxx b/PWG3/dielectron/AliDielectronCF.cxx index 8c80541a2d0..7a0dc7730c4 100644 --- a/PWG3/dielectron/AliDielectronCF.cxx +++ b/PWG3/dielectron/AliDielectronCF.cxx @@ -35,10 +35,12 @@ #include #include #include +#include #include #include "AliDielectronCF.h" #include "AliDielectronMC.h" +#include "AliDielectronPair.h" ClassImp(AliDielectronCF) @@ -46,7 +48,9 @@ AliDielectronCF::AliDielectronCF() : TNamed("DielectronCF","DielectronCF"), fNSteps(0), fNVars(0), + fNVarsLeg(0), fNCuts(0), + fValues(0x0), fStepForMCtruth(kFALSE), fStepForNoCutsMCmotherPid(kFALSE), fStepForAfterAllCuts(kTRUE), @@ -67,6 +71,9 @@ AliDielectronCF::AliDielectronCF() : fNBins[i]=0; fVarLoLimit[i]=0.; fVarUpLimit[i]=0.; + fNBinsLeg[i]=0; + fVarLoLimitLeg[i]=0.; + fVarUpLimitLeg[i]=0.; fStepMasks[i]=0xFFFFFF; } } @@ -76,7 +83,9 @@ AliDielectronCF::AliDielectronCF(const char* name, const char* title) : TNamed(name, title), fNSteps(0), fNVars(0), + fNVarsLeg(0), fNCuts(0), + fValues(0x0), fStepForMCtruth(kFALSE), fStepForNoCutsMCmotherPid(kFALSE), fStepForAfterAllCuts(kTRUE), @@ -97,6 +106,9 @@ AliDielectronCF::AliDielectronCF(const char* name, const char* title) : fNBins[i]=0; fVarLoLimit[i]=0.; fVarUpLimit[i]=0.; + fNBinsLeg[i]=0; + fVarLoLimitLeg[i]=0.; + fVarUpLimitLeg[i]=0.; fStepMasks[i]=0xFFFFFF; } } @@ -107,20 +119,29 @@ AliDielectronCF::~AliDielectronCF() // // 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; + } } //________________________________________________________________ @@ -142,7 +163,13 @@ void AliDielectronCF::InitialiseContainer(const AliAnalysisFilter& filter) // 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;iSetBinLimits(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; iVarSetBinLimits(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 // @@ -231,7 +283,7 @@ void AliDielectronCF::InitialiseContainer(const AliAnalysisFilter& filter) } //________________________________________________________________ -void AliDielectronCF::Fill(UInt_t mask, const TObject *particle) +void AliDielectronCF::Fill(UInt_t mask, const AliDielectronPair *particle) { // // Fill the containers @@ -240,15 +292,27 @@ void AliDielectronCF::Fill(UInt_t mask, const TObject *particle) 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; iVar0){ + 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; iVarFill(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; @@ -280,9 +344,9 @@ void AliDielectronCF::Fill(UInt_t mask, const TObject *particle) if (fStepsForEachCut&&fNCuts>1){ for (Int_t iCut=0; iCutFill(values,step); + fCfContainer->Fill(fValues,step); ++step; - if (isMCTruth) fCfContainer->Fill(values,step); + if (isMCTruth) fCfContainer->Fill(fValues,step); ++step; } else { step+=2; @@ -294,9 +358,9 @@ void AliDielectronCF::Fill(UInt_t mask, const TObject *particle) if (fStepsForCutsIncreasing&&fNCuts>2){ for (Int_t iCut=1; iCutFill(values,step); + fCfContainer->Fill(fValues,step); ++step; - if (isMCTruth) fCfContainer->Fill(values,step); + if (isMCTruth) fCfContainer->Fill(fValues,step); ++step; } else { step+=2; @@ -308,9 +372,9 @@ void AliDielectronCF::Fill(UInt_t mask, const TObject *particle) for (UInt_t iComb=0; iCombFill(values,step); + fCfContainer->Fill(fValues,step); ++step; - if (isMCTruth) fCfContainer->Fill(values,step); + if (isMCTruth) fCfContainer->Fill(fValues,step); ++step; } else { step+=2; @@ -327,16 +391,33 @@ void AliDielectronCF::FillMC(const TObject *particle) // 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; iVarFill(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; iVarFill(fValues,0); } diff --git a/PWG3/dielectron/AliDielectronCF.h b/PWG3/dielectron/AliDielectronCF.h index 272791c982b..609cd42834d 100644 --- a/PWG3/dielectron/AliDielectronCF.h +++ b/PWG3/dielectron/AliDielectronCF.h @@ -27,6 +27,7 @@ class AliAnalysisCuts; class AliAnalysisFilter; class AliCFContainer; +class AliDielectronPair; class AliDielectronCF : public TNamed { public: @@ -46,26 +47,36 @@ 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 @@ -82,7 +93,7 @@ public: AliDielectronCF(const AliDielectronCF &c); AliDielectronCF &operator=(const AliDielectronCF &c); - ClassDef(AliDielectronCF,2) //Dielectron Correction Framework handler + ClassDef(AliDielectronCF,3) //Dielectron Correction Framework handler }; #endif diff --git a/PWG3/dielectron/AliDielectronCFdraw.cxx b/PWG3/dielectron/AliDielectronCFdraw.cxx new file mode 100644 index 00000000000..4deb36dd3b5 --- /dev/null +++ b/PWG3/dielectron/AliDielectronCFdraw.cxx @@ -0,0 +1,344 @@ +/************************************************************************* +* 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#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(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; istepGetGrid(istep); + + //add step to the new container + Int_t istep=0; + for (Int_t icf=0; icfGetEntries(); ++icf){ + AliCFContainer *cf=dynamic_cast(arr->At(icf)); + if (!cf) continue; + for (Int_t istepCurr=0; istepCurrGetNStep(); ++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(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; istepGetNStep(); ++istep){ + fCfContainer->SetRangeUser(ivar,min,max,istep); + } + } else { + TIter next(arr); + TObjString *ostr=0x0; + while ( (ostr=static_cast(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; istepGetNStep(); ++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(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(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; icd(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; istepGetNStep(); ++istep){ + arrHists->Add(Project(dim,vars,istep)); + } + } else { + arrHists=new TObjArray(arr->GetEntriesFast()); + TIter next(arr); + TObjString *ostr=0x0; + while ( (ostr=static_cast(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; +} + diff --git a/PWG3/dielectron/AliDielectronCFdraw.h b/PWG3/dielectron/AliDielectronCFdraw.h new file mode 100644 index 00000000000..e79c5b64eec --- /dev/null +++ b/PWG3/dielectron/AliDielectronCFdraw.h @@ -0,0 +1,84 @@ +#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 +#include + +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 + diff --git a/PWG3/dielectron/AliDielectronMC.cxx b/PWG3/dielectron/AliDielectronMC.cxx index b2fcaf573a3..6ba008e179b 100644 --- a/PWG3/dielectron/AliDielectronMC.cxx +++ b/PWG3/dielectron/AliDielectronMC.cxx @@ -424,3 +424,27 @@ Bool_t AliDielectronMC::IsMotherPdgAOD(const AliVParticle *particle1, const AliV 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(mother); + lblD1=aodMother->GetDaughter(0); + lblD2=aodMother->GetDaughter(1); + } else if (fAnaType==kESD){ + const AliMCParticle *aodMother=static_cast(mother); + lblD1=aodMother->GetFirstDaughter(); + lblD2=aodMother->GetLastDaughter(); + } + d1=fMCEvent->GetTrack(lblD1); + d2=fMCEvent->GetTrack(lblD2); +} diff --git a/PWG3/dielectron/AliDielectronMC.h b/PWG3/dielectron/AliDielectronMC.h index 17231afafb4..cc0edef124e 100644 --- a/PWG3/dielectron/AliDielectronMC.h +++ b/PWG3/dielectron/AliDielectronMC.h @@ -61,6 +61,8 @@ public: 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 diff --git a/PWG3/dielectron/AliDielectronPair.h b/PWG3/dielectron/AliDielectronPair.h index 4c93cc8c749..7957a565d7d 100644 --- a/PWG3/dielectron/AliDielectronPair.h +++ b/PWG3/dielectron/AliDielectronPair.h @@ -68,7 +68,7 @@ public: 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 diff --git a/PWG3/dielectron/AliDielectronVarManager.cxx b/PWG3/dielectron/AliDielectronVarManager.cxx index a6fcbb53eda..b8247a5c0f6 100644 --- a/PWG3/dielectron/AliDielectronVarManager.cxx +++ b/PWG3/dielectron/AliDielectronVarManager.cxx @@ -56,6 +56,7 @@ const char* AliDielectronVarManager::fgkParticleNames[AliDielectronVarManager::k "PdgCode", "P from InnerParam", "TPC signal", + "TPC nSigma Electrons", // "Chi2NDF", "DecayLength", @@ -72,10 +73,12 @@ const char* AliDielectronVarManager::fgkParticleNames[AliDielectronVarManager::k "YRes", "ZRes", "NTrk", - "Tracks" + "Tracks", + "Nevents" }; - +AliESDpid* AliDielectronVarManager::fgESDpid = new AliESDpid; +AliVEvent* AliDielectronVarManager::fgEvent = 0x0; //________________________________________________________________ AliDielectronVarManager::AliDielectronVarManager() : TNamed("AliDielectronVarManager","AliDielectronVarManager") diff --git a/PWG3/dielectron/AliDielectronVarManager.h b/PWG3/dielectron/AliDielectronVarManager.h index c57f34db475..7e82f2c9b13 100644 --- a/PWG3/dielectron/AliDielectronVarManager.h +++ b/PWG3/dielectron/AliDielectronVarManager.h @@ -12,7 +12,7 @@ //# 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 # @@ -24,9 +24,12 @@ #include #include +#include +#include +#include +#include #include -#include #include #include #include @@ -34,6 +37,9 @@ #include #include // ? +#include +#include + #include "AliDielectronPair.h" class AliVEvent; @@ -74,6 +80,7 @@ public: 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 @@ -86,14 +93,15 @@ public: 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?? }; @@ -104,6 +112,9 @@ public: 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&&iIsA() == AliESDtrack::Class()) FillVarESDtrack(static_cast(particle), values); - else if (particle->IsA() == AliAODTrack::Class()) FillVarAODTrack(static_cast(particle), values); - else if (particle->IsA() == AliMCParticle::Class()) FillVarMCParticle(static_cast(particle), values); - else if (particle->IsA() == AliAODMCParticle::Class()) FillVarAODMCParticle(static_cast(particle), values); - else if (particle->IsA() == AliDielectronPair::Class()) FillVarDielectronPair(static_cast(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(object), values); + else if (object->IsA() == AliAODTrack::Class()) FillVarAODTrack(static_cast(object), values); + else if (object->IsA() == AliMCParticle::Class()) FillVarMCParticle(static_cast(object), values); + else if (object->IsA() == AliAODMCParticle::Class()) FillVarAODMCParticle(static_cast(object), values); + else if (object->IsA() == AliDielectronPair::Class()) FillVarDielectronPair(static_cast(object), values); + + // Main function to fill all available variables according to the type of event + + else if (object->IsA() == AliVEvent::Class()) FillVarVEvent(static_cast(object), values); + else if (object->IsA() == AliESDEvent::Class()) FillVarESDEvent(static_cast(object), values); + else if (object->IsA() == AliAODEvent::Class()) FillVarAODEvent(static_cast(object), values); + else if (object->IsA() == AliMCEvent::Class()) FillVarMCEvent(static_cast(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) @@ -162,6 +187,8 @@ inline void AliDielectronVarManager::FillVarVParticle(const AliVParticle *partic 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) @@ -188,14 +215,16 @@ inline void AliDielectronVarManager::FillVarESDtrack(const AliESDtrack *particle 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) @@ -257,6 +286,92 @@ inline void AliDielectronVarManager::FillVarDielectronPair(const AliDielectronPa 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) { diff --git a/PWG3/libPWG3dielectron.pkg b/PWG3/libPWG3dielectron.pkg index bceb5287db4..4e4aeb58f91 100644 --- a/PWG3/libPWG3dielectron.pkg +++ b/PWG3/libPWG3dielectron.pkg @@ -4,6 +4,7 @@ SRCS= dielectron/AliDielectron.cxx \ dielectron/AliDielectronPair.cxx \ dielectron/AliDielectronHistos.cxx \ dielectron/AliDielectronCF.cxx \ + dielectron/AliDielectronCFdraw.cxx \ dielectron/AliDielectronMC.cxx \ dielectron/AliDielectronVarManager.cxx \ dielectron/AliAnalysisTaskDielectronSE.cxx \ -- 2.39.3