[u/mrichter/AliRoot.git] / ITS / UPGRADE / AliITSURecoLayer.cxx

#include <TClonesArray.h>
#include "AliITSURecoLayer.h"
#include "AliITSUGeomTGeo.h"
#include "AliITSsegmentation.h"
#include "AliITSUAux.h"
#include "AliITSUClusterPix.h"

using namespace AliITSUAux;
using namespace TMath;

ClassImp(AliITSURecoLayer)


//______________________________________________________
AliITSURecoLayer::AliITSURecoLayer(const char* name)
  :fActiveID(-1)
  ,fNSensors(0)
  ,fNSensInLadder(0)
  ,fNLadders(0)
  ,fR(0)
  ,fRMax(0)
  ,fRMin(0)
  ,fZMax(0)
  ,fZMin(0)
  ,fPhiLadMax(0)
  ,fPhiLadMin(0)
  ,fPhiOffs(0)
  ,fSensDZInv(0)
  ,fDPhiLadInv(0)
  ,fMaxStep(0.5)
  ,fSensors(0)
  ,fITSGeom(0)
  ,fClusters(0)
{
  // def. c-tor
  SetNameTitle(name,name);
}

//______________________________________________________
AliITSURecoLayer::AliITSURecoLayer(const char* name, Int_t activeID, AliITSUGeomTGeo* gm)
  :fActiveID(activeID)
  ,fNSensors(0)
  ,fNSensInLadder(0)
  ,fNLadders(0)
  ,fR(0)
  ,fRMax(0)
  ,fRMin(0)
  ,fZMax(0)
  ,fZMin(0)
  ,fPhiLadMax(0)
  ,fPhiLadMin(0)
  ,fPhiOffs(0)
  ,fSensDZInv(0)
  ,fDPhiLadInv(0)
  ,fMaxStep(0.5)
  ,fSensors(0)
  ,fITSGeom(gm)
  ,fClusters(0)
{
  // def. c-tor
  SetNameTitle(name,name);
  Build();
}

//______________________________________________________
AliITSURecoLayer::~AliITSURecoLayer()
{
  // def. d-tor
  delete[] fSensors;
  delete[] fPhiLadMax;
  delete[] fPhiLadMin;
}

//______________________________________________________
void AliITSURecoLayer::Print(Option_t* opt) const			      
{
  //print 
  printf("Layer %s %d (active:%+d), NSensors: %d\n",GetName(),GetID(),GetActiveID(),GetNSensors());
  TString opts = opt; opts.ToLower();
  if (opts.Contains("sn")) for (int i=0;i<GetNSensors();i++) GetSensor(i)->Print(opt);
}

