[u/mrichter/AliRoot.git] / EVE / EveDet / AliEveEMCALSModule.cxx

//*************************************************************************
// EMCAL event display
// Visualization of an EMCAL super module.
//
//  Author: Magali Estienne (magali.estienne@cern.ch)
//  June 30 2008
//*************************************************************************

#include <Riostream.h>
#include <vector>

#include <TEveTrans.h>
#include <TEveElement.h>
#include <TEveFrameBox.h>
#include <TEveQuadSet.h>
#include <TEvePointSet.h>
#include <TClonesArray.h>
#include <TVectorT.h>
#include <TStyle.h>
#include <TBuffer3DTypes.h>
#include <TBuffer3D.h>
#include <TVirtualPad.h>
#include <TVirtualViewer3D.h>
#include <TEveRGBAPalette.h>

#include "AliEveEMCALData.h"
#include "AliEveEMCALSModule.h"
#include "AliEveEMCALSModuleData.h"
#include "AliEMCALHit.h"
#include "AliEMCALDigit.h"


ClassImp(AliEveEMCALSModule)

Bool_t AliEveEMCALSModule::fStaticInit = kFALSE;

TEveFrameBox*    AliEveEMCALSModule::fFrameBigBox = 0;
TEveFrameBox*    AliEveEMCALSModule::fFrameSmallBox = 0;
TEveRGBAPalette* AliEveEMCALSModule::fFrameDigPalette = 0;
TEveRGBAPalette* AliEveEMCALSModule::fFrameCluPalette = 0;

AliEveEMCALSModule::AliEveEMCALSModule(Int_t smid, const Text_t* n, const Text_t* t) :
  TEveElement(fFrameColor),
  TNamed(n,t),
  TAtt3D(),
  TAttBBox(),
  fEMCALData(0),
  fEMCALSModuleData(0),
  fFrameColor((Color_t)10),
  fRTS(1),
  fSModuleID(smid),
  fQuadSet(new TEveQuadSet(n,t)),
  fQuadSet2(new TEveQuadSet(n,t)),
  fPointSet(new TEvePointSet(n)),
  fThreshold(0),
  fMaxVal(4096),
  fClusterSize(5),
  fHitSize(5),
  fColorArray(0),
  fDebug(0)
{
  // Constructor.
  Char_t name[256];
  if (smid < 10) {
    sprintf(name,"Full Super Module %02d",smid);
  } else {
    sprintf(name,"Half Super Module %02d",smid);
  }
  SetName(name);

  for(Int_t i=0; i<3; i++) fSMBigBBox[i] = 0.;
  for(Int_t i=0; i<3; i++) fSMSmallBBox[i] = 0.;
  for(Int_t i=0; i<3; i++) fSMBBoxCenter[i] = 0.;

  // Hits
  fPointSet->IncDenyDestroy();
  AddElement(fPointSet);
  // Digits
  fQuadSet->IncDenyDestroy();
  AddElement(fQuadSet);
  // Clusters
  fQuadSet2->IncDenyDestroy();
  AddElement(fQuadSet2);

}

AliEveEMCALSModule::AliEveEMCALSModule(const AliEveEMCALSModule &esm) :
  TEveElement(fFrameColor),
  TNamed(),
  TAtt3D(),
  TAttBBox(),
  fEMCALData(esm.fEMCALData),
  fEMCALSModuleData(esm.fEMCALSModuleData),
  fFrameColor(esm.fFrameColor),
  fRTS(esm.fRTS),
  fSModuleID(esm.fSModuleID),
  fQuadSet(esm.fQuadSet),
  fQuadSet2(esm.fQuadSet2),
  fPointSet(esm.fPointSet),
  fThreshold(esm.fThreshold),
  fMaxVal(esm.fMaxVal),
  fClusterSize(esm.fClusterSize),
  fHitSize(esm.fHitSize),
  fColorArray(esm.fColorArray),
  fDebug(esm.fDebug)
{
  // Copy constructor.
  Char_t name[256];
  if (fSModuleID < 10) {
    sprintf(name,"Full Super Module %02d",fSModuleID);
  } else {
    sprintf(name,"Half Super Module %02d",fSModuleID);
  }
  SetName(name);

  for(Int_t i=0; i<3; i++) fSMBigBBox[i] = 0.;
  for(Int_t i=0; i<3; i++) fSMSmallBBox[i] = 0.;
  for(Int_t i=0; i<3; i++) fSMBBoxCenter[i] = 0.;

  // Hits
  fPointSet->IncDenyDestroy();
  AddElement(fPointSet);
  // Digits
  fQuadSet->IncDenyDestroy();
  AddElement(fQuadSet);
  // Clusters
  fQuadSet2->IncDenyDestroy();
  AddElement(fQuadSet2);

}

