]> git.uio.no Git - u/mrichter/AliRoot.git/blame - MUON/AliMUONSt345SlatSegmentation.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Removing obsolete classes (Chrstian)
[u/mrichter/AliRoot.git] / MUON / AliMUONSt345SlatSegmentation.cxx
CommitLineData
cc4dcfb0 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/* $Id$ */
17
18//*********************************************************
19// Segmentation classes for slat modules
20// This class works with local coordinates
21// of the slats via the class AliMUONGeometrySegmentation
22// This class contains the size of the slats and the
23// and the differents PCB densities.
24// (from old AliMUONSegmentationSlatModule)
25// Gines, Subatech, Nov04
f1501d74 26// Add electronics mapping
27// Christian, Subatech, Mai 05
cc4dcfb0 28//*********************************************************
29
30#include <TArrayI.h>
31#include <TArrayF.h>
32#include "AliMUONSt345SlatSegmentation.h"
33#include "AliLog.h"
34
cc4dcfb0 35ClassImp(AliMUONSt345SlatSegmentation)
36
37
a713db22 38AliMUONSt345SlatSegmentation::AliMUONSt345SlatSegmentation()
f1501d74 39 : AliMUONVGeometryDESegmentation(),
a713db22 40 fBending(0),
41 fId(0),
6b9de626 42 fNsec(0),
43 fNDiv(0),
44 fDpxD(0),
45 fDpyD(0),
a713db22 46 fDpx(0),
47 fDpy(0),
48 fNpx(999999),
49 fNpy(999999),
50 fWireD(0.0),
51 fXhit(0.),
52 fYhit(0.),
53 fIx(0),
54 fIy(0),
55 fX(0.),
56 fY(0.),
57 fIxmin(0),
58 fIxmax(0),
59 fIymin(0),
f1501d74 60 fIymax(0),
9db6c8d7 61 fInitDone(kFALSE)
a713db22 62{
63 // default constructor
f64ec237 64 AliDebug(1,Form("this=%p default (empty) ctor",this));
a713db22 65}
66
67//___________________________________________
f48459ab 68AliMUONSt345SlatSegmentation::AliMUONSt345SlatSegmentation(Bool_t bending)
fed772f3 69 : AliMUONVGeometryDESegmentation(),
f48459ab 70 fBending(bending),
71 fId(0),
6b9de626 72 fNsec(0),
73 fNDiv(0),
74 fDpxD(0),
75 fDpyD(0),
f48459ab 76 fDpx(0),
77 fDpy(0),
78 fNpx(999999),
79 fNpy(999999),
80 fWireD(0.25),
81 fXhit(0.),
82 fYhit(0.),
83 fIx(0),
84 fIy(0),
85 fX(0.),
86 fY(0.),
87 fIxmin(0),
88 fIxmax(0),
89 fIymin(0),
f1501d74 90 fIymax(0),
9db6c8d7 91 fInitDone(kFALSE)
f1501d74 92
cc4dcfb0 93{
f48459ab 94 // Non default constructor
cc4dcfb0 95 fNsec = 4; // 4 sector densities at most per slat
96 fNDiv = new TArrayI(fNsec);
97 fDpxD = new TArrayF(fNsec);
f48459ab 98 fDpyD = new TArrayF(fNsec);
cc4dcfb0 99 (*fNDiv)[0]=(*fNDiv)[1]=(*fNDiv)[2]=(*fNDiv)[3]=0;
100 (*fDpxD)[0]=(*fDpxD)[1]=(*fDpxD)[2]=(*fDpxD)[3]=0;
f1501d74 101 (*fDpyD)[0]=(*fDpyD)[1]=(*fDpyD)[2]=(*fDpyD)[3]=0;
f64ec237 102 AliDebug(1,Form("this=%p ctor for bending=%d",this,fBending));
f1501d74 103
cc4dcfb0 104}
105//----------------------------------------------------------------------
fed772f3 106AliMUONSt345SlatSegmentation::AliMUONSt345SlatSegmentation(const AliMUONSt345SlatSegmentation& rhs)
107: AliMUONVGeometryDESegmentation(rhs),
108 fBending(0),
109 fId(0),
110 fDpx(0),
111 fDpy(0),
112 fNpx(999999),
113 fNpy(999999),
114 fWireD(0.25),
115 fXhit(0.),
116 fYhit(0.),
117 fIx(0),
118 fIy(0),
119 fX(0.),
120 fY(0.),
121 fIxmin(0),
122 fIxmax(0),
123 fIymin(0),
9db6c8d7 124 fIymax(0)
cc4dcfb0 125{
f64ec237 126 AliFatal("Not implemented");
cc4dcfb0 127}
128//----------------------------------------------------------------------
129AliMUONSt345SlatSegmentation::~AliMUONSt345SlatSegmentation()
130{
f48459ab 131 // Destructor
f64ec237 132 delete fNDiv;
133 delete fDpxD;
134 delete fDpyD;
cc4dcfb0 135}
136//----------------------------------------------------------------------
137AliMUONSt345SlatSegmentation& AliMUONSt345SlatSegmentation::operator=(const AliMUONSt345SlatSegmentation& rhs)
138{
f48459ab 139 // Protected assignement operator
cc4dcfb0 140 if (this == &rhs) return *this;
141 AliFatal("Not implemented.");
142 return *this;
143}
144
145
146//------------------------------------------------------------------------
147Float_t AliMUONSt345SlatSegmentation::Distance2AndOffset(Int_t iX, Int_t iY, Float_t X, Float_t Y, Int_t * /*dummy*/)
148{
f48459ab 149 // Returns the square of the distance between 1 pad
150 // labelled by its Channel numbers and a coordinate
cc4dcfb0 151 Float_t x,y;
152 GetPadC(iX,iY,x,y);
153 return (x-X)*(x-X) + (y-Y)*(y-Y);
154}
155//____________________________________________________________________________
156Float_t AliMUONSt345SlatSegmentation::Dpx(Int_t isec) const
157{
f48459ab 158 // Return x-strip width
159 return (*fDpxD)[isec];
cc4dcfb0 160}
161
162//____________________________________________________________________________
f48459ab 163Float_t AliMUONSt345SlatSegmentation::Dpy(Int_t isec) const
cc4dcfb0 164{
165 // Return y-strip width
f48459ab 166 return (*fDpyD)[isec];
cc4dcfb0 167}
168//_____________________________________________________________________________
169Float_t AliMUONSt345SlatSegmentation::GetAnod(Float_t xhit) const
170{
f48459ab 171 // Returns for a hit position xhit the position of the nearest anode wire
172 Float_t wire= (xhit>0)? Int_t(xhit/fWireD)+0.5:Int_t(xhit/fWireD)-0.5;
173 return fWireD*wire;
cc4dcfb0 174}
cc4dcfb0 175
f64ec237 176//_____________________________________________________________________________
177Bool_t AliMUONSt345SlatSegmentation::HasPad(Int_t ix, Int_t iy)
178{
179 if ( ix < 1 || ix > Npx() || iy < 1 || iy > Npy() )
180 {
181 return kFALSE;
182 }
183 Int_t isec = Sector(ix,iy);
184 if ( isec == -1 )
185 {
186 return kFALSE;
187 }
188 if ( iy > fNpyS[isec] )
189 {
190 return kFALSE;
191 }
192 return kTRUE;
193}
f48459ab 194
cc4dcfb0 195//--------------------------------------------------------------------------------
196void AliMUONSt345SlatSegmentation::GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y)
197{
bd57045f 198 if (ix < 1 || ix > Npx() || iy < 1 || iy > Npy() ){
f7db2071 199 AliWarning(Form("ix %d or iy %d out of boundaries: Npx=%d and Npy=%d",ix, iy, Npx(), Npy()));
13b83a58 200 x = y= 0.;
bd57045f 201
202 } else {
203
cc4dcfb0 204 // Returns real coordinates (x,y) for given pad coordinates (ix,iy)
cc4dcfb0 205 // Find sector isec
206 Int_t isec = Sector(ix,iy);
76fa1113 207 if (isec == -1) AliWarning(Form("isector = %d with ix %d, iy %d", isec, ix, iy));
f48459ab 208 if (iy > fNpyS[isec]) {
13b83a58 209 x = y = 0.;
f48459ab 210 return;
211 }
cc4dcfb0 212 if (isec>0) {
213 x = fCx[isec-1]+(ix-fNpxS[isec-1])*(*fDpxD)[isec];
214 x = x-(*fDpxD)[isec]/2;
f48459ab 215 y = Float_t(iy*(*fDpyD)[isec])-(*fDpyD)[isec]/2.- fCy; // !!!
cc4dcfb0 216 } else {
bd57045f 217 x = y = 0;
cc4dcfb0 218 }
219 }
220}
f48459ab 221
222
223//_____________________________________________________________________________
224void AliMUONSt345SlatSegmentation::GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy)
225{
226// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
76fa1113 227
f48459ab 228 // Find sector isec
229 Int_t isec=-1;
230 for (Int_t i=fNsec-1; i > 0; i--) {
231 if (x >= fCx[i-1]) {
232 isec=i;
13b83a58 233 if (TMath::Abs(fCx[isec] - fCx[isec-1]) <0.1 && isec > 1) isec--;
f48459ab 234 break;
235 }
236 }
f7db2071 237 if (isec == -1) AliWarning(Form("isector equal to %d with xl %f, yl %f", isec, x, y));
f48459ab 238 if (isec>0) {
239 ix= Int_t((x-fCx[isec-1])/(*fDpxD)[isec])
240 +fNpxS[isec-1]+1;
241 iy= Int_t((y+fCy)/(*fDpyD)[isec])+1;
242 } else if (isec == 0) {
243 ix= Int_t(x/(*fDpxD)[isec])+1;
244 iy= Int_t((y+fCy)/(*fDpyD)[isec])+1;
245 } else {
246 ix=0;
247 iy=0;
248 }
249}
cc4dcfb0 250//-------------------------------------------------------------------------
251void AliMUONSt345SlatSegmentation::GetPadI(Float_t x, Float_t y , Float_t /*z*/, Int_t &ix, Int_t &iy)
252{
253 GetPadI(x, y, ix, iy);
254}
f1501d74 255
f1501d74 256
cc4dcfb0 257//_______________________________________________________________
258void AliMUONSt345SlatSegmentation::SetPadDivision(Int_t ndiv[4])
259{
f48459ab 260 // Defines the pad size perp. to the anode wire (y) for different sectors.
261 // Pad sizes are defined as integral fractions ndiv of a basis pad size
262 // fDpx
263 //
264 for (Int_t i=0; i<4; i++) {
265 (*fNDiv)[i]=ndiv[i];
266 }
267 ndiv[0]=ndiv[1];
cc4dcfb0 268}
269//____________________________________________________________________________
270void AliMUONSt345SlatSegmentation::SetPadSize(Float_t p1, Float_t p2)
271{
f48459ab 272 // Sets the padsize
273 fDpx=p1;
274 fDpy=p2;
cc4dcfb0 275}
276//_______________________________________________________________
277void AliMUONSt345SlatSegmentation::SetPcbBoards(Int_t n[4])
278{
f48459ab 279 //
280 // Set PcbBoard segmentation zones for each density
f1501d74 281 // n[0] slat type parameter
282 // n[1] PcbBoards for highest density sector fNDiv[1] etc ...
283
284 fRtype = n[0];
285 n[0] = 0;
f48459ab 286 for (Int_t i=0; i<4; i++) fPcbBoards[i]=n[i];
f1501d74 287
cc4dcfb0 288}
289//-------------------------------------------------------------------------
290void AliMUONSt345SlatSegmentation::SetPad(Int_t ix, Int_t iy)
291{
f48459ab 292 //
293 // Sets virtual pad coordinates, needed for evaluating pad response
294 // outside the tracking program
295 GetPadC(ix,iy,fX,fY);
296 fSector=Sector(ix,iy);
cc4dcfb0 297}
298//---------------------------------------------------------------------------
299void AliMUONSt345SlatSegmentation::SetHit(Float_t x, Float_t y)
300{
f48459ab 301 // Set current hit
302 //
303 fXhit = x;
304 fYhit = y;
cc4dcfb0 305
bd57045f 306 if (x < fCx[0]) fXhit = fCx[0];
307 if (y < -fDyPCB/2.) fYhit = -fDyPCB/2.;
cc4dcfb0 308
bd57045f 309 if (x > fCx[fNsec-1]) fXhit = fCx[fNsec-1];
310 if (y > fDyPCB/2.) fYhit = fDyPCB/2.;
cc4dcfb0 311
312}
313//----------------------------------------------------------------------------
314void AliMUONSt345SlatSegmentation::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/)
315{
316 SetHit(xhit, yhit);
317}
f48459ab 318
cc4dcfb0 319//----------------------------------------------------------
320void AliMUONSt345SlatSegmentation::FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy)
321{
322// Initialises iteration over pads for charge distribution algorithm
323//
324 //
325 // Find the wire position (center of charge distribution)
bd57045f 326 Float_t x0a = GetAnod(xhit);
327 fXhit = x0a;
328 fYhit = yhit;
cc4dcfb0 329 //
330 // and take fNsigma*sigma around this center
bd57045f 331 Float_t x01 = x0a - dx ;
332 Float_t x02 = x0a + dx;
333 Float_t y01 = yhit - dy;
334 Float_t y02 = yhit + dy;
cc4dcfb0 335
bd57045f 336 // check the limits after adding (fNsigma*sigma)
337 if (x01 < fCx[0]) x01 = fCx[0];
338 if (y01 < -fDyPCB/2) y01 = -fDyPCB/2;
339
340 if (x02 >= fCx[fNsec-1]) x02 = fCx[fNsec-1]; // still ok ? (CF)
13b83a58 341 if (y02 >= fDyPCB/2.) y02 = fDyPCB/2.;
cc4dcfb0 342
343
344 Int_t isec=-1;
345 for (Int_t i=fNsec-1; i > 0; i--) {
bd57045f 346 if (x02 >= fCx[i-1]) {
347 isec=i;
13b83a58 348 if (TMath::Abs(fCx[isec] - fCx[isec-1]) < 0.1 && isec > 1) isec--;
bd57045f 349 break;
350 }
cc4dcfb0 351 }
bd57045f 352
13b83a58 353 // y02 += Dpy(isec);// why ? (CF)
cc4dcfb0 354
355 //
356 // find the pads over which the charge distributes
357 GetPadI(x01,y01,fIxmin,fIymin);
358 GetPadI(x02,y02,fIxmax,fIymax);
359
360 if (fIxmax > fNpx) fIxmax=fNpx;
361 if (fIymax > fNpyS[isec]) fIymax = fNpyS[isec];
f7db2071 362 if (fIxmin < 1) fIxmin = 1; // patch for the moment (Ch. Finck)
363 if (fIymin < 1) fIymin = 1;
cc4dcfb0 364
bd57045f 365 fXmin = x01;
366 fXmax = x02;
367 fYmin = y01;
368 fYmax = y02;
cc4dcfb0 369
370 //
371 // Set current pad to lower left corner
bd57045f 372 if (fIxmax < fIxmin) fIxmax = fIxmin;
373 if (fIymax < fIymin) fIymax = fIymin;
374 fIx = fIxmin;
375 fIy = fIymin;
cc4dcfb0 376
377 GetPadC(fIx,fIy,fX,fY);
bd57045f 378 fSector = Sector(fIx,fIy);
f64ec237 379
380 AliDebug(4,Form("xhit,yhit,dx,dy=%e,%e,%e,%e ix,iy=%3d,%3d",
381 xhit,yhit,dx,dy,fIx,fIy));
cc4dcfb0 382}
f48459ab 383
cc4dcfb0 384//----------------------------------------------------------------------
385void AliMUONSt345SlatSegmentation::FirstPad(Float_t xhit, Float_t yhit, Float_t /*zhit*/, Float_t dx, Float_t dy)
386{
387 FirstPad(xhit, yhit, dx, dy);
388}
389//----------------------------------------------------------------------
390void AliMUONSt345SlatSegmentation::NextPad()
391{
f48459ab 392 // Stepper for the iteration over pads
393 //
394 // Step to next pad in the integration region
395 // step from left to right
396 if (fIx != fIxmax) {
397 fIx++;
398 GetPadC(fIx,fIy,fX,fY);
399 fSector=Sector(fIx,fIy);
400 // step up
401 } else if (fIy != fIymax) {
402 fIx=fIxmin;
403 fIy++;
404 GetPadC(fIx,fIy,fX,fY);
405 fSector=Sector(fIx,fIy);
f48459ab 406 } else {
f7db2071 407 fIx=-999;
408 fIy=-999;
f48459ab 409 }
cc4dcfb0 410}
411//-------------------------------------------------------------------------
412Int_t AliMUONSt345SlatSegmentation::MorePads()
413{
f48459ab 414 // Stopping condition for the iterator over pads
415 //
416 // Are there more pads in the integration region
cc4dcfb0 417
f7db2071 418 return (fIx != -999 || fIy != -999);
cc4dcfb0 419}
420//--------------------------------------------------------------------------
421Int_t AliMUONSt345SlatSegmentation::Sector(Int_t ix, Int_t iy)
422{
f48459ab 423 //
424 // Determine segmentation zone from pad coordinates
425 //
bd57045f 426 Int_t isec = -1;
427 for (Int_t i = 0; i < fNsec; i++) {
f48459ab 428 if (ix <= fNpxS[i]) {
bd57045f 429 isec = i;
f48459ab 430 break;
cc4dcfb0 431 }
f48459ab 432 }
bd57045f 433 if (isec == -1) AliWarning(Form("Sector = %d with ix %d and iy %d, Npx %d",
434 isec, ix, iy, fNpx));
cc4dcfb0 435
f48459ab 436 return isec;
cc4dcfb0 437
438}
439//-----------------------------------------------------------------------------
440void AliMUONSt345SlatSegmentation::
441IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
442{
f48459ab 443 // Returns integration limits for current pad
444 //
445 x1=fXhit-fX-Dpx(fSector)/2.;
446 x2=x1+Dpx(fSector);
447 y1=fYhit-fY-Dpy(fSector)/2.;
448 y2=y1+Dpy(fSector);
f64ec237 449
450 AliDebug(4,Form("xhit,yhit=%e,%e x,y=%e,%e, x1,x2,y1,y2=%e,%e,%e,%e",fXhit,fYhit,fX,fY,x1,x2,y1,y2));
cc4dcfb0 451
452}
453//-----------------------------------------------------------------------------
454void AliMUONSt345SlatSegmentation::
455Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10])
456{
f48459ab 457 // Returns list of next neighbours for given Pad (iX, iY)
458 Int_t i=0;
459 // step right
460 if (iX+1 <= fNpx) {
461 Xlist[i]=iX+1;
462 Ylist[i++]=iY;
463 }
464 // step left
465 if (iX-1 > 0) {
466 Xlist[i]=iX-1;
467 Ylist[i++]=iY;
468 }
469 Int_t sector = Sector(iX,iY);
470 // step up
471 if (iY+1 <= fNpyS[sector]) {
472 Xlist[i]=iX;
473 Ylist[i++]=iY+1;
474 }
475 // step down
476 if (iY-1 > 0) {
477 Xlist[i]=iX;
478 Ylist[i++]=iY-1;
479 }
480 *Nlist=i;
cc4dcfb0 481}
f48459ab 482
cc4dcfb0 483//--------------------------------------------------------------------------
484void AliMUONSt345SlatSegmentation::Init(Int_t detectionElementId)
485{
f48459ab 486 //
487 // Fill the arrays fCx (x-contour) and fNpxS (ix-contour) for each sector
488 // These arrays help in converting from real to pad co-ordinates and
489 // vice versa
490 //
491 // Segmentation is defined by rectangular modules approximating
492 // concentric circles as shown below
493 //
494 // PCB module size in cm
495 // printf("\n Initialise Segmentation SlatModule \n");
cc4dcfb0 496
f48459ab 497
a713db22 498 // printf(" fBending: %d \n",fBending);
f48459ab 499
f1501d74 500 if (fInitDone) return; // security if init is already done in AliMUONFactory
f48459ab 501 fDxPCB=40;
502 fDyPCB=40;
503
504 // Calculate padsize along x
505 (*fDpxD)[fNsec-1]=fDpx;
506 (*fDpyD)[fNsec-1]=fDpy;
507 if (fNsec > 1) {
508 for (Int_t i=fNsec-1; i>=0; i--){ // fNsec-2
509 if (!fBending) {
510 (*fDpxD)[i]=fDpx;
511 (*fDpyD)[i]=(*fDpyD)[fNsec-1]/(*fNDiv)[i];
512 } else {
cc4dcfb0 513 (*fDpxD)[i]=(*fDpxD)[fNsec-1]/(*fNDiv)[i];
f48459ab 514 (*fDpyD)[i]=fDpy;
cc4dcfb0 515 }
516 }
f48459ab 517 }
518 //
519 // fill the arrays defining the pad segmentation boundaries
520 //
521 //
522 // Loop over sectors (isec=0 for secto close to the beam pipe)
523 Float_t totalLength = 0;
524 for (Int_t isec=0; isec<4; isec++) totalLength += fPcbBoards[isec]*fDxPCB; // !!!!
525
526 fNpy = 0; // maximum number of pads in y
527 for (Int_t isec=0; isec<4; isec++) {
528 if (isec==0) {
529 fNpxS[0] = 0;
530 fNpyS[0] = 0;
531 fCx[0] = -totalLength/2;
532 } else {
13b83a58 533 fNpxS[isec] = fNpxS[isec-1] + fPcbBoards[isec]*Int_t(fDxPCB/(*fDpxD)[isec]+0.5);
534 fNpyS[isec] = Int_t(fDyPCB/(*fDpyD)[isec]+0.5);
f48459ab 535 if (fNpyS[isec] >= fNpy) fNpy = fNpyS[isec];
536 fCx[isec]= fCx[isec-1] + fPcbBoards[isec]*fDxPCB;
537 }
538 } // sectors
cc4dcfb0 539
f48459ab 540 fNpx = fNpxS[3]; // maximum number of pads in x
541 fCy = fDyPCB/2.;
542 //
543 fId = detectionElementId;
f1501d74 544
f1501d74 545 fInitDone = kTRUE;
f48459ab 546}