[u/mrichter/AliRoot.git] / MUON / AliMUONPainterHelper.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 <cstdlib>
#include "AliMUONPainterHelper.h"

#include "AliCodeTimer.h"
#include "AliLog.h"
#include "AliMUONContour.h"
#include "AliMUONContourHandler.h"
#include "AliMUONContourMaker.h"
#include "AliMUONGeometryDetElement.h"
#include "AliMUONGeometryTransformer.h"
#include "AliMUONManuContourMaker.h"
#include "AliMUONPainterEnv.h"
#include "AliMUONPainterMatrix.h"
#include "AliMUONPainterRegistry.h"
#include "AliMUONPadStatusMaker.h"
#include "AliMUONVCalibParam.h"
#include "AliMUONVDigit.h"
#include "AliMUONVTrackerData.h"
#include "AliMpCDB.h"
#include "AliMpConstants.h"
#include "AliMpDDLStore.h"
#include "AliMpDEIterator.h"
#include "AliMpDEManager.h"
#include "AliMpExMap.h"
#include "AliMpMotifMap.h"
#include "AliMpMotifPosition.h"
#include "AliMpPCB.h"
#include "AliMpPad.h"
#include "AliMpSector.h"
#include "AliMpSegmentation.h"
#include "AliMpSlat.h"
#include "AliMpStationType.h"
#include "AliMpVPadIterator.h"
#include <Riostream.h>
#include <TArrayI.h>
#include <TCanvas.h>
#include <TClass.h>
#include <TCollection.h>
#include <TFile.h>
#include <TGLabel.h>
#include <TGMsgBox.h>
#include <TGeoMatrix.h>
#include <TLine.h>
#include <TList.h>
#include <TMap.h>
#include <TObjArray.h>
#include <TObjString.h>
#include <TStyle.h>
#include <TSystem.h>
#include <TVector2.h>
#include <TVector3.h>
#include <TVirtualPad.h>
#include <TVirtualX.h>

#include "AliMUONChamberPainter.h"

///\class AliMUONPainterHelper
///
/// Helper class for painters
///
///\author Laurent Aphecetche, Subatech

///\cond CLASSIMP
ClassImp(AliMUONPainterHelper)
///\endcond

AliMUONPainterHelper* AliMUONPainterHelper::fgInstance(0x0);

//_____________________________________________________________________________
AliMUONPainterHelper::AliMUONPainterHelper() : 
TObject(),
fPainterMatrices(0x0),
fEnv(0x0),
fReal(0x0),
fExploded(0x0)
{
  /// ctor
  
  if ( ! AliMpCDB::LoadMpSegmentation() ) 
  {
    AliFatal("Could not access mapping from OCDB !");
  }
  
  // Load DDL store
  if ( ! AliMpCDB::LoadDDLStore() ) 
  {
    AliFatal("Could not access DDL Store from OCDB !");
  }
  
  fExploded = new AliMUONContourHandler(kTRUE);
}

//_____________________________________________________________________________
AliMUONPainterHelper::~AliMUONPainterHelper()
{
  /// dtor
  delete fPainterMatrices;
  delete fReal;
  delete fExploded;
  fEnv->Save();
  fgInstance = 0;
}

//_____________________________________________________________________________
AliMUONContour*
AliMUONPainterHelper::GetContour(const char* contourName, Bool_t explodedView) const
{
  /// Get a contour by name  
  if (explodedView) 
  {
    return fExploded->GetContour(contourName);
  }
  else
  {
    if ( fReal ) 
    {
      return fReal->GetContour(contourName);
    }
  }
  return 0x0;
}

//_____________________________________________________________________________
void
AliMUONPainterHelper::GenerateDefaultMatrices()
{
  /// Kind of bootstrap method to trigger the generation of all contours
  
  AliCodeTimerAuto("",);
  
  fPainterMatrices = new TObjArray;
  fPainterMatrices->SetOwner(kFALSE);
  
  TObjArray attributes;
  
  AliMUONAttPainter att;
  
  att.SetViewPoint(kTRUE,kFALSE);
  att.SetCathode(kFALSE,kFALSE);
  att.SetPlane(kTRUE,kFALSE);
  attributes.Add(new AliMUONAttPainter(att));

  TIter next(&attributes);
  AliMUONAttPainter* a;
  
  while ( ( a = static_cast<AliMUONAttPainter*>(next()) ) )
  {
    AliMUONPainterMatrix* matrix = new AliMUONPainterMatrix("Tracker",5,2);
    
    for ( Int_t i = 0; i < 10; ++i )
    {
      AliMUONVPainter* painter = new AliMUONChamberPainter(*a,i);
      
      painter->SetResponder("Chamber");
      
      painter->SetOutlined("*",kFALSE);
      
      painter->SetOutlined("MANU",kTRUE);
      
      for ( Int_t j = 0; j < 3; ++j ) 
      {
        painter->SetLine(j,1,4-j);
      }
      
      matrix->Adopt(painter);    
    }
    AliMUONPainterRegistry::Instance()->Register(matrix);
    fPainterMatrices->Add(matrix);
  }
}

