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

// $Id$
// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

/**************************************************************************
 * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
 * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for          *
 * full copyright notice.                                                 *
 **************************************************************************/

#include "AliEveITSModule.h"

#include <AliITSgeomTGeo.h>
#include <AliITSsegmentationSPD.h>
#include <AliITSsegmentationSDD.h>
#include <AliITSsegmentationSSD.h>

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

#include <TEveTrans.h>
#include <TClonesArray.h>
#include <TStyle.h>


//______________________________________________________________________________
//
// Visualization of an ITS module.

ClassImp(AliEveITSModule)

Bool_t AliEveITSModule::fgStaticInitDone = kFALSE;

TEveFrameBox*    AliEveITSModule::fgSPDFrameBox = 0;
TEveFrameBox*    AliEveITSModule::fgSPDFrameBoxDead = 0;
TEveFrameBox*    AliEveITSModule::fgSDDFrameBox = 0;
TEveFrameBox*    AliEveITSModule::fgSSDFrameBox = 0;

TEveRGBAPalette* AliEveITSModule::fgSPDPalette  = 0;
TEveRGBAPalette* AliEveITSModule::fgSDDPalette  = 0;
TEveRGBAPalette* AliEveITSModule::fgSSDPalette  = 0;

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

AliEveITSModule::AliEveITSModule(const Text_t* n, const Text_t* t) :
  TEveQuadSet(n, t),
  fInfo(0),
  fID(-1), fDetID(-1),
  fLayer(-1), fLadder(-1), fDet(-1),
  fDx(0), fDz(0), fDy(0)
{
  // Constructor.
}

AliEveITSModule::AliEveITSModule(Int_t gid, AliEveITSDigitsInfo* info) :
  TEveQuadSet(Form("ITS module %d", gid)),
  fInfo  (0),
  fID(-1), fDetID(-1),
  fLayer(-1), fLadder(-1), fDet(-1),
  fDx(0), fDz(0), fDy(0)
{
  // Constructor with module id and data-source.

  SetDigitsInfo(info);
  SetID(gid);
}

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

  if (fInfo) fInfo->DecRefCount();
}

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

void AliEveITSModule::InitStatics(AliEveITSDigitsInfo* info)
{
  // Initialize static variables.
  //
  // Warning all sensor sizes are in microns, here we transform them
  // to cm. In Eve half-lengths/widths are used, hence another 1/2.

  if (fgStaticInitDone) return;
  fgStaticInitDone = kTRUE;

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

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

    fgSPDFrameBoxDead = new TEveFrameBox();
    fgSPDFrameBoxDead->SetAAQuadXZ(-dx, 0, -dz, 2*dx, 2*dz);
    fgSPDFrameBoxDead->SetFrameColor(kRed);
    fgSPDFrameBoxDead->SetFrameFill(kTRUE);
    fgSPDFrameBoxDead->IncRefCount();
  }

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

    fgSDDFrameBox = new TEveFrameBox();
    fgSDDFrameBox->SetAAQuadXZ(-dx, 0, -dz, 2*dx, 2*dz);
    fgSDDFrameBox->SetFrameColor(Color_t(32));
    fgSDDFrameBox->SetFrameFill(kTRUE);
    fgSDDFrameBox->IncRefCount();
    fgSDDPalette  = new TEveRGBAPalette(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 TEveFrameBox();
    fgSSDFrameBox->SetAAQuadXZ(-dx, 0, -dz, 2*dx, 2*dz);
    fgSSDFrameBox->SetFrameColor(Color_t(33));
    fgSSDFrameBox->SetFrameFill(kTRUE);
    fgSSDFrameBox->IncRefCount();
    fgSSDPalette  = new TEveRGBAPalette(info->fSSDMinVal,info->fSSDMaxVal);
    fgSSDPalette->SetLimits(0, info->fSSDHighLim); // Set proper ADC range.
    fgSSDPalette->IncRefCount();
  }

}

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

