[u/mrichter/AliRoot.git] / MUON / AliMUONPainterMatrix.cxx

/**************************************************************************
* Copyright(c) 1998-1999, 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.                  *
**************************************************************************/

// $Id$

#include "AliMUONPainterMatrix.h"

#include "AliLog.h"
#include "AliMUONPainterGroup.h"
#include "AliMUONPainterHelper.h"
#include "AliMUONVPainter.h"
#include "AliMUONVTrackerData.h"
#include "TCanvas.h"
#include "TGClient.h"
#include "TPaveLabel.h"
#include <Riostream.h>
#include <TBox.h>
#include <TMath.h>
#include <TObjArray.h>
#include <TObjString.h>
#include <TROOT.h>
#include <TVirtualPad.h>
#include <float.h>

///\class AliMUONPainterMatrix
///
/// Matrix of AliMUONVPainter
///
///\author Laurent Aphecetche, Subatech

using std::cout;
using std::endl;
///\cond CLASSIMP 
ClassImp(AliMUONPainterMatrix)
///\endcond

//_____________________________________________________________________________
AliMUONPainterMatrix::AliMUONPainterMatrix(const char* name, Int_t nx, Int_t ny)
: TObject(),
  fBasename(name),
  fWhatname(""),
  fNx(nx),
  fNy(ny),
  fPainters(new TObjArray(fNx*fNy)),
  fAttributes()
{
  /// ctor
  
  fPainters->SetOwner(kTRUE);
  if ( fNx*fNy > 1 ) 
  {
    fAttributes.SetSingle(kFALSE);
  }
}

//_____________________________________________________________________________
AliMUONPainterMatrix::~AliMUONPainterMatrix()
{
  /// dtor
  delete fPainters;
}

//_____________________________________________________________________________
void 
AliMUONPainterMatrix::Adopt(AliMUONVPainter* painter)
{
  /// Adopt a given painter
  fPainters->AddLast(painter);
  UpdateAttributes();
}

//_____________________________________________________________________________
void
AliMUONPainterMatrix::UpdateAttributes()
{
  /// Update our attributes (using our painters' attributes)
  
  Bool_t cathode0(kFALSE);
  Bool_t cathode1(kFALSE);
  Bool_t bending(kFALSE);
  Bool_t nonbending(kFALSE);
  Bool_t front(kFALSE);
  Bool_t back(kFALSE);
  Bool_t cathplaneexclusive(kFALSE);
  Bool_t cathplanedisabled(kFALSE);
  
  for ( Int_t i = 0; i < Size(); ++i )
  {
    AliMUONAttPainter att = Painter(i)->Attributes();
    
    if ( att.IsCathodeDefined() ) 
    {
      if ( att.IsCathode0() ) cathode0 = kTRUE;
      if ( att.IsCathode1() ) cathode1 = kTRUE;
    }

    if ( att.IsPlaneDefined() ) 
    {
      if ( att.IsBendingPlane() ) bending = kTRUE;
      if ( att.IsNonBendingPlane() ) nonbending = kTRUE;
    }
    
    if ( att.IsFrontView() ) front = kTRUE;
    if ( att.IsBackView() ) back = kTRUE;
    
    if ( att.IsCathodeAndPlaneMutuallyExclusive() ) cathplaneexclusive = kTRUE;
    
    if ( att.IsCathodeAndPlaneDisabled() ) cathplanedisabled = kTRUE;
  }
  
  fAttributes.SetCathode(cathode0,cathode1);
  fAttributes.SetPlane(bending,nonbending);
  fAttributes.SetViewPoint(front,back);
  fAttributes.SetCathodeAndPlaneMutuallyExclusive(cathplaneexclusive);
  fAttributes.SetCathodeAndPlaneDisabled(cathplanedisabled);
}

//_____________________________________________________________________________
const char*
AliMUONPainterMatrix::Name() const
{
  /// Build our name
  
  return NameIt(fWhatname.Data(),fBasename.Data(),fAttributes).Data();
}

//_____________________________________________________________________________
TString
AliMUONPainterMatrix::NameIt(const char* whatname, const char* basename, const AliMUONAttPainter& att)
{
  /// Build a name 
  if ( strlen(whatname) > 0 ) 
  {
    return Form("%s-%s-%s",whatname,basename,att.Name().Data());
  }
  else
  {
    return Form("noda-%s-%s",basename,att.Name().Data());
  }
}