//_____________________________________________________________________________
AliMp::CathodType
AliMUONPainterHelper::GetCathodeType(Int_t detElemId, Int_t manuId) const
{
  /// Get the cathode type of a given manu
  
  AliMp::PlaneType planeType(AliMp::kBendingPlane);
  if ( manuId & AliMpConstants::ManuMask(AliMp::kNonBendingPlane) )
  {
    planeType = AliMp::kNonBendingPlane;
  }
  return AliMpDEManager::GetCathod(detElemId,planeType);
}


//_____________________________________________________________________________
AliMpMotifPosition* 
AliMUONPainterHelper::GetMotifPosition(Int_t detElemId, Int_t manuId) const
{
  /// Get a given motif position
  const AliMpVSegmentation* vseg = AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
  if (vseg)
  {
    return vseg->MotifPosition(manuId);
  }
  return 0x0;
}

//_____________________________________________________________________________
AliMpPCB*
AliMUONPainterHelper::GetPCB(Int_t detElemId, AliMp::CathodType cathodeType, 
                             Int_t pcbNumber) const
{
  /// Get a given PCB
  const AliMpSlat* slat = GetSlat(detElemId,cathodeType);
  if ( slat ) return slat->GetPCB(pcbNumber);
  return 0x0;
}

//_____________________________________________________________________________
AliMpPCB*
AliMUONPainterHelper::GetPCB(Int_t detElemId, AliMp::PlaneType planeType, 
                             Int_t pcbNumber) const
{
  /// Get a given PCB
  AliMp::CathodType cathodeType = AliMpDEManager::GetCathod(detElemId,
                                                            planeType);
  return GetPCB(detElemId,cathodeType,pcbNumber);
}

//_____________________________________________________________________________
AliMp::PlaneType
AliMUONPainterHelper::GetPlaneType(Int_t manuId) const
{
  /// Get the planeType of a given manu
  
  if ( manuId & AliMpConstants::ManuMask(AliMp::kNonBendingPlane) )
  {
    return AliMp::kNonBendingPlane;
  }
  return AliMp::kBendingPlane;
}

//_____________________________________________________________________________
const AliMpSlat*
AliMUONPainterHelper::GetSlat(Int_t detElemId, AliMp::PlaneType planeType) const
{
  /// Get a given slat
  
  AliMp::CathodType cathodeType = AliMpDEManager::GetCathod(detElemId,
                                                          planeType);

  return GetSlat(detElemId,cathodeType);
}

//_____________________________________________________________________________
const AliMpSector*
AliMUONPainterHelper::GetSector(Int_t detElemId, AliMp::PlaneType planeType) const
{
  /// Get a given sector
  AliMp::StationType stationType = AliMpDEManager::GetStationType(detElemId);
  if ( stationType != AliMp::kStation12 ) return 0x0;
  
  AliMp::CathodType cathodeType = AliMpDEManager::GetCathod(detElemId,planeType);
  
  return AliMpSegmentation::Instance()->GetSector(detElemId,cathodeType);
}

//_____________________________________________________________________________
const AliMpSlat*
AliMUONPainterHelper::GetSlat(Int_t detElemId, AliMp::CathodType cathodeType) const
{
  /// Get a given slat
  AliMp::StationType stationType = AliMpDEManager::GetStationType(detElemId);
  if ( stationType != AliMp::kStation345 ) return 0x0;

  return AliMpSegmentation::Instance()->GetSlat(detElemId,cathodeType);
}

//_____________________________________________________________________________
const AliMpSlat*
AliMUONPainterHelper::GetSlat(Int_t detElemId, Int_t manuId) const
{
  /// Get a given slat
  AliMp::StationType stationType = AliMpDEManager::GetStationType(detElemId);
  if ( stationType != AliMp::kStation345 ) return 0x0;

  return AliMpSegmentation::Instance()->GetSlatByElectronics(detElemId,manuId);
}

//_____________________________________________________________________________
AliMUONPainterHelper*
AliMUONPainterHelper::Instance()
{
  /// Return the global and unique instance of this class
  
  if (fgInstance) return fgInstance;

  AliCodeTimerAutoClass("",);

  fgInstance = new AliMUONPainterHelper;
  fgInstance->fEnv = new AliMUONPainterEnv;
  return fgInstance;
}

//_____________________________________________________________________________
void 
AliMUONPainterHelper::Global2Local(Int_t detElemId, 
                                    Double_t xg, Double_t yg, Double_t zg,
                                    Double_t& xl, Double_t& yl, Double_t& zl) const
{
  /// Local to global transformation of coordinates
  
  TGeoHMatrix* matrix = static_cast<TGeoHMatrix*>(fExploded->GetTransformations()->GetValue(detElemId));
  Double_t pg[3] = { xg, yg, zg };
  Double_t pl[3] = { 0., 0., 0. };
  matrix->MasterToLocal(pg, pl);
  xl = pl[0];
  yl = pl[1];
  zl = pl[2];
}