AliEveEMCALSModule::~AliEveEMCALSModule()
{
  //
  // Destructor.
  //

  fPointSet->DecDenyDestroy();
  fQuadSet->DecDenyDestroy();

  if(fEMCALData) fEMCALData->DecRefCount();
  if(fFrameBigBox)   fFrameBigBox->Delete();
  if(fFrameSmallBox) fFrameSmallBox->Delete();
  if(fFrameDigPalette) fFrameDigPalette->Delete();
  if(fFrameCluPalette) fFrameCluPalette->Delete();

}

//______________________________________________________________________________
void AliEveEMCALSModule::DropData()
{
  //
  // release the sm data
  //

//   fNDigits   = 0;
//   fNClusters = 0;
//   fNHits     = 0;

  return;

}

//______________________________________________________________________________
void AliEveEMCALSModule::ComputeBBox()
{
  //
  // Bounding box, Framebox and Palette
  //

  fEMCALSModuleData->GetSModuleBigBox(fSMBigBBox[0],fSMBigBBox[1], fSMBigBBox[2]);
  fEMCALSModuleData->GetSModuleSmallBox(fSMSmallBBox[0],fSMSmallBBox[1], fSMSmallBBox[2]);

  if (fStaticInit) return;
  fStaticInit = kTRUE;

  fFrameBigBox = new TEveFrameBox();
  fFrameBigBox->SetAABoxCenterHalfSize(0, 0, 0, fSMBigBBox[0], fSMBigBBox[1], fSMBigBBox[2]);
  fFrameBigBox->SetFrameColor((Color_t)10);
  fFrameDigPalette = new TEveRGBAPalette(0,512);
  fFrameDigPalette->SetLimits(0, 1024);
  fFrameDigPalette->IncRefCount();

  fFrameSmallBox = new TEveFrameBox();
  fFrameSmallBox->SetAABoxCenterHalfSize(0, 0, 0, fSMSmallBBox[0], fSMSmallBBox[1], fSMSmallBBox[2]);
  fFrameSmallBox->SetFrameColor((Color_t)10);
  fFrameCluPalette  = new TEveRGBAPalette(0,512);
  fFrameCluPalette->SetLimits(0, 1024);
  fFrameCluPalette->IncRefCount();

  BBoxInit();

  fBBox[0] = - 2*fSMBigBBox[0];
  fBBox[1] = + 2*fSMBigBBox[0];
  fBBox[2] = - 2*fSMBigBBox[1];
  fBBox[3] = + 2*fSMBigBBox[1];
  fBBox[4] = - 2*fSMBigBBox[2];
  fBBox[5] = + 2*fSMBigBBox[2];

}

//______________________________________________________________________________
void AliEveEMCALSModule::SetThreshold(Short_t t)
{
  //
  // Digit amplitude threshold
  //

  fThreshold = TMath::Min(t, (Short_t)(fMaxVal - 1));
  ClearColorArray();
  IncRTS();

}

//______________________________________________________________________________
void AliEveEMCALSModule::SetMaxVal(Int_t mv)
{
  //
  // Digit amplitude maximum value
  //

  fMaxVal = TMath::Max(mv, (Int_t)(fThreshold + 1));
  ClearColorArray();
  IncRTS();

}

//______________________________________________________________________________
void AliEveEMCALSModule::SetClusterSize(Int_t size)
{
  //
  // Cluster point size
  //

  fClusterSize = TMath::Max(1, size);
  IncRTS();

}

//______________________________________________________________________________
void AliEveEMCALSModule::SetHitSize(Int_t size)
{
  //
  // hit point size
  //

  fHitSize = TMath::Max(1, size);
  IncRTS();

}

//______________________________________________________________________________
void AliEveEMCALSModule::SetupColor(Int_t val, UChar_t* pixel) const
{
  //
  // RGBA color for amplitude "val"
  //

  Float_t div  = TMath::Max(1, fMaxVal - fThreshold);
  Int_t   nCol = gStyle->GetNumberOfColors();
  Int_t   cBin = (Int_t) TMath::Nint(nCol*(val - fThreshold)/div);

  TEveUtil::TEveUtil::ColorFromIdx(gStyle->GetColorPalette(TMath::Min(nCol - 1, cBin)), pixel);

}

//______________________________________________________________________________
Int_t AliEveEMCALSModule::ColorIndex(Int_t val) const
{
  //
  // Index color
  //

  if(val < fThreshold) val = fThreshold;
  if(val > fMaxVal)    val = fMaxVal;

  Float_t div  = TMath::Max(1, fMaxVal - fThreshold);
  Int_t   nCol = gStyle->GetNumberOfColors();
  Int_t   cBin = (Int_t) TMath::Nint(nCol*(val - fThreshold)/div);

  return gStyle->GetColorPalette(TMath::Min(nCol - 1, cBin));

}

