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

// $Header$

//__________________________________________________________________________
// ITSDigitsInfo
//
//
#include <TMath.h>
#include <TVector3.h>

#include <TEveTreeTools.h>
#include <TEveTrans.h>

#include "ITSDigitsInfo.h"
#include <AliITSCalibrationSDD.h>
#include <AliITSdigit.h>
#include <AliITSdigitSPD.h>

#include <AliRawReader.h>
#include <AliITSRawStreamSPD.h>
#include <AliITSRawStreamSDD.h>
#include <AliITSRawStreamSSD.h>
using namespace Alieve;
using namespace std;


ClassImp(ITSModuleSelection)

ITSModuleSelection::ITSModuleSelection():
  fType(-1),
  fLayer(-1),
  fMinPhi(-TMath::Pi()),
  fMaxPhi(TMath::Pi()),
  fMinTheta(-TMath::Pi()),
  fMaxTheta(TMath::Pi())
{}


ClassImp(ITSDigitsInfo)

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

ITSDigitsInfo::ITSDigitsInfo() :
  TObject(),
  TEveRefCnt(),
  fSPDmap(), fSDDmap(), fSSDmap(),
  fTree (0),
  fGeom (0),
  fSegSPD(0), fSegSDD(0), fSegSSD(0)
{
  InitInternals();
}

void ITSDigitsInfo::InitInternals()
{
  static const TEveException eH("ITSDigitsInfo::InitInternals ");

  fGeom = new AliITSgeom();
  fGeom->ReadNewFile("$REVESYS/alice-data/ITSgeometry.det");
  if(fGeom == 0)
    throw(eH + "can not load ITS geometry \n");

  SetITSSegmentation();

  // create tables for scaling
  fSPDMinVal = 0;
  fSDDMinVal = 5;
  fSSDMinVal = 2;

  fSPDMaxVal = 1;
  fSDDMaxVal = 80;
  fSSDMaxVal = 100;

  fSPDHighLim = 1;
  fSDDHighLim = 512;
  fSSDHighLim = 1024;

  // lowest scale factor refers to unscaled ITS module
  fSPDScaleX[0] = 1;
  fSPDScaleZ[0] = 1;
  fSDDScaleX[0] = 1;
  fSDDScaleZ[0] = 1;
  fSSDScale [0] = 1;

  // spd lowest resolution
  Int_t nx = 8; // fSegSPD->Npx()/8; // 32
  Int_t nz = 6; // fSegSPD->Npz()/2; // 128
  fSPDScaleX[1] = Int_t(nx); 
  fSPDScaleZ[1] = Int_t(nz); 
  fSPDScaleX[2] = Int_t(nx*2); 
  fSPDScaleZ[2] = Int_t(nz*2); 
  fSPDScaleX[3] = Int_t(nx*3); 
  fSPDScaleZ[3] = Int_t(nz*3); 
  fSPDScaleX[4] = Int_t(nx*4); 
  fSPDScaleZ[4] = Int_t(nz*4); 

  fSDDScaleX[1] = 2;
  fSDDScaleZ[1] = 2;
  fSDDScaleX[2] = 8;
  fSDDScaleZ[2] = 8;
  fSDDScaleX[3] = 16;
  fSDDScaleZ[3] = 16;
  fSDDScaleX[4] = 25;
  fSDDScaleZ[4] = 25;

  fSSDScale[1] = 3;
  fSSDScale[2] = 9;
  fSSDScale[3] = 20;
  fSSDScale[4] = 30;
}

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

ITSDigitsInfo:: ~ITSDigitsInfo() 
{
  map<Int_t, TClonesArray*>::iterator j;
  for(j = fSPDmap.begin(); j != fSPDmap.end(); ++j)
    delete j->second;
  for(j = fSDDmap.begin(); j != fSDDmap.end(); ++j)
    delete j->second;
  for(j = fSSDmap.begin(); j != fSSDmap.end(); ++j)
    delete j->second;

  delete fSegSPD; delete fSegSDD; delete fSegSSD; 
  delete fGeom;
  delete fTree;
}

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

void ITSDigitsInfo::SetTree(TTree* tree)
{
  // Set digit-tree to be used for digit retrieval. Data is loaded on
  // demand.

  fTree = tree;
}

