[u/mrichter/AliRoot.git] / ANALYSIS / EventMixing / AliMixInfo.cxx

//
// Class AliMixInfo
//
// AliMixInfo object contains information about one cut on for event mixing
// available for users containing mixing information
//
// authors:
//          Martin Vala (martin.vala@cern.ch)
//

#include <TList.h>
#include <TPad.h>
#include <TROOT.h>
#include <TFile.h>
#include <TH1.h>
#include <TH2.h>
#include <TProfile.h>
#include <TStyle.h>
#include <TLegend.h>
#include <TPavesText.h>
#include <TCanvas.h>

#include "AliLog.h"

#include "AliMixInfo.h"
#include "AliMixEventPool.h"
#include "AliMixEventCutObj.h"

ClassImp(AliMixInfo)

//_________________________________________________________________________________________________
AliMixInfo::AliMixInfo(const char *name, const char *title) :
   TNamed(name, title),
   fHistogramList(0)
{
   //
   // Default constructor.
   //
   AliDebug(AliLog::kDebug + 5, "<-");
   AliDebug(AliLog::kDebug + 5, "->");
}
//_________________________________________________________________________________________________
AliMixInfo::AliMixInfo(const AliMixInfo &obj) :
   TNamed(obj),
   fHistogramList(obj.fHistogramList)
{
   //
   // Copy constructor.
   //
   AliDebug(AliLog::kDebug + 5, "<-");
   AliDebug(AliLog::kDebug + 5, "->");
}
//_________________________________________________________________________________________________
AliMixInfo::~AliMixInfo()
{
   //
   // Destructor
   //
}

//_________________________________________________________________________________________________
void AliMixInfo::CreateHistogram(AliMixInfo::EInfoHistorgramType type, Int_t nbins, Int_t min, Int_t max)
{
   //
   // Create mix info histograms
   //
   if (!fHistogramList) {
      fHistogramList = new TList;
      fHistogramList->SetOwner(kTRUE);
   }
   TH1I *hist = (TH1I *) fHistogramList->FindObject(GetNameHistogramByType(type));
   if (hist) return;
   hist = new TH1I(GetNameHistogramByType(type), GetTitleHistogramByType(type), nbins, min, max);
   fHistogramList->Add(hist);
}

//_________________________________________________________________________________________________
void AliMixInfo::FillHistogram(AliMixInfo::EInfoHistorgramType type, Int_t value)
{
   //
   // Create mix info histograms
   //
   if (type == kMixedEvents && value < 0) return;
   if (!fHistogramList) {
      AliError("fHistogramList is null");
      return;
   }
   TH1I *hist = (TH1I *) fHistogramList->FindObject(GetNameHistogramByType(type));
   if (hist) {
      hist->Fill(value);
      AliDebug(AliLog::kDebug, Form("%s was filled with %d sum is %.0f", GetNameHistogramByType(type), value, hist->GetBinContent(value)));
   } else {
      AliError(Form("Problem filling histogram %s", GetNameHistogramByType(type)));
   }
}

//_________________________________________________________________________________________________
const char *AliMixInfo::GetNameHistogramByType(Int_t index) const
{
   //
   // Retruns name of cut
   //
   switch (index) {
      case kMainEvents:
         return "hMainEvents";
      case kMixedEvents:
         return "hMixedEvents";
   }
   return "";
}

//_________________________________________________________________________________________________
const char *AliMixInfo::GetTitleHistogramByType(Int_t index) const
{
   //
   // Retruns name of cut
   //
   switch (index) {
      case kMainEvents:
         return "Main Events";
      case kMixedEvents:
         return "Mixed Events";
   }
   return "";
}

