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

/*
$Log$
Revision 1.8  2001/01/17 20:53:40  hristov
Destructors corrected to avoid memory leaks

Revision 1.7  2000/12/21 22:12:41  morsch
Clean-up of coding rule violations,

Revision 1.6  2000/11/06 09:20:43  morsch
AliMUON delegates part of BuildGeometry() to AliMUONSegmentation using the
Draw() method. This avoids code and parameter replication.

Revision 1.5  2000/10/26 19:32:04  morsch
Problem with iteration over y-pads for 2nd cathode corrected.

Revision 1.4  2000/10/25 19:56:55  morsch
Handle correctly slats with less than 3 segmentation zones.

Revision 1.3  2000/10/22 16:56:32  morsch
- Store chamber number as slat id.

Revision 1.2  2000/10/18 11:42:06  morsch
- AliMUONRawCluster contains z-position.
- Some clean-up of useless print statements during initialisations.

Revision 1.1  2000/10/06 08:59:03  morsch
Segmentation classes for bending and non bending plane slat modules (A. de Falco, A. Morsch)

*/

/////////////////////////////////////////////////////
//  Segmentation classes for slat modules          //
//  to be used with AluMUONSegmentationSlat        //
/////////////////////////////////////////////////////


#include "AliMUONSegmentationSlatModule.h"
#include "AliRun.h"
#include "AliMUON.h"
#include <TMath.h>
#include <iostream.h>

#include "AliMUONSegmentationV01.h"

//___________________________________________
ClassImp(AliMUONSegmentationSlatModule)

AliMUONSegmentationSlatModule::AliMUONSegmentationSlatModule() 
{
// Default constructor
}

AliMUONSegmentationSlatModule::AliMUONSegmentationSlatModule(Int_t nsec) 
{
// Non default constructor
    fNsec = nsec;
    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;     
}

AliMUONSegmentationSlatModule::~AliMUONSegmentationSlatModule() 
{
// Destructor
    if (fNDiv) delete fNDiv;
    if (fDpxD) delete fDpxD;
}

void AliMUONSegmentationSlatModule::SetPcbBoards(Int_t n[4])
{
//
// Set Pcb Board segmentation zones
    for (Int_t i=0; i<4; i++) fPcbBoards[i]=n[i];
}


void AliMUONSegmentationSlatModule::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];
}

Float_t AliMUONSegmentationSlatModule::Dpx(Int_t isec) const
{
// Return x-strip width
    return (*fDpxD)[isec];
} 


Float_t AliMUONSegmentationSlatModule::Dpy(Int_t isec) const
{
// Return y-strip width

    return fDpy;
}


void AliMUONSegmentationSlatModule::
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/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 AliMUONSegmentationSlatModule::
GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y) 
{
//  Returns real coordinates (x,y) for given pad coordinates (ix,iy)
//
    y = Float_t(iy*fDpy)-fDpy/2.;
//
//  Find sector isec
    Int_t isec=AliMUONSegmentationSlatModule::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 AliMUONSegmentationSlatModule::
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 AliMUONSegmentationSlatModule::
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 AliMUONSegmentationSlatModule::
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 AliMUONSegmentationSlatModule::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 AliMUONSegmentationSlatModule::MorePads()
{
// Stopping condition for the iterator over pads
//
// Are there more pads in the integration region
    
    return  (fIx != -1  || fIy != -1);
}


Int_t AliMUONSegmentationSlatModule::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 AliMUONSegmentationSlatModule::
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 AliMUONSegmentationSlatModule::
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 AliMUONSegmentationSlatModule::Init(Int_t chamber)
{
//
//  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-2; i>=0; i--){
	    (*fDpxD)[i]=(*fDpxD)[fNsec-1]/(*fNDiv)[i];
	}
    }