void ITSDigitsInfo::ReadRaw(AliRawReader* raw, Int_t mode)
{
  // Read raw-data into internal structures. AliITSdigit is used to
  // store raw-adata for all sub-detectors.

  if ((mode & 1) || (mode & 2)){
    AliITSRawStreamSPD inputSPD(raw);
    TClonesArray* digits = 0;
    while (inputSPD.Next())
    {
      Int_t module = inputSPD.GetModuleID();
      Int_t column = inputSPD.GetColumn();
      Int_t row    = inputSPD.GetRow();
    
      if (inputSPD.IsNewModule())
      {
	digits = fSPDmap[module];
	if (digits == 0)
	  fSPDmap[module] = digits = new TClonesArray("AliITSdigit", 16);
      }

      AliITSdigit* d = new ((*digits)[digits->GetEntriesFast()]) AliITSdigit();
      d->SetCoord1(column);
      d->SetCoord2(row);
      d->SetSignal(1);

      // printf("SPD: %d %d %d\n",module,column,row);
    }
    raw->Reset();
  }

  if ((mode & 4) || (mode & 8)){
    AliITSRawStreamSDD input(raw);
    TClonesArray* digits = 0;
    while (input.Next())
    {
      Int_t module = input.GetModuleID();
      Int_t anode  = input.GetAnode();
      Int_t time   = input.GetTime();
      Int_t signal = input.GetSignal();

      if (input.IsNewModule())
      {
	digits = fSDDmap[module];
	if (digits == 0)
	  fSDDmap[module] = digits = new TClonesArray("AliITSdigit", 0);
      }

      AliITSdigit* d = new ((*digits)[digits->GetEntriesFast()]) AliITSdigit();
      d->SetCoord1(anode);
      d->SetCoord2(time);
      d->SetSignal(signal);

      // printf("SDD: %d %d %d %d\n",module,anode,time,signal);
    }
    raw->Reset();
  }

  if ((mode & 16) || (mode & 32)){
    AliITSRawStreamSSD input(raw);
    TClonesArray* digits = 0;
    while (input.Next())
    {
      Int_t module  = input.GetModuleID();
      Int_t side    = input.GetSideFlag();
      Int_t strip   = input.GetStrip();
      Int_t signal  = input.GetSignal();

      if (input.IsNewModule())
      {
	digits = fSSDmap[module];
	if (digits == 0)
	  fSSDmap[module] = digits = new TClonesArray("AliITSdigit", 0);
      }

      AliITSdigit* d = new ((*digits)[digits->GetEntriesFast()]) AliITSdigit();
      d->SetCoord1(side);
      d->SetCoord2(strip);
      d->SetSignal(signal);

      // printf("SSD: %d %d %d %d\n",module,side,strip,signal);
    }
    raw->Reset();
  }
}

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

void ITSDigitsInfo::SetITSSegmentation()
{
  // SPD
  fSegSPD = new AliITSsegmentationSPD(fGeom);
  //SPD geometry  
  Int_t m;
  Float_t fNzSPD=160;
  Float_t fZ1pitchSPD=0.0425; Float_t fZ2pitchSPD=0.0625;
  Float_t fHlSPD=3.48;

  fSPDZCoord[0]=fZ1pitchSPD -fHlSPD;
  for (m=1; m<fNzSPD; m++) {
    Double_t dz=fZ1pitchSPD;
    if (m==31 || m==32 || m==63  || m==64  || m==95 || m==96 || 
        m==127 || m==128) dz=fZ2pitchSPD; 
    fSPDZCoord[m]=fSPDZCoord[m-1]+dz;
  }
  
  for (m=0; m<fNzSPD; m++) {
    Double_t dz=1.*fZ1pitchSPD;
    if (m==31 || m==32 || m==63  || m==64  || m==95 || m==96 || 
	m==127 || m==128) dz=1.*fZ2pitchSPD; 
    fSPDZCoord[m]-=dz;
  }
  
  // end of SPD geometry
  
  // SDD
  fSegSDD = new AliITSsegmentationSDD(fGeom);

  // SSD
  fSegSSD = new AliITSsegmentationSSD(fGeom);
}

void ITSDigitsInfo::GetSPDLocalZ(Int_t j, Float_t& z)
{
  z = fSPDZCoord[j];
}

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

