[u/mrichter/AliRoot.git] / MUON / AliMUONSt345SlatSegmentation.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$ */

//*********************************************************
//  Segmentation classes for slat modules          
//  This class works with local coordinates
//  of the slats via the class AliMUONGeometrySegmentation
//  This class contains the size of the slats and the
//  and the differents PCB densities. 
//  (from old AliMUONSegmentationSlatModule)
//  Gines, Subatech, Nov04
//*********************************************************

#include <TArrayI.h>
#include <TArrayF.h>
#include "AliMUONSt345SlatSegmentation.h"
#include "AliLog.h"

//___________________________________________
ClassImp(AliMUONSt345SlatSegmentation)


AliMUONSt345SlatSegmentation::AliMUONSt345SlatSegmentation() 
  : AliSegmentation(),
    fId(0),
    fDpx(0),
    fDpy(0),
    fNpx(999999),
    fNpy(999999),
    fWireD(0.25),
    fXhit(0.),
    fYhit(0.),
    fIx(0),
    fIy(0),
    fX(0.),
    fY(0.),
    fIxmin(0),
    fIxmax(0),
    fIymin(0),
    fIymax(0)
{
// Non default constructor
  fNsec = 4;  // 4 sector densities at most per slat 
  fNDiv = new TArrayI(fNsec);      
  fDpxD = new TArrayF(fNsec);      
  (*fNDiv)[0]=(*fNDiv)[1]=(*fNDiv)[2]=(*fNDiv)[3]=0;     
  (*fDpxD)[0]=(*fDpxD)[1]=(*fDpxD)[2]=(*fDpxD)[3]=0;       
}
//----------------------------------------------------------------------
AliMUONSt345SlatSegmentation::AliMUONSt345SlatSegmentation(const AliMUONSt345SlatSegmentation& rhs) : AliSegmentation(rhs)
{
  AliFatal("Not implemented.");
}
//----------------------------------------------------------------------
AliMUONSt345SlatSegmentation::~AliMUONSt345SlatSegmentation() 
{
// Destructor
    if (fNDiv) delete fNDiv;
    if (fDpxD) delete fDpxD;
}
//----------------------------------------------------------------------
AliMUONSt345SlatSegmentation& AliMUONSt345SlatSegmentation::operator=(const AliMUONSt345SlatSegmentation& rhs)
{
// Protected assignement operator
  if (this == &rhs) return *this;
  AliFatal("Not implemented.");
  return *this;  
}


//------------------------------------------------------------------------
Float_t AliMUONSt345SlatSegmentation::Distance2AndOffset(Int_t iX, Int_t iY, Float_t X, Float_t Y, Int_t * /*dummy*/)
{
// Returns the square of the distance between 1 pad
// labelled by its Channel numbers and a coordinate
  Float_t x,y;
  GetPadC(iX,iY,x,y);
  return (x-X)*(x-X) + (y-Y)*(y-Y);
}
//____________________________________________________________________________
Float_t AliMUONSt345SlatSegmentation::Dpx(Int_t isec) const
{
// Return x-strip width
    return (*fDpxD)[isec];
} 

