ROOT logo
/*************************************************************************
* 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 SignalFunc                                  //
//                                                                       //
//                                                                       //
/*

  Class used for extracting the signal from an invariant mass spectrum.
  It implements the AliDielectronSignalBase and -Ext classes and it uses user provided
  functions to fit the spectrum with a combined signa+background fit.
  Used invariant mass spectra are provided via an array of histograms. There are serveral method
  to estimate the background and to extract the raw yield from the background subtracted spectra.

  Example usage:

  AliDielectronSignalFunc *sig = new AliDielectronSignalFunc();


  1) invariant mass input spectra

  1.1) Assuming a AliDielectronCF container as data format (check class for more details)
  AliDielectronCFdraw *cf = new AliDielectronCFdraw("path/to/the/output/file.root");
  TObjArray *arrHists = cf->CollectMinvProj(cf->FindStep("Config"));

  1.2) Assuming a AliDielectronHF grid as data format (check class for more details)
  AliDielectronHFhelper *hf = new AliDielectronHFhelper("path/to/the/output/file.root", "ConfigName");
  TObjArray *arrHists = hf->CollectHistos(AliDielectronVarManager::kM);

  1.3) Assuming a single histograms
  TObjArray *histoArray = new TObjArray();
  arrHists->Add(signalPP);            // add the spectrum histograms to the array
  arrHists->Add(signalPM);            // the order is important !!!
  arrHists->Add(signalMM);


  2) background estimation

  2.1) set the method for the background estimation (methods can be found in AliDielectronSignalBase)
  sig->SetMethod(AliDielectronSignalBase::kFitted);
  2.2) rebin the spectras if needed
  //  sig->SetRebin(2);
  2.3) add any background function you like
  TF1 *fB = new TF1("fitBgrd","pol3",minFit,maxFit);


  3) configure the signal extraction

  3.1) chose one of the signal functions (MCshape, CrystalBall, Gauss)
  TF1 *fS = new TF1("fitSign",AliDielectronSignalFunc::PeakFunCB,minFit,maxFit,5); // has 5 parameters
  //  TF1 *fS = new TF1("fitSign",AliDielectronSignalFunc::PeakFunGaus,minFit,maxFit,3); // has 3 parameters
  //  sig->SetMCSignalShape(hMCsign);
  //  TF1 *fS = new TF1("fitSign",AliDielectronSignalFunc::PeakFunMC,minFit,maxFit,1); // requires a MC shape
  3.2) set the method for the signal extraction (methods can be found in AliDielectronSignalBase)
  depending on the method serveral inputs are needed (e.g. MC shape, PDG code of the particle of interest)
  //  sig->SetParticleOfInterest(443); //default is jpsi
  //  sig->SetMCSignalShape(signalMC);
  //  sig->SetIntegralRange(minInt, maxInt);
  sig->SetExtractionMethod(AliDielectronSignal::BinCounting); // this is the default


  4) combined fit of bgrd+signal

  4.1) combine the two functions
  sig->CombineFunc(fS,fB);
  4.2) apply fitting ranges and the fit options
  sig->SetFitRange(minFit, maxFit);
  sig->SetFitOption("NR");


  5) start the processing

  sig->Process(arrHists);
  sig->Print(""); // print values and errors extracted


  6) access the spectra and values created

  6.1) standard spectra as provided filled in AliDielectronSignalExt
  TH1F *hsign = (TH1F*) sig->GetUnlikeSignHistogram();  // same as the input (rebinned)
  TH1F *hbgrd = (TH1F*) sig->GetBackgroundHistogram();  // filled histogram with fitBgrd
  TH1F *hextr = (TH1F*) sig->GetSignalHistogram();      // after backgound extraction (rebinned)
  TObject *oPeak = (TObject*) sig->GetPeakShape();      // can be a TF1 or TH1 depending on the method
  6.2) flow spectra
  TF1 *fFitSign  = sig->GetCombinedFunction();                // combined fit function
  TF1 *fFitExtr  = sig->GetSignalFunction();                  // signal function
  TF1 *fFitBgrd  = sig->GetBackgroundFunction();              // background function
  6.3) access the extracted values and errors
  sig->GetValues();     or GetErrors();                 // yield extraction

*/
//                                                                       //
///////////////////////////////////////////////////////////////////////////

#include <TF1.h>
#include <TH1.h>
#include <TGraph.h>
#include <TMath.h>
#include <TString.h>
#include <TPaveText.h>
#include <TList.h>
#include <TFitResult.h>
//#include <../hist/hist/src/TF1Helper.h>

#include <AliLog.h>

#include "AliDielectronSignalFunc.h"

ClassImp(AliDielectronSignalFunc)

//TH1F* AliDielectronSignalFunc::fgHistSimPM=0x0;
TF1*  AliDielectronSignalFunc::fFuncSignal=0x0;
TF1*  AliDielectronSignalFunc::fFuncBackground=0x0;
Int_t AliDielectronSignalFunc::fNparPeak=0;
Int_t AliDielectronSignalFunc::fNparBgnd=0;


AliDielectronSignalFunc::AliDielectronSignalFunc() :
AliDielectronSignalExt(),
fFuncSigBack(0x0),
fParMass(1),
fParMassWidth(2),
fFitOpt("SMNQE"),
fUseIntegral(kFALSE),
fDof(0),
fChi2Dof(0.0)
{
  //
  // Default Constructor
  //
  
}

//______________________________________________
AliDielectronSignalFunc::AliDielectronSignalFunc(const char* name, const char* title) :
AliDielectronSignalExt(name, title),
fFuncSigBack(0x0),
fParMass(1),
fParMassWidth(2),
fFitOpt("SMNQE"),
fUseIntegral(kFALSE),
fDof(0),
fChi2Dof(0.0)
{
  //
  // Named Constructor
  //
}

//______________________________________________
AliDielectronSignalFunc::~AliDielectronSignalFunc()
{
  //
  // Default Destructor
  //
  if(fFuncSigBack) delete fFuncSigBack;
}


//______________________________________________
void AliDielectronSignalFunc::Process(TObjArray * const arrhist)
{
  //
  // Fit the invariant mass histograms and retrieve the signal and background
  //
  switch(fMethod) {
  case kFitted :
    ProcessFit(arrhist);
    break;

  case kLikeSignFit :
    ProcessFitLS(arrhist);
    break;

  case kEventMixingFit :
    ProcessFitEM(arrhist);
    break;

  case kLikeSign :
  case kLikeSignArithm :
  case kLikeSignRcorr:
  case kLikeSignArithmRcorr:
    ProcessLS(arrhist);    // process like-sign subtraction method
    break;

  case kEventMixing :
    ProcessEM(arrhist);    // process event mixing method
    break;

  case kRotation:
    ProcessRotation(arrhist);
    break;

  default :
    AliError("Background substraction method not known!");
  }
}
//______________________________________________________________________________
Double_t AliDielectronSignalFunc::PeakFunMC(const Double_t *x, const Double_t *par) {
  // Fit MC signal shape
  // parameters
  // [0]:   scale for simpeak
  
  Double_t xx  = x[0];
  
  TH1F *hPeak = fgHistSimPM;
  if (!hPeak) {
    printf("E-AliDielectronSignalFunc::PeakFun: No histogram for peak fit defined!\n");
    return 0.0;
  }
  
  Int_t idx = hPeak->FindBin(xx);
  if ((idx <= 1) ||
      (idx >= hPeak->GetNbinsX())) {
    return 0.0;
  }
  
  return (par[0] * hPeak->GetBinContent(idx));
  
}