//_____________________________________________________________________________
void 
AliMUONPainterHelper::Local2Global(Int_t detElemId, 
                                   Double_t xl, Double_t yl, Double_t zl,
                                   Double_t& xg, Double_t& yg, Double_t& zg) const
{
  /// Local to (exploded) global transformation of coordinates
  
  TGeoHMatrix* matrix = static_cast<TGeoHMatrix*>(fExploded->GetTransformations()->GetValue(detElemId));
  Double_t pl[3] = { xl, yl, zl };
  Double_t pg[3] = { 0., 0., 0. };
  matrix->LocalToMaster(pl, pg);
  xg = pg[0];
  yg = pg[1];
  zg = pg[2];
}

//_____________________________________________________________________________
Int_t
AliMUONPainterHelper::ColorFromValue(Double_t value, Double_t min, Double_t max) const
{ 
  /// Convert a value into a color, fitting within a given range
  
  Int_t rv;
  
  if (value > max) rv = 1;
  else if (value <= min) rv = 0;
  else
  {
    if  ( max == min ) return gStyle->GetColorPalette(1);
    Double_t range = max - min;
    Double_t offset = value - min;
    rv = gStyle->GetColorPalette( 1 + int( offset*(gStyle->GetNumberOfColors()-2)/range - 0.5 ) );
  }
  return rv;
}

//_____________________________________________________________________________
AliMUONContour* 
AliMUONPainterHelper::MergeContours(const TObjArray& contours, const char* contourName, Bool_t explodedGeometry)
{
  /// Merge a set of contours (delegating to the contour maker)
  
  AliMUONContourMaker maker;
  
  AliMUONContour* contour = maker.MergeContour(contours,contourName);
  
  if (contour) 
  {
    RegisterContour(contour,explodedGeometry);
  }
  return contour;
}


//_____________________________________________________________________________
void
AliMUONPainterHelper::Print(Option_t* opt) const
{
  /// Printout
  TString sopt(opt);
  sopt.ToUpper();
  
  if ( sopt.Length() == 0 )
  {
    if ( fExploded ) fExploded->Print();
    if ( fReal ) fReal->Print();
  }
  
  if ( fPainterMatrices && ( sopt.Contains("MATRI") || sopt.Contains("FULL") ) )
  {
    fPainterMatrices->Print(opt);
  }
}

//_____________________________________________________________________________
void
AliMUONPainterHelper::RegisterContour(AliMUONContour* contour, Bool_t explodedView)
{
  /// contour is adopted by contourMaker
  AliCodeTimerAuto("",)
  AliDebug(1,contour->GetName());
  AliMUONContourHandler* ch = fReal;
  if ( explodedView ) 
  {
    ch = fExploded;
  }
  if (!ch)
  {
    AliError(Form("ContourHandler for %s view is not created yet !",explodedView ? "EXPLODED" : "REAL"));
  }
  else
  {
    if ( ch->GetContour(contour->GetName()) )
    {
      AliError(Form("Contour with name %s is already there",contour->GetName()));
      return;
    }
    ch->Adopt(contour);
  }
}

//_____________________________________________________________________________
TString 
AliMUONPainterHelper::ChamberName(Int_t chamberId) const
{
  /// Build a name for one chamber
  return Form("Chamber%1d",chamberId+1);
}

//_____________________________________________________________________________
TString 
AliMUONPainterHelper::StationName(Int_t stationId) const
{
  /// Build a name for one station
  return Form("Station%1d",stationId+1);
}

//_____________________________________________________________________________
TString 
AliMUONPainterHelper::DEName(Int_t detElemId) const
{
  /// Build a name for one detection element
  return Form("DE%04d",detElemId);
}

//_____________________________________________________________________________
TString 
AliMUONPainterHelper::ManuName(Int_t manuId) const
{
  /// Build a name for one manu
  return Form("MANU%04d",manuId);
}

//_____________________________________________________________________________
TString 
AliMUONPainterHelper::BusPatchName(Int_t busPatchId) const
{
  /// Build a name for one buspatch
  return Form("BUSPATCH%04d",busPatchId);
}

//_____________________________________________________________________________
TString 
AliMUONPainterHelper::PCBName(Int_t pcbNumber) const
{
  /// Build a name for one pcb
  return Form("PCB%1d",pcbNumber);
}

//_____________________________________________________________________________
TString 
AliMUONPainterHelper::ChamberPathName(Int_t chamberId) const
{
  /// Build a name for one chamber
  return Form("%s/%s",StationName(chamberId/2).Data(),ChamberName(chamberId).Data());
}