//_____________________________________________________________________________
void 
AliMUONPainterMatrix::ComputeDataRange()
{
  /// Compute the data range spanned by the painters in this matrix
  
  Double_t dataMin(FLT_MAX);
  Double_t dataMax(-FLT_MAX);
  Bool_t atLeastOnePlotter(kFALSE);
  
  for ( Int_t i = 0; i < Size(); ++i ) 
  {
    AliMUONVPainter* p = Painter(i);
    AliMUONPainterGroup* g = p->PlotterGroup();

    Double_t min(FLT_MAX);
    Double_t max(-FLT_MAX);

    if ( g ) 
    {
      atLeastOnePlotter = kTRUE;
      g->ComputeDataRange(min,max);
      if ( min <= max ) 
      {
        dataMin = TMath::Min(min,dataMin);
        dataMax = TMath::Max(max,dataMax);
      }
    }

    AliDebug(1,Form("painter %s group %s min %e max %e dataMin,Max=%7.3f,%7.3f",
                    p->GetName(),
                    g ? g->Type() : "none",
                    min,max,
                    dataMin,dataMax));
  }

  if ( dataMin > dataMax && atLeastOnePlotter ) 
  {
    AliError(Form("data min %e > max %e : setting both to 0.0",
                    dataMin,dataMax));
    dataMin = dataMax = 0.0;
  }
  
  AliDebug(1,Form("Final dataMin,Max=%7.3f,%7.3f",dataMin,dataMax));
  
  SetDataRange(dataMin,dataMax);
}

//_____________________________________________________________________________
void 
AliMUONPainterMatrix::Connect(const char* sourceMethod, const char* destClassName, 
                              void* destObject, const char* destMethod)
{
  /// Connect our painters
  
  for ( Int_t i = 0; i < Size(); ++i )
  {
    Painter(i)->Connect(sourceMethod,destClassName,destObject,destMethod);
  }
}

//_____________________________________________________________________________
TCanvas*
AliMUONPainterMatrix::CreateCanvas(Int_t x, Int_t y, Int_t w, Int_t h)
{
  /// Generate a canvas to show the painter matrix.
  ///
  /// Layout is the following :
  ///
  /// ----------------------------------------------------
  /// |    title describing what is plotted              |
  /// ----------------------------------------------------
  /// |                                        |         |
  /// |                                        |         |
  /// |                                        |         |
  /// |                                        |         |
  /// |                                        |         |
  /// |             painter themselves         | color   |
  /// |                                        | range   |
  /// |                                        |         |
  /// |                                        |         |
  /// ----------------------------------------------------
  ///
  
  Int_t mw = ( w <= 0 ? TMath::Nint(gClient->GetDisplayWidth()*0.9) : w );
  Int_t mh = ( h <= 0 ? TMath::Nint(gClient->GetDisplayHeight()*0.9) : h );
  
  TString name(Name());
  
  TCanvas* d = new TCanvas(name.Data(),name.Data(),x,y,mw,mh);

  TVirtualPad* pTitle = new TPad(Form("%s-title",name.Data()),Form("%s-title",name.Data()),0,0.9,1.0,0.99);
  
  pTitle->Draw();
  
  pTitle->cd();
  
  TPaveLabel* text = new TPaveLabel(0,0,1,1,"");
  text->SetFillStyle(0);
  text->SetFillColor(0);
  text->SetTextColor(4);
  text->SetBorderSize(0);
  
  text->SetLabel(name.Data());
  
  text->Draw();
  
  d->cd();
  
  TVirtualPad* pMatrix = new TPad(Form("%s-matrix",name.Data()),Form("%s-matrix",name.Data()),0,0,0.9,0.89);
  
  pMatrix->Draw();
  pMatrix->cd();
  
  Draw();
  
  d->cd();
  
  TVirtualPad* pColor = new TPad(Form("%s-color",name.Data()),Form("%s-color",name.Data()),0.91,0.01,0.99,0.89);
    
  pColor->Range(0,0,1,1);

  pColor->Draw();
  
  pColor->cd();
  
  Int_t ndivisions(20);
  
  Double_t rangeXmin(0.1);
  Double_t rangeXmax(0.9);
  
  Double_t ymin, ymax;
  
  GetDataRange(ymin,ymax);
    
  Double_t min(0.0);
  Double_t max(1.0);
  
  Double_t step = (max-min)/ndivisions;

  Double_t hsize = 1.0/(ndivisions+2);

  Double_t ypos = 1.0;
  
  for ( Int_t i = -1; i < ndivisions+1; ++i ) 
  {
    Double_t value = max - (min + step*i);
    
    Int_t color = AliMUONPainterHelper::Instance()->ColorFromValue(value,min,max);
    
    Bool_t limit(kFALSE);
    
    TString label;
    TString sign;
    
    Double_t yvalue(0.0);
    
    if ( i == -1 )
    {
      yvalue = ymax;
      limit = kTRUE;
      sign = ">";
    }
    else if ( i == ndivisions )
    {
      yvalue = ymin;
      limit = kTRUE;
      sign = "<=";
    }
    
    if (limit)
    {
      if ( TMath::Abs(yvalue) < 1E5 ) 
      {
        label = Form("%s %7.2f",sign.Data(),yvalue);    
      }
      else
      {
        label = Form("%s %e",sign.Data(),yvalue);
      }
    }

    TPaveLabel* box = new TPaveLabel(rangeXmin,TMath::Max(0.001,ypos-hsize),rangeXmax,ypos,label.Data(),"");    
    
    ypos -= hsize;
    
    box->SetFillColor(color);
    box->SetTextColor( i == -1 ? 0 : 1 );
    box->SetBorderSize(1);
    box->SetLineColor(1);
    box->Draw();
  }  
  
  d->SetEditable(kFALSE);
  
  return d;
}

