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