[u/mrichter/AliRoot.git] / EVE / Alieve / ITSModule.cxx

#include "ITSModule.h"

#include <AliITSdigitSPD.h>
#include <AliITSdigitSDD.h>
#include <AliITSdigitSSD.h>

#include <TStyle.h>

using namespace Reve;
using namespace Alieve;
using namespace std;

Short_t ITSModule::fgSDDThreshold  = 5;
Short_t ITSModule::fgSDDMaxVal     = 80;
Short_t ITSModule::fgSSDThreshold  = 2;
Short_t ITSModule::fgSSDMaxVal     = 100;

ClassImp(ITSModule)

/**************************************************************************/

ITSModule::ITSModule(const Text_t* n, const Text_t* t, Color_t col) :
  Reve::RenderElement(fFrameColor),
  QuadSet(n, t),
  fInfo(0),
  fID(-1), fDetID(-1),
  fLayer(-1), fLadder(-1), fDet(-1),
  fDx(0), fDz(0), fDy(0),
  fFrameColor(col)
{}

ITSModule::ITSModule(Int_t id, ITSDigitsInfo* info, Color_t col) :
  Reve::RenderElement(fFrameColor),
  QuadSet(Form("ITS module %d", id)),
  fInfo  (0),
  fID(-1), fDetID(-1),
  fLayer(-1), fLadder(-1), fDet(-1),
  fDx(0), fDz(0), fDy(0),
  fFrameColor(col)
{
  SetDigitsInfo(info);
  SetID(id);
}

ITSModule::~ITSModule()
{
  if(fInfo) fInfo->DecRefCount();
}

/**************************************************************************/

void ITSModule::SetMainColor(Color_t col)
{
  Reve::RenderElement::SetMainColor(col);
  if(!fQuads.empty()) {
    fQuads.front().ColorFromIdx(col);
  }
}

/**************************************************************************/

void ITSModule::SetDigitsInfo(ITSDigitsInfo* info)
{
  if(fInfo) fInfo->DecRefCount();
  fInfo = info;
  if(fInfo) fInfo->IncRefCount();
}

void ITSModule::SetID(Int_t id)
{
  static const Exc_t eH("ITSModule::SetID ");

  if(fInfo == 0)
    throw(eH + "ITSDigitsInfo not set.");

  if (id < fInfo->fGeom->GetStartSPD() || id > fInfo->fGeom->GetLastSSD())
    throw(eH + Form("%d is not valid. ID range from %d to %d", id,
		     fInfo->fGeom->GetStartSPD(), fInfo->fGeom->GetLastSSD()));

  fID = id;
  InitModule();
}

/**************************************************************************/

void ITSModule::InitModule()
{
  fInfo->fGeom->GetModuleId(fID,fLayer,fLadder,fDet);
  SetName(Form("ITSModule %d", fID));

  if (fID <= fInfo->fGeom->GetLastSPD()) {
    fDetID = 0;
    fDx = fInfo->fSegSPD->Dx()*0.00005;
    fDz = 3.48; 
    fDy = fInfo->fSegSPD->Dy()*0.00005;
  }
  else if (fID <= fInfo->fGeom->GetLastSDD()) {
    fDetID = 1;
    fDx = fInfo->fSegSDD->Dx()*0.0001;
    fDz = fInfo->fSegSDD->Dz()*0.00005;
    fDy = fInfo->fSegSDD->Dy()*0.00005;
  }
  else {
    fDetID = 2;
    fInfo->fSegSSD->SetLayer(fLayer);  
    fDx = fInfo->fSegSSD->Dx()*0.00005;
    fDz = fInfo->fSegSSD->Dz()*0.00005;
    fDy = fInfo->fSegSSD->Dy()*0.00005;
  }

  LoadQuads();  
  ComputeBBox();
  SetTrans();
}