//_____________________________________________________________________________
void
AliMUONPainterMatrix::GetDataRange(Double_t& dataMin, Double_t& dataMax) const
{
  /// Get the data range spanned by the painters in this matrix
  
  dataMin=FLT_MAX;
  dataMax=-FLT_MAX;
  
  for ( Int_t i = 0; i < Size(); ++i ) 
  {
    AliMUONVPainter* p = Painter(i);
    if ( p )
    {
      AliMUONPainterGroup* g = p->PlotterGroup();
      if ( g ) 
      {
        dataMin = TMath::Min(dataMin,g->DataMin());
        dataMax = TMath::Max(dataMax,g->DataMax());
      }
    }
  }
}

//_____________________________________________________________________________
void 
AliMUONPainterMatrix::GetTypes(TObjArray& types) const
{
  /// Get the types of the painters in this matrix
  
  types.SetOwner(kTRUE);
  types.Clear();
  
  for ( Int_t i = 0; i < Size(); ++i ) 
  {
    AliMUONVPainter* p = Painter(i);
    TObjArray ptypes;
    p->GetTypes(ptypes);
    TIter next(&ptypes);
    TObject* o;
    while ( ( o = next() ) )
    {
      if ( ! types.FindObject(o) )
      {
        types.AddLast(o->Clone());
      }
    }
  }  
}


//_____________________________________________________________________________
void
AliMUONPainterMatrix::Draw(Option_t*)
{
  /// Append our painters to the current pad

  if (!gPad) 
  {
    gROOT->MakeDefCanvas();
  }
  
  TVirtualPad* pad = gPad;

  gPad->Divide(Nx(),Ny());
  
  for ( Int_t i = 0; i < Size(); ++i ) 
  {
    AliMUONVPainter* painter = Painter(i);
    pad->cd(i+1);
    painter->Draw("R");
  }  
  
  AppendPad("");
}

//_____________________________________________________________________________
AliMUONVPainter* 
AliMUONPainterMatrix::Painter(Int_t index) const
{
  /// Get a given painter
  
  if ( index <= fPainters->GetLast() ) 
  {
    return static_cast<AliMUONVPainter*>(fPainters->At(index));
  }
  return 0x0;
}

//_____________________________________________________________________________
AliMUONVTrackerData* 
AliMUONPainterMatrix::Data() const
{
  /// Return our data
  AliMUONPainterGroup* group = Painter(0)->PlotterGroup();
  return ( group ? group->Data() : 0x0 );
}

//_____________________________________________________________________________
TString 
AliMUONPainterMatrix::DataPattern() const
{
  /// Return our data pattern
  AliMUONPainterGroup* group = Painter(0)->PlotterGroup();
  return ( group ? group->Type() : "" );
}

//_____________________________________________________________________________
Int_t 
AliMUONPainterMatrix::DataIndex() const
{
  /// Return our data index
  AliMUONPainterGroup* group = Painter(0)->PlotterGroup();
  return ( group ? group->DataIndex() : -1 );
}

//_____________________________________________________________________________
void
AliMUONPainterMatrix::SetData(const char* pattern, AliMUONVTrackerData* d,
                              Int_t indexInData)
{
  /// Set the data to be plotted
  
  for ( Int_t i = 0; i < Size(); ++i )
  {
    AliMUONVPainter* painter = Painter(i);
    painter->SetData(pattern,d,indexInData);
  }
  
  if ( d ) 
  {
    fWhatname = Form("%s-%s",d->GetName(),d->DimensionName(indexInData).Data());
  }
  else
  {
    fWhatname = "";
  }
}

//_____________________________________________________________________________
void
AliMUONPainterMatrix::SetDataRange(Double_t dataMin, Double_t dataMax)
{
  /// Set the data range
  
  for ( Int_t i = 0; i < Size(); ++i ) 
  {
    AliMUONVPainter* p = Painter(i);
    AliMUONPainterGroup* g = p->PlotterGroup();
    if ( g ) 
    {
      g->SetDataRange(dataMin,dataMax);
    }
  }       
}

