[u/mrichter/AliRoot.git] / PWGDQ / dielectron / AliDielectronSignalExt.cxx

/*************************************************************************
* 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 SignalExt                             //
//                                                                       //
/*
Dielectron signal extraction class using functions as input.

A function to describe the signal as well as one to describe the background
has to be deployed by the user. Alternatively on of the default implementaions
can be used.

*/
//                                                                       //
///////////////////////////////////////////////////////////////////////////
#include <TF1.h>
#include <TH1.h>
#include <TH2F.h>
#include <TLatex.h>
#include <TLegend.h>
#include <TCanvas.h>
#include <TMath.h>
#include <TString.h>
#include <TLine.h>

#include <AliLog.h>

#include "AliDielectronSignalExt.h"

ClassImp(AliDielectronSignalExt)

AliDielectronSignalExt::AliDielectronSignalExt() :
  AliDielectronSignalBase()
{
  //
  // Default Constructor
  //
}

//______________________________________________
AliDielectronSignalExt::AliDielectronSignalExt(const char* name, const char* title) :
  AliDielectronSignalBase(name, title)
{
  //
  // Named Constructor
  //
}

//______________________________________________
AliDielectronSignalExt::~AliDielectronSignalExt()
{
  //
  // Default Destructor
  //
}

//______________________________________________
void AliDielectronSignalExt::Process(TObjArray* const arrhist)
{
  // 
  // signal subtraction. support like-sign subtraction and event mixing method
  //
  switch ( fMethod ){
    case kLikeSign :
    case kLikeSignArithm :
      ProcessLS(arrhist);    // process like-sign subtraction method
      break;

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

  case kRotation:
      ProcessRotation(arrhist);
      break;

    default :
      AliWarning("Subtraction method not supported. Please check SetMethod() function.");
  }
}

//______________________________________________
void AliDielectronSignalExt::ProcessLS(TObjArray* const arrhist)
{
  //
  // signal subtraction 
  //
  fHistDataPP = (TH1*)(arrhist->At(0))->Clone("histPP");  // ++    SE
  fHistDataPM = (TH1*)(arrhist->At(1))->Clone("histPM");  // +-    SE
  fHistDataMM = (TH1*)(arrhist->At(2))->Clone("histMM");  // --    SE
  fHistDataPP->Sumw2();
  fHistDataPM->Sumw2();
  fHistDataMM->Sumw2();
  fHistDataPP->SetDirectory(0);
  fHistDataPM->SetDirectory(0);
  fHistDataMM->SetDirectory(0);
  
  // rebin the histograms
  if (fRebin>1) { 
    fHistDataPP->Rebin(fRebin);
    fHistDataPM->Rebin(fRebin);
    fHistDataMM->Rebin(fRebin);
  }       

  fHistSignal = new TH1D("HistSignal", "Like-Sign substracted signal",
			 fHistDataPM->GetXaxis()->GetNbins(),
			 fHistDataPM->GetXaxis()->GetXmin(), fHistDataPM->GetXaxis()->GetXmax());
  fHistSignal->SetDirectory(0);
  fHistBackground = new TH1D("HistBackground", "Like-sign contribution",
			     fHistDataPM->GetXaxis()->GetNbins(),
			     fHistDataPM->GetXaxis()->GetXmin(), fHistDataPM->GetXaxis()->GetXmax());
  fHistBackground->SetDirectory(0);
  
  // fill out background and subtracted histogram
  for(Int_t ibin=1; ibin<=fHistDataPM->GetXaxis()->GetNbins(); ibin++) {
    Float_t pm = fHistDataPM->GetBinContent(ibin);
    Float_t pp = fHistDataPP->GetBinContent(ibin);
    Float_t mm = fHistDataMM->GetBinContent(ibin);
    Float_t epm = fHistDataPM->GetBinError(ibin);

    Float_t background = 2*TMath::Sqrt(pp*mm);
    Float_t ebackground = TMath::Sqrt(mm+pp);
    if (fMethod==kLikeSignArithm){
      //Arithmetic mean instead of geometric
      background=(pp+mm);
      ebackground=TMath::Sqrt(pp+mm);
      if (TMath::Abs(ebackground)<1e-30) ebackground=1;
    }
//     Float_t signal = pm - background;
//     Float_t error = TMath::Sqrt(epm*epm+mm+pp);

    fHistSignal->SetBinContent(ibin, pm);
    fHistSignal->SetBinError(ibin, epm);
    fHistBackground->SetBinContent(ibin, background);
    fHistBackground->SetBinError(ibin, ebackground);
  }
  //scale histograms to match integral between fScaleMin and fScaleMax
  // or if fScaleMax <  fScaleMin use fScaleMin as scale factor
  if (fScaleMax>fScaleMin) fScaleFactor=ScaleHistograms(fHistDataPM,fHistBackground,fScaleMin,fScaleMax);
  else if (fScaleMin>0.){
    fScaleFactor=fScaleMin;
    fHistBackground->Scale(fScaleFactor);
  }

  //subract background
  fHistSignal->Add(fHistBackground,-1);
  
  // 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));
  printf("%f  %f\n",fValues(0),fValues(1));
  // S/B and significance
  SetSignificanceAndSOB();

  fProcessed = kTRUE;
}