//_________________________________________________________________________________________________
void AliMixInfo::Print(Option_t *option) const
{
   //
   // Print Mix info
   //
   if (!fHistogramList) return;
   if (option)
      AliInfo(Form("Name %s with option is %s", GetName(), option));
   TIter next(fHistogramList);
   TH1I *h = 0;
   for (Int_t i = 0; i < fHistogramList->GetEntries(); i++) {
      h = dynamic_cast<TH1I *>(fHistogramList->At(i));
      if (h) {
         h->Print();
         continue;
      }
   }
}
//_________________________________________________________________________________________________
void AliMixInfo::Draw(Option_t* option)
{
   //
   // Drwas mixi info canvas
   //
   if (!fHistogramList) return;

   // creating main canvas
   TCanvas *cMain = new TCanvas("cMain", "Mixing Info", 500, 500);
   if (!cMain) return;
   cMain->Divide(1, 2, 0.001, 0.001);
   cMain->cd(1);
//     TVirtualPad *upperPad = cMain->cd(1);
//     upperPad->Divide(2,1);
//     TVirtualPad *upperPad1 = gPad->cd(2);
//     upperPad1->Divide(1,2);
//     upperPad1->cd(1);
   TPavesText*text = new TPavesText(0.05, 0.05, 0.95, 0.95, 1);
   text->SetName("mixInfoText");
   text->AddText("Help:");
   text->AddText("Move over histogram to see mix info for different bins");
   text->Draw();

   // gets corresponding histograms
   TH1I *hMain = GetHistogramByType(kMainEvents);
   if (!hMain) {
      AliError("hMain is null");
      return;
   }
   TH1I *hMix =  GetHistogramByType(kMixedEvents);
   if (!hMix) {
      AliError("hMix is null");
      return;
   }


   TH2I *hMixInfo2D = 0;
//     TH1I *hOK=0,*hBad=0;
   AliMixEventPool *evPool = (AliMixEventPool *) GetEventPool("mixEventPool");
   if (evPool) {
      Int_t mixNum = evPool->GetMixNumber();
//         hOK = (TH1I *) hMain->Clone();
//         hBad = (TH1I *) hMain->Clone();
      if (!hMixInfo2D) hMixInfo2D = new TH2I("hMixInfo2D", "hMixInfo2D", hMain->GetXaxis()->GetNbins() + 1, hMain->GetXaxis()->GetXmin() - 1, hMain->GetXaxis()->GetXmax(), 1, 0, 1);
      for (Int_t iBin = 0; iBin < hMain->GetNbinsX() + 1; iBin++) {
         if (!iBin) {
            hMixInfo2D->SetBinContent(iBin + 1, 1, 1);
         } else if (!hMain->GetBinContent(iBin) && !hMix->GetBinContent(iBin)) {
            hMixInfo2D->SetBinContent(iBin + 1, 1, 2);
         } else if (hMix->GetBinContent(iBin) == mixNum * hMain->GetBinContent(iBin)) {
            hMixInfo2D->SetBinContent(iBin + 1, 1, 4);
         } else {
            hMixInfo2D->SetBinContent(iBin + 1, 1, 3);
         }
      }
   }

   TStyle *style = gStyle;
   Int_t cols[4] = { kYellow, kViolet, kRed, kGreen  };
   style->SetPalette(4, cols);
   cMain->cd(2);
//    cMain->SetGrid();
   if (hMixInfo2D) {
      hMixInfo2D->SetMaximum(4);
      hMixInfo2D->SetStats(0);
      hMixInfo2D->SetTitle("");
      hMixInfo2D->GetXaxis()->SetNdivisions(510);
      hMixInfo2D->GetYaxis()->SetNdivisions(0);
   }

   if (hMixInfo2D) hMixInfo2D->Draw(Form("COL %s", option));
//
//     TLegend *legend = new TLegend(0.55,0.65,0.76,0.82);
//     legend->AddEntry(hOK,"OK","f");
//     legend->AddEntry(hBad,"NOT OK","f");
//     legend->Draw();

   cMain->cd(2)->AddExec("dynamic", Form("AliMixInfo::DynamicExec((AliMixInfo*)0x%lx)", (ULong_t)this));
}