//______________________________________________________________________________
void AliEveEMCALSModule::SetupColorArray() const
{
  //
  // Build array of colors
  //

  if(fColorArray)
    return;

  fColorArray = new UChar_t [4 * (fMaxVal - fThreshold + 1)];
  UChar_t* p = fColorArray;
  for(Int_t v=fThreshold; v<=fMaxVal; ++v, p+=4)
    SetupColor(v, p);

}

//______________________________________________________________________________
void AliEveEMCALSModule::ClearColorArray()
{
  //
  // Delete array of colors
  //

  if(fColorArray) {
    delete [] fColorArray;
    fColorArray = 0;
  }
}

//______________________________________________________________________________
void AliEveEMCALSModule::SetDataSource(AliEveEMCALData* data)
{
  //
  // Set source of data.
  //

  if (data == fEMCALData) return;
  if(fEMCALData) fEMCALData->DecRefCount();
  fEMCALData = data;
  if(fEMCALData) fEMCALData->IncRefCount();

  // Get pointer on SM data
  fEMCALSModuleData = GetSModuleData();

  IncRTS();
}

//______________________________________________________________________________
AliEveEMCALSModuleData* AliEveEMCALSModule::GetSModuleData() const
{
  //
  // Return source of data.
  //

  return fEMCALData ? fEMCALData->GetSModuleData(fSModuleID) : 0;
}

//______________________________________________________________________________
void AliEveEMCALSModule::UpdateQuads()
{
  //
  // Update hit/digit/cluster representation.
  //

  vector< vector<Double_t> > bufferDigit;
  vector< vector<Double_t> > bufferCluster;
  vector< vector<Float_t> > bufferHit;
  Int_t nDigits, nClusters, nHits, oldSize;
  Float_t hitX, hitY, hitZ;
  Int_t smId = fEMCALSModuleData->GetSmId();

  //--------------------------
  // Hits from runloader
  //--------------------------
  fPointSet->Reset();

  /*
  TEvePointSet* points = fEMCALData->GetPointSetData();
  char form[1000];
  if(points){
    sprintf(form,"N=%d", points->Size());
    points->SetTitle(form);
    points->SetMarkerSize(.5);
    points->SetMarkerColor((Color_t)2);
    fPointSet->AddElement(points);
  }
  else {printf("There is no hits in Runloader \n"); }
  
  */

  if (fEMCALSModuleData != 0) {
    
    // digits ------------------------

    // Define TEveQuadSet for digits
    fQuadSet->SetOwnIds(kTRUE);
    fQuadSet->Reset(TEveQuadSet::kQT_RectangleYZFixedDimX, kFALSE, 32);
    fQuadSet->SetDefWidth (fEMCALSModuleData->GetPhiTileSize());
    fQuadSet->SetDefHeight(fEMCALSModuleData->GetEtaTileSize());
    fQuadSet->RefMainTrans().SetFrom(*fEMCALSModuleData->GetSModuleMatrix());
    fQuadSet->SetPalette(fFrameDigPalette);
    if(smId<fEMCALSModuleData->GetNsmf()) 
      fQuadSet->SetFrame(fFrameBigBox);
    else fQuadSet->SetFrame(fFrameSmallBox);

    // Get the digit information from the buffer
    bufferDigit = fEMCALSModuleData->GetDigitBuffer();
    if(!bufferDigit.empty())
      {
	nDigits = fEMCALSModuleData->GetNDigits();
	if(fDebug>1) cout << "nDigits: " << nDigits << endl;
	// loop over digits
	for (Int_t id = 0; id < nDigits; id++) {
	  //	  Int_t iid = (Int_t)bufferDigit[id][0];
	  //	  Int_t isupMod = (Int_t)bufferDigit[id][1];
	  Double_t iamp = bufferDigit[id][2];
	  Int_t amp = (Int_t)(iamp+0.5);
	  //	  Double_t ix = bufferDigit[id][3];
	  Double_t iy = bufferDigit[id][4];
	  Double_t iz = bufferDigit[id][5];
	  
	  // Add digit information to the TEveQuadSet
	  fQuadSet->AddQuad(iy, iz);
	  fQuadSet->QuadValue(amp);
	} // end digits loop
      }
    else { printf("There is no digits in SM %d \n", smId); }

    // hits --------------------------
    bufferHit = fEMCALSModuleData->GetHitBuffer();
    if(!bufferHit.empty())
      {
	char form[1000];
	nHits = fEMCALSModuleData->GetNHits();
	if(fDebug>1) cout << "nHits: " << nHits << endl;
	oldSize = fPointSet->GrowFor(nHits);
	// Loop over hits
	for (Int_t ih = 0; ih < nHits; ih++) {
	  hitX = bufferHit[ih][3];
	  hitY = bufferHit[ih][4];
	  hitZ = bufferHit[ih][5];
	  fPointSet->SetPoint(ih,hitX,hitY,hitZ);
	  sprintf(form,"N=%d", fPointSet->Size());
	  fPointSet->SetTitle(form);
	  fPointSet->SetMarkerSize(.5);
	  fPointSet->SetMarkerColor((Color_t)2);
	}
      }
    else {printf("There is no hits in SM %d \n", smId); }

    // clusters ------------------------

    // Define TEveQuadSet for clusters
    fQuadSet2->SetOwnIds(kTRUE);
    fQuadSet2->Reset(TEveQuadSet::kQT_RectangleYZFixedDimX, kFALSE, 32);
    fQuadSet2->SetDefWidth (fEMCALSModuleData->GetPhiTileSize());
    fQuadSet2->SetDefHeight(fEMCALSModuleData->GetEtaTileSize());
    fQuadSet2->RefMainTrans().SetFrom(*fEMCALSModuleData->GetSModuleMatrix());
    fQuadSet2->SetPalette(fFrameCluPalette);
    if(smId<fEMCALSModuleData->GetNsmf()) 
      fQuadSet2->SetFrame(fFrameBigBox);
    else fQuadSet2->SetFrame(fFrameSmallBox);

    // Get the cluster information from the buffer
    bufferCluster = fEMCALSModuleData->GetClusterBuffer();
    if(!bufferCluster.empty())
      {
	nClusters = fEMCALSModuleData->GetNClusters();
	if(fDebug>1) cout << "nClusters: " << nClusters << endl;
	// loop over clusters
	for (Int_t id = 0; id < nClusters; id++) {
	  if(fDebug>1) {
	    cout << "bufferCluster[" << id << "][0]: " << bufferCluster[id][0] << endl;
	    cout << "bufferCluster[" << id << "][1]: " << bufferCluster[id][1] << endl;
	    cout << "bufferCluster[" << id << "][2]: " << bufferCluster[id][2] << endl;
	    cout << "bufferCluster[" << id << "][3]: " << bufferCluster[id][3] << endl;
	    cout << "bufferCluster[" << id << "][4]: " << bufferCluster[id][4] << endl;
	  }
	  //	  Int_t isupMod = (Int_t)bufferCluster[id][0];
	  Double_t iamp = bufferCluster[id][1];
	  Int_t amp = (Int_t)(iamp+0.5);
	  //	  Double_t ix = bufferCluster[id][2];
	  Double_t iy = bufferCluster[id][3];
	  Double_t iz = bufferCluster[id][4];
	  
	  // Add cluster information to the TEveQuadSet
	  fQuadSet2->AddQuad(iy, iz);
	  fQuadSet2->QuadValue(amp);
	  //      fQuadSet2->QuadId(iid);

	} // end clusters loop
      }
    else { printf("There is no clusters in SM %d \n", smId); }

  } // end if (fEMCALSModuleData != 0)

}

