[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;


Bool_t       ITSModule::fgStaticInitDone = kFALSE;

FrameBox*    ITSModule::fgSPDFrameBox = 0;
FrameBox*    ITSModule::fgSDDFrameBox = 0;
FrameBox*    ITSModule::fgSSDFrameBox = 0;

RGBAPalette* ITSModule::fgSPDPalette  = 0;
RGBAPalette* ITSModule::fgSDDPalette  = 0;
RGBAPalette* ITSModule::fgSSDPalette  = 0;

//__________________________________________________________________________
// ITSModule
//
//

ClassImp(ITSModule)

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

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

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

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

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

void ITSModule::InitStatics(ITSDigitsInfo* info)
{
  if (fgStaticInitDone) return;
  fgStaticInitDone = kTRUE;

  {
    Float_t dx = info->fSegSPD->Dx()*0.00005;
    Float_t dz = 3.50; 

    fgSPDFrameBox = new FrameBox();
    fgSPDFrameBox->SetAAQuadXZ(-dx, 0, -dz, 2*dx, 2*dz);
    fgSPDFrameBox->SetFrameColor((Color_t) 31);
    fgSPDFrameBox->SetFrameFill(kTRUE);
    fgSPDFrameBox->IncRefCount();
    fgSPDPalette  = new RGBAPalette(info->fSPDMinVal,info->fSPDMaxVal);
    fgSPDPalette->IncRefCount();
  }

  {
    Float_t dx = info->fSegSDD->Dx()*0.0001;
    Float_t dz = info->fSegSDD->Dz()*0.00005;

    fgSDDFrameBox = new FrameBox();
    fgSDDFrameBox->SetAAQuadXZ(-dx, 0, -dz, 2*dx, 2*dz);
    fgSDDFrameBox->SetFrameColor((Color_t) 32);
    fgSDDFrameBox->SetFrameFill(kTRUE);
    fgSDDFrameBox->IncRefCount();
    fgSDDPalette  = new RGBAPalette(info->fSDDMinVal,info->fSDDMaxVal);
    fgSDDPalette->SetLimits(0, info->fSDDHighLim); // Set proper ADC range.
    fgSDDPalette->IncRefCount();
  }

  {
    Float_t dx = info->fSegSSD->Dx()*0.00005;
    Float_t dz = info->fSegSSD->Dz()*0.00005;

    fgSSDFrameBox = new FrameBox();
    fgSSDFrameBox->SetAAQuadXZ(-dx, 0, -dz, 2*dx, 2*dz);
    fgSSDFrameBox->SetFrameColor((Color_t) 33);
    fgSSDFrameBox->SetFrameFill(kTRUE);
    fgSSDFrameBox->IncRefCount();
    fgSSDPalette  = new RGBAPalette(info->fSSDMinVal,info->fSSDMaxVal);
    fgSSDPalette->SetLimits(0, info->fSSDHighLim); // Set proper ADC range.
    fgSSDPalette->IncRefCount();
  }

}

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

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

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

void ITSModule::SetID(Int_t gid, Bool_t trans)
{
  static const Exc_t eH("ITSModule::SetID ");

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

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

  fID = gid;

  if (!fgStaticInitDone) {
    InitStatics(fInfo);
    
    fgSPDFrameBox->IncRefCount(this);
    fgSPDPalette->IncRefCount();
  
    fgSDDFrameBox->IncRefCount(this);
    fgSDDPalette->IncRefCount();

    fgSSDFrameBox->IncRefCount(this);
    fgSSDPalette->IncRefCount();
  }

  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())
  {
    // SPD

    SetFrame(fgSPDFrameBox);
    SetPalette(fgSPDPalette);
 
    symname += strLadder;
    if (fID < 80)
    {
      nsector = fID/8;
      rest    = fID - 8*nsector;
      nstave  = 1;
    }
    else
    {
      id      = fID - 80;
      nsector = id/8;
      rest    = id - 8*nsector;
      nstave  = 1;
    }
    if (rest < 4) nstave = 0;
    rest    -= 4*nstave;
    symname += rest;
    SetName(symname);
    fDetID = 0;
    fDx = fInfo->fSegSPD->Dx()*0.00005;
    fDz = 3.50; 
    fDy = fInfo->fSegSPD->Dy()*0.00005;

  }
  else if (fID <= fInfo->fGeom->GetLastSDD())
  {
    // SDD

    SetFrame(fgSDDFrameBox);
    SetPalette(fgSDDPalette);
 
    symname += strSensor;
    if (fID < 324)
    {
      id      = fID - 240;
      nladder = id/6;
      rest    = id - 6*nladder;
    }
    else
    {
      id      = fID - 324;
      nladder = id/8;
      rest    = id - 8*nladder;
    }
    symname += rest;
    SetName(symname);
    fDetID = 1;
    fDx = fInfo->fSegSDD->Dx()*0.0001;
    fDz = fInfo->fSegSDD->Dz()*0.00005;
    fDy = fInfo->fSegSDD->Dy()*0.00005;

  }
  else
  {
    // SSD

    SetFrame(fgSSDFrameBox);
    SetPalette(fgSSDPalette);

    symname += strSensor;
    if (fID < 1248)
    {
      id      = fID - 500;
      nladder = id/22;
      rest    = id - nladder*22;
    }
    else
    {
      id      = fID - 1248;
      nladder = id/25;
      rest    = id - nladder*25;
    }
    symname += rest;
    SetName(symname);
    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();
  if (trans)
    SetTrans();
}

void ITSModule::LoadQuads()
{
  // Here we still use 'z' for the name of axial coordinates.
  // The transforamtion matrix aplied rotates y -> z.
  // We need this as QuadSet offers optimized treatment for
  // quads in the x-y plane.

  // printf("its module load quads \n");

  TClonesArray *digits  = fInfo->GetDigits(fID, fDetID);
  Int_t         ndigits = digits ? digits->GetEntriesFast() : 0;

  Float_t       x, z, dpx, dpz; 
  Int_t         i, j;

  switch(fDetID)
  {

    case 0: { // SPD
      AliITSsegmentationSPD* seg =  fInfo->fSegSPD; 

      Reset(QT_RectangleXZFixedY, kFALSE, 32);

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

	AddQuad(x, z, dpx, dpz);
	QuadValue(1); // In principle could have color based on number of neigbours
	QuadId(d);
      }
      break;
    }

    case 1: { // SDD
      AliITSsegmentationSDD *seg =  fInfo->fSegSDD; 

      Reset(QT_RectangleXZFixedY, kFALSE, 32);

      for (Int_t k=0; k<ndigits; ++k)
      {
	AliITSdigit* d = (AliITSdigit*) digits->UncheckedAt(k);

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

	  AddQuad(x-2*dpx, z - dpz*0.5, 4*dpx, dpz);
	  QuadValue(d->GetSignal());
	  QuadId(d);
	}
      }
      break;
    }

    case 2: { // SSD
      AliITSsegmentationSSD* seg = fInfo->fSegSSD; 

      Reset(QT_LineXZFixedY, kFALSE, 32);

      Float_t ap, an; // positive/negative angles -> offsets
      seg->Angles(ap, an);
      ap =   TMath::Tan(ap) * fDz;
      an = - TMath::Tan(an) * fDz;

      for (Int_t k=0; k<ndigits; ++k)
      {
	AliITSdigit *d = (AliITSdigit*) digits->UncheckedAt(k);
	// if(d->GetSignal() > fgSSDThreshold)
	{
	  j = d->GetCoord1();
	  i = d->GetCoord2();
	  seg->DetToLocal(i,j,x,z);

	  Float_t a = ( d->GetCoord1() == 1) ? ap : an;

	  AddLine(x-a, -fDz, 2*a, 2*fDz);
	  QuadValue(d->GetSignal());
	  QuadId(d);
	  // printf("%3d -> %3d -> %8x\n", d->GetSignal(), ci, fQuads.back().color);
	}
      }
      break;
    }

  } // end switch

  RefitPlex();
}

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