//______________________________________________________________________________
Double_t AliDielectronSignalFunc::PeakFunCB(const Double_t *x, const Double_t *par) {
  // Crystal Ball fit function
  
  Double_t alpha = par[0];
  Double_t     n = par[1];
  Double_t meanx = par[2];
  Double_t sigma = par[3];
  Double_t    nn = par[4];
   
  Double_t a = TMath::Power((n/TMath::Abs(alpha)), n) * TMath::Exp(-.5*alpha*alpha);
  Double_t b = n/TMath::Abs(alpha) - TMath::Abs(alpha);
  
  Double_t arg = (x[0] - meanx)/sigma;
  Double_t fitval = 0;
  
  if (arg > -1.*alpha) {
    fitval = nn * TMath::Exp(-.5*arg*arg);
  } else {
    fitval = nn * a * TMath::Power((b-arg), (-1*n));
  }
  
  return fitval;
}

//______________________________________________________________________________
Double_t AliDielectronSignalFunc::PeakFunGaus(const Double_t *x, const Double_t *par) {
  // Gaussian fit function
  //printf("fNparBgrd %d \n",fNparBgnd);
  Double_t     n = par[0];
  Double_t  mean = par[1];
  Double_t sigma = par[2];
  Double_t    xx = x[0];

  return ( n*TMath::Exp(-0.5*TMath::Power((xx-mean)/sigma,2)) );
}

