[u/mrichter/AliRoot.git] / EVE / EveDet / AliEveITSScaledModule.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 "AliEveITSScaledModule.h"

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

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

#include <TMath.h>
#include <TClonesArray.h>

//==============================================================================
//==============================================================================
// AliEveDigitScaleInfo
//==============================================================================

//______________________________________________________________________________
//
// Encapsulates current state of scaling and agglomeration.

ClassImp(AliEveDigitScaleInfo)

AliEveDigitScaleInfo::AliEveDigitScaleInfo():
  fScale(1),
  fStatType (kSTAverage),
  fSyncPalette(kFALSE)
{
}

void AliEveDigitScaleInfo::ScaleChanged(Int_t s)
{
  fScale = s;

  AliEveITSScaledModule* sm;
  std::list<TEveElement*>::iterator i = fBackRefs.begin();
  while (i != fBackRefs.end())
  {
    sm = dynamic_cast<AliEveITSScaledModule*>(*i);
    if(sm) sm->LoadQuads();
    ++i;
  }
}

void AliEveDigitScaleInfo::StatTypeChanged(Int_t t)
{
  fStatType = t;
  fSyncPalette = kTRUE;

  AliEveITSScaledModule* sm;
  std::list<TEveElement*>::iterator i = fBackRefs.begin();
  while (i != fBackRefs.end())
  {
    sm = dynamic_cast<AliEveITSScaledModule*>(*i);
    if (sm) sm->SetQuadValues();
    ++i;
  }
}

//______________________________________________________________________________
// ScaledDigit_t
//

AliEveITSScaledModule::ScaledDigit_t::ScaledDigit_t() :
  TObject(),
  fN(0),
  fSum(0), fSqrSum(0),
  fMinI(-1), fMinJ(-1), fMaxI(-1), fMaxJ(-1)
{
}

AliEveITSScaledModule::ScaledDigit_t::ScaledDigit_t(Int_t di, Int_t dj) :
  TObject(),
  fN(0),
  fSum(0), fSqrSum(0),
  fMinI(di), fMinJ(dj), fMaxI(di), fMaxJ(dj)
{
}

void AliEveITSScaledModule::ScaledDigit_t::Dump() const
{
  printf("N %d, sum %f, sqr_sum %f", fN, fSum, fSqrSum);
}


//==============================================================================
//==============================================================================
// AliEveITSScaledModule
//==============================================================================

//______________________________________________________________________________
//
// Visualization of an ITS module with digits aggregated
// on a grid of pre-defined size.

ClassImp(AliEveITSScaledModule)

AliEveITSScaledModule::AliEveITSScaledModule(Int_t gid, AliEveITSDigitsInfo* info, AliEveDigitScaleInfo* si):
  AliEveITSModule("AliEveITSScaledModule", "AliEveITSScaledModule"),
  fNx(-1),
  fNz(-1),
  fNCx(-1),
  fNCz(-1),
  fScaleInfo(si),
  fDigitsMap()
{
  SetOwnIds(kTRUE);

  SetDigitsInfo(info);
  SetID(gid);
  fScaleInfo->IncRefCount(this);
}