//____________________________________________________________________________
Float_t AliMUONSt345SlatSegmentation::Dpy(Int_t /*isec*/) const
{
  // Return y-strip width
  return fDpy;
}
//_____________________________________________________________________________
Float_t AliMUONSt345SlatSegmentation::GetAnod(Float_t xhit) const
{
// Returns for a hit position xhit the position of the nearest anode wire    
    Float_t wire= (xhit>0)? Int_t(xhit/fWireD)+0.5:Int_t(xhit/fWireD)-0.5;
    return fWireD*wire;
}
//_____________________________________________________________________________
void AliMUONSt345SlatSegmentation::GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy) 
{
//  Returns pad coordinates (ix,iy) for given real coordinates (x,y)
  iy = Int_t((y+fCy)/fDpy)+1; // !!!
    if (iy >  fNpy) iy= fNpy;

//  Find sector isec    
    Int_t isec=-1;
    for (Int_t i=fNsec-1; i > 0; i--) {
	if (x >= fCx[i-1]) {
	    isec=i;
	    if (fCx[isec] == fCx[isec-1]  && isec > 1) isec--;
	    break;
	}
    }

    if (isec>0) {
	ix= Int_t((x-fCx[isec-1])/(*fDpxD)[isec])
	    +fNpxS[isec-1]+1;
    } else if (isec == 0) {
	ix= Int_t(x/(*fDpxD)[isec])+1;
    } else {
	ix=0;
	iy=0;
    }
}
//--------------------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y) 
{
  if (ix<1 || ix>Npx() || iy<1 || iy>Npy() ){
    AliWarning(Form("ix or iy out of boundaries: Npx=%d and Npy=%d",Npx(),Npy()));
    x=-99999.; y=-99999.;
  }
  else { 
    //  Returns real coordinates (x,y) for given pad coordinates (ix,iy)
    y = Float_t(iy*fDpy)-fDpy/2.- fCy;  // !!!  
    //  Find sector isec
    Int_t isec = Sector(ix,iy);
    if (isec == -1) printf("\n PadC %d %d %d  %d \n ", isec, fId, ix, iy);
    if (isec>0) {
      x = fCx[isec-1]+(ix-fNpxS[isec-1])*(*fDpxD)[isec];
      x = x-(*fDpxD)[isec]/2;
    } else {
      x=y=0;
    }
  }
}
//-------------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::GetPadI(Float_t x, Float_t y , Float_t /*z*/, Int_t &ix, Int_t &iy)
{
  GetPadI(x, y, ix, iy);
}
//_______________________________________________________________
void AliMUONSt345SlatSegmentation::SetPadDivision(Int_t ndiv[4])
{
// Defines the pad size perp. to the anode wire (y) for different sectors. 
// Pad sizes are defined as integral fractions ndiv of a basis pad size
// fDpx
// 
    for (Int_t i=0; i<4; i++) {
	(*fNDiv)[i]=ndiv[i];
    }
    ndiv[0]=ndiv[1];
}
//____________________________________________________________________________
void AliMUONSt345SlatSegmentation::SetPadSize(Float_t p1, Float_t p2)
{
//  Sets the padsize 
    fDpx=p1;
    fDpy=p2;
}
//_______________________________________________________________          
void AliMUONSt345SlatSegmentation::SetPcbBoards(Int_t n[4])
{
//
// Set PcbBoard segmentation zones for each density
// n[0] PcbBoards for maximum density sector fNDiv[0]
// n[1] PcbBoards for next density sector fNDiv[1] etc ...
    for (Int_t i=0; i<4; i++) fPcbBoards[i]=n[i];
}
//-------------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::SetPad(Int_t ix, Int_t iy)
{
    //
    // Sets virtual pad coordinates, needed for evaluating pad response 
    // outside the tracking program 
    GetPadC(ix,iy,fX,fY);
    fSector=Sector(ix,iy);
}
//---------------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::SetHit(Float_t x, Float_t y)
{
// Set current hit 
//
    fXhit = x;
    fYhit = y;
    
    if (x < 0) fXhit = 0;
    if (y < 0) fYhit = 0;
    
    if (x >= fCx[fNsec-1]) fXhit = fCx[fNsec-1];
    if (y >= fDyPCB)       fYhit = fDyPCB;
    
}
//----------------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/)
{
  SetHit(xhit, yhit);
}
//----------------------------------------------------------
void AliMUONSt345SlatSegmentation::FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy)
{
// Initialises iteration over pads for charge distribution algorithm
//
    //
    // Find the wire position (center of charge distribution)
    Float_t x0a=GetAnod(xhit);
    fXhit=x0a;
    fYhit=yhit;
    //
    // and take fNsigma*sigma around this center
    Float_t x01=x0a  - dx;
    Float_t x02=x0a  + dx;
    Float_t y01=yhit - dy;
    Float_t y02=yhit + dy;
    if (x01 < 0) x01 = 0;
    if (y01 < 0) y01 = 0;

    if (x02 >= fCx[fNsec-1]) x02 = fCx[fNsec-1];

   
    Int_t isec=-1;
    for (Int_t i=fNsec-1; i > 0; i--) {
	if (x02 >= fCx[i-1]) {
	    isec=i;
	    if (fCx[isec] == fCx[isec-1] && isec > 1) isec--;
	    break;
	}
    }
    y02 += Dpy(isec);
    if (y02 >= fDyPCB) y02 = fDyPCB;
   
    //
    // find the pads over which the charge distributes
    GetPadI(x01,y01,fIxmin,fIymin);
    GetPadI(x02,y02,fIxmax,fIymax);
    
    if (fIxmax > fNpx) fIxmax=fNpx;
    if (fIymax > fNpyS[isec]) fIymax = fNpyS[isec];    

    fXmin=x01;
    fXmax=x02;    
    fYmin=y01;
    fYmax=y02;    
  
    // 
    // Set current pad to lower left corner
    if (fIxmax < fIxmin) fIxmax=fIxmin;
    if (fIymax < fIymin) fIymax=fIymin;    
    fIx=fIxmin;
    fIy=fIymin;
    
    GetPadC(fIx,fIy,fX,fY);
    fSector=Sector(fIx,fIy);
/*
    printf("\n \n First Pad: %d %d %f %f %d %d %d %f" , 
	   fIxmin, fIxmax, fXmin, fXmax, fNpx, fId, isec, Dpy(isec));    
    printf("\n \n First Pad: %d %d %f %f %d %d %d %f",
	   fIymin, fIymax, fYmin, fYmax,  fNpyS[isec], fId, isec, Dpy(isec));
*/
}
//----------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::FirstPad(Float_t xhit, Float_t yhit, Float_t /*zhit*/, Float_t dx, Float_t dy)
{
  FirstPad(xhit, yhit, dx, dy);
}
//----------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::NextPad()
{
// Stepper for the iteration over pads
//
// Step to next pad in the integration region
//  step from left to right    
    if (fIx != fIxmax) {
	fIx++;
	GetPadC(fIx,fIy,fX,fY);
	fSector=Sector(fIx,fIy);
//  step up 
    } else if (fIy != fIymax) {
	fIx=fIxmin;
	fIy++;
	GetPadC(fIx,fIy,fX,fY);
	fSector=Sector(fIx,fIy);

    } else {
	fIx=-1;
	fIy=-1;
    }
//    printf("\n Next Pad %d %d %f %f %d %d %d %d %d ", 
}
//-------------------------------------------------------------------------
Int_t AliMUONSt345SlatSegmentation::MorePads()
{
// Stopping condition for the iterator over pads
//
// Are there more pads in the integration region
    
    return  (fIx != -1  || fIy != -1);
}
//--------------------------------------------------------------------------
Int_t AliMUONSt345SlatSegmentation::Sector(Int_t ix, Int_t iy) 
{
//
// Determine segmentation zone from pad coordinates
//
    Int_t isec=-1;
    for (Int_t i=0; i < fNsec; i++) {
	if (ix <= fNpxS[i]) {
	    isec=i;
	    break;
	}
    }
    if (isec == -1) printf("\n Sector: Attention isec ! %d %d %d %d \n",
			   fId, ix, iy,fNpxS[3]);

    return isec;

}
//-----------------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::
IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2) 
{
//  Returns integration limits for current pad
//
    x1=fXhit-fX-Dpx(fSector)/2.;
    x2=x1+Dpx(fSector);
    y1=fYhit-fY-Dpy(fSector)/2.;
    y2=y1+Dpy(fSector);    
//    printf("\n Integration Limits %f %f %f %f %d %f", x1, x2, y1, y2, fSector, Dpx(fSector));

}
//-----------------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::
Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10]) 
{
// Returns list of next neighbours for given Pad (iX, iY)
    Int_t i=0;
//  step right
    if (iX+1 <= fNpx) {
	Xlist[i]=iX+1;
	Ylist[i++]=iY;
    }
//  step left    
    if (iX-1 > 0) {
	Xlist[i]=iX-1;
	Ylist[i++]=iY;
    } 
//  step up
    if (iY+1 <= fNpy) {
	Xlist[i]=iX;
	Ylist[i++]=iY+1;
    }
//  step down    
    if (iY-1 > 0) {
	Xlist[i]=iX;
	Ylist[i++]=iY-1;
    }
    *Nlist=i;
}
//--------------------------------------------------------------------------
void AliMUONSt345SlatSegmentation::Init(Int_t detectionElementId)
{
//
//  Fill the arrays fCx (x-contour) and fNpxS (ix-contour) for each sector
//  These arrays help in converting from real to pad co-ordinates and
//  vice versa
//   
//  Segmentation is defined by rectangular modules approximating
//  concentric circles as shown below
//
//  PCB module size in cm
//  printf("\n Initialise Segmentation SlatModule \n");

    fDxPCB=40;
    fDyPCB=40;
//
// number of pad rows per PCB
//    
    Int_t nPyPCB=Int_t(fDyPCB/fDpy);
//
// maximum number of pad rows    
    fNpy=nPyPCB;
//
//  Calculate padsize along x
    (*fDpxD)[fNsec-1]=fDpx;
    if (fNsec > 1) {
      for (Int_t i=fNsec-1; i>=0; i--){ // fNsec-2
	(*fDpxD)[i]=(*fDpxD)[fNsec-1]/(*fNDiv)[i];
      }
    }
//
// fill the arrays defining the pad segmentation boundaries
//
//  
//  Loop over sectors (isec=0 for secto close to the bema pipe)
    Float_t totalLength = 0;
    for (Int_t isec=0; isec<4; isec++) totalLength += fPcbBoards[isec]*fDxPCB;  // !!!!

    for (Int_t isec=0; isec<4; isec++) {
	if (isec==0) {
	    fNpxS[0] = 0;
	    fNpyS[0] = 0;
	    fCx[0]   = -totalLength/2;
	} else {
	    fNpxS[isec]=fNpxS[isec-1] + fPcbBoards[isec]*Int_t(fDxPCB/(*fDpxD)[isec]);
	    fNpyS[isec]=fNpy;
	    fCx[isec]= fCx[isec-1] + fPcbBoards[isec]*fDxPCB;
	}
    } // sectors
// maximum number of pad rows    
    fNpy=nPyPCB;
    fNpx=fNpxS[3];
    fCy = fDyPCB/2.;
//
    fId = detectionElementId;
}
Commit	Line	Data
cc4dcfb0	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
	16	/* $Id$ */
	17
	18	//*********************************************************
	19	// Segmentation classes for slat modules
	20	// This class works with local coordinates
	21	// of the slats via the class AliMUONGeometrySegmentation
	22	// This class contains the size of the slats and the
	23	// and the differents PCB densities.
	24	// (from old AliMUONSegmentationSlatModule)
	25	// Gines, Subatech, Nov04
	26	//*********************************************************
	27
	28	#include <TArrayI.h>
	29	#include <TArrayF.h>
	30	#include "AliMUONSt345SlatSegmentation.h"
	31	#include "AliLog.h"
	32
	33	//___________________________________________
	34	ClassImp(AliMUONSt345SlatSegmentation)
	35
	36
	37	AliMUONSt345SlatSegmentation::AliMUONSt345SlatSegmentation()
	38	: AliSegmentation(),
	39	fId(0),
	40	fDpx(0),
	41	fDpy(0),
	42	fNpx(999999),
	43	fNpy(999999),
	44	fWireD(0.25),
	45	fXhit(0.),
	46	fYhit(0.),
	47	fIx(0),
	48	fIy(0),
	49	fX(0.),
	50	fY(0.),
	51	fIxmin(0),
	52	fIxmax(0),
	53	fIymin(0),
	54	fIymax(0)
	55	{
	56	// Non default constructor
	57	fNsec = 4; // 4 sector densities at most per slat
	58	fNDiv = new TArrayI(fNsec);
	59	fDpxD = new TArrayF(fNsec);
	60	(fNDiv)[0]=(fNDiv)[1]=(fNDiv)[2]=(fNDiv)[3]=0;
	61	(fDpxD)[0]=(fDpxD)[1]=(fDpxD)[2]=(fDpxD)[3]=0;
	62	}
	63	//----------------------------------------------------------------------
	64	AliMUONSt345SlatSegmentation::AliMUONSt345SlatSegmentation(const AliMUONSt345SlatSegmentation& rhs) : AliSegmentation(rhs)