//_____________________________________________________________________________
TString 
AliMUONPainterHelper::StationPathName(Int_t stationId) const
{
  /// Build a name for one station
  return StationName(stationId);
}

//_____________________________________________________________________________
TString 
AliMUONPainterHelper::DEPathName(Int_t detElemId) const
{
  /// Build a name for one detection element
  
  Int_t chamberId = AliMpDEManager::GetChamberId(detElemId);
  
  return Form("%s/%s/%s",
              StationName(chamberId/2).Data(),
              ChamberName(chamberId).Data(),
              DEName(detElemId).Data());
}

//_____________________________________________________________________________
TString 
AliMUONPainterHelper::ManuPathName(Int_t detElemId, Int_t manuId) const
{
  /// Build a name for one manu
  return Form("%s/%s",DEPathName(detElemId).Data(),ManuName(manuId).Data());
}

//_____________________________________________________________________________
TString 
AliMUONPainterHelper::BusPatchPathName(Int_t busPatchId) const
{
  /// Build a name for one buspatch
  Int_t detElemId = AliMpDDLStore::Instance()->GetDEfromBus(busPatchId);
  
  return Form("%s/%s",DEPathName(detElemId).Data(),BusPatchName(busPatchId).Data());
}

//_____________________________________________________________________________
TString 
AliMUONPainterHelper::PCBPathName(Int_t detElemId, Int_t pcbNumber) const
{
  /// Build a name for one pcb
  return Form("%s/%s",DEPathName(detElemId).Data(),PCBName(pcbNumber).Data());
}

//_____________________________________________________________________________
TString
AliMUONPainterHelper::FormatValue(const char* name, Double_t value) const
{
  /// Format a double value to be displayed
  /// FIXME: should insure we have the right number of significant digits here...
  
  TString sname(name);
  
  sname.ToUpper();
  if (sname.Contains("BIT"))
  {
    Int_t i = (Int_t)(value);
    TString rv = Form("%s = 0x%x",name,i);
    cout << rv << ":" << AliMUONPadStatusMaker::AsString(i) << endl;
    return rv;
  }
  else
  {
    return Form("%s = %e",name,value);
  }
}

//_____________________________________________________________________________
TObjArray*
AliMUONPainterHelper::GetAllContoursAsArray(Bool_t explodedView) const
{
  /// Get the contours in a specially arranged array (orderer by hierarchy level)
  
  if ( explodedView ) return fExploded->AllContourArray(); // fExploded should always be created
  
  if (!fReal) fReal = new AliMUONContourHandler(kFALSE); // fReal might be first asked here.
  
  return fReal->AllContourArray();
}
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
b09247a2	18	#include <cstdlib>
0145e89a	19	#include "AliMUONPainterHelper.h"
0145e89a	20
8f0acce4	21	#include "AliCodeTimer.h"
	22	#include "AliLog.h"
	23	#include "AliMUONContour.h"
fef32488	24	#include "AliMUONContourHandler.h"
8f0acce4	25	#include "AliMUONContourMaker.h"
0145e89a	26	#include "AliMUONGeometryDetElement.h"
0145e89a	27	#include "AliMUONGeometryTransformer.h"
8f0acce4	28	#include "AliMUONManuContourMaker.h"
0145e89a	29	#include "AliMUONPainterEnv.h"
0145e89a	30	#include "AliMUONPainterMatrix.h"
0145e89a	31	#include "AliMUONPainterRegistry.h"
fef32488	32	#include "AliMUONPadStatusMaker.h"
0145e89a	33	#include "AliMUONVCalibParam.h"
	34	#include "AliMUONVDigit.h"
	35	#include "AliMUONVTrackerData.h"
	36	#include "AliMpCDB.h"
	37	#include "AliMpConstants.h"
	38	#include "AliMpDDLStore.h"
	39	#include "AliMpDEIterator.h"
	40	#include "AliMpDEManager.h"
	41	#include "AliMpExMap.h"
	42	#include "AliMpMotifMap.h"
	43	#include "AliMpMotifPosition.h"
	44	#include "AliMpPCB.h"
	45	#include "AliMpPad.h"
	46	#include "AliMpSector.h"
0145e89a	47	#include "AliMpSegmentation.h"
0145e89a	48	#include "AliMpSlat.h"
0145e89a	49	#include "AliMpStationType.h"
0145e89a	50	#include "AliMpVPadIterator.h"
0145e89a	51	#include <Riostream.h>
	52	#include <TArrayI.h>
	53	#include <TCanvas.h>
	54	#include <TClass.h>
	55	#include <TCollection.h>
	56	#include <TFile.h>
	57	#include <TGLabel.h>