//______________________________________________________
void AliITSURecoLayer::Build()
{
  // build internal structures
  if (fActiveID<0) return;
  fNLadders = fITSGeom->GetNLadders(fActiveID);
  fNSensInLadder = fITSGeom->GetNDetectors(fActiveID);
  fNSensors = fNLadders*fNSensInLadder;
  fSensors = new AliITSURecoSens*[fNSensors];
  const AliITSsegmentation* kSegm = fITSGeom->GetSegmentation(fActiveID);
  //
  // name layer according its active id, detector type and segmentation tyoe
  TGeoHMatrix mmod;
  const TGeoHMatrix* mt2l;
  fRMin=fZMin=1e9;
  fRMax=fZMax=-1e9;
  double phiTF,rTF, loc[3]={0,0,0},glo[3];
  fNSensors = 0;
  fPhiLadMin = new Double_t[fNLadders];
  fPhiLadMax = new Double_t[fNLadders];
  fSensDZInv = 0;
  //
  for (int ild=0;ild<fNLadders;ild++) {
    fPhiLadMin[ild] = 1e9;
    fPhiLadMax[ild] = -1e9;
    //
    for (int idt=0;idt<fNSensInLadder;idt++) {
      AliITSURecoSens* sens = new AliITSURecoSens(fNSensors++);
      fSensors[idt] = sens;
      //
      double phiMin=1e9,phiMax=-1e9,zMin=1e9,zMax=-1e9;
      mmod = *fITSGeom->GetMatrix(fActiveID,ild,idt);
      for (int ix=0;ix<2;ix++) {
	loc[0] = (ix-0.5)*kSegm->Dx(); // +-DX/2
	for (int iy=0;iy<2;iy++) {
	  loc[1] = (iy-0.5)*kSegm->Dy(); // +-DY/2
	  for (int iz=0;iz<2;iz++) {
	    loc[2] = (iz-0.5)*kSegm->Dz(); // +-DZ/2
	    //
	    mmod.LocalToMaster(loc,glo);
	    double phi = ATan2(glo[1],glo[0]);
	    double r   = glo[0]*glo[0] + glo[1]*glo[1];
	    if (fRMin>r) fRMin = r;
	    if (fRMax<r) fRMax = r;
	    BringTo02Pi(phi);
	    if      (phiMin>1e8) phiMin=phi; 
	    else if (!OKforPhiMin(phiMin,phi)) phiMin=phi;
	    if      (phiMax<-1e8) phiMax=phi;
	    else if (!OKforPhiMax(phiMax,phi)) phiMax=phi;	      
	    if (glo[2]>zMax) zMax=glo[2]; else if (glo[2]<zMin) zMin=glo[2];
	  }
	}
      }
      printf("%d %d (%d)  %f %f\n",ild,idt, ild*fNSensInLadder+idt,phiMin,phiMax);

      sens->SetBoundaries(phiMin,phiMax,zMin,zMax);
      mt2l = fITSGeom->GetMatrixT2L(fActiveID,ild,idt);
      mmod.Multiply(mt2l);	
      loc[0]=loc[1]=loc[2]=0;
      mmod.LocalToMaster(loc,glo);
      rTF   = Sqrt(glo[0]*glo[0] + glo[1]*glo[1]);  //  tracking params (misaligned)
      phiTF = ATan2(glo[1],glo[0]);
      BringTo02Pi(phiTF);
      //
      sens->SetXTF(rTF);
      sens->SetPhiTF(phiTF);
      //
      if      (fPhiLadMin[ild]>1e8)  fPhiLadMin[ild] = phiMin;
      else if (!OKforPhiMin(fPhiLadMin[ild],phiMin)) fPhiLadMin[ild] = phiMin;
      if      (fPhiLadMax[ild]<-1e8) fPhiLadMax[ild] = phiMax;
      else if (!OKforPhiMax(fPhiLadMax[ild],phiMax)) fPhiLadMax[ild] = phiMax;
      if (fZMin>zMin) fZMin = zMin;
      if (fZMax<zMax) fZMax = zMax;
      //
      if (idt>0) fSensDZInv += zMax - GetSensor(fNSensors-2)->GetZMax(); // z interval to previoud
    }
  }
  //
  fRMin = Sqrt(fRMin);
  fRMax = Sqrt(fRMax);
  fR = 0.5*(fRMin+fRMax);
  double dz = fNSensInLadder>0 ? fSensDZInv/(fNSensInLadder-1)/fNLadders : fZMax-fZMin;
  fSensDZInv = 1./dz;

  const int kNBId[3][3] = { 
    {AliITSURecoSens::kNghbBL,AliITSURecoSens::kNghbB,AliITSURecoSens::kNghbBR},
    {AliITSURecoSens::kNghbL,          -1            ,AliITSURecoSens::kNghbR },
    {AliITSURecoSens::kNghbTL,AliITSURecoSens::kNghbT,AliITSURecoSens::kNghbTR}
  };

  // add neighbours info
  double zTol = 0.45*dz, phiTol = 0.45*TwoPi()/fNLadders;
  for (int ild=0;ild<fNLadders;ild++) {
    for (int idt=0;idt<fNSensInLadder;idt++) {
      AliITSURecoSens* sens = GetSensor(ild,idt);
      //
      for (int ils=-1;ils<=1;ils++) {
	int ildN = ild+ils;  // ladders of neighbouring sensors
	if (ildN<0) ildN = fNLadders-1; else if (ildN==fNLadders) ildN = 0;
	for (int ids=-1;ids<=1;ids++) {
	  int idtN = idt+ids;
	  if (idtN<0 || idtN==fNSensInLadder || (ids==0&&ils==0)) continue;
	  AliITSURecoSens* sensN = GetSensor(ildN,idtN); // potential neighbor
	  int neighbID = ildN*fNSensInLadder+idtN;
	  //	  
	  int zType = 1;  // side
	  if (sens->GetZMin()-zTol  > sensN->GetZMax()) continue; // too large distance
	  if (sensN->GetZMin()-zTol > sens->GetZMax() ) continue; // too large distance
	  if      (sens->GetZMin()-zTol>sensN->GetZMin()) zType =  0;     // bottom
	  else if (sensN->GetZMin()-zTol>sens->GetZMin()) zType =  2;     // top
	  //
	  int phiType = 1;

	  double phiTstMn = sensN->GetPhiMin()-phiTol;
	  BringTo02Pi(phiTstMn);
	  if (!OKforPhiMax(sens->GetPhiMax(),phiTstMn)) continue; // too large angle	  
	  double phiTstMx = sensN->GetPhiMax()+phiTol;	  
	  BringTo02Pi(phiTstMx);
	  if (!OKforPhiMin(sens->GetPhiMin(),phiTstMx)) continue; // too large angle
	  //
	  phiTstMn = sensN->GetPhiMin()+phiTol;
	  BringTo02Pi(phiTstMn);
	  phiTstMx = sensN->GetPhiMax()-phiTol;	  
	  BringTo02Pi(phiTstMx);
	  if      (!OKforPhiMax(sens->GetPhiMax(),phiTstMx)) phiType = 0; // left
	  else if (!OKforPhiMin(sens->GetPhiMin(),phiTstMn)) phiType = 2; // right
	  //
	  sens->SetNeighborID(kNBId[zType][phiType], neighbID);
	} // phi scan
      } // z scan
    } // sensors
  } // ladders
  //
  //
}

