[u/mrichter/AliRoot.git] / EVE / alice-macros / esd_muon_tracks.C

// $Id$

/**************************************************************************
 * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
 * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for          *
 * full copyright notice.                                                 *
 **************************************************************************/

/// \ingroup evemacros
/// \file esd_muon_tracks.C
/// \brief Macro to visualise ESD tracks from MUON spectrometer 
/// (both tracker and trigger).
///
/// Use esd_muon_tracks(Bool_t showClusters, Bool_t showDigits) in order to run it
///
/// Needs that alieve_init() is already called
///
/// \author P. Pillot, L. Aphecetche; Subatech

#if !defined(__CINT__) || defined(__MAKECINT__)

#include "AliMUONESDInterface.h"
#include "AliMUONTrack.h"
#include "AliMUONTrackExtrap.h"
#include "AliMUONTrackParam.h"
#include "AliMUONConstants.h"
#include "AliMUONCDB.h"
#include "AliMUONGeometryTransformer.h"
#include "AliMUONTriggerCircuit.h"

#include "AliMpCDB.h"

#include "AliESDEvent.h"
#include "AliESDMuonTrack.h"

#include "EveBase/AliEveMagField.h"
#include "EveBase/AliEveTrack.h"
#include "EveBase/AliEveEventManager.h"

#include <TEveManager.h>
#include <TEveUtil.h>
#include <TEveTrack.h>
#include <TEvePointSet.h>
#include <TEveQuadSet.h>
#include <TEveTrackPropagator.h>
#include <TEveVSDStructs.h>

#include <TStyle.h>
#include <TROOT.h>

#endif

//______________________________________________________________________________
void esd_muon_track_propagator_setup(TEveTrackPropagator* trkProp, Bool_t tracker, Bool_t trigger)
{
  // set magnetic field
  if (AliMUONTrackExtrap::IsFieldON())
  {
    trkProp->SetMagFieldObj(new AliEveMagField);
  }
  else
  {
    trkProp->SetMagField(0.0);
  }
  trkProp->SetStepper(TEveTrackPropagator::kRungeKutta);
  
  // set propagation range
  trkProp->SetMaxR(1000);
  if (trigger) trkProp->SetMaxZ(-AliMUONConstants::DefaultChamberZ(13)+10.);
  else trkProp->SetMaxZ(-AliMUONConstants::MuonFilterZBeg());
  
  // go through pathmarks
  trkProp->SetFitDaughters(kFALSE);
  trkProp->SetFitReferences(kTRUE);
  trkProp->SetFitDecay(kFALSE);
  trkProp->SetFitCluster2Ds(kFALSE);
  
  // Render the ref pathmarks
  trkProp->SetRnrReferences(kTRUE);
  trkProp->RefPMAtt().SetMarkerSize(0.5);
  if (trigger) trkProp->RefPMAtt().SetMarkerColor(kGreen);
  else trkProp->RefPMAtt().SetMarkerColor(kAzure);
  
  // Render first vertex
  if (tracker)
  {
    trkProp->SetRnrFV(kTRUE);
    if (trigger) trkProp->RefFVAtt().SetMarkerColor(kGreen);
    else trkProp->RefFVAtt().SetMarkerColor(kAzure);
  }
}