void ITSModule::SetTrans()
{
  // Set transformation matrix based on module id (use geometry to
  // retrieve this information).

  Double_t x[9];
  fHMTrans.UnitTrans();

  // !!!! Here should use AliITSgeomTGeo ... but can i be sure
  // the geometry has been loaded?

  // column major
  fInfo->fGeom->GetRotMatrix(fID, x);
  fHMTrans.SetBaseVec(1, x[0], x[3], x[6]);
  fHMTrans.SetBaseVec(2, x[1], x[4], x[7]);
  fHMTrans.SetBaseVec(3, x[2], x[5], x[8]);
  // translation
  fInfo->fGeom->GetTrans(fID, x);  
  fHMTrans.SetBaseVec(4, x);
}

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

void ITSModule::DigitSelected(Int_t idx)
{
  // Override control-click from QuadSet

  DigitBase* qb   = GetDigit(idx);
  TObject* obj   = qb->fId.GetObject();
  AliITSdigit* d = dynamic_cast<AliITSdigit*>(obj);
  printf("ITSModule::QuadSelected "); Print();
  printf("  idx=%d, value=%d, obj=0x%lx, digit=0x%lx\n",
	 idx, qb->fValue, (ULong_t)obj, (ULong_t)d);
  if (d)
    printf("  coord1=%3d coord2=%3d signal=%d\n",
	   d->GetCoord1(), d->GetCoord2(), d->GetSignal());

}

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

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;
5a5a1232	11
9efc978d	12
	13	Bool_t ITSModule::fgStaticInitDone = kFALSE;
	14
	15	FrameBox* ITSModule::fgSPDFrameBox = 0;
	16	FrameBox* ITSModule::fgSDDFrameBox = 0;
	17	FrameBox* ITSModule::fgSSDFrameBox = 0;
	18
	19	RGBAPalette* ITSModule::fgSPDPalette = 0;
	20	RGBAPalette* ITSModule::fgSDDPalette = 0;
	21	RGBAPalette* ITSModule::fgSSDPalette = 0;
	22
	23	//__________________________________________________________________________
	24	// ITSModule
	25	//
	26	//
