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

//------------------------------------------------------------------
void AliMUONSegmentationTriggerY::Init(Int_t chamber)
{
// intialize Y segmentation 
  cout << "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::GetPadIxy(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::GetPadCxy(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[2], Int_t Ylist[2]){
// Returns list of next neighbours for given Pad (ix, iy)  
  Int_t absiX=TMath::Abs(iX); 
  *Nlist = 0;
  
  if (absiX!=0) {                         
    Int_t numModule=ModuleNumber(absiX);
    
    if (iY==AliMUONTriggerConstants::NstripY(numModule)-1) { // strip right 
      if (absiX%10!=7) {
	*Nlist=1;
	Xlist[0]=absiX+1;
	Ylist[0]=0;
      } 
    } else {
      *Nlist=1;
      Xlist[0]=absiX;
      Ylist[0]=iY+1;
    }
    
    if (iY==0) {                                            // strip left 
      if (absiX%10!=1&&absiX!=52) {
	*Nlist=*Nlist+1;
	Xlist[*Nlist-1]=absiX-1;
	Ylist[*Nlist-1]=AliMUONTriggerConstants::NstripY(numModule-1)-1;
      } 
    } else {
      *Nlist=*Nlist+1;
      Xlist[*Nlist-1]=absiX;
      Ylist[*Nlist-1]=iY-1;
    }
    
    if (iX<0) {                                  // left side of chamber 
      for (Int_t i=0; i<*Nlist; i++) {Xlist[i]=-Xlist[i];}
    }
  }     
}

