[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 <AliITSgeom.h>
#include <AliITSsegmentationSPD.h>
#include <AliITSsegmentationSDD.h>
#include <AliITSsegmentationSSD.h>

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

#include <TStyle.h>


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

ClassImp(AliEveITSModule)

Bool_t AliEveITSModule::fgStaticInitDone = kFALSE;

TEveFrameBox*    AliEveITSModule::fgSPDFrameBox = 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,

  if (fgStaticInitDone) return;
  fgStaticInitDone = kTRUE;

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

    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();
  }

  {
    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 eH("AliEveITSModule::SetID ");

  if(fInfo == 0)
    throw(eH + "AliEveITSDigitsInfo 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 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: { // SPD
      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: { // SDD
      AliITSsegmentationSDD *seg =  fInfo->fSegSDD;

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