void AliEveITSModule::SetDigitsInfo(AliEveITSDigitsInfo* info)
{
  // Set data and geometry source.

  if (fInfo == info) return;
  if (fInfo) fInfo->DecRefCount();
  fInfo = info;
  if (fInfo) fInfo->IncRefCount();
}

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

void AliEveITSModule::SetID(Int_t gid, Bool_t trans)
{
  // Set detector id.

  static const TEveException kEH("AliEveITSModule::SetID ");

  if (fInfo == 0)
    throw(kEH + "AliEveITSDigitsInfo not set.");

  Int_t firstSPD = AliITSgeomTGeo::GetModuleIndex(1,1,1);
  Int_t lastSSD  = AliITSgeomTGeo::GetNModules() - 1;
  if (gid < firstSPD || gid > lastSSD)
  {
    throw(kEH + Form("%d is not valid. ID range from %d to %d", gid,
		    firstSPD, lastSSD ));
  }

  fID = gid;

  if (!fgStaticInitDone)
  {
    InitStatics(fInfo);
  }

  AliITSgeomTGeo::GetModuleId(fID, fLayer, fLadder, fDet);
  TString strLadder = "Ladder";
  TString strSensor = "Sensor";
  TString symname;
  Int_t   id, nsector, nstave, nladder, rest;

  if (fID <= (AliITSgeomTGeo::GetModuleIndex(3,1,1) - 1))
  {
    // SPD

    fDetID = 0;

    SetFrame(fInfo->IsDead(fID, fDetID) ? fgSPDFrameBoxDead : 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);
    fDx = fInfo->fSegSPD->Dx()*0.00005;
    fDz = 3.50;
    fDy = fInfo->fSegSPD->Dy()*0.00005;
  }
  else if (fID <= (AliITSgeomTGeo::GetModuleIndex(5,1,1) - 1))
  {
    // SDD

    fDetID = 1;

    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);
    fDx = fInfo->fSegSDD->Dx()*0.0001;
    fDz = fInfo->fSegSDD->Dz()*0.00005;
    fDy = fInfo->fSegSDD->Dy()*0.00005;
  }
  else
  {
    // SSD

    fDetID = 2;

    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);
    fInfo->fSegSSD->SetLayer(fLayer);
    fDx = fInfo->fSegSSD->Dx()*0.00005;
    fDz = fInfo->fSegSSD->Dz()*0.00005;
    fDy = fInfo->fSegSSD->Dy()*0.00005;
  }

  LoadQuads();
  RefitPlex();
  ComputeBBox();
  InitMainTrans();
  if (trans)
    SetTrans();

}