TClonesArray* ITSDigitsInfo::GetDigits(Int_t mod, Int_t subdet)
{
  switch(subdet) {
    case 0: {
      TClonesArray* digitsSPD = 0;
      map<Int_t, TClonesArray*>::iterator i = fSPDmap.find(mod);
      if(i == fSPDmap.end()) {
	if (fTree) {
	  TBranch* br =  fTree->GetBranch("ITSDigitsSPD");
	  br->SetAddress(&digitsSPD);
	  br->GetEntry(mod);
	  fSPDmap[mod] = digitsSPD;
	  return digitsSPD;
	}
	else
	  return NULL;
      } else {
	return i->second;
      }
      break;
    }
    case 1: {
      TClonesArray* digitsSDD = 0;
      map<Int_t, TClonesArray*>::iterator i = fSDDmap.find(mod);
      if(i == fSDDmap.end()) {
	if (fTree) {
	  TBranch* br =  fTree->GetBranch("ITSDigitsSDD");
	  br->SetAddress(&digitsSDD);
	  br->GetEntry(mod);
	  fSDDmap[mod] = digitsSDD;
	  return digitsSDD;
	}
	else
	  return NULL;
       } else {
	return i->second;
      }
      break;
    }
    case 2: {
      TClonesArray* digitsSSD = 0;
      map<Int_t, TClonesArray*>::iterator i = fSSDmap.find(mod);
      if(i == fSSDmap.end()) {
	if (fTree) {
	  TBranch* br =  fTree->GetBranch("ITSDigitsSSD");
	  br->SetAddress(&digitsSSD);
	  br->GetEntry(mod);

	  fSSDmap[mod] = digitsSSD;
	  return digitsSSD;
	}
	else
	  return NULL;
       } else {
	return i->second;
      }
      break;
    }
    default:
      return 0;
  } //end switch
  return 0;
}

/**************************************************************************/
void ITSDigitsInfo::GetModuleIDs(ITSModuleSelection* sel, std::vector<UInt_t>& ids)
{
  // loop SPD
  Int_t idx0 = 0, idx1 = 0;
  switch(sel->fType)
  {
    case 0:
      idx0 = 0;
      idx1 = fGeom->GetLastSPD();
      break;
    case 1:
      idx0 = fGeom->GetLastSPD()+1;
      idx1 = fGeom->GetLastSDD();
      break;
    case 2:
      idx0 = fGeom->GetLastSDD()+1;
      idx1 = fGeom->GetLastSSD();
      break;
    default:
      idx1 = 0;
      idx1 = fGeom->GetLastSSD();
  }

  TVector3 v;
  Double_t x[9];
  Int_t lay, lad, det;
  TEveTrans mx;
  for(Int_t id = idx0; id<idx1; id++){
    fGeom->GetModuleId(id, lay, lad, det);
    if(sel->fLayer==lay || sel->fLayer==-1)
    {
      // check data from matrix
      mx.UnitTrans();
      fGeom->GetRotMatrix(id, x);
      mx.SetBaseVec(1, x[0], x[3], x[6]);
      mx.SetBaseVec(2, x[1], x[4], x[7]);
      mx.SetBaseVec(3, x[2], x[5], x[8]);
      fGeom->GetTrans(id, x);  
      mx.SetBaseVec(4, x);
      mx.GetPos(v);
      if(v.Phi()<=sel->fMaxPhi && v.Phi()>=sel->fMinPhi &&
         v.Theta()<=sel->fMaxTheta && v.Theta()>=sel->fMinTheta )
	ids.push_back(id);
    }
  }
}

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

