[u/mrichter/AliRoot.git] / MUON / AliMUONsegmentv1.cxx

/////////////////////////////////////////////////////////
//  Manager and hits classes for set:MUON version 0    //
/////////////////////////////////////////////////////////

#include <TTUBE.h>
#include <TNode.h> 
#include <TRandom.h> 

#include "AliMUONv0.h"
#include "AliMUONsegmentv1.h"
#include "AliRun.h"
#include "AliMC.h"
#include "iostream.h"

//___________________________________________
ClassImp(AliMUONsegmentationV1)

AliMUONsegmentationV1::AliMUONsegmentationV1()
  // initizalize the class with default settings
{
fNzone=1;
fDAnod=0.0;
fDpx=0.0;
fDpx=0.0; // forces crash if not initialized by user
fNZoneCut[0]=0;
fSensOffset=0;
}


void AliMUONsegmentationV1::Init(AliMUONchamber* Chamber)
{
  // valid only for T5/6
  frSensMin2 = (Chamber->frMin + 6.)*(Chamber->frMin + 6.);
  frSensMax2 = (Chamber->frMax - 6.)*(Chamber->frMax - 6.);
  fNpx=(Int_t) (Chamber->frMax/fDpx) + 1;
  fNpy=(Int_t) (Chamber->frMax/fDpy) + 1;
  //    fNwire=3;
  DefaultCut();
}

void AliMUONsegmentationV1::DefaultCut(void)
{
SetNzone(3);
AddCut(0,7*6,18*8);
AddCut(0,10*6,15*8);
AddCut(0,12*6,12*8);
AddCut(0,13*6,9*8);
AddCut(0,14*6,6*8);
AddCut(1,8*6,21*12);
AddCut(1,12*6,18*12);
AddCut(1,16*6,15*12);
AddCut(1,18*6,12*12);
AddCut(1,20*6,9*12);
AddCut(1,22*6,6*12);
SetSensOffset(3.0);
SetDAnod(0.325);
}

Int_t AliMUONsegmentationV1::GetiAnod(Float_t xhit)
{
Int_t kwire=Int_t((TMath::Abs(xhit)-fSensOffset)/fDAnod)+1;
return (xhit>0) ? kwire : -kwire ;
}

Float_t AliMUONsegmentationV1::GetAnod(Float_t xhit)
{
  Int_t kwire=Int_t((TMath::Abs(xhit)-fSensOffset)/fDAnod)+1; // to be compatible ...
    return (xhit>0) ? fDAnod*(kwire-0.5)+fSensOffset : -fDAnod*(kwire-0.5)-fSensOffset ;
}

// For chamber T5/6 p1 and p2 should be same for each zone
void AliMUONsegmentationV1::SetPADSIZ(Float_t p1, Float_t p2)
{
  fDpx=p1;
  fDpy=p2;
}