//______________________________________________________________________________
void add_esd_muon_tracks(AliESDEvent* esd, AliMUONESDInterface* data,
			 TEveTrackList* match, TEveTrackList* nomatch, TEveTrackList* ghost)
{
  // load trigger circuit
  static AliMUONTriggerCircuit* gTriggerCircuit = 0x0;
  if (!gTriggerCircuit) 
  {
    AliEveEventManager::AssertGeometry();
    AliMUONGeometryTransformer* fMUONGeometryTransformer = new AliMUONGeometryTransformer();
    fMUONGeometryTransformer->LoadGeometryData();
    gTriggerCircuit = new AliMUONTriggerCircuit(fMUONGeometryTransformer);
  }
  
  Int_t nTrack(esd->GetNumberOfMuonTracks());
  TEveRecTrack recTrack;
  TEveTrack* track;
  
  // add ESD tracks to the proper list
  for (Int_t n = 0; n < nTrack; ++n)
  {
    AliESDMuonTrack* emt = esd->GetMuonTrack(n);
    
    // fill general info
    UInt_t trackId = emt->GetUniqueID();
    recTrack.fLabel = emt->GetLabel();
    recTrack.fIndex = (Int_t)trackId;
    
    // fill tracker track specific info
    if ( emt->ContainTrackerData() )
    {
      recTrack.fStatus = emt->GetMatchTrigger();
      recTrack.fSign = emt->Charge();
      recTrack.fV.Set(emt->GetNonBendingCoorAtDCA(),emt->GetBendingCoorAtDCA(),emt->GetZ());
      recTrack.fP.Set(emt->PxAtDCA(),emt->PyAtDCA(),emt->PzAtDCA());
      recTrack.fBeta = ( emt->E() > 0 ) ? emt->P()/emt->E() : 0;
      
      // get proper track list
      TEveTrackList* trackList = nomatch;
      if ( emt->GetMatchTrigger() > 0 ) trackList = match;
      
      // produce eve track
      track = new AliEveTrack(&recTrack,trackList->GetPropagator());
      track->SetName(Form("%cmu",emt->Charge()>0 ? '+':'-'));
      track->SetStdTitle();
      track->SetSourceObject(emt); // WARNING: Change the UniqueID of the object!!
      
      // add path mark
      TIter next(data->FindTrack(trackId)->GetTrackParamAtCluster());
      AliMUONTrackParam* param;
      while ( ( param = static_cast<AliMUONTrackParam*>(next()) ) )
      {
	TEveVector v(param->GetNonBendingCoor(),param->GetBendingCoor(),param->GetZ());
	TEveVector p(param->Px(),param->Py(),param->Pz());
	track->AddPathMark(TEvePathMark(TEvePathMark::kReference,v,p));
      }
      
      // add trigger track if any
      if (emt->ContainTriggerData())
      {
	Double_t x11 = gTriggerCircuit->GetX11Pos(emt->LoCircuit(), emt->LoStripY());
	Double_t y11 = gTriggerCircuit->GetY11Pos(emt->LoCircuit(), emt->LoStripX());
	Double_t z11 = gTriggerCircuit->GetZ11Pos(emt->LoCircuit(), emt->LoStripX());
	Double_t y21 = gTriggerCircuit->GetY21Pos(emt->LoCircuit(), emt->LoStripX()+emt->LoDev()+1);
	Double_t z21 = gTriggerCircuit->GetZ21Pos(emt->LoCircuit(), emt->LoStripX()+emt->LoDev()+1);
	Double_t pz  = -emt->PUncorrected(); // max value
	TEveVector v(x11, y11, z11);
	TEveVector p(pz*x11/z11, pz*(y21-y11)/(z21-z11), pz);
	track->AddPathMark(TEvePathMark(TEvePathMark::kReference,v,p));
      }
      
      // add the track to proper list
      track->SetAttLineAttMarker(trackList);
      trackList->AddElement(track);
    }
    else // fill ghost track specific info
    {
      recTrack.fStatus = 0;
      recTrack.fSign = emt->Charge();
      Double_t z11 = (emt->GetZUncorrected() < -1.) ? emt->GetZUncorrected() : (Double_t)AliMUONConstants::DefaultChamberZ(10);
      recTrack.fV.Set(emt->GetNonBendingCoorUncorrected(),emt->GetBendingCoorUncorrected(),z11);
      recTrack.fP.Set(-TMath::Tan(emt->GetThetaXUncorrected()),-TMath::Tan(emt->GetThetaYUncorrected()),-1.);
      
      // produce eve track
      track = new AliEveTrack(&recTrack,ghost->GetPropagator());
      track->SetName("mu");
      track->SetTitle("Trigger only");
      track->SetSourceObject(emt);
      
      // add the track to proper list
      track->SetAttLineAttMarker(ghost);
      ghost->AddElement(track);
    }
    
  }
  
}