void ITSDigitsInfo::Print(Option_t* ) const
{
  printf("*********************************************************\n");
  printf("SPD module dimension (%f,%f) \n",fSegSPD->Dx()*0.0001, fSegSPD->Dz()*0.0001);
  printf("SPD first,last module:: %d,%d \n", fGeom->GetStartSPD(),fGeom->GetLastSPD() );
  printf("SPD num cells per module (x::%d,z::%d)\n",fSegSPD->Npx(), fSegSPD->Npz());
  Int_t iz=0,ix = 0;
  printf("SPD dimesion of (%d,%d) in pixel(%f,%f) \n", ix,iz, fSegSPD->Dpx(ix), fSegSPD->Dpz(iz));
  iz = 32;
  printf("SPD dimesion of pixel (%d,%d) are (%f,%f) \n", ix,iz, fSegSPD->Dpx(ix)*0.001, fSegSPD->Dpz(iz)*0.001);
 
  printf("*********************************************************\n");
  printf("SDD module dimension (%f,%f) \n",fSegSDD->Dx()*0.0001, fSegSDD->Dz()*0.0001);
  printf("SDD first,last module:: %d,%d \n", fGeom->GetStartSDD(),fGeom->GetLastSDD() );
  printf("SDD num cells per module (x::%d,z::%d)\n",fSegSDD->Npx(), fSegSDD->Npz());
  printf("SDD dimesion of pixel are (%f,%f) \n", fSegSDD->Dpx(1)*0.001,fSegSDD->Dpz(1)*0.001);
  printf("*********************************************************\n");
  printf("SSD module dimension (%f,%f) \n",fSegSSD->Dx()*0.0001, fSegSSD->Dz()*0.0001);
  printf("SSD first,last module:: %d,%d \n", fGeom->GetStartSSD(),fGeom->GetLastSSD() );
  printf("SSD strips in module %d \n",fSegSSD->Npx());
  printf("SSD strip sizes are (%f,%f) \n", fSegSSD->Dpx(1),fSegSSD->Dpz(1));
  fSegSSD->SetLayer(5); Float_t ap,an;  fSegSSD->Angles(ap,an);
  printf("SSD layer 5 stereoP %f stereoN %f angle \n",ap,an); 
  fSegSSD->SetLayer(6);  fSegSSD->Angles(ap,an);
  printf("SSD layer 6 stereoP %f stereoN %f angle \n",ap,an); 
}


/*
  printf("num cells %d,%d scaled %d,%d \n",fSegSPD->Npz(),fSegSPD->Npx(),Nz,Nx);
  printf("%d digits in ITSModule %d\n",ne, module);
  Float_t zn = i*(3.48*2)/Nz - 3.48 ;
  Float_t xo =  -fSegSPD->Dx()*0.00005 + fSegSPD->Dpx(0)*od->GetCoord2()*0.0001;
  Float_t xn =  -fSegSPD->Dx()*0.00005 + j*0.0001*fSegSPD->Dx()/Nx;
  Float_t dpx = 0.0001*fSegSPD->Dx()/Nx;
  Float_t dpz = 3.48*2/Nz;
  printf("Z::original (%3f) scaled (%3f, %3f) \n", zo, zn-dpz/2, zn+dpz/2);
  printf("X::original (%3f) scaled (%3f, %3f) \n", xo, xn-dpx/2, xn+dpx/2);
  printf("%d,%d maped to %d,%d \n", od->GetCoord1(), od->GetCoord2(), i,j );
*/
Commit	Line	Data
5a5a1232	1	// $Header$
	2
	3	//__________________________________________________________________________
	4	// ITSDigitsInfo
	5	//
	6	//
3d598e88	7	#include <TMath.h>
3d598e88	8	#include <TVector3.h>
5a5a1232	9
84aff7a4	10	#include <TEveTreeTools.h>
84aff7a4	11	#include <TEveTrans.h>
5a5a1232	12
5a5a1232	13	#include "ITSDigitsInfo.h"
5a5a1232	14	#include <AliITSCalibrationSDD.h>
	15	#include <AliITSdigit.h>
	16	#include <AliITSdigitSPD.h>
	17
b3bc5327	18	#include <AliRawReader.h>
	19	#include <AliITSRawStreamSPD.h>
	20	#include <AliITSRawStreamSDD.h>
	21	#include <AliITSRawStreamSSD.h>
5a5a1232	22	using namespace Alieve;
	23	using namespace std;
	24
3d598e88	25
	26	ClassImp(ITSModuleSelection)
	27
	28	ITSModuleSelection::ITSModuleSelection():
	29	fType(-1),
	30	fLayer(-1),
32e219c2	31	fMinPhi(-TMath::Pi()),
	32	fMaxPhi(TMath::Pi()),
	33	fMinTheta(-TMath::Pi()),
	34	fMaxTheta(TMath::Pi())
b3bc5327	35	{}
b3bc5327	36
3d598e88	37
5a5a1232	38	ClassImp(ITSDigitsInfo)
	39
	40	/**************************************************************************/
	41
265ecb21	42	ITSDigitsInfo::ITSDigitsInfo() :
265ecb21	43	TObject(),
84aff7a4	44	TEveRefCnt(),
265ecb21	45	fSPDmap(), fSDDmap(), fSSDmap(),
	46	fTree (0),
	47	fGeom (0),
	48	fSegSPD(0), fSegSDD(0), fSegSSD(0)