//______________________________________________
void AliDielectronSignalExt::ProcessEM(TObjArray* const arrhist)
{
  //
  // event mixing
  //
  fHistDataPM = (TH1*)(arrhist->At(0))->Clone("histPMSE");  // +-    SE
  fHistDataME = (TH1*)(arrhist->At(1))->Clone("histPMME");  // +-    ME
  fHistDataPM->Sumw2();
  fHistDataME->Sumw2();
  fHistDataPM->SetDirectory(0);
  fHistDataME->SetDirectory(0);

  // rebin the histograms
  if (fRebin>1) {
    fHistDataPM->Rebin(fRebin); 
    fHistDataME->Rebin(fRebin);
  }

  fHistSignal = new TH1D("HistSignal", "Mixed events background substracted signal",
			 fHistDataPM->GetXaxis()->GetNbins(),
		   fHistDataPM->GetXaxis()->GetXmin(), fHistDataPM->GetXaxis()->GetXmax());
  fHistSignal->SetDirectory(0);
  fHistBackground = new TH1D("HistBackground", "background contribution from mixed events",
			     fHistDataPM->GetXaxis()->GetNbins(),
			     fHistDataPM->GetXaxis()->GetXmin(), fHistDataPM->GetXaxis()->GetXmax());
  fHistBackground->SetDirectory(0);

  // fill out background and subtracted histogram
  for(Int_t ibin=1; ibin<=fHistDataPM->GetXaxis()->GetNbins(); ibin++) {
    Float_t pm = fHistDataPM->GetBinContent(ibin);
    Float_t epm = fHistDataPM->GetBinError(ibin);
    Float_t background = fHistDataME->GetBinContent(ibin);
    Float_t ebackground = fHistDataME->GetBinError(ibin);

    fHistSignal->SetBinContent(ibin, pm); 
    fHistSignal->SetBinError(ibin, epm);
    fHistBackground->SetBinContent(ibin, background);
    fHistBackground->SetBinError(ibin, ebackground); 
  }

  if (fScaleMax>fScaleMin) fScaleFactor=ScaleHistograms(fHistDataPM,fHistBackground,fScaleMin,fScaleMax);
  else if (fScaleMin>0.){    
    fScaleFactor=fScaleMin;
    fHistBackground->Scale(fScaleFactor);
  }

  //subract background  
  fHistSignal->Add(fHistBackground,-1);

  // 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();

  fProcessed = kTRUE;
}

//______________________________________________
void AliDielectronSignalExt::ProcessRotation(TObjArray* const arrhist)
{
  //
  // signal subtraction
  //
  fHistDataPM = (TH1*)(arrhist->At(1))->Clone("histPM");  // +-    SE
  if (!fHistDataPM){
    AliError("Unlike sign histogram not available. Cannot extract the signal.");
    return;
  }
  fHistDataPM->Sumw2();

  fHistBackground=(TH1*)arrhist->At(10)->Clone("histRotation");
  if (!fHistBackground){
    AliError("Histgram from rotation not available. Cannot extract the signal.");
    delete fHistDataPM;
    fHistDataPM=0x0;
    return;
  }
  fHistBackground->Sumw2();

  // rebin the histograms
  if (fRebin>1) {
    fHistDataPM->Rebin(fRebin);
    fHistBackground->Rebin(fRebin);
  }

  //scale histograms to match integral between fScaleMin and fScaleMax
  // or if fScaleMax <  fScaleMin use fScaleMin as scale factor
  if (fScaleMax>fScaleMin) fScaleFactor=ScaleHistograms(fHistDataPM,fHistBackground,fScaleMin,fScaleMax);
  else if (fScaleMin>0.){
    fScaleFactor=fScaleMin;
    fHistBackground->Scale(fScaleFactor);
  }

  fHistSignal=(TH1*)fHistDataPM->Clone("histSignal");
  fHistSignal->Add(fHistBackground,-1.);

    // 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();
  
  fProcessed = kTRUE;
  
}

