[u/mrichter/AliRoot.git] / EVE / Alieve / 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 <AliITSdigitSPD.h>
#include <AliITSdigitSDD.h>
#include <AliITSdigitSSD.h>


//______________________________________________________________________
// AliEveDigitScaleInfo
//
ClassImp(AliEveDigitScaleInfo)

AliEveDigitScaleInfo::AliEveDigitScaleInfo():
  fScale(1),
  fStatType (ST_Average),
  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
//
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);
}

//______________________________________________________________________
// AliEveITSScaledModule
//

ClassImp(AliEveITSScaledModule)

AliEveITSScaledModule::AliEveITSScaledModule(Int_t gid, AliEveITSDigitsInfo* info, AliEveDigitScaleInfo* si):
  AliEveITSModule("AliEveITSScaledModule", "AliEveITSScaledModule"),
  fNx(-1),
  fNz(-1),
  fNCx(-1),
  fNCz(-1),
  fScaleInfo(si)
{
  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;
  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(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;
 
        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(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();
 
	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(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; 

	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 AliEveITSScaledModule::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 AliEveDigitScaleInfo::ST_Occup:
	v = Nint((100.0*sd->N) / (fNCx*fNCz));
	break;
      case AliEveDigitScaleInfo::ST_Average:
	v = Nint((Double_t) sd->sum / sd->N);
	break;
      case AliEveDigitScaleInfo::ST_Rms:
	v = Nint(Sqrt(sd->sqr_sum) / sd->N);
	break;
    }
    DigitBase_t* qb = GetDigit(i);
    qb->fValue = v;
  }
}

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

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