void AliEveITSModule::LoadQuads()
{
  // Read module data from source and create low-level objects for
  // visualization - called quads.

  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:
    {
      AliITSsegmentationSPD* seg =  fInfo->fSegSPD;

      Reset(kQT_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:
    {
      AliITSsegmentationSDD *seg =  fInfo->fSegSDD;

      Reset(kQT_RectangleXZFixedY, kFALSE, 32);

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

	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:
    {
      AliITSsegmentationSSD* seg = fInfo->fSegSSD;

      Reset(kQT_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);

	j = d->GetCoord1();
	i = d->GetCoord2();
	// !!!! The following function complains about not being verified.
	// !!!! Experts should check.
	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
}

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

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

  fMainTrans->SetFrom(*AliITSgeomTGeo::GetMatrix(fID));
}

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

void AliEveITSModule::DigitSelected(Int_t idx)
{
  // Override secondary select (alt-click) from TEveQuadSet.

  DigitBase_t *qb  = GetDigit(idx);
  TObject     *obj = qb->fId.GetObject();
  AliITSdigit *d   = dynamic_cast<AliITSdigit*>(obj);
  printf("AliEveITSModule::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 AliEveITSModule::Print(Option_t* ) const
{
  // Print object summary information.

  printf("AliEveITSModule: ID %d, layer %d, ladder %d, det %d\n",
         fID, fLayer, fLadder, fDetID);
}
Commit	Line	Data
d810d0de	1	// $Id$
	2	// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
	3
	4	/**************************************************************************
	5	* Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
	6	* See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
51346b82	7	* full copyright notice. *
d810d0de	8	**************************************************************************/
0879c50b	9
d810d0de	10	#include "AliEveITSModule.h"
5a5a1232	11
12f6a2f3	12	#include <AliITSgeomTGeo.h>
0879c50b	13	#include <AliITSsegmentationSPD.h>
	14	#include <AliITSsegmentationSDD.h>
	15	#include <AliITSsegmentationSSD.h>
	16
5a5a1232	17	#include <AliITSdigitSPD.h>
	18	#include <AliITSdigitSDD.h>
	19	#include <AliITSdigitSSD.h>
	20
a15e6d7d	21	#include <TEveTrans.h>
a15e6d7d	22	#include <TClonesArray.h>
5a5a1232	23	#include <TStyle.h>
5a5a1232	24
9efc978d	25
698e2c9b	26	//______________________________________________________________________________
	27	//
	28	// Visualization of an ITS module.
	29
	30	ClassImp(AliEveITSModule)
	31
0879c50b	32	Bool_t AliEveITSModule::fgStaticInitDone = kFALSE;
d810d0de	33
d810d0de	34	TEveFrameBox* AliEveITSModule::fgSPDFrameBox = 0;
fe6798e0	35	TEveFrameBox* AliEveITSModule::fgSPDFrameBoxDead = 0;
d810d0de	36	TEveFrameBox* AliEveITSModule::fgSDDFrameBox = 0;
d810d0de	37	TEveFrameBox* AliEveITSModule::fgSSDFrameBox = 0;
9efc978d	38
d810d0de	39	TEveRGBAPalette* AliEveITSModule::fgSPDPalette = 0;
	40	TEveRGBAPalette* AliEveITSModule::fgSDDPalette = 0;
	41	TEveRGBAPalette* AliEveITSModule::fgSSDPalette = 0;
9efc978d	42
57ffa5fb	43	/******************************************************************************/
5a5a1232	44
d810d0de	45	AliEveITSModule::AliEveITSModule(const Text_t* n, const Text_t* t) :
84aff7a4	46	TEveQuadSet(n, t),
265ecb21	47	fInfo(0),
	48	fID(-1), fDetID(-1),
	49	fLayer(-1), fLadder(-1), fDet(-1),
9efc978d	50	fDx(0), fDz(0), fDy(0)
698e2c9b	51	{
	52	// Constructor.
	53	}
5a5a1232	54
d810d0de	55	AliEveITSModule::AliEveITSModule(Int_t gid, AliEveITSDigitsInfo* info) :
84aff7a4	56	TEveQuadSet(Form("ITS module %d", gid)),
27db2029	57	fInfo (0),
265ecb21	58	fID(-1), fDetID(-1),
265ecb21	59	fLayer(-1), fLadder(-1), fDet(-1),
9efc978d	60	fDx(0), fDz(0), fDy(0)
5a5a1232	61	{
698e2c9b	62	// Constructor with module id and data-source.
698e2c9b	63
27db2029	64	SetDigitsInfo(info);
9c8221e9	65	SetID(gid);
5a5a1232	66	}
5a5a1232	67
d810d0de	68	AliEveITSModule::~AliEveITSModule()
5a5a1232	69	{
698e2c9b	70	// Destructor.
698e2c9b	71
4516a822	72	if (fInfo) fInfo->DecRefCount();
5a5a1232	73	}
5a5a1232	74
57ffa5fb	75	/******************************************************************************/
5a5a1232	76
d810d0de	77	void AliEveITSModule::InitStatics(AliEveITSDigitsInfo* info)
9efc978d	78	{
c93f2d9b	79	// Initialize static variables.
	80	//
	81	// Warning all sensor sizes are in microns, here we transform them
	82	// to cm. In Eve half-lengths/widths are used, hence another 1/2.
698e2c9b	83
9efc978d	84	if (fgStaticInitDone) return;
9c8221e9	85	fgStaticInitDone = kTRUE;
9efc978d	86
	87	{
	88	Float_t dx = info->fSegSPD->Dx()*0.00005;
c93f2d9b	89	Float_t dz = info->fSegSPD->Dz()*0.00005;
9efc978d	90
84aff7a4	91	fgSPDFrameBox = new TEveFrameBox();
9efc978d	92	fgSPDFrameBox->SetAAQuadXZ(-dx, 0, -dz, 2dx, 2dz);
ab73f3eb	93	fgSPDFrameBox->SetFrameColor(Color_t(31));
32e219c2	94	fgSPDFrameBox->SetFrameFill(kTRUE);
32e219c2	95	fgSPDFrameBox->IncRefCount();
84aff7a4	96	fgSPDPalette = new TEveRGBAPalette(info->fSPDMinVal,info->fSPDMaxVal);
32e219c2	97	fgSPDPalette->IncRefCount();
fe6798e0	98
	99	fgSPDFrameBoxDead = new TEveFrameBox();
	100	fgSPDFrameBoxDead->SetAAQuadXZ(-dx, 0, -dz, 2dx, 2dz);
	101	fgSPDFrameBoxDead->SetFrameColor(kRed);
	102	fgSPDFrameBoxDead->SetFrameFill(kTRUE);
	103	fgSPDFrameBoxDead->IncRefCount();
9efc978d	104	}
	105
	106	{
	107	Float_t dx = info->fSegSDD->Dx()*0.0001;
	108	Float_t dz = info->fSegSDD->Dz()*0.00005;
	109
84aff7a4	110	fgSDDFrameBox = new TEveFrameBox();
9efc978d	111	fgSDDFrameBox->SetAAQuadXZ(-dx, 0, -dz, 2dx, 2dz);
ab73f3eb	112	fgSDDFrameBox->SetFrameColor(Color_t(32));
32e219c2	113	fgSDDFrameBox->SetFrameFill(kTRUE);
32e219c2	114	fgSDDFrameBox->IncRefCount();
84aff7a4	115	fgSDDPalette = new TEveRGBAPalette(info->fSDDMinVal,info->fSDDMaxVal);
32e219c2	116	fgSDDPalette->SetLimits(0, info->fSDDHighLim); // Set proper ADC range.
32e219c2	117	fgSDDPalette->IncRefCount();
9efc978d	118	}
	119
	120	{
	121	Float_t dx = info->fSegSSD->Dx()*0.00005;
	122	Float_t dz = info->fSegSSD->Dz()*0.00005;
	123
84aff7a4	124	fgSSDFrameBox = new TEveFrameBox();
9efc978d	125	fgSSDFrameBox->SetAAQuadXZ(-dx, 0, -dz, 2dx, 2dz);
ab73f3eb	126	fgSSDFrameBox->SetFrameColor(Color_t(33));
32e219c2	127	fgSSDFrameBox->SetFrameFill(kTRUE);
32e219c2	128	fgSSDFrameBox->IncRefCount();
84aff7a4	129	fgSSDPalette = new TEveRGBAPalette(info->fSSDMinVal,info->fSSDMaxVal);
32e219c2	130	fgSSDPalette->SetLimits(0, info->fSSDHighLim); // Set proper ADC range.
32e219c2	131	fgSSDPalette->IncRefCount();
9efc978d	132	}
	133
	134	}
	135
57ffa5fb	136	/******************************************************************************/
9efc978d	137
d810d0de	138	void AliEveITSModule::SetDigitsInfo(AliEveITSDigitsInfo* info)
5a5a1232	139	{
698e2c9b	140	// Set data and geometry source.
698e2c9b	141
9c8221e9	142	if (fInfo == info) return;
	143	if (fInfo) fInfo->DecRefCount();
	144	fInfo = info;
	145	if (fInfo) fInfo->IncRefCount();
	146	}
	147
57ffa5fb	148	/******************************************************************************/
9c8221e9	149
d810d0de	150	void AliEveITSModule::SetID(Int_t gid, Bool_t trans)
9c8221e9	151	{
698e2c9b	152	// Set detector id.
698e2c9b	153
a15e6d7d	154	static const TEveException kEH("AliEveITSModule::SetID ");
9efc978d	155
12f6a2f3	156	if (fInfo == 0)
a15e6d7d	157	throw(kEH + "AliEveITSDigitsInfo not set.");
9c8221e9	158
ff67a00a	159	Int_t firstSPD = AliITSgeomTGeo::GetModuleIndex(1,1,1);
	160	Int_t lastSSD = AliITSgeomTGeo::GetNModules() - 1;
	161	if (gid < firstSPD \|\| gid > lastSSD)
12f6a2f3	162	{
a15e6d7d	163	throw(kEH + Form("%d is not valid. ID range from %d to %d", gid,
12f6a2f3	164	firstSPD, lastSSD ));
12f6a2f3	165	}
9c8221e9	166
	167	fID = gid;
	168
4516a822	169	if (!fgStaticInitDone)
4516a822	170	{
1d3c2b09	171	InitStatics(fInfo);
1d3c2b09	172	}
9c8221e9	173
12f6a2f3	174	AliITSgeomTGeo::GetModuleId(fID, fLayer, fLadder, fDet);
ba6cfb13	175	TString strLadder = "Ladder";
	176	TString strSensor = "Sensor";
	177	TString symname;
9c8221e9	178	Int_t id, nsector, nstave, nladder, rest;
51346b82	179
12f6a2f3	180	if (fID <= (AliITSgeomTGeo::GetModuleIndex(3,1,1) - 1))
9efc978d	181	{
	182	// SPD
	183
fe6798e0	184	fDetID = 0;
	185
	186	SetFrame(fInfo->IsDead(fID, fDetID) ? fgSPDFrameBoxDead : fgSPDFrameBox);
9c8221e9	187	SetPalette(fgSPDPalette);
51346b82	188
9efc978d	189	symname += strLadder;
	190	if (fID < 80)
	191	{
ba6cfb13	192	nsector = fID/8;
9efc978d	193	rest = fID - 8*nsector;
	194	nstave = 1;
	195	}
	196	else
	197	{
	198	id = fID - 80;
ba6cfb13	199	nsector = id/8;
9efc978d	200	rest = id - 8*nsector;
9efc978d	201	nstave = 1;
ba6cfb13	202	}
9efc978d	203	if (rest < 4) nstave = 0;
	204	rest -= 4*nstave;
	205	symname += rest;
	206	SetName(symname);
9efc978d	207	fDx = fInfo->fSegSPD->Dx()*0.00005;
51346b82	208	fDz = 3.50;
9efc978d	209	fDy = fInfo->fSegSPD->Dy()*0.00005;
5a5a1232	210	}
12f6a2f3	211	else if (fID <= (AliITSgeomTGeo::GetModuleIndex(5,1,1) - 1))
9efc978d	212	{
	213	// SDD
	214
fe6798e0	215	fDetID = 1;
fe6798e0	216
9c8221e9	217	SetFrame(fgSDDFrameBox);
9c8221e9	218	SetPalette(fgSDDPalette);
51346b82	219
9efc978d	220	symname += strSensor;
	221	if (fID < 324)
	222	{
	223	id = fID - 240;
ba6cfb13	224	nladder = id/6;
9efc978d	225	rest = id - 6*nladder;
	226	}
	227	else
	228	{
	229	id = fID - 324;
ba6cfb13	230	nladder = id/8;
9efc978d	231	rest = id - 8*nladder;
ba6cfb13	232	}
9efc978d	233	symname += rest;
9efc978d	234	SetName(symname);
9efc978d	235	fDx = fInfo->fSegSDD->Dx()*0.0001;
	236	fDz = fInfo->fSegSDD->Dz()*0.00005;
	237	fDy = fInfo->fSegSDD->Dy()*0.00005;
5a5a1232	238	}
9efc978d	239	else
	240	{
	241	// SSD
	242
fe6798e0	243	fDetID = 2;
fe6798e0	244
9c8221e9	245	SetFrame(fgSSDFrameBox);
	246	SetPalette(fgSSDPalette);
	247
9efc978d	248	symname += strSensor;
	249	if (fID < 1248)
	250	{
	251	id = fID - 500;
ba6cfb13	252	nladder = id/22;
9efc978d	253	rest = id - nladder*22;
	254	}
	255	else
	256	{
	257	id = fID - 1248;
ba6cfb13	258	nladder = id/25;
9efc978d	259	rest = id - nladder*25;
ba6cfb13	260	}
9efc978d	261	symname += rest;
9efc978d	262	SetName(symname);
51346b82	263	fInfo->fSegSSD->SetLayer(fLayer);
9efc978d	264	fDx = fInfo->fSegSSD->Dx()*0.00005;
	265	fDz = fInfo->fSegSSD->Dz()*0.00005;
	266	fDy = fInfo->fSegSSD->Dy()*0.00005;
5a5a1232	267	}
5a5a1232	268
51346b82	269	LoadQuads();
fe6798e0	270	RefitPlex();
5a5a1232	271	ComputeBBox();
a15e6d7d	272	InitMainTrans();
97e1e1bc	273	if (trans)
97e1e1bc	274	SetTrans();
fe6798e0	275
5a5a1232	276	}
5a5a1232	277
d810d0de	278	void AliEveITSModule::LoadQuads()
5a5a1232	279	{
698e2c9b	280	// Read module data from source and create low-level objects for
698e2c9b	281	// visualization - called quads.
9efc978d	282
b3bc5327	283	TClonesArray *digits = fInfo->GetDigits(fID, fDetID);
	284	Int_t ndigits = digits ? digits->GetEntriesFast() : 0;
	285
51346b82	286	Float_t x, z, dpx, dpz;
b3bc5327	287	Int_t i, j;
5a5a1232	288
9efc978d	289	switch(fDetID)
9efc978d	290	{
4516a822	291	case 0:
4516a822	292	{
51346b82	293	AliITSsegmentationSPD* seg = fInfo->fSegSPD;
9efc978d	294
84aff7a4	295	Reset(kQT_RectangleXZFixedY, kFALSE, 32);
5a5a1232	296
9efc978d	297	for (Int_t k=0; k<ndigits; ++k)
9efc978d	298	{
b3bc5327	299	AliITSdigit d = (AliITSdigit) digits->UncheckedAt(k);
5a5a1232	300	j = d->GetCoord1();
5a5a1232	301	i = d->GetCoord2();
9efc978d	302	x = -0.5seg->Dx() + iseg->Dpx(0);
	303	x *= 0.0001;
	304	fInfo->GetSPDLocalZ(j, z);
5a5a1232	305	dpx = seg->Dpx(i)*0.0001;
	306	dpz = seg->Dpz(j)*0.0001;
	307
9efc978d	308	AddQuad(x, z, dpx, dpz);
9efc978d	309	QuadValue(1); // In principle could have color based on number of neigbours
ffa36681	310	QuadId(d);
5a5a1232	311	}
9efc978d	312	break;
5a5a1232	313	}
5a5a1232	314
4516a822	315	case 1:
4516a822	316	{
51346b82	317	AliITSsegmentationSDD *seg = fInfo->fSegSDD;
5a5a1232	318
84aff7a4	319	Reset(kQT_RectangleXZFixedY, kFALSE, 32);
9efc978d	320
	321	for (Int_t k=0; k<ndigits; ++k)
	322	{
b3bc5327	323	AliITSdigit* d = (AliITSdigit*) digits->UncheckedAt(k);
9efc978d	324
4516a822	325	j = d->GetCoord1();
	326	i = d->GetCoord2();
	327	seg->DetToLocal(i, j, x, z);
	328	dpx = seg->Dpx(i)*0.0001;
	329	dpz = seg->Dpz(j)*0.0001;
	330
	331	AddQuad(x-2dpx, z - dpz0.5, 4*dpx, dpz);
	332	QuadValue(d->GetSignal());
	333	QuadId(d);
9efc978d	334	}
	335	break;
	336	}
	337
4516a822	338	case 2:
4516a822	339	{
51346b82	340	AliITSsegmentationSSD* seg = fInfo->fSegSSD;
9efc978d	341
84aff7a4	342	Reset(kQT_LineXZFixedY, kFALSE, 32);
9efc978d	343
	344	Float_t ap, an; // positive/negative angles -> offsets
	345	seg->Angles(ap, an);
	346	ap = TMath::Tan(ap) * fDz;
	347	an = - TMath::Tan(an) * fDz;
	348
	349	for (Int_t k=0; k<ndigits; ++k)
	350	{
b3bc5327	351	AliITSdigit d = (AliITSdigit) digits->UncheckedAt(k);
4516a822	352
	353	j = d->GetCoord1();
	354	i = d->GetCoord2();
	355	// !!!! The following function complains about not being verified.
	356	// !!!! Experts should check.
	357	seg->DetToLocal(i,j,x,z);
	358
	359	Float_t a = (d->GetCoord1() == 1) ? ap : an;
	360
	361	AddLine(x-a, -fDz, 2a, 2fDz);
	362	QuadValue(d->GetSignal());
	363	QuadId(d);
	364	// printf("%3d -> %3d -> %8x\n", d->GetSignal(), ci, fQuads.back().color);
5a5a1232	365	}
9efc978d	366	break;
5a5a1232	367	}
5a5a1232	368
9efc978d	369	} // end switch
5a5a1232	370	}
5a5a1232	371
57ffa5fb	372	/******************************************************************************/
5a5a1232	373
d810d0de	374	void AliEveITSModule::SetTrans()
5a5a1232	375	{
4852ff6f	376	// Set transformation matrix based on module id (use geometry to
	377	// retrieve this information).
	378
a15e6d7d	379	fMainTrans->SetFrom(*AliITSgeomTGeo::GetMatrix(fID));
5a5a1232	380	}
5a5a1232	381
57ffa5fb	382	/******************************************************************************/
5a5a1232	383
d810d0de	384	void AliEveITSModule::DigitSelected(Int_t idx)
ffa36681	385	{
12f6a2f3	386	// Override secondary select (alt-click) from TEveQuadSet.
ffa36681	387
12f6a2f3	388	DigitBase_t *qb = GetDigit(idx);
	389	TObject *obj = qb->fId.GetObject();
	390	AliITSdigit d = dynamic_cast<AliITSdigit>(obj);
d810d0de	391	printf("AliEveITSModule::QuadSelected "); Print();
ffa36681	392	printf(" idx=%d, value=%d, obj=0x%lx, digit=0x%lx\n",
	393	idx, qb->fValue, (ULong_t)obj, (ULong_t)d);
	394	if (d)
	395	printf(" coord1=%3d coord2=%3d signal=%d\n",
	396	d->GetCoord1(), d->GetCoord2(), d->GetSignal());
	397
	398	}
	399
57ffa5fb	400	/******************************************************************************/
ffa36681	401
d810d0de	402	void AliEveITSModule::Print(Option_t* ) const
5a5a1232	403	{
698e2c9b	404	// Print object summary information.
	405
	406	printf("AliEveITSModule: ID %d, layer %d, ladder %d, det %d\n",
	407	fID, fLayer, fLadder, fDetID);
5a5a1232	408	}