//______________________________________________
void AliDielectronSignalExt::Draw(const Option_t* option)
{
  //
  // Draw the fitted function
  //
  TString drawOpt(option); 
  drawOpt.ToLower();   

  Float_t minY = 0.001;
  Float_t maxY = 1.2*fHistDataPM->GetMaximum();
  Float_t minX = 1.001*fHistDataPM->GetXaxis()->GetXmin();
  Float_t maxX = 0.999*fHistDataPM->GetXaxis()->GetXmax();
  Int_t binSize = Int_t(1000*fHistDataPM->GetBinWidth(1));   // in MeV
  Float_t minMinY = fHistSignal->GetMinimum();

  TCanvas *cSub = new TCanvas(Form("%s", fName.Data()),Form("%s", fTitle.Data()),1400,1000);
  cSub->SetLeftMargin(0.15);
  cSub->SetRightMargin(0.0);
  cSub->SetTopMargin(0.002);
  cSub->SetBottomMargin(0.0);
  cSub->Divide(2,2,0.,0.);
  cSub->Draw();

  TVirtualPad* pad = cSub->cd(1);
  pad->SetLeftMargin(0.15);
  pad->SetRightMargin(0.0);
  pad->SetTopMargin(0.005);
  pad->SetBottomMargin(0.0);
  TH2F *range1=new TH2F("range1","",10,minX,maxX,10,minY,maxY);
  range1->SetStats(kFALSE);
  range1->GetYaxis()->SetTitle(Form("entries [counts per %d MeV bin]", binSize));
  range1->GetYaxis()->CenterTitle();
  range1->GetYaxis()->SetLabelSize(0.05);
  range1->GetYaxis()->SetTitleSize(0.06);
  range1->GetYaxis()->SetTitleOffset(0.8);
  range1->Draw();
  fHistDataPM->SetLineColor(1);
  fHistDataPM->SetLineWidth(2);
  //  fHistDataPM->SetMarkerStyle(21);
  fHistDataPM->Draw("Psame");
  TLatex *latex = new TLatex();
  latex->SetNDC();
  latex->SetTextSize(0.05);
  latex->DrawLatex(0.2, 0.95, "Background un-substracted");
  TLine line;
  line.SetLineWidth(1);
  line.SetLineStyle(2);
  line.DrawLine(fIntMin, minY, fIntMin, maxY);
  line.DrawLine(fIntMax, minY, fIntMax, maxY);

  pad = cSub->cd(2);
  pad->SetLeftMargin(0.);
  pad->SetRightMargin(0.005);
  pad->SetTopMargin(0.005);
  pad->SetBottomMargin(0.0);
  TH2F *range2=new TH2F("range2","",10,minX,maxX,10,minY,maxY);
  range2->SetStats(kFALSE);
  range2->Draw();
  fHistBackground->SetLineColor(4);
  fHistBackground->SetLineWidth(2);
  //  fHistBackground->SetMarkerColor(4);
  //  fHistBackground->SetMarkerStyle(6);
  fHistBackground->Draw("Psame");
  latex->DrawLatex(0.05, 0.95, "Like-sign background");
  line.DrawLine(fIntMin, minY, fIntMin, maxY);
  line.DrawLine(fIntMax, minY, fIntMax, maxY);
  TLegend *legend = new TLegend(0.65, 0.70, 0.98, 0.98);
  legend->SetFillColor(0);
  legend->SetMargin(0.15);
  legend->AddEntry(fHistDataPM, "N_{+-}", "l");
  legend->AddEntry(fHistDataPP, "N_{++}", "l");
  legend->AddEntry(fHistDataMM, "N_{--}", "l");
  legend->AddEntry(fHistSignal, "N_{+-} - 2 #sqrt{N_{++} #times N_{--}}", "l");
  legend->AddEntry(fHistBackground, "2 #sqrt{N_{++} #times N_{--}}", "l");
  legend->Draw();

  
  pad = cSub->cd(3);
  pad->SetLeftMargin(0.15);
  pad->SetRightMargin(0.0);
  pad->SetTopMargin(0.0);
  pad->SetBottomMargin(0.15);
  TH2F *range3=new TH2F("range3","",10,minX,maxX,10,minMinY,maxY);
  range3->SetStats(kFALSE);
  range3->GetYaxis()->SetTitle(Form("entries [counts per %d MeV bin]", binSize));
  range3->GetYaxis()->CenterTitle();
  range3->GetYaxis()->SetLabelSize(0.05);
  range3->GetYaxis()->SetTitleSize(0.06);
  range3->GetYaxis()->SetTitleOffset(0.8);
  range3->GetXaxis()->SetTitle("inv. mass [GeV/c^{2}]");
  range3->GetXaxis()->CenterTitle();
  range3->GetXaxis()->SetLabelSize(0.05);
  range3->GetXaxis()->SetTitleSize(0.06);
  range3->GetXaxis()->SetTitleOffset(1.0);
  range3->Draw();
  fHistDataPM->Draw("Psame");
  fHistDataPP->SetLineWidth(2);
  fHistDataPP->SetLineColor(6);
  fHistDataMM->SetLineWidth(2);
  fHistDataMM->SetLineColor(8);
  fHistDataPP->Draw("Psame");
  fHistDataMM->Draw("Psame");
  line.DrawLine(minX, 0.,maxX, 0.);
  line.DrawLine(fIntMin, minMinY, fIntMin, maxY);
  line.DrawLine(fIntMax, minMinY, fIntMax, maxY);

  pad = cSub->cd(4);
  pad->SetLeftMargin(0.0);
  pad->SetRightMargin(0.005);
  pad->SetTopMargin(0.0);
  pad->SetBottomMargin(0.15);
  TH2F *range4=new TH2F("range4","",10,minX,maxX,10,minMinY,maxY);
  range4->SetStats(kFALSE);
  range4->GetXaxis()->SetTitle("inv. mass [GeV/c^{2}]");
  range4->GetXaxis()->CenterTitle();
  range4->GetXaxis()->SetLabelSize(0.05);
  range4->GetXaxis()->SetTitleSize(0.06);
  range4->GetXaxis()->SetTitleOffset(1.0);
  range4->Draw();
  fHistSignal->SetLineWidth(2);
  fHistSignal->SetLineColor(2);
  fHistSignal->Draw("Psame");
  latex->DrawLatex(0.05, 0.95, "Like-sign background substracted");
  if(fProcessed) DrawStats(0.05, 0.6, 0.5, 0.9);
  line.DrawLine(minX, 0.,maxX, 0.);
  line.DrawLine(fIntMin, minMinY, fIntMin, maxY);
  line.DrawLine(fIntMax, minMinY, fIntMax, maxY);

  cSub->SaveAs(Form("%s_summary.png", fName.Data()));
}
Commit	Line	Data
572b0139	1	/*************************************************************************
	2	* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	///////////////////////////////////////////////////////////////////////////
	17	// //
	18	// Dielectron SignalExt //
	19	// //
	20	/*
	21	Dielectron signal extraction class using functions as input.
	22
	23	A function to describe the signal as well as one to describe the background
	24	has to be deployed by the user. Alternatively on of the default implementaions
	25	can be used.
	26
	27	*/
	28	// //
	29	///////////////////////////////////////////////////////////////////////////