65	{
66	AliFatal("Not implemented.");
67	}
68	//----------------------------------------------------------------------
69	AliMUONSt345SlatSegmentation::~AliMUONSt345SlatSegmentation()
70	{
71	// Destructor
72	if (fNDiv) delete fNDiv;
73	if (fDpxD) delete fDpxD;
74	}
75	//----------------------------------------------------------------------
76	AliMUONSt345SlatSegmentation& AliMUONSt345SlatSegmentation::operator=(const AliMUONSt345SlatSegmentation& rhs)
77	{
78	// Protected assignement operator
79	if (this == &rhs) return *this;
80	AliFatal("Not implemented.");
81	return *this;
82	}
83
84
85	//------------------------------------------------------------------------
86	Float_t AliMUONSt345SlatSegmentation::Distance2AndOffset(Int_t iX, Int_t iY, Float_t X, Float_t Y, Int_t * /dummy/)
87	{
88	// Returns the square of the distance between 1 pad
89	// labelled by its Channel numbers and a coordinate
90	Float_t x,y;
91	GetPadC(iX,iY,x,y);
92	return (x-X)(x-X) + (y-Y)(y-Y);
93	}
94	//____________________________________________________________________________
95	Float_t AliMUONSt345SlatSegmentation::Dpx(Int_t isec) const
96	{
97	// Return x-strip width
98	return (*fDpxD)[isec];
99	}
100
101	//____________________________________________________________________________
102	Float_t AliMUONSt345SlatSegmentation::Dpy(Int_t /isec/) const
103	{
104	// Return y-strip width
105	return fDpy;
106	}
107	//_____________________________________________________________________________
108	Float_t AliMUONSt345SlatSegmentation::GetAnod(Float_t xhit) const
109	{
110	// Returns for a hit position xhit the position of the nearest anode wire
111	Float_t wire= (xhit>0)? Int_t(xhit/fWireD)+0.5:Int_t(xhit/fWireD)-0.5;
112	return fWireD*wire;
113	}
114	//_____________________________________________________________________________
115	void AliMUONSt345SlatSegmentation::GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
116	{
117	// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
118	iy = Int_t((y+fCy)/fDpy)+1; // !!!
119	if (iy > fNpy) iy= fNpy;
120
121	// Find sector isec
122	Int_t isec=-1;
123	for (Int_t i=fNsec-1; i > 0; i--) {
124	if (x >= fCx[i-1]) {
125	isec=i;
126	if (fCx[isec] == fCx[isec-1] && isec > 1) isec--;
127	break;
128	}
129	}
130
131	if (isec>0) {
132	ix= Int_t((x-fCx[isec-1])/(*fDpxD)[isec])
133	+fNpxS[isec-1]+1;
134	} else if (isec == 0) {
135	ix= Int_t(x/(*fDpxD)[isec])+1;
136	} else {
137	ix=0;
138	iy=0;
139	}
140	}
141	//--------------------------------------------------------------------------------
142	void AliMUONSt345SlatSegmentation::GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
143	{
144	if (ix<1 \|\| ix>Npx() \|\| iy<1 \|\| iy>Npy() ){
145	AliWarning(Form("ix or iy out of boundaries: Npx=%d and Npy=%d",Npx(),Npy()));
146	x=-99999.; y=-99999.;
147	}
148	else {
149	// Returns real coordinates (x,y) for given pad coordinates (ix,iy)
150	y = Float_t(iy*fDpy)-fDpy/2.- fCy; // !!!
151	// Find sector isec
152	Int_t isec = Sector(ix,iy);
153	if (isec == -1) printf("\n PadC %d %d %d %d \n ", isec, fId, ix, iy);
154	if (isec>0) {
155	x = fCx[isec-1]+(ix-fNpxS[isec-1])(fDpxD)[isec];
156	x = x-(*fDpxD)[isec]/2;
157	} else {
158	x=y=0;
159	}
160	}
161	}
162	//-------------------------------------------------------------------------
163	void AliMUONSt345SlatSegmentation::GetPadI(Float_t x, Float_t y , Float_t /z/, Int_t &ix, Int_t &iy)
164	{
165	GetPadI(x, y, ix, iy);
166	}
167	//_______________________________________________________________
168	void AliMUONSt345SlatSegmentation::SetPadDivision(Int_t ndiv[4])
169	{
170	// Defines the pad size perp. to the anode wire (y) for different sectors.
171	// Pad sizes are defined as integral fractions ndiv of a basis pad size
172	// fDpx
173	//
174	for (Int_t i=0; i<4; i++) {
175	(*fNDiv)[i]=ndiv[i];
176	}
177	ndiv[0]=ndiv[1];
178	}
179	//____________________________________________________________________________
180	void AliMUONSt345SlatSegmentation::SetPadSize(Float_t p1, Float_t p2)
181	{
182	// Sets the padsize
183	fDpx=p1;
184	fDpy=p2;
185	}
186	//_______________________________________________________________
187	void AliMUONSt345SlatSegmentation::SetPcbBoards(Int_t n[4])
188	{
189	//
190	// Set PcbBoard segmentation zones for each density
191	// n[0] PcbBoards for maximum density sector fNDiv[0]
192	// n[1] PcbBoards for next density sector fNDiv[1] etc ...
193	for (Int_t i=0; i<4; i++) fPcbBoards[i]=n[i];
194	}
195	//-------------------------------------------------------------------------
196	void AliMUONSt345SlatSegmentation::SetPad(Int_t ix, Int_t iy)
197	{
198	//
199	// Sets virtual pad coordinates, needed for evaluating pad response
200	// outside the tracking program
201	GetPadC(ix,iy,fX,fY);
202	fSector=Sector(ix,iy);
203	}
204	//---------------------------------------------------------------------------
205	void AliMUONSt345SlatSegmentation::SetHit(Float_t x, Float_t y)
206	{
207	// Set current hit
208	//
209	fXhit = x;
210	fYhit = y;
211
212	if (x < 0) fXhit = 0;
213	if (y < 0) fYhit = 0;
214
215	if (x >= fCx[fNsec-1]) fXhit = fCx[fNsec-1];
216	if (y >= fDyPCB) fYhit = fDyPCB;
217
218	}
219	//----------------------------------------------------------------------------
220	void AliMUONSt345SlatSegmentation::SetHit(Float_t xhit, Float_t yhit, Float_t /zhit/)
221	{
222	SetHit(xhit, yhit);
223	}
224	//----------------------------------------------------------
225	void AliMUONSt345SlatSegmentation::FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy)
226	{
227	// Initialises iteration over pads for charge distribution algorithm
228	//
229	//
230	// Find the wire position (center of charge distribution)
231	Float_t x0a=GetAnod(xhit);
232	fXhit=x0a;
233	fYhit=yhit;
234	//
235	// and take fNsigma*sigma around this center
236	Float_t x01=x0a - dx;
237	Float_t x02=x0a + dx;
238	Float_t y01=yhit - dy;
239	Float_t y02=yhit + dy;
240	if (x01 < 0) x01 = 0;
241	if (y01 < 0) y01 = 0;
242
243	if (x02 >= fCx[fNsec-1]) x02 = fCx[fNsec-1];
244
245
246	Int_t isec=-1;
247	for (Int_t i=fNsec-1; i > 0; i--) {
248	if (x02 >= fCx[i-1]) {
249	isec=i;
250	if (fCx[isec] == fCx[isec-1] && isec > 1) isec--;
251	break;
252	}
253	}
254	y02 += Dpy(isec);
255	if (y02 >= fDyPCB) y02 = fDyPCB;
256
257	//
258	// find the pads over which the charge distributes
259	GetPadI(x01,y01,fIxmin,fIymin);
260	GetPadI(x02,y02,fIxmax,fIymax);
261
262	if (fIxmax > fNpx) fIxmax=fNpx;
263	if (fIymax > fNpyS[isec]) fIymax = fNpyS[isec];
264
265	fXmin=x01;
266	fXmax=x02;
267	fYmin=y01;
268	fYmax=y02;
269
270	//
271	// Set current pad to lower left corner
272	if (fIxmax < fIxmin) fIxmax=fIxmin;
273	if (fIymax < fIymin) fIymax=fIymin;
274	fIx=fIxmin;
275	fIy=fIymin;
276
277	GetPadC(fIx,fIy,fX,fY);
278	fSector=Sector(fIx,fIy);
279	/*
280	printf("\n \n First Pad: %d %d %f %f %d %d %d %f" ,
281	fIxmin, fIxmax, fXmin, fXmax, fNpx, fId, isec, Dpy(isec));
282	printf("\n \n First Pad: %d %d %f %f %d %d %d %f",
283	fIymin, fIymax, fYmin, fYmax, fNpyS[isec], fId, isec, Dpy(isec));
284	*/
285	}
286	//----------------------------------------------------------------------
287	void AliMUONSt345SlatSegmentation::FirstPad(Float_t xhit, Float_t yhit, Float_t /zhit/, Float_t dx, Float_t dy)
288	{
289	FirstPad(xhit, yhit, dx, dy);
290	}
291	//----------------------------------------------------------------------
292	void AliMUONSt345SlatSegmentation::NextPad()
293	{
294	// Stepper for the iteration over pads
295	//
296	// Step to next pad in the integration region
297	// step from left to right
298	if (fIx != fIxmax) {
299	fIx++;
300	GetPadC(fIx,fIy,fX,fY);
301	fSector=Sector(fIx,fIy);
302	// step up
303	} else if (fIy != fIymax) {
304	fIx=fIxmin;
305	fIy++;
306	GetPadC(fIx,fIy,fX,fY);
307	fSector=Sector(fIx,fIy);
308
309	} else {
310	fIx=-1;
311	fIy=-1;
312	}
313	// printf("\n Next Pad %d %d %f %f %d %d %d %d %d ",
314	}
315	//-------------------------------------------------------------------------
316	Int_t AliMUONSt345SlatSegmentation::MorePads()
317	{
318	// Stopping condition for the iterator over pads
319	//
320	// Are there more pads in the integration region
321
322	return (fIx != -1 \|\| fIy != -1);
323	}
324	//--------------------------------------------------------------------------
325	Int_t AliMUONSt345SlatSegmentation::Sector(Int_t ix, Int_t iy)
326	{
327	//
328	// Determine segmentation zone from pad coordinates
329	//
330	Int_t isec=-1;
331	for (Int_t i=0; i < fNsec; i++) {
332	if (ix <= fNpxS[i]) {
333	isec=i;
334	break;
335	}
336	}
337	if (isec == -1) printf("\n Sector: Attention isec ! %d %d %d %d \n",
338	fId, ix, iy,fNpxS[3]);
339
340	return isec;
341
342	}
343	//-----------------------------------------------------------------------------
344	void AliMUONSt345SlatSegmentation::
345	IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
346	{
347	// Returns integration limits for current pad
348	//
349	x1=fXhit-fX-Dpx(fSector)/2.;
350	x2=x1+Dpx(fSector);
351	y1=fYhit-fY-Dpy(fSector)/2.;
352	y2=y1+Dpy(fSector);
353	// printf("\n Integration Limits %f %f %f %f %d %f", x1, x2, y1, y2, fSector, Dpx(fSector));
354
355	}
356	//-----------------------------------------------------------------------------
357	void AliMUONSt345SlatSegmentation::
358	Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10])
359	{
360	// Returns list of next neighbours for given Pad (iX, iY)
361	Int_t i=0;
362	// step right
363	if (iX+1 <= fNpx) {
364	Xlist[i]=iX+1;
365	Ylist[i++]=iY;
366	}
367	// step left
368	if (iX-1 > 0) {
369	Xlist[i]=iX-1;
370	Ylist[i++]=iY;
371	}
372	// step up
373	if (iY+1 <= fNpy) {
374	Xlist[i]=iX;
375	Ylist[i++]=iY+1;
376	}
377	// step down
378	if (iY-1 > 0) {
379	Xlist[i]=iX;
380	Ylist[i++]=iY-1;
381	}
382	*Nlist=i;
383	}
384	//--------------------------------------------------------------------------
385	void AliMUONSt345SlatSegmentation::Init(Int_t detectionElementId)
386	{
387	//
388	// Fill the arrays fCx (x-contour) and fNpxS (ix-contour) for each sector
389	// These arrays help in converting from real to pad co-ordinates and
390	// vice versa
391	//
392	// Segmentation is defined by rectangular modules approximating
393	// concentric circles as shown below
394	//
395	// PCB module size in cm
396	// printf("\n Initialise Segmentation SlatModule \n");
397
398	fDxPCB=40;
399	fDyPCB=40;
400	//
401	// number of pad rows per PCB
402	//
403	Int_t nPyPCB=Int_t(fDyPCB/fDpy);
404	//
405	// maximum number of pad rows
406	fNpy=nPyPCB;
407	//
408	// Calculate padsize along x
409	(*fDpxD)[fNsec-1]=fDpx;
410	if (fNsec > 1) {
411	for (Int_t i=fNsec-1; i>=0; i--){ // fNsec-2
412	(fDpxD)[i]=(fDpxD)[fNsec-1]/(*fNDiv)[i];
413	}
414	}
415	//
416	// fill the arrays defining the pad segmentation boundaries
417	//
418	//
419	// Loop over sectors (isec=0 for secto close to the bema pipe)
420	Float_t totalLength = 0;
421	for (Int_t isec=0; isec<4; isec++) totalLength += fPcbBoards[isec]*fDxPCB; // !!!!
422
423	for (Int_t isec=0; isec<4; isec++) {
424	if (isec==0) {
425	fNpxS[0] = 0;
426	fNpyS[0] = 0;
427	fCx[0] = -totalLength/2;
428	} else {
429	fNpxS[isec]=fNpxS[isec-1] + fPcbBoards[isec]Int_t(fDxPCB/(fDpxD)[isec]);
430	fNpyS[isec]=fNpy;
431	fCx[isec]= fCx[isec-1] + fPcbBoards[isec]*fDxPCB;
432	}
433	} // sectors
434	// maximum number of pad rows
435	fNpy=nPyPCB;
436	fNpx=fNpxS[3];
437	fCy = fDyPCB/2.;
438	//
439	fId = detectionElementId;
440	}
441
442
443
444
445
446
447
448
449
450
451
452