//_____________________________________________________________________________
Int_t 
AliMUONPainterMatrix::Size() const
{
  /// Return the number of painters we actually handle
  return fPainters->GetLast()+1;
}

//_____________________________________________________________________________
void
AliMUONPainterMatrix::Print(Option_t*) const
{
  /// Printout
  cout << "Whatname=" << fWhatname.Data() << "Basename=" << fBasename.Data() 
  << " Nx=" << fNx << " Ny=" << fNy << " Att=" << fAttributes.GetName() << endl;
}

//_____________________________________________________________________________
//void 
//AliMUONPainterMatrix::ChangeAttributes(const AliMUONAttPainter& attributes)
//{
//  /// Change painters' attributes
//  
//  AliWarning("Implement me !");
//  
//  //  for ( Int_t i = 0; i < Size(); ++i ) 
//  //  {
//  //    Painter(i)->SetAttributes(attributes);
//  //  }
//}

//_____________________________________________________________________________
AliMUONPainterMatrix*
AliMUONPainterMatrix::Clone(const AliMUONAttPainter& attributes) const
{
  /// Clone with given attributes
  
  AliMUONPainterMatrix* clone = new AliMUONPainterMatrix(Basename(),Nx(),Ny());

  for ( Int_t i = 0; i < Size(); ++i ) 
  {
    AliMUONVPainter* oldPainter = Painter(i);
    
    AliMUONVPainter* newPainter(0x0);
    
    newPainter = AliMUONVPainter::CreatePainter(oldPainter->ClassName(),
                                                attributes,
                                                oldPainter->ID0(),
                                                oldPainter->ID1());
    
    if (newPainter)
    {
      newPainter->UpdateGroupsFrom(*(oldPainter->Master()));
      clone->Adopt(newPainter);
    }
    else
    {
      AliError(Form("Failed to create painter of class %s ID0 %d ID1 %d",
                    oldPainter->ClassName(),
                    oldPainter->ID0(),
                    oldPainter->ID1()));
    }
  }
  
  return clone;
}

//_____________________________________________________________________________
void
AliMUONPainterMatrix::SetOutlined(const char* pattern, Bool_t value)
{
  /// Calls SetOutlined for all our painters

  for ( Int_t i = 0; i < Size(); ++i ) 
  {
    Painter(i)->SetOutlined(pattern,value);
  }
}

//_____________________________________________________________________________
void
AliMUONPainterMatrix::SetResponder(const char* pattern)
{
  /// Calls SetResponder for all our painters
  for ( Int_t i = 0; i < Size(); ++i ) 
  {
    Painter(i)->SetResponder(pattern);
  }
}

//_____________________________________________________________________________
AliMUONAttPainter
AliMUONPainterMatrix::Validate(const AliMUONAttPainter& att) const
{
  /// Normalize attributes

  AliMUONAttPainter a;
  
  for ( Int_t i = 0; i < Size() && a.IsValid(); ++i ) 
  {
    a = Painter(i)->Validate(att);
  }
  return a;
}
Commit	Line	Data
0145e89a	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, 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	// $Id$
	17
	18	#include "AliMUONPainterMatrix.h"
	19
fcabdc0c	20	#include "AliLog.h"
0145e89a	21	#include "AliMUONPainterGroup.h"
fcabdc0c	22	#include "AliMUONPainterHelper.h"
0145e89a	23	#include "AliMUONVPainter.h"
fcabdc0c	24	#include "AliMUONVTrackerData.h"
	25	#include "TCanvas.h"
	26	#include "TGClient.h"
	27	#include "TPaveLabel.h"
0145e89a	28	#include <Riostream.h>
fcabdc0c	29	#include <TBox.h>
fcabdc0c	30	#include <TMath.h>
0145e89a	31	#include <TObjArray.h>
0145e89a	32	#include <TObjString.h>
fcabdc0c	33	#include <TROOT.h>
	34	#include <TVirtualPad.h>
	35	#include <float.h>
0145e89a	36
	37	///\class AliMUONPainterMatrix
	38	///
	39	/// Matrix of AliMUONVPainter
	40	///
	41	///\author Laurent Aphecetche, Subatech
	42
b80faac0	43	using std::cout;
b80faac0	44	using std::endl;
fcabdc0c	45	///\cond CLASSIMP
0145e89a	46	ClassImp(AliMUONPainterMatrix)
	47	///\endcond
	48
	49	//_____________________________________________________________________________
	50	AliMUONPainterMatrix::AliMUONPainterMatrix(const char* name, Int_t nx, Int_t ny)
	51	: TObject(),
	52	fBasename(name),