//______________________________________________
void AliDielectronSignalFunc::ProcessFit(TObjArray * const arrhist) {
  //
  // Fit the +- invariant mass distribution only
  // 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", "Fit substracted signal",
                         fHistDataPM->GetXaxis()->GetNbins(),
                         fHistDataPM->GetXaxis()->GetXmin(), fHistDataPM->GetXaxis()->GetXmax());
  fHistBackground = new TH1F("HistBackground", "Fit 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(); // used only with TF1Helper
  //fFuncBackground->SetParameters(fFuncSigBack->GetParameters());
  fFuncSignal->SetParameters(fFuncSigBack->GetParameters());
  fFuncBackground->SetParameters(fFuncSigBack->GetParameters()+fFuncSignal->GetNpar());

  // fill the background spectrum
  fHistBackground->Eval(fFuncBackground);
  // set the error for the background histogram
  fHistBackground->Fit(fFuncBackground,"0qR","",fFitMin,fFitMax);
  Double_t inte  = fFuncBackground->IntegralError(fIntMin, fIntMax)/fHistDataPM->GetBinWidth(1);
  Double_t binte = inte / TMath::Sqrt((fHistDataPM->FindBin(fIntMax)-fHistDataPM->FindBin(fIntMin))+1);
  for(Int_t iBin=fHistDataPM->FindBin(fIntMin); iBin<=fHistDataPM->FindBin(fIntMax); iBin++) {
    fHistBackground->SetBinError(iBin, binte);
  }

  for(Int_t iBin=1; iBin<=fHistDataPM->GetXaxis()->GetNbins(); iBin++) {
    //    Double_t m = fHistDataPM->GetBinCenter(iBin);
    Double_t pm = fHistDataPM->GetBinContent(iBin);
    Double_t epm = fHistDataPM->GetBinError(iBin);
    Double_t bknd = fHistBackground->GetBinContent(iBin);
    Double_t ebknd = fHistBackground->GetBinError(iBin);
    for(Int_t iPar=fFuncSignal->GetNpar(); iPar<fFuncSigBack->GetNpar(); iPar++) {
      /* TF1Helper problem on alien compilation
	 for(Int_t jPar=iPar; jPar<fFuncSigBack->GetNpar(); jPar++) {
	 TF1 gradientIpar("gradientIpar",
	 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);
	 }
      */
    }
    Double_t signal = pm-bknd;
    Double_t error = TMath::Sqrt(epm*epm+ebknd);
    fHistSignal->SetBinContent(iBin, signal);
    fHistSignal->SetBinError(iBin, error);
  }
  
  if(fUseIntegral) {
    // signal
    fValues(0) = fFuncSignal->Integral(fIntMin, fIntMax)/fHistDataPM->GetBinWidth(1);
    fErrors(0) = 0;
    for(Int_t iPar=0; iPar<fFuncSignal->GetNpar(); iPar++) {
/* TF1Helper problem on alien compilation
      for(Int_t jPar=iPar; jPar<fFuncSignal->GetNpar(); jPar++) {
        TF1 gradientIpar("gradientIpar",
                         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);
      }
*/
    }
    // background
    fValues(1) = fFuncBackground->Integral(fIntMin, fIntMax)/fHistDataPM->GetBinWidth(1);
    fErrors(1) = fFuncBackground->IntegralError(fIntMin, fIntMax)/fHistDataPM->GetBinWidth(1);
    for(Int_t iPar=fFuncSignal->GetNpar(); iPar<fFuncSigBack->GetNpar(); iPar++) {
/* TF1Helper problem on alien compilation
      for(Int_t jPar=iPar; jPar<fFuncSigBack->GetNpar(); jPar++) {
        TF1 gradientIpar("gradientIpar",
                         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);
      }
*/
    }
  }
  else {
    // signal
    fValues(0) = fHistSignal->IntegralAndError(fHistSignal->FindBin(fIntMin),
                                               fHistSignal->FindBin(fIntMax), fErrors(0));
    // background
    fValues(1) = fHistBackground->IntegralAndError(fHistBackground->FindBin(fIntMin),
						   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;
  
  fHistBackground->GetListOfFunctions()->Add(fFuncBackground);

}

//______________________________________________
void AliDielectronSignalFunc::ProcessFitLS(TObjArray * const arrhist) {
  //
  // Substract background using the like-sign spectrum
  //
  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) {
    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());
  
  // fit the +- mass distribution
  fHistDataPM->Fit(fFuncSigBack, fFitOpt.Data(), "", fFitMin, fFitMax);
  fHistDataPM->Fit(fFuncSigBack, fFitOpt.Data(), "", fFitMin, fFitMax);
  // declare the variables where the like-sign fit results will be stored
//   TFitResult *ppFitResult = 0x0;
//   TFitResult *mmFitResult = 0x0;
  // fit the like sign background
  TF1 *funcClonePP = (TF1*)fFuncBackground->Clone("funcClonePP");
  TF1 *funcCloneMM = (TF1*)fFuncBackground->Clone("funcCloneMM");
  fHistDataPP->Fit(funcClonePP, fFitOpt.Data(), "", fFitMin, fFitMax);
  fHistDataPP->Fit(funcClonePP, fFitOpt.Data(), "", fFitMin, fFitMax);
//   TFitResultPtr ppFitPtr = fHistDataPP->Fit(funcClonePP, fFitOpt.Data(), "", fFitMin, fFitMax);
//   ppFitResult = ppFitPtr.Get();
  fHistDataMM->Fit(funcCloneMM, 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);
    Double_t pp = funcClonePP->Eval(m);
    Double_t mm = funcCloneMM->Eval(m);
    Double_t epm = fHistDataPM->GetBinError(iBin);
    Double_t epp = 0;
    for(Int_t iPar=0; iPar<funcClonePP->GetNpar(); iPar++) {
/* TF1Helper problem on alien compilation
      for(Int_t jPar=iPar; jPar<funcClonePP->GetNpar(); jPar++) {
        TF1 gradientIpar("gradientIpar",
                         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);
      }
*/
    }
    Double_t emm = 0;
    for(Int_t iPar=0; iPar<funcCloneMM->GetNpar(); iPar++) {
/* TF1Helper problem on alien compilation
      for(Int_t jPar=iPar; jPar<funcCloneMM->GetNpar(); jPar++) {
        TF1 gradientIpar("gradientIpar",
                         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);
      }
*/
    }
    
    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
    Double_t esignal = TMath::Sqrt(epm*epm+(mm/pp)*epp+(pp/mm)*emm);
    Double_t ebackground = TMath::Sqrt((mm/pp)*epp+(pp/mm)*emm);
    fHistSignal->SetBinContent(iBin, signal);
    fHistSignal->SetBinError(iBin, esignal);
    fHistBackground->SetBinContent(iBin, background);
    fHistBackground->SetBinError(iBin, ebackground);
  }
  
  // signal
  fValues(0) = fHistSignal->IntegralAndError(fHistSignal->FindBin(fIntMin),
                                             fHistSignal->FindBin(fIntMax), fErrors(0));
  // background
  fValues(1) = fHistBackground->IntegralAndError(fHistBackground->FindBin(fIntMin),
                                                 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::ProcessFitEM(TObjArray * const arrhist) {
  //
  // Substract background with the event mixing technique
  //
  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,
                                           Int_t parM, Int_t parMres)
{
  //
  // Set the signal, background functions and combined fit function
  // Note: The process method assumes that the first n parameters in the
  //       combined fit function correspond to the n parameters of the signal function
  //       and the n+1 to n+m parameters to the m parameters of the background function!!!
  
  if (!sig||!back||!combined) {
    AliError("Both, signal and background function need to be set!");
    return;
  }
  fFuncSignal=sig;
  fFuncBackground=back;
  fFuncSigBack=combined;
  fParMass=parM;
  fParMassWidth=parMres;

}

//______________________________________________
void AliDielectronSignalFunc::SetDefaults(Int_t type)
{
  //
  // Setup some default functions:
  // type = 0: gaus signal + linear background in 2.5 - 4 GeV inv. mass
  // type = 1: gaus signal + exponential background in 2.5 - 4 GeV inv. mass
  // type = 2: half gaussian, half exponential signal function
  // type = 3: Crystal-Ball function
  // type = 4: Crystal-Ball signal + exponential background
  //
  
  if (type==0){
    fFuncSignal=new TF1("DieleSignal","gaus",2.5,4);
    fFuncBackground=new TF1("DieleBackground","pol1",2.5,4);
    fFuncSigBack=new TF1("DieleCombined","gaus+pol1(3)",2.5,4);
    
    fFuncSigBack->SetParameters(1,3.1,.05,2.5,1);
    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=new TF1("DieleCombined","gaus+[3]*exp(-(x-[4])/[5])",2.5,4);
    
    fFuncSigBack->SetParameters(1,3.1,.05,1,2.5,1);
    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
    fFuncSignal = new TF1("DieleSignal","(x<[1])*([0]*(exp(-0.5*((x-[1])/[2])^2)+exp((x-[1])/[3])*(1-exp(-0.5*((x-[1])/[2])^2))))+(x>=[1])*([0]*exp(-0.5*((x-[1])/[2])^2))",2.5,4);
    fFuncBackground = new TF1("DieleBackground","[0]*exp(-(x-[1])/[2])+[3]",2.5,4);
    fFuncSigBack = new TF1("DieleCombined","(x<[1])*([0]*(exp(-0.5*((x-[1])/[2])^2)+exp((x-[1])/[3])*(1-exp(-0.5*((x-[1])/[2])^2))))+(x>=[1])*([0]*exp(-0.5*((x-[1])/[2])^2))+[4]*exp(-(x-[5])/[6])+[7]",2.5,4);
    fFuncSigBack->SetParameters(1.,3.1,.05,.1,1,2.5,1,0);
    
    fFuncSigBack->SetParLimits(0,0,10000000);
    fFuncSigBack->SetParLimits(1,3.05,3.15);
    fFuncSigBack->SetParLimits(2,.02,.1);
    fFuncSigBack->FixParameter(6,2.5);
    fFuncSigBack->FixParameter(7,0);
  }
}


//______________________________________________
void AliDielectronSignalFunc::Draw(const Option_t* option)
{
  //
  // Draw the fitted function
  //
  
  TString drawOpt(option);
  drawOpt.ToLower();
  
  Bool_t optStat=drawOpt.Contains("stat");
  
  fFuncSigBack->SetNpx(200);
  fFuncSigBack->SetRange(fIntMin,fIntMax);
  fFuncBackground->SetNpx(200);
  fFuncBackground->SetRange(fIntMin,fIntMax);
  
  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]);
  
  grBack->SetPoint(0,grBack->GetX()[0],0.);
  grBack->SetPoint(grBack->GetN()-1,grBack->GetX()[grBack->GetN()-1],0.);
  
  fFuncSigBack->SetRange(fFitMin,fFitMax);
  fFuncBackground->SetRange(fFitMin,fFitMax);
  
  if (!drawOpt.Contains("same")){
    if (fHistDataPM){
      fHistDataPM->Draw();
      grSig->Draw("f");
    } else {
      grSig->Draw("af");
    }
  } else {
    grSig->Draw("f");
  }
  if(fMethod==kFitted || fMethod==kFittedMC) grBack->Draw("f");
  fFuncSigBack->Draw("same");
  fFuncSigBack->SetLineWidth(2);
  if(fMethod==kLikeSign) {
    fHistDataPP->SetLineWidth(2);
    fHistDataPP->SetLineColor(6);
    fHistDataPP->Draw("same");
    fHistDataMM->SetLineWidth(2);
    fHistDataMM->SetLineColor(8);
    fHistDataMM->Draw("same");
  }
  
  if(fMethod==kFitted || fMethod==kFittedMC)
    fFuncBackground->Draw("same");
  
  if (optStat) DrawStats();
  
}