5a5a1232	49	{
b3bc5327	50	InitInternals();
5a5a1232	51	}
5a5a1232	52
b3bc5327	53	void ITSDigitsInfo::InitInternals()
5a5a1232	54	{
84aff7a4	55	static const TEveException eH("ITSDigitsInfo::InitInternals ");
5a5a1232	56
b3bc5327	57	fGeom = new AliITSgeom();
	58	fGeom->ReadNewFile("$REVESYS/alice-data/ITSgeometry.det");
	59	if(fGeom == 0)
	60	throw(eH + "can not load ITS geometry \n");
5a5a1232	61
5a5a1232	62	SetITSSegmentation();
d4b6a94c	63
5a5a1232	64	// create tables for scaling
d4b6a94c	65	fSPDMinVal = 0;
	66	fSDDMinVal = 5;
	67	fSSDMinVal = 2;
	68
	69	fSPDMaxVal = 1;
	70	fSDDMaxVal = 80;
	71	fSSDMaxVal = 100;
	72
32e219c2	73	fSPDHighLim = 1;
	74	fSDDHighLim = 512;
	75	fSSDHighLim = 1024;
d4b6a94c	76
d54c094e	77	// lowest scale factor refers to unscaled ITS module
	78	fSPDScaleX[0] = 1;
	79	fSPDScaleZ[0] = 1;
	80	fSDDScaleX[0] = 1;
	81	fSDDScaleZ[0] = 1;
	82	fSSDScale [0] = 1;
d4b6a94c	83
b3bc5327	84	// spd lowest resolution
5a5a1232	85	Int_t nx = 8; // fSegSPD->Npx()/8; // 32
5a5a1232	86	Int_t nz = 6; // fSegSPD->Npz()/2; // 128
5a5a1232	87	fSPDScaleX[1] = Int_t(nx);
	88	fSPDScaleZ[1] = Int_t(nz);
	89	fSPDScaleX[2] = Int_t(nx*2);
	90	fSPDScaleZ[2] = Int_t(nz*2);
	91	fSPDScaleX[3] = Int_t(nx*3);
	92	fSPDScaleZ[3] = Int_t(nz*3);
	93	fSPDScaleX[4] = Int_t(nx*4);
	94	fSPDScaleZ[4] = Int_t(nz*4);
	95
5a5a1232	96	fSDDScaleX[1] = 2;
	97	fSDDScaleZ[1] = 2;
	98	fSDDScaleX[2] = 8;
	99	fSDDScaleZ[2] = 8;
	100	fSDDScaleX[3] = 16;
	101	fSDDScaleZ[3] = 16;
	102	fSDDScaleX[4] = 25;
	103	fSDDScaleZ[4] = 25;
	104
	105	fSSDScale[1] = 3;
	106	fSSDScale[2] = 9;
	107	fSSDScale[3] = 20;
	108	fSSDScale[4] = 30;
5a5a1232	109	}
	110
	111	/**************************************************************************/
	112
b3bc5327	113	ITSDigitsInfo:: ~ITSDigitsInfo()
	114	{
	115	map<Int_t, TClonesArray*>::iterator j;
	116	for(j = fSPDmap.begin(); j != fSPDmap.end(); ++j)
	117	delete j->second;
	118	for(j = fSDDmap.begin(); j != fSDDmap.end(); ++j)
	119	delete j->second;
	120	for(j = fSSDmap.begin(); j != fSSDmap.end(); ++j)
	121	delete j->second;
	122
	123	delete fSegSPD; delete fSegSDD; delete fSegSSD;
	124	delete fGeom;
	125	delete fTree;
	126	}
	127
	128	/**************************************************************************/
	129
	130	void ITSDigitsInfo::SetTree(TTree* tree)
	131	{
	132	// Set digit-tree to be used for digit retrieval. Data is loaded on
	133	// demand.
	134
	135	fTree = tree;
	136	}
	137