fcabdc0c	53	fWhatname(""),
0145e89a	54	fNx(nx),
	55	fNy(ny),
	56	fPainters(new TObjArray(fNx*fNy)),
	57	fAttributes()
	58	{
fcabdc0c	59	/// ctor
	60
	61	fPainters->SetOwner(kTRUE);
	62	if ( fNx*fNy > 1 )
	63	{
	64	fAttributes.SetSingle(kFALSE);
	65	}
0145e89a	66	}
	67
	68	//_____________________________________________________________________________
	69	AliMUONPainterMatrix::~AliMUONPainterMatrix()
	70	{
	71	/// dtor
	72	delete fPainters;
	73	}
	74
	75	//_____________________________________________________________________________
	76	void
	77	AliMUONPainterMatrix::Adopt(AliMUONVPainter* painter)
	78	{
	79	/// Adopt a given painter
	80	fPainters->AddLast(painter);
	81	UpdateAttributes();
	82	}
	83
	84	//_____________________________________________________________________________
	85	void
	86	AliMUONPainterMatrix::UpdateAttributes()
	87	{
	88	/// Update our attributes (using our painters' attributes)
	89
	90	Bool_t cathode0(kFALSE);
	91	Bool_t cathode1(kFALSE);
	92	Bool_t bending(kFALSE);
	93	Bool_t nonbending(kFALSE);
	94	Bool_t front(kFALSE);
	95	Bool_t back(kFALSE);
	96	Bool_t cathplaneexclusive(kFALSE);
	97	Bool_t cathplanedisabled(kFALSE);
	98
	99	for ( Int_t i = 0; i < Size(); ++i )
	100	{
	101	AliMUONAttPainter att = Painter(i)->Attributes();
	102
	103	if ( att.IsCathodeDefined() )
	104	{
	105	if ( att.IsCathode0() ) cathode0 = kTRUE;
	106	if ( att.IsCathode1() ) cathode1 = kTRUE;
	107	}
	108
	109	if ( att.IsPlaneDefined() )
	110	{
	111	if ( att.IsBendingPlane() ) bending = kTRUE;
	112	if ( att.IsNonBendingPlane() ) nonbending = kTRUE;
	113	}
	114
	115	if ( att.IsFrontView() ) front = kTRUE;
	116	if ( att.IsBackView() ) back = kTRUE;
	117
	118	if ( att.IsCathodeAndPlaneMutuallyExclusive() ) cathplaneexclusive = kTRUE;
	119
	120	if ( att.IsCathodeAndPlaneDisabled() ) cathplanedisabled = kTRUE;
	121	}
	122
	123	fAttributes.SetCathode(cathode0,cathode1);
	124	fAttributes.SetPlane(bending,nonbending);
	125	fAttributes.SetViewPoint(front,back);
	126	fAttributes.SetCathodeAndPlaneMutuallyExclusive(cathplaneexclusive);
	127	fAttributes.SetCathodeAndPlaneDisabled(cathplanedisabled);
fcabdc0c	128	}
	129
	130	//_____________________________________________________________________________
	131	const char*
	132	AliMUONPainterMatrix::Name() const
	133	{
	134	/// Build our name
0145e89a	135
fcabdc0c	136	return NameIt(fWhatname.Data(),fBasename.Data(),fAttributes).Data();
0145e89a	137	}
	138
	139	//_____________________________________________________________________________
	140	TString
fcabdc0c	141	AliMUONPainterMatrix::NameIt(const char* whatname, const char* basename, const AliMUONAttPainter& att)
0145e89a	142	{
0145e89a	143	/// Build a name
fcabdc0c	144	if ( strlen(whatname) > 0 )
	145	{
	146	return Form("%s-%s-%s",whatname,basename,att.Name().Data());
	147	}
	148	else
	149	{
	150	return Form("noda-%s-%s",basename,att.Name().Data());
	151	}
0145e89a	152	}
	153
	154	//_____________________________________________________________________________
	155	void
	156	AliMUONPainterMatrix::ComputeDataRange()
	157	{
	158	/// Compute the data range spanned by the painters in this matrix
	159
	160	Double_t dataMin(FLT_MAX);
	161	Double_t dataMax(-FLT_MAX);
	162	Bool_t atLeastOnePlotter(kFALSE);
	163
	164	for ( Int_t i = 0; i < Size(); ++i )
	165	{
	166	AliMUONVPainter* p = Painter(i);
	167	AliMUONPainterGroup* g = p->PlotterGroup();
	168
	169	Double_t min(FLT_MAX);
	170	Double_t max(-FLT_MAX);
	171
	172	if ( g )
	173	{
	174	atLeastOnePlotter = kTRUE;
	175	g->ComputeDataRange(min,max);
	176	if ( min <= max )
	177	{
	178	dataMin = TMath::Min(min,dataMin);
	179	dataMax = TMath::Max(max,dataMax);
	180	}
	181	}
	182
	183	AliDebug(1,Form("painter %s group %s min %e max %e dataMin,Max=%7.3f,%7.3f",
	184	p->GetName(),
	185	g ? g->Type() : "none",
	186	min,max,
	187	dataMin,dataMax));
	188	}
	189
	190	if ( dataMin > dataMax && atLeastOnePlotter )
	191	{
	192	AliError(Form("data min %e > max %e : setting both to 0.0",
	193	dataMin,dataMax));
	194	dataMin = dataMax = 0.0;
	195	}
	196
	197	AliDebug(1,Form("Final dataMin,Max=%7.3f,%7.3f",dataMin,dataMax));
	198
	199	SetDataRange(dataMin,dataMax);
	200	}
	201
	202	//_____________________________________________________________________________
	203	void
	204	AliMUONPainterMatrix::Connect(const char* sourceMethod, const char* destClassName,
	205	void* destObject, const char* destMethod)
	206	{
	207	/// Connect our painters
	208
	209	for ( Int_t i = 0; i < Size(); ++i )
	210	{
	211	Painter(i)->Connect(sourceMethod,destClassName,destObject,destMethod);
	212	}
	213	}
	214
