[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.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.Set(fNsec);    
    fNDiv.Set(fNsec);      
    fDpxD.Set(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
   return fDpxD.At(isec);
}

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