AliEveITSScaledModule::~AliEveITSScaledModule()
{
  fScaleInfo->DecRefCount(this);
}

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

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

  TClonesArray *digits = fInfo->GetDigits(fID, fDetID);
  if (!digits) return;

  Int_t ndigits = digits->GetEntriesFast();

  Float_t       x, z, zo, dpx, dpz; // orig cells size, pos
  Int_t         i, j;               // orig cells idx
  Int_t         c1, c2;             // original coordinates

  Int_t id;
  std::map<Int_t, Int_t> dmap;
  std::map<Int_t, Int_t>::iterator miter;

  Int_t scale = fScaleInfo->GetScale() -1;
  switch(fDetID)
  {
    case 0:
    {
      // SPD
      Reset(kQT_RectangleXZFixedY, kFALSE, 32);

      fNCz = fInfo->fSPDScaleZ[scale];
      fNCx = fInfo->fSPDScaleX[scale];
      fNz  = Int_t(fInfo->fSegSPD->Npz()/fNCz);
      fNx  = Int_t(fInfo->fSegSPD->Npx()/fNCx);
      dpz = 2*fDz/fNz;
      dpx = 2*fDx/fNx;
      //printf("SPD orig cells (%d, %d) (%d, %d)\n", fInfo->fSegSPD->Npx(), fInfo->fSegSPD->Npz(), Nx, Nz);

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

	fInfo->GetSPDLocalZ(od->GetCoord1(),zo);
        c1 = od->GetCoord1(); c2 = od->GetCoord2();
	i  = Int_t((zo+fDz)/dpz);
	j  = Int_t((od->GetCoord2()*fNx)/fInfo->fSegSPD->Npx());
	id = j*fNx + i;

        ScaledDigit_t* sd = 0;
        miter = dmap.find(id);
	if(miter == dmap.end())
	{
          dmap[id] = fPlex.Size();
          z = dpz*(i) - fDz;
          x = dpx*(j) - fDx;
          AddQuad(x, z, dpx, dpz);
          sd = new ScaledDigit_t(c1, c2);
	  QuadId(sd);
	}
        else
	{
	  sd = dynamic_cast<ScaledDigit_t*>(GetId(miter->second));
          if(c1 < sd->fMinI)
	    sd->fMinI = c1;
	  else if( c1 > sd->fMaxI)
            sd->fMaxI = c1;

          if(c2 < sd->fMinJ)
	    sd->fMinJ = c2;
	  else if( c2 > sd->fMaxJ)
	    sd->fMaxJ = c2;
	}

	sd->fN++;
	sd->fSum  += od->GetSignal();
	sd->fSqrSum += od->GetSignal()*od->GetSignal();
      }
      break;
    }
    case 1:
    {
      // SDD
      Reset(kQT_RectangleXZFixedY, kFALSE, 32);

      fNCz = fInfo->fSDDScaleZ[scale];
      fNCx = fInfo->fSDDScaleX[scale];
      fNz  = Int_t(fInfo->fSegSDD->Npz()/fNCz);
      fNx  = Int_t(fInfo->fSegSDD->Npx()/fNCx);
      dpz  = 2*fDz/fNz;
      dpx  = 2*fDx/fNx;

      AliITSdigitSDD *od = 0;
      for (Int_t k = 0; k < ndigits; ++k)
      {
	od = (AliITSdigitSDD*)digits->UncheckedAt(k);
	fInfo->fSegSDD->DetToLocal(od->GetCoord2(), od->GetCoord1(),x,z);
	z += fDz;
	x += fDx;
	i  = Int_t(z/dpz);
	j  = Int_t(x/dpx);
	//printf("Mod %d coord %d,%d out of %d,%d :: ORIG coord %d,%d out of %d,%d \n",fID,
	//       i,j,Nz,Nx,od->GetCoord1(),od->GetCoord2(),fInfo->fSegSDD->Npz(),fInfo->fSegSDD->Npx());

	id = j*fNx + i;
	c1 = od->GetCoord1(); c2 = od->GetCoord2();

	ScaledDigit_t* sd = 0;
	miter = dmap.find(id);
	if(miter == dmap.end())
	{
	  dmap[id] = fPlex.Size();
	  z = dpz*(i) - fDz;
	  x = dpx*(j) - fDx;
	  AddQuad(x, z, dpx, dpz);
	  sd = new ScaledDigit_t(od->GetCoord1(),od->GetCoord2());
	  QuadId(sd);
	}
	else
	{
	  sd = dynamic_cast<ScaledDigit_t*>(GetId(miter->second));
	  if(c1 < sd->fMinI)
	    sd->fMinI = c1;
	  else if( c1 > sd->fMaxI)
	    sd->fMaxI = c1;

	  if(c2 < sd->fMinJ)
	    sd->fMinJ = c2;
	  else if( c2 > sd->fMaxJ)
	    sd->fMaxJ = c2;
	}
	sd->fN++;
	sd->fSum  += od->GetSignal();
	sd->fSqrSum += od->GetSignal()*od->GetSignal();
      }
      break;
    }
    case 2:
    {
      // SSD
      Reset(kQT_LineXZFixedY, kFALSE, 32);

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

      fNCx  = fInfo->fSSDScale[scale];
      fNz  = 1;
      fNx  = Int_t(fInfo->fSegSSD->Npx()/fNCx);
      dpz = 2*fDz/fNz;
      dpx = 2*fDx/fNx;

      AliITSdigitSSD *od = 0;
      for (Int_t k=0; k<ndigits; k++) {
	od=(AliITSdigitSSD*)digits->UncheckedAt(k);
	if(od->GetCoord1() == 1)
	  i = 1; // p side
	else
	  i= -1; // n side
	j = Int_t(od->GetCoord2()/fNCx);
	c1 = od->GetCoord1(); c2 = od->GetCoord2();
	id = j*i;

	ScaledDigit_t* sd = 0;
	miter = dmap.find(id);
	if(miter == dmap.end())
	{
	  // printf("orig digit %d,%d scaled %d,%d \n",od->GetCoord1(),od->GetCoord2(),i,j);
	  dmap[id] = fPlex.Size();
	  z = dpz*(i) - fDz;
	  x = dpx*(j) - fDx;
	  Float_t a = ( od->GetCoord1() == 1) ? ap : an;
	  AddLine(x-a, -fDz, 2*a, 2*fDz);

	  sd = new ScaledDigit_t(c1, c2);
	  QuadId(sd);
	}
	else
	{
	  sd = dynamic_cast<ScaledDigit_t*>(GetId(miter->second));
	  if(c1 < sd->fMinI)
	    sd->fMinI = c1;
	  else if( c1 > sd->fMaxI)
	    sd->fMaxI = c1;

	  if(c2 < sd->fMinJ)
	    sd->fMinJ = c2;
	  else if( c2 > sd->fMaxJ)
	    sd->fMaxJ = c2;
	}
	sd->fN++;
	sd->fSum  += od->GetSignal();
	sd->fSqrSum += od->GetSignal()*od->GetSignal();
      } // for digits
      break;
    } // end case 2
  } // end switch

  SetQuadValues();
  RefitPlex();
}

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