//_________________________________________________________________________________________________
void AliMixInfo::DynamicExec(AliMixInfo *const mixInfo)
{
   //
   // Function which is run when user move mouse over mix info
   //

   if (!mixInfo) return;

   TObject *select = gPad->GetSelected();
   if (!select) return;
   if (!select->InheritsFrom(TH2I::Class())) {
      gPad->SetUniqueID(0);
      return;
   }

   TH2I *hSelected = (TH2I *) select;
   gPad->GetCanvas()->FeedbackMode(kTRUE);

   //erase old position and draw a line at current position
   Int_t uid = gPad->GetUniqueID();
//     int pxold = gPad->GetUniqueID();
   Int_t px = gPad->GetEventX();
//     Int_t py = gPad->GetEventY();
//     float uxmin = gPad->GetUxmin();
//     float uxmax = gPad->GetUxmax();
//     float uymin = gPad->GetUymin();
//     float uymax = gPad->GetUymax();
   //     Int_t pxmin = gPad->XtoAbsPixel ( uxmin );
   //     Int_t pxmax = gPad->XtoAbsPixel ( uxmax );
   //     Int_t pymin = gPad->YtoAbsPixel ( uymin );
   //     Int_t pymax = gPad->YtoAbsPixel ( uymax );
// //     if(pxold) gVirtualX->DrawLine(pxold,pymin,pxold,pymax);
// //     else gVirtualX->DrawLine(px,pymin,px,pymax);
//     gPad->SetUniqueID ( px );

   Float_t upx = gPad->AbsPixeltoX(px);
//     Float_t upy = gPad->AbsPixeltoY(py);

   Float_t x = gPad->PadtoX(upx);
//     Float_t y = gPad->PadtoY ( upy );

   Int_t binX = hSelected->GetXaxis()->FindBin(x) - 1;
//     Int_t binY = hSelected->GetYaxis()->FindBin(y)-1;


   // return in case of same bin
   if (uid == binX) return;
//     Printf("%d %d",uid,binX);

   //create or set the new canvas cInfo
   TPaveText *text = 0;
   TVirtualPad *padsav = gPad;
   TCanvas *cInfo = (TCanvas *) gROOT->GetListOfCanvases()->FindObject("cMain");
   if (cInfo) {
      text = (TPaveText *)cInfo->GetPrimitive("mixInfoText");
      if (!text) {
         text = new TPavesText(0.05, 0.05, 0.95, 0.95, 1);
      } else {
         text->DeleteText();
      }

   } else   cInfo = new TCanvas("cInfo", "MixInfo Canvas", 510, 0, 350, 150);

   TVirtualPad *upperPad = cInfo->cd(1);
//     TVirtualPad *upperPadL = upperPad->cd(1);
//     TVirtualPad *upperPadR = upperPad->cd(2);
//     TVirtualPad *upperPadR1 = upperPadR->cd(1);
//     TVirtualPad *upperPadR2 = upperPadR->cd(2);
//     TH1I *hMain = 0;
//     TH1I *hMix = 0;


//     mixInfo->Print();
//     return;

   // gets corresponding histograms
   TH1I *hMain = mixInfo->GetHistogramByType(kMainEvents);
   if (!hMain) {
      Printf("hMain is null");
      return;
   }
   TH1I *hMix =  mixInfo->GetHistogramByType(kMixedEvents);
   if (!hMix) {
      Printf("hMix is null");
      return;
   }

   Double_t numMain = hMain->GetBinContent(binX);
   Double_t numMix = hMix->GetBinContent(binX);
   Int_t hist2DValue = (Int_t) hSelected->GetBinContent(binX + 1, 1);

   Int_t mixNum = 1;
   if (text) {
      text->SetName("mixInfoText");
      text->SetTextAlign(12);
      text->SetToolTipText("Mixing Info about current binX");
//         text->SetTextSize(0.1);
//         text->SetTextColor(3);
      text->SetBorderSize(2);
      text->AddText(Form("binX=%d", binX));
      text->AddText(Form("numMain=%.0f", numMain));
      text->AddText(Form("numMix=%.0f", numMix));
      text->AddText(Form("BINCONTENT=%d", hist2DValue));

      if (mixInfo) {

         AliMixEventPool *evPool = (AliMixEventPool *) mixInfo->GetEventPool("mixEventPool");
         if (evPool) {
            mixNum = evPool->GetMixNumber();
            if (binX - 1 > 0)
               evPool->SetCutValuesFromBinIndex(binX - 1);
            TObjArray *eventCuts = evPool->GetListOfEventCuts();
            if (eventCuts) {

               TObjArrayIter next(eventCuts);
               AliMixEventCutObj *cut;
               while ((cut = (AliMixEventCutObj *) next())) {
                  if (hist2DValue > 1) text->AddText(Form("%s <%.2f,%.2f)", cut->GetCutName(), cut->GetMin(), cut->GetMax()));
                  else text->AddText(Form("%s <Out of Range>", cut->GetCutName()));
               }
            }

         }

      }
      switch (hist2DValue) {
         case 1 :
            text->SetFillColor(kYellow);
            break;
         case 2 :
            text->SetFillColor(kViolet);
            break;
         case 3 :
            text->SetFillColor(kRed);
            break;
         case 4 :
            text->SetFillColor(kGreen);
            break;
         default:
            text->SetFillColor(kWhite);
            break;
      }
      upperPad->cd();
      text->Draw();
//         upperPadR1->cd();
//         TH1D *proj1 = hSelected->ProjectionY("_xxx",binX);
//         proj1->Draw();
//         upperPadR2->cd();
//         TH1D *proj2 = hSelected->ProjectionY("_xxx",binX);
//         proj1->Draw();

   }
   cInfo->Update();
   padsav->cd();

   gPad->SetUniqueID(binX);
}

