[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);
  TString strLadder = "Ladder";
  TString strSensor = "Sensor";
  TString symname;
  Int_t id, nsector, nstave, nladder, rest;
  
  if (fID <= fInfo->fGeom->GetLastSPD()) {
    symname+=strLadder;
    if (fID<80) {
      nsector = fID/8;
      rest=fID-nsector*8;
      nstave=1;
      if (rest<4) nstave=0;
      rest-=nstave*4;
      symname+=rest;
      SetName(symname.Data());
      fDetID = 0;
      fDx = fInfo->fSegSPD->Dx()*0.00005;
      fDz = 3.48; 
      fDy = fInfo->fSegSPD->Dy()*0.00005;
    } else {
      id=fID-80;
      nsector = id/8;
      rest=id-nsector*8;
      nstave=1;
      if (rest<4) nstave=0;
      rest-=nstave*4;
      symname+=rest;
      SetName(symname.Data());
      fDetID = 0;
      fDx = fInfo->fSegSPD->Dx()*0.00005;
      fDz = 3.48; 
      fDy = fInfo->fSegSPD->Dy()*0.00005;
      fDetID = 0;
      fDx = fInfo->fSegSPD->Dx()*0.00005;
      fDz = 3.48; 
      fDy = fInfo->fSegSPD->Dy()*0.00005;
    }
  }
  else if (fID <= fInfo->fGeom->GetLastSDD()) {
    symname+=strSensor;
    if (fID<324) {
      id = fID-240;
      nladder = id/6;
      rest=id-nladder*6;
      symname+=rest;
      SetName(symname.Data());
      fDetID = 1;
      fDx = fInfo->fSegSDD->Dx()*0.0001;
      fDz = fInfo->fSegSDD->Dz()*0.00005;
      fDy = fInfo->fSegSDD->Dy()*0.00005;
    } else {
      id = fID-324;
      nladder = id/8;
      rest=id-nladder*8;
      symname+=rest;
      SetName(symname.Data());
      fDetID = 1;
      fDx = fInfo->fSegSDD->Dx()*0.0001;
      fDz = fInfo->fSegSDD->Dz()*0.00005;
      fDy = fInfo->fSegSDD->Dy()*0.00005;
    }
  }
  else {
    symname+=strSensor;
    if (fID<1248) {
      id = fID-500;
      nladder = id/22;
      rest=id-nladder*22;
      symname+=rest;
      SetName(symname.Data());
      fDetID = 2;
      fInfo->fSegSSD->SetLayer(fLayer);  
      fDx = fInfo->fSegSSD->Dx()*0.00005;
      fDz = fInfo->fSegSSD->Dz()*0.00005;
      fDy = fInfo->fSegSSD->Dy()*0.00005;
    } else {
      id = fID-1248;
      nladder = id/25;
      rest=id-nladder*25;
      symname+=rest;
      SetName(symname.Data());
      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);
ba6cfb13	89	TString strLadder = "Ladder";
	90	TString strSensor = "Sensor";
	91	TString symname;
	92	Int_t id, nsector, nstave, nladder, rest;
	93
5a5a1232	94	if (fID <= fInfo->fGeom->GetLastSPD()) {
ba6cfb13	95	symname+=strLadder;
	96	if (fID<80) {
	97	nsector = fID/8;
	98	rest=fID-nsector*8;
	99	nstave=1;
	100	if (rest<4) nstave=0;
	101	rest-=nstave*4;
	102	symname+=rest;
	103	SetName(symname.Data());
	104	fDetID = 0;
	105	fDx = fInfo->fSegSPD->Dx()*0.00005;
	106	fDz = 3.48;
	107	fDy = fInfo->fSegSPD->Dy()*0.00005;
	108	} else {
	109	id=fID-80;
	110	nsector = id/8;
	111	rest=id-nsector*8;
	112	nstave=1;
	113	if (rest<4) nstave=0;
	114	rest-=nstave*4;
	115	symname+=rest;
	116	SetName(symname.Data());
	117	fDetID = 0;
	118	fDx = fInfo->fSegSPD->Dx()*0.00005;
	119	fDz = 3.48;
	120	fDy = fInfo->fSegSPD->Dy()*0.00005;
	121	fDetID = 0;
	122	fDx = fInfo->fSegSPD->Dx()*0.00005;
	123	fDz = 3.48;
	124	fDy = fInfo->fSegSPD->Dy()*0.00005;
	125	}
5a5a1232	126	}
5a5a1232	127	else if (fID <= fInfo->fGeom->GetLastSDD()) {
ba6cfb13	128	symname+=strSensor;
	129	if (fID<324) {
	130	id = fID-240;
	131	nladder = id/6;
	132	rest=id-nladder*6;
	133	symname+=rest;
	134	SetName(symname.Data());
	135	fDetID = 1;
	136	fDx = fInfo->fSegSDD->Dx()*0.0001;
	137	fDz = fInfo->fSegSDD->Dz()*0.00005;
	138	fDy = fInfo->fSegSDD->Dy()*0.00005;
	139	} else {
	140	id = fID-324;
	141	nladder = id/8;
	142	rest=id-nladder*8;
	143	symname+=rest;
	144	SetName(symname.Data());
	145	fDetID = 1;
	146	fDx = fInfo->fSegSDD->Dx()*0.0001;
	147	fDz = fInfo->fSegSDD->Dz()*0.00005;
	148	fDy = fInfo->fSegSDD->Dy()*0.00005;
	149	}
5a5a1232	150	}
5a5a1232	151	else {
ba6cfb13	152	symname+=strSensor;
	153	if (fID<1248) {
	154	id = fID-500;
	155	nladder = id/22;
	156	rest=id-nladder*22;
	157	symname+=rest;
	158	SetName(symname.Data());
	159	fDetID = 2;
	160	fInfo->fSegSSD->SetLayer(fLayer);
	161	fDx = fInfo->fSegSSD->Dx()*0.00005;
	162	fDz = fInfo->fSegSSD->Dz()*0.00005;
	163	fDy = fInfo->fSegSSD->Dy()*0.00005;
	164	} else {
	165	id = fID-1248;
	166	nladder = id/25;
	167	rest=id-nladder*25;
	168	symname+=rest;
	169	SetName(symname.Data());
	170	fDetID = 2;
	171	fInfo->fSegSSD->SetLayer(fLayer);
	172	fDx = fInfo->fSegSSD->Dx()*0.00005;
	173	fDz = fInfo->fSegSSD->Dz()*0.00005;
	174	fDy = fInfo->fSegSSD->Dy()*0.00005;
	175	}
5a5a1232	176	}
	177
	178	LoadQuads();
	179	ComputeBBox();
	180	SetTrans();
	181	}
	182
	183	void ITSModule::LoadQuads()
	184	{
	185	// printf("its module load quads \n");
	186	Float_t x = fDx;
	187	Float_t z = fDz;
915dabe1	188	Bool_t aboveThreshold = false;
5a5a1232	189
5a5a1232	190	// Module frame in xy plane
092578a7	191	fQuads.push_back(Reve::Quad(fFrameColor));
5a5a1232	192	Float_t dy = -0.;
	193	Float_t* p = fQuads.back().vertices;
	194	p[0] = -x; p[1] = dy; p[2] = -z;
	195	p[3] = -x; p[4] = dy; p[5] = z;
	196	p[6] = x; p[7] = dy; p[8] = z;
	197	p[9] = x; p[10] = dy; p[11] = -z;
	198
	199	// Digits
	200	TClonesArray *digits;
	201	Int_t ndigits;
	202	Float_t dpx,dpz;
	203	Int_t i,j;
	204	digits = fInfo->GetDigits(fID, fDetID );
	205	ndigits = digits->GetEntriesFast();
	206	Int_t n_col = gStyle->GetNumberOfColors();
	207
	208	switch(fDetID) {
	209
	210	case 0: { // SPD
915dabe1	211	aboveThreshold = true;
5a5a1232	212	AliITSsegmentationSPD* seg = fInfo->fSegSPD;
	213	AliITSdigitSPD *d=0;
	214
	215	for (Int_t k=0; k<ndigits; k++) {
	216	d=(AliITSdigitSPD*)digits->UncheckedAt(k);
	217	j = d->GetCoord1();
	218	i = d->GetCoord2();
	219	x = -seg->Dx()/2 + seg->Dpx(0) *i;
	220	x *= 0.0001;
	221	fInfo->GetSPDLocalZ(j,z);
	222	dpx = seg->Dpx(i)*0.0001;
	223	dpz = seg->Dpz(j)*0.0001;
	224
	225	fQuads.push_back(Reve::Quad(7));
	226	Float_t* p = fQuads.back().vertices;
	227	p[0] = x; p[1] = 0.; p[2] = z;
	228	p[3] = x; p[4] = 0.; p[5] = z + dpz;
	229	p[6] = x + dpx; p[7] = 0.; p[8] = z + dpz;
	230	p[9] = x + dpx; p[10] =0.; p[11] = z;
	231	}
	232	break;
	233	}
	234
	235	case 1: { // SDD
	236	AliITSsegmentationSDD* seg = fInfo->fSegSDD;
	237	AliITSdigitSDD *d=0;
	238	x = 2*fDx;
	239	z = 2*fDz;
	240	for (Int_t k=0; k<ndigits; k++) {
	241	d=(AliITSdigitSDD*)digits->UncheckedAt(k);
	242
	243	if (d->GetSignal() > fgSDDThreshold) {
	244	j = d->GetCoord1();
	245	i = d->GetCoord2();
915dabe1	246	aboveThreshold = true;
5a5a1232	247	seg->DetToLocal(i,j,x,z);
	248	dpx = seg->Dpx(i)*0.0001;
	249	dpz = seg->Dpz(j)*0.0001;
	250
	251	Int_t ci = gStyle->GetColorPalette
	252	(TMath::Min(n_col - 1,
	253	(n_col*(d->GetSignal() - fgSDDThreshold))/(fgSDDMaxVal - fgSDDThreshold)));
	254	fQuads.push_back(Reve::Quad(ci, p));
	255	Float_t* p = fQuads.back().vertices;
	256	p[0] = x; p[1] = 0.; p[2] = z;
	257	p[3] = x; p[4] = 0.; p[5] = z + dpz;
	258	p[6] = x + dpx; p[7] = 0.; p[8] = z + dpz;
	259	p[9] = x + dpx; p[10] =0.; p[11] = z;
	260	}
	261	}
	262	break;
	263	}
	264
	265	case 2: { // SSD
	266	AliITSsegmentationSSD* seg = fInfo->fSegSSD;
	267	AliITSdigitSSD *d=0;
	268	Float_t ap,an,a;
	269	seg->Angles(ap,an);
	270	for (Int_t k=0; k<ndigits; k++) {
	271	d=(AliITSdigitSSD*)digits->UncheckedAt(k);
	272	if(d->GetSignal() > fgSSDThreshold){
915dabe1	273	aboveThreshold = true;
5a5a1232	274	j = d->GetCoord1();
	275	i = d->GetCoord2();
	276	seg->DetToLocal(i,j,x,z);
	277
	278	if( d->GetCoord1() == 1) {
	279	a = ap;
	280	}
	281	else {
	282	a = -an;
	283	}
	284	fQuads.push_back(Reve::Quad());
	285	Int_t ci = gStyle->GetColorPalette
	286	(TMath::Min(n_col - 1,
	287	(n_col*(d->GetSignal() - fgSSDThreshold))/(fgSSDMaxVal - fgSSDThreshold)));
	288
	289	fQuads.back().ColorFromIdx(ci);
	290	Float_t* p = fQuads.back().vertices;
	291
	292	p[0] = x-TMath::Tan(a)*fDz; p[1] = 0; p[2] = -fDz;
	293	p[3] = x+TMath::Tan(a)*fDz; p[4] = 0; p[5] = fDz ;
	294	p[6] = x+TMath::Tan(a)*fDz; p[7] = 0; p[8] = fDz ;
	295	p[9] = x-TMath::Tan(a)*fDz; p[10] = 0; p[11] = -fDz;
	296	// printf("%3d -> %3d -> %8x\n", d->GetSignal(), ci, fQuads.back().color);
	297	}
	298	}
	299	break;
	300	}
	301
	302	}
	303	}
	304
	305	/**************************************************************************/
	306
	307	void ITSModule::SetTrans()
	308	{
	309	Double_t pos[3];
	310	Double_t rot[9];
	311	fInfo->fGeom->GetTrans(fID,pos);
	312	fInfo->fGeom->GetRotMatrix(fID,rot);
	313	Double_t s, d;
	314
	315	// column major ii
	316	s = &rot[0]; d = &fMatrix[0];
	317	d[0] = s[0]; d[1] = s[3]; d[2] = s[6]; d[3] = 0;
	318	s = &rot[1]; d = &fMatrix[4];
	319	d[0] = s[0]; d[1] = s[3]; d[2] = s[6]; d[3] = 0;
	320	s = &rot[2]; d = &fMatrix[8];
	321	d[0] = s[0]; d[1] = s[3]; d[2] = s[6]; d[3] = 0;
	322	s = &pos[0]; d = &fMatrix[12];
	323	d[0] = s[0]; d[1] = s[1]; d[2] = s[2]; d[3] = 1;
	324
	325	fTrans = true;
	326	}
	327
	328	/**************************************************************************/
	329
	330	void ITSModule::Print(Option_t* ) const
	331	{
	332	printf("ID %d, layer %d, ladder %d, det %d \n", fID, fLayer, fLadder, fDetID);
	333	}