//
// fill the arrays defining the pad segmentation boundaries
//
//  
//  Loop over sectors (isec=0 is the dead space surounding the beam pipe)
    for (Int_t isec=0; isec<4; isec++) {
	if (isec==0) {
	    fNpxS[0] = 0;
	    fNpyS[0] = 0;
	    fCx[0]   = 0;
	} 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];
//
    fId = chamber;
}
Commit	Line	Data
4c503756	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	/*
	17	$Log$
e9e4cdf2	18	Revision 1.8 2001/01/17 20:53:40 hristov
	19	Destructors corrected to avoid memory leaks
	20
c2c0190f	21	Revision 1.7 2000/12/21 22:12:41 morsch
	22	Clean-up of coding rule violations,
	23
de05461e	24	Revision 1.6 2000/11/06 09:20:43 morsch
	25	AliMUON delegates part of BuildGeometry() to AliMUONSegmentation using the
	26	Draw() method. This avoids code and parameter replication.
	27
aaf4addd	28	Revision 1.5 2000/10/26 19:32:04 morsch
	29	Problem with iteration over y-pads for 2nd cathode corrected.
	30
d4ee3c3e	31	Revision 1.4 2000/10/25 19:56:55 morsch
	32	Handle correctly slats with less than 3 segmentation zones.
	33
f30dea32	34	Revision 1.3 2000/10/22 16:56:32 morsch
	35	- Store chamber number as slat id.
	36
de2f6d11	37	Revision 1.2 2000/10/18 11:42:06 morsch
	38	- AliMUONRawCluster contains z-position.
	39	- Some clean-up of useless print statements during initialisations.
	40
3e1872ed	41	Revision 1.1 2000/10/06 08:59:03 morsch
	42	Segmentation classes for bending and non bending plane slat modules (A. de Falco, A. Morsch)
	43
4c503756	44	*/
	45
	46	/////////////////////////////////////////////////////
	47	// Segmentation classes for slat modules //
	48	// to be used with AluMUONSegmentationSlat //
	49	/////////////////////////////////////////////////////
	50
	51
	52	#include "AliMUONSegmentationSlatModule.h"
aaf4addd	53	#include "AliRun.h"
aaf4addd	54	#include "AliMUON.h"
4c503756	55	#include <TMath.h>
	56	#include <iostream.h>
	57
	58	#include "AliMUONSegmentationV01.h"
	59
	60	//___________________________________________
	61	ClassImp(AliMUONSegmentationSlatModule)
	62
	63	AliMUONSegmentationSlatModule::AliMUONSegmentationSlatModule()
	64	{
	65	// Default constructor
e9e4cdf2	66	}
	67
	68	AliMUONSegmentationSlatModule::AliMUONSegmentationSlatModule(Int_t nsec)
	69	{
	70	// Non default constructor
	71	fNsec = nsec;
4c503756	72	fNDiv = new TArrayI(fNsec);
	73	fDpxD = new TArrayF(fNsec);
	74	(fNDiv)[0]=(fNDiv)[1]=(fNDiv)[2]=(fNDiv)[3]=0;
	75	(fDpxD)[0]=(fDpxD)[1]=(fDpxD)[2]=(fDpxD)[3]=0;
e9e4cdf2	76	}
	77
	78	AliMUONSegmentationSlatModule::~AliMUONSegmentationSlatModule()
	79	{
	80	// Destructor
	81	if (fNDiv) delete fNDiv;
	82	if (fDpxD) delete fDpxD;
4c503756	83	}
	84
	85	void AliMUONSegmentationSlatModule::SetPcbBoards(Int_t n[4])
	86	{
	87	//
	88	// Set Pcb Board segmentation zones
	89	for (Int_t i=0; i<4; i++) fPcbBoards[i]=n[i];
	90	}
	91
	92
	93	void AliMUONSegmentationSlatModule::SetPadDivision(Int_t ndiv[4])
	94	{
	95	//
	96	// Defines the pad size perp. to the anode wire (y) for different sectors.
	97	// Pad sizes are defined as integral fractions ndiv of a basis pad size
	98	// fDpx
	99	//
	100	for (Int_t i=0; i<4; i++) {
	101	(*fNDiv)[i]=ndiv[i];
	102	}
	103	ndiv[0]=ndiv[1];
	104	}
	105
	106	Float_t AliMUONSegmentationSlatModule::Dpx(Int_t isec) const
	107	{
	108	// Return x-strip width
	109	return (*fDpxD)[isec];
	110	}
	111
	112
	113	Float_t AliMUONSegmentationSlatModule::Dpy(Int_t isec) const
	114	{
	115	// Return y-strip width
	116
	117	return fDpy;
	118	}
	119
	120
	121	void AliMUONSegmentationSlatModule::
	122	GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
	123	{
	124	// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
	125	//
	126	iy = Int_t(y/fDpy)+1;
	127	if (iy > fNpy) iy= fNpy;
	128	//
	129	// Find sector isec
	130
	131	Int_t isec=-1;
	132	for (Int_t i=fNsec-1; i > 0; i--) {
	133	if (x >= fCx[i-1]) {
	134	isec=i;
f30dea32	135	if (fCx[isec] == fCx[isec-1] && isec > 1) isec--;
4c503756	136	break;
	137	}
	138	}
	139
	140	if (isec>0) {
	141	ix= Int_t((x-fCx[isec-1])/(*fDpxD)[isec])
	142	+fNpxS[isec-1]+1;
	143	} else if (isec == 0) {
	144	ix= Int_t(x/(*fDpxD)[isec])+1;
	145	} else {
	146	ix=0;
	147	iy=0;
	148	}
	149	}
	150
	151	void AliMUONSegmentationSlatModule::
	152	GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
	153	{
	154	// Returns real coordinates (x,y) for given pad coordinates (ix,iy)
	155	//
	156	y = Float_t(iy*fDpy)-fDpy/2.;
	157	//
	158	// Find sector isec
	159	Int_t isec=AliMUONSegmentationSlatModule::Sector(ix,iy);
de2f6d11	160	if (isec == -1) printf("\n PadC %d %d %d %d \n ", isec, fId, ix, iy);
4c503756	161	//
	162	if (isec>0) {
	163	x = fCx[isec-1]+(ix-fNpxS[isec-1])(fDpxD)[isec];
	164	x = x-(*fDpxD)[isec]/2;
	165	} else {
	166	x=y=0;
	167	}
	168	}
	169
	170	void AliMUONSegmentationSlatModule::
	171	SetPad(Int_t ix, Int_t iy)
	172	{
	173	//
	174	// Sets virtual pad coordinates, needed for evaluating pad response
	175	// outside the tracking program
	176	GetPadC(ix,iy,fX,fY);
	177	fSector=Sector(ix,iy);
	178	}
	179
	180	void AliMUONSegmentationSlatModule::
	181	SetHit(Float_t x, Float_t y)
	182	{
de05461e	183	// Set current hit
de05461e	184	//
4c503756	185	fXhit = x;
	186	fYhit = y;
	187
	188	if (x < 0) fXhit = 0;
	189	if (y < 0) fYhit = 0;
	190
	191	if (x >= fCx[fNsec-1]) fXhit = fCx[fNsec-1];
	192	if (y >= fDyPCB) fYhit = fDyPCB;
	193
	194
	195	}
	196
	197
	198	void AliMUONSegmentationSlatModule::
	199	FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy)
	200	{
	201	// Initialises iteration over pads for charge distribution algorithm
	202	//
	203	//
	204	// Find the wire position (center of charge distribution)
	205	Float_t x0a=GetAnod(xhit);
	206	fXhit=x0a;
	207	fYhit=yhit;
	208	//
	209	// and take fNsigma*sigma around this center
	210	Float_t x01=x0a - dx;
	211	Float_t x02=x0a + dx;
	212	Float_t y01=yhit - dy;
	213	Float_t y02=yhit + dy;
4c503756	214	if (x01 < 0) x01 = 0;
4c503756	215	if (y01 < 0) y01 = 0;
f30dea32	216
f30dea32	217	if (x02 >= fCx[fNsec-1]) x02 = fCx[fNsec-1];
d4ee3c3e	218
4c503756	219
f30dea32	220
4c503756	221	Int_t isec=-1;
	222	for (Int_t i=fNsec-1; i > 0; i--) {
	223	if (x02 >= fCx[i-1]) {
	224	isec=i;
f30dea32	225	if (fCx[isec] == fCx[isec-1] && isec > 1) isec--;
4c503756	226	break;
	227	}
	228	}
d4ee3c3e	229	y02 += Dpy(isec);
d4ee3c3e	230	if (y02 >= fDyPCB) y02 = fDyPCB;
4c503756	231
4c503756	232	//
	233	// find the pads over which the charge distributes
	234	GetPadI(x01,y01,fIxmin,fIymin);
	235	GetPadI(x02,y02,fIxmax,fIymax);
f30dea32	236
4c503756	237	if (fIxmax > fNpx) fIxmax=fNpx;
4c503756	238	if (fIymax > fNpyS[isec]) fIymax = fNpyS[isec];
d4ee3c3e	239
4c503756	240	fXmin=x01;
d4ee3c3e	241	fXmax=x02;
4c503756	242	fYmin=y01;
d4ee3c3e	243	fYmax=y02;
d4ee3c3e	244
4c503756	245	//
	246	// Set current pad to lower left corner
	247	if (fIxmax < fIxmin) fIxmax=fIxmin;
	248	if (fIymax < fIymin) fIymax=fIymin;
	249	fIx=fIxmin;
	250	fIy=fIymin;
	251
	252	GetPadC(fIx,fIy,fX,fY);
	253	fSector=Sector(fIx,fIy);
d4ee3c3e	254	/*
	255	printf("\n \n First Pad: %d %d %f %f %d %d %d %f" ,
	256	fIxmin, fIxmax, fXmin, fXmax, fNpx, fId, isec, Dpy(isec));
	257	printf("\n \n First Pad: %d %d %f %f %d %d %d %f",
	258	fIymin, fIymax, fYmin, fYmax, fNpyS[isec], fId, isec, Dpy(isec));
	259	*/
4c503756	260	}
	261
	262	void AliMUONSegmentationSlatModule::NextPad()
	263	{
	264	// Stepper for the iteration over pads
	265	//
	266	// Step to next pad in the integration region
	267	// step from left to right
	268	if (fIx != fIxmax) {
	269	fIx++;
	270	GetPadC(fIx,fIy,fX,fY);
	271	fSector=Sector(fIx,fIy);
	272	// step up
	273	} else if (fIy != fIymax) {
	274	fIx=fIxmin;
	275	fIy++;
	276	GetPadC(fIx,fIy,fX,fY);
	277	fSector=Sector(fIx,fIy);
	278
	279	} else {
	280	fIx=-1;
	281	fIy=-1;
	282	}
	283	// printf("\n Next Pad %d %d %f %f %d %d %d %d %d ",
	284	}
	285
	286
	287	Int_t AliMUONSegmentationSlatModule::MorePads()
de05461e	288	{
4c503756	289	// Stopping condition for the iterator over pads
	290	//
	291	// Are there more pads in the integration region
4c503756	292
	293	return (fIx != -1 \|\| fIy != -1);
	294	}
	295
	296
	297	Int_t AliMUONSegmentationSlatModule::Sector(Int_t ix, Int_t iy)
	298	{
	299	//
	300	// Determine segmentation zone from pad coordinates
	301	//
	302	Int_t isec=-1;
	303	for (Int_t i=0; i < fNsec; i++) {
	304	if (ix <= fNpxS[i]) {
	305	isec=i;
	306	break;
	307	}
	308	}
	309	if (isec == -1) printf("\n Sector: Attention isec ! %d %d %d %d \n",
	310	fId, ix, iy,fNpxS[3]);
	311
	312	return isec;
	313
	314	}
	315
	316	void AliMUONSegmentationSlatModule::
	317	IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
	318	{
	319	// Returns integration limits for current pad
	320	//
	321
	322	x1=fXhit-fX-Dpx(fSector)/2.;
	323	x2=x1+Dpx(fSector);
	324	y1=fYhit-fY-Dpy(fSector)/2.;
	325	y2=y1+Dpy(fSector);
	326	// printf("\n Integration Limits %f %f %f %f %d %f", x1, x2, y1, y2, fSector, Dpx(fSector));
	327
	328	}
	329
	330	void AliMUONSegmentationSlatModule::
	331	Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10])
	332	{
	333	// Returns list of next neighbours for given Pad (iX, iY)
	334	//
	335	//
	336	Int_t i=0;
	337	//
	338	// step right
	339	if (iX+1 <= fNpx) {
	340	Xlist[i]=iX+1;
	341	Ylist[i++]=iY;
	342	}
	343	//
	344	// step left
	345	if (iX-1 > 0) {
	346	Xlist[i]=iX-1;
	347	Ylist[i++]=iY;
	348	}
	349
	350	//
	351	// step up
	352	if (iY+1 <= fNpy) {
	353	Xlist[i]=iX;
	354	Ylist[i++]=iY+1;
	355	}
356	//
357	// step down
358	if (iY-1 > 0) {
359	Xlist[i]=iX;
360	Ylist[i++]=iY-1;
361	}
362
363	*Nlist=i;
364	}
365
366
367	void AliMUONSegmentationSlatModule::Init(Int_t chamber)
368	{
4c503756	369	//
	370	// Fill the arrays fCx (x-contour) and fNpxS (ix-contour) for each sector
	371	// These arrays help in converting from real to pad co-ordinates and
	372	// vice versa
	373	//
	374	// Segmentation is defined by rectangular modules approximating
	375	// concentric circles as shown below
	376	//
	377	// PCB module size in cm
de05461e	378	printf("\n Initialise Segmentation SlatModule \n");
de05461e	379
4c503756	380	fDxPCB=40;
	381	fDyPCB=40;
	382	//
	383	// number of pad rows per PCB
	384	//
	385	Int_t nPyPCB=Int_t(fDyPCB/fDpy);
	386	//
	387	// maximum number of pad rows
	388	fNpy=nPyPCB;
	389	//
	390	// Calculate padsize along x
	391	(*fDpxD)[fNsec-1]=fDpx;
	392	if (fNsec > 1) {
	393	for (Int_t i=fNsec-2; i>=0; i--){
	394	(fDpxD)[i]=(fDpxD)[fNsec-1]/(*fNDiv)[i];
4c503756	395	}
	396	}
	397	//
	398	// fill the arrays defining the pad segmentation boundaries
	399	//
	400	//
	401	// Loop over sectors (isec=0 is the dead space surounding the beam pipe)
	402	for (Int_t isec=0; isec<4; isec++) {
	403	if (isec==0) {
	404	fNpxS[0] = 0;
	405	fNpyS[0] = 0;
	406	fCx[0] = 0;
	407	} else {
	408	fNpxS[isec]=fNpxS[isec-1] + fPcbBoards[isec]Int_t(fDxPCB/(fDpxD)[isec]);
	409	fNpyS[isec]=fNpy;
	410	fCx[isec]=fCx[isec-1] + fPcbBoards[isec]*fDxPCB;
	411	}
	412	} // sectors
	413	// maximum number of pad rows
	414	fNpy=nPyPCB;
	415	fNpx=fNpxS[3];
de2f6d11	416	//
de2f6d11	417	fId = chamber;
4c503756	418	}
	419
	420
	421
	422
	423
	424
	425
	426
	427
	428
	429
	430