}
//______________________________________________
-THnBase* AliDielectron::InitEffMap(TString filename)
+TObject* AliDielectron::InitEffMap(TString filename)
{
// init an efficiency object for on-the-fly correction calculations
if(filename.Contains("alien://") && !gGrid) TGrid::Connect("alien://",0,0,"t");
TFile* file=TFile::Open(filename.Data());
if(!file) return 0x0;
+
+ // NOTE: the spline must have the 'variable name' stored in its fHistogram
+ TSpline3 *hEff = (TSpline3*) file->Get("hEfficiency");
+ //if(hEff) printf("we use a TSpline!!!!!!!!!!! \n");
+ if(hEff) return (hEff->Clone("effMap"));
+
+
THnBase *hGen = (THnBase*) file->Get("hGenerated");
THnBase *hFnd = (THnBase*) file->Get("hFound");
if(!hFnd || !hGen) return 0x0;
hFnd->Divide(hGen);
printf("[I] AliDielectron::InitEffMap efficiency maps %s with %d dimensions loaded! \n",filename.Data(),hFnd->GetNdimensions());
- return ((THnBase*) hFnd->Clone("effMap"));
+ return (hFnd->Clone("effMap"));
}
//________________________________________________________________
#include <TNamed.h>
#include <TObjArray.h>
#include <THnBase.h>
+#include <TSpline.h>
#include <AliAnalysisFilter.h>
#include <AliKFParticle.h>
AliDielectronCutQA *fQAmonitor; // monitoring of cuts
TH1 *fPostPIDCntrdCorr; // post pid correction object for centroids
TH1 *fPostPIDWdthCorr; // post pid correction object for widths
- THnBase *fLegEffMap; // single electron efficiency map
- THnBase *fPairEffMap; // pair efficiency map
+ TObject *fLegEffMap; // single electron efficiency map
+ TObject *fPairEffMap; // pair efficiency map
AliAnalysisFilter fEventFilter; // Event cuts
AliAnalysisFilter fTrackFilter; // leg cuts
AliAnalysisFilter fPairPreFilter; // pair prefilter cuts
void ClearArrays();
TObjArray* PairArray(Int_t i);
- THnBase* InitEffMap(TString filename);
+ TObject* InitEffMap(TString filename);
static const char* fgkTrackClassNames[4]; //Names for track arrays
static const char* fgkPairClassNames[11]; //Names for pair arrays
AliDielectronEventCuts::AliDielectronEventCuts() :
AliAnalysisCuts(),
+ fUsedVars(new TBits(AliDielectronVarManager::kNMaxValues)),
fRun(),
fVtxZmin(0.),
fVtxZmax(0.),
//
// Default Constructor
//
-
+ for (Int_t icut=0; icut<5; ++icut){
+ fCorrCutMin[icut]=0x0;
+ fCorrCutMax[icut]=0x0;
+ }
}
//______________________________________________
AliDielectronEventCuts::AliDielectronEventCuts(const char* name, const char* title) :
AliAnalysisCuts(name, title),
+ fUsedVars(new TBits(AliDielectronVarManager::kNMaxValues)),
fRun(),
fVtxZmin(0.),
fVtxZmax(0.),
//
// Named Constructor
//
+ for (Int_t icut=0; icut<5; ++icut){
+ fCorrCutMin[icut]=0x0;
+ fCorrCutMax[icut]=0x0;
+ }
}
//______________________________________________
//
// Default Destructor
//
+ if (fUsedVars) delete fUsedVars;
if (fTriggerAnalysis) delete fTriggerAnalysis;
}
AliAODEvent *ev=dynamic_cast<AliAODEvent*>(event);
if (!ev) return kFALSE;
+ //Fill values
+ Double_t values[AliDielectronVarManager::kNMaxValues];
+ if(fUsedVars->CountBits()) {
+ AliDielectronVarManager::SetFillMap(fUsedVars);
+ AliDielectronVarManager::Fill(ev,values);
+ }
+
+ // correlation cuts
+ for(Int_t i=0; i<5; i++) {
+ if(fCorrCutMin[i]) {
+ Double_t varx = values[fCorrCutMin[i]->GetXaxis()->GetUniqueID()];
+ Double_t vary = values[fCorrCutMin[i]->GetYaxis()->GetUniqueID()];
+ Double_t min = ((TF1*)fCorrCutMin[i]->GetListOfFunctions()->At(0))->Eval(varx);
+ // printf("coor cut %d: varx %f -> eval %f > %f \n",i,varx,min,vary);
+ if(vary<min) return kFALSE;
+ }
+ if(fCorrCutMax[i]) {
+ Double_t varx = values[fCorrCutMax[i]->GetXaxis()->GetUniqueID()];
+ Double_t vary = values[fCorrCutMax[i]->GetYaxis()->GetUniqueID()];
+ Double_t max = ((TF1*)fCorrCutMax[i]->GetListOfFunctions()->At(0))->Eval(varx);
+ if(vary>max) return kFALSE;
+ }
+ }
+
// run rejection
Int_t run = ev->GetRunNumber();
if(fRun.GetNrows()) {
return kTRUE;
}
+//______________________________________________
+void AliDielectronEventCuts::SetMinCorrCutFunction(TF1 *fun, UInt_t varx, UInt_t vary)
+{
+ //
+ // add correlation cut using a TF1
+ //
+ fUsedVars->SetBitNumber(varx,kTRUE);
+ fUsedVars->SetBitNumber(vary,kTRUE);
+ // store variables
+ fun->GetXaxis()->SetUniqueID(varx);
+ fun->GetYaxis()->SetUniqueID(vary);
+
+ Int_t i=0;
+ for(i=0; i<5; i++) {
+ if(fCorrCutMin[i]) continue;
+ else {
+ TString key=GetName(); key+=Form("Min%d",i);
+ // clone temporare histogram since otherwise it will not be streamed to file!
+ fCorrCutMin[i] = (TH1*)fun->GetHistogram()->Clone(key.Data());
+ fCorrCutMin[i]->GetListOfFunctions()->AddAt(fun,0);
+ break;
+ }
+ }
+ //printf("-----> corr cut added to %d %p \n",i,fCorrCutMin[i]);
+ // fCorrCutMin[i]->Print();
+ //fCorrCutMin[i]->GetListOfFunctions()->ls();
+}
+
+//______________________________________________
+void AliDielectronEventCuts::SetMaxCorrCutFunction(TF1 *fun, UInt_t varx, UInt_t vary)
+{
+ //
+ // add correlation cut using a TF1
+ //
+ fUsedVars->SetBitNumber(varx,kTRUE);
+ fUsedVars->SetBitNumber(vary,kTRUE);
+ // store variables
+ fun->GetXaxis()->SetUniqueID(varx);
+ fun->GetYaxis()->SetUniqueID(vary);
+
+ Int_t i=0;
+ for(i=0; i<5; i++) {
+ if(fCorrCutMax[i]) continue;
+ else {
+ TString key=GetName(); key+=Form("Max%d",i);
+ // clone temporare histogram since otherwise it will not be streamed to file!
+ fCorrCutMax[i] = (TH1*)fun->GetHistogram()->Clone(key.Data());
+ fCorrCutMax[i]->GetListOfFunctions()->AddAt(fun,0);
+ break;
+ }
+ }
+ //printf("-----> corr cut added to %d %p \n",i,fCorrCutMax[i]);
+ // fCorrCutMax[i]->Print();
+ // fCorrCutMax[i]->GetListOfFunctions()->ls();
+}
+
//________________________________________________________________________
void AliDielectronEventCuts::Print(const Option_t* /*option*/) const
{
#include <TF1.h>
#include <TVectorD.h>
+#include <TBits.h>
#include <AliAnalysisUtils.h>
#include <AliAnalysisCuts.h>
void SetCutOnV0MultipicityNTrks(TF1* parMean, TF1* parSigma, Double_t cutSigma=3.) { fparMean=parMean; fparSigma=parSigma; fcutSigma=cutSigma; }
void SetCutOnNVtxContributorsGloablTPC(TF1* parMin, TF1* parMax) { fparMinVtxContributors=parMin; fparMaxVtxContributors=parMax; }
void SetRequire2013vertexandevent(Bool_t req13 = kTRUE) {fRequire13sel = req13; }
+ void SetMinCorrCutFunction(TF1 *fun, UInt_t varx, UInt_t vary=0);
+ void SetMaxCorrCutFunction(TF1 *fun, UInt_t varx, UInt_t vary=0);
+
//
//Analysis cuts interface
//
private:
static const char* fgkVtxNames[AliDielectronEventCuts::kVtxTracksOrSPD+1]; //vertex names
+
+ TBits *fUsedVars; // list of used variables
TVectorD fRun; // run rejection vector
Double_t fVtxZmin; // minimum z vertex position
Double_t fVtxZmax; // maximum z vertex position
const AliESDVertex *fkVertex; //! current vertex
const AliAODVertex *fkVertexAOD; //! current vertex AOD
+ TH1* fCorrCutMin[5]; //parametrization of lower limit correlation cut
+ TH1* fCorrCutMax[5]; //parametrization of upper limit correlation cut
+
TF1* fparMean; // parametrization of the mean values
TF1* fparSigma; // parametrization of the sigmas
Double_t fcutSigma; // number of absolut sigmas inclusion
AliDielectronEventCuts &operator=(const AliDielectronEventCuts &c);
- ClassDef(AliDielectronEventCuts,3) // Dielectron EventCuts
+ ClassDef(AliDielectronEventCuts,4) // Dielectron EventCuts
};
AliKFVertex* AliDielectronVarManager::fgKFVertex = 0x0;
TProfile* AliDielectronVarManager::fgMultEstimatorAvg[4][9] = {{0x0}};
TH3D* AliDielectronVarManager::fgTRDpidEff[10][4] = {{0x0}};
-THnBase* AliDielectronVarManager::fgLegEffMap = 0x0;
-THnBase* AliDielectronVarManager::fgPairEffMap = 0x0;
+TObject* AliDielectronVarManager::fgLegEffMap = 0x0;
+TObject* AliDielectronVarManager::fgPairEffMap = 0x0;
TBits* AliDielectronVarManager::fgFillMap = 0x0;
Double_t AliDielectronVarManager::fgTRDpidEffCentRanges[10][4] = {{0.0}};
TString AliDielectronVarManager::fgVZEROCalibrationFile = "";
#include <TProfile3D.h>
#include <TH3D.h>
#include <THnBase.h>
+#include <TSpline.h>
#include <TFile.h>
#include <TDatabasePDG.h>
#include <TKey.h>
static void InitAODpidUtil(Int_t type=0);
static void InitEstimatorAvg(const Char_t* filename);
static void InitTRDpidEffHistograms(const Char_t* filename);
- static void SetLegEffMap( THnBase *map) { fgLegEffMap=map; }
- static void SetPairEffMap(THnBase *map) { fgPairEffMap=map; }
+ static void SetLegEffMap( TObject *map) { fgLegEffMap=map; }
+ static void SetPairEffMap(TObject *map) { fgPairEffMap=map; }
static void SetFillMap( TBits *map) { fgFillMap=map; }
static void SetVZEROCalibrationFile(const Char_t* filename) {fgVZEROCalibrationFile = filename;}
static TProfile *fgMultEstimatorAvg[4][9]; // multiplicity estimator averages (4 periods x 9 estimators)
static Double_t fgTRDpidEffCentRanges[10][4]; // centrality ranges for the TRD pid efficiency histograms
static TH3D *fgTRDpidEff[10][4]; // TRD pid efficiencies from conversion electrons
- static THnBase *fgLegEffMap; // single electron efficiencies
- static THnBase *fgPairEffMap; // pair efficiencies
+ static TObject *fgLegEffMap; // single electron efficiencies
+ static TObject *fgPairEffMap; // pair efficiencies
static TBits *fgFillMap; // map for requested variable filling
static TString fgVZEROCalibrationFile; // file with VZERO channel-by-channel calibrations
static TString fgVZERORecenteringFile; // file with VZERO Q-vector averages needed for event plane recentering
//
if(!fgLegEffMap) return -1.;
- Int_t dim=fgLegEffMap->GetNdimensions();
- Int_t idx[dim];
- for(Int_t idim=0; idim<dim; idim++) {
- UInt_t var = GetValueType(fgLegEffMap->GetAxis(idim)->GetName());
- idx[idim] = fgLegEffMap->GetAxis(idim)->FindBin(values[var]);
- if(idx[idim] < 0 || idx[idim]>fgLegEffMap->GetAxis(idim)->GetNbins()) return 0.0;
- /* printf(" [E] AliDielectronVarManager::GetSingleLegEff values %f for %s not found in axis range \n",values[var],fgLegEffMap->GetAxis(idim)->GetName()); */
- // printf(" (%d,%f,%s) \t",idx[idim],values[var],fgLegEffMap->GetAxis(idim)->GetName());
+ if(fgLegEffMap->IsA()== THnBase::Class()) {
+ THnBase *eff = static_cast<THnBase*>(fgLegEffMap);
+ Int_t dim=eff->GetNdimensions();
+ Int_t idx[dim];
+ for(Int_t idim=0; idim<dim; idim++) {
+ UInt_t var = GetValueType(eff->GetAxis(idim)->GetName());
+ idx[idim] = eff->GetAxis(idim)->FindBin(values[var]);
+ if(idx[idim] < 0 || idx[idim]>eff->GetAxis(idim)->GetNbins()) return 0.0;
+ }
+ // printf(" bin content %f+-%f \n",eff->GetBinContent(idx), eff->GetBinError(idx));
+ return (eff->GetBinContent(idx));
}
- // printf(" bin content %f+-%f \n",fgLegEffMap->GetBinContent(idx), fgLegEffMap->GetBinError(idx));
- // if(fgLegEffMap->GetBinContent(idx)<0.01) return 0.0;
- // if(fgLegEffMap->GetBinError(idx)/fgLegEffMap->GetBinContent(idx)>0.2) return 0.0;
- return (fgLegEffMap->GetBinContent(idx));
+ return -1.;
}
inline Double_t AliDielectronVarManager::GetPairEff(Double_t * const values) {
//
if(!fgPairEffMap) return -1.;
- Int_t dim=fgPairEffMap->GetNdimensions();
- Int_t idx[dim];
- for(Int_t idim=0; idim<dim; idim++) {
- UInt_t var = GetValueType(fgPairEffMap->GetAxis(idim)->GetName());
- idx[idim] = fgPairEffMap->GetAxis(idim)->FindBin(values[var]);
- if(idx[idim] < 0 || idx[idim]>fgPairEffMap->GetAxis(idim)->GetNbins()) return 0.0;
+ if(fgPairEffMap->IsA()== THnBase::Class()) {
+ THnBase *eff = static_cast<THnBase*>(fgPairEffMap);
+ Int_t dim=eff->GetNdimensions();
+ Int_t idx[dim];
+ for(Int_t idim=0; idim<dim; idim++) {
+ UInt_t var = GetValueType(eff->GetAxis(idim)->GetName());
+ idx[idim] = eff->GetAxis(idim)->FindBin(values[var]);
+ if(idx[idim] < 0 || idx[idim]>eff->GetAxis(idim)->GetNbins()) return 0.0;
+ }
+ // printf(" bin content %f+-%f \n",eff->GetBinContent(idx), eff->GetBinError(idx));
+ return (eff->GetBinContent(idx));
}
- // printf(" bin content %f+-%f \n",fgPairEffMap->GetBinContent(idx), fgPairEffMap->GetBinError(idx));
- return (fgPairEffMap->GetBinContent(idx));
+ if(fgPairEffMap->IsA()== TSpline3::Class()) {
+ TSpline3 *eff = static_cast<TSpline3*>(fgPairEffMap);
+ if(!eff->GetHistogram()) { printf("no histogram added to the spline\n"); return -1.;}
+ UInt_t var = GetValueType(eff->GetHistogram()->GetXaxis()->GetName());
+ //printf(" bin content %f \n",eff->Eval(values[var]) );
+ return (eff->Eval(values[var]));
+ }
+
+ return -1.;
}