5a5a1232	27
	28	ClassImp(ITSModule)
	29
	30	/**************************************************************************/
	31
9efc978d	32	ITSModule::ITSModule(const Text_t* n, const Text_t* t) :
9efc978d	33	QuadSet(n, t),
265ecb21	34	fInfo(0),
	35	fID(-1), fDetID(-1),
	36	fLayer(-1), fLadder(-1), fDet(-1),
9efc978d	37	fDx(0), fDz(0), fDy(0)
27db2029	38	{}
5a5a1232	39
9c8221e9	40	ITSModule::ITSModule(Int_t gid, ITSDigitsInfo* info) :
9c8221e9	41	QuadSet(Form("ITS module %d", gid)),
27db2029	42	fInfo (0),
265ecb21	43	fID(-1), fDetID(-1),
265ecb21	44	fLayer(-1), fLadder(-1), fDet(-1),
9efc978d	45	fDx(0), fDz(0), fDy(0)
5a5a1232	46	{
27db2029	47	SetDigitsInfo(info);
9c8221e9	48	SetID(gid);
5a5a1232	49	}
	50
	51	ITSModule::~ITSModule()
	52	{
	53	if(fInfo) fInfo->DecRefCount();
	54	}
	55
	56	/**************************************************************************/
	57
9efc978d	58	void ITSModule::InitStatics(ITSDigitsInfo* info)
	59	{
	60	if (fgStaticInitDone) return;
9c8221e9	61	fgStaticInitDone = kTRUE;
9efc978d	62
	63	{
	64	Float_t dx = info->fSegSPD->Dx()*0.00005;
97e1e1bc	65	Float_t dz = 3.50;
9efc978d	66
	67	fgSPDFrameBox = new FrameBox();
	68	fgSPDFrameBox->SetAAQuadXZ(-dx, 0, -dz, 2dx, 2dz);
	69	fgSPDFrameBox->SetFrameColor((Color_t) 31);
32e219c2	70	fgSPDFrameBox->SetFrameFill(kTRUE);
32e219c2	71	fgSPDFrameBox->IncRefCount();
97e1e1bc	72	fgSPDPalette = new RGBAPalette(info->fSPDMinVal,info->fSPDMaxVal);
32e219c2	73	fgSPDPalette->IncRefCount();
9efc978d	74	}
	75
	76	{
	77	Float_t dx = info->fSegSDD->Dx()*0.0001;
	78	Float_t dz = info->fSegSDD->Dz()*0.00005;
	79
	80	fgSDDFrameBox = new FrameBox();
	81	fgSDDFrameBox->SetAAQuadXZ(-dx, 0, -dz, 2dx, 2dz);
	82	fgSDDFrameBox->SetFrameColor((Color_t) 32);
32e219c2	83	fgSDDFrameBox->SetFrameFill(kTRUE);
32e219c2	84	fgSDDFrameBox->IncRefCount();
97e1e1bc	85	fgSDDPalette = new RGBAPalette(info->fSDDMinVal,info->fSDDMaxVal);
32e219c2	86	fgSDDPalette->SetLimits(0, info->fSDDHighLim); // Set proper ADC range.
32e219c2	87	fgSDDPalette->IncRefCount();
9efc978d	88	}
	89
	90	{
	91	Float_t dx = info->fSegSSD->Dx()*0.00005;
	92	Float_t dz = info->fSegSSD->Dz()*0.00005;
	93
	94	fgSSDFrameBox = new FrameBox();
	95	fgSSDFrameBox->SetAAQuadXZ(-dx, 0, -dz, 2dx, 2dz);
	96	fgSSDFrameBox->SetFrameColor((Color_t) 33);
32e219c2	97	fgSSDFrameBox->SetFrameFill(kTRUE);
32e219c2	98	fgSSDFrameBox->IncRefCount();
97e1e1bc	99	fgSSDPalette = new RGBAPalette(info->fSSDMinVal,info->fSSDMaxVal);
32e219c2	100	fgSSDPalette->SetLimits(0, info->fSSDHighLim); // Set proper ADC range.
32e219c2	101	fgSSDPalette->IncRefCount();
9efc978d	102	}
	103
	104	}
	105
	106	/**************************************************************************/
	107