//_________________________________________________________________________________________________
Long64_t AliMixInfo::Merge(TCollection *list)
{
   //
   // Merge function
   //
   if (!list) return 0;
   TIter nxfc(list);
   AliMixInfo *mi = 0;
   Long64_t counter = 0;
   while ((mi = (AliMixInfo *) nxfc())) {
      // Do not merge with ourself
      if (mi == this) continue;
      // Make sure that it is a AliMixInfo
      if (!mi->InheritsFrom(AliMixInfo::Class())) {
         Error("Merge", "attempt to add object of class: %s to a %s", mi->ClassName(), ClassName());
         return -1;
      }
      // Merge now
      Add(mi);
      counter++;
   }
   // Done
   return counter;
}

TH1I *AliMixInfo::GetHistogramByType(Int_t index) const
{
   //
   // GetHistogramByType
   //
   return (TH1I *) fHistogramList->FindObject(GetNameHistogramByType(index));
}

//_________________________________________________________________________________________________
void AliMixInfo::Add(AliMixInfo *mi)
{
   //
   // adds AliMixInfo
   //

   AliInfo(Form("Adding %p", mi));
   if (!mi) return;
   if (!fHistogramList) return;
   TH1I *hMain = GetHistogramByType(kMainEvents);
   if (!hMain) {
      AliError("hMain is null");
      return;
   }
   TH1I *hMix =  GetHistogramByType(kMixedEvents);
   if (!hMix) {
      AliError("hMain is null");
      return;
   }
   hMain->Add(mi->GetHistogramByType(kMainEvents));
   hMix->Add(mi->GetHistogramByType(kMixedEvents));
}

//_________________________________________________________________________________________________
void AliMixInfo::SetEventPool(AliMixEventPool *evPool)
{
   //
   // Sets event pool
   //
   if (!evPool) return;

   if (!fHistogramList) return;

   fHistogramList->Add(evPool);
}