//------------------------------------------------------------------   
void AliMUONSegmentationTriggerY::SetPad(Int_t ix, Int_t iy)
{
  // Sets virtual pad coordinates, needed for evaluating pad response 
  // outside the tracking program 
  GetPadCxy(ix,iy,fx,fy);
  GetPadIxy(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)
{ 
// 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)
{ 
// 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& width) 
{ 
// returns quantities needed to evaluate neighbour strip response
  Int_t ix,iy;
  Float_t xstrip,ystrip;
  GetPadIxy(fxhit,fyhit,ix,iy);  
  GetPadCxy(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 
}
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$
d81db581	18	Revision 1.3 2000/06/26 10:01:26 pcrochet
	19	global variables removed
	20
3f2cdba8	21	Revision 1.2 2000/06/15 07:58:48 morsch
	22	Code from MUON-dev joined
	23
a9e2aefa	24	Revision 1.1.2.1 2000/06/09 21:51:58 morsch
	25	Code from AliMUONSegResTriggerY.cxx
	26
	27	*/
	28
3f2cdba8	29
a9e2aefa	30	/*
	31	Old Log:
	32	Revision 1.1.2.4 2000/05/05 10:17:04 morsch
	33	Y strip numerotation changed (CP)
	34
	35	Revision 1.1.2.3 2000/04/26 12:33:40 morsch
	36	Minor changes in some methods (CP)
	37
	38	Revision 1.1.2.2 2000/02/20 07:49:50 morsch
	39	Bugs in Dpx, Dpy and ISector methods corrected (P.C.)
	40
	41	Revision 1.1.2.1 2000/02/17 14:34:57 morsch
	42	Draft version from P. Crochet
	43
	44	*/
	45
	46	#include "AliMUONSegmentationTriggerY.h"
3f2cdba8	47	#include "AliMUONTriggerConstants.h"
a9e2aefa	48	#include "TMath.h"
	49	#include "TRandom.h"
	50	#include "TArc.h"
	51	#include "AliMUONChamber.h"
	52	#include <iostream.h>
	53	ClassImp(AliMUONSegmentationTriggerY)
	54
3f2cdba8	55	//------------------------------------------------------------------
d81db581	56	void AliMUONSegmentationTriggerY::Init(Int_t chamber)
a9e2aefa	57	{
3f2cdba8	58	// intialize Y segmentation
a9e2aefa	59	cout << "Initialize Trigger Chamber Geometry Y " << "\n";
d81db581	60	AliMUONSegmentationTrigger::Init(chamber);
a9e2aefa	61
a9e2aefa	62	// calculate x & y position of Y strips
3f2cdba8	63	Int_t nModule=AliMUONTriggerConstants::Nmodule();
	64	for (Int_t imodule=0; imodule<nModule; imodule++) {
	65	Float_t width=StripSizeY(AliMUONTriggerConstants::ModuleId(imodule));
	66	Int_t nStrip=AliMUONTriggerConstants::NstripY(imodule);
	67	for (Int_t istrip=0; istrip<nStrip; istrip++){
a9e2aefa	68	if (imodule<63) {
3f2cdba8	69	fXofysmin[imodule][istrip]=
	70	(AliMUONTriggerConstants::XcMin(imodule)+width(istrip))fZscale;
	71	fXofysmax[imodule][istrip]=
	72	(AliMUONTriggerConstants::XcMin(imodule)+width(istrip+1))fZscale;
a9e2aefa	73	} else {
	74	fXofysmin[imodule][istrip]=-1.*fXofysmax[imodule-63][istrip];
	75	fXofysmax[imodule][istrip]=-1.*fXofysmin[imodule-63][istrip];
	76	}
3f2cdba8	77	fYofysmin[imodule][istrip] = fYcmin[imodule]*fZscale;
3f2cdba8	78	fYofysmax[imodule][istrip] = fYcmax[imodule]*fZscale;
a9e2aefa	79	}
	80	}
	81
	82	}
	83
	84	//------------------------------------------------------------------
	85	void AliMUONSegmentationTriggerY::GetPadIxy(Float_t x,Float_t y,Int_t &ix,Int_t &iy){
	86	// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
	87	// x,y = real coordinates; ix = module number , iy = strip number
	88
	89	ix = 0;
	90	iy = 0;
3f2cdba8	91	Int_t nModule=AliMUONTriggerConstants::Nmodule();
	92	for (Int_t imodule=0; imodule<nModule; imodule++) {
	93	Int_t nStrip=AliMUONTriggerConstants::NstripY(imodule);
	94	for (Int_t istrip=0; istrip<nStrip; istrip++){
a9e2aefa	95	if (x>fXofysmin[imodule][istrip]&&x<fXofysmax[imodule][istrip]&&
a9e2aefa	96	y>fYofysmin[imodule][istrip]&&y<fYofysmax[imodule][istrip]){
3f2cdba8	97	ix = AliMUONTriggerConstants::ModuleId(imodule);
a9e2aefa	98	iy = istrip;
	99	}
	100	}
	101	}
	102	}
	103
	104	//------------------------------------------------------------------
	105	void AliMUONSegmentationTriggerY::GetPadCxy(Int_t ix, Int_t iy, Float_t &x, Float_t &y){
	106	// Returns real coordinates (x,y) for given pad coordinates (ix,iy)
	107	// ix = module number , iy = strip number; x,y = center of strip
	108	x = 0.;
	109	y = 0.;
3f2cdba8	110	Int_t nModule=AliMUONTriggerConstants::Nmodule();
	111	for (Int_t imodule=0; imodule<nModule; imodule++) {
	112	if (AliMUONTriggerConstants::ModuleId(imodule)==ix){
a9e2aefa	113	x=fXofysmin[imodule][iy]+(fXofysmax[imodule][iy]-fXofysmin[imodule][iy])/2.;
	114	y=fYofysmin[imodule][iy]+(fYofysmax[imodule][iy]-fYofysmin[imodule][iy])/2.;
	115	}
	116	}
	117	}
	118
	119	//------------------------------------------------------------------
	120	void AliMUONSegmentationTriggerY::SetPadSize(Float_t p1, Float_t p2)
	121	{
	122	// Sets the padsize
	123	//
	124	fDpx=p1;
	125	fDpy=p2;
	126	}
	127
	128	//------------------------------------------------------------------
	129	void AliMUONSegmentationTriggerY::
	130	Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[2], Int_t Ylist[2]){
	131	// Returns list of next neighbours for given Pad (ix, iy)
	132	Int_t absiX=TMath::Abs(iX);
	133	*Nlist = 0;
	134
	135	if (absiX!=0) {
	136	Int_t numModule=ModuleNumber(absiX);
	137
3f2cdba8	138	if (iY==AliMUONTriggerConstants::NstripY(numModule)-1) { // strip right
a9e2aefa	139	if (absiX%10!=7) {
	140	*Nlist=1;
	141	Xlist[0]=absiX+1;
	142	Ylist[0]=0;
	143	}
	144	} else {
	145	*Nlist=1;
	146	Xlist[0]=absiX;
	147	Ylist[0]=iY+1;
	148	}
	149
	150	if (iY==0) { // strip left
	151	if (absiX%10!=1&&absiX!=52) {
	152	Nlist=Nlist+1;
	153	Xlist[*Nlist-1]=absiX-1;
3f2cdba8	154	Ylist[*Nlist-1]=AliMUONTriggerConstants::NstripY(numModule-1)-1;
a9e2aefa	155	}
	156	} else {
	157	Nlist=Nlist+1;
	158	Xlist[*Nlist-1]=absiX;
	159	Ylist[*Nlist-1]=iY-1;
	160	}
	161
	162	if (iX<0) { // left side of chamber
	163	for (Int_t i=0; i<*Nlist; i++) {Xlist[i]=-Xlist[i];}
	164	}
	165	}
	166	}
	167
	168	//------------------------------------------------------------------
	169	void AliMUONSegmentationTriggerY::SetPad(Int_t ix, Int_t iy)
	170	{
	171	// Sets virtual pad coordinates, needed for evaluating pad response
	172	// outside the tracking program
	173	GetPadCxy(ix,iy,fx,fy);
	174	GetPadIxy(fx,fy,fix,fiy);
	175	fSector=Sector(ix,iy);
	176	}
	177
	178	//------------------------------------------------------------------
	179	Int_t AliMUONSegmentationTriggerY::ISector()
	180	{ return fSector;}
	181
	182	//------------------------------------------------------------------
	183	Int_t AliMUONSegmentationTriggerY::Ix()
	184	{ return fix;}
	185
	186	//------------------------------------------------------------------
	187	Int_t AliMUONSegmentationTriggerY::Iy()
	188	{ return fiy;}
	189
	190	//------------------------------------------------------------------
	191	Float_t AliMUONSegmentationTriggerY::Dpx(Int_t isec)
3f2cdba8	192	{
3f2cdba8	193	// returns x size of y strips for sector isec
a9e2aefa	194	if (isec==1) {
	195	return 2.125*fZscale;
	196	} else if (isec==2) {
	197	return 2.125*fZscale;
	198	} else if (isec==3) {
	199	return 2.125*fZscale;
	200	} else if (isec==4) {
	201	return 4.25*fZscale;
	202	} else {
	203	return 0.;
	204	}
	205	}
	206
	207	//------------------------------------------------------------------
	208	Float_t AliMUONSegmentationTriggerY::Dpy(Int_t isec)
3f2cdba8	209	{
3f2cdba8	210	// returns y size of y strips for sector isec
a9e2aefa	211	if (isec==1) {
	212	return 68.0*fZscale;
	213	} else if (isec==2) {
	214	return 51.0*fZscale;
	215	} else if (isec==3) {
	216	return 68.0*fZscale;
	217	} else if (isec==4) {
	218	return 68.0*fZscale;
	219	} else if (isec==5) {
	220	return 68.0*fZscale;
	221	} else {
	222	return 0.;
	223	}
	224
	225	}
	226
	227	//------------------------------------------------------------------
	228	void AliMUONSegmentationTriggerY::SetHit(Float_t xhit, Float_t yhit)
3f2cdba8	229	{
	230	// set hits during diintegration
	231	AliMUONSegmentationTrigger::SetHit(xhit,yhit);
	232	}
a9e2aefa	233
	234	//------------------------------------------------------------------
	235	Int_t AliMUONSegmentationTriggerY::Sector(Int_t ix, Int_t iy)
	236	{
	237	// Returns sector number for given module
	238	//
	239	Int_t absix=TMath::Abs(ix);
	240	Int_t iwidth=Int_t(StripSizeY(absix));
3f2cdba8	241
a9e2aefa	242	if (absix==52) {
	243	return 1;
	244	} else if (absix==41\|\|absix==61) {
	245	return 2;
	246	} else if (iwidth==2) {
	247	return 3;
	248	} else if (iwidth==4) {
	249	return 4;
	250	} else {
	251	return 0;
	252	}
	253	}
	254
	255	//------------------------------------------------------------------
	256	void AliMUONSegmentationTriggerY::
	257	IntegrationLimits(Float_t& x1, Float_t& x2, Float_t& x3, Float_t& width)
	258	{
	259	// returns quantities needed to evaluate neighbour strip response
	260	Int_t ix,iy;
	261	Float_t xstrip,ystrip;
	262	GetPadIxy(fxhit,fyhit,ix,iy);
	263	GetPadCxy(ix,iy,xstrip,ystrip);
	264	x1=fxhit; // hit x position
	265	x2=xstrip; // x coordinate of the main strip
	266	x3=fx; // current strip real x coordinate
	267	width=StripSizeY(ix); // width of the main strip
	268	}
	269
	270
	271
	272