572b0139	30	#include <TF1.h>
572b0139	31	#include <TH1.h>
bc75eeb5	32	#include <TH2F.h>
	33	#include <TLatex.h>
	34	#include <TLegend.h>
572b0139	35	#include <TCanvas.h>
	36	#include <TMath.h>
	37	#include <TString.h>
bc75eeb5	38	#include <TLine.h>
572b0139	39
	40	#include <AliLog.h>
	41
	42	#include "AliDielectronSignalExt.h"
	43
	44	ClassImp(AliDielectronSignalExt)
	45
	46	AliDielectronSignalExt::AliDielectronSignalExt() :
bc75eeb5	47	AliDielectronSignalBase()
572b0139	48	{
	49	//
	50	// Default Constructor
	51	//
572b0139	52	}
	53
	54	//______________________________________________
	55	AliDielectronSignalExt::AliDielectronSignalExt(const char* name, const char* title) :
bc75eeb5	56	AliDielectronSignalBase(name, title)
572b0139	57	{
	58	//
	59	// Named Constructor
	60	//
	61	}
	62
	63	//______________________________________________
	64	AliDielectronSignalExt::~AliDielectronSignalExt()
	65	{
	66	//
	67	// Default Destructor
	68	//
572b0139	69	}
	70
	71	//______________________________________________
	72	void AliDielectronSignalExt::Process(TObjArray* const arrhist)
	73	{
	74	//
	75	// signal subtraction. support like-sign subtraction and event mixing method
	76	//
	77	switch ( fMethod ){
bc75eeb5	78	case kLikeSign :
45b2b1b8	79	case kLikeSignArithm :
572b0139	80	ProcessLS(arrhist); // process like-sign subtraction method
	81	break;
	82
bc75eeb5	83	case kEventMixing :
572b0139	84	ProcessEM(arrhist); // process event mixing method
	85	break;
	86
2a14a7b1	87	case kRotation:
	88	ProcessRotation(arrhist);
	89	break;
	90
572b0139	91	default :
	92	AliWarning("Subtraction method not supported. Please check SetMethod() function.");
	93	}
	94	}
	95
	96	//______________________________________________
	97	void AliDielectronSignalExt::ProcessLS(TObjArray* const arrhist)
	98	{
	99	//
	100	// signal subtraction
	101	//
2a14a7b1	102	fHistDataPP = (TH1*)(arrhist->At(0))->Clone("histPP"); // ++ SE
	103	fHistDataPM = (TH1*)(arrhist->At(1))->Clone("histPM"); // +- SE
	104	fHistDataMM = (TH1*)(arrhist->At(2))->Clone("histMM"); // -- SE
bc75eeb5	105	fHistDataPP->Sumw2();
	106	fHistDataPM->Sumw2();
	107	fHistDataMM->Sumw2();
554e40f8	108	fHistDataPP->SetDirectory(0);
	109	fHistDataPM->SetDirectory(0);
	110	fHistDataMM->SetDirectory(0);
572b0139	111
bc75eeb5	112	// rebin the histograms
	113	if (fRebin>1) {
	114	fHistDataPP->Rebin(fRebin);
	115	fHistDataPM->Rebin(fRebin);
	116	fHistDataMM->Rebin(fRebin);
	117	}
	118
2a14a7b1	119	fHistSignal = new TH1D("HistSignal", "Like-Sign substracted signal",
bc75eeb5	120	fHistDataPM->GetXaxis()->GetNbins(),
bc75eeb5	121	fHistDataPM->GetXaxis()->GetXmin(), fHistDataPM->GetXaxis()->GetXmax());
554e40f8	122	fHistSignal->SetDirectory(0);
2a14a7b1	123	fHistBackground = new TH1D("HistBackground", "Like-sign contribution",
bc75eeb5	124	fHistDataPM->GetXaxis()->GetNbins(),
bc75eeb5	125	fHistDataPM->GetXaxis()->GetXmin(), fHistDataPM->GetXaxis()->GetXmax());
554e40f8	126	fHistBackground->SetDirectory(0);
554e40f8	127
572b0139	128	// fill out background and subtracted histogram
bc75eeb5	129	for(Int_t ibin=1; ibin<=fHistDataPM->GetXaxis()->GetNbins(); ibin++) {
	130	Float_t pm = fHistDataPM->GetBinContent(ibin);
	131	Float_t pp = fHistDataPP->GetBinContent(ibin);
	132	Float_t mm = fHistDataMM->GetBinContent(ibin);
	133	Float_t epm = fHistDataPM->GetBinError(ibin);
	134
	135	Float_t background = 2TMath::Sqrt(ppmm);
	136	Float_t ebackground = TMath::Sqrt(mm+pp);
45b2b1b8	137	if (fMethod==kLikeSignArithm){
	138	//Arithmetic mean instead of geometric
	139	background=(pp+mm);
	140	ebackground=TMath::Sqrt(pp+mm);
	141	if (TMath::Abs(ebackground)<1e-30) ebackground=1;
	142	}
554e40f8	143	// Float_t signal = pm - background;
554e40f8	144	// Float_t error = TMath::Sqrt(epm*epm+mm+pp);
bc75eeb5	145
554e40f8	146	fHistSignal->SetBinContent(ibin, pm);
554e40f8	147	fHistSignal->SetBinError(ibin, epm);
bc75eeb5	148	fHistBackground->SetBinContent(ibin, background);
bc75eeb5	149	fHistBackground->SetBinError(ibin, ebackground);
572b0139	150	}
fb7d2d99	151	//scale histograms to match integral between fScaleMin and fScaleMax
5720c765	152	// or if fScaleMax < fScaleMin use fScaleMin as scale factor
554e40f8	153	if (fScaleMax>fScaleMin) fScaleFactor=ScaleHistograms(fHistDataPM,fHistBackground,fScaleMin,fScaleMax);
5720c765	154	else if (fScaleMin>0.){
	155	fScaleFactor=fScaleMin;
	156	fHistBackground->Scale(fScaleFactor);
	157	}
554e40f8	158
	159	//subract background
	160	fHistSignal->Add(fHistBackground,-1);
	161
bc75eeb5	162	// signal
	163	fValues(0) = fHistSignal->IntegralAndError(fHistSignal->FindBin(fIntMin),
	164	fHistSignal->FindBin(fIntMax), fErrors(0));
	165	// background
	166	fValues(1) = fHistBackground->IntegralAndError(fHistBackground->FindBin(fIntMin),
48609e3d	167	fHistBackground->FindBin(fIntMax),
48609e3d	168	fErrors(1));
5720c765	169	printf("%f %f\n",fValues(0),fValues(1));
bc75eeb5	170	// S/B and significance
572b0139	171	SetSignificanceAndSOB();
572b0139	172
bc75eeb5	173	fProcessed = kTRUE;
572b0139	174	}
	175
	176	//______________________________________________
	177	void AliDielectronSignalExt::ProcessEM(TObjArray* const arrhist)
	178	{
	179	//
5720c765	180	// event mixing
572b0139	181	//
5720c765	182	fHistDataPM = (TH1*)(arrhist->At(0))->Clone("histPMSE"); // +- SE
	183	fHistDataME = (TH1*)(arrhist->At(1))->Clone("histPMME"); // +- ME
	184	fHistDataPM->Sumw2();
	185	fHistDataME->Sumw2();
	186	fHistDataPM->SetDirectory(0);
	187	fHistDataME->SetDirectory(0);
	188
	189	// rebin the histograms
	190	if (fRebin>1) {
	191	fHistDataPM->Rebin(fRebin);
	192	fHistDataME->Rebin(fRebin);
	193	}
	194
	195	fHistSignal = new TH1D("HistSignal", "Mixed events background substracted signal",
	196	fHistDataPM->GetXaxis()->GetNbins(),
	197	fHistDataPM->GetXaxis()->GetXmin(), fHistDataPM->GetXaxis()->GetXmax());
	198	fHistSignal->SetDirectory(0);
	199	fHistBackground = new TH1D("HistBackground", "background contribution from mixed events",
	200	fHistDataPM->GetXaxis()->GetNbins(),
	201	fHistDataPM->GetXaxis()->GetXmin(), fHistDataPM->GetXaxis()->GetXmax());
	202	fHistBackground->SetDirectory(0);
	203
	204	// fill out background and subtracted histogram
	205	for(Int_t ibin=1; ibin<=fHistDataPM->GetXaxis()->GetNbins(); ibin++) {
	206	Float_t pm = fHistDataPM->GetBinContent(ibin);
	207	Float_t epm = fHistDataPM->GetBinError(ibin);
	208	Float_t background = fHistDataME->GetBinContent(ibin);
	209	Float_t ebackground = fHistDataME->GetBinError(ibin);
	210
	211	fHistSignal->SetBinContent(ibin, pm);
	212	fHistSignal->SetBinError(ibin, epm);
	213	fHistBackground->SetBinContent(ibin, background);
	214	fHistBackground->SetBinError(ibin, ebackground);
	215	}
	216
	217	if (fScaleMax>fScaleMin) fScaleFactor=ScaleHistograms(fHistDataPM,fHistBackground,fScaleMin,fScaleMax);
	218	else if (fScaleMin>0.){
	219	fScaleFactor=fScaleMin;
	220	fHistBackground->Scale(fScaleFactor);
	221	}
	222
	223	//subract background
	224	fHistSignal->Add(fHistBackground,-1);
	225
	226	// signal
	227	fValues(0) = fHistSignal->IntegralAndError(fHistSignal->FindBin(fIntMin),
	228	fHistSignal->FindBin(fIntMax), fErrors(0));
	229	// background
	230	fValues(1) = fHistBackground->IntegralAndError(fHistBackground->FindBin(fIntMin),
	231	fHistBackground->FindBin(fIntMax),
	232	fErrors(1));
	233	// S/B and significance
	234	SetSignificanceAndSOB();
	235
	236	fProcessed = kTRUE;
572b0139	237	}
572b0139	238
2a14a7b1	239	//______________________________________________
	240	void AliDielectronSignalExt::ProcessRotation(TObjArray* const arrhist)
	241	{
	242	//
	243	// signal subtraction
	244	//
	245	fHistDataPM = (TH1*)(arrhist->At(1))->Clone("histPM"); // +- SE
	246	if (!fHistDataPM){
	247	AliError("Unlike sign histogram not available. Cannot extract the signal.");
	248	return;
	249	}
	250	fHistDataPM->Sumw2();
	251
	252	fHistBackground=(TH1*)arrhist->At(10)->Clone("histRotation");
	253	if (!fHistBackground){
	254	AliError("Histgram from rotation not available. Cannot extract the signal.");
	255	delete fHistDataPM;
	256	fHistDataPM=0x0;
	257	return;
	258	}
ba15fdfb	259	fHistBackground->Sumw2();
	260
	261	// rebin the histograms
	262	if (fRebin>1) {
	263	fHistDataPM->Rebin(fRebin);
	264	fHistBackground->Rebin(fRebin);
	265	}
2a14a7b1	266
554e40f8	267	//scale histograms to match integral between fScaleMin and fScaleMax
5720c765	268	// or if fScaleMax < fScaleMin use fScaleMin as scale factor
554e40f8	269	if (fScaleMax>fScaleMin) fScaleFactor=ScaleHistograms(fHistDataPM,fHistBackground,fScaleMin,fScaleMax);
5720c765	270	else if (fScaleMin>0.){
	271	fScaleFactor=fScaleMin;
	272	fHistBackground->Scale(fScaleFactor);
	273	}
	274
2a14a7b1	275	fHistSignal=(TH1*)fHistDataPM->Clone("histSignal");
	276	fHistSignal->Add(fHistBackground,-1.);
	277
	278	// signal
	279	fValues(0) = fHistSignal->IntegralAndError(fHistSignal->FindBin(fIntMin),
	280	fHistSignal->FindBin(fIntMax), fErrors(0));
	281	// background
	282	fValues(1) = fHistBackground->IntegralAndError(fHistBackground->FindBin(fIntMin),
	283	fHistBackground->FindBin(fIntMax),
	284	fErrors(1));
	285	// S/B and significance
	286	SetSignificanceAndSOB();
	287
	288	fProcessed = kTRUE;
	289
	290	}
	291