0145e89a	58	#include <TGMsgBox.h>
8f0acce4	59	#include <TGeoMatrix.h>
0145e89a	60	#include <TLine.h>
	61	#include <TList.h>
	62	#include <TMap.h>
	63	#include <TObjArray.h>
	64	#include <TObjString.h>
	65	#include <TStyle.h>
	66	#include <TSystem.h>
	67	#include <TVector2.h>
	68	#include <TVector3.h>
	69	#include <TVirtualPad.h>
	70	#include <TVirtualX.h>
	71
8f0acce4	72	#include "AliMUONChamberPainter.h"
8f0acce4	73
0145e89a	74	///\class AliMUONPainterHelper
	75	///
	76	/// Helper class for painters
	77	///
	78	///\author Laurent Aphecetche, Subatech
	79
	80	///\cond CLASSIMP
	81	ClassImp(AliMUONPainterHelper)
	82	///\endcond
	83
	84	AliMUONPainterHelper* AliMUONPainterHelper::fgInstance(0x0);
	85
	86	//_____________________________________________________________________________
	87	AliMUONPainterHelper::AliMUONPainterHelper() :
8f0acce4	88	TObject(),
8f0acce4	89	fPainterMatrices(0x0),
8f0acce4	90	fEnv(0x0),
fef32488	91	fReal(0x0),
fef32488	92	fExploded(0x0)
0145e89a	93	{
fef32488	94	/// ctor
8f0acce4	95
fef32488	96	if ( ! AliMpCDB::LoadMpSegmentation() )
	97	{
	98	AliFatal("Could not access mapping from OCDB !");
	99	}
8f0acce4	100
fef32488	101	// Load DDL store
	102	if ( ! AliMpCDB::LoadDDLStore() )
	103	{
	104	AliFatal("Could not access DDL Store from OCDB !");
	105	}
	106
	107	fExploded = new AliMUONContourHandler(kTRUE);
0145e89a	108	}
	109
	110	//_____________________________________________________________________________
	111	AliMUONPainterHelper::~AliMUONPainterHelper()
	112	{
	113	/// dtor
0145e89a	114	delete fPainterMatrices;
fef32488	115	delete fReal;
fef32488	116	delete fExploded;
8f0acce4	117	fEnv->Save();
0145e89a	118	fgInstance = 0;
	119	}
	120
	121	//_____________________________________________________________________________
8f0acce4	122	AliMUONContour*
fef32488	123	AliMUONPainterHelper::GetContour(const char* contourName, Bool_t explodedView) const
0145e89a	124	{
8f0acce4	125	/// Get a contour by name
fef32488	126	if (explodedView)
	127	{
	128	return fExploded->GetContour(contourName);
	129	}
	130	else
	131	{
	132	if ( fReal )
	133	{
	134	return fReal->GetContour(contourName);
	135	}
	136	}
	137	return 0x0;
0145e89a	138	}
	139
	140	//_____________________________________________________________________________
	141	void
	142	AliMUONPainterHelper::GenerateDefaultMatrices()
	143	{
	144	/// Kind of bootstrap method to trigger the generation of all contours
	145
70d92702	146	AliCodeTimerAuto("",);
8f0acce4	147
0145e89a	148	fPainterMatrices = new TObjArray;
	149	fPainterMatrices->SetOwner(kFALSE);
	150
	151	TObjArray attributes;
	152
	153	AliMUONAttPainter att;
	154
	155	att.SetViewPoint(kTRUE,kFALSE);
0145e89a	156	att.SetCathode(kFALSE,kFALSE);
	157	att.SetPlane(kTRUE,kFALSE);
	158	attributes.Add(new AliMUONAttPainter(att));
8f0acce4	159
0145e89a	160	TIter next(&attributes);
	161	AliMUONAttPainter* a;
	162
	163	while ( ( a = static_cast<AliMUONAttPainter*>(next()) ) )
	164	{
	165	AliMUONPainterMatrix* matrix = new AliMUONPainterMatrix("Tracker",5,2);
	166
	167	for ( Int_t i = 0; i < 10; ++i )
	168	{
8f0acce4	169	AliMUONVPainter* painter = new AliMUONChamberPainter(*a,i);
0145e89a	170
	171	painter->SetResponder("Chamber");
	172
	173	painter->SetOutlined("*",kFALSE);
	174
	175	painter->SetOutlined("MANU",kTRUE);
	176
	177	for ( Int_t j = 0; j < 3; ++j )
	178	{
	179	painter->SetLine(j,1,4-j);
	180	}
	181
	182	matrix->Adopt(painter);
	183	}
	184	AliMUONPainterRegistry::Instance()->Register(matrix);
	185	fPainterMatrices->Add(matrix);
	186	}
	187	}
	188
0145e89a	189	//_____________________________________________________________________________
	190	AliMp::CathodType
	191	AliMUONPainterHelper::GetCathodeType(Int_t detElemId, Int_t manuId) const
	192	{
	193	/// Get the cathode type of a given manu
	194
	195	AliMp::PlaneType planeType(AliMp::kBendingPlane);
	196	if ( manuId & AliMpConstants::ManuMask(AliMp::kNonBendingPlane) )
	197	{
	198	planeType = AliMp::kNonBendingPlane;
	199	}
	200	return AliMpDEManager::GetCathod(detElemId,planeType);
	201	}
	202