//_________________________________________________________________________________________________
AliMixEventPool *AliMixInfo::GetEventPool(const char *name)
{
   //
   // Gets event pool
   //
   if (!fHistogramList) return 0;

   return (AliMixEventPool *) fHistogramList->FindObject(name);
}
Commit	Line	Data
b425275c	1	//
	2	// Class AliMixInfo
	3	//
	4	// AliMixInfo object contains information about one cut on for event mixing
	5	// available for users containing mixing information
	6	//
	7	// authors:
	8	// Martin Vala (martin.vala@cern.ch)
	9	//
	10
	11	#include <TList.h>
	12	#include <TPad.h>
	13	#include <TROOT.h>
	14	#include <TFile.h>
	15	#include <TH1.h>
	16	#include <TH2.h>
	17	#include <TProfile.h>
	18	#include <TStyle.h>
	19	#include <TLegend.h>
	20	#include <TPavesText.h>
	21	#include <TCanvas.h>
	22
	23	#include "AliLog.h"
	24
	25	#include "AliMixInfo.h"
	26	#include "AliMixEventPool.h"
	27	#include "AliMixEventCutObj.h"
	28
	29	ClassImp(AliMixInfo)
	30
	31	//_________________________________________________________________________________________________
	32	AliMixInfo::AliMixInfo(const char name, const char title) :
	33	TNamed(name, title),
	34	fHistogramList(0)
	35	{
	36	//
	37	// Default constructor.
	38	//
	39	AliDebug(AliLog::kDebug + 5, "<-");
	40	AliDebug(AliLog::kDebug + 5, "->");
	41	}
	42	//_________________________________________________________________________________________________
	43	AliMixInfo::AliMixInfo(const AliMixInfo &obj) :
	44	TNamed(obj),
	45	fHistogramList(obj.fHistogramList)
	46	{
	47	//
	48	// Copy constructor.
	49	//
	50	AliDebug(AliLog::kDebug + 5, "<-");
	51	AliDebug(AliLog::kDebug + 5, "->");
	52	}
	53	//_________________________________________________________________________________________________
	54	AliMixInfo::~AliMixInfo()
	55	{
	56	//
	57	// Destructor
	58	//
	59	}
	60
	61	//_________________________________________________________________________________________________
	62	void AliMixInfo::CreateHistogram(AliMixInfo::EInfoHistorgramType type, Int_t nbins, Int_t min, Int_t max)
	63	{
	64	//
65	// Create mix info histograms
66	//
67	if (!fHistogramList) {
68	fHistogramList = new TList;
69	fHistogramList->SetOwner(kTRUE);
70	}
71	TH1I hist = (TH1I ) fHistogramList->FindObject(GetNameHistogramByType(type));
72	if (hist) return;
73	hist = new TH1I(GetNameHistogramByType(type), GetTitleHistogramByType(type), nbins, min, max);
74	fHistogramList->Add(hist);
75	}
76
77	//_________________________________________________________________________________________________
78	void AliMixInfo::FillHistogram(AliMixInfo::EInfoHistorgramType type, Int_t value)
79	{
80	//
81	// Create mix info histograms
82	//
83	if (type == kMixedEvents && value < 0) return;
84	if (!fHistogramList) {
85	AliError("fHistogramList is null");
86	return;
87	}
88	TH1I hist = (TH1I ) fHistogramList->FindObject(GetNameHistogramByType(type));
89	if (hist) {
90	hist->Fill(value);
91	AliDebug(AliLog::kDebug, Form("%s was filled with %d sum is %.0f", GetNameHistogramByType(type), value, hist->GetBinContent(value)));
92	} else {
93	AliError(Form("Problem filling histogram %s", GetNameHistogramByType(type)));
94	}
95	}
96
97	//_________________________________________________________________________________________________
98	const char *AliMixInfo::GetNameHistogramByType(Int_t index) const
99	{
100	//
101	// Retruns name of cut
102	//
103	switch (index) {
104	case kMainEvents:
105	return "hMainEvents";
106	case kMixedEvents:
107	return "hMixedEvents";
108	}
109	return "";
110	}
111
112	//_________________________________________________________________________________________________
113	const char *AliMixInfo::GetTitleHistogramByType(Int_t index) const
114	{
115	//
116	// Retruns name of cut
117	//
118	switch (index) {
119	case kMainEvents:
120	return "Main Events";
121	case kMixedEvents:
122	return "Mixed Events";
123	}
124	return "";
125	}
126
127	//_________________________________________________________________________________________________
128	void AliMixInfo::Print(Option_t *option) const
129	{
130	//
131	// Print Mix info
132	//
133	if (!fHistogramList) return;
134	if (option)
135	AliInfo(Form("Name %s with option is %s", GetName(), option));
136	TIter next(fHistogramList);
137	TH1I *h = 0;
138	for (Int_t i = 0; i < fHistogramList->GetEntries(); i++) {
139	h = dynamic_cast<TH1I *>(fHistogramList->At(i));
140	if (h) {
141	h->Print();
142	continue;
143	}
144	}
145	}
146	//_________________________________________________________________________________________________
147	void AliMixInfo::Draw(Option_t* option)
148	{
149	//
150	// Drwas mixi info canvas
151	//
152	if (!fHistogramList) return;
153
154	// creating main canvas
155	TCanvas *cMain = new TCanvas("cMain", "Mixing Info", 500, 500);
156	if (!cMain) return;
157	cMain->Divide(1, 2, 0.001, 0.001);
158	cMain->cd(1);
159	// TVirtualPad *upperPad = cMain->cd(1);
160	// upperPad->Divide(2,1);
161	// TVirtualPad *upperPad1 = gPad->cd(2);
162	// upperPad1->Divide(1,2);
163	// upperPad1->cd(1);
164	TPavesText*text = new TPavesText(0.05, 0.05, 0.95, 0.95, 1);
165	text->SetName("mixInfoText");
166	text->AddText("Help:");
167	text->AddText("Move over histogram to see mix info for different bins");
168	text->Draw();
169
170	// gets corresponding histograms
171	TH1I *hMain = GetHistogramByType(kMainEvents);
172	if (!hMain) {
173	AliError("hMain is null");
174	return;
175	}
176	TH1I *hMix = GetHistogramByType(kMixedEvents);
177	if (!hMix) {
178	AliError("hMix is null");
179	return;
180	}
181
182
183	TH2I *hMixInfo2D = 0;
184	// TH1I hOK=0,hBad=0;
185	AliMixEventPool evPool = (AliMixEventPool ) GetEventPool("mixEventPool");
186	if (evPool) {
187	Int_t mixNum = evPool->GetMixNumber();
188	// hOK = (TH1I *) hMain->Clone();
189	// hBad = (TH1I *) hMain->Clone();
190	if (!hMixInfo2D) hMixInfo2D = new TH2I("hMixInfo2D", "hMixInfo2D", hMain->GetXaxis()->GetNbins() + 1, hMain->GetXaxis()->GetXmin() - 1, hMain->GetXaxis()->GetXmax(), 1, 0, 1);
191	for (Int_t iBin = 0; iBin < hMain->GetNbinsX() + 1; iBin++) {
192	if (!iBin) {
193	hMixInfo2D->SetBinContent(iBin + 1, 1, 1);
194	} else if (!hMain->GetBinContent(iBin) && !hMix->GetBinContent(iBin)) {
195	hMixInfo2D->SetBinContent(iBin + 1, 1, 2);
196	} else if (hMix->GetBinContent(iBin) == mixNum * hMain->GetBinContent(iBin)) {
197	hMixInfo2D->SetBinContent(iBin + 1, 1, 4);
198	} else {
199	hMixInfo2D->SetBinContent(iBin + 1, 1, 3);
200	}
201	}
202	}
203
204	TStyle *style = gStyle;
205	Int_t cols[4] = { kYellow, kViolet, kRed, kGreen };
206	style->SetPalette(4, cols);
207	cMain->cd(2);
781b6757	208	// cMain->SetGrid();
a86b14f8	209	if (hMixInfo2D) {
	210	hMixInfo2D->SetMaximum(4);
	211	hMixInfo2D->SetStats(0);
	212	hMixInfo2D->SetTitle("");
	213	hMixInfo2D->GetXaxis()->SetNdivisions(510);
	214	hMixInfo2D->GetYaxis()->SetNdivisions(0);
781b6757	215	}
b425275c	216
781b6757	217	if (hMixInfo2D) hMixInfo2D->Draw(Form("COL %s", option));
b425275c	218	//
	219	// TLegend *legend = new TLegend(0.55,0.65,0.76,0.82);
	220	// legend->AddEntry(hOK,"OK","f");
	221	// legend->AddEntry(hBad,"NOT OK","f");
	222	// legend->Draw();
	223
	224	cMain->cd(2)->AddExec("dynamic", Form("AliMixInfo::DynamicExec((AliMixInfo*)0x%lx)", (ULong_t)this));
	225	}
	226
	227	//_________________________________________________________________________________________________
	228	void AliMixInfo::DynamicExec(AliMixInfo *const mixInfo)
	229	{
	230	//
	231	// Function which is run when user move mouse over mix info
	232	//
	233
a86b14f8	234	if (!mixInfo) return;
781b6757	235
b425275c	236	TObject *select = gPad->GetSelected();
	237	if (!select) return;
	238	if (!select->InheritsFrom(TH2I::Class())) {
	239	gPad->SetUniqueID(0);
	240	return;
	241	}
	242
	243	TH2I hSelected = (TH2I ) select;
	244	gPad->GetCanvas()->FeedbackMode(kTRUE);
	245
	246	//erase old position and draw a line at current position
	247	Int_t uid = gPad->GetUniqueID();
	248	// int pxold = gPad->GetUniqueID();
	249	Int_t px = gPad->GetEventX();
	250	// Int_t py = gPad->GetEventY();
	251	// float uxmin = gPad->GetUxmin();
	252	// float uxmax = gPad->GetUxmax();
	253	// float uymin = gPad->GetUymin();
	254	// float uymax = gPad->GetUymax();
	255	// Int_t pxmin = gPad->XtoAbsPixel ( uxmin );
	256	// Int_t pxmax = gPad->XtoAbsPixel ( uxmax );
	257	// Int_t pymin = gPad->YtoAbsPixel ( uymin );
	258	// Int_t pymax = gPad->YtoAbsPixel ( uymax );
	259	// // if(pxold) gVirtualX->DrawLine(pxold,pymin,pxold,pymax);
	260	// // else gVirtualX->DrawLine(px,pymin,px,pymax);
	261	// gPad->SetUniqueID ( px );
	262
	263	Float_t upx = gPad->AbsPixeltoX(px);
	264	// Float_t upy = gPad->AbsPixeltoY(py);
	265
	266	Float_t x = gPad->PadtoX(upx);
	267	// Float_t y = gPad->PadtoY ( upy );
	268
	269	Int_t binX = hSelected->GetXaxis()->FindBin(x) - 1;
	270	// Int_t binY = hSelected->GetYaxis()->FindBin(y)-1;
	271
	272
	273
	274	// return in case of same bin
	275	if (uid == binX) return;
	276	// Printf("%d %d",uid,binX);
	277
	278	//create or set the new canvas cInfo
	279	TPaveText *text = 0;
	280	TVirtualPad *padsav = gPad;
	281	TCanvas cInfo = (TCanvas ) gROOT->GetListOfCanvases()->FindObject("cMain");
	282	if (cInfo) {
	283	text = (TPaveText *)cInfo->GetPrimitive("mixInfoText");
	284	if (!text) {
	285	text = new TPavesText(0.05, 0.05, 0.95, 0.95, 1);
	286	} else {
	287	text->DeleteText();
	288	}
	289
	290	} else cInfo = new TCanvas("cInfo", "MixInfo Canvas", 510, 0, 350, 150);
	291
	292	TVirtualPad *upperPad = cInfo->cd(1);
	293	// TVirtualPad *upperPadL = upperPad->cd(1);
	294	// TVirtualPad *upperPadR = upperPad->cd(2);
	295	// TVirtualPad *upperPadR1 = upperPadR->cd(1);
	296	// TVirtualPad *upperPadR2 = upperPadR->cd(2);
	297	// TH1I *hMain = 0;
	298	// TH1I *hMix = 0;
	299
300
301	// mixInfo->Print();
302	// return;
303
304	// gets corresponding histograms
305	TH1I *hMain = mixInfo->GetHistogramByType(kMainEvents);
306	if (!hMain) {
307	Printf("hMain is null");
308	return;
309	}
310	TH1I *hMix = mixInfo->GetHistogramByType(kMixedEvents);
311	if (!hMix) {
312	Printf("hMix is null");
313	return;
314	}
315
316	Double_t numMain = hMain->GetBinContent(binX);
317	Double_t numMix = hMix->GetBinContent(binX);
318	Int_t hist2DValue = (Int_t) hSelected->GetBinContent(binX + 1, 1);
319
320	Int_t mixNum = 1;
321	if (text) {
322	text->SetName("mixInfoText");
323	text->SetTextAlign(12);
324	text->SetToolTipText("Mixing Info about current binX");
325	// text->SetTextSize(0.1);
326	// text->SetTextColor(3);
327	text->SetBorderSize(2);
328	text->AddText(Form("binX=%d", binX));
329	text->AddText(Form("numMain=%.0f", numMain));
330	text->AddText(Form("numMix=%.0f", numMix));
331	text->AddText(Form("BINCONTENT=%d", hist2DValue));
332
333	if (mixInfo) {
334
335	AliMixEventPool evPool = (AliMixEventPool ) mixInfo->GetEventPool("mixEventPool");
336	if (evPool) {
337	mixNum = evPool->GetMixNumber();
338	if (binX - 1 > 0)
339	evPool->SetCutValuesFromBinIndex(binX - 1);
340	TObjArray *eventCuts = evPool->GetListOfEventCuts();
341	if (eventCuts) {
342
343	TObjArrayIter next(eventCuts);
344	AliMixEventCutObj *cut;
345	while ((cut = (AliMixEventCutObj *) next())) {
346	if (hist2DValue > 1) text->AddText(Form("%s <%.2f,%.2f)", cut->GetCutName(), cut->GetMin(), cut->GetMax()));
347	else text->AddText(Form("%s <Out of Range>", cut->GetCutName()));
348	}
349	}
350
351	}
352
353	}
354	switch (hist2DValue) {
355	case 1 :
356	text->SetFillColor(kYellow);
357	break;
358	case 2 :
359	text->SetFillColor(kViolet);
360	break;
361	case 3 :
362	text->SetFillColor(kRed);
363	break;
364	case 4 :
365	text->SetFillColor(kGreen);
366	break;
367	default:
368	text->SetFillColor(kWhite);
369	break;
370	}
371	upperPad->cd();
372	text->Draw();
373	// upperPadR1->cd();
374	// TH1D *proj1 = hSelected->ProjectionY("_xxx",binX);
375	// proj1->Draw();
376	// upperPadR2->cd();
377	// TH1D *proj2 = hSelected->ProjectionY("_xxx",binX);
378	// proj1->Draw();
379
380	}
381	cInfo->Update();
382	padsav->cd();
383
384	gPad->SetUniqueID(binX);
385	}
386
387	//_________________________________________________________________________________________________
388	Long64_t AliMixInfo::Merge(TCollection *list)
389	{
390	//
391	// Merge function
392	//
393	if (!list) return 0;
394	TIter nxfc(list);
395	AliMixInfo *mi = 0;
396	Long64_t counter = 0;
397	while ((mi = (AliMixInfo *) nxfc())) {
398	// Do not merge with ourself
399	if (mi == this) continue;
400	// Make sure that it is a AliMixInfo
401	if (!mi->InheritsFrom(AliMixInfo::Class())) {
402	Error("Merge", "attempt to add object of class: %s to a %s", mi->ClassName(), ClassName());
403	return -1;
404	}
405	// Merge now
406	Add(mi);
407	counter++;
408	}
409	// Done
410	return counter;
411	}
412
413	TH1I *AliMixInfo::GetHistogramByType(Int_t index) const
414	{
415	//
416	// GetHistogramByType
417	//
418	return (TH1I *) fHistogramList->FindObject(GetNameHistogramByType(index));
419	}
420
421	//_________________________________________________________________________________________________
422	void AliMixInfo::Add(AliMixInfo *mi)
423	{
424	//
425	// adds AliMixInfo
426	//
427
428	AliInfo(Form("Adding %p", mi));
429	if (!mi) return;
430	if (!fHistogramList) return;
431	TH1I *hMain = GetHistogramByType(kMainEvents);
432	if (!hMain) {
433	AliError("hMain is null");
434	return;
435	}
436	TH1I *hMix = GetHistogramByType(kMixedEvents);
437	if (!hMix) {
438	AliError("hMain is null");
439	return;
440	}
441	hMain->Add(mi->GetHistogramByType(kMainEvents));
442	hMix->Add(mi->GetHistogramByType(kMixedEvents));
443	}
444
445	//_________________________________________________________________________________________________
446	void AliMixInfo::SetEventPool(AliMixEventPool *evPool)
447	{
448	//
449	// Sets event pool
450	//
451	if (!evPool) return;
452
453	if (!fHistogramList) return;
454
455	fHistogramList->Add(evPool);
456	}
457
458	//_________________________________________________________________________________________________
459	AliMixEventPool AliMixInfo::GetEventPool(const char name)
460	{
461	//
462	// Gets event pool
463	//
464	if (!fHistogramList) return 0;
465
466	return (AliMixEventPool *) fHistogramList->FindObject(name);
467	}
468