]>
Commit | Line | Data |
---|---|---|
ba8b0266 | 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 | /// \class AliMUONSurveyUtil | |
18 | /// Utility class for the survey processing of the ALICE DiMuon spectrometer | |
19 | /// | |
20 | /// This class contains various functions to calculate misalignement parameters | |
21 | /// from survey data and designed positions of survey targets. | |
22 | /// Macro also includes a method to get the new AliMUONGeometryTranformer. | |
23 | /// | |
24 | /// \author Javier Castillo | |
25 | //----------------------------------------------------------------------------- | |
26 | ||
27 | #include <fstream> | |
28 | ||
29 | #include <TGeoManager.h> | |
30 | #include <TClonesArray.h> | |
31 | #include <TMath.h> | |
32 | #include <TMatrixDSym.h> | |
33 | #include <TString.h> | |
34 | #include <Riostream.h> | |
35 | ||
36 | #include "AliAlignObjMatrix.h" | |
37 | #include "AliGeomManager.h" | |
38 | #include "AliCDBManager.h" | |
39 | #include "AliCDBMetaData.h" | |
40 | #include "AliCDBId.h" | |
41 | ||
42 | #include "AliMUONSurveyUtil.h" | |
43 | #include "AliMUONGeometryTransformer.h" | |
44 | #include "AliMUONGeometryMisAligner.h" | |
45 | #include "AliMUONGeometryModuleTransformer.h" | |
46 | #include "AliMUONGeometryDetElement.h" | |
47 | #include "AliMUONGeometryBuilder.h" | |
48 | #include "AliMpExMap.h" | |
49 | #include "AliMpExMapIterator.h" | |
50 | ||
51 | /// \cond CLASSIMP | |
52 | ClassImp(AliMUONSurveyUtil) | |
53 | /// \endcond | |
54 | ||
55 | int AliMUONSurveyUtil::fgNDetElemCh[10] = {4,4,4,4,18,18,26,26,26,26}; | |
56 | AliMUONSurveyUtil* AliMUONSurveyUtil::fgInstance(0x0); | |
57 | ||
58 | AliMUONSurveyUtil::~AliMUONSurveyUtil(){ | |
59 | printf("WHAT AM I DOING HERE????????????????\n"); | |
60 | fgInstance = 0x0; | |
61 | } | |
62 | ||
63 | AliMUONSurveyUtil* AliMUONSurveyUtil::Instance() { | |
64 | if (!fgInstance) | |
65 | fgInstance = new AliMUONSurveyUtil(); | |
66 | ||
67 | return fgInstance; | |
68 | } | |
69 | ||
70 | Bool_t AliMUONSurveyUtil::MatrixToAngles(const Double_t *rot, Double_t *angles) | |
71 | { | |
72 | /// Calculates the Euler angles in "x y z" notation | |
73 | /// using the rotation matrix | |
74 | /// Returns false in case the rotation angles can not be | |
75 | ||
76 | // extracted from the matrix | |
77 | // | |
78 | if(TMath::Abs(rot[0])<1e-7 || TMath::Abs(rot[8])<1e-7) { | |
79 | printf("Failed to extract roll-pitch-yall angles!"); | |
80 | return kFALSE; | |
81 | } | |
82 | // Double_t raddeg = TMath::RadToDeg(); | |
83 | angles[0]=TMath::ATan2(-rot[5],rot[8]); | |
84 | angles[1]=TMath::ASin(rot[2]); | |
85 | angles[2]=TMath::ATan2(-rot[1],rot[0]); | |
86 | return kTRUE; | |
87 | } | |
88 | ||
89 | void AliMUONSurveyUtil::AnglesToMatrix(const Double_t *angles, Double_t *rot) | |
90 | { | |
91 | // Calculates the rotation matrix using the | |
92 | // Euler angles in "x y z" notation | |
93 | // | |
94 | // Double_t degrad = TMath::DegToRad(); | |
95 | Double_t degrad = 1.; | |
96 | Double_t sinpsi = TMath::Sin(degrad*angles[0]); | |
97 | Double_t cospsi = TMath::Cos(degrad*angles[0]); | |
98 | Double_t sinthe = TMath::Sin(degrad*angles[1]); | |
99 | Double_t costhe = TMath::Cos(degrad*angles[1]); | |
100 | Double_t sinphi = TMath::Sin(degrad*angles[2]); | |
101 | Double_t cosphi = TMath::Cos(degrad*angles[2]); | |
102 | ||
103 | rot[0] = costhe*cosphi; | |
104 | rot[1] = -costhe*sinphi; | |
105 | rot[2] = sinthe; | |
106 | rot[3] = sinpsi*sinthe*cosphi + cospsi*sinphi; | |
107 | rot[4] = -sinpsi*sinthe*sinphi + cospsi*cosphi; | |
108 | rot[5] = -costhe*sinpsi; | |
109 | rot[6] = -cospsi*sinthe*cosphi + sinpsi*sinphi; | |
110 | rot[7] = cospsi*sinthe*sinphi + sinpsi*cosphi; | |
111 | rot[8] = costhe*cospsi; | |
112 | } | |
113 | ||
114 | Double_t AliMUONSurveyUtil::xpCenter(Double_t *x, Double_t *par){ | |
115 | Double_t lCos2Tht = TMath::Cos(2*par[6]); | |
116 | Double_t lSinTht = TMath::Sin(par[6]); | |
117 | ||
118 | Double_t inSqrt = TMath::Abs((par[0] - par[3])*(par[0] - par[3]) | |
119 | -2*(x[0] -x[1])*(x[0] -x[1]) | |
120 | +(par[1] - par[4] + par[2] - par[5])*(par[1] - par[4] - par[2] + par[5]) | |
121 | +((par[0] - par[3])*(par[0] - par[3]) | |
122 | +(par[1] - par[4])*(par[1] - par[4]) | |
123 | +(par[2] - par[5])*(par[2] - par[5]))*lCos2Tht | |
124 | +4*(x[0] - x[1])*(par[2] - par[5])*lSinTht); | |
125 | ||
126 | if (inSqrt<0) return inSqrt*1e10; | |
127 | ||
128 | Double_t xD = ((2*(par[0]*par[0]*x[1] | |
129 | -par[0]*par[3]*(x[0] + x[1]) | |
130 | +x[1]*par[1]*(par[1] - par[4]) | |
131 | +x[0]*(par[3]*par[3] - par[1]*par[4] + par[4]*par[4])) | |
132 | -2*(par[3]*par[3]*par[2] | |
133 | +par[0]*par[0]*par[5] | |
134 | -par[0]*par[3]*(par[2] + par[5]) | |
135 | +(par[1] - par[4])*(-par[4]*par[2] +par[1]*par[5]))*lSinTht | |
136 | +TMath::Sqrt(2)*(-par[3]*par[1] + par[0]*par[4]) | |
137 | *TMath::Sqrt(inSqrt)) | |
138 | /(2*((par[0] - par[3])*(par[0] - par[3]) + (par[1] - par[4])*(par[1] - par[4])))); | |
139 | ||
140 | return xD; | |
141 | } | |
142 | ||
143 | Double_t AliMUONSurveyUtil::xnCenter(Double_t *x, Double_t *par){ | |
144 | ||
145 | Double_t lCos2Tht = TMath::Cos(2*par[6]); | |
146 | Double_t lSinTht = TMath::Sin(par[6]); | |
147 | ||
148 | Double_t inSqrt = TMath::Abs((par[0] - par[3])*(par[0] - par[3]) | |
149 | -2*(x[0] - x[1])*(x[0] - x[1]) | |
150 | +(par[1] - par[4] + par[2] - par[5])*(par[1] - par[4] - par[2] + par[5]) | |
151 | +((par[0] - par[3])*(par[0] - par[3]) | |
152 | +(par[1] - par[4])*(par[1] - par[4]) | |
153 | +(par[2] - par[5])*(par[2] - par[5]))*lCos2Tht | |
154 | +4*(x[0] - x[1])*(par[2] - par[5])*lSinTht); | |
155 | ||
156 | if (inSqrt<0) return inSqrt*1e10; | |
157 | ||
158 | Double_t xD = ((2*(par[0]*par[0]*x[1] | |
159 | -par[0]*par[3]*(x[0] + x[1]) | |
160 | +x[1]*par[1]*(par[1] - par[4]) | |
161 | +x[0]*(par[3]*par[3] - par[1]*par[4] + par[4]*par[4])) | |
162 | -2*(par[3]*par[3]*par[2] + par[0]*par[0]*par[5] | |
163 | -par[0]*par[3]*(par[2] + par[5]) | |
164 | +(par[1] - par[4])*(-par[4]*par[2] + par[1]*par[5]))*lSinTht | |
165 | +TMath::Sqrt(2)*(par[3]*par[1] - par[0]*par[4]) | |
166 | *TMath::Sqrt(inSqrt)) | |
167 | /(2*((par[0] - par[3])*(par[0] - par[3]) + (par[1] - par[4])*(par[1] - par[4])))); | |
168 | ||
169 | return xD; | |
170 | } | |
171 | ||
172 | Double_t AliMUONSurveyUtil::phixpn(Double_t *x, Double_t *par){ | |
173 | ||
174 | Double_t inSqrt = TMath::Abs(((par[0] - par[3])*(par[0] - par[3]) | |
175 | -2*(x[0] - x[1])*(x[0] - x[1]) | |
176 | +(par[1] - par[4] + par[2] - par[5])*(par[1] - par[4] - par[2] + par[5]) | |
177 | +(+(par[0] - par[3])*(par[0] - par[3]) | |
178 | +(par[1] - par[4])*(par[1] - par[4]) | |
179 | +(par[2] - par[5])*(par[2] - par[5]))*TMath::Cos(2*par[6]) | |
180 | +4*(x[0] - x[1])*(par[2] - par[5])*TMath::Sin(par[6]))); | |
181 | ||
182 | if (inSqrt<0) return inSqrt*1e10; | |
183 | ||
184 | Double_t phix = ((+2*(par[0] - par[3])*(x[0] - x[1]) | |
185 | -2*(par[0] - par[3])*(par[2] - par[5])*TMath::Sin(par[6]) | |
186 | +TMath::Sqrt(2)*(par[1] - par[4]) | |
187 | *TMath::Sqrt(inSqrt)) | |
188 | /(2*(+(par[0] - par[3])*(par[0] - par[3]) | |
189 | +(par[1] - par[4])*(par[1] - par[4]))*TMath::Cos(par[6]))); | |
190 | ||
191 | phix = -TMath::ACos(phix); | |
192 | ||
193 | return phix; | |
194 | } | |
195 | ||
196 | Double_t AliMUONSurveyUtil::phixpp(Double_t *x, Double_t *par){ | |
197 | ||
198 | Double_t inSqrt = TMath::Abs(+(par[0] - par[3])*(par[0] - par[3]) | |
199 | -2*(x[0] - x[1])*(x[0] - x[1]) | |
200 | +(par[1] - par[4] + par[2] - par[5])*(par[1] - par[4] - par[2] + par[5]) | |
201 | +(+(par[0] - par[3])*(par[0] - par[3]) | |
202 | +(par[1] - par[4])*(par[1] - par[4]) | |
203 | +(par[2] - par[5])*(par[2] - par[5]))*TMath::Cos(2*par[6]) | |
204 | +4*(x[0] - x[1])*(par[2] - par[5])*TMath::Sin(par[6])); | |
205 | ||
206 | if (inSqrt<0) return inSqrt*1e10; | |
207 | ||
208 | Double_t phix = ((+2*(par[0] - par[3])*(x[0] - x[1]) | |
209 | -2*(par[0] - par[3])*(par[2] - par[5])*TMath::Sin(par[6]) | |
210 | +TMath::Sqrt(2)*(par[1] - par[4]) | |
211 | *TMath::Sqrt(inSqrt)) | |
212 | /(2*(+(par[0] - par[3])*(par[0] - par[3]) | |
213 | +(par[1] - par[4])*(par[1] - par[4]))*TMath::Cos(par[6]))); | |
214 | ||
215 | phix = TMath::ACos(phix); | |
216 | ||
217 | return phix; | |
218 | } | |
219 | ||
220 | Double_t AliMUONSurveyUtil::phixnn(Double_t *x, Double_t *par){ | |
221 | ||
222 | Double_t inSqrt = TMath::Abs(+(par[0] - par[3])*(par[0] - par[3]) | |
223 | -2*(x[0] - x[1])*(x[0] - x[1]) | |
224 | +(par[1] - par[4] + par[2] - par[5])*(par[1] - par[4] - par[2] + par[5]) | |
225 | +(+(par[0] - par[3])*(par[0] - par[3]) | |
226 | +(par[1] - par[4])*(par[1] - par[4]) | |
227 | +(par[2] - par[5])*(par[2] - par[5]))*TMath::Cos(2*par[6]) | |
228 | + 4*(x[0] - x[1])*(par[2] - par[5])*TMath::Sin(par[6])); | |
229 | ||
230 | if (inSqrt<0) return inSqrt*1e10; | |
231 | ||
232 | Double_t phix = (+(+2*(par[0] - par[3])*(x[0] - x[1]) | |
233 | -2*(par[0] - par[3])*(par[2] - par[5])*TMath::Sin(par[6]) | |
234 | +TMath::Sqrt(2)*(-par[1] + par[4]) | |
235 | *TMath::Sqrt(inSqrt)) | |
236 | /(2*(+(par[0] - par[3])*(par[0] - par[3]) | |
237 | +(par[1] - par[4])*(par[1] - par[4]))*TMath::Cos(par[6]))); | |
238 | ||
239 | phix = -TMath::ACos(phix); | |
240 | ||
241 | return phix; | |
242 | } | |
243 | ||
244 | Double_t AliMUONSurveyUtil::phixnp(Double_t *x, Double_t *par){ | |
245 | ||
246 | Double_t inSqrt = TMath::Abs(+(par[0] - par[3])*(par[0] - par[3]) | |
247 | -2*(x[0] - x[1])*(x[0] - x[1]) | |
248 | +(par[1] - par[4] + par[2] - par[5])*(par[1] - par[4] - par[2] + par[5]) | |
249 | +(+(par[0] - par[3])*(par[0] - par[3]) | |
250 | +(par[1] - par[4])*(par[1] - par[4]) | |
251 | +(par[2] - par[5])*(par[2] - par[5]))*TMath::Cos(2*par[6]) | |
252 | +4*(x[0] - x[1])*(par[2] - par[5])*TMath::Sin(par[6])); | |
253 | ||
254 | if (inSqrt<0) return inSqrt*1e10; | |
255 | ||
256 | Double_t phix = (+(+2*(par[0] - par[3])*(x[0] - x[1]) | |
257 | -2*(par[0] - par[3])*(par[2] - par[5])*TMath::Sin(par[6]) | |
258 | +TMath::Sqrt(2)*(-par[1] + par[4]) | |
259 | *TMath::Sqrt(inSqrt)) | |
260 | /(2*(+(par[0] - par[3])*(par[0] - par[3]) | |
261 | +(par[1] - par[4])*(par[1] - par[4]))*TMath::Cos(par[6]))); | |
262 | ||
263 | phix = TMath::ACos(phix); | |
264 | ||
265 | return phix; | |
266 | } | |
267 | ||
268 | Double_t AliMUONSurveyUtil::ypCenter(Double_t *x, Double_t *par){ | |
269 | // par : x1l, y1l, z1l, x2l, y2l, z2, lpsi, tht, | |
270 | ||
271 | Double_t lCosPsi = TMath::Cos(par[6]); | |
272 | Double_t lSinPsi = TMath::Sin(par[6]); | |
273 | Double_t lCosTht = TMath::Cos(par[7]); | |
274 | Double_t lSinTht = TMath::Sin(par[7]); | |
275 | ||
276 | Double_t yD = ((1./((par[0] - par[3])*(par[0] - par[3]) + (par[1] - par[4])*(par[1] - par[4]))) | |
277 | *(+par[3]*par[3]*x[0] | |
278 | +par[0]*par[0]*x[1] | |
279 | -par[0]*par[3]*(x[0] + x[1]) | |
280 | +(par[1] - par[4])*(-x[0]*par[4] + par[1]*x[1]) | |
281 | +(par[3]*par[3]*par[2] | |
282 | +par[0]*par[0]*par[5] | |
283 | -par[0]*par[3]*(par[2] + par[5]) | |
284 | +(par[1] - par[4])*(-par[4]*par[2] + par[1]*par[5]))*lCosTht*lSinPsi | |
285 | +(-par[3]*par[1] + par[0]*par[4]) | |
286 | *TMath::Sqrt(-(x[0] - x[1] | |
287 | +(par[2] - par[5])*lCosTht*lSinPsi) | |
288 | *(x[0] - x[1] | |
289 | +(par[2] - par[5])*lCosTht*lSinPsi) | |
290 | + ((par[0] - par[3])*(par[0] - par[3]) | |
291 | +(par[1] - par[4])*(par[1] - par[4]))*(lCosPsi*lCosPsi | |
292 | +lSinPsi*lSinPsi*lSinTht*lSinTht)))); | |
293 | ||
294 | return yD; | |
295 | } | |
296 | ||
297 | Double_t AliMUONSurveyUtil::phiypn(Double_t *x, Double_t *par){ | |
298 | ||
299 | Double_t lCosPsi = TMath::Cos(par[6]); | |
300 | Double_t lSinPsi = TMath::Sin(par[6]); | |
301 | Double_t lCosTht = TMath::Cos(par[7]); | |
302 | Double_t lSinTht = TMath::Sin(par[7]); | |
303 | ||
304 | Double_t phiy = ((lCosPsi*((par[1] - par[4])*(x[0] - x[1]) | |
305 | +(par[1] - par[4])*(par[2] - par[5])*lCosTht*lSinPsi | |
306 | +(-par[0] + par[3]) | |
307 | *TMath::Sqrt(-(x[0] - x[1] | |
308 | +(par[2] - par[5])*lCosTht*lSinPsi) | |
309 | *(x[0] - x[1] | |
310 | +(par[2] - par[5])*lCosTht*lSinPsi) | |
311 | +(+(par[0] - par[3])*(par[0] - par[3]) | |
312 | +(par[1] - par[4])*(par[1] - par[4]))*(lCosPsi*lCosPsi | |
313 | +lSinPsi*lSinPsi*lSinTht*lSinTht))) | |
314 | +lSinPsi*lSinTht*((par[0] - par[3])*(x[0] - x[1]) | |
315 | +(par[0] - par[3])*(par[2] - par[5])*lCosTht*lSinPsi | |
316 | +(par[1] - par[4]) | |
317 | *TMath::Sqrt(-(x[0] - x[1] | |
318 | +(par[2] - par[5])*lCosTht*lSinPsi) | |
319 | *(x[0] - x[1] | |
320 | +(par[2] - par[5])*lCosTht*lSinPsi) | |
321 | + ((par[0] - par[3])*(par[0] - par[3]) | |
322 | +(par[1] - par[4])*(par[1] - par[4]))*(lCosPsi*lCosPsi | |
323 | +lSinPsi*lSinPsi*lSinTht*lSinTht)))) | |
324 | /((+(par[0] - par[3])*(par[0] - par[3]) | |
325 | +(par[1] - par[4])*(par[1] - par[4]))*(lCosPsi*lCosPsi | |
326 | +lSinPsi*lSinPsi*lSinTht*lSinTht))); | |
327 | ||
328 | phiy = -TMath::ACos(phiy); | |
329 | ||
330 | ||
331 | return phiy; | |
332 | } | |
333 | ||
334 | Double_t AliMUONSurveyUtil::phiypp(Double_t *x, Double_t *par){ | |
335 | ||
336 | Double_t lCosPsi = TMath::Cos(par[6]); | |
337 | Double_t lSinPsi = TMath::Sin(par[6]); | |
338 | Double_t lCosTht = TMath::Cos(par[7]); | |
339 | Double_t lSinTht = TMath::Sin(par[7]); | |
340 | ||
341 | Double_t phiy = ((lCosPsi*((par[1] - par[4])*(x[0] - x[1]) | |
342 | +(par[1] - par[4])*(par[2] - par[5])*lCosTht*lSinPsi | |
343 | +(-par[0] + par[3]) | |
344 | *TMath::Sqrt(-(x[0] - x[1] | |
345 | +(par[2] - par[5])*lCosTht*lSinPsi) | |
346 | *(x[0] - x[1] | |
347 | +(par[2] - par[5])*lCosTht*lSinPsi) | |
348 | +((par[0] - par[3])*(par[0] - par[3]) | |
349 | +(par[1] - par[4])*(par[1] - par[4]))*(lCosPsi*lCosPsi | |
350 | +lSinPsi*lSinPsi*lSinTht*lSinTht))) | |
351 | +lSinPsi*lSinTht*((par[0] - par[3])*(x[0] - x[1]) | |
352 | +(par[0] - par[3])*(par[2] - par[5])*lCosTht*lSinPsi | |
353 | +(par[1] - par[4])*TMath::Sqrt(-(x[0] - x[1] | |
354 | +(par[2] - par[5])*lCosTht*lSinPsi) | |
355 | *(x[0] - x[1] | |
356 | +(par[2] - par[5])*lCosTht*lSinPsi) | |
357 | +((par[0] - par[3])*(par[0] - par[3]) | |
358 | +(par[1] - par[4])*(par[1] - par[4]))*(lCosPsi*lCosPsi | |
359 | +lSinPsi*lSinPsi*lSinTht*lSinTht)))) | |
360 | /(((par[0] - par[3])*(par[0] - par[3]) | |
361 | +(par[1] - par[4])*(par[1] - par[4]))*(lCosPsi*lCosPsi | |
362 | +lSinPsi*lSinPsi*lSinTht*lSinTht))); | |
363 | ||
364 | phiy = TMath::ACos(phiy); | |
365 | ||
366 | return phiy; | |
367 | } | |
368 | ||
369 | Double_t AliMUONSurveyUtil::ynCenter(Double_t *x, Double_t *par){ | |
370 | ||
371 | Double_t lCosPsi = TMath::Cos(par[6]); | |
372 | Double_t lSinPsi = TMath::Sin(par[6]); | |
373 | Double_t lCosTht = TMath::Cos(par[7]); | |
374 | Double_t lSinTht = TMath::Sin(par[7]); | |
375 | ||
376 | Double_t yD = ((1./(+(par[0] - par[3])*(par[0] - par[3]) | |
377 | +(par[1] - par[4])*(par[1] - par[4]))) | |
378 | *(+par[3]*par[3]*x[0] | |
379 | +par[0]*par[0]*x[1] | |
380 | -par[0]*par[3]*(x[0] + x[1]) | |
381 | +(par[1] - par[4])*(-x[0]*par[4] + par[1]*x[1]) | |
382 | +(+par[3]*par[3]*par[2] | |
383 | +par[0]*par[0]*par[5] | |
384 | -par[0]*par[3]*(par[2] + par[5]) | |
385 | +(par[1] - par[4])*(-par[4]*par[2] + par[1]*par[5]))*lCosTht*lSinPsi | |
386 | +(par[3]*par[1] - par[0]*par[4]) | |
387 | *TMath::Sqrt(-(+x[0] - x[1] | |
388 | +(par[2] - par[5])*lCosTht*lSinPsi) | |
389 | *(x[0] - x[1] | |
390 | +(par[2] - par[5])*lCosTht*lSinPsi) | |
391 | +((par[0] - par[3])*(par[0] - par[3]) | |
392 | +(par[1] - par[4])*(par[1] - par[4]))*(+lCosPsi*lCosPsi | |
393 | +lSinPsi*lSinPsi*lSinTht*lSinTht)))); | |
394 | ||
395 | return yD; | |
396 | } | |
397 | ||
398 | ||
399 | Double_t AliMUONSurveyUtil::phiynn(Double_t *x, Double_t *par){ | |
400 | ||
401 | Double_t lCosPsi = TMath::Cos(par[6]); | |
402 | Double_t lSinPsi = TMath::Sin(par[6]); | |
403 | Double_t lCosTht = TMath::Cos(par[7]); | |
404 | Double_t lSinTht = TMath::Sin(par[7]); | |
405 | ||
406 | Double_t phiy = ((lCosPsi*(+(par[1] - par[4])*(x[0] - x[1]) | |
407 | +(par[1] - par[4])*(par[2] - par[5])*lCosTht*lSinPsi | |
408 | +(par[0] - par[3]) | |
409 | *TMath::Sqrt(-(x[0] - x[1] | |
410 | +(par[2] - par[5])*lCosTht*lSinPsi) | |
411 | *(x[0] - x[1] | |
412 | +(par[2] - par[5])*lCosTht*lSinPsi) | |
413 | +(+(par[0] - par[3])*(par[0] - par[3]) | |
414 | +(par[1] - par[4])*(par[1] - par[4]))*(+lCosPsi*lCosPsi | |
415 | +lSinPsi*lSinPsi*lSinTht*lSinTht))) | |
416 | +lSinPsi*lSinTht*(+(par[0] - par[3])*(x[0] - x[1]) | |
417 | +(par[0] - par[3])*(par[2] - par[5])*lCosTht*lSinPsi | |
418 | +(-par[1] + par[4]) | |
419 | *TMath::Sqrt(-(x[0] - x[1] | |
420 | +(par[2] - par[5])*lCosTht*lSinPsi) | |
421 | *(x[0] - x[1] | |
422 | +(par[2] - par[5])*lCosTht*lSinPsi) | |
423 | +(+(par[0] - par[3])*(par[0] - par[3]) | |
424 | +(par[1] - par[4])*(par[1] - par[4]))*(+lCosPsi*lCosPsi | |
425 | +lSinPsi*lSinPsi*lSinTht*lSinTht)))) | |
426 | /((+(par[0] - par[3])*(par[0] - par[3]) | |
427 | +(par[1] - par[4])*(par[1] - par[4]))*(+lCosPsi*lCosPsi | |
428 | +lSinPsi*lSinPsi*lSinTht*lSinTht))); | |
429 | ||
430 | phiy = -TMath::ACos(phiy); | |
431 | ||
432 | return phiy; | |
433 | } | |
434 | ||
435 | ||
436 | Double_t AliMUONSurveyUtil::phiynp(Double_t *x, Double_t *par){ | |
437 | ||
438 | Double_t lCosPsi = TMath::Cos(par[6]); | |
439 | Double_t lSinPsi = TMath::Sin(par[6]); | |
440 | Double_t lCosTht = TMath::Cos(par[7]); | |
441 | Double_t lSinTht = TMath::Sin(par[7]); | |
442 | ||
443 | Double_t phiy = ((lCosPsi*(+(par[1] - par[4])*(x[0] - x[1]) | |
444 | +(par[1] - par[4])*(par[2] - par[5])*lCosTht*lSinPsi | |
445 | +(par[0] - par[3]) | |
446 | *TMath::Sqrt(-(x[0] - x[1] | |
447 | +(par[2] - par[5])*lCosTht*lSinPsi) | |
448 | *(x[0] - x[1] | |
449 | +(par[2] - par[5])*lCosTht*lSinPsi) | |
450 | +((par[0] - par[3])*(par[0] - par[3]) | |
451 | +(par[1] - par[4])*(par[1] - par[4]))*(+lCosPsi*lCosPsi | |
452 | +lSinPsi*lSinPsi*lSinTht*lSinTht))) | |
453 | +lSinPsi*lSinTht*(+(par[0] - par[3])*(x[0] - x[1]) | |
454 | +(par[0] - par[3])*(par[2] - par[5])*lCosTht*lSinPsi | |
455 | +(-par[1] + par[4]) | |
456 | *TMath::Sqrt(-(x[0] - x[1] | |
457 | +(par[2] - par[5])*lCosTht*lSinPsi) | |
458 | *(x[0] - x[1] | |
459 | +(par[2] - par[5])*lCosTht*lSinPsi) | |
460 | +((par[0] - par[3])*(par[0] - par[3]) | |
461 | +(par[1] - par[4])*(par[1] - par[4]))*(+lCosPsi*lCosPsi | |
462 | +lSinPsi*lSinPsi*lSinTht*lSinTht)))) | |
463 | /((+(par[0] - par[3])*(par[0] - par[3]) | |
464 | +(par[1] - par[4])*(par[1] - par[4]))*(+lCosPsi*lCosPsi | |
465 | +lSinPsi*lSinPsi*lSinTht*lSinTht))); | |
466 | ||
467 | phiy = TMath::ACos(phiy); | |
468 | ||
469 | return phiy; | |
470 | } | |
471 | ||
472 | Double_t AliMUONSurveyUtil::znCenter(Double_t *x, Double_t *par){ | |
473 | // par : x1l, y1l, z1l, x2l, y2l, z2l, psi, tht | |
474 | ||
475 | Double_t lCosPsi = TMath::Cos(par[6]); | |
476 | Double_t lSinPsi = TMath::Sin(par[6]); | |
477 | Double_t lCosTht = TMath::Cos(par[7]); | |
478 | Double_t lSinTht = TMath::Sin(par[7]); | |
479 | ||
480 | Double_t inSqrt = ((par[3]*par[1] - par[0]*par[4])*(par[3]*par[1] - par[0]*par[4]) | |
481 | *((-(x[0] - x[1])*(x[0] - x[1])) | |
482 | +(((par[0] - par[3])*(par[0] - par[3]) | |
483 | +(par[1] - par[4])*(par[1] - par[4])))*lSinPsi*lSinPsi | |
484 | +lCosPsi*((-(par[2] - par[5])) | |
485 | *lCosTht*(-2*x[0]+2*x[1] | |
486 | +(par[2] - par[5])*lCosPsi*lCosTht) | |
487 | +((par[0] - par[3])*(par[0] - par[3]) | |
488 | +(par[1] - par[4])*(par[1] - par[4]))*lCosPsi*lSinTht*lSinTht))); | |
489 | ||
490 | if (inSqrt<0) return inSqrt*1e10; | |
491 | ||
492 | Double_t zD = ((1./((par[0] - par[3])*(par[0] - par[3]) | |
493 | +(par[1] - par[4])*(par[1] - par[4]))) | |
494 | *(-par[1]*par[4]*x[0] | |
495 | +par[4]*par[4]*x[0] | |
496 | +par[0]*par[0]*x[1] | |
497 | +par[1]*par[1]*x[1] | |
498 | -par[1]*par[4]*x[1] | |
499 | -par[0]*par[3]*(x[0] + x[1]) | |
500 | +par[3]*par[3]*x[0] | |
501 | +(+par[1]*par[4]*par[2] | |
502 | -par[4]*par[4]*par[2] | |
503 | -par[0]*par[0]*par[5] | |
504 | -par[1]*par[1]*par[5] | |
505 | +par[1]*par[4]*par[5] | |
506 | +par[0]*par[3]*(par[2] + par[5]) | |
507 | -par[3]*par[3]*par[2])*lCosPsi*lCosTht | |
508 | -TMath::Sqrt(inSqrt))); | |
509 | ||
510 | return zD; | |
511 | } | |
512 | ||
513 | Double_t AliMUONSurveyUtil::zpCenter(Double_t *x, Double_t *par){ | |
514 | // par : x1l, y1l, z1l, x2l, y2l, z2l, psi, tht | |
515 | ||
516 | Double_t lCosPsi = TMath::Cos(par[6]); | |
517 | Double_t lSinPsi = TMath::Sin(par[6]); | |
518 | Double_t lCosTht = TMath::Cos(par[7]); | |
519 | Double_t lSinTht = TMath::Sin(par[7]); | |
520 | ||
521 | Double_t inSqrt = ((par[3]*par[1] - par[0]*par[4])*(par[3]*par[1] - par[0]*par[4]) | |
522 | *((-(x[0] - x[1])*(x[0] - x[1])) | |
523 | +(((par[0] - par[3])*(par[0] - par[3]) | |
524 | +(par[1] - par[4])*(par[1] - par[4])))*lSinPsi*lSinPsi | |
525 | +lCosPsi*((-(par[2] - par[5])) | |
526 | *lCosTht*(-2*x[0]+2*x[1] | |
527 | +(par[2] - par[5])*lCosPsi*lCosTht) | |
528 | +((par[0] - par[3])*(par[0] - par[3]) | |
529 | +(par[1] - par[4])*(par[1] - par[4]))*lCosPsi*lSinTht*lSinTht))); | |
530 | ||
531 | if (inSqrt<0) return inSqrt*1e10; | |
532 | ||
533 | Double_t zD = ((1./((par[0] - par[3])*(par[0] - par[3]) | |
534 | +(par[1] - par[4])*(par[1] - par[4]))) | |
535 | *(-par[1]*par[4]*x[0] | |
536 | +par[4]*par[4]*x[0] | |
537 | +par[0]*par[0]*x[1] | |
538 | +par[1]*par[1]*x[1] | |
539 | -par[1]*par[4]*x[1] | |
540 | -par[0]*par[3]*(x[0] + x[1]) | |
541 | +par[3]*par[3]*x[0] | |
542 | +(+par[1]*par[4]*par[2] | |
543 | -par[4]*par[4]*par[2] | |
544 | -par[0]*par[0]*par[5] | |
545 | -par[1]*par[1]*par[5] | |
546 | +par[1]*par[4]*par[5] | |
547 | +par[0]*par[3]*(par[2] + par[5]) | |
548 | -par[3]*par[3]*par[2])*lCosPsi*lCosTht | |
549 | +TMath::Sqrt(inSqrt))); | |
550 | ||
551 | return zD; | |
552 | } | |
553 | ||
554 | //______________________________________________________________________ | |
555 | AliMUONGeometryTransformer* AliMUONSurveyUtil::ReAlign(const AliMUONGeometryTransformer * transformer, | |
556 | int rMod, int rNDetElems, int rDetElemPseudoIdToDetElem[], TGeoCombiTrans deltaDetElemTransf[], Bool_t verbose) | |
557 | { | |
558 | ///////////////////////////////////////////////////////////////////// | |
559 | /// Takes the internal geometry module transformers, copies them | |
560 | /// and gets the Detection Elements from them. | |
561 | /// Takes misalignment parameters and applies these | |
562 | /// to the local transform of the Detection Element | |
563 | /// Obtains the global transform by multiplying the module transformer | |
564 | /// transformation with the local transformation | |
565 | /// Applies the global transform to a new detection element | |
566 | /// Adds the new detection element to a new module transformer | |
567 | /// Adds the new module transformer to a new geometry transformer | |
568 | /// Returns the new geometry transformer | |
569 | ||
570 | Int_t iDetElemId = 0; | |
571 | Int_t iDetElemPseudoId = 0; | |
572 | ||
573 | AliMUONGeometryTransformer *newGeometryTransformer = | |
574 | new AliMUONGeometryTransformer(); | |
575 | for (Int_t iMt = 0; iMt < transformer->GetNofModuleTransformers(); iMt++) { | |
576 | // module transformers | |
577 | const AliMUONGeometryModuleTransformer *kModuleTransformer = | |
578 | transformer->GetModuleTransformer(iMt, true); | |
579 | ||
580 | AliMUONGeometryModuleTransformer *newModuleTransformer = | |
581 | new AliMUONGeometryModuleTransformer(iMt); | |
582 | newGeometryTransformer->AddModuleTransformer(newModuleTransformer); | |
583 | ||
584 | TGeoCombiTrans moduleTransform = | |
585 | TGeoCombiTrans(*kModuleTransformer->GetTransformation()); | |
586 | // New module transformation | |
587 | TGeoCombiTrans *newModuleTransform; | |
588 | if ((rMod<4 && iMt==rMod) || (rMod>=4 && (iMt==4+(rMod-4)*2||iMt==4+(rMod-4)*2+1))) { | |
589 | newModuleTransform = new TGeoCombiTrans(moduleTransform*deltaDetElemTransf[rNDetElems]); | |
590 | } else { | |
591 | newModuleTransform = new TGeoCombiTrans(moduleTransform); | |
592 | } | |
593 | newModuleTransformer->SetTransformation(*newModuleTransform); | |
594 | ||
595 | // For the selected chamber add misalign module | |
596 | if ((rMod<4 && iMt==rMod) || (rMod>=4 && (iMt==4+(rMod-4)*2||iMt==4+(rMod-4)*2+1))) { | |
597 | // Get delta transformation: | |
598 | // Tdelta = Tnew * Told.inverse | |
599 | TGeoHMatrix deltaModuleTransform = | |
600 | AliMUONGeometryBuilder::Multiply(*newModuleTransform, | |
601 | kModuleTransformer->GetTransformation()->Inverse()); | |
602 | // Create module mis alignment matrix | |
603 | newGeometryTransformer | |
604 | ->AddMisAlignModule(kModuleTransformer->GetModuleId(), deltaModuleTransform); | |
605 | } | |
606 | ||
607 | AliMpExMap *detElements = kModuleTransformer->GetDetElementStore(); | |
608 | ||
609 | if (verbose) | |
610 | printf("%i DEs in old GeometryStore %i\n",detElements->GetSize(), iMt); | |
611 | TGeoCombiTrans *deltaLocalTransform; | |
612 | TIter next(detElements->CreateIterator()); | |
613 | AliMUONGeometryDetElement *detElement; | |
614 | while ((detElement = static_cast<AliMUONGeometryDetElement*>(next()))){ | |
615 | /// make a new detection element | |
616 | AliMUONGeometryDetElement *newDetElement = | |
617 | new AliMUONGeometryDetElement(detElement->GetId(), | |
618 | detElement->GetVolumePath()); | |
619 | TString lDetElemName(detElement->GetDEName()); | |
620 | lDetElemName.ReplaceAll("DE",""); | |
621 | iDetElemId = lDetElemName.Atoi(); | |
622 | iDetElemPseudoId = iDetElemId%100; | |
623 | if ((rMod<4 && iMt==rMod) || (rMod>=4 && (iMt==4+(rMod-4)*2||iMt==4+(rMod-4)*2+1))) { | |
624 | deltaLocalTransform = new TGeoCombiTrans(deltaDetElemTransf[rDetElemPseudoIdToDetElem[iDetElemPseudoId]]); | |
625 | } else { | |
626 | deltaLocalTransform = new TGeoCombiTrans(*gGeoIdentity); | |
627 | } | |
628 | ||
629 | // local transformation of this detection element. | |
630 | TGeoCombiTrans localTransform | |
631 | = TGeoCombiTrans(*detElement->GetLocalTransformation()); | |
632 | // TGeoHMatrix newLocalMatrix = localTransform * (*deltaLocalTransform); | |
633 | TGeoCombiTrans newLocalTransform | |
634 | = TGeoCombiTrans(localTransform * (*deltaLocalTransform)); | |
635 | newDetElement->SetLocalTransformation(newLocalTransform); | |
636 | // global transformation | |
637 | TGeoHMatrix newGlobalTransform = | |
638 | AliMUONGeometryBuilder::Multiply(*newModuleTransform, | |
639 | newLocalTransform); | |
640 | newDetElement->SetGlobalTransformation(newGlobalTransform); | |
641 | ||
642 | // add this det element to module | |
643 | newModuleTransformer->GetDetElementStore()->Add(newDetElement->GetId(), | |
644 | newDetElement); | |
645 | ||
646 | // In the Alice Alignment Framework misalignment objects store | |
647 | // global delta transformation | |
648 | // Get detection "intermediate" global transformation | |
649 | TGeoHMatrix newOldGlobalTransform = (*newModuleTransform) * localTransform; | |
650 | // Get detection element global delta transformation: | |
651 | // Tdelta = Tnew * Told.inverse | |
652 | TGeoHMatrix deltaGlobalTransform | |
653 | = AliMUONGeometryBuilder::Multiply(newGlobalTransform, | |
654 | newOldGlobalTransform.Inverse()); | |
655 | ||
656 | // Create mis alignment matrix | |
657 | newGeometryTransformer | |
658 | ->AddMisAlignDetElement(detElement->GetId(), deltaGlobalTransform); | |
659 | } | |
660 | ||
661 | if (verbose) | |
662 | printf("Added module transformer %i to the transformer\n", iMt); | |
663 | newGeometryTransformer->AddModuleTransformer(newModuleTransformer); | |
664 | } | |
665 | return newGeometryTransformer; | |
666 | } | |
667 | ||
668 | void AliMUONSurveyUtil::SetAlignmentResolution(const TClonesArray* misAlignArray, Int_t chId, Double_t chResX, Double_t chResY, Double_t deResX, Double_t deResY){ | |
669 | ||
670 | TMatrixDSym mChCorrMatrix(6); | |
671 | mChCorrMatrix[0][0]=chResX*chResX; | |
672 | mChCorrMatrix[1][1]=chResY*chResY; | |
673 | // mChCorrMatrix.Print(); | |
674 | ||
675 | TMatrixDSym mDECorrMatrix(6); | |
676 | mDECorrMatrix[0][0]=deResX*deResX; | |
677 | mDECorrMatrix[1][1]=deResY*deResY; | |
678 | // mDECorrMatrix.Print(); | |
679 | ||
680 | AliAlignObjMatrix *alignMat = 0x0; | |
681 | ||
d011bba5 | 682 | // Int_t modId = (chId<4)? chId : 4+(chId-4)*2; |
ba8b0266 | 683 | TString chName1; |
684 | TString chName2; | |
685 | if (chId<4){ | |
686 | chName1 = Form("GM%d",chId); | |
687 | chName2 = Form("GM%d",chId); | |
688 | } else { | |
689 | chName1 = Form("GM%d",4+(chId-4)*2); | |
690 | chName2 = Form("GM%d",4+(chId-4)*2+1); | |
691 | } | |
692 | ||
693 | for (int i=0; i<misAlignArray->GetEntries(); i++) { | |
694 | alignMat = (AliAlignObjMatrix*)misAlignArray->At(i); | |
695 | TString volName(alignMat->GetSymName()); | |
696 | if((volName.Contains(chName1)&& | |
697 | volName.Last('/')<=volName.Index(chName1)+chName1.Length())|| | |
698 | (volName.Contains(chName2)&& | |
699 | volName.Last('/')<=volName.Index(chName2)+chName2.Length())) { | |
700 | volName.Remove(0,volName.Last('/')+1); | |
701 | if (volName.Contains("GM")) { | |
702 | // alignMat->Print("NULL"); | |
703 | alignMat->SetCorrMatrix(mChCorrMatrix); | |
704 | } else if (volName.Contains("DE")) { | |
705 | // alignMat->Print("NULL"); | |
706 | alignMat->SetCorrMatrix(mDECorrMatrix); | |
707 | } | |
708 | } | |
709 | } | |
710 | } |