0145e89a	203
	204	//_____________________________________________________________________________
	205	AliMpMotifPosition*
	206	AliMUONPainterHelper::GetMotifPosition(Int_t detElemId, Int_t manuId) const
	207	{
	208	/// Get a given motif position
fef32488	209	const AliMpVSegmentation* vseg = AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId,manuId);
fef32488	210	if (vseg)
0145e89a	211	{
fef32488	212	return vseg->MotifPosition(manuId);
0145e89a	213	}
0145e89a	214	return 0x0;
	215	}
	216
0145e89a	217	//_____________________________________________________________________________
	218	AliMpPCB*
	219	AliMUONPainterHelper::GetPCB(Int_t detElemId, AliMp::CathodType cathodeType,
	220	Int_t pcbNumber) const
	221	{
	222	/// Get a given PCB
	223	const AliMpSlat* slat = GetSlat(detElemId,cathodeType);
	224	if ( slat ) return slat->GetPCB(pcbNumber);
	225	return 0x0;
	226	}
	227
	228	//_____________________________________________________________________________
	229	AliMpPCB*
	230	AliMUONPainterHelper::GetPCB(Int_t detElemId, AliMp::PlaneType planeType,
	231	Int_t pcbNumber) const
	232	{
	233	/// Get a given PCB
	234	AliMp::CathodType cathodeType = AliMpDEManager::GetCathod(detElemId,
	235	planeType);
	236	return GetPCB(detElemId,cathodeType,pcbNumber);
	237	}
	238
	239	//_____________________________________________________________________________
	240	AliMp::PlaneType
	241	AliMUONPainterHelper::GetPlaneType(Int_t manuId) const
	242	{
	243	/// Get the planeType of a given manu
	244
	245	if ( manuId & AliMpConstants::ManuMask(AliMp::kNonBendingPlane) )
	246	{
	247	return AliMp::kNonBendingPlane;
	248	}
	249	return AliMp::kBendingPlane;
	250	}
	251
	252	//_____________________________________________________________________________
	253	const AliMpSlat*
	254	AliMUONPainterHelper::GetSlat(Int_t detElemId, AliMp::PlaneType planeType) const
	255	{
	256	/// Get a given slat
	257
	258	AliMp::CathodType cathodeType = AliMpDEManager::GetCathod(detElemId,
	259	planeType);
	260
	261	return GetSlat(detElemId,cathodeType);
	262	}
	263
	264	//_____________________________________________________________________________
	265	const AliMpSector*
	266	AliMUONPainterHelper::GetSector(Int_t detElemId, AliMp::PlaneType planeType) const
	267	{
	268	/// Get a given sector
	269	AliMp::StationType stationType = AliMpDEManager::GetStationType(detElemId);
4e51cfd2	270	if ( stationType != AliMp::kStation12 ) return 0x0;
0145e89a	271
	272	AliMp::CathodType cathodeType = AliMpDEManager::GetCathod(detElemId,planeType);
	273
f3ed9a44	274	return AliMpSegmentation::Instance()->GetSector(detElemId,cathodeType);
0145e89a	275	}
	276
	277	//_____________________________________________________________________________
	278	const AliMpSlat*
	279	AliMUONPainterHelper::GetSlat(Int_t detElemId, AliMp::CathodType cathodeType) const
	280	{
	281	/// Get a given slat
	282	AliMp::StationType stationType = AliMpDEManager::GetStationType(detElemId);
	283	if ( stationType != AliMp::kStation345 ) return 0x0;
	284
f3ed9a44	285	return AliMpSegmentation::Instance()->GetSlat(detElemId,cathodeType);
0145e89a	286	}
	287
	288	//_____________________________________________________________________________
	289	const AliMpSlat*
	290	AliMUONPainterHelper::GetSlat(Int_t detElemId, Int_t manuId) const
	291	{
	292	/// Get a given slat
f3ed9a44	293	AliMp::StationType stationType = AliMpDEManager::GetStationType(detElemId);
	294	if ( stationType != AliMp::kStation345 ) return 0x0;
	295
	296	return AliMpSegmentation::Instance()->GetSlatByElectronics(detElemId,manuId);
0145e89a	297	}
	298
	299	//_____________________________________________________________________________
	300	AliMUONPainterHelper*
	301	AliMUONPainterHelper::Instance()
	302	{
	303	/// Return the global and unique instance of this class
	304
	305	if (fgInstance) return fgInstance;
0145e89a	306
70d92702	307	AliCodeTimerAutoClass("",);
8f0acce4	308
8f0acce4	309	fgInstance = new AliMUONPainterHelper;
8f0acce4	310	fgInstance->fEnv = new AliMUONPainterEnv;
0145e89a	311	return fgInstance;
	312	}
	313
	314	//_____________________________________________________________________________
	315	void
	316	AliMUONPainterHelper::Global2Local(Int_t detElemId,
	317	Double_t xg, Double_t yg, Double_t zg,
	318	Double_t& xl, Double_t& yl, Double_t& zl) const
	319	{
	320	/// Local to global transformation of coordinates
	321
fef32488	322	TGeoHMatrix* matrix = static_cast<TGeoHMatrix*>(fExploded->GetTransformations()->GetValue(detElemId));
0145e89a	323	Double_t pg[3] = { xg, yg, zg };
	324	Double_t pl[3] = { 0., 0., 0. };
	325	matrix->MasterToLocal(pg, pl);
	326	xl = pl[0];
	327	yl = pl[1];
	328	zl = pl[2];
	329	}
	330
	331	//_____________________________________________________________________________
	332	void
	333	AliMUONPainterHelper::Local2Global(Int_t detElemId,
	334	Double_t xl, Double_t yl, Double_t zl,
	335	Double_t& xg, Double_t& yg, Double_t& zg) const
	336	{
	337	/// Local to (exploded) global transformation of coordinates
	338
fef32488	339	TGeoHMatrix* matrix = static_cast<TGeoHMatrix*>(fExploded->GetTransformations()->GetValue(detElemId));
0145e89a	340	Double_t pl[3] = { xl, yl, zl };
	341	Double_t pg[3] = { 0., 0., 0. };
	342	matrix->LocalToMaster(pl, pg);
	343	xg = pg[0];
	344	yg = pg[1];
	345	zg = pg[2];
	346	}
	347
	348	//_____________________________________________________________________________
	349	Int_t
	350	AliMUONPainterHelper::ColorFromValue(Double_t value, Double_t min, Double_t max) const
	351	{
	352	/// Convert a value into a color, fitting within a given range
	353
	354	Int_t rv;
	355
	356	if (value > max) rv = 1;
	357	else if (value <= min) rv = 0;
	358	else
	359	{
	360	if ( max == min ) return gStyle->GetColorPalette(1);
	361	Double_t range = max - min;
	362	Double_t offset = value - min;
	363	rv = gStyle->GetColorPalette( 1 + int( offset*(gStyle->GetNumberOfColors()-2)/range - 0.5 ) );
	364	}
	365	return rv;
	366	}
	367
	368	//_____________________________________________________________________________