//______________________________________________________________________________
void esd_muon_tracks(Bool_t showClusters, Bool_t showDigits)
{
  // load ESD
  AliESDEvent* esd = AliEveEventManager::AssertESD();
  if (esd->GetNumberOfMuonTracks() == 0 && !gEve->GetKeepEmptyCont()) return;
  
  // load field
  AliEveEventManager::AssertMagField();
  if (!AliMUONESDInterface::GetTracker()) AliMUONESDInterface::ResetTracker(AliMUONCDB::LoadRecoParam());
  
  // load mapping
  AliMpCDB::LoadAll(kFALSE);
  
  // convert ESD objects to MUON objects
  AliMUONESDInterface data;
  data.LoadEvent(*esd);
  
  // track containers
  TEveElementList* trackCont = new TEveElementList("ESD MUON Tracks");
  trackCont->SetTitle(Form("N=%d", esd->GetNumberOfMuonTracks()));
  
  TEveTrackList* match = new TEveTrackList("Matched");
  match->SetRnrPoints(kFALSE);
  match->SetRnrLine(kTRUE);
  match->SetLineColor(kGreen);
  esd_muon_track_propagator_setup(match->GetPropagator(), kTRUE, kTRUE);
  trackCont->AddElement(match);
  
  TEveTrackList* nomatch = new TEveTrackList("Not matched");
  nomatch->SetRnrPoints(kFALSE);
  nomatch->SetRnrLine(kTRUE);
  nomatch->SetLineColor(kAzure);
  esd_muon_track_propagator_setup(nomatch->GetPropagator(), kTRUE, kFALSE);
  trackCont->AddElement(nomatch);
  
  TEveTrackList* ghost = new TEveTrackList("Ghost");
  ghost->SetRnrPoints(kFALSE);
  ghost->SetRnrLine(kTRUE);
  ghost->SetLineColor(kAzure);
  esd_muon_track_propagator_setup(ghost->GetPropagator(), kFALSE, kTRUE);
  trackCont->AddElement(ghost);
  
  // cluster container
  TEvePointSet* clusterList = 0x0;
  if (showClusters && (data.GetNClusters() > 0 || gEve->GetKeepEmptyCont()))
  {
    clusterList = new TEvePointSet(10000);
    clusterList->SetName("ESD MUON Clusters");
    clusterList->SetTitle(Form("N=%d",data.GetNClusters()));
    clusterList->SetPickable(kFALSE);
    clusterList->SetMarkerStyle(5);
    clusterList->SetMarkerColor(kYellow);
    clusterList->SetMarkerSize(2.5);
  }

  // digit containers
  TEveElementList* digitCont = 0x0;
  TEveQuadSet* bending = 0x0;
  TEveQuadSet* nonBending = 0x0;
  if (showDigits && (data.GetNDigits() > 0 || gEve->GetKeepEmptyCont()))
  {
    digitCont = new TEveElementList("ESD MUON Digits");
    digitCont->SetTitle(Form("N=%d",data.GetNDigits()));
    
    bending = new TEveQuadSet(TEveQuadSet::kQT_RectangleXY, kFALSE, 32);
    bending->SetName("Bending");
    bending->SetRenderMode(TEveDigitSet::kRM_Fill);
    bending->SetPickable(kFALSE);
    digitCont->AddElement(bending);
    
    nonBending = new TEveQuadSet(TEveQuadSet::kQT_RectangleXY, kFALSE, 32);
    nonBending->SetName("Non bending");
    nonBending->SetRenderMode(TEveDigitSet::kRM_Line);
    nonBending->SetPickable(kFALSE);
    digitCont->AddElement(nonBending);
  }
  
  // add tracks to the proper list and propagate them
  add_esd_muon_tracks(esd, &data, match, nomatch, ghost);
  match->SetTitle(Form("N=%d",match->NumChildren()));
  nomatch->SetTitle(Form("N=%d",nomatch->NumChildren()));
  ghost->SetTitle(Form("N=%d",ghost->NumChildren()));
  match->MakeTracks();
  nomatch->MakeTracks();
  ghost->MakeTracks();
  
  // add cluster to the container
  if (clusterList)
  {
    TEveUtil::LoadMacro("muon_clusters.C+");
    TIter next(data.CreateClusterIterator());
    gROOT->ProcessLine(Form("add_muon_clusters((TIter*)%p, (TEvePointSet*)%p);",&next, clusterList));
  }
  
  // add digits to the containers
  if (digitCont)
  {
    TEveUtil::LoadMacro("muon_digits.C+");
    TIter next(data.CreateDigitIterator());
    gROOT->ProcessLine(Form("add_muon_digits((TIter*)%p, (TEveQuadSet*)%p, (TEveQuadSet*)%p, kFALSE);",
			    &next, bending, nonBending));
    
    // set containers' title
    bending->SetTitle(Form("N=%d",bending->GetPlex()->Size()));
    nonBending->SetTitle(Form("N=%d",nonBending->GetPlex()->Size()));
    
    // automatic scaling
    gStyle->SetPalette(1);
    bending->AssertPalette();
    nonBending->AssertPalette();
  }
  
  // add graphic containers
  gEve->DisableRedraw();
  gEve->AddElement(trackCont);
  if (clusterList) gEve->AddElement(clusterList);
  if (digitCont) gEve->AddElement(digitCont);
  gEve->EnableRedraw();
  gEve->Redraw3D();
}
Commit	Line	Data
39d6561a	1	// $Id$
	2
	3	/**************************************************************************
	4	* Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
	5	* See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
	6	* full copyright notice. *
	7	**************************************************************************/
	8