//______________________________________________________________________________
void AliEveEMCALSModule::SetSModuleID(Int_t id)
{
  //
  // Set id of the SM to display.
  //

  if (id <  0) id = 0;
  if (id > 12) id = 12;

  fSModuleID = id;
  IncRTS();
}
Commit	Line	Data
c3e34498	1	//*************************************************************************
	2	// EMCAL event display
	3	// Visualization of an EMCAL super module.
	4	//
	5	// Author: Magali Estienne (magali.estienne@cern.ch)
	6	// June 30 2008
	7	//*************************************************************************
	8
	9	#include <Riostream.h>
	10	#include <vector>
	11
	12	#include <TEveTrans.h>
	13	#include <TEveElement.h>
	14	#include <TEveFrameBox.h>
	15	#include <TEveQuadSet.h>
	16	#include <TEvePointSet.h>
	17	#include <TClonesArray.h>
	18	#include <TVectorT.h>
	19	#include <TStyle.h>
	20	#include <TBuffer3DTypes.h>
	21	#include <TBuffer3D.h>
	22	#include <TVirtualPad.h>
	23	#include <TVirtualViewer3D.h>
	24	#include <TEveRGBAPalette.h>
	25
	26	#include "AliEveEMCALData.h"
	27	#include "AliEveEMCALSModule.h"
	28	#include "AliEveEMCALSModuleData.h"
	29	#include "AliEMCALHit.h"
	30	#include "AliEMCALDigit.h"
	31
	32
	33	ClassImp(AliEveEMCALSModule)
	34
a312477b	35	Bool_t AliEveEMCALSModule::fStaticInit = kFALSE;
a312477b	36
c3e34498	37	TEveFrameBox* AliEveEMCALSModule::fFrameBigBox = 0;
	38	TEveFrameBox* AliEveEMCALSModule::fFrameSmallBox = 0;
	39	TEveRGBAPalette* AliEveEMCALSModule::fFrameDigPalette = 0;
	40	TEveRGBAPalette* AliEveEMCALSModule::fFrameCluPalette = 0;
	41
	42	AliEveEMCALSModule::AliEveEMCALSModule(Int_t smid, const Text_t* n, const Text_t* t) :
	43	TEveElement(fFrameColor),
	44	TNamed(n,t),