void AliMUONsegmentationV1::
    GetPadIxy(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
{
//  returns pad coordinates (ix,iy) for given real coordinates (x,y)
//
    ix = (x>0)? Int_t((x-fSensOffset)/fDpx)+1 : Int_t((x+fSensOffset)/fDpx)-1;
    iy = (y>0)? Int_t((y-fSensOffset)/fDpy)+1 : Int_t((y+fSensOffset)/fDpy)-1;
}

void AliMUONsegmentationV1::
GetPadCxy(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
{
//  returns real coordinates (x,y) for given pad coordinates (ix,iy)
//
    x = (ix>0) ? (Float_t(ix)-0.5)*fDpx+fSensOffset : (Float_t(ix)+0.5)*fDpx-fSensOffset;
    y = (iy>0) ? (Float_t(iy)-0.5)*fDpy+fSensOffset : (Float_t(iy)+0.5)*fDpy-fSensOffset;
}

void AliMUONsegmentationV1::AddCut(Int_t Zone, Int_t nX, Int_t nY)
{// the pad nX,nY is last INSIDE zone Zone
if (Zone+1>=fNzone) // no cut for last Zone : it is the natural boundary of the chamber
  printf("AliMUONsegmentationV1::AddCut ==> Zone %d not allowed !\n",Zone);
fZoneX[Zone][fNZoneCut[Zone]] = nX;
fZoneY[Zone][fNZoneCut[Zone]] = nY;
fNZoneCut[Zone]++;
}

Int_t AliMUONsegmentationV1::GetZone(Float_t X, Float_t Y)
{
Int_t iX, iY;
GetPadIxy(X,Y,iX,iY);
return GetZone( iX , iY );
}

Int_t AliMUONsegmentationV1::GetZone(Int_t nX, Int_t nY)
{// Beware : first pad begins at 1 !!
Int_t aX =  TMath::Abs(nX);
Int_t aY =  TMath::Abs(nY);
Int_t zone=fNzone-1;
for (Int_t iZone=fNzone-2;iZone>=0;iZone--) 
  {
  for (Int_t iCut=0;iCut<fNZoneCut[iZone];iCut++)
    if ( aY<=fZoneY[iZone][iCut] && aX<=fZoneX[iZone][iCut] )
      {
      zone=iZone;
      break;
      } 
  }
return zone;
}


void AliMUONsegmentationV1::SetPadCoord(Int_t iX, Int_t iY)
{    
GetPadCxy(iX,iY,fx,fy);
Float_t radius2;
if ( ( (radius2=fx*fx+fy*fy) > frSensMax2 || radius2 < frSensMin2 ) 
     && MorePads() )
  NextPad();

}

void AliMUONsegmentationV1::FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy)
{
    //
    // Find the wire position (center of charge distribution)
    Float_t x0a=GetAnod(xhit);
    //
    // 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;

    // Do not cross over frames...
    if (x01 * x0a < 0) 
      x01 = TMath::Sign(fSensOffset, x0a);
    if (x02 * x0a < 0) 
      x02 = TMath::Sign(fSensOffset, x0a);
    if (y01 * yhit < 0) 
      y01 = TMath::Sign(fSensOffset, yhit);
    if (y02 * yhit < 0) 
      y02 = TMath::Sign(fSensOffset, yhit);
    //
    // find the pads over which the charge distributes
    GetPadIxy(x01,y01,fixmin,fiymin);
    GetPadIxy(x02,y02,fixmax,fiymax);
    
//  printf("\n FirstPad called");
//  printf("\n Hit Position %f %f",xhit,yhit);
//  printf("\n Integration limits: %i %i %i %i",fixmin,fixmax,fiymin,fiymax);
//  printf("\n Integration limits: %f %f %f %f \n",x01,x02,y01,y02);
    // 
    // Set current pad to lower left corner
    fix=fixmin;
    fiy=fiymin;
    SetPadCoord(fix,fiy);
}

void AliMUONsegmentationV1::NextPad()
{
  // 
  // Step to next pad in integration region
    if (fix != fixmax) {
	fix++;
    } else if (fiy != fiymax) {
	fix=fixmin;
	fiy++;
    } else 
	printf("\n Error: Stepping outside integration region\n ");
    SetPadCoord(fix,fiy);
}

Int_t AliMUONsegmentationV1::MorePads()
//
// Are there more pads in the integration region
{
    if (fix == fixmax && fiy == fiymax) {
	return 0;
    } else {
	return 1;	
    }
}

Int_t AliMUONsegmentationV1::Ix()
// returns the X number of pad which has to increment charge
// due to parallel read-out
{
Int_t wix = TMath::Abs(fix)-1;
Int_t wiy = TMath::Abs(fiy)-1;
Int_t zone = GetZone(fix,fiy);
switch (zone) {
 case 0: return fix;
 case 1:
   if ( wiy%3 !=1 && wix%6>2)
     return (fix>0)? fix-3 : fix+3 ;
   return fix;
 case 2:
   if ( (wiy%6 == 1 && wix%2 ==0) ||  (wiy%6 == 4 && wix%2 ==1))
     return fix;
   return fix>0? fix - ((wix%12)/4)*4 : fix + ((wix%12)/4)*4;
 default :
   printf("Couille dans AliMUONsegmentationV1::ix\n");
 }
return -1;
}

Int_t AliMUONsegmentationV1::ISector()
{
Int_t wix = TMath::Abs(fix)-1;
Int_t wiy = TMath::Abs(fiy)-1;
Int_t zone = GetZone(fix,fiy);
switch (zone) {
 case 0: return 0;
 case 1:
   if ( wiy%3 !=1 && wix%6>2)
     return 1 ;
   return 0;
 case 2:
   if ((wiy%6 == 1 && wix%2 ==0) ||  (wiy%6 == 4 && wix%2 ==1))
     return 0;
   return (wix%12)/4;
 default :
   printf("Couille dans AliMUONsegmentationV1::ISector\n");
 }
return -1;
}

void AliMUONsegmentationV1::SigGenInit(Float_t x,Float_t y,Float_t)
{
//
//  Initialises pad and wire position during stepping
    fxt =x;
    fyt =y;
    GetPadIxy(x,y,fixt,fiyt);
    fiwt= GetiAnod(x);

}

Int_t AliMUONsegmentationV1::SigGenCond(Float_t x,Float_t y,Float_t)
{
//
//  Signal will be generated if particle crosses pad boundary or
//  boundary between two wires. 
    Int_t ixt;
    Int_t iyt;
    GetPadIxy(x,y,ixt,iyt);
    Int_t iwt= GetiAnod(x);
    
    if ((ixt != fixt) || (iyt !=fiyt) || (iwt != fiwt)) {
	return 1;
    } else {
	return 0;
    }
}

void AliMUONsegmentationV1::
IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
{
    x1=fxt-fx-fDpx/2.;
    x2=x1+fDpx;
    y1=fyt-fy-fDpy/2.;
    y2=y1+fDpy;    
}

void AliMUONsegmentationV1::
Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[7], Int_t Ylist[7])
{
    *Nlist=4;Xlist[0]=Xlist[1]=iX;Xlist[2]=iX-1;Xlist[3]=iX+1;
    Ylist[0]=iY-1;Ylist[1]=iY+1;Ylist[2]=Ylist[3]=iY;
}