540e156e	138	void ITSDigitsInfo::ReadRaw(AliRawReader* raw, Int_t mode)
b3bc5327	139	{
	140	// Read raw-data into internal structures. AliITSdigit is used to
	141	// store raw-adata for all sub-detectors.
	142
540e156e	143	if ((mode & 1) \|\| (mode & 2)){
b3bc5327	144	AliITSRawStreamSPD inputSPD(raw);
b3bc5327	145	TClonesArray* digits = 0;
b3bc5327	146	while (inputSPD.Next())
	147	{
	148	Int_t module = inputSPD.GetModuleID();
	149	Int_t column = inputSPD.GetColumn();
	150	Int_t row = inputSPD.GetRow();
	151
	152	if (inputSPD.IsNewModule())
	153	{
f8495fba	154	digits = fSPDmap[module];
	155	if (digits == 0)
	156	fSPDmap[module] = digits = new TClonesArray("AliITSdigit", 16);
b3bc5327	157	}
b3bc5327	158
f8495fba	159	AliITSdigit* d = new ((*digits)[digits->GetEntriesFast()]) AliITSdigit();
b3bc5327	160	d->SetCoord1(column);
	161	d->SetCoord2(row);
	162	d->SetSignal(1);
b3bc5327	163
	164	// printf("SPD: %d %d %d\n",module,column,row);
	165	}
b3bc5327	166	raw->Reset();
	167	}
	168
540e156e	169	if ((mode & 4) \|\| (mode & 8)){
b3bc5327	170	AliITSRawStreamSDD input(raw);
b3bc5327	171	TClonesArray* digits = 0;
b3bc5327	172	while (input.Next())
	173	{
	174	Int_t module = input.GetModuleID();
	175	Int_t anode = input.GetAnode();
	176	Int_t time = input.GetTime();
	177	Int_t signal = input.GetSignal();
	178
	179	if (input.IsNewModule())
	180	{
f8495fba	181	digits = fSDDmap[module];
	182	if (digits == 0)
	183	fSDDmap[module] = digits = new TClonesArray("AliITSdigit", 0);
b3bc5327	184	}
b3bc5327	185
f8495fba	186	AliITSdigit* d = new ((*digits)[digits->GetEntriesFast()]) AliITSdigit();
b3bc5327	187	d->SetCoord1(anode);
	188	d->SetCoord2(time);
	189	d->SetSignal(signal);
b3bc5327	190
	191	// printf("SDD: %d %d %d %d\n",module,anode,time,signal);
	192	}
b3bc5327	193	raw->Reset();
	194	}
	195
540e156e	196	if ((mode & 16) \|\| (mode & 32)){
b3bc5327	197	AliITSRawStreamSSD input(raw);
b3bc5327	198	TClonesArray* digits = 0;
b3bc5327	199	while (input.Next())
	200	{
	201	Int_t module = input.GetModuleID();
	202	Int_t side = input.GetSideFlag();
	203	Int_t strip = input.GetStrip();
	204	Int_t signal = input.GetSignal();
	205
	206	if (input.IsNewModule())
	207	{
f8495fba	208	digits = fSSDmap[module];
	209	if (digits == 0)
	210	fSSDmap[module] = digits = new TClonesArray("AliITSdigit", 0);
b3bc5327	211	}
b3bc5327	212
f8495fba	213	AliITSdigit* d = new ((*digits)[digits->GetEntriesFast()]) AliITSdigit();
b3bc5327	214	d->SetCoord1(side);
	215	d->SetCoord2(strip);
	216	d->SetSignal(signal);
b3bc5327	217
	218	// printf("SSD: %d %d %d %d\n",module,side,strip,signal);
	219	}
b3bc5327	220	raw->Reset();
	221	}
	222	}
	223
	224	/**************************************************************************/
	225