a312477b	45	TAtt3D(),
a312477b	46	TAttBBox(),
c3e34498	47	fEMCALData(0),
	48	fEMCALSModuleData(0),
	49	fFrameColor((Color_t)10),
	50	fRTS(1),
	51	fSModuleID(smid),
	52	fQuadSet(new TEveQuadSet(n,t)),
	53	fQuadSet2(new TEveQuadSet(n,t)),
	54	fPointSet(new TEvePointSet(n)),
	55	fThreshold(0),
	56	fMaxVal(4096),
	57	fClusterSize(5),
	58	fHitSize(5),
	59	fColorArray(0),
	60	fDebug(0)
	61	{
	62	// Constructor.
	63	Char_t name[256];
	64	if (smid < 10) {
	65	sprintf(name,"Full Super Module %02d",smid);
	66	} else {
	67	sprintf(name,"Half Super Module %02d",smid);
	68	}
	69	SetName(name);
	70
	71	for(Int_t i=0; i<3; i++) fSMBigBBox[i] = 0.;
	72	for(Int_t i=0; i<3; i++) fSMSmallBBox[i] = 0.;
	73	for(Int_t i=0; i<3; i++) fSMBBoxCenter[i] = 0.;
	74
	75	// Hits
	76	fPointSet->IncDenyDestroy();
	77	AddElement(fPointSet);
	78	// Digits
	79	fQuadSet->IncDenyDestroy();
	80	AddElement(fQuadSet);
	81	// Clusters
	82	fQuadSet2->IncDenyDestroy();
	83	AddElement(fQuadSet2);
	84
	85	}
	86
	87	AliEveEMCALSModule::AliEveEMCALSModule(const AliEveEMCALSModule &esm) :
	88	TEveElement(fFrameColor),
	89	TNamed(),