void ITSModule::LoadQuads()
{
  // printf("its module load quads \n");
  Float_t x = fDx;
  Float_t z = fDz;
  Bool_t aboveThreshold = false;

  // Module frame in xy plane
  fQuads.push_back(Reve::Quad(fFrameColor));
  Float_t dy = -0.;
  Float_t* p = fQuads.back().vertices;
  p[0] = -x;  p[1] =  dy; p[2]  = -z;
  p[3] = -x;  p[4] =  dy; p[5]  =  z;
  p[6] =  x;  p[7] =  dy; p[8]  =  z;
  p[9] =  x;  p[10] = dy; p[11] = -z;

  // Digits
  TClonesArray *digits;
  Int_t ndigits;
  Float_t dpx,dpz; 
  Int_t i,j;
  digits  = fInfo->GetDigits(fID, fDetID );
  ndigits = digits->GetEntriesFast(); 
  Int_t n_col = gStyle->GetNumberOfColors();

  switch(fDetID) {

  case 0: { // SPD
    aboveThreshold = true;
    AliITSsegmentationSPD* seg =  fInfo->fSegSPD; 
    AliITSdigitSPD *d=0;

    for (Int_t k=0; k<ndigits; k++) {
      d=(AliITSdigitSPD*)digits->UncheckedAt(k);
      j = d->GetCoord1();
      i = d->GetCoord2();
      x  = -seg->Dx()/2 + seg->Dpx(0) *i;
      x *=  0.0001;
      fInfo->GetSPDLocalZ(j,z);
      dpx = seg->Dpx(i)*0.0001;
      dpz = seg->Dpz(j)*0.0001;

      fQuads.push_back(Reve::Quad(7));
      Float_t* p = fQuads.back().vertices;
      p[0] = x;        p[1] = 0.; p[2]  = z;
      p[3] = x;        p[4] = 0.; p[5]  = z + dpz;
      p[6] = x + dpx;  p[7] = 0.; p[8]  = z + dpz;
      p[9] = x + dpx;  p[10] =0.; p[11] = z;
    }
    break;
  }

  case 1: { // SDD
    AliITSsegmentationSDD* seg =  fInfo->fSegSDD; 
    AliITSdigitSDD *d=0;
    x = 2*fDx;
    z = 2*fDz;
    for (Int_t k=0; k<ndigits; k++) {
      d=(AliITSdigitSDD*)digits->UncheckedAt(k);

      if (d->GetSignal() > fgSDDThreshold) {
	j = d->GetCoord1();
	i = d->GetCoord2();
	aboveThreshold = true;
	seg->DetToLocal(i,j,x,z);
	dpx = seg->Dpx(i)*0.0001;
	dpz = seg->Dpz(j)*0.0001;

	Int_t ci = gStyle->GetColorPalette
	  (TMath::Min(n_col - 1,
		      (n_col*(d->GetSignal() - fgSDDThreshold))/(fgSDDMaxVal - fgSDDThreshold)));
	fQuads.push_back(Reve::Quad(ci, p));
	Float_t* p = fQuads.back().vertices;
	p[0] = x;        p[1] = 0.; p[2]  = z;
	p[3] = x;        p[4] = 0.; p[5]  = z + dpz;
	p[6] = x + dpx;  p[7] = 0.; p[8]  = z + dpz;
	p[9] = x + dpx;  p[10] =0.; p[11] = z;
      }
    }
    break;
  }

  case 2: { // SSD
    AliITSsegmentationSSD* seg = fInfo->fSegSSD; 
    AliITSdigitSSD *d=0;
    Float_t ap,an,a;
    seg->Angles(ap,an);
    for (Int_t k=0; k<ndigits; k++) {
      d=(AliITSdigitSSD*)digits->UncheckedAt(k);
      if(d->GetSignal() > fgSSDThreshold){
	aboveThreshold = true;
	j = d->GetCoord1();
	i = d->GetCoord2();
	seg->DetToLocal(i,j,x,z);

	if( d->GetCoord1() == 1) {
	  a = ap;
	}
	else {
	  a = -an;
	}
     	fQuads.push_back(Reve::Quad());
	Int_t ci = gStyle->GetColorPalette
	  (TMath::Min(n_col - 1,
		      (n_col*(d->GetSignal() - fgSSDThreshold))/(fgSSDMaxVal - fgSSDThreshold)));

	fQuads.back().ColorFromIdx(ci);
	Float_t* p = fQuads.back().vertices;
        
	p[0] = x-TMath::Tan(a)*fDz;  p[1] =  0; p[2]  = -fDz;
	p[3] = x+TMath::Tan(a)*fDz;  p[4] =  0; p[5]  = fDz ;
	p[6] = x+TMath::Tan(a)*fDz;  p[7] =  0; p[8]  = fDz  ;
	p[9] = x-TMath::Tan(a)*fDz;  p[10] = 0; p[11] = -fDz;
	//	printf("%3d -> %3d -> %8x\n", d->GetSignal(), ci, fQuads.back().color);
      }
    }
    break;
  }

  }
}