8f0acce4	369	AliMUONContour*
fef32488	370	AliMUONPainterHelper::MergeContours(const TObjArray& contours, const char* contourName, Bool_t explodedGeometry)
0145e89a	371	{
0145e89a	372	/// Merge a set of contours (delegating to the contour maker)
0145e89a	373
8f0acce4	374	AliMUONContourMaker maker;
	375
	376	AliMUONContour* contour = maker.MergeContour(contours,contourName);
0145e89a	377
	378	if (contour)
	379	{
fef32488	380	RegisterContour(contour,explodedGeometry);
0145e89a	381	}
	382	return contour;
	383	}
	384
	385
	386	//_____________________________________________________________________________
	387	void
	388	AliMUONPainterHelper::Print(Option_t* opt) const
	389	{
	390	/// Printout
	391	TString sopt(opt);
	392	sopt.ToUpper();
	393
	394	if ( sopt.Length() == 0 )
	395	{
fef32488	396	if ( fExploded ) fExploded->Print();
fef32488	397	if ( fReal ) fReal->Print();
0145e89a	398	}
0145e89a	399
fef32488	400	if ( fPainterMatrices && ( sopt.Contains("MATRI") \|\| sopt.Contains("FULL") ) )
0145e89a	401	{
	402	fPainterMatrices->Print(opt);
	403	}
	404	}
	405
	406	//_____________________________________________________________________________
	407	void
