[u/mrichter/AliRoot.git] / MUON / AliMUONSegmentationV01.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.7  2000/10/02 21:28:09  fca
Removal of useless dependecies via forward declarations

Revision 1.6  2000/10/02 16:58:29  egangler
Cleaning of the code :
-> coding conventions
-> void Streamers
-> some useless includes removed or replaced by "class" statement

Revision 1.5  2000/07/13 16:19:44  fca
Mainly coding conventions + some small bug fixes

Revision 1.4  2000/07/03 11:54:57  morsch
AliMUONSegmentation and AliMUONHitMap have been replaced by AliSegmentation and AliHitMap in STEER
The methods GetPadIxy and GetPadXxy of AliMUONSegmentation have changed name to GetPadI and GetPadC.

Revision 1.3  2000/06/29 12:34:09  morsch
AliMUONSegmentation class has been made independent of AliMUONChamber. This makes
it usable with any other geometry class. The link to the object to which it belongs is
established via an index. This assumes that there exists a global geometry manager
from which the pointer to the parent object can be obtained (in our case gAlice).

Revision 1.2  2000/06/15 07:58:48  morsch
Code from MUON-dev joined

Revision 1.1.2.1  2000/06/09 21:37:30  morsch
AliMUONSegmentationV01 code  from  AliMUONSegResV01.cxx

*/


/////////////////////////////////////////////////////
//  Segmentation and Response classes version 01   //
/////////////////////////////////////////////////////

#include <TBox.h> 
#include <TF1.h> 
#include <TObjArray.h>
#include <iostream.h>

#include "AliMUONSegmentationV01.h"
#include "AliMUON.h"


//___________________________________________
ClassImp(AliMUONSegmentationV01)

AliMUONSegmentationV01::AliMUONSegmentationV01(const AliMUONSegmentationV01& segmentation)
{
// Dummy copy constructor
}
AliMUONSegmentationV01::AliMUONSegmentationV01() 
{
// Default constructor
    fNsec=4;
    fRSec = new TArrayF(fNsec);
    fNDiv = new TArrayI(fNsec);      
    fDpxD = new TArrayF(fNsec);      
    (*fRSec)[0]=(*fRSec)[1]=(*fRSec)[2]=(*fRSec)[3]=0;     
    (*fNDiv)[0]=(*fNDiv)[1]=(*fNDiv)[2]=(*fNDiv)[3]=0;     
    (*fDpxD)[0]=(*fDpxD)[1]=(*fDpxD)[2]=(*fDpxD)[3]=0;     
    fCorr = new TObjArray(3);
    (*fCorr)[0]=0;
    (*fCorr)[1]=0;
    (*fCorr)[2]=0;
} 

Float_t AliMUONSegmentationV01::Dpx(Int_t isec) const
{
//
// Returns x-pad size for given sector isec
   Float_t dpx = (*fDpxD)[isec];
   return dpx;
}

Float_t AliMUONSegmentationV01::Dpy(Int_t isec) const
{
//
// Returns y-pad size for given sector isec
   return fDpy;
}
    
void   AliMUONSegmentationV01::SetSegRadii(Float_t  r[4])
{
//
// Set the radii of the segmentation zones 
    for (Int_t i=0; i<4; i++) {
	(*fRSec)[i]=r[i];
	printf("\n R %d %f \n",i,(*fRSec)[i]);
	
    }
}


void AliMUONSegmentationV01::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];
	printf("\n Ndiv %d %d \n",i,(*fNDiv)[i]);
    }
    ndiv[0]=ndiv[1];
}


void AliMUONSegmentationV01::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.
//  This version approximates concentric segmentation zones
//
    Int_t isec;
    printf("\n Initialise segmentation v01 -- test !!!!!!!!!!!!!! \n");
    fNpy=Int_t((*fRSec)[fNsec-1]/fDpy)+1;

    (*fDpxD)[fNsec-1]=fDpx;
    if (fNsec > 1) {
	for (Int_t i=fNsec-2; i>=0; i--){
	    (*fDpxD)[i]=(*fDpxD)[fNsec-1]/(*fNDiv)[i];
	    printf("\n test ---dx %d %f \n",i,(*fDpxD)[i]);
	}
    }
//
// fill the arrays defining the pad segmentation boundaries
    Float_t ry;
    Int_t   dnx;
    Int_t   add;
//
//  loop over sections
    for(isec=0; isec<fNsec; isec++) {
//  
//  loop over pads along the aode wires
	for (Int_t iy=1; iy<=fNpy; iy++) {
//
	    Float_t x=iy*fDpy-fDpy/2;
	    if (x > (*fRSec)[isec]) {
		fNpxS[isec][iy]=0;
		fCx[isec][iy]=0;
	    } else {
		ry=TMath::Sqrt((*fRSec)[isec]*(*fRSec)[isec]-x*x);
		if (isec > 1) {
		    dnx= Int_t((ry-fCx[isec-1][iy])/(*fDpxD)[isec]);
		    if (isec < fNsec-1) {
			if (TMath::Odd((Long_t)dnx)) dnx++;    		
		    }
                    fNpxS[isec][iy]=fNpxS[isec-1][iy]+dnx;
          	    fCx[isec][iy]=fCx[isec-1][iy]+dnx*(*fDpxD)[isec];
		} else if (isec == 1) {
		    dnx= Int_t((ry-fCx[isec-1][iy])/(*fDpxD)[isec]);
		    fNpxS[isec][iy]=fNpxS[isec-1][iy]+dnx;
                    add=4 - (fNpxS[isec][iy])%4;
                    if (add < 4) fNpxS[isec][iy]+=add; 
		    dnx=fNpxS[isec][iy]-fNpxS[isec-1][iy];
		    fCx[isec][iy]=fCx[isec-1][iy]+dnx*(*fDpxD)[isec];
		} else {
		    dnx=Int_t(ry/(*fDpxD)[isec]);
                    fNpxS[isec][iy]=dnx;
		    fCx[isec][iy]=dnx*(*fDpxD)[isec];
		}
	    }
	} // y-pad loop
    } // sector loop
}

Int_t AliMUONSegmentationV01::Sector(Int_t ix, Int_t iy)
{
// Returns sector number for given pad position
//
    Int_t absix=TMath::Abs(ix);
    Int_t absiy=TMath::Abs(iy);
    Int_t isec=0;
    for (Int_t i=0; i<fNsec; i++) {
	if (absix<=fNpxS[i][absiy]){
	    isec=i;
	    break;
	}
    }
    return isec;
}

void AliMUONSegmentationV01::
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 = (y>0)? Int_t(y/fDpy)+1 : Int_t(y/fDpy)-1;
    if (iy >  fNpy) iy= fNpy;
    if (iy < -fNpy) iy=-fNpy;
//
//  Find sector isec
    Int_t isec=-1;
    Float_t absx=TMath::Abs(x);
    Int_t absiy=TMath::Abs(iy);
    for (Int_t i=0; i < fNsec; i++) {
	if (absx <= fCx[i][absiy]) {
	    isec=i;
	    break;
	}
    }
    if (isec>0) {
	ix= Int_t((absx-fCx[isec-1][absiy])/(*fDpxD)[isec])
	    +fNpxS[isec-1][absiy]+1;
    } else if (isec == 0) {
	ix= Int_t(absx/(*fDpxD)[isec])+1;
    } else {
	ix=fNpxS[fNsec-1][absiy]+1;	
    }
    ix = (x>0) ? ix:-ix;
}

void AliMUONSegmentationV01::
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 = (iy>0) ? Float_t(iy*fDpy)-fDpy/2. : Float_t(iy*fDpy)+fDpy/2.;
//
//  Find sector isec
    Int_t isec=AliMUONSegmentationV01::Sector(ix,iy);
//
    Int_t absix=TMath::Abs(ix);
    Int_t absiy=TMath::Abs(iy);
    if (isec) {
	x=fCx[isec-1][absiy]+(absix-fNpxS[isec-1][absiy])*(*fDpxD)[isec];
	x=(ix>0) ?  x-(*fDpxD)[isec]/2 : -x+(*fDpxD)[isec]/2;
    } else {
	x=y=0;
    }
}

void AliMUONSegmentationV01::
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 AliMUONSegmentationV01::
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;
    //
    // find the pads over which the charge distributes

    GetPadI(x01,y01,fIxmin,fIymin);
    GetPadI(x02,y02,fIxmax,fIymax);
    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);
}


void AliMUONSegmentationV01::NextPad()
{
// Stepper for the iteration over pads
//
// Step to next pad in the integration region
  // 
  // Step to next pad in integration region
    Float_t xc,yc;
    Int_t   iyc;
    
//  step from left to right    

    if (fX < fXmax && fX != 0) {
	if (fIx==-1) fIx++;
	fIx++;
//  step up 
    } else if (fIy != fIymax) {
	if (fIy==-1) fIy++;
	fIy++;
//      get y-position of next row (yc), xc not used here 	
	GetPadC(fIx,fIy,xc,yc);
//      get x-pad coordiante for first pad in row (fIx)
	GetPadI(fXmin,yc,fIx,iyc);
    } else {
	printf("\n Error: Stepping outside integration region\n ");
    }
    GetPadC(fIx,fIy,fX,fY);
    fSector=Sector(fIx,fIy);
    if (MorePads() && 
	(fSector ==-1 || fSector==0)) 
	NextPad();
}

Int_t AliMUONSegmentationV01::MorePads()
// Stopping condition for the iterator over pads
//
// Are there more pads in the integration region
{
    if ((fX >= fXmax  && fIy >= fIymax) || fY==0) {
	return 0;
    } else {
	return 1;
    }
}

void AliMUONSegmentationV01::
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);    
}

void AliMUONSegmentationV01::
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)
//
    const Float_t kEpsilon=fDpy/1000;
    
    Float_t x,y;
    Int_t   ixx, iyy, isec1;
//
    Int_t   isec0=AliMUONSegmentationV01::Sector(iX,iY);
    Int_t i=0;
//    
//  step right
    Xlist[i]=iX+1;
    if (Xlist[i]==0) Xlist[i]++;
    Ylist[i++]=iY;
//
//  step left    
    Xlist[i]=iX-1;
    if (Xlist[i]==0) Xlist[i]--;
    Ylist[i++]=iY;
//
//  step up 
    AliMUONSegmentationV01::GetPadC(iX,iY,x,y);
    AliMUONSegmentationV01::GetPadI(x+kEpsilon,y+fDpy,ixx,iyy);
    Xlist[i]=ixx;
    Ylist[i++]=iyy;
    isec1=AliMUONSegmentationV01::Sector(ixx,iyy);
    if (isec1==isec0) {
//
//  no sector boundary crossing
//	Xlist[i]=ixx+1;
//	Ylist[i++]=iY+1;
	
//	Xlist[i]=ixx-1;
//	Ylist[i++]=iY+1;
    } else if (isec1 < isec0) {
// finer segmentation
//	Xlist[i]=ixx+1;
//	Ylist[i++]=iY+1;
	
	Xlist[i]=ixx-1;
	Ylist[i++]=iyy;
	
//	Xlist[i]=ixx-2;
//	Ylist[i++]=iY+1;
    } else {
// coarser segmenation	
/*
	if (TMath::Odd(iX-fNpxS[isec1-1][iY+1])) {
	    Xlist[i]=ixx-1;
	    Ylist[i++]=iY+1;
	} else {
	    Xlist[i]=ixx+1;
	    Ylist[i++]=iY+1;
	}
*/
    }

//
// step down 
    AliMUONSegmentationV01::GetPadC(iX,iY,x,y);
    AliMUONSegmentationV01::GetPadI(x+kEpsilon,y-fDpy,ixx,iyy);
    Xlist[i]=ixx;
    Ylist[i++]=iyy;
    isec1=AliMUONSegmentationV01::Sector(ixx,iyy);
    if (isec1==isec0) {
//
//  no sector boundary crossing
/*
    Xlist[i]=ixx+1;
    Ylist[i++]=iY-1;
	
    Xlist[i]=ixx-1;
    Ylist[i++]=iY-1;
*/
    } else if (isec1 < isec0) {
// finer segmentation
//	Xlist[i]=ixx+1;
//	Ylist[i++]=iY-1;
	
	Xlist[i]=ixx-1;
	Ylist[i++]=iyy;
	
//	Xlist[i]=ixx-2;
//	Ylist[i++]=iY-1;
    } else {
// coarser segmentation	
/*
	if (TMath::Odd(iX-fNpxS[isec1-1][iY-1])) {
	    Xlist[i]=ixx-1;
	    Ylist[i++]=iY-1;
	} else {
	    Xlist[i]=ixx+1;
	    Ylist[i++]=iY-1;
	}
*/
    }
    *Nlist=i;
}

void AliMUONSegmentationV01::GiveTestPoints(Int_t &n, Float_t *x, Float_t *y) const
{
// Returns test point on the pad plane.
// Used during determination of the segmoid correction of the COG-method

    n=3;
    x[0]=((*fRSec)[0]+(*fRSec)[1])/2/TMath::Sqrt(2.);
    y[0]=x[0];
    x[1]=((*fRSec)[1]+(*fRSec)[2])/2/TMath::Sqrt(2.);
    y[1]=x[1];
    x[2]=((*fRSec)[2]+(*fRSec)[3])/2/TMath::Sqrt(2.);
    y[2]=x[2];
}

void AliMUONSegmentationV01::Draw(const char *) const
{
// Draws the segmentation zones
//
    TBox *box;
    
    Float_t dx=0.95/fCx[3][1]/2;
    Float_t dy=0.95/(Float_t(Npy()))/2;
    Float_t x0,y0,x1,y1;
    Float_t xc=0.5;
    Float_t yc=0.5;
    
    for (Int_t iy=1; iy<Npy(); iy++)
    {
	for (Int_t isec=0; isec<4; isec++) {
	    if (isec==0) {
		x0=0;
		x1=fCx[isec][iy]*dx;
	    } else {
		x0=fCx[isec-1][iy]*dx;
		x1=fCx[isec][iy]*dx;
	    }
	    y0=Float_t(iy-1)*dy;
	    y1=y0+dy;
	    box=new TBox(x0+xc,y0+yc,x1+xc,y1+yc);
	    box->SetFillColor(isec+1);
	    box->Draw();

	    box=new TBox(-x1+xc,y0+yc,-x0+xc,y1+yc);
	    box->SetFillColor(isec+1);
	    box->Draw();

	    box=new TBox(x0+xc,-y1+yc,x1+xc,-y0+yc);
	    box->SetFillColor(isec+1);
	    box->Draw();

	    box=new TBox(-x1+xc,-y1+yc,-x0+xc,-y0+yc);
	    box->SetFillColor(isec+1);
	    box->Draw();
	}
    }
}
void AliMUONSegmentationV01::SetCorrFunc(Int_t isec, TF1* func)
{
    (*fCorr)[isec]=func;
}

TF1* AliMUONSegmentationV01::CorrFunc(Int_t isec) const
{ 
    return (TF1*) (*fCorr)[isec];
}

AliMUONSegmentationV01& AliMUONSegmentationV01::operator 
=(const AliMUONSegmentationV01 & rhs)
{
// Dummy assignment operator
    return *this;
}
Commit	Line	Data
a9e2aefa	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$
c3eff6ad	18	Revision 1.7 2000/10/02 21:28:09 fca
	19	Removal of useless dependecies via forward declarations
	20
94de3818	21	Revision 1.6 2000/10/02 16:58:29 egangler
	22	Cleaning of the code :
	23	-> coding conventions
	24	-> void Streamers
	25	-> some useless includes removed or replaced by "class" statement
	26
ecfa008b	27	Revision 1.5 2000/07/13 16:19:44 fca
	28	Mainly coding conventions + some small bug fixes
	29
ef42d733	30	Revision 1.4 2000/07/03 11:54:57 morsch
	31	AliMUONSegmentation and AliMUONHitMap have been replaced by AliSegmentation and AliHitMap in STEER
	32	The methods GetPadIxy and GetPadXxy of AliMUONSegmentation have changed name to GetPadI and GetPadC.
	33
a30a000f	34	Revision 1.3 2000/06/29 12:34:09 morsch
	35	AliMUONSegmentation class has been made independent of AliMUONChamber. This makes
	36	it usable with any other geometry class. The link to the object to which it belongs is
	37	established via an index. This assumes that there exists a global geometry manager
	38	from which the pointer to the parent object can be obtained (in our case gAlice).
	39
d81db581	40	Revision 1.2 2000/06/15 07:58:48 morsch
	41	Code from MUON-dev joined
	42
a9e2aefa	43	Revision 1.1.2.1 2000/06/09 21:37:30 morsch
	44	AliMUONSegmentationV01 code from AliMUONSegResV01.cxx
	45
	46	*/
	47
	48
	49	/////////////////////////////////////////////////////
	50	// Segmentation and Response classes version 01 //
	51	/////////////////////////////////////////////////////
	52
	53	#include <TBox.h>
	54	#include <TF1.h>
	55	#include <TObjArray.h>
	56	#include <iostream.h>
	57
	58	#include "AliMUONSegmentationV01.h"
	59	#include "AliMUON.h"
	60
	61
	62
	63	//___________________________________________
	64	ClassImp(AliMUONSegmentationV01)
	65
	66	AliMUONSegmentationV01::AliMUONSegmentationV01(const AliMUONSegmentationV01& segmentation)
	67	{
	68	// Dummy copy constructor
	69	}
	70	AliMUONSegmentationV01::AliMUONSegmentationV01()
	71	{
	72	// Default constructor
	73	fNsec=4;
c3eff6ad	74	fRSec = new TArrayF(fNsec);
	75	fNDiv = new TArrayI(fNsec);
	76	fDpxD = new TArrayF(fNsec);
	77	(fRSec)[0]=(fRSec)[1]=(fRSec)[2]=(fRSec)[3]=0;
	78	(fNDiv)[0]=(fNDiv)[1]=(fNDiv)[2]=(fNDiv)[3]=0;
	79	(fDpxD)[0]=(fDpxD)[1]=(fDpxD)[2]=(fDpxD)[3]=0;
a9e2aefa	80	fCorr = new TObjArray(3);
	81	(*fCorr)[0]=0;
	82	(*fCorr)[1]=0;
	83	(*fCorr)[2]=0;
	84	}
	85
94de3818	86	Float_t AliMUONSegmentationV01::Dpx(Int_t isec) const
a9e2aefa	87	{
	88	//
	89	// Returns x-pad size for given sector isec
c3eff6ad	90	Float_t dpx = (*fDpxD)[isec];
c3eff6ad	91	return dpx;
a9e2aefa	92	}
a9e2aefa	93
94de3818	94	Float_t AliMUONSegmentationV01::Dpy(Int_t isec) const
a9e2aefa	95	{
	96	//
	97	// Returns y-pad size for given sector isec
	98	return fDpy;
	99	}
	100
	101	void AliMUONSegmentationV01::SetSegRadii(Float_t r[4])
	102	{
	103	//
	104	// Set the radii of the segmentation zones
	105	for (Int_t i=0; i<4; i++) {
c3eff6ad	106	(*fRSec)[i]=r[i];
c3eff6ad	107	printf("\n R %d %f \n",i,(*fRSec)[i]);
a9e2aefa	108
	109	}
	110	}
	111
	112
	113	void AliMUONSegmentationV01::SetPadDivision(Int_t ndiv[4])
	114	{
	115	//
	116	// Defines the pad size perp. to the anode wire (y) for different sectors.
	117	// Pad sizes are defined as integral fractions ndiv of a basis pad size
	118	// fDpx
	119	//
	120	for (Int_t i=0; i<4; i++) {
c3eff6ad	121	(*fNDiv)[i]=ndiv[i];
c3eff6ad	122	printf("\n Ndiv %d %d \n",i,(*fNDiv)[i]);
a9e2aefa	123	}
	124	ndiv[0]=ndiv[1];
	125	}
	126
	127
d81db581	128	void AliMUONSegmentationV01::Init(Int_t chamber)
a9e2aefa	129	{
	130	//
	131	// Fill the arrays fCx (x-contour) and fNpxS (ix-contour) for each sector
	132	// These arrays help in converting from real to pad co-ordinates and
	133	// vice versa.
	134	// This version approximates concentric segmentation zones
	135	//
	136	Int_t isec;
	137	printf("\n Initialise segmentation v01 -- test !!!!!!!!!!!!!! \n");
c3eff6ad	138	fNpy=Int_t((*fRSec)[fNsec-1]/fDpy)+1;
a9e2aefa	139
c3eff6ad	140	(*fDpxD)[fNsec-1]=fDpx;
a9e2aefa	141	if (fNsec > 1) {
a9e2aefa	142	for (Int_t i=fNsec-2; i>=0; i--){
c3eff6ad	143	(fDpxD)[i]=(fDpxD)[fNsec-1]/(*fNDiv)[i];
c3eff6ad	144	printf("\n test ---dx %d %f \n",i,(*fDpxD)[i]);
a9e2aefa	145	}
	146	}
	147	//
	148	// fill the arrays defining the pad segmentation boundaries
	149	Float_t ry;
	150	Int_t dnx;
	151	Int_t add;
	152	//
	153	// loop over sections
	154	for(isec=0; isec<fNsec; isec++) {
	155	//
	156	// loop over pads along the aode wires
	157	for (Int_t iy=1; iy<=fNpy; iy++) {
	158	//
	159	Float_t x=iy*fDpy-fDpy/2;
c3eff6ad	160	if (x > (*fRSec)[isec]) {
a9e2aefa	161	fNpxS[isec][iy]=0;
	162	fCx[isec][iy]=0;
	163	} else {
c3eff6ad	164	ry=TMath::Sqrt((fRSec)[isec](fRSec)[isec]-xx);
a9e2aefa	165	if (isec > 1) {
c3eff6ad	166	dnx= Int_t((ry-fCx[isec-1][iy])/(*fDpxD)[isec]);
a9e2aefa	167	if (isec < fNsec-1) {
	168	if (TMath::Odd((Long_t)dnx)) dnx++;
	169	}
	170	fNpxS[isec][iy]=fNpxS[isec-1][iy]+dnx;
c3eff6ad	171	fCx[isec][iy]=fCx[isec-1][iy]+dnx(fDpxD)[isec];
a9e2aefa	172	} else if (isec == 1) {
c3eff6ad	173	dnx= Int_t((ry-fCx[isec-1][iy])/(*fDpxD)[isec]);
a9e2aefa	174	fNpxS[isec][iy]=fNpxS[isec-1][iy]+dnx;
	175	add=4 - (fNpxS[isec][iy])%4;
	176	if (add < 4) fNpxS[isec][iy]+=add;
	177	dnx=fNpxS[isec][iy]-fNpxS[isec-1][iy];
c3eff6ad	178	fCx[isec][iy]=fCx[isec-1][iy]+dnx(fDpxD)[isec];
a9e2aefa	179	} else {
c3eff6ad	180	dnx=Int_t(ry/(*fDpxD)[isec]);
a9e2aefa	181	fNpxS[isec][iy]=dnx;
c3eff6ad	182	fCx[isec][iy]=dnx(fDpxD)[isec];
a9e2aefa	183	}
	184	}
	185	} // y-pad loop
	186	} // sector loop
	187	}
	188
	189	Int_t AliMUONSegmentationV01::Sector(Int_t ix, Int_t iy)
	190	{
	191	// Returns sector number for given pad position
	192	//
	193	Int_t absix=TMath::Abs(ix);
	194	Int_t absiy=TMath::Abs(iy);
	195	Int_t isec=0;
	196	for (Int_t i=0; i<fNsec; i++) {
	197	if (absix<=fNpxS[i][absiy]){
	198	isec=i;
	199	break;
	200	}
	201	}
	202	return isec;
	203	}
	204
	205	void AliMUONSegmentationV01::
a30a000f	206	GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
a9e2aefa	207	{
	208	// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
	209	//
	210	iy = (y>0)? Int_t(y/fDpy)+1 : Int_t(y/fDpy)-1;
	211	if (iy > fNpy) iy= fNpy;
	212	if (iy < -fNpy) iy=-fNpy;
	213	//
	214	// Find sector isec
	215	Int_t isec=-1;
	216	Float_t absx=TMath::Abs(x);
	217	Int_t absiy=TMath::Abs(iy);
	218	for (Int_t i=0; i < fNsec; i++) {
	219	if (absx <= fCx[i][absiy]) {
	220	isec=i;
	221	break;
	222	}
	223	}
	224	if (isec>0) {
c3eff6ad	225	ix= Int_t((absx-fCx[isec-1][absiy])/(*fDpxD)[isec])
a9e2aefa	226	+fNpxS[isec-1][absiy]+1;
a9e2aefa	227	} else if (isec == 0) {
c3eff6ad	228	ix= Int_t(absx/(*fDpxD)[isec])+1;
a9e2aefa	229	} else {
	230	ix=fNpxS[fNsec-1][absiy]+1;
	231	}
	232	ix = (x>0) ? ix:-ix;
	233	}
	234
	235	void AliMUONSegmentationV01::
a30a000f	236	GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
a9e2aefa	237	{
	238	// Returns real coordinates (x,y) for given pad coordinates (ix,iy)
	239	//
	240	y = (iy>0) ? Float_t(iyfDpy)-fDpy/2. : Float_t(iyfDpy)+fDpy/2.;
	241	//
	242	// Find sector isec
	243	Int_t isec=AliMUONSegmentationV01::Sector(ix,iy);
	244	//
	245	Int_t absix=TMath::Abs(ix);
	246	Int_t absiy=TMath::Abs(iy);
	247	if (isec) {
c3eff6ad	248	x=fCx[isec-1][absiy]+(absix-fNpxS[isec-1][absiy])(fDpxD)[isec];
c3eff6ad	249	x=(ix>0) ? x-(fDpxD)[isec]/2 : -x+(fDpxD)[isec]/2;
a9e2aefa	250	} else {
	251	x=y=0;
	252	}
	253	}
	254
	255	void AliMUONSegmentationV01::
	256	SetPad(Int_t ix, Int_t iy)
	257	{
	258	//
	259	// Sets virtual pad coordinates, needed for evaluating pad response
	260	// outside the tracking program
ecfa008b	261	GetPadC(ix,iy,fX,fY);
a9e2aefa	262	fSector=Sector(ix,iy);
	263	}
	264
	265
	266	void AliMUONSegmentationV01::
	267	FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy)
	268	{
	269	// Initialises iteration over pads for charge distribution algorithm
	270	//
	271	//
	272	// Find the wire position (center of charge distribution)
	273	Float_t x0a=GetAnod(xhit);
ecfa008b	274	fXhit=x0a;
ecfa008b	275	fYhit=yhit;
a9e2aefa	276
	277	//
	278	// and take fNsigma*sigma around this center
	279	Float_t x01=x0a - dx;
	280	Float_t x02=x0a + dx;
	281	Float_t y01=yhit - dy;
	282	Float_t y02=yhit + dy;
	283	//
	284	// find the pads over which the charge distributes
c3eff6ad	285
ecfa008b	286	GetPadI(x01,y01,fIxmin,fIymin);
	287	GetPadI(x02,y02,fIxmax,fIymax);
	288	fXmin=x01;
	289	fXmax=x02;
	290	fYmin=y01;
	291	fYmax=y02;
a9e2aefa	292
	293	//
	294	// Set current pad to lower left corner
ecfa008b	295	if (fIxmax < fIxmin) fIxmax=fIxmin;
	296	if (fIymax < fIymin) fIymax=fIymin;
	297	fIx=fIxmin;
	298	fIy=fIymin;
	299	GetPadC(fIx,fIy,fX,fY);
a9e2aefa	300	}
	301
	302
	303	void AliMUONSegmentationV01::NextPad()
	304	{
	305	// Stepper for the iteration over pads
	306	//
	307	// Step to next pad in the integration region
	308	//
	309	// Step to next pad in integration region
	310	Float_t xc,yc;
	311	Int_t iyc;
	312
	313	// step from left to right
c3eff6ad	314
ecfa008b	315	if (fX < fXmax && fX != 0) {
	316	if (fIx==-1) fIx++;
	317	fIx++;
a9e2aefa	318	// step up
ecfa008b	319	} else if (fIy != fIymax) {
	320	if (fIy==-1) fIy++;
	321	fIy++;
a9e2aefa	322	// get y-position of next row (yc), xc not used here
ecfa008b	323	GetPadC(fIx,fIy,xc,yc);
	324	// get x-pad coordiante for first pad in row (fIx)
	325	GetPadI(fXmin,yc,fIx,iyc);
a9e2aefa	326	} else {
	327	printf("\n Error: Stepping outside integration region\n ");
	328	}
ecfa008b	329	GetPadC(fIx,fIy,fX,fY);
ecfa008b	330	fSector=Sector(fIx,fIy);
a9e2aefa	331	if (MorePads() &&
	332	(fSector ==-1 \|\| fSector==0))
	333	NextPad();
	334	}
	335
	336	Int_t AliMUONSegmentationV01::MorePads()
	337	// Stopping condition for the iterator over pads
	338	//
	339	// Are there more pads in the integration region
	340	{
ecfa008b	341	if ((fX >= fXmax && fIy >= fIymax) \|\| fY==0) {
a9e2aefa	342	return 0;
	343	} else {
	344	return 1;
	345	}
	346	}
	347
	348	void AliMUONSegmentationV01::
	349	IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
	350	{
	351	// Returns integration limits for current pad
	352	//
ecfa008b	353	x1=fXhit-fX-Dpx(fSector)/2.;
a9e2aefa	354	x2=x1+Dpx(fSector);
ecfa008b	355	y1=fYhit-fY-Dpy(fSector)/2.;
a9e2aefa	356	y2=y1+Dpy(fSector);
	357	}
	358
	359	void AliMUONSegmentationV01::
	360	Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10])
	361	{
	362	// Returns list of next neighbours for given Pad (iX, iY)
	363	//
	364	const Float_t kEpsilon=fDpy/1000;
	365
	366	Float_t x,y;
	367	Int_t ixx, iyy, isec1;
	368	//
	369	Int_t isec0=AliMUONSegmentationV01::Sector(iX,iY);
	370	Int_t i=0;
	371	//
	372	// step right
	373	Xlist[i]=iX+1;
	374	if (Xlist[i]==0) Xlist[i]++;
	375	Ylist[i++]=iY;
	376	//
	377	// step left
	378	Xlist[i]=iX-1;
	379	if (Xlist[i]==0) Xlist[i]--;
	380	Ylist[i++]=iY;
	381	//
	382	// step up
a30a000f	383	AliMUONSegmentationV01::GetPadC(iX,iY,x,y);
a30a000f	384	AliMUONSegmentationV01::GetPadI(x+kEpsilon,y+fDpy,ixx,iyy);
a9e2aefa	385	Xlist[i]=ixx;
	386	Ylist[i++]=iyy;
	387	isec1=AliMUONSegmentationV01::Sector(ixx,iyy);
	388	if (isec1==isec0) {
	389	//
	390	// no sector boundary crossing
	391	// Xlist[i]=ixx+1;
	392	// Ylist[i++]=iY+1;
	393
	394	// Xlist[i]=ixx-1;
	395	// Ylist[i++]=iY+1;
	396	} else if (isec1 < isec0) {
	397	// finer segmentation
	398	// Xlist[i]=ixx+1;
	399	// Ylist[i++]=iY+1;
	400
	401	Xlist[i]=ixx-1;
	402	Ylist[i++]=iyy;
	403
	404	// Xlist[i]=ixx-2;
	405	// Ylist[i++]=iY+1;
	406	} else {
	407	// coarser segmenation
	408	/*
	409	if (TMath::Odd(iX-fNpxS[isec1-1][iY+1])) {
	410	Xlist[i]=ixx-1;
	411	Ylist[i++]=iY+1;
	412	} else {
	413	Xlist[i]=ixx+1;
	414	Ylist[i++]=iY+1;
	415	}
	416	*/
	417	}
	418
	419	//
	420	// step down
a30a000f	421	AliMUONSegmentationV01::GetPadC(iX,iY,x,y);
a30a000f	422	AliMUONSegmentationV01::GetPadI(x+kEpsilon,y-fDpy,ixx,iyy);
a9e2aefa	423	Xlist[i]=ixx;
	424	Ylist[i++]=iyy;
	425	isec1=AliMUONSegmentationV01::Sector(ixx,iyy);
	426	if (isec1==isec0) {
	427	//
	428	// no sector boundary crossing
	429	/*
	430	Xlist[i]=ixx+1;
	431	Ylist[i++]=iY-1;
	432
	433	Xlist[i]=ixx-1;
	434	Ylist[i++]=iY-1;
	435	*/
	436	} else if (isec1 < isec0) {
	437	// finer segmentation
	438	// Xlist[i]=ixx+1;
	439	// Ylist[i++]=iY-1;
	440
	441	Xlist[i]=ixx-1;
	442	Ylist[i++]=iyy;
	443
	444	// Xlist[i]=ixx-2;
	445	// Ylist[i++]=iY-1;
	446	} else {
	447	// coarser segmentation
	448	/*
	449	if (TMath::Odd(iX-fNpxS[isec1-1][iY-1])) {
	450	Xlist[i]=ixx-1;
	451	Ylist[i++]=iY-1;
	452	} else {
	453	Xlist[i]=ixx+1;
	454	Ylist[i++]=iY-1;
	455	}
	456	*/
	457	}
	458	*Nlist=i;
	459	}
	460
c3eff6ad	461	void AliMUONSegmentationV01::GiveTestPoints(Int_t &n, Float_t x, Float_t y) const
a9e2aefa	462	{
	463	// Returns test point on the pad plane.
	464	// Used during determination of the segmoid correction of the COG-method
	465
	466	n=3;
c3eff6ad	467	x[0]=((fRSec)[0]+(fRSec)[1])/2/TMath::Sqrt(2.);
a9e2aefa	468	y[0]=x[0];
c3eff6ad	469	x[1]=((fRSec)[1]+(fRSec)[2])/2/TMath::Sqrt(2.);
a9e2aefa	470	y[1]=x[1];
c3eff6ad	471	x[2]=((fRSec)[2]+(fRSec)[3])/2/TMath::Sqrt(2.);
a9e2aefa	472	y[2]=x[2];
	473	}
	474
c3eff6ad	475	void AliMUONSegmentationV01::Draw(const char *) const
a9e2aefa	476	{
	477	// Draws the segmentation zones
	478	//
	479	TBox *box;
	480
	481	Float_t dx=0.95/fCx[3][1]/2;
	482	Float_t dy=0.95/(Float_t(Npy()))/2;
	483	Float_t x0,y0,x1,y1;
	484	Float_t xc=0.5;
	485	Float_t yc=0.5;
	486
	487	for (Int_t iy=1; iy<Npy(); iy++)
	488	{
	489	for (Int_t isec=0; isec<4; isec++) {
	490	if (isec==0) {
	491	x0=0;
	492	x1=fCx[isec][iy]*dx;
	493	} else {
	494	x0=fCx[isec-1][iy]*dx;
	495	x1=fCx[isec][iy]*dx;
	496	}
	497	y0=Float_t(iy-1)*dy;
	498	y1=y0+dy;
	499	box=new TBox(x0+xc,y0+yc,x1+xc,y1+yc);
	500	box->SetFillColor(isec+1);
	501	box->Draw();
	502
	503	box=new TBox(-x1+xc,y0+yc,-x0+xc,y1+yc);
	504	box->SetFillColor(isec+1);
	505	box->Draw();
	506
	507	box=new TBox(x0+xc,-y1+yc,x1+xc,-y0+yc);
	508	box->SetFillColor(isec+1);
	509	box->Draw();
	510
	511	box=new TBox(-x1+xc,-y1+yc,-x0+xc,-y0+yc);
	512	box->SetFillColor(isec+1);
	513	box->Draw();
	514	}
	515	}
	516	}
	517	void AliMUONSegmentationV01::SetCorrFunc(Int_t isec, TF1* func)
	518	{
	519	(*fCorr)[isec]=func;
	520	}
	521
c3eff6ad	522	TF1* AliMUONSegmentationV01::CorrFunc(Int_t isec) const
a9e2aefa	523	{
	524	return (TF1) (fCorr)[isec];
	525	}
	526
	527	AliMUONSegmentationV01& AliMUONSegmentationV01::operator
	528	=(const AliMUONSegmentationV01 & rhs)
	529	{
	530	// Dummy assignment operator
	531	return *this;
	532	}