/**************************************************************************/

void ITSModule::SetTrans()
{
  Double_t pos[3];
  Double_t rot[9];
  fInfo->fGeom->GetTrans(fID,pos);
  fInfo->fGeom->GetRotMatrix(fID,rot);
  Double_t *s, *d;

  // column major ii
  s = &rot[0]; d = &fMatrix[0];
  d[0] = s[0]; d[1] = s[3]; d[2] = s[6]; d[3] = 0;
  s = &rot[1]; d = &fMatrix[4];
  d[0] = s[0]; d[1] = s[3]; d[2] = s[6]; d[3] = 0;
  s = &rot[2]; d = &fMatrix[8];
  d[0] = s[0]; d[1] = s[3]; d[2] = s[6]; d[3] = 0;
  s = &pos[0]; d = &fMatrix[12];
  d[0] = s[0]; d[1] = s[1]; d[2] = s[2]; d[3] = 1;

  fTrans = true;
}

/**************************************************************************/

void ITSModule::Print(Option_t* ) const
{
  printf("ID %d, layer %d, ladder %d, det %d \n", fID, fLayer, fLadder, fDetID);
}
Commit	Line	Data
5a5a1232	1	#include "ITSModule.h"
	2
	3	#include <AliITSdigitSPD.h>
	4	#include <AliITSdigitSDD.h>
	5	#include <AliITSdigitSSD.h>
	6
	7	#include <TStyle.h>
	8
	9	using namespace Reve;
	10	using namespace Alieve;
	11	using namespace std;
	12
	13	Short_t ITSModule::fgSDDThreshold = 5;
	14	Short_t ITSModule::fgSDDMaxVal = 80;
	15	Short_t ITSModule::fgSSDThreshold = 2;
	16	Short_t ITSModule::fgSSDMaxVal = 100;
	17
	18	ClassImp(ITSModule)
	19
	20	/**************************************************************************/
	21
27db2029	22	ITSModule::ITSModule(const Text_t* n, const Text_t* t, Color_t col) :
	23	Reve::RenderElement(fFrameColor),
	24	QuadSet(n, t),
265ecb21	25	fInfo(0),
	26	fID(-1), fDetID(-1),
	27	fLayer(-1), fLadder(-1), fDet(-1),
	28	fDx(0), fDz(0), fDy(0),
27db2029	29	fFrameColor(col)
27db2029	30	{}
5a5a1232	31
5a5a1232	32	ITSModule::ITSModule(Int_t id, ITSDigitsInfo* info, Color_t col) :
27db2029	33	Reve::RenderElement(fFrameColor),
	34	QuadSet(Form("ITS module %d", id)),
	35	fInfo (0),
265ecb21	36	fID(-1), fDetID(-1),
	37	fLayer(-1), fLadder(-1), fDet(-1),
	38	fDx(0), fDz(0), fDy(0),
092578a7	39	fFrameColor(col)
5a5a1232	40	{
27db2029	41	SetDigitsInfo(info);
5a5a1232	42	SetID(id);
	43	}
	44
	45	ITSModule::~ITSModule()
	46	{
	47	if(fInfo) fInfo->DecRefCount();
	48	}
	49
	50	/**************************************************************************/
	51
	52	void ITSModule::SetMainColor(Color_t col)
	53	{
	54	Reve::RenderElement::SetMainColor(col);
	55	if(!fQuads.empty()) {
	56	fQuads.front().ColorFromIdx(col);
	57	}
	58	}
	59
	60	/**************************************************************************/
	61
27db2029	62	void ITSModule::SetDigitsInfo(ITSDigitsInfo* info)
	63	{
	64	if(fInfo) fInfo->DecRefCount();
	65	fInfo = info;
	66	if(fInfo) fInfo->IncRefCount();
	67	}
	68