fef32488	408	AliMUONPainterHelper::RegisterContour(AliMUONContour* contour, Bool_t explodedView)
0145e89a	409	{
0145e89a	410	/// contour is adopted by contourMaker
70d92702	411	AliCodeTimerAuto("",)
0145e89a	412	AliDebug(1,contour->GetName());
fef32488	413	AliMUONContourHandler* ch = fReal;
fef32488	414	if ( explodedView )
0145e89a	415	{
fef32488	416	ch = fExploded;
	417	}
	418	if (!ch)
	419	{
	420	AliError(Form("ContourHandler for %s view is not created yet !",explodedView ? "EXPLODED" : "REAL"));
	421	}
	422	else
	423	{
	424	if ( ch->GetContour(contour->GetName()) )
	425	{
	426	AliError(Form("Contour with name %s is already there",contour->GetName()));
	427	return;
	428	}
	429	ch->Adopt(contour);
0145e89a	430	}
0145e89a	431	}
	432
	433	//_____________________________________________________________________________
	434	TString
	435	AliMUONPainterHelper::ChamberName(Int_t chamberId) const
	436	{
	437	/// Build a name for one chamber
dc9bb08e	438	return Form("Chamber%1d",chamberId+1);
0145e89a	439	}
	440
	441	//_____________________________________________________________________________
	442	TString
	443	AliMUONPainterHelper::StationName(Int_t stationId) const
	444	{
	445	/// Build a name for one station
	446	return Form("Station%1d",stationId+1);
	447	}
	448
	449	//_____________________________________________________________________________
	450	TString
	451	AliMUONPainterHelper::DEName(Int_t detElemId) const
	452	{
	453	/// Build a name for one detection element
	454	return Form("DE%04d",detElemId);
	455	}
	456
	457	//_____________________________________________________________________________
	458	TString
	459	AliMUONPainterHelper::ManuName(Int_t manuId) const
	460	{
	461	/// Build a name for one manu
	462	return Form("MANU%04d",manuId);
	463	}
	464
	465	//_____________________________________________________________________________
	466	TString
	467	AliMUONPainterHelper::BusPatchName(Int_t busPatchId) const
	468	{
	469	/// Build a name for one buspatch
	470	return Form("BUSPATCH%04d",busPatchId);
	471	}
	472
	473	//_____________________________________________________________________________
	474	TString
	475	AliMUONPainterHelper::PCBName(Int_t pcbNumber) const
	476	{
	477	/// Build a name for one pcb
	478	return Form("PCB%1d",pcbNumber);
	479	}
	480
	481	//_____________________________________________________________________________
	482	TString
	483	AliMUONPainterHelper::ChamberPathName(Int_t chamberId) const
	484	{
	485	/// Build a name for one chamber
	486	return Form("%s/%s",StationName(chamberId/2).Data(),ChamberName(chamberId).Data());
	487	}
	488
	489	//_____________________________________________________________________________
	490	TString
	491	AliMUONPainterHelper::StationPathName(Int_t stationId) const
	492	{
	493	/// Build a name for one station
	494	return StationName(stationId);
	495	}
	496
	497	//_____________________________________________________________________________
	498	TString
	499	AliMUONPainterHelper::DEPathName(Int_t detElemId) const
	500	{
	501	/// Build a name for one detection element
	502
503	Int_t chamberId = AliMpDEManager::GetChamberId(detElemId);
504
505	return Form("%s/%s/%s",
506	StationName(chamberId/2).Data(),
507	ChamberName(chamberId).Data(),
508	DEName(detElemId).Data());
509	}
510
511	//_____________________________________________________________________________
512	TString
513	AliMUONPainterHelper::ManuPathName(Int_t detElemId, Int_t manuId) const
514	{
515	/// Build a name for one manu
516	return Form("%s/%s",DEPathName(detElemId).Data(),ManuName(manuId).Data());
517	}
518
519	//_____________________________________________________________________________
520	TString
521	AliMUONPainterHelper::BusPatchPathName(Int_t busPatchId) const
522	{
523	/// Build a name for one buspatch
524	Int_t detElemId = AliMpDDLStore::Instance()->GetDEfromBus(busPatchId);
525
526	return Form("%s/%s",DEPathName(detElemId).Data(),BusPatchName(busPatchId).Data());
527	}
528
529	//_____________________________________________________________________________
530	TString
531	AliMUONPainterHelper::PCBPathName(Int_t detElemId, Int_t pcbNumber) const
532	{
533	/// Build a name for one pcb
534	return Form("%s/%s",DEPathName(detElemId).Data(),PCBName(pcbNumber).Data());
535	}
536
537	//_____________________________________________________________________________
538	TString
539	AliMUONPainterHelper::FormatValue(const char* name, Double_t value) const
540	{
541	/// Format a double value to be displayed
542	/// FIXME: should insure we have the right number of significant digits here...
543
fef32488	544	TString sname(name);
	545
	546	sname.ToUpper();
	547	if (sname.Contains("BIT"))
	548	{
	549	Int_t i = (Int_t)(value);
	550	TString rv = Form("%s = 0x%x",name,i);
	551	cout << rv << ":" << AliMUONPadStatusMaker::AsString(i) << endl;
	552	return rv;
	553	}
	554	else
	555	{
	556	return Form("%s = %e",name,value);
	557	}
	558	}
	559
	560	//_____________________________________________________________________________
	561	TObjArray*
	562	AliMUONPainterHelper::GetAllContoursAsArray(Bool_t explodedView) const
	563	{
	564	/// Get the contours in a specially arranged array (orderer by hierarchy level)
	565
	566	if ( explodedView ) return fExploded->AllContourArray(); // fExploded should always be created
	567
	568	if (!fReal) fReal = new AliMUONContourHandler(kFALSE); // fReal might be first asked here.
	569
	570	return fReal->AllContourArray();
0145e89a	571	}
8f0acce4	572
fef32488	573