9c8221e9	108	void ITSModule::SetDigitsInfo(ITSDigitsInfo* info)
5a5a1232	109	{
9c8221e9	110	if (fInfo == info) return;
	111	if (fInfo) fInfo->DecRefCount();
	112	fInfo = info;
	113	if (fInfo) fInfo->IncRefCount();
	114	}
	115
	116	/**************************************************************************/
	117
97e1e1bc	118	void ITSModule::SetID(Int_t gid, Bool_t trans)
9c8221e9	119	{
9c8221e9	120	static const Exc_t eH("ITSModule::SetID ");
9efc978d	121
9c8221e9	122	if(fInfo == 0)
	123	throw(eH + "ITSDigitsInfo not set.");
	124
	125	if (gid < fInfo->fGeom->GetStartSPD() \|\| gid > fInfo->fGeom->GetLastSSD())
	126	throw(eH + Form("%d is not valid. ID range from %d to %d", gid,
1d3c2b09	127	fInfo->fGeom->GetStartSPD(), fInfo->fGeom->GetLastSSD()));
9c8221e9	128
	129	fID = gid;
	130
1d3c2b09	131	if (!fgStaticInitDone) {
	132	InitStatics(fInfo);
	133
	134	fgSPDFrameBox->IncRefCount(this);
	135	fgSPDPalette->IncRefCount();
	136
	137	fgSDDFrameBox->IncRefCount(this);
	138	fgSDDPalette->IncRefCount();
	139
	140	fgSSDFrameBox->IncRefCount(this);
	141	fgSSDPalette->IncRefCount();
	142	}
9c8221e9	143
9c8221e9	144	fInfo->fGeom->GetModuleId(fID, fLayer, fLadder, fDet);
ba6cfb13	145	TString strLadder = "Ladder";
	146	TString strSensor = "Sensor";
	147	TString symname;
9c8221e9	148	Int_t id, nsector, nstave, nladder, rest;
ba6cfb13	149
9efc978d	150	if (fID <= fInfo->fGeom->GetLastSPD())
	151	{
	152	// SPD
	153
9c8221e9	154	SetFrame(fgSPDFrameBox);
	155	SetPalette(fgSPDPalette);
	156
9efc978d	157	symname += strLadder;
	158	if (fID < 80)
	159	{
ba6cfb13	160	nsector = fID/8;
9efc978d	161	rest = fID - 8*nsector;
	162	nstave = 1;
	163	}
	164	else
	165	{
	166	id = fID - 80;
ba6cfb13	167	nsector = id/8;
9efc978d	168	rest = id - 8*nsector;
9efc978d	169	nstave = 1;
ba6cfb13	170	}
9efc978d	171	if (rest < 4) nstave = 0;
	172	rest -= 4*nstave;
	173	symname += rest;
	174	SetName(symname);
	175	fDetID = 0;
	176	fDx = fInfo->fSegSPD->Dx()*0.00005;
97e1e1bc	177	fDz = 3.50;
9efc978d	178	fDy = fInfo->fSegSPD->Dy()*0.00005;
9efc978d	179
5a5a1232	180	}
9efc978d	181	else if (fID <= fInfo->fGeom->GetLastSDD())
	182	{
	183	// SDD
	184
9c8221e9	185	SetFrame(fgSDDFrameBox);
	186	SetPalette(fgSDDPalette);
	187
9efc978d	188	symname += strSensor;
	189	if (fID < 324)
	190	{
	191	id = fID - 240;
ba6cfb13	192	nladder = id/6;
9efc978d	193	rest = id - 6*nladder;
	194	}
	195	else
	196	{
	197	id = fID - 324;
ba6cfb13	198	nladder = id/8;
9efc978d	199	rest = id - 8*nladder;
ba6cfb13	200	}
9efc978d	201	symname += rest;
	202	SetName(symname);
	203	fDetID = 1;
	204	fDx = fInfo->fSegSDD->Dx()*0.0001;
	205	fDz = fInfo->fSegSDD->Dz()*0.00005;
	206	fDy = fInfo->fSegSDD->Dy()*0.00005;
	207
5a5a1232	208	}
9efc978d	209	else
	210	{
	211	// SSD
	212
9c8221e9	213	SetFrame(fgSSDFrameBox);
	214	SetPalette(fgSSDPalette);
	215
9efc978d	216	symname += strSensor;
	217	if (fID < 1248)
	218	{
	219	id = fID - 500;
ba6cfb13	220	nladder = id/22;
9efc978d	221	rest = id - nladder*22;
	222	}
	223	else
	224	{
	225	id = fID - 1248;
ba6cfb13	226	nladder = id/25;
9efc978d	227	rest = id - nladder*25;
ba6cfb13	228	}
9efc978d	229	symname += rest;
	230	SetName(symname);
	231	fDetID = 2;
	232	fInfo->fSegSSD->SetLayer(fLayer);
	233	fDx = fInfo->fSegSSD->Dx()*0.00005;
	234	fDz = fInfo->fSegSSD->Dz()*0.00005;
	235	fDy = fInfo->fSegSSD->Dy()*0.00005;
	236
5a5a1232	237	}
	238
	239	LoadQuads();
	240	ComputeBBox();
97e1e1bc	241	if (trans)
97e1e1bc	242	SetTrans();
5a5a1232	243	}
	244
	245	void ITSModule::LoadQuads()
	246	{
9efc978d	247	// Here we still use 'z' for the name of axial coordinates.
	248	// The transforamtion matrix aplied rotates y -> z.
	249	// We need this as QuadSet offers optimized treatment for
	250	// quads in the x-y plane.
	251
5a5a1232	252	// printf("its module load quads \n");
9efc978d	253
b3bc5327	254	TClonesArray *digits = fInfo->GetDigits(fID, fDetID);
	255	Int_t ndigits = digits ? digits->GetEntriesFast() : 0;
	256
9efc978d	257	Float_t x, z, dpx, dpz;
b3bc5327	258	Int_t i, j;
5a5a1232	259
9efc978d	260	switch(fDetID)
	261	{
	262
	263	case 0: { // SPD
	264	AliITSsegmentationSPD* seg = fInfo->fSegSPD;
	265
697c88e6	266	Reset(QT_RectangleXZFixedY, kFALSE, 32);
5a5a1232	267
9efc978d	268	for (Int_t k=0; k<ndigits; ++k)
9efc978d	269	{
b3bc5327	270	AliITSdigit d = (AliITSdigit) digits->UncheckedAt(k);
5a5a1232	271	j = d->GetCoord1();
5a5a1232	272	i = d->GetCoord2();
9efc978d	273	x = -0.5seg->Dx() + iseg->Dpx(0);
	274	x *= 0.0001;
	275	fInfo->GetSPDLocalZ(j, z);
5a5a1232	276	dpx = seg->Dpx(i)*0.0001;
	277	dpz = seg->Dpz(j)*0.0001;
	278
9efc978d	279	AddQuad(x, z, dpx, dpz);
9efc978d	280	QuadValue(1); // In principle could have color based on number of neigbours
ffa36681	281	QuadId(d);
5a5a1232	282	}
9efc978d	283	break;
5a5a1232	284	}
5a5a1232	285
9efc978d	286	case 1: { // SDD
9efc978d	287	AliITSsegmentationSDD *seg = fInfo->fSegSDD;
5a5a1232	288
697c88e6	289	Reset(QT_RectangleXZFixedY, kFALSE, 32);
9efc978d	290
	291	for (Int_t k=0; k<ndigits; ++k)
	292	{
b3bc5327	293	AliITSdigit* d = (AliITSdigit*) digits->UncheckedAt(k);
9efc978d	294
	295	// if (d->GetSignal() > fgSDDThreshold)
	296	{
	297	j = d->GetCoord1();
	298	i = d->GetCoord2();
	299	seg->DetToLocal(i, j, x, z);
	300	dpx = seg->Dpx(i)*0.0001;
	301	dpz = seg->Dpz(j)*0.0001;
	302
97e1e1bc	303	AddQuad(x-2dpx, z - dpz0.5, 4*dpx, dpz);
9efc978d	304	QuadValue(d->GetSignal());
ffa36681	305	QuadId(d);
5a5a1232	306	}
9efc978d	307	}
	308	break;
	309	}
	310
	311	case 2: { // SSD
	312	AliITSsegmentationSSD* seg = fInfo->fSegSSD;
	313
697c88e6	314	Reset(QT_LineXZFixedY, kFALSE, 32);
9efc978d	315
	316	Float_t ap, an; // positive/negative angles -> offsets
	317	seg->Angles(ap, an);
	318	ap = TMath::Tan(ap) * fDz;
	319	an = - TMath::Tan(an) * fDz;
	320
	321	for (Int_t k=0; k<ndigits; ++k)
	322	{
b3bc5327	323	AliITSdigit d = (AliITSdigit) digits->UncheckedAt(k);
9efc978d	324	// if(d->GetSignal() > fgSSDThreshold)
	325	{
	326	j = d->GetCoord1();
	327	i = d->GetCoord2();
	328	seg->DetToLocal(i,j,x,z);
	329
	330	Float_t a = ( d->GetCoord1() == 1) ? ap : an;
	331
e974c097	332	AddLine(x-a, -fDz, 2a, 2fDz);
9efc978d	333	QuadValue(d->GetSignal());
ffa36681	334	QuadId(d);
9efc978d	335	// printf("%3d -> %3d -> %8x\n", d->GetSignal(), ci, fQuads.back().color);
5a5a1232	336	}
5a5a1232	337	}
9efc978d	338	break;
5a5a1232	339	}
5a5a1232	340
9efc978d	341	} // end switch
	342
	343	RefitPlex();
5a5a1232	344	}
	345
	346	/**************************************************************************/
	347
	348	void ITSModule::SetTrans()
	349	{
4852ff6f	350	// Set transformation matrix based on module id (use geometry to
	351	// retrieve this information).
	352
9efc978d	353	Double_t x[9];
	354	fHMTrans.UnitTrans();
	355
4852ff6f	356	// !!!! Here should use AliITSgeomTGeo ... but can i be sure
	357	// the geometry has been loaded?
	358
	359	// column major
9efc978d	360	fInfo->fGeom->GetRotMatrix(fID, x);
	361	fHMTrans.SetBaseVec(1, x[0], x[3], x[6]);
	362	fHMTrans.SetBaseVec(2, x[1], x[4], x[7]);
	363	fHMTrans.SetBaseVec(3, x[2], x[5], x[8]);
	364	// translation
	365	fInfo->fGeom->GetTrans(fID, x);
	366	fHMTrans.SetBaseVec(4, x);
5a5a1232	367	}
	368
	369	/**************************************************************************/
	370
32e219c2	371	void ITSModule::DigitSelected(Int_t idx)
ffa36681	372	{
	373	// Override control-click from QuadSet
	374
32e219c2	375	DigitBase* qb = GetDigit(idx);
ffa36681	376	TObject* obj = qb->fId.GetObject();
	377	AliITSdigit* d = dynamic_cast<AliITSdigit*>(obj);
	378	printf("ITSModule::QuadSelected "); Print();
	379	printf(" idx=%d, value=%d, obj=0x%lx, digit=0x%lx\n",
	380	idx, qb->fValue, (ULong_t)obj, (ULong_t)d);
	381	if (d)
	382	printf(" coord1=%3d coord2=%3d signal=%d\n",
	383	d->GetCoord1(), d->GetCoord2(), d->GetSignal());
	384
	385	}
	386
	387	/**************************************************************************/
	388
5a5a1232	389	void ITSModule::Print(Option_t* ) const
	390	{
	391	printf("ID %d, layer %d, ladder %d, det %d \n", fID, fLayer, fLadder, fDetID);
	392	}