//______________________________________________________
Int_t AliITSURecoLayer::FindSensors(const double* impPar, AliITSURecoSens *sensors[AliITSURecoSens::kNNeighbors])
{
  // find sensors having intersection with track
  // impPar contains: lab phi of track, dphi, labZ, dz
  double z = impPar[2];
  if (z>fZMax+impPar[3]) return -1; // outside of Z coverage
  z -= fZMin;
  if (z<-impPar[3]) return -1; // outside of Z coverage
  int sensInLad = int(z*fSensDZInv);
  //
  double phi = impPar[0] - fPhiOffs;
  BringTo02Pi(phi);
  int ladID = int(phi*fDPhiLadInv);  // ladder id
  int nsens = 0;
  //
  AliITSURecoSens* sensN,*sens = GetSensor(ladID*fNSensInLadder+sensInLad);
  sensors[nsens++] = sens;
  // check neighbours
  double zMn=impPar[2]-impPar[3], zMx=impPar[2]+impPar[3], phiMn=impPar[0]-impPar[1], phiMx=impPar[0]+impPar[1];
  BringTo02Pi(phiMn);
  BringTo02Pi(phiMx);
  //
  sensN = GetSensor(sens->GetNeighborID(AliITSURecoSens::kNghbR)); // neighbor on the right
  if (sensN && OKforPhiMax(phiMx,sensN->GetPhiMin())) sensors[nsens++] = sensN;
  //
  sensN = GetSensor(sens->GetNeighborID(AliITSURecoSens::kNghbTR)); // neighbor on the top right
  if (sensN && OKforPhiMax(phiMx,sensN->GetPhiMin()) && sensN->GetZMin()<zMx) sensors[nsens++] = sensN;
  //
  sensN = GetSensor(sens->GetNeighborID(AliITSURecoSens::kNghbT)); // neighbor on the top
  if (sensN && sensN->GetZMin()>zMx) sensors[nsens++] = sensN;
  //
  sensN = GetSensor(sens->GetNeighborID(AliITSURecoSens::kNghbTL)); // neighbor on the top left
  if (sensN && OKforPhiMin(phiMn,sensN->GetPhiMax()) && sensN->GetZMin()<zMx) sensors[nsens++] = sensN;
  //
  sensN = GetSensor(sens->GetNeighborID(AliITSURecoSens::kNghbL)); // neighbor on the left
  if (sensN && OKforPhiMin(phiMn,sensN->GetPhiMax())) sensors[nsens++] = sensN;
  //
  sensN = GetSensor(sens->GetNeighborID(AliITSURecoSens::kNghbBL)); // neighbor on the bottom left
  if (sensN && OKforPhiMin(phiMn,sensN->GetPhiMax()) && sensN->GetZMax()>zMn) sensors[nsens++] = sensN;
  //
  sensN = GetSensor(sens->GetNeighborID(AliITSURecoSens::kNghbB));  // neighbor on the bottom
  if (sensN && sensN->GetZMax()>zMn) sensors[nsens++] = sensN;
  //
  sensN = GetSensor(sens->GetNeighborID(AliITSURecoSens::kNghbBR)); // neighbor on the bottom right
  if (sensN && OKforPhiMax(phiMx,sensN->GetPhiMin()) && sensN->GetZMax()>zMn) sensors[nsens++] = sensN;
  //
  return nsens;
}