void AliEveITSScaledModule::SetQuadValues()
{
  if(fScaleInfo->GetSyncPalette()) SyncPalette();

  Int_t num = fPlex.Size();
  for (Int_t i = 0 ; i < num; i++)
  {
    ScaledDigit_t* sd = dynamic_cast<ScaledDigit_t*>(GetId(i));
    Int_t v = 0;
    switch(fScaleInfo->GetStatType())
    {
      using namespace TMath;

      case AliEveDigitScaleInfo::kSTOccup:
	v = Nint((100.0*sd->fN) / (fNCx*fNCz));
	break;
      case AliEveDigitScaleInfo::kSTAverage:
	v = Nint((Double_t) sd->fSum / sd->fN);
	break;
      case AliEveDigitScaleInfo::kSTRms:
	v = Nint(Sqrt(sd->fSqrSum) / sd->fN);
	break;
    }
    DigitBase_t* qb = GetDigit(i);
    qb->fValue = v;
  }
}

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

void AliEveITSScaledModule::SyncPalette()
{
  // printf("AliEveITSScaledModule::SyncPalette()\n");
  if(fScaleInfo->GetStatType() == AliEveDigitScaleInfo::kSTOccup)
  {
    // SPD
    AliEveITSModule::fgSPDPalette->SetLimits(0, 100);
    AliEveITSModule::fgSPDPalette->SetMinMax(0, 100);

    // SDD
    AliEveITSModule::fgSDDPalette->SetLimits(0, 100);
    AliEveITSModule::fgSDDPalette->SetMinMax(0, 100);

    // SSD
    AliEveITSModule::fgSSDPalette->SetLimits(0, 100);
    AliEveITSModule::fgSDDPalette->SetMinMax(0, 100);
  }
  else
  {
    AliEveITSDigitsInfo& di = *fInfo;
    // SPD
    AliEveITSModule::fgSPDPalette->SetLimits(0, di.fSPDHighLim);
    AliEveITSModule::fgSPDPalette->SetMinMax(di.fSPDMinVal, di.fSPDMaxVal);

    // SDD
    AliEveITSModule::fgSDDPalette->SetLimits(0, di.fSDDHighLim);
    AliEveITSModule::fgSDDPalette->SetMinMax(di.fSDDMinVal, di.fSDDMaxVal);

    // SSD
    AliEveITSModule::fgSSDPalette->SetLimits(0, di.fSSDHighLim);
    AliEveITSModule::fgSSDPalette->SetMinMax(di.fSSDMinVal, di.fSSDMaxVal);
  }

  fScaleInfo->SetSyncPalette(kFALSE);
}

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

