387d078296c2262320a410514052543d97c13a4a
[u/mrichter/AliRoot.git] / MUON / AliMUONSegmentationV05.cxx
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$
18 Revision 1.2  2000/06/15 07:58:48  morsch
19 Code from MUON-dev joined
20
21 Revision 1.1.2.1  2000/06/09 21:38:46  morsch
22 AliMUONSegmentationV05 code  from  AliMUONSegResV05.cxx
23
24 */
25
26 /////////////////////////////////////////////////////
27 //  Segmentation and Response classes version 05   //
28 /////////////////////////////////////////////////////
29
30
31 #include "AliMUONSegmentationV05.h"
32 #include <TMath.h>
33 //___________________________________________
34 ClassImp(AliMUONSegmentationV05)
35
36
37 void AliMUONSegmentationV05::Init(Int_t chamber)
38 {
39     printf("\n Initialise segmentation v05 \n");
40 //
41 //  Fill the arrays fCx (x-contour) and fNpxS (ix-contour) for each sector
42 //  These arrays help in converting from real to pad co-ordinates and
43 //  vice versa
44 //
45 //  Segmentation is defined by rectangular modules approximating
46 //  concentric circles as shown below
47 //
48 //  PCB module size in cm
49     const Float_t kDxPCB=40, kDyPCB=40;
50 //  PCB distribution (7 rows with 1+3 segmentation regions)
51     const Int_t kpcb[7][4] = {{1, 2, 2, 2}, 
52                               {0, 3, 2, 2}, 
53                               {0, 2, 2, 2}, 
54                               {0, 0, 3, 3}, 
55                               {0, 0, 2, 3}, 
56                               {0, 0, 0, 4}, 
57                               {0, 0, 0, 3}};
58     
59     
60 //
61 //                             3 3 3 | 3 3 3
62 //                           3 3 3 3 | 3 3 3 3
63 //                         3 3 3 2 2 | 2 2 3 3 3
64 //                       3 3 3 2 2 2 | 2 2 2 3 3 3
65 //                       3 3 2 2 1 1 | 1 1 2 2 3 3      
66 //                     3 3 2 2 1 1 1 | 1 1 1 2 2 3 3
67 //                     3 3 2 2 1 1 0 | 0 1 1 2 2 3 3
68 //                    ------------------------------
69 //                     3 3 2 2 1 1 0 | 0 1 1 2 2 3 3
70 //                     3 3 2 2 1 1 1 | 1 1 1 2 2 3 3
71 //                       3 3 2 2 1 1 | 1 1 2 2 3 3      
72 //                       3 3 3 2 2 2 | 2 2 2 3 3 3                      
73 //                         3 3 3 2 2 | 2 2 3 3 3
74 //                           3 3 3 3 | 3 3 3 3
75 //                             3 3 3 | 3 3 3
76 //
77 // number of pad rows per PCB
78 //    
79     Int_t nPyPCB=Int_t(kDyPCB/fDpy);
80 //
81 // maximum number of pad rows    
82     fNpy=7*nPyPCB;
83 //
84 //  Calculate padsize along x
85     fDpxD[fNsec-1]=fDpx;
86     if (fNsec > 1) {
87         for (Int_t i=fNsec-2; i>=0; i--){
88             fDpxD[i]=fDpxD[fNsec-1]/fNDiv[i];
89             printf("\n test ---dx %d %f \n",i,fDpxD[i]);
90         }
91     }
92 //
93 // fill the arrays defining the pad segmentation boundaries
94 //
95 //  loop over pcb module rows
96     Int_t iy=0;
97     for (Int_t irow=0; irow<7; irow++) {
98 //  
99 //  loop over pads along the anode wires
100         for (Int_t i=0; i<=nPyPCB; i++) {
101 //  iy counts the padrow
102             iy++;
103 //  Loop over sectors (isec=0 is the dead space surounding the beam pipe)
104             for (Int_t isec=0; isec<4; isec++) {
105                 if (isec==0) {
106                     fNpxS[0][iy]=kpcb[irow][0]*Int_t(kDxPCB/fDpxD[0]);
107                     fCx[0][iy]=kpcb[irow][0]*kDxPCB;
108                 } else {
109                     fNpxS[isec][iy]=fNpxS[isec-1][iy]
110                         +kpcb[irow][isec]*Int_t(kDxPCB/fDpxD[isec]);
111
112                     fCx[isec][iy]=fCx[isec-1][iy]
113                     +kpcb[irow][isec]*kDxPCB;
114                 }
115             } // sectors
116         } // pad raws in module
117     } // PCB rows
118 /*
119     for (Int_t iy=1; iy< fNpy; iy++) {
120             printf("\nBoundary %d %f %d %f %d %f %d %f",
121                    fNpxS[0][iy], fCx[0][iy],
122                    fNpxS[1][iy], fCx[1][iy],
123                    fNpxS[2][iy], fCx[2][iy],
124                    fNpxS[3][iy], fCx[3][iy]);
125             
126     }
127 */
128 }
129
130 void AliMUONSegmentationV05::GiveTestPoints(Int_t &n, Float_t *x, Float_t *y)
131 {
132 // Returns test point on the pad plane.
133 // Used during determination of the segmoid correction of the COG-method
134     n=1;
135     x[0]=(fCx[1][1]+fCx[0][1])/2/TMath::Sqrt(2.);
136     y[0]=x[0];
137 }
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154