//______________________________________________________
void AliITSURecoLayer::ProcessClusters(Int_t mode)
{
  // register in each sensor of the layer its cluster.
  // the clusters of the layer must be sorted per sensor
  int ncl = fClusters->GetEntriesFast();
  int curSensID = -1;
  AliITSURecoSens* curSens = 0;
  for (int icl=0;icl<ncl;icl++) {
    AliITSUClusterPix* cl = (AliITSUClusterPix*) fClusters->UncheckedAt(icl);
    cl->GoToFrameTrk();
    int vID = cl->GetVolumeId();
    if (vID<curSensID) {AliFatal("Clusters are not sorted in increasing sensorID");}
    if (vID>curSensID) {
      if (curSens) curSens->ProcessClusters(mode);    // prepare clusters for reconstruction
      curSens   = GetSensor(vID - fITSGeom->GetFirstModIndex(fActiveID));
      curSensID = vID;
      curSens->SetFirstClusterId(icl);
    }
    curSens->IncNClusters();
  }
  if (curSens) curSens->ProcessClusters(mode); // last sensor was not processed yet
  //
}
Commit	Line	Data
32d38de2	1	#include <TClonesArray.h>
a11ef2e4	2	#include "AliITSURecoLayer.h"
	3	#include "AliITSUGeomTGeo.h"
	4	#include "AliITSsegmentation.h"
a11ef2e4	5	#include "AliITSUAux.h"
32d38de2	6	#include "AliITSUClusterPix.h"
a11ef2e4	7
	8	using namespace AliITSUAux;
	9	using namespace TMath;
	10
	11	ClassImp(AliITSURecoLayer)
	12
	13
	14	//______________________________________________________
	15	AliITSURecoLayer::AliITSURecoLayer(const char* name)
	16	:fActiveID(-1)
	17	,fNSensors(0)
	18	,fNSensInLadder(0)
	19	,fNLadders(0)
	20	,fR(0)
	21	,fRMax(0)
	22	,fRMin(0)
	23	,fZMax(0)
	24	,fZMin(0)
	25	,fPhiLadMax(0)
	26	,fPhiLadMin(0)
	27	,fPhiOffs(0)
	28	,fSensDZInv(0)
	29	,fDPhiLadInv(0)