5a5a1232	69	void ITSModule::SetID(Int_t id)
	70	{
	71	static const Exc_t eH("ITSModule::SetID ");
	72
	73	if(fInfo == 0)
	74	throw(eH + "ITSDigitsInfo not set.");
	75
	76	if (id < fInfo->fGeom->GetStartSPD() \|\| id > fInfo->fGeom->GetLastSSD())
	77	throw(eH + Form("%d is not valid. ID range from %d to %d", id,
	78	fInfo->fGeom->GetStartSPD(), fInfo->fGeom->GetLastSSD()));
	79
	80	fID = id;
	81	InitModule();
	82	}
	83
	84	/**************************************************************************/
	85
	86	void ITSModule::InitModule()
	87	{
	88	fInfo->fGeom->GetModuleId(fID,fLayer,fLadder,fDet);
	89	SetName(Form("ITSModule %d", fID));
	90
	91	if (fID <= fInfo->fGeom->GetLastSPD()) {
	92	fDetID = 0;
	93	fDx = fInfo->fSegSPD->Dx()*0.00005;
	94	fDz = 3.48;
	95	fDy = fInfo->fSegSPD->Dy()*0.00005;
	96	}
	97	else if (fID <= fInfo->fGeom->GetLastSDD()) {
	98	fDetID = 1;
	99	fDx = fInfo->fSegSDD->Dx()*0.0001;
	100	fDz = fInfo->fSegSDD->Dz()*0.00005;
	101	fDy = fInfo->fSegSDD->Dy()*0.00005;
	102	}
	103	else {
	104	fDetID = 2;
	105	fInfo->fSegSSD->SetLayer(fLayer);
	106	fDx = fInfo->fSegSSD->Dx()*0.00005;
	107	fDz = fInfo->fSegSSD->Dz()*0.00005;
	108	fDy = fInfo->fSegSSD->Dy()*0.00005;
	109	}
	110
	111	LoadQuads();
	112	ComputeBBox();
	113	SetTrans();
	114	}
	115
	116	void ITSModule::LoadQuads()
	117	{
	118	// printf("its module load quads \n");
	119	Float_t x = fDx;
	120	Float_t z = fDz;
915dabe1	121	Bool_t aboveThreshold = false;
5a5a1232	122
5a5a1232	123	// Module frame in xy plane
092578a7	124	fQuads.push_back(Reve::Quad(fFrameColor));
5a5a1232	125	Float_t dy = -0.;
	126	Float_t* p = fQuads.back().vertices;
	127	p[0] = -x; p[1] = dy; p[2] = -z;
	128	p[3] = -x; p[4] = dy; p[5] = z;
	129	p[6] = x; p[7] = dy; p[8] = z;
	130	p[9] = x; p[10] = dy; p[11] = -z;
	131
	132	// Digits
	133	TClonesArray *digits;
	134	Int_t ndigits;
	135	Float_t dpx,dpz;
	136	Int_t i,j;
	137	digits = fInfo->GetDigits(fID, fDetID );
	138	ndigits = digits->GetEntriesFast();
	139	Int_t n_col = gStyle->GetNumberOfColors();
	140
	141	switch(fDetID) {
	142
	143	case 0: { // SPD
915dabe1	144	aboveThreshold = true;
5a5a1232	145	AliITSsegmentationSPD* seg = fInfo->fSegSPD;
	146	AliITSdigitSPD *d=0;
	147
	148	for (Int_t k=0; k<ndigits; k++) {
	149	d=(AliITSdigitSPD*)digits->UncheckedAt(k);
	150	j = d->GetCoord1();
	151	i = d->GetCoord2();
	152	x = -seg->Dx()/2 + seg->Dpx(0) *i;
	153	x *= 0.0001;
	154	fInfo->GetSPDLocalZ(j,z);
	155	dpx = seg->Dpx(i)*0.0001;
	156	dpz = seg->Dpz(j)*0.0001;
	157
	158	fQuads.push_back(Reve::Quad(7));
	159	Float_t* p = fQuads.back().vertices;
	160	p[0] = x; p[1] = 0.; p[2] = z;
	161	p[3] = x; p[4] = 0.; p[5] = z + dpz;
	162	p[6] = x + dpx; p[7] = 0.; p[8] = z + dpz;
	163	p[9] = x + dpx; p[10] =0.; p[11] = z;
	164	}
	165	break;
	166	}
	167
	168	case 1: { // SDD
	169	AliITSsegmentationSDD* seg = fInfo->fSegSDD;
	170	AliITSdigitSDD *d=0;
	171	x = 2*fDx;
	172	z = 2*fDz;
	173	for (Int_t k=0; k<ndigits; k++) {
	174	d=(AliITSdigitSDD*)digits->UncheckedAt(k);
	175
	176	if (d->GetSignal() > fgSDDThreshold) {
	177	j = d->GetCoord1();
	178	i = d->GetCoord2();
915dabe1	179	aboveThreshold = true;
5a5a1232	180	seg->DetToLocal(i,j,x,z);
	181	dpx = seg->Dpx(i)*0.0001;
	182	dpz = seg->Dpz(j)*0.0001;
	183
	184	Int_t ci = gStyle->GetColorPalette
	185	(TMath::Min(n_col - 1,
	186	(n_col*(d->GetSignal() - fgSDDThreshold))/(fgSDDMaxVal - fgSDDThreshold)));
	187	fQuads.push_back(Reve::Quad(ci, p));
	188	Float_t* p = fQuads.back().vertices;
	189	p[0] = x; p[1] = 0.; p[2] = z;
	190	p[3] = x; p[4] = 0.; p[5] = z + dpz;
	191	p[6] = x + dpx; p[7] = 0.; p[8] = z + dpz;
	192	p[9] = x + dpx; p[10] =0.; p[11] = z;
	193	}
	194	}
	195	break;
	196	}
	197
	198	case 2: { // SSD
	199	AliITSsegmentationSSD* seg = fInfo->fSegSSD;
	200	AliITSdigitSSD *d=0;
	201	Float_t ap,an,a;
	202	seg->Angles(ap,an);
	203	for (Int_t k=0; k<ndigits; k++) {
	204	d=(AliITSdigitSSD*)digits->UncheckedAt(k);
	205	if(d->GetSignal() > fgSSDThreshold){
915dabe1	206	aboveThreshold = true;
5a5a1232	207	j = d->GetCoord1();
	208	i = d->GetCoord2();
	209	seg->DetToLocal(i,j,x,z);
	210
	211	if( d->GetCoord1() == 1) {
	212	a = ap;
	213	}
	214	else {
	215	a = -an;
	216	}
	217	fQuads.push_back(Reve::Quad());
	218	Int_t ci = gStyle->GetColorPalette
	219	(TMath::Min(n_col - 1,
	220	(n_col*(d->GetSignal() - fgSSDThreshold))/(fgSSDMaxVal - fgSSDThreshold)));
	221
	222	fQuads.back().ColorFromIdx(ci);
	223	Float_t* p = fQuads.back().vertices;
	224
	225	p[0] = x-TMath::Tan(a)*fDz; p[1] = 0; p[2] = -fDz;
	226	p[3] = x+TMath::Tan(a)*fDz; p[4] = 0; p[5] = fDz ;
	227	p[6] = x+TMath::Tan(a)*fDz; p[7] = 0; p[8] = fDz ;
	228	p[9] = x-TMath::Tan(a)*fDz; p[10] = 0; p[11] = -fDz;
	229	// printf("%3d -> %3d -> %8x\n", d->GetSignal(), ci, fQuads.back().color);
	230	}
	231	}
	232	break;
	233	}
	234
	235	}
	236	}
	237
	238	/**************************************************************************/
	239
	240	void ITSModule::SetTrans()
	241	{
	242	Double_t pos[3];
	243	Double_t rot[9];
	244	fInfo->fGeom->GetTrans(fID,pos);
	245	fInfo->fGeom->GetRotMatrix(fID,rot);
	246	Double_t s, d;
	247
	248	// column major ii
	249	s = &rot[0]; d = &fMatrix[0];
	250	d[0] = s[0]; d[1] = s[3]; d[2] = s[6]; d[3] = 0;
	251	s = &rot[1]; d = &fMatrix[4];
	252	d[0] = s[0]; d[1] = s[3]; d[2] = s[6]; d[3] = 0;
	253	s = &rot[2]; d = &fMatrix[8];
	254	d[0] = s[0]; d[1] = s[3]; d[2] = s[6]; d[3] = 0;
	255	s = &pos[0]; d = &fMatrix[12];
	256	d[0] = s[0]; d[1] = s[1]; d[2] = s[2]; d[3] = 1;
	257
	258	fTrans = true;
	259	}
	260
	261	/**************************************************************************/
	262
	263	void ITSModule::Print(Option_t* ) const
	264	{
	265	printf("ID %d, layer %d, ladder %d, det %d \n", fID, fLayer, fLadder, fDetID);
	266	}