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