5a5a1232	226	void ITSDigitsInfo::SetITSSegmentation()
	227	{
	228	// SPD
	229	fSegSPD = new AliITSsegmentationSPD(fGeom);
	230	//SPD geometry
	231	Int_t m;
	232	Float_t fNzSPD=160;
	233	Float_t fZ1pitchSPD=0.0425; Float_t fZ2pitchSPD=0.0625;
	234	Float_t fHlSPD=3.48;
	235
	236	fSPDZCoord[0]=fZ1pitchSPD -fHlSPD;
	237	for (m=1; m<fNzSPD; m++) {
	238	Double_t dz=fZ1pitchSPD;
	239	if (m==31 \|\| m==32 \|\| m==63 \|\| m==64 \|\| m==95 \|\| m==96 \|\|
	240	m==127 \|\| m==128) dz=fZ2pitchSPD;
	241	fSPDZCoord[m]=fSPDZCoord[m-1]+dz;
	242	}
	243
	244	for (m=0; m<fNzSPD; m++) {
	245	Double_t dz=1.*fZ1pitchSPD;
	246	if (m==31 \|\| m==32 \|\| m==63 \|\| m==64 \|\| m==95 \|\| m==96 \|\|
	247	m==127 \|\| m==128) dz=1.*fZ2pitchSPD;
	248	fSPDZCoord[m]-=dz;
	249	}
	250
	251	// end of SPD geometry
	252
	253	// SDD
b85e8cbd	254	fSegSDD = new AliITSsegmentationSDD(fGeom);
5a5a1232	255
	256	// SSD
	257	fSegSSD = new AliITSsegmentationSSD(fGeom);
	258	}
	259
	260	void ITSDigitsInfo::GetSPDLocalZ(Int_t j, Float_t& z)
	261	{
	262	z = fSPDZCoord[j];
	263	}
	264
	265	/**************************************************************************/
	266
	267	TClonesArray* ITSDigitsInfo::GetDigits(Int_t mod, Int_t subdet)
	268	{
	269	switch(subdet) {
6ddaaee3	270	case 0: {
	271	TClonesArray* digitsSPD = 0;
	272	map<Int_t, TClonesArray*>::iterator i = fSPDmap.find(mod);
	273	if(i == fSPDmap.end()) {
540e156e	274	if (fTree) {
	275	TBranch* br = fTree->GetBranch("ITSDigitsSPD");
	276	br->SetAddress(&digitsSPD);
	277	br->GetEntry(mod);
	278	fSPDmap[mod] = digitsSPD;
	279	return digitsSPD;
	280	}
	281	else
	282	return NULL;
6ddaaee3	283	} else {
	284	return i->second;
	285	}
	286	break;
5a5a1232	287	}
6ddaaee3	288	case 1: {
	289	TClonesArray* digitsSDD = 0;
	290	map<Int_t, TClonesArray*>::iterator i = fSDDmap.find(mod);
	291	if(i == fSDDmap.end()) {
540e156e	292	if (fTree) {
	293	TBranch* br = fTree->GetBranch("ITSDigitsSDD");
	294	br->SetAddress(&digitsSDD);
	295	br->GetEntry(mod);
	296	fSDDmap[mod] = digitsSDD;
	297	return digitsSDD;
	298	}
	299	else
	300	return NULL;
	301	} else {
6ddaaee3	302	return i->second;
	303	}
	304	break;
5a5a1232	305	}
6ddaaee3	306	case 2: {
	307	TClonesArray* digitsSSD = 0;
	308	map<Int_t, TClonesArray*>::iterator i = fSSDmap.find(mod);
	309	if(i == fSSDmap.end()) {
540e156e	310	if (fTree) {
	311	TBranch* br = fTree->GetBranch("ITSDigitsSSD");
	312	br->SetAddress(&digitsSSD);
	313	br->GetEntry(mod);
	314
	315	fSSDmap[mod] = digitsSSD;
	316	return digitsSSD;
	317	}
	318	else
	319	return NULL;
	320	} else {
6ddaaee3	321	return i->second;
	322	}
	323	break;
5a5a1232	324	}
6ddaaee3	325	default:
6ddaaee3	326	return 0;
5a5a1232	327	} //end switch
03ecfe88	328	return 0;
5a5a1232	329	}
5a5a1232	330
3d598e88	331	/**************************************************************************/
	332	void ITSDigitsInfo::GetModuleIDs(ITSModuleSelection* sel, std::vector<UInt_t>& ids)
	333	{
	334	// loop SPD
	335	Int_t idx0 = 0, idx1 = 0;
	336	switch(sel->fType)
	337	{
	338	case 0:
	339	idx0 = 0;
	340	idx1 = fGeom->GetLastSPD();
	341	break;
	342	case 1:
32e219c2	343	idx0 = fGeom->GetLastSPD()+1;
3d598e88	344	idx1 = fGeom->GetLastSDD();
	345	break;
	346	case 2:
32e219c2	347	idx0 = fGeom->GetLastSDD()+1;
3d598e88	348	idx1 = fGeom->GetLastSSD();
	349	break;
	350	default:
	351	idx1 = 0;
	352	idx1 = fGeom->GetLastSSD();
	353	}
	354
	355	TVector3 v;
	356	Double_t x[9];
	357	Int_t lay, lad, det;
84aff7a4	358	TEveTrans mx;
3d598e88	359	for(Int_t id = idx0; id<idx1; id++){
	360	fGeom->GetModuleId(id, lay, lad, det);
	361	if(sel->fLayer==lay \|\| sel->fLayer==-1)
	362	{
	363	// check data from matrix
	364	mx.UnitTrans();
	365	fGeom->GetRotMatrix(id, x);
	366	mx.SetBaseVec(1, x[0], x[3], x[6]);
	367	mx.SetBaseVec(2, x[1], x[4], x[7]);
	368	mx.SetBaseVec(3, x[2], x[5], x[8]);
	369	fGeom->GetTrans(id, x);
	370	mx.SetBaseVec(4, x);
	371	mx.GetPos(v);
32e219c2	372	if(v.Phi()<=sel->fMaxPhi && v.Phi()>=sel->fMinPhi &&
32e219c2	373	v.Theta()<=sel->fMaxTheta && v.Theta()>=sel->fMinTheta )
3d598e88	374	ids.push_back(id);
	375	}
	376	}
	377	}