//______________________________________________________________________________
void AliDielectronSignalFunc::CombineFunc(TF1 * const peak, TF1 * const bgnd) {
  //
  // combine the bgnd and the peak function
  //

  if (!peak||!bgnd) {
    AliError("Both, signal and background function need to be set!");
    return;
  }
  fFuncSignal=peak;
  fFuncBackground=bgnd;

  fNparPeak     = fFuncSignal->GetNpar();
  fNparBgnd     = fFuncBackground->GetNpar();

  fFuncSigBack = new TF1("BgndPeak",AliDielectronSignalFunc::PeakBgndFun, fFitMin,fFitMax, fNparPeak+fNparBgnd);
  return;
}

//______________________________________________________________________________
Double_t AliDielectronSignalFunc::PeakBgndFun(const Double_t *x, const Double_t *par) {
  //
  // merge peak and bgnd functions
  //
  return (fFuncSignal->EvalPar(x,par) + fFuncBackground->EvalPar(x,par+fNparPeak));
}

 AliDielectronSignalFunc.cxx:1
 AliDielectronSignalFunc.cxx:2
 AliDielectronSignalFunc.cxx:3
 AliDielectronSignalFunc.cxx:4
 AliDielectronSignalFunc.cxx:5
 AliDielectronSignalFunc.cxx:6
 AliDielectronSignalFunc.cxx:7
 AliDielectronSignalFunc.cxx:8
 AliDielectronSignalFunc.cxx:9
 AliDielectronSignalFunc.cxx:10
 AliDielectronSignalFunc.cxx:11
 AliDielectronSignalFunc.cxx:12
 AliDielectronSignalFunc.cxx:13
 AliDielectronSignalFunc.cxx:14
 AliDielectronSignalFunc.cxx:15
 AliDielectronSignalFunc.cxx:16
 AliDielectronSignalFunc.cxx:17
 AliDielectronSignalFunc.cxx:18
 AliDielectronSignalFunc.cxx:19
 AliDielectronSignalFunc.cxx:20
 AliDielectronSignalFunc.cxx:21
 AliDielectronSignalFunc.cxx:22
 AliDielectronSignalFunc.cxx:23
 AliDielectronSignalFunc.cxx:24
 AliDielectronSignalFunc.cxx:25
 AliDielectronSignalFunc.cxx:26
 AliDielectronSignalFunc.cxx:27
 AliDielectronSignalFunc.cxx:28
 AliDielectronSignalFunc.cxx:29
 AliDielectronSignalFunc.cxx:30
 AliDielectronSignalFunc.cxx:31
 AliDielectronSignalFunc.cxx:32
 AliDielectronSignalFunc.cxx:33
 AliDielectronSignalFunc.cxx:34
 AliDielectronSignalFunc.cxx:35
 AliDielectronSignalFunc.cxx:36
 AliDielectronSignalFunc.cxx:37
 AliDielectronSignalFunc.cxx:38
 AliDielectronSignalFunc.cxx:39
 AliDielectronSignalFunc.cxx:40
 AliDielectronSignalFunc.cxx:41
 AliDielectronSignalFunc.cxx:42
 AliDielectronSignalFunc.cxx:43
 AliDielectronSignalFunc.cxx:44
 AliDielectronSignalFunc.cxx:45
 AliDielectronSignalFunc.cxx:46
 AliDielectronSignalFunc.cxx:47
 AliDielectronSignalFunc.cxx:48
 AliDielectronSignalFunc.cxx:49
 AliDielectronSignalFunc.cxx:50
 AliDielectronSignalFunc.cxx:51
 AliDielectronSignalFunc.cxx:52
 AliDielectronSignalFunc.cxx:53
 AliDielectronSignalFunc.cxx:54
 AliDielectronSignalFunc.cxx:55
 AliDielectronSignalFunc.cxx:56
 AliDielectronSignalFunc.cxx:57
 AliDielectronSignalFunc.cxx:58
 AliDielectronSignalFunc.cxx:59
 AliDielectronSignalFunc.cxx:60
 AliDielectronSignalFunc.cxx:61
 AliDielectronSignalFunc.cxx:62
 AliDielectronSignalFunc.cxx:63
 AliDielectronSignalFunc.cxx:64
 AliDielectronSignalFunc.cxx:65
 AliDielectronSignalFunc.cxx:66
 AliDielectronSignalFunc.cxx:67
 AliDielectronSignalFunc.cxx:68
 AliDielectronSignalFunc.cxx:69
 AliDielectronSignalFunc.cxx:70
 AliDielectronSignalFunc.cxx:71
 AliDielectronSignalFunc.cxx:72
 AliDielectronSignalFunc.cxx:73
 AliDielectronSignalFunc.cxx:74
 AliDielectronSignalFunc.cxx:75
 AliDielectronSignalFunc.cxx:76
 AliDielectronSignalFunc.cxx:77
 AliDielectronSignalFunc.cxx:78
 AliDielectronSignalFunc.cxx:79
 AliDielectronSignalFunc.cxx:80
 AliDielectronSignalFunc.cxx:81
 AliDielectronSignalFunc.cxx:82
 AliDielectronSignalFunc.cxx:83
 AliDielectronSignalFunc.cxx:84
 AliDielectronSignalFunc.cxx:85
 AliDielectronSignalFunc.cxx:86
 AliDielectronSignalFunc.cxx:87
 AliDielectronSignalFunc.cxx:88
 AliDielectronSignalFunc.cxx:89
 AliDielectronSignalFunc.cxx:90
 AliDielectronSignalFunc.cxx:91
 AliDielectronSignalFunc.cxx:92
 AliDielectronSignalFunc.cxx:93
 AliDielectronSignalFunc.cxx:94
 AliDielectronSignalFunc.cxx:95
 AliDielectronSignalFunc.cxx:96
 AliDielectronSignalFunc.cxx:97
 AliDielectronSignalFunc.cxx:98
 AliDielectronSignalFunc.cxx:99
 AliDielectronSignalFunc.cxx:100
 AliDielectronSignalFunc.cxx:101
 AliDielectronSignalFunc.cxx:102
 AliDielectronSignalFunc.cxx:103
 AliDielectronSignalFunc.cxx:104
 AliDielectronSignalFunc.cxx:105
 AliDielectronSignalFunc.cxx:106
 AliDielectronSignalFunc.cxx:107
 AliDielectronSignalFunc.cxx:108
 AliDielectronSignalFunc.cxx:109
 AliDielectronSignalFunc.cxx:110
 AliDielectronSignalFunc.cxx:111
 AliDielectronSignalFunc.cxx:112
 AliDielectronSignalFunc.cxx:113
 AliDielectronSignalFunc.cxx:114
 AliDielectronSignalFunc.cxx:115
 AliDielectronSignalFunc.cxx:116
 AliDielectronSignalFunc.cxx:117
 AliDielectronSignalFunc.cxx:118
 AliDielectronSignalFunc.cxx:119
 AliDielectronSignalFunc.cxx:120
 AliDielectronSignalFunc.cxx:121
 AliDielectronSignalFunc.cxx:122
 AliDielectronSignalFunc.cxx:123
 AliDielectronSignalFunc.cxx:124
 AliDielectronSignalFunc.cxx:125
 AliDielectronSignalFunc.cxx:126
 AliDielectronSignalFunc.cxx:127
 AliDielectronSignalFunc.cxx:128
 AliDielectronSignalFunc.cxx:129
 AliDielectronSignalFunc.cxx:130
 AliDielectronSignalFunc.cxx:131
 AliDielectronSignalFunc.cxx:132
 AliDielectronSignalFunc.cxx:133
 AliDielectronSignalFunc.cxx:134
 AliDielectronSignalFunc.cxx:135
 AliDielectronSignalFunc.cxx:136
 AliDielectronSignalFunc.cxx:137
 AliDielectronSignalFunc.cxx:138
 AliDielectronSignalFunc.cxx:139
 AliDielectronSignalFunc.cxx:140
 AliDielectronSignalFunc.cxx:141
 AliDielectronSignalFunc.cxx:142
 AliDielectronSignalFunc.cxx:143
 AliDielectronSignalFunc.cxx:144
 AliDielectronSignalFunc.cxx:145
 AliDielectronSignalFunc.cxx:146
 AliDielectronSignalFunc.cxx:147
 AliDielectronSignalFunc.cxx:148
 AliDielectronSignalFunc.cxx:149
 AliDielectronSignalFunc.cxx:150
 AliDielectronSignalFunc.cxx:151
 AliDielectronSignalFunc.cxx:152
 AliDielectronSignalFunc.cxx:153
 AliDielectronSignalFunc.cxx:154
 AliDielectronSignalFunc.cxx:155
 AliDielectronSignalFunc.cxx:156
 AliDielectronSignalFunc.cxx:157
 AliDielectronSignalFunc.cxx:158
 AliDielectronSignalFunc.cxx:159
 AliDielectronSignalFunc.cxx:160
 AliDielectronSignalFunc.cxx:161
 AliDielectronSignalFunc.cxx:162
 AliDielectronSignalFunc.cxx:163
 AliDielectronSignalFunc.cxx:164
 AliDielectronSignalFunc.cxx:165
 AliDielectronSignalFunc.cxx:166
 AliDielectronSignalFunc.cxx:167
 AliDielectronSignalFunc.cxx:168
 AliDielectronSignalFunc.cxx:169
 AliDielectronSignalFunc.cxx:170
 AliDielectronSignalFunc.cxx:171
 AliDielectronSignalFunc.cxx:172
 AliDielectronSignalFunc.cxx:173
 AliDielectronSignalFunc.cxx:174
 AliDielectronSignalFunc.cxx:175
 AliDielectronSignalFunc.cxx:176
 AliDielectronSignalFunc.cxx:177
 AliDielectronSignalFunc.cxx:178
 AliDielectronSignalFunc.cxx:179
 AliDielectronSignalFunc.cxx:180
 AliDielectronSignalFunc.cxx:181
 AliDielectronSignalFunc.cxx:182
 AliDielectronSignalFunc.cxx:183
 AliDielectronSignalFunc.cxx:184
 AliDielectronSignalFunc.cxx:185
 AliDielectronSignalFunc.cxx:186
 AliDielectronSignalFunc.cxx:187
 AliDielectronSignalFunc.cxx:188
 AliDielectronSignalFunc.cxx:189
 AliDielectronSignalFunc.cxx:190
 AliDielectronSignalFunc.cxx:191
 AliDielectronSignalFunc.cxx:192
 AliDielectronSignalFunc.cxx:193
 AliDielectronSignalFunc.cxx:194
 AliDielectronSignalFunc.cxx:195
 AliDielectronSignalFunc.cxx:196
 AliDielectronSignalFunc.cxx:197
 AliDielectronSignalFunc.cxx:198
 AliDielectronSignalFunc.cxx:199
 AliDielectronSignalFunc.cxx:200
 AliDielectronSignalFunc.cxx:201
 AliDielectronSignalFunc.cxx:202
 AliDielectronSignalFunc.cxx:203
 AliDielectronSignalFunc.cxx:204
 AliDielectronSignalFunc.cxx:205
 AliDielectronSignalFunc.cxx:206
 AliDielectronSignalFunc.cxx:207
 AliDielectronSignalFunc.cxx:208
 AliDielectronSignalFunc.cxx:209
 AliDielectronSignalFunc.cxx:210
 AliDielectronSignalFunc.cxx:211
 AliDielectronSignalFunc.cxx:212
 AliDielectronSignalFunc.cxx:213
 AliDielectronSignalFunc.cxx:214
 AliDielectronSignalFunc.cxx:215
 AliDielectronSignalFunc.cxx:216
 AliDielectronSignalFunc.cxx:217
 AliDielectronSignalFunc.cxx:218
 AliDielectronSignalFunc.cxx:219
 AliDielectronSignalFunc.cxx:220
 AliDielectronSignalFunc.cxx:221
 AliDielectronSignalFunc.cxx:222
 AliDielectronSignalFunc.cxx:223
 AliDielectronSignalFunc.cxx:224
 AliDielectronSignalFunc.cxx:225
 AliDielectronSignalFunc.cxx:226
 AliDielectronSignalFunc.cxx:227
 AliDielectronSignalFunc.cxx:228
 AliDielectronSignalFunc.cxx:229
 AliDielectronSignalFunc.cxx:230
 AliDielectronSignalFunc.cxx:231
 AliDielectronSignalFunc.cxx:232
 AliDielectronSignalFunc.cxx:233
 AliDielectronSignalFunc.cxx:234
 AliDielectronSignalFunc.cxx:235
 AliDielectronSignalFunc.cxx:236
 AliDielectronSignalFunc.cxx:237
 AliDielectronSignalFunc.cxx:238
 AliDielectronSignalFunc.cxx:239
 AliDielectronSignalFunc.cxx:240
 AliDielectronSignalFunc.cxx:241
 AliDielectronSignalFunc.cxx:242
 AliDielectronSignalFunc.cxx:243
 AliDielectronSignalFunc.cxx:244
 AliDielectronSignalFunc.cxx:245
 AliDielectronSignalFunc.cxx:246
 AliDielectronSignalFunc.cxx:247
 AliDielectronSignalFunc.cxx:248
 AliDielectronSignalFunc.cxx:249
 AliDielectronSignalFunc.cxx:250
 AliDielectronSignalFunc.cxx:251
 AliDielectronSignalFunc.cxx:252
 AliDielectronSignalFunc.cxx:253
 AliDielectronSignalFunc.cxx:254
 AliDielectronSignalFunc.cxx:255
 AliDielectronSignalFunc.cxx:256
 AliDielectronSignalFunc.cxx:257
 AliDielectronSignalFunc.cxx:258
 AliDielectronSignalFunc.cxx:259
 AliDielectronSignalFunc.cxx:260
 AliDielectronSignalFunc.cxx:261
 AliDielectronSignalFunc.cxx:262
 AliDielectronSignalFunc.cxx:263
 AliDielectronSignalFunc.cxx:264
 AliDielectronSignalFunc.cxx:265
 AliDielectronSignalFunc.cxx:266
 AliDielectronSignalFunc.cxx:267
 AliDielectronSignalFunc.cxx:268
 AliDielectronSignalFunc.cxx:269
 AliDielectronSignalFunc.cxx:270
 AliDielectronSignalFunc.cxx:271
 AliDielectronSignalFunc.cxx:272
 AliDielectronSignalFunc.cxx:273
 AliDielectronSignalFunc.cxx:274
 AliDielectronSignalFunc.cxx:275
 AliDielectronSignalFunc.cxx:276
 AliDielectronSignalFunc.cxx:277
 AliDielectronSignalFunc.cxx:278
 AliDielectronSignalFunc.cxx:279
 AliDielectronSignalFunc.cxx:280
 AliDielectronSignalFunc.cxx:281
 AliDielectronSignalFunc.cxx:282
 AliDielectronSignalFunc.cxx:283
 AliDielectronSignalFunc.cxx:284
 AliDielectronSignalFunc.cxx:285
 AliDielectronSignalFunc.cxx:286
 AliDielectronSignalFunc.cxx:287
 AliDielectronSignalFunc.cxx:288
 AliDielectronSignalFunc.cxx:289
 AliDielectronSignalFunc.cxx:290
 AliDielectronSignalFunc.cxx:291
 AliDielectronSignalFunc.cxx:292
 AliDielectronSignalFunc.cxx:293
 AliDielectronSignalFunc.cxx:294
 AliDielectronSignalFunc.cxx:295
 AliDielectronSignalFunc.cxx:296
 AliDielectronSignalFunc.cxx:297
 AliDielectronSignalFunc.cxx:298
 AliDielectronSignalFunc.cxx:299
 AliDielectronSignalFunc.cxx:300
 AliDielectronSignalFunc.cxx:301
 AliDielectronSignalFunc.cxx:302
 AliDielectronSignalFunc.cxx:303
 AliDielectronSignalFunc.cxx:304
 AliDielectronSignalFunc.cxx:305
 AliDielectronSignalFunc.cxx:306
 AliDielectronSignalFunc.cxx:307
 AliDielectronSignalFunc.cxx:308
 AliDielectronSignalFunc.cxx:309
 AliDielectronSignalFunc.cxx:310
 AliDielectronSignalFunc.cxx:311
 AliDielectronSignalFunc.cxx:312
 AliDielectronSignalFunc.cxx:313
 AliDielectronSignalFunc.cxx:314
 AliDielectronSignalFunc.cxx:315
 AliDielectronSignalFunc.cxx:316
 AliDielectronSignalFunc.cxx:317
 AliDielectronSignalFunc.cxx:318
 AliDielectronSignalFunc.cxx:319
 AliDielectronSignalFunc.cxx:320
 AliDielectronSignalFunc.cxx:321
 AliDielectronSignalFunc.cxx:322
 AliDielectronSignalFunc.cxx:323
 AliDielectronSignalFunc.cxx:324
 AliDielectronSignalFunc.cxx:325
 AliDielectronSignalFunc.cxx:326
 AliDielectronSignalFunc.cxx:327
 AliDielectronSignalFunc.cxx:328
 AliDielectronSignalFunc.cxx:329
 AliDielectronSignalFunc.cxx:330
 AliDielectronSignalFunc.cxx:331
 AliDielectronSignalFunc.cxx:332
 AliDielectronSignalFunc.cxx:333
 AliDielectronSignalFunc.cxx:334
 AliDielectronSignalFunc.cxx:335
 AliDielectronSignalFunc.cxx:336
 AliDielectronSignalFunc.cxx:337
 AliDielectronSignalFunc.cxx:338
 AliDielectronSignalFunc.cxx:339
 AliDielectronSignalFunc.cxx:340
 AliDielectronSignalFunc.cxx:341
 AliDielectronSignalFunc.cxx:342
 AliDielectronSignalFunc.cxx:343
 AliDielectronSignalFunc.cxx:344
 AliDielectronSignalFunc.cxx:345
 AliDielectronSignalFunc.cxx:346
 AliDielectronSignalFunc.cxx:347
 AliDielectronSignalFunc.cxx:348
 AliDielectronSignalFunc.cxx:349
 AliDielectronSignalFunc.cxx:350
 AliDielectronSignalFunc.cxx:351
 AliDielectronSignalFunc.cxx:352
 AliDielectronSignalFunc.cxx:353
 AliDielectronSignalFunc.cxx:354
 AliDielectronSignalFunc.cxx:355
 AliDielectronSignalFunc.cxx:356
 AliDielectronSignalFunc.cxx:357
 AliDielectronSignalFunc.cxx:358
 AliDielectronSignalFunc.cxx:359
 AliDielectronSignalFunc.cxx:360
 AliDielectronSignalFunc.cxx:361
 AliDielectronSignalFunc.cxx:362
 AliDielectronSignalFunc.cxx:363
 AliDielectronSignalFunc.cxx:364
 AliDielectronSignalFunc.cxx:365
 AliDielectronSignalFunc.cxx:366
 AliDielectronSignalFunc.cxx:367
 AliDielectronSignalFunc.cxx:368
 AliDielectronSignalFunc.cxx:369
 AliDielectronSignalFunc.cxx:370
 AliDielectronSignalFunc.cxx:371
 AliDielectronSignalFunc.cxx:372
 AliDielectronSignalFunc.cxx:373
 AliDielectronSignalFunc.cxx:374
 AliDielectronSignalFunc.cxx:375
 AliDielectronSignalFunc.cxx:376
 AliDielectronSignalFunc.cxx:377
 AliDielectronSignalFunc.cxx:378
 AliDielectronSignalFunc.cxx:379
 AliDielectronSignalFunc.cxx:380
 AliDielectronSignalFunc.cxx:381
 AliDielectronSignalFunc.cxx:382
 AliDielectronSignalFunc.cxx:383
 AliDielectronSignalFunc.cxx:384
 AliDielectronSignalFunc.cxx:385
 AliDielectronSignalFunc.cxx:386
 AliDielectronSignalFunc.cxx:387
 AliDielectronSignalFunc.cxx:388
 AliDielectronSignalFunc.cxx:389
 AliDielectronSignalFunc.cxx:390
 AliDielectronSignalFunc.cxx:391
 AliDielectronSignalFunc.cxx:392
 AliDielectronSignalFunc.cxx:393
 AliDielectronSignalFunc.cxx:394
 AliDielectronSignalFunc.cxx:395
 AliDielectronSignalFunc.cxx:396
 AliDielectronSignalFunc.cxx:397
 AliDielectronSignalFunc.cxx:398
 AliDielectronSignalFunc.cxx:399
 AliDielectronSignalFunc.cxx:400
 AliDielectronSignalFunc.cxx:401
 AliDielectronSignalFunc.cxx:402
 AliDielectronSignalFunc.cxx:403
 AliDielectronSignalFunc.cxx:404
 AliDielectronSignalFunc.cxx:405
 AliDielectronSignalFunc.cxx:406
 AliDielectronSignalFunc.cxx:407
 AliDielectronSignalFunc.cxx:408
 AliDielectronSignalFunc.cxx:409
 AliDielectronSignalFunc.cxx:410
 AliDielectronSignalFunc.cxx:411
 AliDielectronSignalFunc.cxx:412
 AliDielectronSignalFunc.cxx:413
 AliDielectronSignalFunc.cxx:414
 AliDielectronSignalFunc.cxx:415
 AliDielectronSignalFunc.cxx:416
 AliDielectronSignalFunc.cxx:417
 AliDielectronSignalFunc.cxx:418
 AliDielectronSignalFunc.cxx:419
 AliDielectronSignalFunc.cxx:420
 AliDielectronSignalFunc.cxx:421
 AliDielectronSignalFunc.cxx:422
 AliDielectronSignalFunc.cxx:423
 AliDielectronSignalFunc.cxx:424
 AliDielectronSignalFunc.cxx:425
 AliDielectronSignalFunc.cxx:426
 AliDielectronSignalFunc.cxx:427
 AliDielectronSignalFunc.cxx:428
 AliDielectronSignalFunc.cxx:429
 AliDielectronSignalFunc.cxx:430
 AliDielectronSignalFunc.cxx:431
 AliDielectronSignalFunc.cxx:432
 AliDielectronSignalFunc.cxx:433
 AliDielectronSignalFunc.cxx:434
 AliDielectronSignalFunc.cxx:435
 AliDielectronSignalFunc.cxx:436
 AliDielectronSignalFunc.cxx:437
 AliDielectronSignalFunc.cxx:438
 AliDielectronSignalFunc.cxx:439
 AliDielectronSignalFunc.cxx:440
 AliDielectronSignalFunc.cxx:441
 AliDielectronSignalFunc.cxx:442
 AliDielectronSignalFunc.cxx:443
 AliDielectronSignalFunc.cxx:444
 AliDielectronSignalFunc.cxx:445
 AliDielectronSignalFunc.cxx:446
 AliDielectronSignalFunc.cxx:447
 AliDielectronSignalFunc.cxx:448
 AliDielectronSignalFunc.cxx:449
 AliDielectronSignalFunc.cxx:450
 AliDielectronSignalFunc.cxx:451
 AliDielectronSignalFunc.cxx:452
 AliDielectronSignalFunc.cxx:453
 AliDielectronSignalFunc.cxx:454
 AliDielectronSignalFunc.cxx:455
 AliDielectronSignalFunc.cxx:456
 AliDielectronSignalFunc.cxx:457
 AliDielectronSignalFunc.cxx:458
 AliDielectronSignalFunc.cxx:459
 AliDielectronSignalFunc.cxx:460
 AliDielectronSignalFunc.cxx:461
 AliDielectronSignalFunc.cxx:462
 AliDielectronSignalFunc.cxx:463
 AliDielectronSignalFunc.cxx:464
 AliDielectronSignalFunc.cxx:465
 AliDielectronSignalFunc.cxx:466
 AliDielectronSignalFunc.cxx:467
 AliDielectronSignalFunc.cxx:468
 AliDielectronSignalFunc.cxx:469
 AliDielectronSignalFunc.cxx:470
 AliDielectronSignalFunc.cxx:471
 AliDielectronSignalFunc.cxx:472
 AliDielectronSignalFunc.cxx:473
 AliDielectronSignalFunc.cxx:474
 AliDielectronSignalFunc.cxx:475
 AliDielectronSignalFunc.cxx:476
 AliDielectronSignalFunc.cxx:477
 AliDielectronSignalFunc.cxx:478
 AliDielectronSignalFunc.cxx:479
 AliDielectronSignalFunc.cxx:480
 AliDielectronSignalFunc.cxx:481
 AliDielectronSignalFunc.cxx:482
 AliDielectronSignalFunc.cxx:483
 AliDielectronSignalFunc.cxx:484
 AliDielectronSignalFunc.cxx:485
 AliDielectronSignalFunc.cxx:486
 AliDielectronSignalFunc.cxx:487
 AliDielectronSignalFunc.cxx:488
 AliDielectronSignalFunc.cxx:489
 AliDielectronSignalFunc.cxx:490
 AliDielectronSignalFunc.cxx:491
 AliDielectronSignalFunc.cxx:492
 AliDielectronSignalFunc.cxx:493
 AliDielectronSignalFunc.cxx:494
 AliDielectronSignalFunc.cxx:495
 AliDielectronSignalFunc.cxx:496
 AliDielectronSignalFunc.cxx:497
 AliDielectronSignalFunc.cxx:498
 AliDielectronSignalFunc.cxx:499
 AliDielectronSignalFunc.cxx:500
 AliDielectronSignalFunc.cxx:501
 AliDielectronSignalFunc.cxx:502
 AliDielectronSignalFunc.cxx:503
 AliDielectronSignalFunc.cxx:504
 AliDielectronSignalFunc.cxx:505
 AliDielectronSignalFunc.cxx:506
 AliDielectronSignalFunc.cxx:507
 AliDielectronSignalFunc.cxx:508
 AliDielectronSignalFunc.cxx:509
 AliDielectronSignalFunc.cxx:510
 AliDielectronSignalFunc.cxx:511
 AliDielectronSignalFunc.cxx:512
 AliDielectronSignalFunc.cxx:513
 AliDielectronSignalFunc.cxx:514
 AliDielectronSignalFunc.cxx:515
 AliDielectronSignalFunc.cxx:516
 AliDielectronSignalFunc.cxx:517
 AliDielectronSignalFunc.cxx:518
 AliDielectronSignalFunc.cxx:519
 AliDielectronSignalFunc.cxx:520
 AliDielectronSignalFunc.cxx:521
 AliDielectronSignalFunc.cxx:522
 AliDielectronSignalFunc.cxx:523
 AliDielectronSignalFunc.cxx:524
 AliDielectronSignalFunc.cxx:525
 AliDielectronSignalFunc.cxx:526
 AliDielectronSignalFunc.cxx:527
 AliDielectronSignalFunc.cxx:528
 AliDielectronSignalFunc.cxx:529
 AliDielectronSignalFunc.cxx:530
 AliDielectronSignalFunc.cxx:531
 AliDielectronSignalFunc.cxx:532
 AliDielectronSignalFunc.cxx:533
 AliDielectronSignalFunc.cxx:534
 AliDielectronSignalFunc.cxx:535
 AliDielectronSignalFunc.cxx:536
 AliDielectronSignalFunc.cxx:537
 AliDielectronSignalFunc.cxx:538
 AliDielectronSignalFunc.cxx:539
 AliDielectronSignalFunc.cxx:540
 AliDielectronSignalFunc.cxx:541
 AliDielectronSignalFunc.cxx:542
 AliDielectronSignalFunc.cxx:543
 AliDielectronSignalFunc.cxx:544
 AliDielectronSignalFunc.cxx:545
 AliDielectronSignalFunc.cxx:546
 AliDielectronSignalFunc.cxx:547
 AliDielectronSignalFunc.cxx:548
 AliDielectronSignalFunc.cxx:549
 AliDielectronSignalFunc.cxx:550
 AliDielectronSignalFunc.cxx:551
 AliDielectronSignalFunc.cxx:552
 AliDielectronSignalFunc.cxx:553
 AliDielectronSignalFunc.cxx:554
 AliDielectronSignalFunc.cxx:555
 AliDielectronSignalFunc.cxx:556
 AliDielectronSignalFunc.cxx:557
 AliDielectronSignalFunc.cxx:558
 AliDielectronSignalFunc.cxx:559
 AliDielectronSignalFunc.cxx:560
 AliDielectronSignalFunc.cxx:561
 AliDielectronSignalFunc.cxx:562
 AliDielectronSignalFunc.cxx:563
 AliDielectronSignalFunc.cxx:564
 AliDielectronSignalFunc.cxx:565
 AliDielectronSignalFunc.cxx:566
 AliDielectronSignalFunc.cxx:567
 AliDielectronSignalFunc.cxx:568
 AliDielectronSignalFunc.cxx:569
 AliDielectronSignalFunc.cxx:570
 AliDielectronSignalFunc.cxx:571
 AliDielectronSignalFunc.cxx:572
 AliDielectronSignalFunc.cxx:573
 AliDielectronSignalFunc.cxx:574
 AliDielectronSignalFunc.cxx:575
 AliDielectronSignalFunc.cxx:576
 AliDielectronSignalFunc.cxx:577
 AliDielectronSignalFunc.cxx:578
 AliDielectronSignalFunc.cxx:579
 AliDielectronSignalFunc.cxx:580
 AliDielectronSignalFunc.cxx:581
 AliDielectronSignalFunc.cxx:582
 AliDielectronSignalFunc.cxx:583
 AliDielectronSignalFunc.cxx:584
 AliDielectronSignalFunc.cxx:585
 AliDielectronSignalFunc.cxx:586
 AliDielectronSignalFunc.cxx:587
 AliDielectronSignalFunc.cxx:588
 AliDielectronSignalFunc.cxx:589
 AliDielectronSignalFunc.cxx:590
 AliDielectronSignalFunc.cxx:591
 AliDielectronSignalFunc.cxx:592
 AliDielectronSignalFunc.cxx:593
 AliDielectronSignalFunc.cxx:594
 AliDielectronSignalFunc.cxx:595
 AliDielectronSignalFunc.cxx:596
 AliDielectronSignalFunc.cxx:597
 AliDielectronSignalFunc.cxx:598
 AliDielectronSignalFunc.cxx:599
 AliDielectronSignalFunc.cxx:600
 AliDielectronSignalFunc.cxx:601
 AliDielectronSignalFunc.cxx:602
 AliDielectronSignalFunc.cxx:603
 AliDielectronSignalFunc.cxx:604
 AliDielectronSignalFunc.cxx:605
 AliDielectronSignalFunc.cxx:606
 AliDielectronSignalFunc.cxx:607
 AliDielectronSignalFunc.cxx:608
 AliDielectronSignalFunc.cxx:609
 AliDielectronSignalFunc.cxx:610
 AliDielectronSignalFunc.cxx:611
 AliDielectronSignalFunc.cxx:612
 AliDielectronSignalFunc.cxx:613
 AliDielectronSignalFunc.cxx:614
 AliDielectronSignalFunc.cxx:615
 AliDielectronSignalFunc.cxx:616
 AliDielectronSignalFunc.cxx:617
 AliDielectronSignalFunc.cxx:618
 AliDielectronSignalFunc.cxx:619
 AliDielectronSignalFunc.cxx:620
 AliDielectronSignalFunc.cxx:621
 AliDielectronSignalFunc.cxx:622
 AliDielectronSignalFunc.cxx:623
 AliDielectronSignalFunc.cxx:624
 AliDielectronSignalFunc.cxx:625
 AliDielectronSignalFunc.cxx:626
 AliDielectronSignalFunc.cxx:627
 AliDielectronSignalFunc.cxx:628
 AliDielectronSignalFunc.cxx:629
 AliDielectronSignalFunc.cxx:630
 AliDielectronSignalFunc.cxx:631
 AliDielectronSignalFunc.cxx:632
 AliDielectronSignalFunc.cxx:633
 AliDielectronSignalFunc.cxx:634
 AliDielectronSignalFunc.cxx:635
 AliDielectronSignalFunc.cxx:636
 AliDielectronSignalFunc.cxx:637
 AliDielectronSignalFunc.cxx:638
 AliDielectronSignalFunc.cxx:639
 AliDielectronSignalFunc.cxx:640
 AliDielectronSignalFunc.cxx:641
 AliDielectronSignalFunc.cxx:642
 AliDielectronSignalFunc.cxx:643
 AliDielectronSignalFunc.cxx:644
 AliDielectronSignalFunc.cxx:645
 AliDielectronSignalFunc.cxx:646
 AliDielectronSignalFunc.cxx:647
 AliDielectronSignalFunc.cxx:648
 AliDielectronSignalFunc.cxx:649
 AliDielectronSignalFunc.cxx:650
 AliDielectronSignalFunc.cxx:651
 AliDielectronSignalFunc.cxx:652
 AliDielectronSignalFunc.cxx:653
 AliDielectronSignalFunc.cxx:654
 AliDielectronSignalFunc.cxx:655
 AliDielectronSignalFunc.cxx:656
 AliDielectronSignalFunc.cxx:657
 AliDielectronSignalFunc.cxx:658
 AliDielectronSignalFunc.cxx:659
 AliDielectronSignalFunc.cxx:660
 AliDielectronSignalFunc.cxx:661
 AliDielectronSignalFunc.cxx:662
 AliDielectronSignalFunc.cxx:663
 AliDielectronSignalFunc.cxx:664
 AliDielectronSignalFunc.cxx:665
 AliDielectronSignalFunc.cxx:666
 AliDielectronSignalFunc.cxx:667
 AliDielectronSignalFunc.cxx:668