[u/mrichter/AliRoot.git] / EVE / Alieve / ITSScaledModule.cxx

// $Header$

#include "ITSScaledModule.h"

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

using namespace Reve;
using namespace Alieve;

//______________________________________________________________________
// DigitScaleInfo
//
ClassImp(DigitScaleInfo)

DigitScaleInfo::DigitScaleInfo():
  fScale(1),
  fStatType (ST_Average),
  fSyncPalette(kFALSE)
{
}

void DigitScaleInfo::ScaleChanged(Int_t s)
{
  fScale = s;
  
  ITSScaledModule* sm;
  std::list<RenderElement*>::iterator i = fBackRefs.begin();
  while (i != fBackRefs.end())
  {
    sm = dynamic_cast<ITSScaledModule*>(*i);
    if(sm) sm->LoadQuads();
    ++i;
  }
}

void DigitScaleInfo::StatTypeChanged(Int_t t)
{
  fStatType = t;
  fSyncPalette = kTRUE;
    
  ITSScaledModule* sm;
  std::list<RenderElement*>::iterator i = fBackRefs.begin();
  while (i != fBackRefs.end())
  {
    sm = dynamic_cast<ITSScaledModule*>(*i);
    if(sm) sm->SetQuadValues();
    ++i;
  }
}

//______________________________________________________________________
// ScaledDigit
//
ScaledDigit::ScaledDigit():
  TObject(),
  N(0),
  sum(0), sqr_sum(0),
  min_i(-1), min_j(-1), max_i(-1), max_j(-1)
{
}

ScaledDigit::ScaledDigit(Int_t di, Int_t dj):
  TObject(),
  N(0),
  sum(0), sqr_sum(0),
  min_i(di), min_j(dj), max_i(di), max_j(dj)
{
}

void ScaledDigit::Dump() const
{
  printf("N %d, sum %f, sqr_sum %f",N, sum, sqr_sum);
}

//______________________________________________________________________
// ITSScaledModule
//

ClassImp(ITSScaledModule)

ITSScaledModule::ITSScaledModule(Int_t gid, ITSDigitsInfo* info, DigitScaleInfo* si):
  ITSModule("ITSScaledModule", "ITSScaledModule"),
  fNx(-1),
  fNz(-1),
  fNCx(-1),
  fNCz(-1),
  fScaleInfo(si)
{
  SetOwnIds(kTRUE);

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

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

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

void ITSScaledModule::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.

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

  Int_t id;
  map<Int_t, Int_t> dmap;
  map<Int_t, Int_t>::iterator miter;
  digits  = fInfo->GetDigits(fID, fDetID);
  ndigits = digits->GetEntriesFast();

  ScaledDigit* sd;
  Int_t scale = fScaleInfo->GetScale() -1;
  switch(fDetID)
  {
    case 0: 
    { 
      // SPD
      Reset(QT_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;
 
        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(c1, c2);
	  QuadId(sd);
	}
        else 
	{
	  sd = dynamic_cast<ScaledDigit*>(GetId(miter->second));
          if(c1 < sd->min_i) 
	    sd->min_i = c1;
	  else if( c1 > sd->max_i)
            sd->max_i = c1;
	
          if(c2 < sd->min_j) 
	    sd->min_j = c2;
	  else if( c2 > sd->max_j)
	    sd->max_j = c2;
	}
	  
	sd->N++;
	sd->sum  += od->GetSignal();
	sd->sqr_sum += od->GetSignal()*od->GetSignal();
      }
      break;
    }
    case 1: 
    { 
      // SDD
      Reset(QT_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();
 
	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(od->GetCoord1(),od->GetCoord2());
	  QuadId(sd);
	}
	else 
	{
	  sd = dynamic_cast<ScaledDigit*>(GetId(miter->second));
	  if(c1 < sd->min_i) 
	    sd->min_i = c1;
	  else if( c1 > sd->max_i)
	    sd->max_i = c1;
	
	  if(c2 < sd->min_j) 
	    sd->min_j = c2;
	  else if( c2 > sd->max_j)
	    sd->max_j = c2;
	}
	sd->N++;
	sd->sum  += od->GetSignal();
	sd->sqr_sum += od->GetSignal()*od->GetSignal();
      }
      break;
    }  
    case 2: 
    { 
      // SSD  
      Reset(QT_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; 

	miter = dmap.find(id);
	ScaledDigit* sd;
	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(c1, c2);
	  QuadId(sd);
	}
	else 
	{
	  sd = dynamic_cast<ScaledDigit*>(GetId(miter->second)); 
	  if(c1 < sd->min_i) 
	    sd->min_i = c1;
	  else if( c1 > sd->max_i)
	    sd->max_i = c1;
	
	  if(c2 < sd->min_j) 
	    sd->min_j = c2;
	  else if( c2 > sd->max_j)
	    sd->max_j = c2;
	}
	sd->N++;
	sd->sum  += od->GetSignal();
	sd->sqr_sum += od->GetSignal()*od->GetSignal();
      } // for digits
      break;
    } // end case 2
  } // end switch

  SetQuadValues();
  RefitPlex();
}

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

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

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

      case DigitScaleInfo::ST_Occup:
	v = Nint((100.0*sd->N) / (fNCx*fNCz));
	break;
      case DigitScaleInfo::ST_Average:
	v = Nint((Double_t) sd->sum / sd->N);
	break;
      case DigitScaleInfo::ST_Rms:
	v = Nint(Sqrt(sd->sqr_sum) / sd->N);
	break;
    }
    DigitBase* qb = GetDigit(i);
    qb->fValue = v;
  }
}

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

void ITSScaledModule::SyncPalette()
{  
  // printf("ITSScaledModule::SyncPalette()\n");
  if(fScaleInfo->GetStatType() == DigitScaleInfo::ST_Occup) 
  {
    // SPD
    ITSModule::fgSPDPalette->SetLimits(0, 100);
    ITSModule::fgSPDPalette->SetMinMax(0, 100);
    
    // SDD
    ITSModule::fgSDDPalette->SetLimits(0, 100);
    ITSModule::fgSDDPalette->SetMinMax(0, 100);

    // SSD
    ITSModule::fgSSDPalette->SetLimits(0, 100);
    ITSModule::fgSDDPalette->SetMinMax(0, 100);
  }
  else
  {
    Alieve::ITSDigitsInfo& DI = *fInfo;
    // SPD
    ITSModule::fgSPDPalette->SetLimits(0, DI.fSPDHighLim);
    ITSModule::fgSPDPalette->SetMinMax(DI.fSPDMinVal, DI.fSPDMaxVal);
    
    // SDD
    ITSModule::fgSDDPalette->SetLimits(0, DI.fSDDHighLim);
    ITSModule::fgSDDPalette->SetMinMax(DI.fSDDMinVal, DI.fSDDMaxVal);

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

  fScaleInfo->SetSyncPalette(kFALSE);
}

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

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

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

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

  DigitBase* qb  = GetDigit(idx);
  TObject* obj  = qb->fId.GetObject();
  ScaledDigit* sd = dynamic_cast<ScaledDigit*>(obj);
  TClonesArray *digits = fInfo->GetDigits(fID, fDetID);
  Int_t ndigits = digits->GetEntriesFast();

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

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

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