5a5a1232	378
	379	/**************************************************************************/
	380
	381	void ITSDigitsInfo::Print(Option_t* ) const
	382	{
	383	printf("*********************************************************\n");
	384	printf("SPD module dimension (%f,%f) \n",fSegSPD->Dx()0.0001, fSegSPD->Dz()0.0001);
	385	printf("SPD first,last module:: %d,%d \n", fGeom->GetStartSPD(),fGeom->GetLastSPD() );
	386	printf("SPD num cells per module (x::%d,z::%d)\n",fSegSPD->Npx(), fSegSPD->Npz());
	387	Int_t iz=0,ix = 0;
	388	printf("SPD dimesion of (%d,%d) in pixel(%f,%f) \n", ix,iz, fSegSPD->Dpx(ix), fSegSPD->Dpz(iz));
	389	iz = 32;
	390	printf("SPD dimesion of pixel (%d,%d) are (%f,%f) \n", ix,iz, fSegSPD->Dpx(ix)0.001, fSegSPD->Dpz(iz)0.001);
	391
	392	printf("*********************************************************\n");
	393	printf("SDD module dimension (%f,%f) \n",fSegSDD->Dx()0.0001, fSegSDD->Dz()0.0001);
	394	printf("SDD first,last module:: %d,%d \n", fGeom->GetStartSDD(),fGeom->GetLastSDD() );
	395	printf("SDD num cells per module (x::%d,z::%d)\n",fSegSDD->Npx(), fSegSDD->Npz());
	396	printf("SDD dimesion of pixel are (%f,%f) \n", fSegSDD->Dpx(1)0.001,fSegSDD->Dpz(1)0.001);
	397	printf("*********************************************************\n");
	398	printf("SSD module dimension (%f,%f) \n",fSegSSD->Dx()0.0001, fSegSSD->Dz()0.0001);
	399	printf("SSD first,last module:: %d,%d \n", fGeom->GetStartSSD(),fGeom->GetLastSSD() );
	400	printf("SSD strips in module %d \n",fSegSSD->Npx());
	401	printf("SSD strip sizes are (%f,%f) \n", fSegSSD->Dpx(1),fSegSSD->Dpz(1));
	402	fSegSSD->SetLayer(5); Float_t ap,an; fSegSSD->Angles(ap,an);
	403	printf("SSD layer 5 stereoP %f stereoN %f angle \n",ap,an);
	404	fSegSSD->SetLayer(6); fSegSSD->Angles(ap,an);
	405	printf("SSD layer 6 stereoP %f stereoN %f angle \n",ap,an);
	406	}
	407
	408
	409	/*
	410	printf("num cells %d,%d scaled %d,%d \n",fSegSPD->Npz(),fSegSPD->Npx(),Nz,Nx);
	411	printf("%d digits in ITSModule %d\n",ne, module);
	412	Float_t zn = i(3.482)/Nz - 3.48 ;
	413	Float_t xo = -fSegSPD->Dx()0.00005 + fSegSPD->Dpx(0)od->GetCoord2()*0.0001;
	414	Float_t xn = -fSegSPD->Dx()0.00005 + j0.0001*fSegSPD->Dx()/Nx;
	415	Float_t dpx = 0.0001*fSegSPD->Dx()/Nx;
	416	Float_t dpz = 3.48*2/Nz;
	417	printf("Z::original (%3f) scaled (%3f, %3f) \n", zo, zn-dpz/2, zn+dpz/2);
	418	printf("X::original (%3f) scaled (%3f, %3f) \n", xo, xn-dpx/2, xn+dpx/2);
	419	printf("%d,%d maped to %d,%d \n", od->GetCoord1(), od->GetCoord2(), i,j );
	420	*/