572b0139	292	//______________________________________________
	293	void AliDielectronSignalExt::Draw(const Option_t* option)
	294	{
	295	//
	296	// Draw the fitted function
	297	//
	298	TString drawOpt(option);
	299	drawOpt.ToLower();
	300
bc75eeb5	301	Float_t minY = 0.001;
	302	Float_t maxY = 1.2*fHistDataPM->GetMaximum();
	303	Float_t minX = 1.001*fHistDataPM->GetXaxis()->GetXmin();
	304	Float_t maxX = 0.999*fHistDataPM->GetXaxis()->GetXmax();
	305	Int_t binSize = Int_t(1000*fHistDataPM->GetBinWidth(1)); // in MeV
	306	Float_t minMinY = fHistSignal->GetMinimum();
	307
48609e3d	308	TCanvas *cSub = new TCanvas(Form("%s", fName.Data()),Form("%s", fTitle.Data()),1400,1000);
bc75eeb5	309	cSub->SetLeftMargin(0.15);
	310	cSub->SetRightMargin(0.0);
	311	cSub->SetTopMargin(0.002);
	312	cSub->SetBottomMargin(0.0);
	313	cSub->Divide(2,2,0.,0.);
572b0139	314	cSub->Draw();
572b0139	315
bc75eeb5	316	TVirtualPad* pad = cSub->cd(1);
	317	pad->SetLeftMargin(0.15);
	318	pad->SetRightMargin(0.0);
	319	pad->SetTopMargin(0.005);
	320	pad->SetBottomMargin(0.0);
	321	TH2F *range1=new TH2F("range1","",10,minX,maxX,10,minY,maxY);
	322	range1->SetStats(kFALSE);
	323	range1->GetYaxis()->SetTitle(Form("entries [counts per %d MeV bin]", binSize));
	324	range1->GetYaxis()->CenterTitle();
	325	range1->GetYaxis()->SetLabelSize(0.05);
	326	range1->GetYaxis()->SetTitleSize(0.06);
	327	range1->GetYaxis()->SetTitleOffset(0.8);
	328	range1->Draw();
	329	fHistDataPM->SetLineColor(1);
	330	fHistDataPM->SetLineWidth(2);
	331	// fHistDataPM->SetMarkerStyle(21);
	332	fHistDataPM->Draw("Psame");
	333	TLatex *latex = new TLatex();
	334	latex->SetNDC();
	335	latex->SetTextSize(0.05);
	336	latex->DrawLatex(0.2, 0.95, "Background un-substracted");
	337	TLine line;
	338	line.SetLineWidth(1);
	339	line.SetLineStyle(2);
	340	line.DrawLine(fIntMin, minY, fIntMin, maxY);
	341	line.DrawLine(fIntMax, minY, fIntMax, maxY);
	342
	343	pad = cSub->cd(2);
	344	pad->SetLeftMargin(0.);
	345	pad->SetRightMargin(0.005);
	346	pad->SetTopMargin(0.005);
	347	pad->SetBottomMargin(0.0);
	348	TH2F *range2=new TH2F("range2","",10,minX,maxX,10,minY,maxY);
	349	range2->SetStats(kFALSE);
	350	range2->Draw();
	351	fHistBackground->SetLineColor(4);
	352	fHistBackground->SetLineWidth(2);
	353	// fHistBackground->SetMarkerColor(4);
	354	// fHistBackground->SetMarkerStyle(6);
	355	fHistBackground->Draw("Psame");
	356	latex->DrawLatex(0.05, 0.95, "Like-sign background");
	357	line.DrawLine(fIntMin, minY, fIntMin, maxY);
	358	line.DrawLine(fIntMax, minY, fIntMax, maxY);
	359	TLegend *legend = new TLegend(0.65, 0.70, 0.98, 0.98);
	360	legend->SetFillColor(0);
	361	legend->SetMargin(0.15);
	362	legend->AddEntry(fHistDataPM, "N_{+-}", "l");
	363	legend->AddEntry(fHistDataPP, "N_{++}", "l");
	364	legend->AddEntry(fHistDataMM, "N_{--}", "l");
	365	legend->AddEntry(fHistSignal, "N_{+-} - 2 #sqrt{N_{++} #times N_{--}}", "l");
	366	legend->AddEntry(fHistBackground, "2 #sqrt{N_{++} #times N_{--}}", "l");
	367	legend->Draw();
	368
572b0139	369
bc75eeb5	370	pad = cSub->cd(3);
	371	pad->SetLeftMargin(0.15);
	372	pad->SetRightMargin(0.0);
	373	pad->SetTopMargin(0.0);
	374	pad->SetBottomMargin(0.15);
	375	TH2F *range3=new TH2F("range3","",10,minX,maxX,10,minMinY,maxY);
	376	range3->SetStats(kFALSE);
	377	range3->GetYaxis()->SetTitle(Form("entries [counts per %d MeV bin]", binSize));
	378	range3->GetYaxis()->CenterTitle();
	379	range3->GetYaxis()->SetLabelSize(0.05);
	380	range3->GetYaxis()->SetTitleSize(0.06);
	381	range3->GetYaxis()->SetTitleOffset(0.8);
	382	range3->GetXaxis()->SetTitle("inv. mass [GeV/c^{2}]");
	383	range3->GetXaxis()->CenterTitle();
	384	range3->GetXaxis()->SetLabelSize(0.05);
	385	range3->GetXaxis()->SetTitleSize(0.06);
	386	range3->GetXaxis()->SetTitleOffset(1.0);
	387	range3->Draw();
	388	fHistDataPM->Draw("Psame");
	389	fHistDataPP->SetLineWidth(2);
	390	fHistDataPP->SetLineColor(6);
	391	fHistDataMM->SetLineWidth(2);
	392	fHistDataMM->SetLineColor(8);
	393	fHistDataPP->Draw("Psame");
	394	fHistDataMM->Draw("Psame");
	395	line.DrawLine(minX, 0.,maxX, 0.);
	396	line.DrawLine(fIntMin, minMinY, fIntMin, maxY);
	397	line.DrawLine(fIntMax, minMinY, fIntMax, maxY);
	398
	399	pad = cSub->cd(4);
	400	pad->SetLeftMargin(0.0);
	401	pad->SetRightMargin(0.005);
	402	pad->SetTopMargin(0.0);
	403	pad->SetBottomMargin(0.15);
	404	TH2F *range4=new TH2F("range4","",10,minX,maxX,10,minMinY,maxY);
	405	range4->SetStats(kFALSE);
	406	range4->GetXaxis()->SetTitle("inv. mass [GeV/c^{2}]");
	407	range4->GetXaxis()->CenterTitle();
	408	range4->GetXaxis()->SetLabelSize(0.05);
	409	range4->GetXaxis()->SetTitleSize(0.06);
	410	range4->GetXaxis()->SetTitleOffset(1.0);
	411	range4->Draw();
	412	fHistSignal->SetLineWidth(2);
	413	fHistSignal->SetLineColor(2);
	414	fHistSignal->Draw("Psame");
	415	latex->DrawLatex(0.05, 0.95, "Like-sign background substracted");
	416	if(fProcessed) DrawStats(0.05, 0.6, 0.5, 0.9);
	417	line.DrawLine(minX, 0.,maxX, 0.);
	418	line.DrawLine(fIntMin, minMinY, fIntMin, maxY);
	419	line.DrawLine(fIntMax, minMinY, fIntMax, maxY);
48609e3d	420
48609e3d	421	cSub->SaveAs(Form("%s_summary.png", fName.Data()));
572b0139	422	}
572b0139	423