a312477b	90	TAtt3D(),
a312477b	91	TAttBBox(),
c3e34498	92	fEMCALData(esm.fEMCALData),
	93	fEMCALSModuleData(esm.fEMCALSModuleData),
	94	fFrameColor(esm.fFrameColor),
	95	fRTS(esm.fRTS),
	96	fSModuleID(esm.fSModuleID),
	97	fQuadSet(esm.fQuadSet),
	98	fQuadSet2(esm.fQuadSet2),
	99	fPointSet(esm.fPointSet),
	100	fThreshold(esm.fThreshold),
	101	fMaxVal(esm.fMaxVal),
	102	fClusterSize(esm.fClusterSize),
	103	fHitSize(esm.fHitSize),
	104	fColorArray(esm.fColorArray),
	105	fDebug(esm.fDebug)
	106	{
a312477b	107	// Copy constructor.
c3e34498	108	Char_t name[256];
	109	if (fSModuleID < 10) {
	110	sprintf(name,"Full Super Module %02d",fSModuleID);
	111	} else {
	112	sprintf(name,"Half Super Module %02d",fSModuleID);
	113	}
	114	SetName(name);
	115
	116	for(Int_t i=0; i<3; i++) fSMBigBBox[i] = 0.;
	117	for(Int_t i=0; i<3; i++) fSMSmallBBox[i] = 0.;
	118	for(Int_t i=0; i<3; i++) fSMBBoxCenter[i] = 0.;
	119
	120	// Hits
	121	fPointSet->IncDenyDestroy();
	122	AddElement(fPointSet);
	123	// Digits
	124	fQuadSet->IncDenyDestroy();
	125	AddElement(fQuadSet);
	126	// Clusters
	127	fQuadSet2->IncDenyDestroy();
	128	AddElement(fQuadSet2);
	129
	130	}
	131
	132	AliEveEMCALSModule::~AliEveEMCALSModule()
	133	{
	134	//
	135	// Destructor.
	136	//
	137
	138	fPointSet->DecDenyDestroy();
	139	fQuadSet->DecDenyDestroy();
	140
	141	if(fEMCALData) fEMCALData->DecRefCount();
	142	if(fFrameBigBox) fFrameBigBox->Delete();
	143	if(fFrameSmallBox) fFrameSmallBox->Delete();
	144	if(fFrameDigPalette) fFrameDigPalette->Delete();
	145	if(fFrameCluPalette) fFrameCluPalette->Delete();
	146
	147	}
	148
	149	//______________________________________________________________________________
	150	void AliEveEMCALSModule::DropData()
	151	{
	152	//
	153	// release the sm data
	154	//
	155
	156	// fNDigits = 0;
	157	// fNClusters = 0;
	158	// fNHits = 0;
	159
	160	return;
	161
	162	}
	163
	164	//______________________________________________________________________________
	165	void AliEveEMCALSModule::ComputeBBox()
	166	{
	167	//
a312477b	168	// Bounding box, Framebox and Palette
c3e34498	169	//
	170
	171	fEMCALSModuleData->GetSModuleBigBox(fSMBigBBox[0],fSMBigBBox[1], fSMBigBBox[2]);
	172	fEMCALSModuleData->GetSModuleSmallBox(fSMSmallBBox[0],fSMSmallBBox[1], fSMSmallBBox[2]);
	173
a312477b	174	if (fStaticInit) return;
a312477b	175	fStaticInit = kTRUE;
c3e34498	176
	177	fFrameBigBox = new TEveFrameBox();
	178	fFrameBigBox->SetAABoxCenterHalfSize(0, 0, 0, fSMBigBBox[0], fSMBigBBox[1], fSMBigBBox[2]);
	179	fFrameBigBox->SetFrameColor((Color_t)10);
	180	fFrameDigPalette = new TEveRGBAPalette(0,512);
	181	fFrameDigPalette->SetLimits(0, 1024);
	182	fFrameDigPalette->IncRefCount();
	183
	184	fFrameSmallBox = new TEveFrameBox();
	185	fFrameSmallBox->SetAABoxCenterHalfSize(0, 0, 0, fSMSmallBBox[0], fSMSmallBBox[1], fSMSmallBBox[2]);
	186	fFrameSmallBox->SetFrameColor((Color_t)10);
	187	fFrameCluPalette = new TEveRGBAPalette(0,512);
	188	fFrameCluPalette->SetLimits(0, 1024);
	189	fFrameCluPalette->IncRefCount();
	190
	191	BBoxInit();
	192
	193	fBBox[0] = - 2*fSMBigBBox[0];
	194	fBBox[1] = + 2*fSMBigBBox[0];
	195	fBBox[2] = - 2*fSMBigBBox[1];
	196	fBBox[3] = + 2*fSMBigBBox[1];
	197	fBBox[4] = - 2*fSMBigBBox[2];
	198	fBBox[5] = + 2*fSMBigBBox[2];
	199
	200	}
	201
	202	//______________________________________________________________________________
	203	void AliEveEMCALSModule::SetThreshold(Short_t t)
	204	{
	205	//
a312477b	206	// Digit amplitude threshold
c3e34498	207	//
	208
	209	fThreshold = TMath::Min(t, (Short_t)(fMaxVal - 1));
	210	ClearColorArray();
	211	IncRTS();
	212
	213	}
	214
	215	//______________________________________________________________________________
	216	void AliEveEMCALSModule::SetMaxVal(Int_t mv)
	217	{
	218	//
a312477b	219	// Digit amplitude maximum value
c3e34498	220	//
	221
	222	fMaxVal = TMath::Max(mv, (Int_t)(fThreshold + 1));
	223	ClearColorArray();
	224	IncRTS();
	225
	226	}
	227
	228	//______________________________________________________________________________
	229	void AliEveEMCALSModule::SetClusterSize(Int_t size)
	230	{
	231	//
a312477b	232	// Cluster point size
c3e34498	233	//
	234
	235	fClusterSize = TMath::Max(1, size);
	236	IncRTS();
	237
	238	}
	239
	240	//______________________________________________________________________________
	241	void AliEveEMCALSModule::SetHitSize(Int_t size)
	242	{
	243	//
	244	// hit point size
	245	//
	246
	247	fHitSize = TMath::Max(1, size);
	248	IncRTS();
	249
	250	}
	251
	252	//______________________________________________________________________________
	253	void AliEveEMCALSModule::SetupColor(Int_t val, UChar_t* pixel) const
	254	{
	255	//
	256	// RGBA color for amplitude "val"
	257	//
	258
	259	Float_t div = TMath::Max(1, fMaxVal - fThreshold);
	260	Int_t nCol = gStyle->GetNumberOfColors();
	261	Int_t cBin = (Int_t) TMath::Nint(nCol*(val - fThreshold)/div);
	262
	263	TEveUtil::TEveUtil::ColorFromIdx(gStyle->GetColorPalette(TMath::Min(nCol - 1, cBin)), pixel);
	264
	265	}
	266
	267	//______________________________________________________________________________
	268	Int_t AliEveEMCALSModule::ColorIndex(Int_t val) const
	269	{
	270	//
a312477b	271	// Index color
c3e34498	272	//
	273
	274	if(val < fThreshold) val = fThreshold;
	275	if(val > fMaxVal) val = fMaxVal;
	276
	277	Float_t div = TMath::Max(1, fMaxVal - fThreshold);
	278	Int_t nCol = gStyle->GetNumberOfColors();
	279	Int_t cBin = (Int_t) TMath::Nint(nCol*(val - fThreshold)/div);
	280
	281	return gStyle->GetColorPalette(TMath::Min(nCol - 1, cBin));
	282
	283	}
	284
	285	//______________________________________________________________________________
	286	void AliEveEMCALSModule::SetupColorArray() const
	287	{
	288	//
a312477b	289	// Build array of colors
c3e34498	290	//
	291
	292	if(fColorArray)
	293	return;
	294
	295	fColorArray = new UChar_t [4 * (fMaxVal - fThreshold + 1)];
	296	UChar_t* p = fColorArray;
	297	for(Int_t v=fThreshold; v<=fMaxVal; ++v, p+=4)
	298	SetupColor(v, p);
	299
	300	}
	301
	302	//______________________________________________________________________________
	303	void AliEveEMCALSModule::ClearColorArray()
	304	{
	305	//
a312477b	306	// Delete array of colors
c3e34498	307	//
	308
	309	if(fColorArray) {
	310	delete [] fColorArray;
	311	fColorArray = 0;
	312	}
	313	}
	314
	315	//______________________________________________________________________________
	316	void AliEveEMCALSModule::SetDataSource(AliEveEMCALData* data)
	317	{
a312477b	318	//
c3e34498	319	// Set source of data.
a312477b	320	//
c3e34498	321
	322	if (data == fEMCALData) return;
	323	if(fEMCALData) fEMCALData->DecRefCount();
	324	fEMCALData = data;
	325	if(fEMCALData) fEMCALData->IncRefCount();
	326
a312477b	327	// Get pointer on SM data
c3e34498	328	fEMCALSModuleData = GetSModuleData();
	329
	330	IncRTS();
	331	}
	332
	333	//______________________________________________________________________________
	334	AliEveEMCALSModuleData* AliEveEMCALSModule::GetSModuleData() const
	335	{
a312477b	336	//
c3e34498	337	// Return source of data.
a312477b	338	//
c3e34498	339
	340	return fEMCALData ? fEMCALData->GetSModuleData(fSModuleID) : 0;
	341	}
	342
	343	//______________________________________________________________________________
	344	void AliEveEMCALSModule::UpdateQuads()
	345	{
a312477b	346	//
c3e34498	347	// Update hit/digit/cluster representation.
a312477b	348	//
c3e34498	349
a312477b	350	vector< vector<Double_t> > bufferDigit;
a312477b	351	vector< vector<Double_t> > bufferCluster;
c3e34498	352	vector< vector<Float_t> > bufferHit;
a312477b	353	Int_t nDigits, nClusters, nHits, oldSize;
c3e34498	354	Float_t hitX, hitY, hitZ;
	355	Int_t smId = fEMCALSModuleData->GetSmId();
	356
	357	//--------------------------
	358	// Hits from runloader
	359	//--------------------------
	360	fPointSet->Reset();
	361
a312477b	362	/*
c3e34498	363	TEvePointSet* points = fEMCALData->GetPointSetData();
	364	char form[1000];
	365	if(points){
	366	sprintf(form,"N=%d", points->Size());
	367	points->SetTitle(form);
	368	points->SetMarkerSize(.5);
	369	points->SetMarkerColor((Color_t)2);
	370	fPointSet->AddElement(points);
	371	}
	372	else {printf("There is no hits in Runloader \n"); }
	373
a312477b	374	*/
a312477b	375
c3e34498	376	if (fEMCALSModuleData != 0) {
	377
	378	// digits ------------------------
a312477b	379
a312477b	380	// Define TEveQuadSet for digits
c3e34498	381	fQuadSet->SetOwnIds(kTRUE);
	382	fQuadSet->Reset(TEveQuadSet::kQT_RectangleYZFixedDimX, kFALSE, 32);
	383	fQuadSet->SetDefWidth (fEMCALSModuleData->GetPhiTileSize());
	384	fQuadSet->SetDefHeight(fEMCALSModuleData->GetEtaTileSize());
	385	fQuadSet->RefMainTrans().SetFrom(*fEMCALSModuleData->GetSModuleMatrix());
	386	fQuadSet->SetPalette(fFrameDigPalette);
	387	if(smId<fEMCALSModuleData->GetNsmf())
	388	fQuadSet->SetFrame(fFrameBigBox);
	389	else fQuadSet->SetFrame(fFrameSmallBox);
	390
a312477b	391	// Get the digit information from the buffer
c3e34498	392	bufferDigit = fEMCALSModuleData->GetDigitBuffer();
	393	if(!bufferDigit.empty())
	394	{
	395	nDigits = fEMCALSModuleData->GetNDigits();
	396	if(fDebug>1) cout << "nDigits: " << nDigits << endl;
	397	// loop over digits
	398	for (Int_t id = 0; id < nDigits; id++) {
a312477b	399	// Int_t iid = (Int_t)bufferDigit[id][0];
	400	// Int_t isupMod = (Int_t)bufferDigit[id][1];
	401	Double_t iamp = bufferDigit[id][2];
	402	Int_t amp = (Int_t)(iamp+0.5);
	403	// Double_t ix = bufferDigit[id][3];
	404	Double_t iy = bufferDigit[id][4];
	405	Double_t iz = bufferDigit[id][5];
c3e34498	406
a312477b	407	// Add digit information to the TEveQuadSet
c3e34498	408	fQuadSet->AddQuad(iy, iz);
a312477b	409	fQuadSet->QuadValue(amp);
c3e34498	410	} // end digits loop
	411	}
	412	else { printf("There is no digits in SM %d \n", smId); }
	413
	414	// hits --------------------------
a312477b	415	bufferHit = fEMCALSModuleData->GetHitBuffer();
c3e34498	416	if(!bufferHit.empty())
c3e34498	417	{
a312477b	418	char form[1000];
c3e34498	419	nHits = fEMCALSModuleData->GetNHits();
	420	if(fDebug>1) cout << "nHits: " << nHits << endl;
	421	oldSize = fPointSet->GrowFor(nHits);
	422	// Loop over hits
	423	for (Int_t ih = 0; ih < nHits; ih++) {
a312477b	424	hitX = bufferHit[ih][3];
	425	hitY = bufferHit[ih][4];
	426	hitZ = bufferHit[ih][5];
c3e34498	427	fPointSet->SetPoint(ih,hitX,hitY,hitZ);
a312477b	428	sprintf(form,"N=%d", fPointSet->Size());
	429	fPointSet->SetTitle(form);
	430	fPointSet->SetMarkerSize(.5);
	431	fPointSet->SetMarkerColor((Color_t)2);
c3e34498	432	}
	433	}
	434	else {printf("There is no hits in SM %d \n", smId); }
	435
	436	// clusters ------------------------
a312477b	437
a312477b	438	// Define TEveQuadSet for clusters
c3e34498	439	fQuadSet2->SetOwnIds(kTRUE);
	440	fQuadSet2->Reset(TEveQuadSet::kQT_RectangleYZFixedDimX, kFALSE, 32);
	441	fQuadSet2->SetDefWidth (fEMCALSModuleData->GetPhiTileSize());
	442	fQuadSet2->SetDefHeight(fEMCALSModuleData->GetEtaTileSize());
	443	fQuadSet2->RefMainTrans().SetFrom(*fEMCALSModuleData->GetSModuleMatrix());
	444	fQuadSet2->SetPalette(fFrameCluPalette);
	445	if(smId<fEMCALSModuleData->GetNsmf())
	446	fQuadSet2->SetFrame(fFrameBigBox);
	447	else fQuadSet2->SetFrame(fFrameSmallBox);
	448
a312477b	449	// Get the cluster information from the buffer
c3e34498	450	bufferCluster = fEMCALSModuleData->GetClusterBuffer();
	451	if(!bufferCluster.empty())
	452	{
	453	nClusters = fEMCALSModuleData->GetNClusters();
	454	if(fDebug>1) cout << "nClusters: " << nClusters << endl;
	455	// loop over clusters
	456	for (Int_t id = 0; id < nClusters; id++) {
	457	if(fDebug>1) {
	458	cout << "bufferCluster[" << id << "][0]: " << bufferCluster[id][0] << endl;
	459	cout << "bufferCluster[" << id << "][1]: " << bufferCluster[id][1] << endl;
	460	cout << "bufferCluster[" << id << "][2]: " << bufferCluster[id][2] << endl;
	461	cout << "bufferCluster[" << id << "][3]: " << bufferCluster[id][3] << endl;
	462	cout << "bufferCluster[" << id << "][4]: " << bufferCluster[id][4] << endl;
	463	}
a312477b	464	// Int_t isupMod = (Int_t)bufferCluster[id][0];
	465	Double_t iamp = bufferCluster[id][1];
	466	Int_t amp = (Int_t)(iamp+0.5);
	467	// Double_t ix = bufferCluster[id][2];
	468	Double_t iy = bufferCluster[id][3];
	469	Double_t iz = bufferCluster[id][4];
c3e34498	470
a312477b	471	// Add cluster information to the TEveQuadSet
c3e34498	472	fQuadSet2->AddQuad(iy, iz);
a312477b	473	fQuadSet2->QuadValue(amp);
c3e34498	474	// fQuadSet2->QuadId(iid);
	475
	476	} // end clusters loop
	477	}
	478	else { printf("There is no clusters in SM %d \n", smId); }
	479
	480	} // end if (fEMCALSModuleData != 0)
	481
	482	}
	483
	484	//______________________________________________________________________________
	485	void AliEveEMCALSModule::SetSModuleID(Int_t id)
	486	{
a312477b	487	//
	488	// Set id of the SM to display.
	489	//
c3e34498	490
	491	if (id < 0) id = 0;
	492	if (id > 12) id = 12;
	493
	494	fSModuleID = id;
	495	IncRTS();
	496	}