fcabdc0c	215	//_____________________________________________________________________________
	216	TCanvas*
	217	AliMUONPainterMatrix::CreateCanvas(Int_t x, Int_t y, Int_t w, Int_t h)
	218	{
	219	/// Generate a canvas to show the painter matrix.
	220	///
	221	/// Layout is the following :
	222	///
	223	/// ----------------------------------------------------
	224	/// \| title describing what is plotted \|
	225	/// ----------------------------------------------------
	226	/// \| \| \|
	227	/// \| \| \|
	228	/// \| \| \|
	229	/// \| \| \|
	230	/// \| \| \|
	231	/// \| painter themselves \| color \|
	232	/// \| \| range \|
	233	/// \| \| \|
	234	/// \| \| \|
	235	/// ----------------------------------------------------
	236	///
	237
	238	Int_t mw = ( w <= 0 ? TMath::Nint(gClient->GetDisplayWidth()*0.9) : w );
	239	Int_t mh = ( h <= 0 ? TMath::Nint(gClient->GetDisplayHeight()*0.9) : h );
	240
	241	TString name(Name());
	242
	243	TCanvas* d = new TCanvas(name.Data(),name.Data(),x,y,mw,mh);
	244
	245	TVirtualPad* pTitle = new TPad(Form("%s-title",name.Data()),Form("%s-title",name.Data()),0,0.9,1.0,0.99);
	246
	247	pTitle->Draw();
	248
	249	pTitle->cd();
	250
	251	TPaveLabel* text = new TPaveLabel(0,0,1,1,"");
	252	text->SetFillStyle(0);
	253	text->SetFillColor(0);
	254	text->SetTextColor(4);
	255	text->SetBorderSize(0);
	256
	257	text->SetLabel(name.Data());
	258
	259	text->Draw();
	260
	261	d->cd();
	262
	263	TVirtualPad* pMatrix = new TPad(Form("%s-matrix",name.Data()),Form("%s-matrix",name.Data()),0,0,0.9,0.89);
	264
	265	pMatrix->Draw();
	266	pMatrix->cd();
	267
	268	Draw();
	269
	270	d->cd();
	271
	272	TVirtualPad* pColor = new TPad(Form("%s-color",name.Data()),Form("%s-color",name.Data()),0.91,0.01,0.99,0.89);
	273
	274	pColor->Range(0,0,1,1);
	275
	276	pColor->Draw();
	277
	278	pColor->cd();
279
280	Int_t ndivisions(20);
281
282	Double_t rangeXmin(0.1);
283	Double_t rangeXmax(0.9);
284
285	Double_t ymin, ymax;
286
287	GetDataRange(ymin,ymax);
288
289	Double_t min(0.0);
290	Double_t max(1.0);
291
292	Double_t step = (max-min)/ndivisions;
293
294	Double_t hsize = 1.0/(ndivisions+2);
295
296	Double_t ypos = 1.0;
297
298	for ( Int_t i = -1; i < ndivisions+1; ++i )
299	{
300	Double_t value = max - (min + step*i);
301
302	Int_t color = AliMUONPainterHelper::Instance()->ColorFromValue(value,min,max);
303
304	Bool_t limit(kFALSE);
305
306	TString label;
307	TString sign;
308
309	Double_t yvalue(0.0);
310
311	if ( i == -1 )
312	{
313	yvalue = ymax;
314	limit = kTRUE;
315	sign = ">";
316	}
317	else if ( i == ndivisions )
318	{
319	yvalue = ymin;
320	limit = kTRUE;
321	sign = "<=";
322	}
323
324	if (limit)
325	{
326	if ( TMath::Abs(yvalue) < 1E5 )
327	{
328	label = Form("%s %7.2f",sign.Data(),yvalue);
329	}
330	else
331	{
332	label = Form("%s %e",sign.Data(),yvalue);
333	}
334	}
335
336	TPaveLabel* box = new TPaveLabel(rangeXmin,TMath::Max(0.001,ypos-hsize),rangeXmax,ypos,label.Data(),"");
337
338	ypos -= hsize;
339
340	box->SetFillColor(color);
341	box->SetTextColor( i == -1 ? 0 : 1 );
342	box->SetBorderSize(1);
343	box->SetLineColor(1);
344	box->Draw();
345	}
346
347	d->SetEditable(kFALSE);
348
349	return d;
350	}
351
0145e89a	352	//_____________________________________________________________________________
	353	void
	354	AliMUONPainterMatrix::GetDataRange(Double_t& dataMin, Double_t& dataMax) const
	355	{
	356	/// Get the data range spanned by the painters in this matrix
	357
	358	dataMin=FLT_MAX;
	359	dataMax=-FLT_MAX;
	360
	361	for ( Int_t i = 0; i < Size(); ++i )
	362	{
	363	AliMUONVPainter* p = Painter(i);
	364	if ( p )
	365	{
	366	AliMUONPainterGroup* g = p->PlotterGroup();
	367	if ( g )
	368	{
	369	dataMin = TMath::Min(dataMin,g->DataMin());
	370	dataMax = TMath::Max(dataMax,g->DataMax());
	371	}
	372	}
	373	}
	374	}
	375
	376	//_____________________________________________________________________________
	377	void
	378	AliMUONPainterMatrix::GetTypes(TObjArray& types) const
	379	{
	380	/// Get the types of the painters in this matrix
	381
	382	types.SetOwner(kTRUE);
	383	types.Clear();
	384
	385	for ( Int_t i = 0; i < Size(); ++i )
	386	{
	387	AliMUONVPainter* p = Painter(i);
	388	TObjArray ptypes;
	389	p->GetTypes(ptypes);
	390	TIter next(&ptypes);
	391	TObject* o;
	392	while ( ( o = next() ) )
	393	{
	394	if ( ! types.FindObject(o) )
	395	{
	396	types.AddLast(o->Clone());
	397	}
	398	}
	399	}
	400	}
	401