void AliMUONsegmentationV1::
FitXY(AliMUONRecCluster* ,TClonesArray* )
    // Default : Centre of gravity method
{
    ;
}
Commit	Line	Data
fe4da5cc	1	/////////////////////////////////////////////////////////
	2	// Manager and hits classes for set:MUON version 0 //
	3	/////////////////////////////////////////////////////////
	4
	5	#include <TTUBE.h>
	6	#include <TNode.h>
	7	#include <TRandom.h>
	8
	9	#include "AliMUONv0.h"
	10	#include "AliMUONsegmentv1.h"
	11	#include "AliRun.h"
	12	#include "AliMC.h"
	13	#include "iostream.h"
	14
	15	//___________________________________________
	16	ClassImp(AliMUONsegmentationV1)
	17
	18	AliMUONsegmentationV1::AliMUONsegmentationV1()
	19	// initizalize the class with default settings
	20	{
	21	fNzone=1;
	22	fDAnod=0.0;
	23	fDpx=0.0;
	24	fDpx=0.0; // forces crash if not initialized by user
	25	fNZoneCut[0]=0;
	26	fSensOffset=0;
	27	}
	28
	29
	30	void AliMUONsegmentationV1::Init(AliMUONchamber* Chamber)
	31	{
	32	// valid only for T5/6
	33	frSensMin2 = (Chamber->frMin + 6.)*(Chamber->frMin + 6.);
	34	frSensMax2 = (Chamber->frMax - 6.)*(Chamber->frMax - 6.);
	35	fNpx=(Int_t) (Chamber->frMax/fDpx) + 1;
	36	fNpy=(Int_t) (Chamber->frMax/fDpy) + 1;
	37	// fNwire=3;
	38	DefaultCut();
	39	}
	40
	41	void AliMUONsegmentationV1::DefaultCut(void)
	42	{
	43	SetNzone(3);
	44	AddCut(0,76,188);
	45	AddCut(0,106,158);
	46	AddCut(0,126,128);
	47	AddCut(0,136,98);
	48	AddCut(0,146,68);
	49	AddCut(1,86,2112);
	50	AddCut(1,126,1812);
	51	AddCut(1,166,1512);
	52	AddCut(1,186,1212);
	53	AddCut(1,206,912);
	54	AddCut(1,226,612);
	55	SetSensOffset(3.0);
	56	SetDAnod(0.325);
	57	}
	58
	59	Int_t AliMUONsegmentationV1::GetiAnod(Float_t xhit)
	60	{
	61	Int_t kwire=Int_t((TMath::Abs(xhit)-fSensOffset)/fDAnod)+1;
	62	return (xhit>0) ? kwire : -kwire ;
	63	}
	64