25b4bdb2	9	/// \ingroup evemacros
	10	/// \file esd_muon_tracks.C
	11	/// \brief Macro to visualise ESD tracks from MUON spectrometer
	12	/// (both tracker and trigger).
	13	///
	14	/// Use esd_muon_tracks(Bool_t showClusters, Bool_t showDigits) in order to run it
	15	///
	16	/// Needs that alieve_init() is already called
	17	///
	18	/// \author P. Pillot, L. Aphecetche; Subatech
39d6561a	19
	20	#if !defined(__CINT__) \|\| defined(__MAKECINT__)
	21
	22	#include "AliMUONESDInterface.h"
	23	#include "AliMUONTrack.h"
	24	#include "AliMUONTrackExtrap.h"
	25	#include "AliMUONTrackParam.h"
	26	#include "AliMUONConstants.h"
	27	#include "AliMUONCDB.h"
	28	#include "AliMUONGeometryTransformer.h"
	29	#include "AliMUONTriggerCircuit.h"
	30
	31	#include "AliMpCDB.h"
	32
	33	#include "AliESDEvent.h"
	34	#include "AliESDMuonTrack.h"
	35
	36	#include "EveBase/AliEveMagField.h"
	37	#include "EveBase/AliEveTrack.h"
	38	#include "EveBase/AliEveEventManager.h"
	39
	40	#include <TEveManager.h>
	41	#include <TEveUtil.h>
	42	#include <TEveTrack.h>
	43	#include <TEvePointSet.h>
	44	#include <TEveQuadSet.h>
	45	#include <TEveTrackPropagator.h>
	46	#include <TEveVSDStructs.h>
	47
	48	#include <TStyle.h>
	49	#include <TROOT.h>
	50
	51	#endif
	52