void AliEveITSScaledModule::GetScaleData(Int_t& cnx, Int_t& cnz, Int_t& total) const
{
  cnx   = fNx;
  cnz   = fNz;
  total = cnx*cnz;
}

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

void  AliEveITSScaledModule::DigitSelected(Int_t idx)
{
  // Override control-click from TEveQuadSet
  printf("AliEveITSScaledModule::DigitSelected "); Print();

  // DigitBase_t *qb  = GetDigit(idx);
  TObject     *obj = GetId(idx);
  ScaledDigit_t *sd = dynamic_cast<ScaledDigit_t*>(obj);
  TClonesArray *digits = fInfo->GetDigits(fID, fDetID);
  Int_t ndigits = digits->GetEntriesFast();

  printf("%d digits in cell scaleX = %d,  scaleZ = %d \n", sd->fN, fNCx, fNCz);

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

    if(d->GetCoord1()>=sd->fMinI && d->GetCoord1()<=sd->fMaxI &&
       d->GetCoord2()>=sd->fMinJ && d->GetCoord2()<=sd->fMaxJ)
    {
      printf("%3d, %3d: %3d", d->GetCoord1(), d->GetCoord2(), d->GetSignal());
      printf(" | ");
      il++;
      if(il>5) {
	printf("\n");
	il = 0;
      }
    }
  }
  if(il) printf("\n");
}
Commit	Line	Data
	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 *
	7	* full copyright notice. *
	8	**************************************************************************/
	9
	10	#include "AliEveITSScaledModule.h"
	11
	12	#include <AliITSsegmentationSPD.h>
	13	#include <AliITSsegmentationSDD.h>
	14	#include <AliITSsegmentationSSD.h>
	15
	16	#include <AliITSdigitSPD.h>
	17	#include <AliITSdigitSDD.h>
	18	#include <AliITSdigitSSD.h>
	19
	20	#include <TMath.h>
	21	#include <TClonesArray.h>
	22
	23	//==============================================================================
	24	//==============================================================================
	25	// AliEveDigitScaleInfo
	26	//==============================================================================
	27
	28	//______________________________________________________________________________
	29	//
	30	// Encapsulates current state of scaling and agglomeration.
	31
	32	ClassImp(AliEveDigitScaleInfo)
	33
	34	AliEveDigitScaleInfo::AliEveDigitScaleInfo():
	35	fScale(1),
	36	fStatType (kSTAverage),
	37	fSyncPalette(kFALSE)
	38	{
	39	}
	40
	41	void AliEveDigitScaleInfo::ScaleChanged(Int_t s)
	42	{
	43	fScale = s;
	44
	45	AliEveITSScaledModule* sm;
	46	std::list<TEveElement*>::iterator i = fBackRefs.begin();
	47	while (i != fBackRefs.end())
	48	{
	49	sm = dynamic_cast<AliEveITSScaledModule>(i);
	50	if(sm) sm->LoadQuads();
	51	++i;
	52	}
	53	}
	54
	55	void AliEveDigitScaleInfo::StatTypeChanged(Int_t t)
	56	{
	57	fStatType = t;
	58	fSyncPalette = kTRUE;
	59
	60	AliEveITSScaledModule* sm;
	61	std::list<TEveElement*>::iterator i = fBackRefs.begin();
	62	while (i != fBackRefs.end())
	63	{
	64	sm = dynamic_cast<AliEveITSScaledModule>(i);
	65	if (sm) sm->SetQuadValues();
	66	++i;
	67	}
	68	}
	69
	70	//______________________________________________________________________________
	71	// ScaledDigit_t
	72	//
	73
	74	AliEveITSScaledModule::ScaledDigit_t::ScaledDigit_t() :
	75	TObject(),
	76	fN(0),
	77	fSum(0), fSqrSum(0),
	78	fMinI(-1), fMinJ(-1), fMaxI(-1), fMaxJ(-1)
	79	{
	80	}
	81
	82	AliEveITSScaledModule::ScaledDigit_t::ScaledDigit_t(Int_t di, Int_t dj) :
	83	TObject(),
	84	fN(0),
	85	fSum(0), fSqrSum(0),
	86	fMinI(di), fMinJ(dj), fMaxI(di), fMaxJ(dj)
	87	{
	88	}
	89
	90	void AliEveITSScaledModule::ScaledDigit_t::Dump() const
	91	{
	92	printf("N %d, sum %f, sqr_sum %f", fN, fSum, fSqrSum);
	93	}
	94
	95
	96	//==============================================================================
	97	//==============================================================================
	98	// AliEveITSScaledModule
	99	//==============================================================================
	100
	101	//______________________________________________________________________________
	102	//
	103	// Visualization of an ITS module with digits aggregated
	104	// on a grid of pre-defined size.
	105
	106	ClassImp(AliEveITSScaledModule)
	107
	108	AliEveITSScaledModule::AliEveITSScaledModule(Int_t gid, AliEveITSDigitsInfo* info, AliEveDigitScaleInfo* si):
	109	AliEveITSModule("AliEveITSScaledModule", "AliEveITSScaledModule"),
	110	fNx(-1),
	111	fNz(-1),
	112	fNCx(-1),
	113	fNCz(-1),
	114	fScaleInfo(si),
	115	fDigitsMap()
	116	{
	117	SetOwnIds(kTRUE);
	118
	119	SetDigitsInfo(info);
	120	SetID(gid);
	121	fScaleInfo->IncRefCount(this);
	122	}
	123
	124	AliEveITSScaledModule::~AliEveITSScaledModule()
	125	{
	126	fScaleInfo->DecRefCount(this);
	127	}
	128
	129	/******************************************************************************/
	130
	131	void AliEveITSScaledModule::LoadQuads()
	132	{
	133	// Here we still use 'z' for the name of axial coordinates.
	134	// The transforamtion matrix aplied rotates y -> z.
	135	// We need this as TEveQuadSet offers optimized treatment for
	136	// quads in the x-y plane.
	137
	138	TClonesArray *digits = fInfo->GetDigits(fID, fDetID);
	139	if (!digits) return;
	140
	141	Int_t ndigits = digits->GetEntriesFast();
	142
	143	Float_t x, z, zo, dpx, dpz; // orig cells size, pos
	144	Int_t i, j; // orig cells idx
	145	Int_t c1, c2; // original coordinates
	146
	147	Int_t id;
	148	std::map<Int_t, Int_t> dmap;
	149	std::map<Int_t, Int_t>::iterator miter;
	150
	151	Int_t scale = fScaleInfo->GetScale() -1;
	152	switch(fDetID)
	153	{
	154	case 0:
	155	{
	156	// SPD
	157	Reset(kQT_RectangleXZFixedY, kFALSE, 32);
	158
	159	fNCz = fInfo->fSPDScaleZ[scale];
	160	fNCx = fInfo->fSPDScaleX[scale];
	161	fNz = Int_t(fInfo->fSegSPD->Npz()/fNCz);
	162	fNx = Int_t(fInfo->fSegSPD->Npx()/fNCx);
	163	dpz = 2*fDz/fNz;
	164	dpx = 2*fDx/fNx;
	165	//printf("SPD orig cells (%d, %d) (%d, %d)\n", fInfo->fSegSPD->Npx(), fInfo->fSegSPD->Npz(), Nx, Nz);
	166
	167	AliITSdigitSPD *od ;
	168	for (Int_t k=0; k<ndigits; ++k)
	169	{
	170	od = (AliITSdigitSPD*) digits->UncheckedAt(k);
	171
	172	fInfo->GetSPDLocalZ(od->GetCoord1(),zo);
	173	c1 = od->GetCoord1(); c2 = od->GetCoord2();
	174	i = Int_t((zo+fDz)/dpz);
	175	j = Int_t((od->GetCoord2()*fNx)/fInfo->fSegSPD->Npx());
	176	id = j*fNx + i;
	177
	178	ScaledDigit_t* sd = 0;
	179	miter = dmap.find(id);
	180	if(miter == dmap.end())
	181	{
	182	dmap[id] = fPlex.Size();
	183	z = dpz*(i) - fDz;
	184	x = dpx*(j) - fDx;
	185	AddQuad(x, z, dpx, dpz);
	186	sd = new ScaledDigit_t(c1, c2);
	187	QuadId(sd);
	188	}
	189	else
	190	{
	191	sd = dynamic_cast<ScaledDigit_t*>(GetId(miter->second));
	192	if(c1 < sd->fMinI)
	193	sd->fMinI = c1;
	194	else if( c1 > sd->fMaxI)
	195	sd->fMaxI = c1;
	196
	197	if(c2 < sd->fMinJ)
	198	sd->fMinJ = c2;
	199	else if( c2 > sd->fMaxJ)
	200	sd->fMaxJ = c2;
	201	}
	202
	203	sd->fN++;
	204	sd->fSum += od->GetSignal();
	205	sd->fSqrSum += od->GetSignal()*od->GetSignal();
	206	}
	207	break;
	208	}
	209	case 1:
	210	{
	211	// SDD
	212	Reset(kQT_RectangleXZFixedY, kFALSE, 32);
	213
	214	fNCz = fInfo->fSDDScaleZ[scale];
	215	fNCx = fInfo->fSDDScaleX[scale];
	216	fNz = Int_t(fInfo->fSegSDD->Npz()/fNCz);
	217	fNx = Int_t(fInfo->fSegSDD->Npx()/fNCx);
	218	dpz = 2*fDz/fNz;
	219	dpx = 2*fDx/fNx;
	220
	221	AliITSdigitSDD *od = 0;
	222	for (Int_t k = 0; k < ndigits; ++k)
	223	{
	224	od = (AliITSdigitSDD*)digits->UncheckedAt(k);
	225	fInfo->fSegSDD->DetToLocal(od->GetCoord2(), od->GetCoord1(),x,z);
	226	z += fDz;
	227	x += fDx;
	228	i = Int_t(z/dpz);
	229	j = Int_t(x/dpx);
	230	//printf("Mod %d coord %d,%d out of %d,%d :: ORIG coord %d,%d out of %d,%d \n",fID,
	231	// i,j,Nz,Nx,od->GetCoord1(),od->GetCoord2(),fInfo->fSegSDD->Npz(),fInfo->fSegSDD->Npx());
	232
	233	id = j*fNx + i;
	234	c1 = od->GetCoord1(); c2 = od->GetCoord2();
	235
	236	ScaledDigit_t* sd = 0;
	237	miter = dmap.find(id);
	238	if(miter == dmap.end())
	239	{
	240	dmap[id] = fPlex.Size();
	241	z = dpz*(i) - fDz;
	242	x = dpx*(j) - fDx;
	243	AddQuad(x, z, dpx, dpz);
	244	sd = new ScaledDigit_t(od->GetCoord1(),od->GetCoord2());
	245	QuadId(sd);
	246	}
	247	else
	248	{
	249	sd = dynamic_cast<ScaledDigit_t*>(GetId(miter->second));
	250	if(c1 < sd->fMinI)
	251	sd->fMinI = c1;
	252	else if( c1 > sd->fMaxI)
	253	sd->fMaxI = c1;
	254
	255	if(c2 < sd->fMinJ)
	256	sd->fMinJ = c2;
	257	else if( c2 > sd->fMaxJ)
	258	sd->fMaxJ = c2;
	259	}
	260	sd->fN++;
	261	sd->fSum += od->GetSignal();
	262	sd->fSqrSum += od->GetSignal()*od->GetSignal();
	263	}
	264	break;
	265	}
	266	case 2:
	267	{
	268	// SSD
	269	Reset(kQT_LineXZFixedY, kFALSE, 32);
	270
	271	AliITSsegmentationSSD* seg = fInfo->fSegSSD;
	272	Float_t ap, an; // positive/negative angles -> offsets
	273	seg->Angles(ap, an);
	274	ap = TMath::Tan(ap) * fDz;
	275	an = - TMath::Tan(an) * fDz;
	276
	277	fNCx = fInfo->fSSDScale[scale];
	278	fNz = 1;
	279	fNx = Int_t(fInfo->fSegSSD->Npx()/fNCx);
	280	dpz = 2*fDz/fNz;
	281	dpx = 2*fDx/fNx;
	282
	283	AliITSdigitSSD *od = 0;
	284	for (Int_t k=0; k<ndigits; k++) {
	285	od=(AliITSdigitSSD*)digits->UncheckedAt(k);
	286	if(od->GetCoord1() == 1)
	287	i = 1; // p side
	288	else
	289	i= -1; // n side
	290	j = Int_t(od->GetCoord2()/fNCx);
	291	c1 = od->GetCoord1(); c2 = od->GetCoord2();
	292	id = j*i;
	293
	294	ScaledDigit_t* sd = 0;
	295	miter = dmap.find(id);
	296	if(miter == dmap.end())
	297	{
	298	// printf("orig digit %d,%d scaled %d,%d \n",od->GetCoord1(),od->GetCoord2(),i,j);
	299	dmap[id] = fPlex.Size();
	300	z = dpz*(i) - fDz;
	301	x = dpx*(j) - fDx;
	302	Float_t a = ( od->GetCoord1() == 1) ? ap : an;
	303	AddLine(x-a, -fDz, 2a, 2fDz);
	304
	305	sd = new ScaledDigit_t(c1, c2);
	306	QuadId(sd);
	307	}
	308	else
	309	{
	310	sd = dynamic_cast<ScaledDigit_t*>(GetId(miter->second));
	311	if(c1 < sd->fMinI)
	312	sd->fMinI = c1;
	313	else if( c1 > sd->fMaxI)
	314	sd->fMaxI = c1;
	315
	316	if(c2 < sd->fMinJ)
	317	sd->fMinJ = c2;
	318	else if( c2 > sd->fMaxJ)
	319	sd->fMaxJ = c2;
	320	}
	321	sd->fN++;
	322	sd->fSum += od->GetSignal();
	323	sd->fSqrSum += od->GetSignal()*od->GetSignal();
	324	} // for digits
	325	break;
	326	} // end case 2
	327	} // end switch
	328
	329	SetQuadValues();
	330	RefitPlex();
	331	}
	332
	333	/******************************************************************************/
	334
	335	void AliEveITSScaledModule::SetQuadValues()
	336	{
	337	if(fScaleInfo->GetSyncPalette()) SyncPalette();
	338
	339	Int_t num = fPlex.Size();
	340	for (Int_t i = 0 ; i < num; i++)
	341	{
	342	ScaledDigit_t* sd = dynamic_cast<ScaledDigit_t*>(GetId(i));
	343	Int_t v = 0;
	344	switch(fScaleInfo->GetStatType())
	345	{
	346	using namespace TMath;
	347
	348	case AliEveDigitScaleInfo::kSTOccup:
	349	v = Nint((100.0sd->fN) / (fNCxfNCz));
	350	break;
	351	case AliEveDigitScaleInfo::kSTAverage:
	352	v = Nint((Double_t) sd->fSum / sd->fN);
	353	break;
	354	case AliEveDigitScaleInfo::kSTRms:
	355	v = Nint(Sqrt(sd->fSqrSum) / sd->fN);
	356	break;
	357	}
	358	DigitBase_t* qb = GetDigit(i);
	359	qb->fValue = v;
	360	}
	361	}
	362
	363	/******************************************************************************/
	364
	365	void AliEveITSScaledModule::SyncPalette()
	366	{
	367	// printf("AliEveITSScaledModule::SyncPalette()\n");
	368	if(fScaleInfo->GetStatType() == AliEveDigitScaleInfo::kSTOccup)
	369	{
	370	// SPD
	371	AliEveITSModule::fgSPDPalette->SetLimits(0, 100);
	372	AliEveITSModule::fgSPDPalette->SetMinMax(0, 100);
	373
	374	// SDD
	375	AliEveITSModule::fgSDDPalette->SetLimits(0, 100);
	376	AliEveITSModule::fgSDDPalette->SetMinMax(0, 100);
	377
	378	// SSD
	379	AliEveITSModule::fgSSDPalette->SetLimits(0, 100);
	380	AliEveITSModule::fgSDDPalette->SetMinMax(0, 100);
	381	}
	382	else
	383	{
	384	AliEveITSDigitsInfo& di = *fInfo;
	385	// SPD
	386	AliEveITSModule::fgSPDPalette->SetLimits(0, di.fSPDHighLim);
	387	AliEveITSModule::fgSPDPalette->SetMinMax(di.fSPDMinVal, di.fSPDMaxVal);
	388
	389	// SDD
	390	AliEveITSModule::fgSDDPalette->SetLimits(0, di.fSDDHighLim);
	391	AliEveITSModule::fgSDDPalette->SetMinMax(di.fSDDMinVal, di.fSDDMaxVal);
	392
	393	// SSD
	394	AliEveITSModule::fgSSDPalette->SetLimits(0, di.fSSDHighLim);
	395	AliEveITSModule::fgSSDPalette->SetMinMax(di.fSSDMinVal, di.fSSDMaxVal);
	396	}
	397
	398	fScaleInfo->SetSyncPalette(kFALSE);
	399	}
	400
	401	/******************************************************************************/
	402
	403	void AliEveITSScaledModule::GetScaleData(Int_t& cnx, Int_t& cnz, Int_t& total) const
	404	{
	405	cnx = fNx;
	406	cnz = fNz;
	407	total = cnx*cnz;
	408	}
	409
	410	/******************************************************************************/
	411
	412	void AliEveITSScaledModule::DigitSelected(Int_t idx)
	413	{
	414	// Override control-click from TEveQuadSet
	415	printf("AliEveITSScaledModule::DigitSelected "); Print();
	416
	417	// DigitBase_t *qb = GetDigit(idx);
	418	TObject *obj = GetId(idx);
	419	ScaledDigit_t sd = dynamic_cast<ScaledDigit_t>(obj);
	420	TClonesArray *digits = fInfo->GetDigits(fID, fDetID);
	421	Int_t ndigits = digits->GetEntriesFast();
	422
	423	printf("%d digits in cell scaleX = %d, scaleZ = %d \n", sd->fN, fNCx, fNCz);
	424
	425	Int_t il = 0;
	426	for(Int_t k=0; k<ndigits; k++)
	427	{
	428	AliITSdigit d = (AliITSdigit) digits->UncheckedAt(k);
	429
	430	if(d->GetCoord1()>=sd->fMinI && d->GetCoord1()<=sd->fMaxI &&
	431	d->GetCoord2()>=sd->fMinJ && d->GetCoord2()<=sd->fMaxJ)
	432	{
	433	printf("%3d, %3d: %3d", d->GetCoord1(), d->GetCoord2(), d->GetSignal());
	434	printf(" \| ");
	435	il++;
	436	if(il>5) {
	437	printf("\n");
	438	il = 0;
	439	}
	440	}
	441	}
	442	if(il) printf("\n");
	443	}