65	Float_t AliMUONsegmentationV1::GetAnod(Float_t xhit)
66	{
67	Int_t kwire=Int_t((TMath::Abs(xhit)-fSensOffset)/fDAnod)+1; // to be compatible ...
68	return (xhit>0) ? fDAnod(kwire-0.5)+fSensOffset : -fDAnod(kwire-0.5)-fSensOffset ;
69	}
70
71	// For chamber T5/6 p1 and p2 should be same for each zone
72	void AliMUONsegmentationV1::SetPADSIZ(Float_t p1, Float_t p2)
73	{
74	fDpx=p1;
75	fDpy=p2;
76	}
77
78	void AliMUONsegmentationV1::
79	GetPadIxy(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
80	{
81	// returns pad coordinates (ix,iy) for given real coordinates (x,y)
82	//
83	ix = (x>0)? Int_t((x-fSensOffset)/fDpx)+1 : Int_t((x+fSensOffset)/fDpx)-1;
84	iy = (y>0)? Int_t((y-fSensOffset)/fDpy)+1 : Int_t((y+fSensOffset)/fDpy)-1;
85	}
86
87	void AliMUONsegmentationV1::
88	GetPadCxy(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
89	{
90	// returns real coordinates (x,y) for given pad coordinates (ix,iy)
91	//
92	x = (ix>0) ? (Float_t(ix)-0.5)fDpx+fSensOffset : (Float_t(ix)+0.5)fDpx-fSensOffset;
93	y = (iy>0) ? (Float_t(iy)-0.5)fDpy+fSensOffset : (Float_t(iy)+0.5)fDpy-fSensOffset;
94	}
95
96	void AliMUONsegmentationV1::AddCut(Int_t Zone, Int_t nX, Int_t nY)
97	{// the pad nX,nY is last INSIDE zone Zone
98	if (Zone+1>=fNzone) // no cut for last Zone : it is the natural boundary of the chamber
99	printf("AliMUONsegmentationV1::AddCut ==> Zone %d not allowed !\n",Zone);
100	fZoneX[Zone][fNZoneCut[Zone]] = nX;
101	fZoneY[Zone][fNZoneCut[Zone]] = nY;
102	fNZoneCut[Zone]++;
103	}
104
105	Int_t AliMUONsegmentationV1::GetZone(Float_t X, Float_t Y)
106	{
107	Int_t iX, iY;
108	GetPadIxy(X,Y,iX,iY);
109	return GetZone( iX , iY );
110	}
111
112	Int_t AliMUONsegmentationV1::GetZone(Int_t nX, Int_t nY)
113	{// Beware : first pad begins at 1 !!
114	Int_t aX = TMath::Abs(nX);
115	Int_t aY = TMath::Abs(nY);
116	Int_t zone=fNzone-1;
117	for (Int_t iZone=fNzone-2;iZone>=0;iZone--)
118	{
119	for (Int_t iCut=0;iCut<fNZoneCut[iZone];iCut++)
120	if ( aY<=fZoneY[iZone][iCut] && aX<=fZoneX[iZone][iCut] )
121	{
122	zone=iZone;
123	break;
124	}
125	}
126	return zone;
127	}
128
129
130	void AliMUONsegmentationV1::SetPadCoord(Int_t iX, Int_t iY)
131	{
132	GetPadCxy(iX,iY,fx,fy);
133	Float_t radius2;
134	if ( ( (radius2=fxfx+fyfy) > frSensMax2 \|\| radius2 < frSensMin2 )
135	&& MorePads() )
136	NextPad();
137
138	}
139
140	void AliMUONsegmentationV1::FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy)
141	{
142	//
143	// Find the wire position (center of charge distribution)
144	Float_t x0a=GetAnod(xhit);
145	//
146	// and take fNsigma*sigma around this center
147	Float_t x01=x0a - dx;
148	Float_t x02=x0a + dx;
149	Float_t y01=yhit - dy;
150	Float_t y02=yhit + dy;
151
152	// Do not cross over frames...
153	if (x01 * x0a < 0)
154	x01 = TMath::Sign(fSensOffset, x0a);
155	if (x02 * x0a < 0)
156	x02 = TMath::Sign(fSensOffset, x0a);
157	if (y01 * yhit < 0)
158	y01 = TMath::Sign(fSensOffset, yhit);
159	if (y02 * yhit < 0)
160	y02 = TMath::Sign(fSensOffset, yhit);
161	//
162	// find the pads over which the charge distributes
163	GetPadIxy(x01,y01,fixmin,fiymin);
164	GetPadIxy(x02,y02,fixmax,fiymax);
165
166	// printf("\n FirstPad called");
167	// printf("\n Hit Position %f %f",xhit,yhit);
168	// printf("\n Integration limits: %i %i %i %i",fixmin,fixmax,fiymin,fiymax);
169	// printf("\n Integration limits: %f %f %f %f \n",x01,x02,y01,y02);
170	//
171	// Set current pad to lower left corner
172	fix=fixmin;
173	fiy=fiymin;
174	SetPadCoord(fix,fiy);
175	}
176
177	void AliMUONsegmentationV1::NextPad()
178	{
179	//
180	// Step to next pad in integration region
181	if (fix != fixmax) {
182	fix++;
183	} else if (fiy != fiymax) {
184	fix=fixmin;
185	fiy++;
186	} else
187	printf("\n Error: Stepping outside integration region\n ");
188	SetPadCoord(fix,fiy);
189	}
190
191	Int_t AliMUONsegmentationV1::MorePads()
192	//
193	// Are there more pads in the integration region
194	{
195	if (fix == fixmax && fiy == fiymax) {
196	return 0;
197	} else {
198	return 1;
199	}
200	}
201
202	Int_t AliMUONsegmentationV1::Ix()
203	// returns the X number of pad which has to increment charge
204	// due to parallel read-out
205	{
206	Int_t wix = TMath::Abs(fix)-1;
207	Int_t wiy = TMath::Abs(fiy)-1;
208	Int_t zone = GetZone(fix,fiy);
209	switch (zone) {
210	case 0: return fix;
211	case 1:
212	if ( wiy%3 !=1 && wix%6>2)
213	return (fix>0)? fix-3 : fix+3 ;
214	return fix;
215	case 2:
216	if ( (wiy%6 == 1 && wix%2 ==0) \|\| (wiy%6 == 4 && wix%2 ==1))
217	return fix;
218	return fix>0? fix - ((wix%12)/4)4 : fix + ((wix%12)/4)4;
219	default :
220	printf("Couille dans AliMUONsegmentationV1::ix\n");
221	}
222	return -1;
223	}
224
225	Int_t AliMUONsegmentationV1::ISector()
226	{
227	Int_t wix = TMath::Abs(fix)-1;
228	Int_t wiy = TMath::Abs(fiy)-1;
229	Int_t zone = GetZone(fix,fiy);
230	switch (zone) {
231	case 0: return 0;
232	case 1:
233	if ( wiy%3 !=1 && wix%6>2)
234	return 1 ;
235	return 0;
236	case 2:
237	if ((wiy%6 == 1 && wix%2 ==0) \|\| (wiy%6 == 4 && wix%2 ==1))
238	return 0;
239	return (wix%12)/4;
240	default :
241	printf("Couille dans AliMUONsegmentationV1::ISector\n");
242	}
243	return -1;
244	}
245
246	void AliMUONsegmentationV1::SigGenInit(Float_t x,Float_t y,Float_t)
247	{
248	//
249	// Initialises pad and wire position during stepping
250	fxt =x;
251	fyt =y;
252	GetPadIxy(x,y,fixt,fiyt);
253	fiwt= GetiAnod(x);
254
255	}
256
257	Int_t AliMUONsegmentationV1::SigGenCond(Float_t x,Float_t y,Float_t)
258	{
259	//
260	// Signal will be generated if particle crosses pad boundary or
261	// boundary between two wires.
262	Int_t ixt;
263	Int_t iyt;
264	GetPadIxy(x,y,ixt,iyt);
265	Int_t iwt= GetiAnod(x);
266
267	if ((ixt != fixt) \|\| (iyt !=fiyt) \|\| (iwt != fiwt)) {
268	return 1;
269	} else {
270	return 0;
271	}
272	}
273
274	void AliMUONsegmentationV1::
275	IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
276	{
277	x1=fxt-fx-fDpx/2.;
278	x2=x1+fDpx;
279	y1=fyt-fy-fDpy/2.;
280	y2=y1+fDpy;
281	}
282
283	void AliMUONsegmentationV1::
284	Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[7], Int_t Ylist[7])
285	{
286	*Nlist=4;Xlist[0]=Xlist[1]=iX;Xlist[2]=iX-1;Xlist[3]=iX+1;
287	Ylist[0]=iY-1;Ylist[1]=iY+1;Ylist[2]=Ylist[3]=iY;
288	}
289
290	void AliMUONsegmentationV1::
291	FitXY(AliMUONRecCluster* ,TClonesArray* )
292	// Default : Centre of gravity method
293	{
294	;
295	}