39d6561a	53	//______________________________________________________________________________
	54	void esd_muon_track_propagator_setup(TEveTrackPropagator* trkProp, Bool_t tracker, Bool_t trigger)
	55	{
	56	// set magnetic field
	57	if (AliMUONTrackExtrap::IsFieldON())
	58	{
	59	trkProp->SetMagFieldObj(new AliEveMagField);
	60	}
	61	else
	62	{
	63	trkProp->SetMagField(0.0);
	64	}
	65	trkProp->SetStepper(TEveTrackPropagator::kRungeKutta);
	66
	67	// set propagation range
	68	trkProp->SetMaxR(1000);
	69	if (trigger) trkProp->SetMaxZ(-AliMUONConstants::DefaultChamberZ(13)+10.);
	70	else trkProp->SetMaxZ(-AliMUONConstants::MuonFilterZBeg());
	71
	72	// go through pathmarks
	73	trkProp->SetFitDaughters(kFALSE);
	74	trkProp->SetFitReferences(kTRUE);
	75	trkProp->SetFitDecay(kFALSE);
	76	trkProp->SetFitCluster2Ds(kFALSE);
	77
	78	// Render the ref pathmarks
	79	trkProp->SetRnrReferences(kTRUE);
	80	trkProp->RefPMAtt().SetMarkerSize(0.5);
	81	if (trigger) trkProp->RefPMAtt().SetMarkerColor(kGreen);
	82	else trkProp->RefPMAtt().SetMarkerColor(kAzure);
	83
	84	// Render first vertex
	85	if (tracker)
	86	{
	87	trkProp->SetRnrFV(kTRUE);
	88	if (trigger) trkProp->RefFVAtt().SetMarkerColor(kGreen);
	89	else trkProp->RefFVAtt().SetMarkerColor(kAzure);
	90	}
	91	}
	92
	93	//______________________________________________________________________________
	94	void add_esd_muon_tracks(AliESDEvent* esd, AliMUONESDInterface* data,
	95	TEveTrackList* match, TEveTrackList* nomatch, TEveTrackList* ghost)
	96	{
2fcde5f6	97	// load trigger circuit
	98	static AliMUONTriggerCircuit* gTriggerCircuit = 0x0;
	99	if (!gTriggerCircuit)
	100	{
	101	AliEveEventManager::AssertGeometry();
	102	AliMUONGeometryTransformer* fMUONGeometryTransformer = new AliMUONGeometryTransformer();
	103	fMUONGeometryTransformer->LoadGeometryData();
	104	gTriggerCircuit = new AliMUONTriggerCircuit(fMUONGeometryTransformer);
	105	}
	106
39d6561a	107	Int_t nTrack(esd->GetNumberOfMuonTracks());
	108	TEveRecTrack recTrack;
	109	TEveTrack* track;
	110
	111	// add ESD tracks to the proper list
	112	for (Int_t n = 0; n < nTrack; ++n)
	113	{
	114	AliESDMuonTrack* emt = esd->GetMuonTrack(n);
	115
	116	// fill general info
	117	UInt_t trackId = emt->GetUniqueID();
	118	recTrack.fLabel = emt->GetLabel();
	119	recTrack.fIndex = (Int_t)trackId;
	120
	121	// fill tracker track specific info
	122	if ( emt->ContainTrackerData() )
	123	{
	124	recTrack.fStatus = emt->GetMatchTrigger();
	125	recTrack.fSign = emt->Charge();
	126	recTrack.fV.Set(emt->GetNonBendingCoorAtDCA(),emt->GetBendingCoorAtDCA(),emt->GetZ());
	127	recTrack.fP.Set(emt->PxAtDCA(),emt->PyAtDCA(),emt->PzAtDCA());
	128	recTrack.fBeta = ( emt->E() > 0 ) ? emt->P()/emt->E() : 0;
	129
	130	// get proper track list
	131	TEveTrackList* trackList = nomatch;
	132	if ( emt->GetMatchTrigger() > 0 ) trackList = match;
	133
	134	// produce eve track
	135	track = new AliEveTrack(&recTrack,trackList->GetPropagator());
	136	track->SetName(Form("%cmu",emt->Charge()>0 ? '+':'-'));
	137	track->SetStdTitle();
	138	track->SetSourceObject(emt); // WARNING: Change the UniqueID of the object!!
	139
	140	// add path mark
	141	TIter next(data->FindTrack(trackId)->GetTrackParamAtCluster());
	142	AliMUONTrackParam* param;
	143	while ( ( param = static_cast<AliMUONTrackParam*>(next()) ) )
	144	{
	145	TEveVector v(param->GetNonBendingCoor(),param->GetBendingCoor(),param->GetZ());
	146	TEveVector p(param->Px(),param->Py(),param->Pz());
	147	track->AddPathMark(TEvePathMark(TEvePathMark::kReference,v,p));
	148	}
	149
	150	// add trigger track if any
	151	if (emt->ContainTriggerData())
	152	{
	153	Double_t x11 = gTriggerCircuit->GetX11Pos(emt->LoCircuit(), emt->LoStripY());
	154	Double_t y11 = gTriggerCircuit->GetY11Pos(emt->LoCircuit(), emt->LoStripX());
d4731f84	155	Double_t z11 = gTriggerCircuit->GetZ11Pos(emt->LoCircuit(), emt->LoStripX());
39d6561a	156	Double_t y21 = gTriggerCircuit->GetY21Pos(emt->LoCircuit(), emt->LoStripX()+emt->LoDev()+1);
d4731f84	157	Double_t z21 = gTriggerCircuit->GetZ21Pos(emt->LoCircuit(), emt->LoStripX()+emt->LoDev()+1);
39d6561a	158	Double_t pz = -emt->PUncorrected(); // max value
	159	TEveVector v(x11, y11, z11);
	160	TEveVector p(pzx11/z11, pz(y21-y11)/(z21-z11), pz);
	161	track->AddPathMark(TEvePathMark(TEvePathMark::kReference,v,p));
	162	}
	163
	164	// add the track to proper list
	165	track->SetAttLineAttMarker(trackList);
	166	trackList->AddElement(track);
	167	}
	168	else // fill ghost track specific info
	169	{
	170	recTrack.fStatus = 0;
	171	recTrack.fSign = emt->Charge();
d4731f84	172	Double_t z11 = (emt->GetZUncorrected() < -1.) ? emt->GetZUncorrected() : (Double_t)AliMUONConstants::DefaultChamberZ(10);
d4731f84	173	recTrack.fV.Set(emt->GetNonBendingCoorUncorrected(),emt->GetBendingCoorUncorrected(),z11);
39d6561a	174	recTrack.fP.Set(-TMath::Tan(emt->GetThetaXUncorrected()),-TMath::Tan(emt->GetThetaYUncorrected()),-1.);
	175
	176	// produce eve track
	177	track = new AliEveTrack(&recTrack,ghost->GetPropagator());
	178	track->SetName("mu");
	179	track->SetTitle("Trigger only");
	180	track->SetSourceObject(emt);
	181
	182	// add the track to proper list
	183	track->SetAttLineAttMarker(ghost);
	184	ghost->AddElement(track);
	185	}
	186
	187	}
	188
	189	}
	190
	191	//______________________________________________________________________________
	192	void esd_muon_tracks(Bool_t showClusters, Bool_t showDigits)
	193	{
	194	// load ESD
	195	AliESDEvent* esd = AliEveEventManager::AssertESD();
	196	if (esd->GetNumberOfMuonTracks() == 0 && !gEve->GetKeepEmptyCont()) return;
	197
	198	// load field
	199	AliEveEventManager::AssertMagField();
	200	if (!AliMUONESDInterface::GetTracker()) AliMUONESDInterface::ResetTracker(AliMUONCDB::LoadRecoParam());
	201
	202	// load mapping
	203	AliMpCDB::LoadAll(kFALSE);
	204
39d6561a	205	// convert ESD objects to MUON objects
	206	AliMUONESDInterface data;
	207	data.LoadEvent(*esd);
	208
	209	// track containers
	210	TEveElementList* trackCont = new TEveElementList("ESD MUON Tracks");
	211	trackCont->SetTitle(Form("N=%d", esd->GetNumberOfMuonTracks()));
	212
	213	TEveTrackList* match = new TEveTrackList("Matched");
	214	match->SetRnrPoints(kFALSE);
	215	match->SetRnrLine(kTRUE);
	216	match->SetLineColor(kGreen);
	217	esd_muon_track_propagator_setup(match->GetPropagator(), kTRUE, kTRUE);
	218	trackCont->AddElement(match);
	219
	220	TEveTrackList* nomatch = new TEveTrackList("Not matched");
	221	nomatch->SetRnrPoints(kFALSE);
	222	nomatch->SetRnrLine(kTRUE);
	223	nomatch->SetLineColor(kAzure);
	224	esd_muon_track_propagator_setup(nomatch->GetPropagator(), kTRUE, kFALSE);
	225	trackCont->AddElement(nomatch);
	226
	227	TEveTrackList* ghost = new TEveTrackList("Ghost");
	228	ghost->SetRnrPoints(kFALSE);
	229	ghost->SetRnrLine(kTRUE);
	230	ghost->SetLineColor(kAzure);
	231	esd_muon_track_propagator_setup(ghost->GetPropagator(), kFALSE, kTRUE);
	232	trackCont->AddElement(ghost);
	233
	234	// cluster container
	235	TEvePointSet* clusterList = 0x0;
	236	if (showClusters && (data.GetNClusters() > 0 \|\| gEve->GetKeepEmptyCont()))
	237	{
	238	clusterList = new TEvePointSet(10000);
	239	clusterList->SetName("ESD MUON Clusters");
	240	clusterList->SetTitle(Form("N=%d",data.GetNClusters()));
	241	clusterList->SetPickable(kFALSE);
	242	clusterList->SetMarkerStyle(5);
	243	clusterList->SetMarkerColor(kYellow);
	244	clusterList->SetMarkerSize(2.5);
	245	}
	246
	247	// digit containers
	248	TEveElementList* digitCont = 0x0;
	249	TEveQuadSet* bending = 0x0;
	250	TEveQuadSet* nonBending = 0x0;
	251	if (showDigits && (data.GetNDigits() > 0 \|\| gEve->GetKeepEmptyCont()))
	252	{
	253	digitCont = new TEveElementList("ESD MUON Digits");
	254	digitCont->SetTitle(Form("N=%d",data.GetNDigits()));
	255
	256	bending = new TEveQuadSet(TEveQuadSet::kQT_RectangleXY, kFALSE, 32);
	257	bending->SetName("Bending");
	258	bending->SetRenderMode(TEveDigitSet::kRM_Fill);
	259	bending->SetPickable(kFALSE);
	260	digitCont->AddElement(bending);
	261
	262	nonBending = new TEveQuadSet(TEveQuadSet::kQT_RectangleXY, kFALSE, 32);
	263	nonBending->SetName("Non bending");
	264	nonBending->SetRenderMode(TEveDigitSet::kRM_Line);
	265	nonBending->SetPickable(kFALSE);
	266	digitCont->AddElement(nonBending);
	267	}
	268
269	// add tracks to the proper list and propagate them
270	add_esd_muon_tracks(esd, &data, match, nomatch, ghost);
271	match->SetTitle(Form("N=%d",match->NumChildren()));
272	nomatch->SetTitle(Form("N=%d",nomatch->NumChildren()));
273	ghost->SetTitle(Form("N=%d",ghost->NumChildren()));
274	match->MakeTracks();
275	nomatch->MakeTracks();
276	ghost->MakeTracks();
277
278	// add cluster to the container
279	if (clusterList)
280	{
281	TEveUtil::LoadMacro("muon_clusters.C+");
282	TIter next(data.CreateClusterIterator());
283	gROOT->ProcessLine(Form("add_muon_clusters((TIter)%p, (TEvePointSet)%p);",&next, clusterList));
284	}
285
286	// add digits to the containers
287	if (digitCont)
288	{
289	TEveUtil::LoadMacro("muon_digits.C+");
290	TIter next(data.CreateDigitIterator());
291	gROOT->ProcessLine(Form("add_muon_digits((TIter)%p, (TEveQuadSet)%p, (TEveQuadSet*)%p, kFALSE);",
292	&next, bending, nonBending));
293
294	// set containers' title
295	bending->SetTitle(Form("N=%d",bending->GetPlex()->Size()));
296	nonBending->SetTitle(Form("N=%d",nonBending->GetPlex()->Size()));
297
298	// automatic scaling
299	gStyle->SetPalette(1);
300	bending->AssertPalette();
301	nonBending->AssertPalette();
302	}
303
304	// add graphic containers
305	gEve->DisableRedraw();
306	gEve->AddElement(trackCont);
307	if (clusterList) gEve->AddElement(clusterList);
308	if (digitCont) gEve->AddElement(digitCont);
309	gEve->EnableRedraw();
310	gEve->Redraw3D();
311	}