fcabdc0c	402
	403	//_____________________________________________________________________________
	404	void
	405	AliMUONPainterMatrix::Draw(Option_t*)
	406	{
	407	/// Append our painters to the current pad
	408
	409	if (!gPad)
	410	{
	411	gROOT->MakeDefCanvas();
	412	}
	413
	414	TVirtualPad* pad = gPad;
	415
	416	gPad->Divide(Nx(),Ny());
	417
	418	for ( Int_t i = 0; i < Size(); ++i )
	419	{
	420	AliMUONVPainter* painter = Painter(i);
	421	pad->cd(i+1);
	422	painter->Draw("R");
	423	}
	424
	425	AppendPad("");
	426	}
	427
0145e89a	428	//_____________________________________________________________________________
	429	AliMUONVPainter*
	430	AliMUONPainterMatrix::Painter(Int_t index) const
	431	{
	432	/// Get a given painter
	433
	434	if ( index <= fPainters->GetLast() )
	435	{
	436	return static_cast<AliMUONVPainter*>(fPainters->At(index));
	437	}
	438	return 0x0;
	439	}
	440
	441	//_____________________________________________________________________________
	442	AliMUONVTrackerData*
	443	AliMUONPainterMatrix::Data() const
	444	{
9016a84e	445	/// Return our data
0145e89a	446	AliMUONPainterGroup* group = Painter(0)->PlotterGroup();
	447	return ( group ? group->Data() : 0x0 );
	448	}
	449
	450	//_____________________________________________________________________________
	451	TString
	452	AliMUONPainterMatrix::DataPattern() const
	453	{
9016a84e	454	/// Return our data pattern
0145e89a	455	AliMUONPainterGroup* group = Painter(0)->PlotterGroup();
	456	return ( group ? group->Type() : "" );
	457	}
	458
	459	//_____________________________________________________________________________
	460	Int_t
	461	AliMUONPainterMatrix::DataIndex() const
	462	{
9016a84e	463	/// Return our data index
0145e89a	464	AliMUONPainterGroup* group = Painter(0)->PlotterGroup();
	465	return ( group ? group->DataIndex() : -1 );
	466	}
	467
	468	//_____________________________________________________________________________
	469	void
	470	AliMUONPainterMatrix::SetData(const char* pattern, AliMUONVTrackerData* d,
	471	Int_t indexInData)
	472	{
	473	/// Set the data to be plotted
	474
	475	for ( Int_t i = 0; i < Size(); ++i )
	476	{
	477	AliMUONVPainter* painter = Painter(i);
	478	painter->SetData(pattern,d,indexInData);
	479	}
fcabdc0c	480
	481	if ( d )
	482	{
	483	fWhatname = Form("%s-%s",d->GetName(),d->DimensionName(indexInData).Data());
	484	}
	485	else
	486	{
	487	fWhatname = "";
	488	}
0145e89a	489	}
	490
	491	//_____________________________________________________________________________
	492	void
	493	AliMUONPainterMatrix::SetDataRange(Double_t dataMin, Double_t dataMax)
	494	{
	495	/// Set the data range
	496
	497	for ( Int_t i = 0; i < Size(); ++i )
	498	{
	499	AliMUONVPainter* p = Painter(i);
	500	AliMUONPainterGroup* g = p->PlotterGroup();
	501	if ( g )
	502	{
	503	g->SetDataRange(dataMin,dataMax);
	504	}
	505	}
	506	}
	507
	508	//_____________________________________________________________________________
	509	Int_t
	510	AliMUONPainterMatrix::Size() const
	511	{
	512	/// Return the number of painters we actually handle
	513	return fPainters->GetLast()+1;
	514	}
	515
	516	//_____________________________________________________________________________
	517	void
	518	AliMUONPainterMatrix::Print(Option_t*) const
	519	{
	520	/// Printout
fcabdc0c	521	cout << "Whatname=" << fWhatname.Data() << "Basename=" << fBasename.Data()
0145e89a	522	<< " Nx=" << fNx << " Ny=" << fNy << " Att=" << fAttributes.GetName() << endl;
	523	}
	524
	525	//_____________________________________________________________________________
	526	//void
	527	//AliMUONPainterMatrix::ChangeAttributes(const AliMUONAttPainter& attributes)
	528	//{
	529	// /// Change painters' attributes
	530	//
	531	// AliWarning("Implement me !");
	532	//
	533	// // for ( Int_t i = 0; i < Size(); ++i )
	534	// // {
	535	// // Painter(i)->SetAttributes(attributes);
	536	// // }
	537	//}
	538
	539	//_____________________________________________________________________________
	540	AliMUONPainterMatrix*
	541	AliMUONPainterMatrix::Clone(const AliMUONAttPainter& attributes) const
	542	{
	543	/// Clone with given attributes
	544
fcabdc0c	545	AliMUONPainterMatrix* clone = new AliMUONPainterMatrix(Basename(),Nx(),Ny());
0145e89a	546
	547	for ( Int_t i = 0; i < Size(); ++i )
	548	{
	549	AliMUONVPainter* oldPainter = Painter(i);
	550
	551	AliMUONVPainter* newPainter(0x0);
	552
	553	newPainter = AliMUONVPainter::CreatePainter(oldPainter->ClassName(),
	554	attributes,
	555	oldPainter->ID0(),
	556	oldPainter->ID1());
	557
	558	if (newPainter)
	559	{
	560	newPainter->UpdateGroupsFrom(*(oldPainter->Master()));
	561	clone->Adopt(newPainter);
	562	}
	563	else
	564	{
	565	AliError(Form("Failed to create painter of class %s ID0 %d ID1 %d",
	566	oldPainter->ClassName(),
	567	oldPainter->ID0(),
	568	oldPainter->ID1()));
	569	}
	570	}
	571
	572	return clone;
	573	}
	574
	575	//_____________________________________________________________________________
	576	void
	577	AliMUONPainterMatrix::SetOutlined(const char* pattern, Bool_t value)
	578	{
	579	/// Calls SetOutlined for all our painters
	580
	581	for ( Int_t i = 0; i < Size(); ++i )
	582	{
	583	Painter(i)->SetOutlined(pattern,value);
	584	}
	585	}
	586
	587	//_____________________________________________________________________________
	588	void
	589	AliMUONPainterMatrix::SetResponder(const char* pattern)
	590	{
	591	/// Calls SetResponder for all our painters
	592	for ( Int_t i = 0; i < Size(); ++i )
	593	{
	594	Painter(i)->SetResponder(pattern);
	595	}
	596	}
	597
	598	//_____________________________________________________________________________
	599	AliMUONAttPainter
	600	AliMUONPainterMatrix::Validate(const AliMUONAttPainter& att) const
	601	{
	602	/// Normalize attributes
	603
	604	AliMUONAttPainter a;
	605
	606	for ( Int_t i = 0; i < Size() && a.IsValid(); ++i )
	607	{
	608	a = Painter(i)->Validate(att);
	609	}
610	return a;
611	}