[u/mrichter/AliRoot.git] / MUON / AliMUONSegmentationTriggerY.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  2000/11/20 21:44:17  pcrochet
some modifications to account for the new class AliMUONResponseTriggerV1

Revision 1.7  2000/10/03 21:48:07  morsch
Adopt to const declaration of some of the methods in AliSegmentation.

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/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.4  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.3  2000/06/26 10:01:26  pcrochet
global variables removed

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

Revision 1.1.2.1  2000/06/09 21:51:58  morsch
Code from AliMUONSegResTriggerY.cxx

*/


/*
Old Log:
Revision 1.1.2.4  2000/05/05 10:17:04  morsch
Y strip numerotation changed (CP)

Revision 1.1.2.3  2000/04/26 12:33:40  morsch
Minor changes in some methods (CP)

Revision 1.1.2.2  2000/02/20 07:49:50  morsch
Bugs in Dpx, Dpy and ISector methods corrected (P.C.)

Revision 1.1.2.1  2000/02/17 14:34:57  morsch
Draft version from P. Crochet

*/

#include "AliMUONSegmentationTriggerY.h"
#include "AliMUONTriggerConstants.h"
#include "TMath.h"
#include "TRandom.h"
#include "TArc.h"
#include "AliMUONChamber.h"
#include "AliMUON.h"
#include "AliRun.h"
#include <iostream.h> 
ClassImp(AliMUONSegmentationTriggerY)

//------------------------------------------------------------------
void AliMUONSegmentationTriggerY::Init(Int_t chamber)
{
// intialize Y segmentation 
  AliMUON *pMUON  = (AliMUON *) gAlice->GetModule("MUON");
  if(pMUON->GetDebug()) cout << ClassName() <<": Initialize Trigger Chamber Geometry Y " << "\n";    
  AliMUONSegmentationTrigger::Init(chamber);
    
// calculate x & y position of Y strips
  Int_t nModule=AliMUONTriggerConstants::Nmodule();  
  for (Int_t imodule=0; imodule<nModule; imodule++) {    
    Float_t width=StripSizeY(AliMUONTriggerConstants::ModuleId(imodule));
    Int_t nStrip=AliMUONTriggerConstants::NstripY(imodule);    
    for (Int_t istrip=0; istrip<nStrip; istrip++){
      if (imodule<63) {
	fXofysmin[imodule][istrip]=
	    (AliMUONTriggerConstants::XcMin(imodule)+width*(istrip))*fZscale;
	fXofysmax[imodule][istrip]=
	    (AliMUONTriggerConstants::XcMin(imodule)+width*(istrip+1))*fZscale;
      } else {	
	fXofysmin[imodule][istrip]=-1.*fXofysmax[imodule-63][istrip];
	fXofysmax[imodule][istrip]=-1.*fXofysmin[imodule-63][istrip];
      }      
      fYofysmin[imodule][istrip] = fYcmin[imodule]*fZscale;
      fYofysmax[imodule][istrip] = fYcmax[imodule]*fZscale;
    }
  }

}

//------------------------------------------------------------------
void AliMUONSegmentationTriggerY::GetPadI(Float_t x,Float_t y,Int_t &ix,Int_t &iy) 
{
//  Returns pad coordinates (ix,iy) for given real coordinates (x,y)
//  x,y = real coordinates; ix = module number , iy = strip number

  ix = 0;    
  iy = 0;
  Int_t nModule=AliMUONTriggerConstants::Nmodule();
  for (Int_t imodule=0; imodule<nModule; imodule++) {
      Int_t nStrip=AliMUONTriggerConstants::NstripY(imodule);      
    for (Int_t istrip=0; istrip<nStrip; istrip++){
      if (x>fXofysmin[imodule][istrip]&&x<fXofysmax[imodule][istrip]&&
	  y>fYofysmin[imodule][istrip]&&y<fYofysmax[imodule][istrip]){
	ix = AliMUONTriggerConstants::ModuleId(imodule);
	iy = istrip;
      }
    }
  }
}

//------------------------------------------------------------------
void AliMUONSegmentationTriggerY::GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
{
//  Returns real coordinates (x,y) for given pad coordinates (ix,iy)
//  ix = module number , iy = strip number;  x,y = center of strip
  x = 0.;    
  y = 0.;
  Int_t nModule=AliMUONTriggerConstants::Nmodule();
  for (Int_t imodule=0; imodule<nModule; imodule++) {
    if (AliMUONTriggerConstants::ModuleId(imodule)==ix){
      x=fXofysmin[imodule][iy]+(fXofysmax[imodule][iy]-fXofysmin[imodule][iy])/2.;
      y=fYofysmin[imodule][iy]+(fYofysmax[imodule][iy]-fYofysmin[imodule][iy])/2.;
    }
  }
}

//------------------------------------------------------------------
void AliMUONSegmentationTriggerY::SetPadSize(Float_t p1, Float_t p2)
{
//  Sets the padsize 
//  
  fDpx=p1;
  fDpy=p2;
}

//------------------------------------------------------------------
void AliMUONSegmentationTriggerY::
Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10]){
// Returns list of 10 next neighbours for given Y strip (ix, iy)  
// neighbour number 9 8 7 6 5 (Y strip (ix, iy)) 0 1 2 3 4 in the list
//                  \_______/                    \_______/
//                    left                         right  
// Note : should not be used to return a list of neighbours larger than 16 !

  Int_t absiX = TMath::Abs(iX); 
  Int_t numModule = ModuleNumber(absiX);   // module number Id.
  Int_t nStrip = AliMUONTriggerConstants::NstripY(numModule); //numb of strips
  Int_t iCandidateLeft, iCandidateRight;
  Int_t iNewCandidateRight=0; 
  Int_t iNewCandidateLeft=0;
// first strip number on the right of the left module  
  if ( (absiX-(Int_t(absiX/10))*10)!=1 && absiX!=52 ) 
    iNewCandidateLeft = 
      AliMUONTriggerConstants::NstripY(ModuleNumber(absiX-1))-1;
  Int_t j;
  
  *Nlist = 10;
  for (Int_t i=0; i<10; i++) Xlist[i]=Ylist[i]=0;

  if (iY < nStrip) {

    for (Int_t i=0; i<5; i++) {
      j = i + 5;
      iCandidateRight = iY + (i + 1);
      iCandidateLeft  = iY - (i + 1);
      if (iCandidateRight < nStrip) { // strip in same module  
	Xlist[i] = absiX;
	Ylist[i] = iCandidateRight;  
      } else if ((absiX+1)%10!=8) {   // need to scan the module on the right
	Xlist[i] = absiX+1;
	Ylist[i] = iNewCandidateRight;  
	iNewCandidateRight++;
      }
      
      if (iCandidateLeft >=0 ) { // strip in same module
	Xlist[j] = absiX;
	Ylist[j] = iCandidateLeft;  
      } else if ( iNewCandidateLeft !=0) {
	Xlist[j] = absiX-1;
	Ylist[j] = iNewCandidateLeft;  
	iNewCandidateLeft--;
      }
    }
    
    if (iX<0) {                                  // left side of chamber 
      for (Int_t i=0; i<10; i++) { 
	if (Xlist[i]!=0) Xlist[i]=-Xlist[i]; 
      }
    }
    
  } // iY < nStrip    
}

//------------------------------------------------------------------   
void AliMUONSegmentationTriggerY::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);
  GetPadI(fX,fY,fIx,fIy);
  fSector=Sector(ix,iy);    
}

//------------------------------------------------------------------   
Int_t AliMUONSegmentationTriggerY::ISector() 
{ return fSector;}

//------------------------------------------------------------------   

Int_t AliMUONSegmentationTriggerY::Ix()
{ return fIx;}

//------------------------------------------------------------------   

Int_t AliMUONSegmentationTriggerY::Iy()
{ return fIy;}

//------------------------------------------------------------------
Float_t AliMUONSegmentationTriggerY::Dpx(Int_t isec) const
{ 
// returns x size of y strips for sector isec
  if (isec==1) {
    return 2.125*fZscale;
  } else if (isec==2) {
    return 2.125*fZscale;
  } else if (isec==3) {
    return 2.125*fZscale;
  } else if (isec==4) {
    return 4.25*fZscale;
  } else {
    return 0.;	
  }       
}

//------------------------------------------------------------------
Float_t AliMUONSegmentationTriggerY::Dpy(Int_t isec) const
{ 
// returns y size of y strips for sector isec
  if (isec==1) {
    return 68.0*fZscale;
  } else if (isec==2) {
    return 51.0*fZscale;
  } else if (isec==3) {
    return 68.0*fZscale;
  } else if (isec==4) {
    return 68.0*fZscale;
  } else if (isec==5) {
    return 68.0*fZscale;
  } else {
    return 0.;
  }

}

//------------------------------------------------------------------   
void AliMUONSegmentationTriggerY::SetHit(Float_t xhit, Float_t yhit)
{ 
// set hits during diintegration
  AliMUONSegmentationTrigger::SetHit(xhit,yhit);
}

//------------------------------------------------------------------   
Int_t AliMUONSegmentationTriggerY::Sector(Int_t ix, Int_t iy)
{
// Returns sector number for given module
// 
  Int_t absix=TMath::Abs(ix);
  Int_t iwidth=Int_t(StripSizeY(absix));

  if (absix==52) {
    return 1;
  } else if (absix==41||absix==61) {
    return 2;
  } else if (iwidth==2) {
    return 3;
  } else if (iwidth==4) {
    return 4;
  } else {
    return 0;
  }
}

//------------------------------------------------------------------   
void AliMUONSegmentationTriggerY::
IntegrationLimits(Float_t& x1, Float_t& x2, Float_t& x3, Float_t& x4) 
{ 
// returns quantities needed to evaluate neighbour strip response
  Int_t ix,iy;
  Float_t xstrip,ystrip;
  GetPadI(fXhit,fYhit,ix,iy);  
  GetPadC(ix,iy,xstrip,ystrip);  
  x1=fXhit;        // hit x position
  x2=xstrip;       // x coordinate of the main strip
  x3=fX;           // current strip real x coordinate  
  //  width=StripSizeY(ix);   // width of the main strip 

  // find the position of the 2 borders of the current strip
  Float_t xmin = fXofysmin[ModuleNumber(fIx)][fIy];
  Float_t xmax = fXofysmax[ModuleNumber(fIx)][fIy];

  // dist. between the hit and the closest border of the current strip
  x4 = (TMath::Abs(xmax-x1) > TMath::Abs(xmin-x1)) ? 
    TMath::Abs(xmin-x1):TMath::Abs(xmax-x1);    

}
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$
9e1a0ddb	18	Revision 1.8 2000/11/20 21:44:17 pcrochet
	19	some modifications to account for the new class AliMUONResponseTriggerV1
	20
03f221a7	21	Revision 1.7 2000/10/03 21:48:07 morsch
	22	Adopt to const declaration of some of the methods in AliSegmentation.
	23
c3eff6ad	24	Revision 1.6 2000/10/02 16:58:29 egangler
	25	Cleaning of the code :
	26	-> coding conventions
	27	-> void Streamers
	28	-> some useless includes removed or replaced by "class" statement
	29
ecfa008b	30	Revision 1.5 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.4 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.3 2000/06/26 10:01:26 pcrochet
	41	global variables removed
	42
3f2cdba8	43	Revision 1.2 2000/06/15 07:58:48 morsch
	44	Code from MUON-dev joined
	45
a9e2aefa	46	Revision 1.1.2.1 2000/06/09 21:51:58 morsch
	47	Code from AliMUONSegResTriggerY.cxx
	48
	49	*/
	50
3f2cdba8	51
a9e2aefa	52	/*
	53	Old Log:
	54	Revision 1.1.2.4 2000/05/05 10:17:04 morsch
	55	Y strip numerotation changed (CP)
	56
	57	Revision 1.1.2.3 2000/04/26 12:33:40 morsch
	58	Minor changes in some methods (CP)
	59
	60	Revision 1.1.2.2 2000/02/20 07:49:50 morsch
	61	Bugs in Dpx, Dpy and ISector methods corrected (P.C.)
	62
	63	Revision 1.1.2.1 2000/02/17 14:34:57 morsch
	64	Draft version from P. Crochet
	65
	66	*/
	67
	68	#include "AliMUONSegmentationTriggerY.h"
3f2cdba8	69	#include "AliMUONTriggerConstants.h"
a9e2aefa	70	#include "TMath.h"
	71	#include "TRandom.h"
	72	#include "TArc.h"
	73	#include "AliMUONChamber.h"
9e1a0ddb	74	#include "AliMUON.h"
9e1a0ddb	75	#include "AliRun.h"
a9e2aefa	76	#include <iostream.h>
	77	ClassImp(AliMUONSegmentationTriggerY)
	78
3f2cdba8	79	//------------------------------------------------------------------
d81db581	80	void AliMUONSegmentationTriggerY::Init(Int_t chamber)
a9e2aefa	81	{
3f2cdba8	82	// intialize Y segmentation
9e1a0ddb	83	AliMUON pMUON = (AliMUON ) gAlice->GetModule("MUON");
9e1a0ddb	84	if(pMUON->GetDebug()) cout << ClassName() <<": Initialize Trigger Chamber Geometry Y " << "\n";
d81db581	85	AliMUONSegmentationTrigger::Init(chamber);
a9e2aefa	86
a9e2aefa	87	// calculate x & y position of Y strips
3f2cdba8	88	Int_t nModule=AliMUONTriggerConstants::Nmodule();
	89	for (Int_t imodule=0; imodule<nModule; imodule++) {
	90	Float_t width=StripSizeY(AliMUONTriggerConstants::ModuleId(imodule));
	91	Int_t nStrip=AliMUONTriggerConstants::NstripY(imodule);
	92	for (Int_t istrip=0; istrip<nStrip; istrip++){
a9e2aefa	93	if (imodule<63) {
3f2cdba8	94	fXofysmin[imodule][istrip]=
	95	(AliMUONTriggerConstants::XcMin(imodule)+width(istrip))fZscale;
	96	fXofysmax[imodule][istrip]=
	97	(AliMUONTriggerConstants::XcMin(imodule)+width(istrip+1))fZscale;
a9e2aefa	98	} else {
	99	fXofysmin[imodule][istrip]=-1.*fXofysmax[imodule-63][istrip];
	100	fXofysmax[imodule][istrip]=-1.*fXofysmin[imodule-63][istrip];
	101	}
3f2cdba8	102	fYofysmin[imodule][istrip] = fYcmin[imodule]*fZscale;
3f2cdba8	103	fYofysmax[imodule][istrip] = fYcmax[imodule]*fZscale;
a9e2aefa	104	}
	105	}
	106
	107	}
	108
	109	//------------------------------------------------------------------
c3eff6ad	110	void AliMUONSegmentationTriggerY::GetPadI(Float_t x,Float_t y,Int_t &ix,Int_t &iy)
c3eff6ad	111	{
a9e2aefa	112	// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
	113	// x,y = real coordinates; ix = module number , iy = strip number
	114
	115	ix = 0;
	116	iy = 0;
3f2cdba8	117	Int_t nModule=AliMUONTriggerConstants::Nmodule();
	118	for (Int_t imodule=0; imodule<nModule; imodule++) {
	119	Int_t nStrip=AliMUONTriggerConstants::NstripY(imodule);
	120	for (Int_t istrip=0; istrip<nStrip; istrip++){
a9e2aefa	121	if (x>fXofysmin[imodule][istrip]&&x<fXofysmax[imodule][istrip]&&
a9e2aefa	122	y>fYofysmin[imodule][istrip]&&y<fYofysmax[imodule][istrip]){
3f2cdba8	123	ix = AliMUONTriggerConstants::ModuleId(imodule);
a9e2aefa	124	iy = istrip;
	125	}
	126	}
	127	}
	128	}
	129
	130	//------------------------------------------------------------------
c3eff6ad	131	void AliMUONSegmentationTriggerY::GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
c3eff6ad	132	{
a9e2aefa	133	// Returns real coordinates (x,y) for given pad coordinates (ix,iy)
	134	// ix = module number , iy = strip number; x,y = center of strip
	135	x = 0.;
	136	y = 0.;
3f2cdba8	137	Int_t nModule=AliMUONTriggerConstants::Nmodule();
	138	for (Int_t imodule=0; imodule<nModule; imodule++) {
	139	if (AliMUONTriggerConstants::ModuleId(imodule)==ix){
a9e2aefa	140	x=fXofysmin[imodule][iy]+(fXofysmax[imodule][iy]-fXofysmin[imodule][iy])/2.;
	141	y=fYofysmin[imodule][iy]+(fYofysmax[imodule][iy]-fYofysmin[imodule][iy])/2.;
	142	}
	143	}
	144	}
	145
	146	//------------------------------------------------------------------
	147	void AliMUONSegmentationTriggerY::SetPadSize(Float_t p1, Float_t p2)
	148	{
	149	// Sets the padsize
	150	//
	151	fDpx=p1;
	152	fDpy=p2;
	153	}
	154
	155	//------------------------------------------------------------------
	156	void AliMUONSegmentationTriggerY::
03f221a7	157	Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10]){
	158	// Returns list of 10 next neighbours for given Y strip (ix, iy)
	159	// neighbour number 9 8 7 6 5 (Y strip (ix, iy)) 0 1 2 3 4 in the list
	160	// \_______/ \_______/
	161	// left right
	162	// Note : should not be used to return a list of neighbours larger than 16 !
	163
	164	Int_t absiX = TMath::Abs(iX);
	165	Int_t numModule = ModuleNumber(absiX); // module number Id.
	166	Int_t nStrip = AliMUONTriggerConstants::NstripY(numModule); //numb of strips
	167	Int_t iCandidateLeft, iCandidateRight;
	168	Int_t iNewCandidateRight=0;
	169	Int_t iNewCandidateLeft=0;
	170	// first strip number on the right of the left module
	171	if ( (absiX-(Int_t(absiX/10))*10)!=1 && absiX!=52 )
	172	iNewCandidateLeft =
	173	AliMUONTriggerConstants::NstripY(ModuleNumber(absiX-1))-1;
	174	Int_t j;
a9e2aefa	175
03f221a7	176	*Nlist = 10;
	177	for (Int_t i=0; i<10; i++) Xlist[i]=Ylist[i]=0;
	178
	179	if (iY < nStrip) {
	180
	181	for (Int_t i=0; i<5; i++) {
	182	j = i + 5;
	183	iCandidateRight = iY + (i + 1);
	184	iCandidateLeft = iY - (i + 1);
	185	if (iCandidateRight < nStrip) { // strip in same module
	186	Xlist[i] = absiX;
	187	Ylist[i] = iCandidateRight;
	188	} else if ((absiX+1)%10!=8) { // need to scan the module on the right
	189	Xlist[i] = absiX+1;
	190	Ylist[i] = iNewCandidateRight;
	191	iNewCandidateRight++;
	192	}
	193
	194	if (iCandidateLeft >=0 ) { // strip in same module
	195	Xlist[j] = absiX;
	196	Ylist[j] = iCandidateLeft;
	197	} else if ( iNewCandidateLeft !=0) {
	198	Xlist[j] = absiX-1;
	199	Ylist[j] = iNewCandidateLeft;
	200	iNewCandidateLeft--;
	201	}
a9e2aefa	202	}
	203
	204	if (iX<0) { // left side of chamber
03f221a7	205	for (Int_t i=0; i<10; i++) {
	206	if (Xlist[i]!=0) Xlist[i]=-Xlist[i];
	207	}
a9e2aefa	208	}
03f221a7	209
03f221a7	210	} // iY < nStrip
a9e2aefa	211	}
	212
	213	//------------------------------------------------------------------
	214	void AliMUONSegmentationTriggerY::SetPad(Int_t ix, Int_t iy)
	215	{
	216	// Sets virtual pad coordinates, needed for evaluating pad response
	217	// outside the tracking program
ecfa008b	218	GetPadC(ix,iy,fX,fY);
ecfa008b	219	GetPadI(fX,fY,fIx,fIy);
a9e2aefa	220	fSector=Sector(ix,iy);
	221	}
	222
	223	//------------------------------------------------------------------
c3eff6ad	224	Int_t AliMUONSegmentationTriggerY::ISector()
a9e2aefa	225	{ return fSector;}
	226
	227	//------------------------------------------------------------------
c3eff6ad	228
a9e2aefa	229	Int_t AliMUONSegmentationTriggerY::Ix()
ecfa008b	230	{ return fIx;}
a9e2aefa	231
a9e2aefa	232	//------------------------------------------------------------------
c3eff6ad	233
a9e2aefa	234	Int_t AliMUONSegmentationTriggerY::Iy()
ecfa008b	235	{ return fIy;}
a9e2aefa	236
a9e2aefa	237	//------------------------------------------------------------------
c3eff6ad	238	Float_t AliMUONSegmentationTriggerY::Dpx(Int_t isec) const
3f2cdba8	239	{
3f2cdba8	240	// returns x size of y strips for sector isec
a9e2aefa	241	if (isec==1) {
	242	return 2.125*fZscale;
	243	} else if (isec==2) {
	244	return 2.125*fZscale;
	245	} else if (isec==3) {
	246	return 2.125*fZscale;
	247	} else if (isec==4) {
	248	return 4.25*fZscale;
	249	} else {
	250	return 0.;
	251	}
	252	}
	253
	254	//------------------------------------------------------------------
c3eff6ad	255	Float_t AliMUONSegmentationTriggerY::Dpy(Int_t isec) const
3f2cdba8	256	{
3f2cdba8	257	// returns y size of y strips for sector isec
a9e2aefa	258	if (isec==1) {
	259	return 68.0*fZscale;
	260	} else if (isec==2) {
	261	return 51.0*fZscale;
	262	} else if (isec==3) {
	263	return 68.0*fZscale;
	264	} else if (isec==4) {
	265	return 68.0*fZscale;
	266	} else if (isec==5) {
	267	return 68.0*fZscale;
	268	} else {
	269	return 0.;
	270	}
	271
	272	}
	273
	274	//------------------------------------------------------------------
	275	void AliMUONSegmentationTriggerY::SetHit(Float_t xhit, Float_t yhit)
3f2cdba8	276	{
3f2cdba8	277	// set hits during diintegration
03f221a7	278	AliMUONSegmentationTrigger::SetHit(xhit,yhit);
3f2cdba8	279	}
a9e2aefa	280
	281	//------------------------------------------------------------------
	282	Int_t AliMUONSegmentationTriggerY::Sector(Int_t ix, Int_t iy)
	283	{
	284	// Returns sector number for given module
	285	//
	286	Int_t absix=TMath::Abs(ix);
	287	Int_t iwidth=Int_t(StripSizeY(absix));
3f2cdba8	288
a9e2aefa	289	if (absix==52) {
	290	return 1;
	291	} else if (absix==41\|\|absix==61) {
	292	return 2;
	293	} else if (iwidth==2) {
	294	return 3;
	295	} else if (iwidth==4) {
	296	return 4;
	297	} else {
	298	return 0;
	299	}
	300	}
	301
	302	//------------------------------------------------------------------
	303	void AliMUONSegmentationTriggerY::
03f221a7	304	IntegrationLimits(Float_t& x1, Float_t& x2, Float_t& x3, Float_t& x4)
a9e2aefa	305	{
	306	// returns quantities needed to evaluate neighbour strip response
	307	Int_t ix,iy;
	308	Float_t xstrip,ystrip;
ecfa008b	309	GetPadI(fXhit,fYhit,ix,iy);
a30a000f	310	GetPadC(ix,iy,xstrip,ystrip);
ecfa008b	311	x1=fXhit; // hit x position
a9e2aefa	312	x2=xstrip; // x coordinate of the main strip
ecfa008b	313	x3=fX; // current strip real x coordinate
03f221a7	314	// width=StripSizeY(ix); // width of the main strip
	315
	316	// find the position of the 2 borders of the current strip
	317	Float_t xmin = fXofysmin[ModuleNumber(fIx)][fIy];
	318	Float_t xmax = fXofysmax[ModuleNumber(fIx)][fIy];
	319
	320	// dist. between the hit and the closest border of the current strip
	321	x4 = (TMath::Abs(xmax-x1) > TMath::Abs(xmin-x1)) ?
	322	TMath::Abs(xmin-x1):TMath::Abs(xmax-x1);
	323
a9e2aefa	324	}
	325
	326
	327
	328