[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.10  2002/10/23 07:24:56  alibrary
Introducing Riostream.h

Revision 1.9  2001/05/16 14:57:17  alibrary
New files for folders and Stack

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 <Riostream.h> 
ClassImp(AliMUONSegmentationTriggerY)

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