32d38de2	30	,fMaxStep(0.5)
a11ef2e4	31	,fSensors(0)
a11ef2e4	32	,fITSGeom(0)
32d38de2	33	,fClusters(0)
a11ef2e4	34	{
	35	// def. c-tor
	36	SetNameTitle(name,name);
a11ef2e4	37	}
	38
	39	//______________________________________________________
32d38de2	40	AliITSURecoLayer::AliITSURecoLayer(const char* name, Int_t activeID, AliITSUGeomTGeo* gm)
a11ef2e4	41	:fActiveID(activeID)
	42	,fNSensors(0)
	43	,fNSensInLadder(0)
	44	,fNLadders(0)
	45	,fR(0)
	46	,fRMax(0)
	47	,fRMin(0)
	48	,fZMax(0)
	49	,fZMin(0)
	50	,fPhiLadMax(0)
	51	,fPhiLadMin(0)
	52	,fPhiOffs(0)
	53	,fSensDZInv(0)
	54	,fDPhiLadInv(0)
32d38de2	55	,fMaxStep(0.5)
32d38de2	56	,fSensors(0)
a11ef2e4	57	,fITSGeom(gm)
32d38de2	58	,fClusters(0)
a11ef2e4	59	{
	60	// def. c-tor
	61	SetNameTitle(name,name);
32d38de2	62	Build();
a11ef2e4	63	}
	64
	65	//______________________________________________________
	66	AliITSURecoLayer::~AliITSURecoLayer()
	67	{
	68	// def. d-tor
32d38de2	69	delete[] fSensors;
	70	delete[] fPhiLadMax;
	71	delete[] fPhiLadMin;
a11ef2e4	72	}
	73
	74	//______________________________________________________
	75	void AliITSURecoLayer::Print(Option_t* opt) const
	76	{
	77	//print
	78	printf("Layer %s %d (active:%+d), NSensors: %d\n",GetName(),GetID(),GetActiveID(),GetNSensors());
	79	TString opts = opt; opts.ToLower();
	80	if (opts.Contains("sn")) for (int i=0;i<GetNSensors();i++) GetSensor(i)->Print(opt);
	81	}
	82
	83	//______________________________________________________
32d38de2	84	void AliITSURecoLayer::Build()
a11ef2e4	85	{
a11ef2e4	86	// build internal structures
32d38de2	87	if (fActiveID<0) return;
a11ef2e4	88	fNLadders = fITSGeom->GetNLadders(fActiveID);
a11ef2e4	89	fNSensInLadder = fITSGeom->GetNDetectors(fActiveID);
32d38de2	90	fNSensors = fNLadders*fNSensInLadder;
32d38de2	91	fSensors = new AliITSURecoSens*[fNSensors];
546d00d8	92	const AliITSsegmentation* kSegm = fITSGeom->GetSegmentation(fActiveID);
a11ef2e4	93	//
	94	// name layer according its active id, detector type and segmentation tyoe
	95	TGeoHMatrix mmod;
	96	const TGeoHMatrix* mt2l;
	97	fRMin=fZMin=1e9;
	98	fRMax=fZMax=-1e9;
	99	double phiTF,rTF, loc[3]={0,0,0},glo[3];
	100	fNSensors = 0;
	101	fPhiLadMin = new Double_t[fNLadders];
	102	fPhiLadMax = new Double_t[fNLadders];
	103	fSensDZInv = 0;
	104	//
	105	for (int ild=0;ild<fNLadders;ild++) {
	106	fPhiLadMin[ild] = 1e9;
	107	fPhiLadMax[ild] = -1e9;
	108	//
	109	for (int idt=0;idt<fNSensInLadder;idt++) {
	110	AliITSURecoSens* sens = new AliITSURecoSens(fNSensors++);
32d38de2	111	fSensors[idt] = sens;
a11ef2e4	112	//
	113	double phiMin=1e9,phiMax=-1e9,zMin=1e9,zMax=-1e9;
	114	mmod = *fITSGeom->GetMatrix(fActiveID,ild,idt);
	115	for (int ix=0;ix<2;ix++) {
546d00d8	116	loc[0] = (ix-0.5)*kSegm->Dx(); // +-DX/2
a11ef2e4	117	for (int iy=0;iy<2;iy++) {
546d00d8	118	loc[1] = (iy-0.5)*kSegm->Dy(); // +-DY/2
a11ef2e4	119	for (int iz=0;iz<2;iz++) {
546d00d8	120	loc[2] = (iz-0.5)*kSegm->Dz(); // +-DZ/2
a11ef2e4	121	//
	122	mmod.LocalToMaster(loc,glo);
	123	double phi = ATan2(glo[1],glo[0]);
	124	double r = glo[0]glo[0] + glo[1]glo[1];
	125	if (fRMin>r) fRMin = r;
	126	if (fRMax<r) fRMax = r;
	127	BringTo02Pi(phi);
	128	if (phiMin>1e8) phiMin=phi;
	129	else if (!OKforPhiMin(phiMin,phi)) phiMin=phi;
	130	if (phiMax<-1e8) phiMax=phi;
	131	else if (!OKforPhiMax(phiMax,phi)) phiMax=phi;
	132	if (glo[2]>zMax) zMax=glo[2]; else if (glo[2]<zMin) zMin=glo[2];
	133	}
	134	}
	135	}
	136	printf("%d %d (%d) %f %f\n",ild,idt, ild*fNSensInLadder+idt,phiMin,phiMax);
	137
	138	sens->SetBoundaries(phiMin,phiMax,zMin,zMax);
	139	mt2l = fITSGeom->GetMatrixT2L(fActiveID,ild,idt);
	140	mmod.Multiply(mt2l);
	141	loc[0]=loc[1]=loc[2]=0;
	142	mmod.LocalToMaster(loc,glo);
	143	rTF = Sqrt(glo[0]glo[0] + glo[1]glo[1]); // tracking params (misaligned)
	144	phiTF = ATan2(glo[1],glo[0]);
	145	BringTo02Pi(phiTF);
	146	//
	147	sens->SetXTF(rTF);
	148	sens->SetPhiTF(phiTF);
	149	//
	150	if (fPhiLadMin[ild]>1e8) fPhiLadMin[ild] = phiMin;
	151	else if (!OKforPhiMin(fPhiLadMin[ild],phiMin)) fPhiLadMin[ild] = phiMin;
	152	if (fPhiLadMax[ild]<-1e8) fPhiLadMax[ild] = phiMax;
	153	else if (!OKforPhiMax(fPhiLadMax[ild],phiMax)) fPhiLadMax[ild] = phiMax;
	154	if (fZMin>zMin) fZMin = zMin;
	155	if (fZMax<zMax) fZMax = zMax;
	156	//
	157	if (idt>0) fSensDZInv += zMax - GetSensor(fNSensors-2)->GetZMax(); // z interval to previoud
	158	}
	159	}
	160	//
	161	fRMin = Sqrt(fRMin);
	162	fRMax = Sqrt(fRMax);
	163	fR = 0.5*(fRMin+fRMax);
	164	double dz = fNSensInLadder>0 ? fSensDZInv/(fNSensInLadder-1)/fNLadders : fZMax-fZMin;
	165	fSensDZInv = 1./dz;
	166
	167	const int kNBId[3][3] = {
	168	{AliITSURecoSens::kNghbBL,AliITSURecoSens::kNghbB,AliITSURecoSens::kNghbBR},
	169	{AliITSURecoSens::kNghbL, -1 ,AliITSURecoSens::kNghbR },
	170	{AliITSURecoSens::kNghbTL,AliITSURecoSens::kNghbT,AliITSURecoSens::kNghbTR}
	171	};
	172
	173	// add neighbours info
	174	double zTol = 0.45dz, phiTol = 0.45TwoPi()/fNLadders;
	175	for (int ild=0;ild<fNLadders;ild++) {
	176	for (int idt=0;idt<fNSensInLadder;idt++) {
	177	AliITSURecoSens* sens = GetSensor(ild,idt);
	178	//
	179	for (int ils=-1;ils<=1;ils++) {
	180	int ildN = ild+ils; // ladders of neighbouring sensors
	181	if (ildN<0) ildN = fNLadders-1; else if (ildN==fNLadders) ildN = 0;
	182	for (int ids=-1;ids<=1;ids++) {
	183	int idtN = idt+ids;
	184	if (idtN<0 \|\| idtN==fNSensInLadder \|\| (ids==0&&ils==0)) continue;
185	AliITSURecoSens* sensN = GetSensor(ildN,idtN); // potential neighbor
186	int neighbID = ildN*fNSensInLadder+idtN;
187	//
188	int zType = 1; // side
32d38de2	189	if (sens->GetZMin()-zTol > sensN->GetZMax()) continue; // too large distance
32d38de2	190	if (sensN->GetZMin()-zTol > sens->GetZMax() ) continue; // too large distance
a11ef2e4	191	if (sens->GetZMin()-zTol>sensN->GetZMin()) zType = 0; // bottom
	192	else if (sensN->GetZMin()-zTol>sens->GetZMin()) zType = 2; // top
	193	//
	194	int phiType = 1;
32d38de2	195
a11ef2e4	196	double phiTstMn = sensN->GetPhiMin()-phiTol;
	197	BringTo02Pi(phiTstMn);
	198	if (!OKforPhiMax(sens->GetPhiMax(),phiTstMn)) continue; // too large angle
	199	double phiTstMx = sensN->GetPhiMax()+phiTol;
	200	BringTo02Pi(phiTstMx);
	201	if (!OKforPhiMin(sens->GetPhiMin(),phiTstMx)) continue; // too large angle
	202	//
	203	phiTstMn = sensN->GetPhiMin()+phiTol;
	204	BringTo02Pi(phiTstMn);
	205	phiTstMx = sensN->GetPhiMax()-phiTol;
	206	BringTo02Pi(phiTstMx);
	207	if (!OKforPhiMax(sens->GetPhiMax(),phiTstMx)) phiType = 0; // left
	208	else if (!OKforPhiMin(sens->GetPhiMin(),phiTstMn)) phiType = 2; // right
	209	//
	210	sens->SetNeighborID(kNBId[zType][phiType], neighbID);
	211	} // phi scan
	212	} // z scan
	213	} // sensors
	214	} // ladders
	215	//
	216	//
a11ef2e4	217	}
	218
	219	//______________________________________________________
32d38de2	220	Int_t AliITSURecoLayer::FindSensors(const double* impPar, AliITSURecoSens *sensors[AliITSURecoSens::kNNeighbors])
a11ef2e4	221	{
	222	// find sensors having intersection with track
	223	// impPar contains: lab phi of track, dphi, labZ, dz
	224	double z = impPar[2];
	225	if (z>fZMax+impPar[3]) return -1; // outside of Z coverage
	226	z -= fZMin;
	227	if (z<-impPar[3]) return -1; // outside of Z coverage
	228	int sensInLad = int(z*fSensDZInv);
	229	//
	230	double phi = impPar[0] - fPhiOffs;
	231	BringTo02Pi(phi);
	232	int ladID = int(phi*fDPhiLadInv); // ladder id
	233	int nsens = 0;
	234	//
	235	AliITSURecoSens* sensN,sens = GetSensor(ladIDfNSensInLadder+sensInLad);
	236	sensors[nsens++] = sens;
	237	// check neighbours
	238	double zMn=impPar[2]-impPar[3], zMx=impPar[2]+impPar[3], phiMn=impPar[0]-impPar[1], phiMx=impPar[0]+impPar[1];
	239	BringTo02Pi(phiMn);
	240	BringTo02Pi(phiMx);
	241	//
	242	sensN = GetSensor(sens->GetNeighborID(AliITSURecoSens::kNghbR)); // neighbor on the right
	243	if (sensN && OKforPhiMax(phiMx,sensN->GetPhiMin())) sensors[nsens++] = sensN;
	244	//
	245	sensN = GetSensor(sens->GetNeighborID(AliITSURecoSens::kNghbTR)); // neighbor on the top right
	246	if (sensN && OKforPhiMax(phiMx,sensN->GetPhiMin()) && sensN->GetZMin()<zMx) sensors[nsens++] = sensN;
	247	//
	248	sensN = GetSensor(sens->GetNeighborID(AliITSURecoSens::kNghbT)); // neighbor on the top
	249	if (sensN && sensN->GetZMin()>zMx) sensors[nsens++] = sensN;
	250	//
	251	sensN = GetSensor(sens->GetNeighborID(AliITSURecoSens::kNghbTL)); // neighbor on the top left
	252	if (sensN && OKforPhiMin(phiMn,sensN->GetPhiMax()) && sensN->GetZMin()<zMx) sensors[nsens++] = sensN;
	253	//
	254	sensN = GetSensor(sens->GetNeighborID(AliITSURecoSens::kNghbL)); // neighbor on the left
	255	if (sensN && OKforPhiMin(phiMn,sensN->GetPhiMax())) sensors[nsens++] = sensN;
	256	//
	257	sensN = GetSensor(sens->GetNeighborID(AliITSURecoSens::kNghbBL)); // neighbor on the bottom left
	258	if (sensN && OKforPhiMin(phiMn,sensN->GetPhiMax()) && sensN->GetZMax()>zMn) sensors[nsens++] = sensN;
	259	//
	260	sensN = GetSensor(sens->GetNeighborID(AliITSURecoSens::kNghbB)); // neighbor on the bottom
	261	if (sensN && sensN->GetZMax()>zMn) sensors[nsens++] = sensN;
	262	//
	263	sensN = GetSensor(sens->GetNeighborID(AliITSURecoSens::kNghbBR)); // neighbor on the bottom right
	264	if (sensN && OKforPhiMax(phiMx,sensN->GetPhiMin()) && sensN->GetZMax()>zMn) sensors[nsens++] = sensN;
	265	//
	266	return nsens;
	267	}
	268
32d38de2	269	//______________________________________________________
	270	void AliITSURecoLayer::ProcessClusters(Int_t mode)
	271	{
	272	// register in each sensor of the layer its cluster.
	273	// the clusters of the layer must be sorted per sensor
	274	int ncl = fClusters->GetEntriesFast();
	275	int curSensID = -1;
	276	AliITSURecoSens* curSens = 0;
	277	for (int icl=0;icl<ncl;icl++) {
	278	AliITSUClusterPix* cl = (AliITSUClusterPix*) fClusters->UncheckedAt(icl);
	279	cl->GoToFrameTrk();
	280	int vID = cl->GetVolumeId();
	281	if (vID<curSensID) {AliFatal("Clusters are not sorted in increasing sensorID");}
	282	if (vID>curSensID) {
	283	if (curSens) curSens->ProcessClusters(mode); // prepare clusters for reconstruction
	284	curSens = GetSensor(vID - fITSGeom->GetFirstModIndex(fActiveID));
	285	curSensID = vID;
	286	curSens->SetFirstClusterId(icl);
	287	}
	288	curSens->IncNClusters();
	289	}
	290	if (curSens) curSens->ProcessClusters(mode); // last sensor was not processed yet
	291	//
	292	}