#include <TList.h>
#include <TObjArray.h>
#include <TVectorD.h>
+#include <TString.h>
+#include <TObjString.h>
#include <AliCFContainer.h>
#include <AliAnalysisFilter.h>
fNVars(0),
fVarBinLimits(0x0),
fNVarsLeg(0),
+ fVarBinLimitsLeg(0x0),
fNCuts(0),
fValues(0x0),
fStepForMCtruth(kFALSE),
}
for (Int_t i=0; i<kNmaxAddSteps; ++i){
- fNBins[i]=0;
- fVarLoLimit[i]=0.;
- fVarUpLimit[i]=0.;
- fNBinsLeg[i]=0;
- fVarLoLimitLeg[i]=0.;
- fVarUpLimitLeg[i]=0.;
fStepMasks[i]=0xFFFFFF;
}
}
fNVars(0),
fVarBinLimits(0x0),
fNVarsLeg(0),
+ fVarBinLimitsLeg(0x0),
fNCuts(0),
fValues(0x0),
fStepForMCtruth(kFALSE),
}
for (Int_t i=0; i<kNmaxAddSteps; ++i){
- 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;
+ if (fVarBinLimits) delete fVarBinLimits;
+ if (fVarBinLimitsLeg) delete fVarBinLimitsLeg;
}
//________________________________________________________________
-void AliDielectronCF::AddVariable(AliDielectronVarManager::ValueTypes type, Int_t nbins, Double_t min, Double_t max, Bool_t leg)
+void AliDielectronCF::AddVariable(AliDielectronVarManager::ValueTypes type, Int_t nbins,
+ Double_t min, Double_t max, Bool_t leg, Bool_t log)
{
//
// Add a variable to the CF configuration
+ // if leg is true it will add the variables of the leg
+ // if log is true log binning will be created
//
+ TVectorD *binLimits=0x0;
+ if (!log) binLimits=MakeLinBinning(nbins,min,max);
+ else binLimits=MakeLogBinning(nbins,min,max);
+ AddVariable(type,binLimits,leg);
+}
+
+//________________________________________________________________
+void AliDielectronCF::AddVariable(AliDielectronVarManager::ValueTypes type, const char* binLimitStr, Bool_t leg/*=kFALSE*/)
+{
+ //
+ // Add a variable to the CF configuration
+ // specify arbitrary binning in a string.
+ // Bin limits need to be separated by a ","
+ //
+ TString limits(binLimitStr);
+ if (limits.IsNull()){
+ AliError(Form("Bin Limit string is empty, cannot add the variable '%s'",AliDielectronVarManager::GetValueName(type)));
+ return;
+ }
+
+ TObjArray *arr=limits.Tokenize(",");
+ Int_t nLimits=arr->GetEntries();
+ if (nLimits<2){
+ AliError(Form("Need at leas 2 bin limits, cannot add the variable '%s'",AliDielectronVarManager::GetValueName(type)));
+ delete arr;
+ return;
+ }
+
+ TVectorD *binLimits=new TVectorD(nLimits);
+ for (Int_t iLim=0; iLim<nLimits; ++iLim){
+ (*binLimits)[iLim]=(static_cast<TObjString*>(arr->At(iLim)))->GetString().Atof();
+ }
+
+ delete arr;
+ AddVariable(type,binLimits,leg);
+}
+
+//________________________________________________________________
+void AliDielectronCF::AddVariable(AliDielectronVarManager::ValueTypes type, TVectorD *binLimits, Bool_t leg/*=kFALSE*/)
+{
+ //
+ // Add variable with the binning given in the TVectorD
+ //
if (!leg){
- if (max<min){
- Double_t tmp=min;
- min=max;
- max=tmp;
+ if (!fVarBinLimits){
+ fVarBinLimits=new TObjArray;
+ fVarBinLimits->SetOwner();
}
+ fVarBinLimits->Add(binLimits);
fVariables[fNVars] = (UInt_t)type;
- fVarLoLimit[fNVars] = min;
- fVarUpLimit[fNVars] = max;
- fNBins[fNVars] = nbins;
++fNVars;
} else {
+ if (!fVarBinLimitsLeg){
+ fVarBinLimitsLeg=new TObjArray;
+ fVarBinLimitsLeg->SetOwner();
+ }
+ fVarBinLimitsLeg->Add(binLimits);
fVariablesLeg[fNVarsLeg] = (UInt_t)type;
- fVarLoLimitLeg[fNVarsLeg] = min;
- fVarUpLimitLeg[fNVarsLeg] = max;
- fNBinsLeg[fNVarsLeg] = nbins;
++fNVarsLeg;
}
}
-//________________________________________________________________
-void AliDielectronCF::AddVariable(AliDielectronVarManager::ValueTypes type, TVectorD * const binLimits)
-{
- //
- // Add a variable to the CF configuration
- //
- if (!binLimits) return;
- if (!fVarBinLimits) fVarBinLimits=new TObjArray(kNmaxAddSteps);
- fVarBinLimits->AddAt(binLimits, fNVars);
- fVariables[fNVars] = (UInt_t)type;
- fVarLoLimit[fNVars] = 2.;
- fVarUpLimit[fNVars] = 1.;
- fNBins[fNVars] = binLimits->GetNrows()-1;
- ++fNVars;
-}
-
//________________________________________________________________
void AliDielectronCF::InitialiseContainer(const AliAnalysisFilter& filter)
{
// e.g. cut2&cut3, cut2&cut3&cut4
fNSteps+=(fNAddSteps*fNStepMasks); // cuts for the additional cut masks
// create the container
+
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];
+ for (Int_t i=0;i<fNVars;++i) {
+ Int_t nBins=(static_cast<TVectorD*>(fVarBinLimits->At(i)))->GetNrows()-1;
+ nbins[i]=nBins;
+ }
+ for (Int_t i=0;i<fNVarsLeg;++i){
+ Int_t nBins=(static_cast<TVectorD*>(fVarBinLimitsLeg->At(i)))->GetNrows()-1;
+ nbins[i+fNVars]=nBins;
+ nbins[i+fNVars+fNVarsLeg]=nBins;
+ }
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++) {
UInt_t type=fVariables[iVar];
- Int_t nBins = fNBins[iVar];
- Double_t loLim = fVarLoLimit[iVar];
- Double_t upLim = fVarUpLimit[iVar];
- Double_t *binLim = 0x0;
-
- if (upLim<loLim) {
- if (!fVarBinLimits) {
- AliError(Form("Expected variable bin limits for variable %d (%s)",
- iVar,AliDielectronVarManager::GetValueName(type)));
- continue;
- }
- if (!fVarBinLimits->At(iVar)) {
- AliError(Form("Expected variable bin limits for variable %d (%s)",
- iVar,AliDielectronVarManager::GetValueName(type)));
- continue;
- }
- binLim=(static_cast<TVectorD*>(fVarBinLimits->At(iVar)))->GetMatrixArray();
- } else {
- 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;
- }
+ Double_t *binLim = (static_cast<TVectorD*>(fVarBinLimits->At(iVar)))->GetMatrixArray();
+
fCfContainer->SetBinLimits(iVar, binLim);
fCfContainer->SetVarTitle(iVar, AliDielectronVarManager::GetValueName(type));
- if ( upLim>loLim ) 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;
+ Double_t *binLim=(static_cast<TVectorD*>(fVarBinLimitsLeg->At(iVar)))->GetMatrixArray();
//Leg1
fCfContainer->SetBinLimits(iVar+fNVars, binLim);
//Leg2
fCfContainer->SetBinLimits(iVar+fNVars+fNVarsLeg, binLim);
fCfContainer->SetVarTitle(iVar+fNVars+fNVarsLeg, Form("Leg2_%s",AliDielectronVarManager::GetValueName(type)));
-
- delete [] binLim;
}
// array for storing values
fCfContainer->Fill(fValues,0);
}
+//_____________________________________________________________________________
+TVectorD* AliDielectronCF::MakeLogBinning(Int_t nbinsX, Double_t xmin, Double_t xmax) const
+{
+ //
+ // Make logarithmic binning
+ // the user has to delete the array afterwards!!!
+ //
+
+ //check limits
+ if (xmin<1e-20 || xmax<1e-20){
+ AliError("For Log binning xmin and xmax must be > 1e-20. Using linear binning instead!");
+ return MakeLinBinning(nbinsX, xmin, xmax);
+ }
+ if (xmax<xmin){
+ Double_t tmp=xmin;
+ xmin=xmax;
+ xmax=tmp;
+ }
+ TVectorD *binLim=new TVectorD(nbinsX+1);
+ Double_t first=xmin;
+ Double_t last=xmax;
+ Double_t expMax=TMath::Log(last/first);
+ for (Int_t i=0; i<nbinsX+1; ++i){
+ (*binLim)[i]=first*TMath::Exp(expMax/nbinsX*(Double_t)i);
+ }
+ return binLim;
+}
+
+//_____________________________________________________________________________
+TVectorD* AliDielectronCF::MakeLinBinning(Int_t nbinsX, Double_t xmin, Double_t xmax) const
+{
+ //
+ // Make logarithmic binning
+ // the user has to delete the array afterwards!!!
+ //
+ if (xmax<xmin){
+ Double_t tmp=xmin;
+ xmin=xmax;
+ xmax=tmp;
+ }
+ TVectorD *binLim=new TVectorD(nbinsX+1);
+ Double_t first=xmin;
+ Double_t last=xmax;
+ Double_t binWidth=(last-first)/nbinsX;
+ for (Int_t i=0; i<nbinsX+1; ++i){
+ (*binLim)[i]=first+binWidth*(Double_t)i;
+ }
+ return binLim;
+}
+
void AddStepMask(UInt_t mask) { fStepMasks[fNStepMasks++]=mask; }
- void AddVariable(AliDielectronVarManager::ValueTypes type, Int_t nbins, Double_t min, Double_t max, Bool_t leg=kFALSE);
- void AddVariable(AliDielectronVarManager::ValueTypes type, TVectorD * const binLimits);
+ void AddVariable(AliDielectronVarManager::ValueTypes type, Int_t nbins,
+ Double_t min, Double_t max, Bool_t leg=kFALSE, Bool_t log=kFALSE);
+ void AddVariable(AliDielectronVarManager::ValueTypes type, const char* binLimitStr, Bool_t leg=kFALSE);
+ void AddVariable(AliDielectronVarManager::ValueTypes type, TVectorD *binLimits, Bool_t leg=kFALSE);
void InitialiseContainer(const AliAnalysisFilter& filter);
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
- TObjArray *fVarBinLimits; // alternative array of bin limits
-
- 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
+ TObjArray *fVarBinLimits; // array of bin limits
+
+ Int_t fNVarsLeg; // number of variables for the legs
+ TObjArray *fVarBinLimitsLeg; // array of bin limits of the legs
Int_t fNCuts; // Number of cuts in the filter concerned
Bool_t fHasMC; //if MC info is available
Int_t fNAddSteps; //number of additional MC related steps per cut step
+
+ TVectorD* MakeLogBinning(Int_t nbinsX, Double_t xmin, Double_t xmax) const;
+ TVectorD* MakeLinBinning(Int_t nbinsX, Double_t xmin, Double_t xmax) const;
AliDielectronCF(const AliDielectronCF &c);
AliDielectronCF &operator=(const AliDielectronCF &c);
- ClassDef(AliDielectronCF,3) //Dielectron Correction Framework handler
+ ClassDef(AliDielectronCF,4) //Dielectron Correction Framework handler
};
#endif
if (fgInstance) return fgInstance;
AnalysisType type=kUNSET;
- if (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()->IsA()==AliESDInputHandler::Class()) type=kESD;
- else if (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()->IsA()==AliAODHandler::Class()) type=kAOD;
-
- AliMCEventHandler* mcHandler = dynamic_cast<AliMCEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
+ Bool_t hasMC=kFALSE;
+ if (AliAnalysisManager::GetAnalysisManager()){
+ if (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()->IsA()==AliESDInputHandler::Class()) type=kESD;
+ else if (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()->IsA()==AliAODHandler::Class()) type=kAOD;
+ AliMCEventHandler* mcHandler = dynamic_cast<AliMCEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
+ hasMC=mcHandler!=0x0;
+ }
+
fgInstance=new AliDielectronMC(type);
- fgInstance->SetHasMC(mcHandler!=0x0);
+ fgInstance->SetHasMC(hasMC);
return fgInstance;
}
// include 2sigma e TPC
// 3sigma bands TOF
// - exclude K,P
- AddCut(kTPC,AliPID::kElectron,2.);
- AddCut(kTOF,AliPID::kKaon,-3.,3.,0.,0.,kTRUE);
- AddCut(kTOF,AliPID::kProton,-3.,3.,0.,0.,kTRUE);
+ AddCut(kTPC,AliPID::kElectron,-2.5,4.);
+ AddCut(kTPC,AliPID::kPion,-3.,3.,0.,0.,kTRUE);
+ AddCut(kTPC,AliPID::kProton,-3.,3.,0.,0.,kTRUE);
} else if (def==3) {
// include 2sigma e TPC
ClassImp(AliDielectronSignalFunc)
AliDielectronSignalFunc::AliDielectronSignalFunc() :
- AliDielectronSignalBase(),
- fFuncSignal(0x0),
- fFuncBackground(0x0),
- fFuncSigBack(0x0),
- fParMass(1),
- fParMassWidth(2),
- fFitOpt("SMNQE"),
- fUseIntegral(kFALSE)
+AliDielectronSignalBase(),
+fFuncSignal(0x0),
+fFuncBackground(0x0),
+fFuncSigBack(0x0),
+fParMass(1),
+fParMassWidth(2),
+fFitOpt("SMNQE"),
+fUseIntegral(kFALSE)
{
//
// Default Constructor
//______________________________________________
AliDielectronSignalFunc::AliDielectronSignalFunc(const char* name, const char* title) :
- AliDielectronSignalBase(name, title),
- fFuncSignal(0x0),
- fFuncBackground(0x0),
- fFuncSigBack(0x0),
- fParMass(1),
- fParMassWidth(2),
- fFitOpt("SMNQE"),
- fUseIntegral(kFALSE)
+AliDielectronSignalBase(name, title),
+fFuncSignal(0x0),
+fFuncBackground(0x0),
+fFuncSigBack(0x0),
+fParMass(1),
+fParMassWidth(2),
+fFitOpt("SMNQE"),
+fUseIntegral(kFALSE)
{
//
// Named Constructor
case kFitted :
ProcessFit(arrhist);
break;
-
+
case kLikeSign :
ProcessLS(arrhist);
break;
-
+
case kEventMixing :
- //ProcessEM(arrhist); //yet to be implemented...
+ ProcessEM(arrhist);
break;
-
+
default :
AliError("Background substraction method not known!");
}
// Here we assume that the combined fit function is a sum of the signal and background functions
// and that the signal function is always the first term of this sum
//
-
+
fHistDataPM = (TH1F*)(arrhist->At(1))->Clone("histPM"); // +- SE
fHistDataPM->Sumw2();
if(fRebin>1)
fHistDataPM->Rebin(fRebin);
-
- fHistSignal = new TH1F("HistSignal", "Like-Sign substracted signal",
- fHistDataPM->GetXaxis()->GetNbins(),
- fHistDataPM->GetXaxis()->GetXmin(), fHistDataPM->GetXaxis()->GetXmax());
- fHistBackground = new TH1F("HistBackground", "Like-sign contribution",
- fHistDataPM->GetXaxis()->GetNbins(),
- fHistDataPM->GetXaxis()->GetXmin(), fHistDataPM->GetXaxis()->GetXmax());
- // the starting parameters of the fit function and their limits can be tuned
+ fHistSignal = new TH1F("HistSignal", "Like-Sign substracted signal",
+ fHistDataPM->GetXaxis()->GetNbins(),
+ fHistDataPM->GetXaxis()->GetXmin(), fHistDataPM->GetXaxis()->GetXmax());
+ fHistBackground = new TH1F("HistBackground", "Like-sign contribution",
+ fHistDataPM->GetXaxis()->GetNbins(),
+ fHistDataPM->GetXaxis()->GetXmin(), fHistDataPM->GetXaxis()->GetXmax());
+
+ // the starting parameters of the fit function and their limits can be tuned
// by the user in its macro
fHistDataPM->Fit(fFuncSigBack, fFitOpt.Data(), "", fFitMin, fFitMax);
TFitResultPtr pmFitPtr = fHistDataPM->Fit(fFuncSigBack, fFitOpt.Data(), "", fFitMin, fFitMax);
- TFitResult *pmFitResult = pmFitPtr.Get();
+ TFitResult *pmFitResult = pmFitPtr.Get();
fFuncSignal->SetParameters(fFuncSigBack->GetParameters());
fFuncBackground->SetParameters(fFuncSigBack->GetParameters()+fFuncSignal->GetNpar());
for(Int_t iPar=fFuncSignal->GetNpar(); iPar<fFuncSigBack->GetNpar(); iPar++) {
for(Int_t jPar=iPar; jPar<fFuncSigBack->GetNpar(); jPar++) {
TF1 gradientIpar("gradientIpar",
- ROOT::TF1Helper::TGradientParFunction(iPar-fFuncSignal->GetNpar(),fFuncBackground),0,0,0);
+ ROOT::TF1Helper::TGradientParFunction(iPar-fFuncSignal->GetNpar(),fFuncBackground),0,0,0);
TF1 gradientJpar("gradientJpar",
- ROOT::TF1Helper::TGradientParFunction(jPar-fFuncSignal->GetNpar(),fFuncBackground),0,0,0);
- ebknd += pmFitResult->CovMatrix(iPar,jPar)*
- gradientIpar.Eval(m)*gradientJpar.Eval(m)*
- (iPar==jPar ? 1.0 : 2.0);
+ ROOT::TF1Helper::TGradientParFunction(jPar-fFuncSignal->GetNpar(),fFuncBackground),0,0,0);
+ ebknd += pmFitResult->CovMatrix(iPar,jPar)*
+ gradientIpar.Eval(m)*gradientJpar.Eval(m)*
+ (iPar==jPar ? 1.0 : 2.0);
}
}
Double_t signal = pm-bknd;
fHistBackground->SetBinContent(iBin, bknd);
fHistBackground->SetBinError(iBin, TMath::Sqrt(ebknd));
}
-
+
if(fUseIntegral) {
// signal
fValues(0) = fFuncSignal->Integral(fIntMin, fIntMax)/fHistDataPM->GetBinWidth(1);
for(Int_t iPar=0; iPar<fFuncSignal->GetNpar(); iPar++) {
for(Int_t jPar=iPar; jPar<fFuncSignal->GetNpar(); jPar++) {
TF1 gradientIpar("gradientIpar",
- ROOT::TF1Helper::TGradientParFunction(iPar,fFuncSignal),0,0,0);
+ ROOT::TF1Helper::TGradientParFunction(iPar,fFuncSignal),0,0,0);
TF1 gradientJpar("gradientJpar",
- ROOT::TF1Helper::TGradientParFunction(jPar,fFuncSignal),0,0,0);
- fErrors(0) += pmFitResult->CovMatrix(iPar,jPar)*
- gradientIpar.Integral(fIntMin,fIntMax)*gradientJpar.Integral(fIntMin,fIntMax)*
- (iPar==jPar ? 1.0 : 2.0);
+ ROOT::TF1Helper::TGradientParFunction(jPar,fFuncSignal),0,0,0);
+ fErrors(0) += pmFitResult->CovMatrix(iPar,jPar)*
+ gradientIpar.Integral(fIntMin,fIntMax)*gradientJpar.Integral(fIntMin,fIntMax)*
+ (iPar==jPar ? 1.0 : 2.0);
}
- }
+ }
// background
fValues(1) = fFuncBackground->Integral(fIntMin, fIntMax)/fHistDataPM->GetBinWidth(1);
fErrors(1) = 0;
for(Int_t iPar=fFuncSignal->GetNpar(); iPar<fFuncSigBack->GetNpar(); iPar++) {
for(Int_t jPar=iPar; jPar<fFuncSigBack->GetNpar(); jPar++) {
TF1 gradientIpar("gradientIpar",
- ROOT::TF1Helper::TGradientParFunction(iPar-fFuncSignal->GetNpar(),fFuncBackground),0,0,0);
+ ROOT::TF1Helper::TGradientParFunction(iPar-fFuncSignal->GetNpar(),fFuncBackground),0,0,0);
TF1 gradientJpar("gradientJpar",
- ROOT::TF1Helper::TGradientParFunction(jPar-fFuncSignal->GetNpar(),fFuncBackground),0,0,0);
- fErrors(1) += pmFitResult->CovMatrix(iPar,jPar)*
- gradientIpar.Integral(fIntMin, fIntMax)*gradientJpar.Integral(fIntMin, fIntMax)*
- (iPar==jPar ? 1.0 : 2.0);
+ ROOT::TF1Helper::TGradientParFunction(jPar-fFuncSignal->GetNpar(),fFuncBackground),0,0,0);
+ fErrors(1) += pmFitResult->CovMatrix(iPar,jPar)*
+ gradientIpar.Integral(fIntMin, fIntMax)*gradientJpar.Integral(fIntMin, fIntMax)*
+ (iPar==jPar ? 1.0 : 2.0);
}
}
}
else {
// signal
fValues(0) = fHistSignal->IntegralAndError(fHistSignal->FindBin(fIntMin),
- fHistSignal->FindBin(fIntMax), fErrors(0));
+ fHistSignal->FindBin(fIntMax), fErrors(0));
// background
fValues(1) = fHistBackground->IntegralAndError(fHistBackground->FindBin(fIntMin),
- fHistBackground->FindBin(fIntMax),
- fErrors(1));
+ fHistBackground->FindBin(fIntMax),
+ fErrors(1));
}
// S/B and significance
SetSignificanceAndSOB();
fErrors(4) = fFuncSigBack->GetParError(fParMass);
fValues(5) = fFuncSigBack->GetParameter(fParMassWidth);
fErrors(5) = fFuncSigBack->GetParError(fParMassWidth);
-
+
fProcessed = kTRUE;
}
//
fHistDataPP = (TH1F*)(arrhist->At(0))->Clone("histPP"); // ++ SE
fHistDataPM = (TH1F*)(arrhist->At(1))->Clone("histPM"); // +- SE
- fHistDataMM = (TH1F*)(arrhist->At(2))->Clone("histMM"); // -- SE
- if (fRebin>1) {
+ fHistDataMM = (TH1F*)(arrhist->At(2))->Clone("histMM"); // -- SE
+ if (fRebin>1) {
fHistDataPP->Rebin(fRebin);
fHistDataPM->Rebin(fRebin);
fHistDataMM->Rebin(fRebin);
- }
+ }
fHistDataPP->Sumw2();
fHistDataPM->Sumw2();
fHistDataMM->Sumw2();
-
- fHistSignal = new TH1F("HistSignal", "Like-Sign substracted signal",
- fHistDataPM->GetXaxis()->GetNbins(),
- fHistDataPM->GetXaxis()->GetXmin(), fHistDataPM->GetXaxis()->GetXmax());
- fHistBackground = new TH1F("HistBackground", "Like-sign contribution",
- fHistDataPM->GetXaxis()->GetNbins(),
- fHistDataPM->GetXaxis()->GetXmin(), fHistDataPM->GetXaxis()->GetXmax());
-
+
+ fHistSignal = new TH1F("HistSignal", "Like-Sign substracted signal",
+ fHistDataPM->GetXaxis()->GetNbins(),
+ fHistDataPM->GetXaxis()->GetXmin(), fHistDataPM->GetXaxis()->GetXmax());
+ fHistBackground = new TH1F("HistBackground", "Like-sign contribution",
+ fHistDataPM->GetXaxis()->GetNbins(),
+ fHistDataPM->GetXaxis()->GetXmin(), fHistDataPM->GetXaxis()->GetXmax());
+
// fit the +- mass distribution
fHistDataPM->Fit(fFuncSigBack, fFitOpt.Data(), "", fFitMin, fFitMax);
fHistDataPM->Fit(fFuncSigBack, fFitOpt.Data(), "", fFitMin, fFitMax);
fHistDataMM->Fit(funcCloneMM, fFitOpt.Data(), "", fFitMin, fFitMax);
TFitResultPtr mmFitPtr = fHistDataMM->Fit(funcCloneMM, fFitOpt.Data(), "", fFitMin, fFitMax);
mmFitResult = mmFitPtr.Get();
-
+
for(Int_t iBin=1; iBin<=fHistDataPM->GetXaxis()->GetNbins(); iBin++) {
Double_t m = fHistDataPM->GetBinCenter(iBin);
Double_t pm = fHistDataPM->GetBinContent(iBin);
for(Int_t iPar=0; iPar<funcClonePP->GetNpar(); iPar++) {
for(Int_t jPar=iPar; jPar<funcClonePP->GetNpar(); jPar++) {
TF1 gradientIpar("gradientIpar",
- ROOT::TF1Helper::TGradientParFunction(iPar,funcClonePP),0,0,0);
+ ROOT::TF1Helper::TGradientParFunction(iPar,funcClonePP),0,0,0);
TF1 gradientJpar("gradientJpar",
- ROOT::TF1Helper::TGradientParFunction(jPar,funcClonePP),0,0,0);
- epp += ppFitResult->CovMatrix(iPar,jPar)*
- gradientIpar.Eval(m)*gradientJpar.Eval(m)*
- (iPar==jPar ? 1.0 : 2.0);
+ ROOT::TF1Helper::TGradientParFunction(jPar,funcClonePP),0,0,0);
+ epp += ppFitResult->CovMatrix(iPar,jPar)*
+ gradientIpar.Eval(m)*gradientJpar.Eval(m)*
+ (iPar==jPar ? 1.0 : 2.0);
}
}
Double_t emm = 0;
for(Int_t iPar=0; iPar<funcCloneMM->GetNpar(); iPar++) {
for(Int_t jPar=iPar; jPar<funcCloneMM->GetNpar(); jPar++) {
TF1 gradientIpar("gradientIpar",
- ROOT::TF1Helper::TGradientParFunction(iPar,funcCloneMM),0,0,0);
+ ROOT::TF1Helper::TGradientParFunction(iPar,funcCloneMM),0,0,0);
TF1 gradientJpar("gradientJpar",
- ROOT::TF1Helper::TGradientParFunction(jPar,funcCloneMM),0,0,0);
- emm += mmFitResult->CovMatrix(iPar,jPar)*
- gradientIpar.Eval(m)*gradientJpar.Eval(m)*
- (iPar==jPar ? 1.0 : 2.0);
+ ROOT::TF1Helper::TGradientParFunction(jPar,funcCloneMM),0,0,0);
+ emm += mmFitResult->CovMatrix(iPar,jPar)*
+ gradientIpar.Eval(m)*gradientJpar.Eval(m)*
+ (iPar==jPar ? 1.0 : 2.0);
}
}
-
+
Double_t signal = pm-2.0*TMath::Sqrt(pp*mm);
Double_t background = 2.0*TMath::Sqrt(pp*mm);
// error propagation on the signal calculation above
fHistBackground->SetBinContent(iBin, background);
fHistBackground->SetBinError(iBin, ebackground);
}
-
+
// signal
fValues(0) = fHistSignal->IntegralAndError(fHistSignal->FindBin(fIntMin),
- fHistSignal->FindBin(fIntMax), fErrors(0));
+ fHistSignal->FindBin(fIntMax), fErrors(0));
// background
fValues(1) = fHistBackground->IntegralAndError(fHistBackground->FindBin(fIntMin),
- fHistBackground->FindBin(fIntMax),
- fErrors(1));
+ fHistBackground->FindBin(fIntMax),
+ fErrors(1));
// S/B and significance
SetSignificanceAndSOB();
fValues(4) = fFuncSigBack->GetParameter(fParMass);
fErrors(4) = fFuncSigBack->GetParError(fParMass);
fValues(5) = fFuncSigBack->GetParameter(fParMassWidth);
fErrors(5) = fFuncSigBack->GetParError(fParMassWidth);
-
+
fProcessed = kTRUE;
}
//______________________________________________
-//void AliDielectronSignalFunc::ProcessEM(TObjArray * const arrhist) {
+void AliDielectronSignalFunc::ProcessEM(TObjArray * const arrhist) {
//
// Substract background with the event mixing technique
//
- //AliError("Event mixing for background substraction method not implemented!");
-//}
+ arrhist->GetEntries(); // just to avoid the unused parameter warning
+ AliError("Event mixing for background substraction method not implemented!");
+}
//______________________________________________
void AliDielectronSignalFunc::SetFunctions(TF1 * const combined, TF1 * const sig, TF1 * const back,
fFuncSigBack->SetParLimits(0,0,10000000);
fFuncSigBack->SetParLimits(1,3.05,3.15);
fFuncSigBack->SetParLimits(2,.02,.1);
- }
+ }
else if (type==1){
fFuncSignal=new TF1("DieleSignal","gaus",2.5,4);
fFuncBackground=new TF1("DieleBackground","[0]*exp(-(x-[1])/[2])",2.5,4);
fFuncSigBack->SetParLimits(0,0,10000000);
fFuncSigBack->SetParLimits(1,3.05,3.15);
fFuncSigBack->SetParLimits(2,.02,.1);
- }
+ }
else if (type==2){
// half gaussian, half exponential signal function
// exponential background
TString drawOpt(option);
drawOpt.ToLower();
-
+
Bool_t optStat=drawOpt.Contains("stat");
fFuncSigBack->SetNpx(200);
TGraph *grSig=new TGraph(fFuncSigBack);
grSig->SetFillColor(kGreen);
grSig->SetFillStyle(3001);
-
+
TGraph *grBack=new TGraph(fFuncBackground);
grBack->SetFillColor(kRed);
grBack->SetFillStyle(3001);
-
+
grSig->SetPoint(0,grBack->GetX()[0],grBack->GetY()[0]);
grSig->SetPoint(grSig->GetN()-1,grBack->GetX()[grBack->GetN()-1],grBack->GetY()[grBack->GetN()-1]);
fHistDataPP->SetLineColor(6);
fHistDataPP->Draw("same");
fHistDataMM->SetLineWidth(2);
- fHistDataMM->SetLineColor(8);
+ fHistDataMM->SetLineColor(8);
fHistDataMM->Draw("same");
}
-
- if(fMethod==kFitted)
+
+ if(fMethod==kFitted)
fFuncBackground->Draw("same");
-
+
if (optStat) DrawStats();
}
virtual void Process(TObjArray * const arrhist);
void ProcessFit(TObjArray * const arrhist); // fit the SE +- distribution
void ProcessLS(TObjArray * const arrhist); // substract the fitted SE like-sign background
- //void ProcessEM(TObjArray * const arrhist); // substract the fitted SE+ME like-sign background ...not yet implemented
+ void ProcessEM(TObjArray * const arrhist); // substract the fitted SE+ME like-sign background
void SetUseIntegral(Bool_t flag=kTRUE) {fUseIntegral = flag;};
void SetFunctions(TF1 * const combined, TF1 * const sig=0, TF1 * const back=0, Int_t parM=1, Int_t parMres=2);
}
void SetDefaults(Int_t type);
- TF1* GetSignalFunction() { return fFuncSignal; }
- TF1* GetBackgroundFunction() { return fFuncBackground; }
- TF1* GetCombinedFunction() { return fFuncSigBack; }
+ TF1* GetSignalFunction() const { return fFuncSignal; }
+ TF1* GetBackgroundFunction() const { return fFuncBackground; }
+ TF1* GetCombinedFunction() const { return fFuncSigBack; }
virtual void Draw(const Option_t* option = "");
"SSD2_signal",
"SDD1_signal",
"SDD2_signal",
+ "ITS_clusterMap",
"ITS_nSigma_Electrons",
"ITS_nSigma_Pions",
"ITS_nSigma_Muons",
kITSsignalSSD2, // SSD2 dE/dx signal
kITSsignalSDD1, // SDD1 dE/dx signal
kITSsignalSDD2, // SDD2 dE/dx signal
+ kITSclusterMap, // ITS cluster map
kITSnSigmaEle, // number of sigmas to the dE/dx electron line in the ITS
kITSnSigmaPio, // number of sigmas to the dE/dx pion line in the ITS
kITSnSigmaMuo, // number of sigmas to the dE/dx muon line in the ITS
values[AliDielectronVarManager::kITSsignalSSD2] = itsdEdx[1];
values[AliDielectronVarManager::kITSsignalSDD1] = itsdEdx[2];
values[AliDielectronVarManager::kITSsignalSDD2] = itsdEdx[3];
-
+ values[AliDielectronVarManager::kITSclusterMap] = particle->GetITSClusterMap();
+
values[AliDielectronVarManager::kTrackLength] = particle->GetIntegratedLength();
//dEdx information
Double_t mom = particle->GetP();
values[AliDielectronVarManager::kTPCnSigmaKao]=0;
values[AliDielectronVarManager::kTPCnSigmaPro]=0;
+ values[AliDielectronVarManager::kITSclusterMap] = particle->GetITSClusterMap();
AliAODPid *pid=particle->GetDetPid();
if (pid){
fDiele->GetTrackFilter().AddCuts(pt);
// PID cuts --------------------------------------------------------
- AliDielectronPID *pid = new AliDielectronPID("PID10","TPC nSigma |e|<3 + |Pi|>3 + |P|>3 + TOF nSigma |e|<3");
- pid->SetDefaults(10);
+ AliDielectronPID *pid = new AliDielectronPID("PID10","TPC nSigma 2.5<e<4. + |Pi|>3 + |P|>3");
+ pid->SetDefaults(2);
fDiele->GetTrackFilter().AddCuts(pid);
}
AliDielectronCF *cf=new AliDielectronCF(fDiele->GetName(),fDiele->GetTitle());
//pair variables
- TVectorD *binLimPt=new TVectorD(6);
- (*binLimPt)[0]=0.0; (*binLimPt)[1]=0.8; (*binLimPt)[2]=1.4; (*binLimPt)[3]=2.8; (*binLimPt)[4]=4.2; (*binLimPt)[5]=9.9;
- cf->AddVariable(AliDielectronVarManager::kPt,binLimPt);
+ cf->AddVariable(AliDielectronVarManager::kPt,"0.0, 0.8, 1.4, 2.8, 4.2, 9.9, 100.0");
+
cf->AddVariable(AliDielectronVarManager::kY,40,-2,2);
- cf->AddVariable(AliDielectronVarManager::kM,150,0.,150*.027); //27Mev Steps
+ cf->AddVariable(AliDielectronVarManager::kM,50,1.98,1.98+50*.04); //40Mev Steps
cf->AddVariable(AliDielectronVarManager::kPairType,10,0,10);
//leg variables
- cf->AddVariable(AliDielectronVarManager::kPt,2,0.8,1.2,kTRUE);
- cf->AddVariable(AliDielectronVarManager::kNclsTPC,3,90,120,kTRUE);
+ cf->AddVariable(AliDielectronVarManager::kPt,"0.0, 0.8, 1.2, 100.0",kTRUE);
+ cf->AddVariable(AliDielectronVarManager::kNclsTPC,"0, 100, 120, 160",kTRUE);
fDiele->SetCFManagerPair(cf);
h.UserHistogram("TPCsignal","sigTPC","TPC signal;P [GeV];TPC signal [arb. Units]",400,.3,40,400,0.,200.,0,0,kTRUE,kFALSE)
h.GetHistogram("TPCsignal","sigTPC")->SetDirectory(gDirectory)
-h.UserHistogram("TPCsignal","nSigE","TPC n #sigma Electrons;P [GeV];TPC n #sigma Electrons",400,.3,40.,400,-4.,4.,0,0,kTRUE,kFALSE)
+h.UserHistogram("TPCsignal","nSigE","TPC n #sigma Electrons;P [GeV];TPC n #sigma Electrons",200,.3,40.,100,-4.,4.,0,0,kTRUE,kFALSE)
h.GetHistogram("TPCsignal","nSigE")->SetDirectory(gDirectory)
h.UserHistogram("TPCsignal","nSigMu","TPC n #sigma Muons;P [GeV];TPC n #sigma Muons",400,.3,40.,400,-4.,4.,0,0,kTRUE,kFALSE)
h.GetHistogram("TPCsignal","nSigMu")->SetDirectory(gDirectory)
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff