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

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id: AliITSUSegmentationPix.cxx 47180 2011-02-08 09:42:29Z masera $ */
#include <TGeoManager.h>
#include <TGeoVolume.h>
#include <TGeoBBox.h>
#include <TObjArray.h>
#include <TString.h>
#include <TSystem.h>
#include <TFile.h>
#include "AliITSUGeomTGeo.h"
#include "AliITSUSegmentationPix.h"
using namespace TMath;

////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Segmentation class for pixels                                                                          //
// Questions to solve: are guardrings needed and do they belong to the sensor or to the module in TGeo    //
//                     At the moment assume that the local coord syst. is located at bottom left corner   //
//                     of the ACTIVE matrix. If the guardring to be accounted in the local coords, in     //
//                     the Z and X conversions one needs to first subtract the  fGuardLft and fGuardBot   //
//                     from the local Z,X coordinates                                                     //
//                                                                                                        //
////////////////////////////////////////////////////////////////////////////////////////////////////////////

ClassImp(AliITSUSegmentationPix)

const char* AliITSUSegmentationPix::fgkSegmListName = "ITSUSegmentations";

//_____________________________________________________________________________RS
AliITSUSegmentationPix::AliITSUSegmentationPix(UInt_t id, int nchips,int ncol,int nrow,
						   double pitchX,double pitchZ,
						   double thickness,
						   double pitchLftC,double pitchRgtC,
						   double edgL,double edgR,double edgT,double edgB)
: AliITSsegmentation()
  ,fGuardLft(edgL)
  ,fGuardRgt(edgR)
  ,fGuardTop(edgT)
  ,fGuardBot(edgB)
  ,fPitchX(pitchX)
  ,fPitchZ(pitchZ)
  ,fPitchZLftCol(pitchLftC<0 ? pitchZ:pitchLftC)
  ,fPitchZRgtCol(pitchRgtC<0 ? pitchZ:pitchRgtC)
  ,fChipDZ(0)
  ,fNChips(nchips)
  ,fNColPerChip(nchips>0 ? ncol/nchips:0)
  ,fNRow(nrow)
  ,fNCol(ncol)
{
  // Default constructor, sizes in cm
  if (nchips) SetUniqueID( AliITSUGeomTGeo::ComposeDetTypeID(id) );
  fChipDZ = (fNColPerChip-2)*fPitchZ + fPitchZLftCol + fPitchZRgtCol;
  SetDetSize( fNRow*fPitchX /*+fGuardTop+fGuardBot*/,
	      fNChips*fChipDZ /*+fGuardLft+fGuardRgt*/,
	      thickness);
  //
}

//_____________________________________________________________________________RS
void AliITSUSegmentationPix::GetPadIxz(Float_t x,Float_t z,Int_t &ix,Int_t &iz) const 
{
  //  Returns pixel coordinates (ix,iz) for given real local coordinates (x,z)
  //  expects x, z in cm. RS: TO CHECK: why from 1
  ix = int(x/fPitchX) + 1;     
  iz = int(Z2Col(z)) + 1;
  //  
  if (iz >  fNCol) iz= fNCol;
  if (ix >  fNRow) ix= fNRow;
  //
}

//_____________________________________________________________________________RS
void AliITSUSegmentationPix::GetPadTxz(Float_t &x,Float_t &z) const
{
  //  local transformation of real local coordinates (x,z)
  //  expects x, z in cm
  x /= fPitchX;
  z = Z2Col(z);
  //
}

//_____________________________________________________________________________RS
void AliITSUSegmentationPix::GetPadCxz(Int_t ix,Int_t iz,Float_t &x,Float_t&z) const
{
  // Transform from pixel to real local coordinates
  // returns x, z in cm. RS: TO CHECK if indexing starts from 1 or 0 
  x = (ix>0) ? Float_t((ix-0.5)*fPitchX) : Float_t((ix+0.5)*fPitchX);
  z = Col2Z(iz);
  //
}

//_____________________________________________________________________________RS
Float_t AliITSUSegmentationPix::Z2Col(Float_t z) const 
{
  // get column number (from 0) from local Z
  int chip = int(z/fChipDZ);
  float col = chip*fNColPerChip;
  z -= chip*fChipDZ;
  if (z>fPitchZLftCol) col += 1+(z-fPitchZLftCol)/fPitchZ;
  return col;
}

//_____________________________________________________________________________RS
Float_t AliITSUSegmentationPix::Col2Z(Int_t col) const 
{
  // convert column number (from 0) to Z coordinate
  int nchip = col/fNColPerChip;
  col %= fNColPerChip;
  float z = nchip*fChipDZ;
  if (col>0) {
    if (col<fNColPerChip-1) z += fPitchZLftCol + (col-0.5)*fPitchZ;
    else                    z += fChipDZ - fPitchZRgtCol/2;
  }
  else z += fPitchZLftCol/2;
  return z;
  //
}

//______________________________________________________________________RS
AliITSUSegmentationPix& AliITSUSegmentationPix::operator=(const AliITSUSegmentationPix &src)
{
  // = operator
  if(this==&src) return *this;
  AliITSsegmentation::operator=(src);
  fNCol  = src.fNCol;
  fNRow  = src.fNRow;
  fNColPerChip  = src.fNColPerChip;
  fNChips = src.fNChips;
  fChipDZ = src.fChipDZ;
  fPitchZRgtCol = src.fPitchZRgtCol;
  fPitchZLftCol = src.fPitchZLftCol;
  fPitchZ = src.fPitchZ;
  fPitchX = src.fPitchX;
  //
  fGuardBot = src.fGuardBot;
  fGuardTop = src.fGuardTop;
  fGuardRgt = src.fGuardRgt;
  fGuardLft = src.fGuardLft;
  //
  return *this;
}

//____________________________________________________________________________RS
AliITSUSegmentationPix::AliITSUSegmentationPix(const AliITSUSegmentationPix &src) :
  AliITSsegmentation(src)
  ,fGuardLft(src.fGuardLft)
  ,fGuardRgt(src.fGuardRgt)
  ,fGuardTop(src.fGuardTop)
  ,fGuardBot(src.fGuardBot)
  ,fPitchX(src.fPitchX)
  ,fPitchZ(src.fPitchZ)
  ,fPitchZLftCol(src.fPitchZLftCol)
  ,fPitchZRgtCol(src.fPitchZRgtCol)
  ,fChipDZ(src.fChipDZ)
  ,fNChips(src.fNChips)
  ,fNColPerChip(src.fNColPerChip)
  ,fNRow(src.fNRow)
  ,fNCol(src.fNCol)  
{
}

//____________________________________________________________________________RS
Float_t AliITSUSegmentationPix::Dpx(Int_t ) const 
{
  //returs x pixel pitch for a give pixel
  return fPitchX;
}

//____________________________________________________________________________RS
Float_t AliITSUSegmentationPix::Dpz(Int_t col) const 
{
  // returns z pixel pitch for a given pixel (cols starts from 0)
  col %= fNColPerChip;
  if (!col) return fPitchZLftCol;
  if (col==fNColPerChip-1) return fPitchZRgtCol;
  return fPitchZ;
  //
}

//------------------------------
void AliITSUSegmentationPix::Neighbours(Int_t iX, Int_t iZ, Int_t* nlist, Int_t xlist[8], Int_t zlist[8]) const 
{
  // returns the neighbouring pixels for use in Cluster Finders and the like.
  //
  *nlist=8;
  xlist[0]=xlist[1]=iX;
  xlist[2]=iX-1;
  xlist[3]=iX+1;
  zlist[0]=iZ-1;
  zlist[1]=iZ+1;
  zlist[2]=zlist[3]=iZ;
  // Diagonal elements
  xlist[4]=iX+1;
  zlist[4]=iZ+1;
  //  
  xlist[5]=iX-1;
  zlist[5]=iZ-1;
  //
  xlist[6]=iX-1;
  zlist[6]=iZ+1;
  //
  xlist[7]=iX+1;
  zlist[7]=iZ-1;
  //
}

//______________________________________________________________________
Bool_t AliITSUSegmentationPix::LocalToDet(Float_t x,Float_t z,Int_t &ix,Int_t &iz) const 
{
  // Transformation from Geant detector centered local coordinates (cm) to
  // Pixel cell numbers ix and iz.
  // Input:
  //    Float_t   x        detector local coordinate x in cm with respect to
  //                       the center of the sensitive volume.
  //    Float_t   z        detector local coordinate z in cm with respect to
  //                       the center of the sensitive volulme.
  // Output:
  //    Int_t    ix        detector x cell coordinate. Has the range 
  //                       0<=ix<fNRow.
  //    Int_t    iz        detector z cell coordinate. Has the range 
  //                       0<=iz<fNCol.
  // Return:
  //   kTRUE if point x,z is inside sensitive volume, kFALSE otherwise.
  //   A value of -1 for ix or iz indecates that this point is outside of the
  //   detector segmentation as defined.
  x += 0.5*Dx();
  z += 0.5*Dz();
  ix = iz = -1;
  if(x<0 || x>Dx()) return kFALSE; // outside x range.
  if(z<0 || z>Dz()) return kFALSE; // outside z range.
  ix = int(x/fPitchX);
  iz = Z2Col(z);
  return kTRUE; // Found ix and iz, return.
}

//______________________________________________________________________
void AliITSUSegmentationPix::DetToLocal(Int_t ix,Int_t iz,Float_t &x,Float_t &z) const
{
// Transformation from Detector cell coordiantes to Geant detector centerd 
// local coordinates (cm).
// Input:
// Int_t    ix        detector x cell coordinate. Has the range 0<=ix<fNRow.
// Int_t    iz        detector z cell coordinate. Has the range 0<=iz<fNCol.
// Output:
// Float_t   x        detector local coordinate x in cm with respect to the
//                    center of the sensitive volume.
// Float_t   z        detector local coordinate z in cm with respect to the
//                    center of the sensitive volulme.
// If ix and or iz is outside of the segmentation range a value of -0.5*Dx()
// or -0.5*Dz() is returned.
  //
  x = -0.5*Dx(); // default value.
  z = -0.5*Dz(); // default value.
  // RS: to check: why we don't do strict check for [0:n)
  if(ix<0 || ix>fNRow) return; // outside of detector 
  if(iz<0 || iz>fNCol) return; // outside of detctor
  x += (ix+0.5)*fPitchX;       // RS: we go to the center of the pad, i.e. + pitch/2, not to the boundary as in SPD
  z += Col2Z(iz); 
  return; // Found x and z, return.
}

//______________________________________________________________________
void AliITSUSegmentationPix::CellBoundries(Int_t ix,Int_t iz,Double_t &xl,Double_t &xu,Double_t &zl,Double_t &zu) const
{
  // Transformation from Detector cell coordiantes to Geant detector centerd 
  // local coordinates (cm).
  // Input:
  // Int_t    ix        detector x cell coordinate. Has the range 0<=ix<fNRow.
  // Int_t    iz        detector z cell coordinate. Has the range 0<=iz<fNCol.
  // Output:
  // Double_t   xl       detector local coordinate cell lower bounds x in cm
  //                    with respect to the center of the sensitive volume.
  // Double_t   xu       detector local coordinate cell upper bounds x in cm 
  //                    with respect to the center of the sensitive volume.
  // Double_t   zl       detector local coordinate lower bounds z in cm with
  //                    respect to the center of the sensitive volulme.
  // Double_t   zu       detector local coordinate upper bounds z in cm with 
  //                    respect to the center of the sensitive volulme.
  // If ix and or iz is outside of the segmentation range a value of -0.5*Dx()
  // and -0.5*Dx() or -0.5*Dz() and -0.5*Dz() are returned.
  Float_t x,z;
  DetToLocal(ix,iz,x,z);
  //
  if( ix<0 || ix>=fNRow || iz<0 || iz>=fNCol) {
    xl = xu = -0.5*Dx(); // default value.
    zl = zu = -0.5*Dz(); // default value.
    return; // outside of detctor
  }
  float zpitchH = Dpz(iz)*0.5;
  float xpitchH = fPitchX*0.5;
  xl -= xpitchH;
  xu += xpitchH;
  zl -= zpitchH;
  zu += zpitchH;
  return; // Found x and z, return.
}

//______________________________________________________________________
Int_t AliITSUSegmentationPix::GetChipFromChannel(Int_t, Int_t iz) const 
{
  // returns chip number (in range 0-4) starting from channel number
  if(iz>=fNCol  || iz<0 ){
    AliWarning("Bad cell number");
    return -1;
  }
  return iz/fNColPerChip;
}

//______________________________________________________________________
Int_t AliITSUSegmentationPix::GetChipFromLocal(Float_t, Float_t zloc) const 
{
  // returns chip number (in range 0-4) starting from local coordinates
  Int_t ix0,iz;
  if (!LocalToDet(0,zloc,ix0,iz)) {
    AliWarning("Bad local coordinate");
    return -1;
  } 
  return GetChipFromChannel(ix0,iz);
}

//______________________________________________________________________
Int_t AliITSUSegmentationPix::GetChipsInLocalWindow(Int_t* array, Float_t zmin, Float_t zmax, Float_t, Float_t) const 
{
  // returns the number of chips containing a road defined by given local coordinate limits
  //
  if (zmin>zmax) {
    AliWarning("Bad coordinate limits: zmin>zmax!");
    return -1;
  } 
  //
  Int_t nChipInW = 0;
  //
  Float_t zminDet = -0.5*Dz();
  Float_t zmaxDet =  0.5*Dz();
  if(zmin<zminDet) zmin=zminDet;
  if(zmax>zmaxDet) zmax=zmaxDet;

  Int_t n1 = GetChipFromLocal(0,zmin);
  array[nChipInW] = n1;
  nChipInW++;

  Int_t n2 = GetChipFromLocal(0,zmax);

  if(n2!=n1){
    Int_t imin=Min(n1,n2);
    Int_t imax=Max(n1,n2);
    for(Int_t ichip=imin; ichip<=imax; ichip++){
      if(ichip==n1) continue;
      array[nChipInW]=ichip;
      nChipInW++;
    }
  }
  //
  return nChipInW;
}

//______________________________________________________________________
void AliITSUSegmentationPix::Init()
{
  // init settings
}

//______________________________________________________________________
Bool_t AliITSUSegmentationPix::Store(const char* outf)
{
  // store in the special list under given ID
  TString fns = outf;
  gSystem->ExpandPathName(fns);
  if (fns.IsNull()) {AliFatal("No file name provided"); return kFALSE;}
  TFile* fout = TFile::Open(fns.Data(),"update");
  if (!fout) {AliFatal(Form("Failed to open output file %s",outf)); return kFALSE;}
  TObjArray* arr = (TObjArray*)fout->Get(fgkSegmListName);
  int id = GetUniqueID();
  if (!arr) arr = new TObjArray();
  else if (arr->At(id)) {AliFatal(Form("Segmenation %d already exists in file %s",id,outf));return kFALSE;}
  //
  arr->AddAtAndExpand(this,id);
  arr->SetOwner(kTRUE);
  fout->WriteObject(arr,fgkSegmListName,"kSingleKey");
  fout->Close();
  delete fout;
  arr->RemoveAt(id);
  delete arr;
  AliInfo(Form("Stored segmentation %d in %s",id,outf));
  return kTRUE;
  //
}

//______________________________________________________________________
AliITSUSegmentationPix* AliITSUSegmentationPix::LoadWithID(UInt_t id, const char* inpf)
{
  // store in the special list under given ID
  TString fns = inpf;
  gSystem->ExpandPathName(fns);
  if (fns.IsNull()) {AliFatalGeneral("LoadWithID","No file name provided"); return 0;}
  TFile* finp = TFile::Open(fns.Data());
  if (!finp) {AliFatalGeneral("LoadWithID",Form("Failed to open file %s",inpf)); return 0;}
  TObjArray* arr = (TObjArray*)finp->Get(fgkSegmListName);
  if (!arr) {
    AliFatalGeneral("LoadWithID",Form("Failed to find segmenation array %s in %s",fgkSegmListName,inpf)); 
    return 0;
  }
  AliITSUSegmentationPix* segm = dynamic_cast<AliITSUSegmentationPix*>(arr->At(id));
  if (!segm || segm->GetUniqueID()!=id) {AliFatalGeneral("LoadWithID",Form("Failed to find segmenation %d in %s",id,inpf)); return 0;}
  //
  arr->RemoveAt(id);
  arr->SetOwner(kTRUE); // to not leave in memory other segmenations
  finp->Close();
  delete finp;
  delete arr;
  //
  return segm;
}

//______________________________________________________________________
void AliITSUSegmentationPix::LoadSegmentations(TObjArray* dest, const char* inpf)
{
  // store in the special list under given ID
  if (!dest) return;
  TString fns = inpf;
  gSystem->ExpandPathName(fns);
  if (fns.IsNull()) AliFatalGeneral("LoadWithID","No file name provided");
  TFile* finp = TFile::Open(fns.Data());
  if (!finp) AliFatalGeneral("LoadWithID",Form("Failed to open file %s",inpf));
  TObjArray* arr = (TObjArray*)finp->Get(fgkSegmListName);
  if (!arr) AliFatalGeneral("LoadWithID",Form("Failed to find segmenation array %s in %s",fgkSegmListName,inpf)); 
  int nent = arr->GetEntriesFast();
  TObject *segm = 0;
  for (int i=nent;i--;) if ((segm=arr->At(i))) dest->AddAtAndExpand(segm,segm->GetUniqueID());
  AliInfoGeneral("LoadSegmentations",Form("Loaded %d segmantions from %s",arr->GetEntries(),inpf));
  arr->SetOwner(kFALSE);
  arr->Clear();
  finp->Close();
  delete finp;
  delete arr;
  //
}
Commit	Line	Data
909b16e7	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
451f5018	16	/* $Id: AliITSUSegmentationPix.cxx 47180 2011-02-08 09:42:29Z masera $ */
909b16e7	17	#include <TGeoManager.h>
	18	#include <TGeoVolume.h>
	19	#include <TGeoBBox.h>
e5373622	20	#include <TObjArray.h>
	21	#include <TString.h>
	22	#include <TSystem.h>
	23	#include <TFile.h>
451f5018	24	#include "AliITSUGeomTGeo.h"
451f5018	25	#include "AliITSUSegmentationPix.h"
a11ef2e4	26	using namespace TMath;
909b16e7	27
	28	////////////////////////////////////////////////////////////////////////////////////////////////////////////
	29	// Segmentation class for pixels //
	30	// Questions to solve: are guardrings needed and do they belong to the sensor or to the module in TGeo //
	31	// At the moment assume that the local coord syst. is located at bottom left corner //
	32	// of the ACTIVE matrix. If the guardring to be accounted in the local coords, in //
	33	// the Z and X conversions one needs to first subtract the fGuardLft and fGuardBot //
	34	// from the local Z,X coordinates //
	35	// //
	36	////////////////////////////////////////////////////////////////////////////////////////////////////////////
	37
451f5018	38	ClassImp(AliITSUSegmentationPix)
909b16e7	39
02d6eccc	40	const char* AliITSUSegmentationPix::fgkSegmListName = "ITSUSegmentations";
e5373622	41
909b16e7	42	//_____________________________________________________________________________RS
451f5018	43	AliITSUSegmentationPix::AliITSUSegmentationPix(UInt_t id, int nchips,int ncol,int nrow,
909b16e7	44	double pitchX,double pitchZ,
909b16e7	45	double thickness,
e5373622	46	double pitchLftC,double pitchRgtC,
909b16e7	47	double edgL,double edgR,double edgT,double edgB)
	48	: AliITSsegmentation()
	49	,fGuardLft(edgL)
	50	,fGuardRgt(edgR)
	51	,fGuardTop(edgT)
	52	,fGuardBot(edgB)
	53	,fPitchX(pitchX)
	54	,fPitchZ(pitchZ)
	55	,fPitchZLftCol(pitchLftC<0 ? pitchZ:pitchLftC)
	56	,fPitchZRgtCol(pitchRgtC<0 ? pitchZ:pitchRgtC)
	57	,fChipDZ(0)
	58	,fNChips(nchips)
	59	,fNColPerChip(nchips>0 ? ncol/nchips:0)
	60	,fNRow(nrow)
	61	,fNCol(ncol)
	62	{
29f5e263	63	// Default constructor, sizes in cm
451f5018	64	if (nchips) SetUniqueID( AliITSUGeomTGeo::ComposeDetTypeID(id) );
909b16e7	65	fChipDZ = (fNColPerChip-2)*fPitchZ + fPitchZLftCol + fPitchZRgtCol;
	66	SetDetSize( fNRowfPitchX /+fGuardTop+fGuardBot*/,
	67	fNChipsfChipDZ /+fGuardLft+fGuardRgt*/,
	68	thickness);
	69	//
	70	}
	71
	72	//_____________________________________________________________________________RS
451f5018	73	void AliITSUSegmentationPix::GetPadIxz(Float_t x,Float_t z,Int_t &ix,Int_t &iz) const
909b16e7	74	{
909b16e7	75	// Returns pixel coordinates (ix,iz) for given real local coordinates (x,z)
29f5e263	76	// expects x, z in cm. RS: TO CHECK: why from 1
909b16e7	77	ix = int(x/fPitchX) + 1;
	78	iz = int(Z2Col(z)) + 1;
	79	//
	80	if (iz > fNCol) iz= fNCol;
	81	if (ix > fNRow) ix= fNRow;
	82	//
	83	}
	84
	85	//_____________________________________________________________________________RS
451f5018	86	void AliITSUSegmentationPix::GetPadTxz(Float_t &x,Float_t &z) const
909b16e7	87	{
909b16e7	88	// local transformation of real local coordinates (x,z)
29f5e263	89	// expects x, z in cm
909b16e7	90	x /= fPitchX;
	91	z = Z2Col(z);
	92	//
	93	}
	94
	95	//_____________________________________________________________________________RS
451f5018	96	void AliITSUSegmentationPix::GetPadCxz(Int_t ix,Int_t iz,Float_t &x,Float_t&z) const
909b16e7	97	{
909b16e7	98	// Transform from pixel to real local coordinates
29f5e263	99	// returns x, z in cm. RS: TO CHECK if indexing starts from 1 or 0
909b16e7	100	x = (ix>0) ? Float_t((ix-0.5)fPitchX) : Float_t((ix+0.5)fPitchX);
	101	z = Col2Z(iz);
	102	//
	103	}
	104
	105	//_____________________________________________________________________________RS
451f5018	106	Float_t AliITSUSegmentationPix::Z2Col(Float_t z) const
909b16e7	107	{
909b16e7	108	// get column number (from 0) from local Z
4fa9d550	109	int chip = int(z/fChipDZ);
909b16e7	110	float col = chip*fNColPerChip;
909b16e7	111	z -= chip*fChipDZ;
4fa9d550	112	if (z>fPitchZLftCol) col += 1+(z-fPitchZLftCol)/fPitchZ;
909b16e7	113	return col;
	114	}
	115
	116	//_____________________________________________________________________________RS
451f5018	117	Float_t AliITSUSegmentationPix::Col2Z(Int_t col) const
909b16e7	118	{
	119	// convert column number (from 0) to Z coordinate
	120	int nchip = col/fNColPerChip;
	121	col %= fNColPerChip;
	122	float z = nchip*fChipDZ;
4fa9d550	123	if (col>0) {
	124	if (col<fNColPerChip-1) z += fPitchZLftCol + (col-0.5)*fPitchZ;
	125	else z += fChipDZ - fPitchZRgtCol/2;
	126	}
	127	else z += fPitchZLftCol/2;
909b16e7	128	return z;
	129	//
	130	}
	131
	132	//______________________________________________________________________RS
451f5018	133	AliITSUSegmentationPix& AliITSUSegmentationPix::operator=(const AliITSUSegmentationPix &src)
909b16e7	134	{
	135	// = operator
	136	if(this==&src) return *this;
	137	AliITSsegmentation::operator=(src);
	138	fNCol = src.fNCol;
	139	fNRow = src.fNRow;
	140	fNColPerChip = src.fNColPerChip;
	141	fNChips = src.fNChips;
	142	fChipDZ = src.fChipDZ;
	143	fPitchZRgtCol = src.fPitchZRgtCol;
	144	fPitchZLftCol = src.fPitchZLftCol;
	145	fPitchZ = src.fPitchZ;
	146	fPitchX = src.fPitchX;
	147	//
	148	fGuardBot = src.fGuardBot;
	149	fGuardTop = src.fGuardTop;
	150	fGuardRgt = src.fGuardRgt;
	151	fGuardLft = src.fGuardLft;
	152	//
	153	return *this;
	154	}
	155
	156	//____________________________________________________________________________RS
451f5018	157	AliITSUSegmentationPix::AliITSUSegmentationPix(const AliITSUSegmentationPix &src) :
909b16e7	158	AliITSsegmentation(src)
	159	,fGuardLft(src.fGuardLft)
	160	,fGuardRgt(src.fGuardRgt)
	161	,fGuardTop(src.fGuardTop)
	162	,fGuardBot(src.fGuardBot)
	163	,fPitchX(src.fPitchX)
	164	,fPitchZ(src.fPitchZ)
	165	,fPitchZLftCol(src.fPitchZLftCol)
	166	,fPitchZRgtCol(src.fPitchZRgtCol)
	167	,fChipDZ(src.fChipDZ)
	168	,fNChips(src.fNChips)
	169	,fNColPerChip(src.fNColPerChip)
	170	,fNRow(src.fNRow)
	171	,fNCol(src.fNCol)
	172	{
	173	}
	174
	175	//____________________________________________________________________________RS
451f5018	176	Float_t AliITSUSegmentationPix::Dpx(Int_t ) const
909b16e7	177	{
	178	//returs x pixel pitch for a give pixel
	179	return fPitchX;
	180	}
	181
	182	//____________________________________________________________________________RS
451f5018	183	Float_t AliITSUSegmentationPix::Dpz(Int_t col) const
909b16e7	184	{
	185	// returns z pixel pitch for a given pixel (cols starts from 0)
	186	col %= fNColPerChip;
	187	if (!col) return fPitchZLftCol;
	188	if (col==fNColPerChip-1) return fPitchZRgtCol;
	189	return fPitchZ;
	190	//
	191	}
	192
	193	//------------------------------
451f5018	194	void AliITSUSegmentationPix::Neighbours(Int_t iX, Int_t iZ, Int_t* nlist, Int_t xlist[8], Int_t zlist[8]) const
909b16e7	195	{
	196	// returns the neighbouring pixels for use in Cluster Finders and the like.
	197	//
	198	*nlist=8;
	199	xlist[0]=xlist[1]=iX;
	200	xlist[2]=iX-1;
	201	xlist[3]=iX+1;
	202	zlist[0]=iZ-1;
	203	zlist[1]=iZ+1;
	204	zlist[2]=zlist[3]=iZ;
	205	// Diagonal elements
	206	xlist[4]=iX+1;
	207	zlist[4]=iZ+1;
	208	//
	209	xlist[5]=iX-1;
	210	zlist[5]=iZ-1;
	211	//
	212	xlist[6]=iX-1;
	213	zlist[6]=iZ+1;
	214	//
	215	xlist[7]=iX+1;
	216	zlist[7]=iZ-1;
	217	//
	218	}
	219
	220	//______________________________________________________________________
451f5018	221	Bool_t AliITSUSegmentationPix::LocalToDet(Float_t x,Float_t z,Int_t &ix,Int_t &iz) const
909b16e7	222	{
	223	// Transformation from Geant detector centered local coordinates (cm) to
	224	// Pixel cell numbers ix and iz.
	225	// Input:
	226	// Float_t x detector local coordinate x in cm with respect to
	227	// the center of the sensitive volume.
	228	// Float_t z detector local coordinate z in cm with respect to
	229	// the center of the sensitive volulme.
	230	// Output:
	231	// Int_t ix detector x cell coordinate. Has the range
	232	// 0<=ix<fNRow.
	233	// Int_t iz detector z cell coordinate. Has the range
	234	// 0<=iz<fNCol.
	235	// Return:
	236	// kTRUE if point x,z is inside sensitive volume, kFALSE otherwise.
	237	// A value of -1 for ix or iz indecates that this point is outside of the
	238	// detector segmentation as defined.
29f5e263	239	x += 0.5*Dx();
29f5e263	240	z += 0.5*Dz();
909b16e7	241	ix = iz = -1;
	242	if(x<0 \|\| x>Dx()) return kFALSE; // outside x range.
	243	if(z<0 \|\| z>Dz()) return kFALSE; // outside z range.
	244	ix = int(x/fPitchX);
	245	iz = Z2Col(z);
	246	return kTRUE; // Found ix and iz, return.
	247	}
	248
	249	//______________________________________________________________________
451f5018	250	void AliITSUSegmentationPix::DetToLocal(Int_t ix,Int_t iz,Float_t &x,Float_t &z) const
909b16e7	251	{
	252	// Transformation from Detector cell coordiantes to Geant detector centerd
	253	// local coordinates (cm).
	254	// Input:
	255	// Int_t ix detector x cell coordinate. Has the range 0<=ix<fNRow.
	256	// Int_t iz detector z cell coordinate. Has the range 0<=iz<fNCol.
	257	// Output:
	258	// Float_t x detector local coordinate x in cm with respect to the
	259	// center of the sensitive volume.
	260	// Float_t z detector local coordinate z in cm with respect to the
	261	// center of the sensitive volulme.
	262	// If ix and or iz is outside of the segmentation range a value of -0.5*Dx()
	263	// or -0.5*Dz() is returned.
	264	//
29f5e263	265	x = -0.5*Dx(); // default value.
29f5e263	266	z = -0.5*Dz(); // default value.
909b16e7	267	// RS: to check: why we don't do strict check for [0:n)
4fa9d550	268	if(ix<0 \|\| ix>fNRow) return; // outside of detector
4fa9d550	269	if(iz<0 \|\| iz>fNCol) return; // outside of detctor
29f5e263	270	x += (ix+0.5)*fPitchX; // RS: we go to the center of the pad, i.e. + pitch/2, not to the boundary as in SPD
29f5e263	271	z += Col2Z(iz);
909b16e7	272	return; // Found x and z, return.
	273	}
	274
	275	//______________________________________________________________________
451f5018	276	void AliITSUSegmentationPix::CellBoundries(Int_t ix,Int_t iz,Double_t &xl,Double_t &xu,Double_t &zl,Double_t &zu) const
909b16e7	277	{
	278	// Transformation from Detector cell coordiantes to Geant detector centerd
	279	// local coordinates (cm).
	280	// Input:
	281	// Int_t ix detector x cell coordinate. Has the range 0<=ix<fNRow.
	282	// Int_t iz detector z cell coordinate. Has the range 0<=iz<fNCol.
	283	// Output:
	284	// Double_t xl detector local coordinate cell lower bounds x in cm
	285	// with respect to the center of the sensitive volume.
	286	// Double_t xu detector local coordinate cell upper bounds x in cm
	287	// with respect to the center of the sensitive volume.
	288	// Double_t zl detector local coordinate lower bounds z in cm with
	289	// respect to the center of the sensitive volulme.
	290	// Double_t zu detector local coordinate upper bounds z in cm with
	291	// respect to the center of the sensitive volulme.
	292	// If ix and or iz is outside of the segmentation range a value of -0.5*Dx()
	293	// and -0.5Dx() or -0.5Dz() and -0.5*Dz() are returned.
	294	Float_t x,z;
	295	DetToLocal(ix,iz,x,z);
	296	//
	297	if( ix<0 \|\| ix>=fNRow \|\| iz<0 \|\| iz>=fNCol) {
29f5e263	298	xl = xu = -0.5*Dx(); // default value.
29f5e263	299	zl = zu = -0.5*Dz(); // default value.
909b16e7	300	return; // outside of detctor
909b16e7	301	}
29f5e263	302	float zpitchH = Dpz(iz)*0.5;
29f5e263	303	float xpitchH = fPitchX*0.5;
909b16e7	304	xl -= xpitchH;
	305	xu += xpitchH;
	306	zl -= zpitchH;
	307	zu += zpitchH;
	308	return; // Found x and z, return.
	309	}
	310
	311	//______________________________________________________________________
451f5018	312	Int_t AliITSUSegmentationPix::GetChipFromChannel(Int_t, Int_t iz) const
909b16e7	313	{
	314	// returns chip number (in range 0-4) starting from channel number
	315	if(iz>=fNCol \|\| iz<0 ){
	316	AliWarning("Bad cell number");
	317	return -1;
	318	}
	319	return iz/fNColPerChip;
	320	}
	321
	322	//______________________________________________________________________
451f5018	323	Int_t AliITSUSegmentationPix::GetChipFromLocal(Float_t, Float_t zloc) const
909b16e7	324	{
	325	// returns chip number (in range 0-4) starting from local coordinates
	326	Int_t ix0,iz;
	327	if (!LocalToDet(0,zloc,ix0,iz)) {
	328	AliWarning("Bad local coordinate");
	329	return -1;
	330	}
	331	return GetChipFromChannel(ix0,iz);
	332	}
	333
	334	//______________________________________________________________________
451f5018	335	Int_t AliITSUSegmentationPix::GetChipsInLocalWindow(Int_t* array, Float_t zmin, Float_t zmax, Float_t, Float_t) const
909b16e7	336	{
	337	// returns the number of chips containing a road defined by given local coordinate limits
	338	//
909b16e7	339	if (zmin>zmax) {
	340	AliWarning("Bad coordinate limits: zmin>zmax!");
	341	return -1;
	342	}
	343	//
	344	Int_t nChipInW = 0;
	345	//
29f5e263	346	Float_t zminDet = -0.5*Dz();
29f5e263	347	Float_t zmaxDet = 0.5*Dz();
909b16e7	348	if(zmin<zminDet) zmin=zminDet;
	349	if(zmax>zmaxDet) zmax=zmaxDet;
	350
	351	Int_t n1 = GetChipFromLocal(0,zmin);
	352	array[nChipInW] = n1;
	353	nChipInW++;
	354
	355	Int_t n2 = GetChipFromLocal(0,zmax);
	356
	357	if(n2!=n1){
a11ef2e4	358	Int_t imin=Min(n1,n2);
a11ef2e4	359	Int_t imax=Max(n1,n2);
909b16e7	360	for(Int_t ichip=imin; ichip<=imax; ichip++){
	361	if(ichip==n1) continue;
	362	array[nChipInW]=ichip;
	363	nChipInW++;
	364	}
	365	}
	366	//
	367	return nChipInW;
	368	}
a84c4b15	369
a84c4b15	370	//______________________________________________________________________
451f5018	371	void AliITSUSegmentationPix::Init()
a84c4b15	372	{
	373	// init settings
	374	}
e5373622	375
e5373622	376	//______________________________________________________________________
451f5018	377	Bool_t AliITSUSegmentationPix::Store(const char* outf)
e5373622	378	{
	379	// store in the special list under given ID
	380	TString fns = outf;
	381	gSystem->ExpandPathName(fns);
	382	if (fns.IsNull()) {AliFatal("No file name provided"); return kFALSE;}
	383	TFile* fout = TFile::Open(fns.Data(),"update");
	384	if (!fout) {AliFatal(Form("Failed to open output file %s",outf)); return kFALSE;}
	385	TObjArray* arr = (TObjArray*)fout->Get(fgkSegmListName);
451f5018	386	int id = GetUniqueID();
e5373622	387	if (!arr) arr = new TObjArray();
451f5018	388	else if (arr->At(id)) {AliFatal(Form("Segmenation %d already exists in file %s",id,outf));return kFALSE;}
e5373622	389	//
451f5018	390	arr->AddAtAndExpand(this,id);
e5373622	391	arr->SetOwner(kTRUE);
	392	fout->WriteObject(arr,fgkSegmListName,"kSingleKey");
	393	fout->Close();
	394	delete fout;
451f5018	395	arr->RemoveAt(id);
e5373622	396	delete arr;
	397	AliInfo(Form("Stored segmentation %d in %s",id,outf));
	398	return kTRUE;
	399	//
	400	}
	401
	402	//______________________________________________________________________
451f5018	403	AliITSUSegmentationPix* AliITSUSegmentationPix::LoadWithID(UInt_t id, const char* inpf)
e5373622	404	{
	405	// store in the special list under given ID
	406	TString fns = inpf;
	407	gSystem->ExpandPathName(fns);
	408	if (fns.IsNull()) {AliFatalGeneral("LoadWithID","No file name provided"); return 0;}
	409	TFile* finp = TFile::Open(fns.Data());
	410	if (!finp) {AliFatalGeneral("LoadWithID",Form("Failed to open file %s",inpf)); return 0;}
	411	TObjArray* arr = (TObjArray*)finp->Get(fgkSegmListName);
	412	if (!arr) {
	413	AliFatalGeneral("LoadWithID",Form("Failed to find segmenation array %s in %s",fgkSegmListName,inpf));
	414	return 0;
	415	}
451f5018	416	AliITSUSegmentationPix* segm = dynamic_cast<AliITSUSegmentationPix*>(arr->At(id));
451f5018	417	if (!segm \|\| segm->GetUniqueID()!=id) {AliFatalGeneral("LoadWithID",Form("Failed to find segmenation %d in %s",id,inpf)); return 0;}
e5373622	418	//
451f5018	419	arr->RemoveAt(id);
e5373622	420	arr->SetOwner(kTRUE); // to not leave in memory other segmenations
	421	finp->Close();
	422	delete finp;
	423	delete arr;
	424	//
	425	return segm;
	426	}
451f5018	427
	428	//______________________________________________________________________
	429	void AliITSUSegmentationPix::LoadSegmentations(TObjArray* dest, const char* inpf)
	430	{
	431	// store in the special list under given ID
	432	if (!dest) return;
	433	TString fns = inpf;
	434	gSystem->ExpandPathName(fns);
	435	if (fns.IsNull()) AliFatalGeneral("LoadWithID","No file name provided");
	436	TFile* finp = TFile::Open(fns.Data());
	437	if (!finp) AliFatalGeneral("LoadWithID",Form("Failed to open file %s",inpf));
	438	TObjArray* arr = (TObjArray*)finp->Get(fgkSegmListName);
	439	if (!arr) AliFatalGeneral("LoadWithID",Form("Failed to find segmenation array %s in %s",fgkSegmListName,inpf));
	440	int nent = arr->GetEntriesFast();
	441	TObject *segm = 0;
	442	for (int i=nent;i--;) if ((segm=arr->At(i))) dest->AddAtAndExpand(segm,segm->GetUniqueID());
	443	AliInfoGeneral("LoadSegmentations",Form("Loaded %d segmantions from %s",arr->GetEntries(),inpf));
	444	arr->SetOwner(kFALSE);
02d6eccc	445	arr->Clear();
451f5018	446	finp->Close();
	447	delete finp;
	448	delete arr;
	449	//
	450	}