]>
Commit | Line | Data |
---|---|---|
02078bdf | 1 | /************************************************************************** |
2 | * Copyright(c) 2008-2010, 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 | // Class to convert survey tables in alignment objects | |
20 | // for SSD and SDD | |
21 | // origin: Marco Van Leeuwen (m.vanleeuwen1@uu.nl) | |
22 | // Panos.Christakoglou (Panos.Christakoglou@cern.ch) | |
23 | // Martin Poghosyan (Martin.Poghosyan@to.infn.it) | |
24 | ////////////////////////////////////////////////////////////////////////// | |
25 | ||
02078bdf | 26 | #include "TGeoManager.h" |
02078bdf | 27 | #include "TGeoPhysicalNode.h" |
28 | #include "TMatrixD.h" | |
29 | #include "TMath.h" | |
30 | ||
31 | #include "AliITSSurveyToAlign.h" | |
02078bdf | 32 | #include "AliSurveyPoint.h" |
33 | #include "AliAlignObjParams.h" | |
34 | #include "AliGeomManager.h" | |
35 | ||
36 | #include "AliLog.h" | |
37 | ||
38 | #include "AliCDBManager.h" | |
02078bdf | 39 | |
40 | #include "AliITSgeomTGeo.h" | |
41 | ||
7640ec1d | 42 | |
43 | //#include "dataSDDladder.h" | |
02078bdf | 44 | ClassImp(AliITSSurveyToAlign) |
45 | ||
46 | const Double_t AliITSSurveyToAlign::fgkLocR[6][3]={{ 3.24,0.21905,-2.4}, | |
47 | { 3.58,0.21905, 0. }, | |
48 | { 3.24,0.21905,+2.4}, | |
49 | {-3.24,0.21905,+2.4}, | |
50 | {-3.58,0.21905, 0. }, | |
51 | {-3.24,0.21905,-2.4}}; | |
52 | ||
53 | const Double_t AliITSSurveyToAlign::fgkLocL[6][3]={{-3.24,0.21905, 2.4}, | |
54 | {-3.58,0.21905, 0. }, | |
55 | {-3.24,0.21905,-2.4}, | |
56 | { 3.24,0.21905,-2.4}, | |
57 | { 3.58,0.21905, 0. }, | |
58 | { 3.24,0.21905, 2.4}}; | |
59 | ||
98380f3e | 60 | const Double_t kRadToDeg = 180./TMath::Pi(); |
02078bdf | 61 | |
62 | //________________________________________________________________________ | |
7640ec1d | 63 | AliITSSurveyToAlign::AliITSSurveyToAlign(Int_t run, Int_t repModSDD, Int_t repModVerSDD, Int_t repLadSDD, Int_t repLadVerSDD, Int_t repModSSD, Int_t repModVerSSD, Int_t repLaddSSD, Int_t repLaddVerSSD) : |
02078bdf | 64 | AliSurveyToAlignObjs(), |
65 | fRun(run), | |
7640ec1d | 66 | fSDDModuleRepNumber(repModSDD), |
67 | fSDDModuleRepVersion(repModVerSDD), | |
68 | fSDDLadderRepNumber(repLadSDD), | |
69 | fSDDLadderRepVersion(repLadVerSDD), | |
02078bdf | 70 | fSSDModuleRepNumber(repModSSD), |
71 | fSSDModuleRepVersion(repModVerSSD), | |
72 | fSSDLadderRepNumber(repLaddSSD), | |
73 | fSSDLadderRepVersion(repLaddVerSSD) | |
74 | { | |
7640ec1d | 75 | // Standard constructor |
76 | for(Int_t i=0; i<260; i++) | |
77 | { | |
78 | fuidSDDm[i]= 0; | |
79 | fsymnameSDDm[i]=TString(""); | |
80 | fxSDDm[i]=0; | |
81 | fySDDm[i]=0; | |
82 | fzSDDm[i]=0; | |
83 | fpsiSDDm[i]=0; | |
84 | ftetSDDm[i]=0; | |
85 | fphiSDDm[i]=0; | |
86 | if(i>35) continue; | |
87 | fuidSDDl[i]=0; | |
88 | fsymnameSDDl[i]=TString(""); | |
89 | fxSDDl[i]=0; | |
90 | fySDDl[i]=0; | |
91 | fzSDDl[i]=0; | |
92 | fpsiSDDl[i]=0; | |
93 | ftetSDDl[i]=0; | |
94 | fphiSDDl[i]=0; | |
95 | } | |
96 | ||
97 | // ftypeSDDlad=0; | |
02078bdf | 98 | // |
99 | // default constructor | |
100 | // Arguments are report numbers for survey data. | |
101 | // The defaults point to reports from detector construction | |
102 | // | |
103 | } | |
104 | ||
105 | //_________________________________________________________________________ | |
106 | AliITSSurveyToAlign::AliITSSurveyToAlign(const AliITSSurveyToAlign &align) : | |
02078bdf | 107 | AliSurveyToAlignObjs(align), |
108 | fRun(align.fRun), | |
7640ec1d | 109 | fSDDModuleRepNumber(align.fSDDModuleRepNumber), |
110 | fSDDModuleRepVersion(align.fSDDModuleRepVersion), | |
111 | fSDDLadderRepNumber(align.fSDDLadderRepNumber), | |
112 | fSDDLadderRepVersion(align.fSDDLadderRepVersion), | |
02078bdf | 113 | fSSDModuleRepNumber(align.fSSDModuleRepNumber), |
114 | fSSDModuleRepVersion(align.fSSDModuleRepVersion), | |
115 | fSSDLadderRepNumber(align.fSSDLadderRepNumber), | |
116 | fSSDLadderRepVersion(align.fSSDLadderRepVersion) | |
117 | { | |
118 | // | |
119 | // copy constructor | |
120 | // | |
7640ec1d | 121 | for(Int_t i=0; i<260; i++) |
122 | { | |
123 | fuidSDDm[i]= align.fuidSDDm[i]; | |
124 | fsymnameSDDm[i]=TString(align.fsymnameSDDm[i]); | |
125 | fxSDDm[i]=align.fxSDDm[i]; | |
126 | fySDDm[i]=align.fySDDm[i]; | |
127 | fzSDDm[i]=align.fzSDDm[i]; | |
128 | fpsiSDDm[i]=align.fpsiSDDm[i]; | |
129 | ftetSDDm[i]=align.ftetSDDm[i]; | |
130 | fphiSDDm[i]=align.fphiSDDm[i]; | |
131 | if(i>35) continue; | |
132 | fuidSDDl[i]=align.fuidSDDl[i]; | |
133 | fsymnameSDDl[i]=TString(align.fsymnameSDDl[i]); | |
134 | fxSDDl[i]=align.fxSDDl[i]; | |
135 | fySDDl[i]=align.fySDDl[i]; | |
136 | fzSDDl[i]=align.fzSDDl[i]; | |
137 | fpsiSDDl[i]=align.fpsiSDDl[i]; | |
138 | ftetSDDl[i]=align.ftetSDDl[i]; | |
139 | fphiSDDl[i]=align.fphiSDDl[i]; | |
140 | } | |
141 | ||
02078bdf | 142 | } |
143 | ||
144 | //__________________________________________________________________________ | |
7640ec1d | 145 | AliITSSurveyToAlign & AliITSSurveyToAlign::operator =(const AliITSSurveyToAlign& align) { |
02078bdf | 146 | // |
7640ec1d | 147 | // assignment operator |
02078bdf | 148 | // |
7640ec1d | 149 | this->~AliITSSurveyToAlign(); |
150 | new(this) AliITSSurveyToAlign(align); | |
151 | return *this; | |
02078bdf | 152 | } |
153 | ||
154 | //__________________________________________________________________________ | |
155 | AliITSSurveyToAlign::~AliITSSurveyToAlign() { | |
156 | // | |
157 | // destructor | |
158 | // | |
159 | } | |
160 | ||
161 | //______________________________________________________________________ | |
162 | void AliITSSurveyToAlign::Run() { | |
163 | // | |
164 | // Runs the full chain | |
2afbf330 | 165 | // User should call StoreAlignObjToFile or StoreAlignObjToCDB afterwards to |
166 | // store output (not included here to leave the choice between the two) | |
02078bdf | 167 | // |
168 | ||
169 | // Load ideal geometry from the OCDB | |
170 | AliCDBManager *cdb = AliCDBManager::Instance(); | |
171 | cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); | |
172 | cdb->SetRun(fRun); | |
173 | AliGeomManager::LoadGeometry(); | |
2afbf330 | 174 | |
175 | if(!CreateAlignObjs()) AliError("Construction of alignment objects from survey failed!"); | |
176 | } | |
177 | ||
178 | //______________________________________________________________________ | |
179 | Bool_t AliITSSurveyToAlign::CreateAlignObjs() { | |
180 | // Fill the array of alignment objects with alignment objects | |
98380f3e | 181 | // from survey for all three subdetectors |
2afbf330 | 182 | // |
183 | ||
184 | //for SPD | |
185 | CreateAlignObjDummySPD(); | |
186 | ||
7640ec1d | 187 | /////////////////////////// |
2afbf330 | 188 | // for SDD |
7640ec1d | 189 | if(!LoadSurveyFromAlienFile("ITS", fSDDModuleRepNumber, fSDDModuleRepVersion)){ |
190 | AliError("Loading of alignment objects from survey for SDD modules failed!"); | |
191 | return kFALSE; | |
192 | } | |
193 | CreateAlignObjSDDModules(); | |
194 | ||
195 | if(!LoadSurveyFromAlienFile("ITS", fSDDLadderRepNumber, fSDDLadderRepVersion)){ | |
196 | AliError("Loading of alignment objects from survey for SDD ladder failed!"); | |
2afbf330 | 197 | return kFALSE; |
198 | } | |
7640ec1d | 199 | CreateAlignObjSDDLadders(); |
200 | if(!ApplyAlignObjSDD()) return kFALSE; | |
201 | ||
2afbf330 | 202 | |
203 | // for SSD ladders | |
204 | if(!LoadSurveyFromAlienFile("ITS", fSSDLadderRepNumber, fSSDLadderRepVersion)){ | |
205 | AliError("Loading of alignment objects from survey for SSD ladders failed!"); | |
206 | return kFALSE; | |
207 | } | |
02078bdf | 208 | CreateAlignObjSSDLadders(); |
2afbf330 | 209 | |
210 | // for SSD modules | |
211 | if(!ApplyAlignObjSSDLadders()) return kFALSE; // needed to build correctly the objects for SSD modules | |
212 | if(!LoadSurveyFromAlienFile("ITS", fSSDModuleRepNumber, fSSDModuleRepVersion)){ | |
213 | AliError("Loading of alignment objects from survey for SSD modules failed!"); | |
214 | return kFALSE; | |
215 | } | |
216 | CreateAlignObjSSDModules(); | |
217 | ||
218 | return kTRUE; | |
02078bdf | 219 | } |
220 | ||
2afbf330 | 221 | //______________________________________________________________________ |
222 | void AliITSSurveyToAlign::CreateAlignObjDummySPD(){ | |
02078bdf | 223 | // |
224 | // Create alignObjs for SPD | |
225 | // For the moment, uses 0,0,0,0,0,0 | |
226 | // | |
227 | for(Int_t imod = 0; imod < 240; imod++) { | |
228 | Int_t ilayer = (imod < 80) ? AliGeomManager::kSPD1 : AliGeomManager::kSPD2; | |
229 | Int_t imodule = (imod < 80) ? imod : imod - 80; | |
230 | ||
231 | Int_t uid = AliGeomManager::LayerToVolUID(ilayer,imodule); | |
232 | const Char_t *symname = AliGeomManager::SymName(uid); | |
233 | ||
234 | new((*fAlignObjArray)[imod]) AliAlignObjParams(symname, uid, 0., 0., 0., 0., 0., 0., kTRUE); | |
235 | }//module loop | |
236 | ||
237 | } | |
7640ec1d | 238 | Bool_t AliITSSurveyToAlign::ApplyAlignObjSDD() |
239 | { | |
240 | // Apply alignment for SDD | |
241 | Int_t applied=0; | |
242 | ||
243 | for(Int_t iLadd=0; iLadd<36; iLadd++) | |
244 | { | |
245 | new((*fAlignObjArray)[240+iLadd]) AliAlignObjParams(fsymnameSDDl[iLadd].Data(), fuidSDDl[iLadd], | |
246 | fxSDDl[iLadd] , fySDDl[iLadd] , fzSDDl[iLadd] , | |
247 | fpsiSDDl[iLadd], ftetSDDl[iLadd], fphiSDDl[iLadd], kFALSE); | |
248 | // new((*fAlignObjArray)[240+iLadd]) AliAlignObjParams(fsymnameSDDl[iLadd].Data(), fuidSDDl[iLadd], | |
249 | // fxSDDl[iLadd] , fySDDl[iLadd] , fzSDDl[iLadd] , | |
250 | // 0, 0, 0, kFALSE); | |
251 | ||
252 | AliAlignObjParams* ap = dynamic_cast<AliAlignObjParams*> (fAlignObjArray->UncheckedAt(240+iLadd)); | |
253 | // printf("%s %f %f %f\n",fxSDDl[iLadd], fsymnameSDDl[iLadd].Data(), fySDDl[iLadd] , fzSDDl[iLadd]); | |
254 | //printf("%d %f\n", iLadd, fzSDDl[iLadd]); | |
255 | ||
256 | if(fsymnameSDDl[iLadd].Contains("SDD") && fsymnameSDDl[iLadd].Contains("Ladder")) | |
257 | { | |
258 | // printf("%d %s %d\n",240+iLadd, fsymnameSDDl[iLadd].Data(),fuidSDDl[iLadd] ); | |
259 | ||
260 | if(!ap->ApplyToGeometry()) return kFALSE; | |
261 | applied++; | |
262 | } | |
263 | else | |
264 | { | |
265 | AliError("SDD Ladder array is not initialized correctly"); | |
266 | return kFALSE; | |
267 | } | |
268 | } | |
269 | ||
270 | for(Int_t iMod=0; iMod<260; iMod++) | |
271 | { | |
272 | new((*fAlignObjArray)[240+36+iMod]) AliAlignObjParams(fsymnameSDDm[iMod].Data(), fuidSDDm[iMod], | |
273 | fxSDDm[iMod], fySDDm[iMod], fzSDDm[iMod], | |
274 | fpsiSDDm[iMod], ftetSDDm[iMod], fphiSDDm[iMod], kFALSE); | |
275 | ||
276 | // printf("%d %s %f %f %f\n",240+36+iMod, fsymnameSDDm[iMod].Data(),fxSDDm[iMod], fySDDm[iMod], fzSDDm[iMod] ); | |
277 | ||
278 | if(!fsymnameSDDm[iMod].Contains("SDD") || !fsymnameSDDm[iMod].Contains("Sensor")) | |
279 | { | |
280 | AliError("SDD Module array is not initialized correctly\n"); | |
281 | return kFALSE; | |
282 | } | |
283 | ||
284 | } | |
285 | ||
286 | AliInfo(Form(" %d alignment objects for SDD ladders applied to geometry.",applied)); | |
287 | return kTRUE; | |
288 | } | |
02078bdf | 289 | |
2afbf330 | 290 | //______________________________________________________________________ |
7640ec1d | 291 | void AliITSSurveyToAlign::CreateAlignObjSDDModules(){ |
02078bdf | 292 | // |
293 | // Create alignment objects for SDD | |
294 | // Called by Run() | |
295 | // | |
296 | Int_t uid = 0; | |
297 | const char* symname = 0; | |
298 | AliSurveyPoint* pt = 0; | |
299 | ||
300 | Int_t iModuleIndex=240; | |
301 | Int_t iModule0=0; | |
302 | Int_t iLadder0=0; | |
303 | Int_t iLayer0=3; | |
304 | Int_t nModules=0; | |
305 | ||
306 | if (fSurveyPoints == 0 || fSurveyPoints->GetEntries() == 0) { | |
307 | AliWarning("SDD survey data are not available, using zero values"); | |
7640ec1d | 308 | CreateAlignObjDummySDDModules(); |
02078bdf | 309 | return; |
310 | } | |
311 | ||
312 | for(Int_t imod = 1; imod < fSurveyPoints->GetEntries(); imod++) { | |
313 | pt = (AliSurveyPoint*) fSurveyPoints->At(imod); | |
314 | if(!pt) continue; | |
315 | ||
316 | Int_t iLayer, iLadder, iModule, iPoint; | |
317 | ReadPointNameSDD(pt->GetName(),iLayer, iLadder, iModule, iPoint); | |
318 | ||
319 | if(iModule==iModule0) | |
320 | { | |
321 | fSDDmeP[iPoint][0]=pt->GetX(); | |
322 | fSDDmeP[iPoint][1]=pt->GetY(); | |
323 | fSDDmeP[iPoint][2]=pt->GetZ(); | |
324 | fSDDmeP[iPoint][3]=pt->GetPrecisionX(); | |
325 | fSDDmeP[iPoint][4]=pt->GetPrecisionY(); | |
326 | fSDDmeP[iPoint][5]=pt->GetPrecisionZ(); | |
327 | fSDDisMe[iPoint]=kTRUE; | |
328 | ||
329 | if(iLayer==3) uid = AliGeomManager::LayerToVolUID(iLayer0,iModuleIndex-240); | |
330 | if(iLayer==4) uid = AliGeomManager::LayerToVolUID(iLayer0,iModuleIndex-324); | |
331 | symname = AliGeomManager::SymName(uid); | |
332 | GetIdPosSDD(uid,iLayer0, iModule0, iPoint); | |
333 | nModules++; | |
334 | } | |
335 | // cout << "Points red module " << imod << endl; | |
336 | if((iModule!=iModule0)||(imod==(fSurveyPoints->GetEntries()-1))) | |
337 | { | |
338 | ConvertToRSofModulesAndRotSDD(iLayer0, iModule0); | |
339 | ||
340 | Double_t tet = 0.; | |
341 | Double_t psi =0.; | |
342 | Double_t phi = 0.; | |
343 | Double_t x0 = 0.; | |
344 | Double_t y0 =0.; | |
345 | Double_t z0 = 0.; | |
346 | ||
347 | if(nModules==2) CalcShiftSDD(x0,y0,z0); | |
348 | if(nModules>2) CalcShiftRotSDD(tet, psi, phi, x0, y0, z0); | |
98380f3e | 349 | tet*=kRadToDeg; |
350 | psi*=kRadToDeg; | |
351 | phi*=kRadToDeg; | |
02078bdf | 352 | |
353 | // printf("%s %d %f %f %f %f %f %f\n",symname, uid, x0/10., y0/10., z0/10., psi, tet, phi); | |
354 | // cout << "Allocate alignobjparams " << imod << endl; | |
7640ec1d | 355 | |
356 | // new((*fAlignObjArray)[iModuleIndex]) AliAlignObjParams(symname, uid, x0/10., y0/10., z0/10., psi, tet, phi, kFALSE); | |
357 | // printf("INDEX: Module: %d\n",iModuleIndex); | |
358 | ||
359 | fsymnameSDDm[iModuleIndex-240]=TString(symname); | |
360 | fuidSDDm[iModuleIndex-240]=uid; | |
361 | fxSDDm[iModuleIndex-240]=x0/10.; | |
362 | fySDDm[iModuleIndex-240]=y0/10.; | |
363 | fzSDDm[iModuleIndex-240]=z0/10.; | |
364 | fpsiSDDm[iModuleIndex-240]=psi; | |
365 | ftetSDDm[iModuleIndex-240]=tet; | |
366 | fphiSDDm[iModuleIndex-240]=phi; | |
367 | ||
368 | // new((*fAlignObjArray)[36+iModuleIndex]) AliAlignObjParams(fsymnameSDDm[iModuleIndex-240].Data(), fuidSDDm[iModuleIndex-240], | |
369 | // fxSDDm[iModuleIndex-240], fySDDm[iModuleIndex-240], fzSDDm[iModuleIndex-240], | |
370 | // fpsiSDDm[iModuleIndex-240], ftetSDDm[iModuleIndex-240], fphiSDDm[iModuleIndex-240], kFALSE); | |
02078bdf | 371 | |
372 | iModule0=iModule; | |
373 | iLayer0=iLayer; | |
374 | iLadder0=iLadder; | |
375 | nModules=0; | |
376 | iModuleIndex = AliITSgeomTGeo::GetModuleIndex(iLayer,iLadder+1,iModule+1); | |
377 | for(Int_t i=0; i<6;i++) fSDDisMe[i]=kFALSE; | |
378 | if(imod!=(fSurveyPoints->GetEntries()-1)) imod--; | |
379 | } | |
380 | }//module loop | |
381 | } | |
382 | ||
2afbf330 | 383 | //______________________________________________________________________ |
7640ec1d | 384 | void AliITSSurveyToAlign::CreateAlignObjDummySDDModules(){ |
02078bdf | 385 | // |
386 | // Create empty alignment objects | |
387 | // Used when fSurveySDD == 0 | |
388 | // | |
389 | for(Int_t imod = 0; imod < 260; imod++) { | |
390 | ||
391 | Int_t ilayer = (imod < 84) ? AliGeomManager::kSDD1 : AliGeomManager::kSDD2; | |
392 | Int_t imodule = (imod < 84) ? imod : imod - 84; | |
393 | ||
394 | Int_t uid = AliGeomManager::LayerToVolUID(ilayer,imodule); | |
395 | const Char_t *symname = AliGeomManager::SymName(uid); | |
396 | ||
7640ec1d | 397 | fsymnameSDDm[imod]=TString(symname); |
398 | fuidSDDm[imod]=uid; | |
399 | fxSDDm[imod]=0.; | |
400 | fySDDm[imod]=0.; | |
401 | fzSDDm[imod]=0.; | |
402 | fpsiSDDm[imod]=0.; | |
403 | ftetSDDm[imod]=0.; | |
404 | fphiSDDm[imod]=0.; | |
405 | ||
406 | // new((*fAlignObjArray)[imod+36+240]) AliAlignObjParams(symname, uid, 0., 0., 0., 0., 0., 0., kTRUE); | |
02078bdf | 407 | }//module loop |
408 | } | |
409 | ||
2afbf330 | 410 | //______________________________________________________________________ |
02078bdf | 411 | void AliITSSurveyToAlign::CreateAlignObjSSDModules(){ |
412 | // | |
2afbf330 | 413 | // Create alignment objects for SSD modules |
414 | // Objects for SSD ladders must be applied to geometry first | |
02078bdf | 415 | // |
416 | Double_t sx, sz; | |
417 | const Float_t kMu2Cm = 1e-4; | |
418 | const Float_t kSensLength = 7.464; | |
419 | const Int_t kSSDMODULES = 1698; | |
420 | ||
421 | if (fSurveyPoints == 0 || fSurveyPoints->GetEntries() == 0) { | |
422 | AliWarning("SSD module survey data not available; using dummy values"); | |
423 | CreateAlignObjDummySSDModules(); | |
424 | return; | |
425 | } | |
426 | ||
427 | // First do module-by-module | |
428 | ||
429 | for(Int_t imod = 500; imod < kSSDMODULES + 500; imod++) { | |
430 | Int_t iLayer, iLadder, iLaddMod; | |
431 | AliITSgeomTGeo::GetModuleId(imod,iLayer,iLadder,iLaddMod); // returns 1-based numbers | |
432 | ||
433 | TString pname="ITS/SSD"; | |
434 | pname += iLayer-1; | |
435 | pname += "/Ladder"; | |
436 | pname += iLadder-1; | |
437 | pname += "/Sensor"; | |
438 | pname += iLaddMod-1; | |
439 | AliSurveyPoint *pt1 = (AliSurveyPoint*) fSurveyPoints->FindObject(pname+"/Point0"); | |
440 | AliSurveyPoint *pt2 = (AliSurveyPoint*) fSurveyPoints->FindObject(pname+"/Point1"); | |
441 | if(!pt1 || !pt2) { | |
442 | AliWarning(Form("No Survey points for iladd %d imod %d",iLadder,iLaddMod)); | |
443 | continue; | |
444 | } | |
445 | ||
446 | sx = 0.5*(pt1->GetX() + pt2->GetX()) * kMu2Cm; | |
447 | sz = 0.5*(pt1->GetZ() + pt2->GetZ()) * kMu2Cm; | |
448 | ||
449 | // Minus sign to change local coordinate convention | |
450 | Float_t theta = -(pt2->GetZ() - pt1->GetZ())*kMu2Cm/kSensLength; | |
451 | ||
98380f3e | 452 | theta *= kRadToDeg; |
02078bdf | 453 | Int_t iLayMod = imod - 500; |
454 | if (iLayer == 6) | |
455 | iLayMod -= 748; | |
456 | Int_t uid = AliGeomManager::LayerToVolUID(iLayer,iLayMod); | |
457 | ||
458 | const Char_t *symname = AliGeomManager::SymName(uid); | |
459 | if (pname.CompareTo(symname) != 0) | |
460 | AliWarning(Form("Mapping mismatch survey point %s volume name %s",pname.Data(),symname)); | |
461 | /* | |
462 | if (imod >= 676 && imod <= 697) { | |
463 | cout << "ilayer " << iLayer << " imod " << imod | |
464 | << " uid " << uid << " name " << symname | |
465 | << " survey shift " << sx << " " << 0 << " " << sz << endl | |
466 | << " theta " << theta << endl; | |
467 | } | |
468 | */ | |
7640ec1d | 469 | new((*fAlignObjArray)[imod+36]) AliAlignObjParams(symname, uid, sx, 0, sz, 0., theta, 0., kFALSE); |
02078bdf | 470 | } //module loop |
471 | } | |
472 | ||
2afbf330 | 473 | //______________________________________________________________________ |
474 | Bool_t AliITSSurveyToAlign::ApplyAlignObjSSDLadders(){ | |
475 | // | |
476 | // Apply alignment objects for SSD ladders to geometry, needed to correctly | |
477 | // build alignment objects for SSD modules | |
478 | // | |
6e732991 | 479 | Int_t applied=0; |
480 | ||
2afbf330 | 481 | for(Int_t jj=0; jj<fAlignObjArray->GetEntriesFast(); jj++) |
482 | { | |
483 | AliAlignObjParams* ap = dynamic_cast<AliAlignObjParams*> (fAlignObjArray->UncheckedAt(jj)); | |
484 | if(ap) | |
485 | { | |
486 | TString sName(ap->GetSymName()); | |
487 | if(sName.Contains("SSD") && sName.Contains("Ladder")) | |
6e732991 | 488 | { |
489 | if(!ap->ApplyToGeometry()) return kFALSE; | |
490 | applied++; | |
491 | } | |
2afbf330 | 492 | } |
493 | } | |
6e732991 | 494 | AliInfo(Form(" %d alignment objects for SSD ladders applied to geometry.",applied)); |
2afbf330 | 495 | |
6e732991 | 496 | return kTRUE; |
2afbf330 | 497 | } |
7640ec1d | 498 | //______________________________________________________________________ |
499 | /* | |
500 | Bool_t AliITSSurveyToAlign::ApplyAlignObjSDDLadders(){ | |
501 | // | |
502 | // Apply alignment objects for SDD ladders to geometry, needed to correctly | |
503 | // build alignment objects for SDD modules | |
504 | // | |
505 | Int_t applied=0; | |
506 | ||
507 | for(Int_t jj=0; jj<fAlignObjArray->GetEntriesFast(); jj++) | |
508 | { | |
509 | AliAlignObjParams* ap = dynamic_cast<AliAlignObjParams*> (fAlignObjArray->UncheckedAt(jj)); | |
510 | if(ap) | |
511 | { | |
512 | TString sName(ap->GetSymName()); | |
513 | // printf("%s\n",sName.Data()); | |
514 | if(sName.Contains("SDD") && sName.Contains("Ladder")) | |
515 | { | |
516 | if(!ap->ApplyToGeometry()) return kFALSE; | |
517 | applied++; | |
518 | } | |
519 | } | |
520 | } | |
521 | AliInfo(Form(" %d alignment objects for SDD ladders applied to geometry.",applied)); | |
522 | ||
523 | return kTRUE; | |
524 | } | |
525 | */ | |
526 | //______________________________________________________________________ | |
527 | void AliITSSurveyToAlign::CreateAlignObjDummySDDLadders() | |
528 | { | |
529 | // | |
530 | // Create empty alignment objects | |
531 | TString sddName = "ITS/SDD"; | |
532 | Int_t iLadd = 0; | |
533 | ||
534 | for (Int_t ilayer = 0; ilayer < 2; ilayer ++) | |
535 | { | |
536 | Int_t nLadder = 14; // layer SDD1 | |
537 | if (ilayer == 1) nLadder = 22; // layer SDD2 | |
538 | for (Int_t iLadder = 0; iLadder < nLadder; iLadder++) { | |
539 | TString ladName = sddName; | |
540 | ladName += (ilayer+2); | |
541 | ladName += "/Ladder"; | |
542 | ladName += iLadder; | |
543 | fsymnameSDDl[iLadd]=TString(ladName); | |
544 | fuidSDDl[iLadd]=0; | |
545 | fxSDDl[iLadd]=0; | |
546 | fySDDl[iLadd]=10; | |
547 | fzSDDl[iLadd]=0; | |
548 | fpsiSDDl[iLadd]=0; | |
549 | ftetSDDl[iLadd]=0; | |
550 | fphiSDDl[iLadd]=0; | |
551 | iLadd++; | |
552 | } // Ladder loop | |
553 | } // Layer loop | |
554 | ||
555 | } | |
556 | ||
557 | ||
558 | ||
559 | void AliITSSurveyToAlign::CreateAlignObjSDDLadders(){ | |
560 | // | |
561 | // Alignment objects from survey for SDD ladders | |
562 | // | |
563 | const Float_t kLaddLenz[2] ={500, 650}; // Layer 2,3: distance between mouting points along z (mm) | |
564 | const Float_t kLaddLenx = 28 ; // Layer 2,3: distance between mouting points along x (mm) | |
565 | ||
566 | TString sddName = "ITS/SDD"; | |
567 | ||
568 | TObjArray *ladderPoints = fSurveyPoints; | |
569 | if (ladderPoints == 0 || ladderPoints->GetEntries() == 0) { | |
570 | AliWarning("No SDD Ladder alignment points found. Skipping"); | |
571 | return; | |
572 | } | |
573 | if (ladderPoints->GetEntries()!= 72) { | |
574 | AliWarning(Form("Unexpected number of survey points %d, should be 72",ladderPoints->GetEntries())); | |
575 | } | |
576 | ||
577 | ||
578 | /* | |
579 | TAlien::Connect("alien://"); | |
580 | gSystem->Load("libXMLParser.so"); | |
581 | .x loadlibs.C | |
582 | ||
583 | AliCDBManager *cdb = AliCDBManager::Instance(); | |
584 | cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB"); | |
585 | cdb->SetRun(0); | |
586 | AliGeomManager::LoadGeometry(); | |
587 | AliITSSurveyToAlign *a = new AliITSSurveyToAlign(); | |
588 | ||
589 | a->CreateAlignObjSDDLadders() | |
590 | a->ApplyAlignObjSDDLadders(); | |
591 | ||
592 | a->LoadSurveyFromAlienFile("ITS", 845069, 1); | |
593 | a->CreateAlignObjSDD(); | |
594 | ||
595 | a->CreateAlignObjs(); | |
596 | */ | |
597 | ||
598 | // Int_t type =0; | |
599 | //////////////////////////////////////////////////////////// | |
600 | // pRB2X[layer][ladder][dx,dy,dz] | |
601 | Double_t pRB24[2][22][3]; //(mm) | |
602 | Double_t pRB26[2][22][3]; //(mm) | |
603 | ||
604 | ||
605 | pRB24[0][0][2] = 0.0228; pRB26[0][0][2] = 0.0284; pRB24[0][0][0] =-0.0377; pRB26[0][0][0] =-0.0008; pRB24[0][0][1] =-0.0336; pRB26[0][0][1] = 0.0540; | |
606 | pRB24[0][1][2] =-0.0175; pRB26[0][1][2] =-0.0186; pRB24[0][1][0] =-0.0143; pRB26[0][1][0] = 0.0348; pRB24[0][1][1] =-0.0123; pRB26[0][1][1] = 0.0407; | |
607 | pRB24[0][2][2] = 0.1313; pRB26[0][2][2] = 0.0302; pRB24[0][2][0] = 0.2408; pRB26[0][2][0] = 0.1113; pRB24[0][2][1] =-0.0150; pRB26[0][2][1] =-0.0194; | |
608 | pRB24[0][3][2] = 0.0307; pRB26[0][3][2] = 0.0350; pRB24[0][3][0] = 0.1140; pRB26[0][3][0] = 0.0952; pRB24[0][3][1] =-0.0423; pRB26[0][3][1] =-0.0375; | |
609 | pRB24[0][4][2] =-0.0159; pRB26[0][4][2] = 0.0185; pRB24[0][4][0] = 0.0713; pRB26[0][4][0] = 0.0803; pRB24[0][4][1] =-0.1311; pRB26[0][4][1] =-0.1201; | |
610 | pRB24[0][5][2] =-0.0128; pRB26[0][5][2] =-0.0209; pRB24[0][5][0] = 0.0436; pRB26[0][5][0] = 0.0606; pRB24[0][5][1] =-0.1551; pRB26[0][5][1] =-0.0587; | |
611 | pRB24[0][6][2] =-0.0257; pRB26[0][6][2] =-0.0044; pRB24[0][6][0] = 0.0380; pRB26[0][6][0] = 0.0264; pRB24[0][6][1] =-0.1913; pRB26[0][6][1] =-0.1851; | |
612 | pRB24[0][7][2] = 0.0185; pRB26[0][7][2] = 0.1450; pRB24[0][7][0] =-0.0406; pRB26[0][7][0] =-0.0426; pRB24[0][7][1] = 0.1564; pRB26[0][7][1] = 0.2998; | |
613 | pRB24[0][8][2] = 0.0048; pRB26[0][8][2] = 0.0077; pRB24[0][8][0] = 0.0290; pRB26[0][8][0] = 0.0361; pRB24[0][8][1] = 0.1321; pRB26[0][8][1] = 0.1679; | |
614 | pRB24[0][9][2] = 0.0049; pRB26[0][9][2] = 0.0115; pRB24[0][9][0] = 0.0405; pRB26[0][9][0] = 0.1058; pRB24[0][9][1] = 0.0319; pRB26[0][9][1] = 0.2464; | |
615 | pRB24[0][10][2]=-0.0017; pRB26[0][10][2]= 0.0100; pRB24[0][10][0]= 0.0724; pRB26[0][10][0]= 0.1035; pRB24[0][10][1]= 0.0561; pRB26[0][10][1]= 0.0713; | |
616 | pRB24[0][11][2]=-0.0021; pRB26[0][11][2]= 0.0202; pRB24[0][11][0]= 0.0590; pRB26[0][11][0]= 0.0596; pRB24[0][11][1]=-0.0875; pRB26[0][11][1]=-0.0591; | |
617 | pRB24[0][12][2]=-0.0200; pRB26[0][12][2]= 0.0242; pRB24[0][12][0]= 0.0664; pRB26[0][12][0]= 0.0780; pRB24[0][12][1]=-0.0197; pRB26[0][12][1]=-0.0227; | |
618 | pRB24[0][13][2]=-0.0382; pRB26[0][13][2]=-0.0139; pRB24[0][13][0]=-0.0320; pRB26[0][13][0]=-0.0136; pRB24[0][13][1]=-0.0798; pRB26[0][13][1]=-0.0843; | |
619 | pRB24[1][0][2] = 0.0191; pRB26[1][0][2] = 0.0295; pRB24[1][0][0] =-0.0776; pRB26[1][0][0] =-0.0585; pRB24[1][0][1] =-0.0148; pRB26[1][0][1] = 0.0123; | |
620 | pRB24[1][1][2] = 0.0135; pRB26[1][1][2] = 0.0074; pRB24[1][1][0] =-0.0289; pRB26[1][1][0] =-0.0213; pRB24[1][1][1] = 0.0064; pRB26[1][1][1] = 0.0289; | |
621 | pRB24[1][2][2] = 0.0096; pRB26[1][2][2] = 0.0011; pRB24[1][2][0] = 0.0123; pRB26[1][2][0] = 0.0404; pRB24[1][2][1] =-0.0246; pRB26[1][2][1] =-0.0064; | |
622 | pRB24[1][3][2] = 0.0209; pRB26[1][3][2] =-0.0049; pRB24[1][3][0] = 0.0322; pRB26[1][3][0] = 0.0447; pRB24[1][3][1] = 0.0066; pRB26[1][3][1] = 0.0284; | |
623 | pRB24[1][4][2] = 0.0149; pRB26[1][4][2] =-0.0033; pRB24[1][4][0] = 0.0530; pRB26[1][4][0] = 0.0822; pRB24[1][4][1] =-0.0455; pRB26[1][4][1] =-0.0365; | |
624 | pRB24[1][5][2] = 0.0395; pRB26[1][5][2] = 0.0094; pRB24[1][5][0] = 0.0633; pRB26[1][5][0] = 0.0933; pRB24[1][5][1] =-0.1133; pRB26[1][5][1] =-0.1070; | |
625 | pRB24[1][6][2] = 0.0288; pRB26[1][6][2] =-0.0002; pRB24[1][6][0] = 0.0692; pRB26[1][6][0] = 0.0916; pRB24[1][6][1] =-0.1670; pRB26[1][6][1] =-0.1670; | |
626 | pRB24[1][7][2] = 0.0238; pRB26[1][7][2] =-0.0090; pRB24[1][7][0] = 0.0625; pRB26[1][7][0] = 0.0607; pRB24[1][7][1] =-0.1592; pRB26[1][7][1] =-0.1678; | |
627 | pRB24[1][8][2] = 0.0196; pRB26[1][8][2] =-0.0738; pRB24[1][8][0] = 0.0639; pRB26[1][8][0] = 0.0686; pRB24[1][8][1] =-0.2050; pRB26[1][8][1] =-0.2056; | |
628 | pRB24[1][9][2] = 0.0029; pRB26[1][9][2] =-0.0051; pRB24[1][9][0] = 0.0178; pRB26[1][9][0] = 0.0170; pRB24[1][9][1] =-0.1042; pRB26[1][9][1] =-0.1159; | |
629 | pRB24[1][10][2]=-0.0108; pRB26[1][10][2]=-0.0023; pRB24[1][10][0]=-0.0005; pRB26[1][10][0]= 0.0119; pRB24[1][10][1]=-0.1353; pRB26[1][10][1]=-0.1461; | |
630 | pRB24[1][11][2]=-0.0131; pRB26[1][11][2]=-0.0233; pRB24[1][11][0]=-0.0202; pRB26[1][11][0]=-0.0242; pRB24[1][11][1]=-0.1883; pRB26[1][11][1]=-0.2031; | |
631 | pRB24[1][12][2]= 0.0028; pRB26[1][12][2]= 0.0036; pRB24[1][12][0]=-0.0066; pRB26[1][12][0]= 0.0011; pRB24[1][12][1]= 0.2024; pRB26[1][12][1]= 0.2382; | |
632 | pRB24[1][13][2]= 0.0111; pRB26[1][13][2]= 0.0029; pRB24[1][13][0]= 0.0283; pRB26[1][13][0]= 0.0287; pRB24[1][13][1]= 0.2057; pRB26[1][13][1]= 0.2384; | |
633 | pRB24[1][14][2]= 0.0140; pRB26[1][14][2]=-0.0657; pRB24[1][14][0]= 0.0682; pRB26[1][14][0]= 0.0825; pRB24[1][14][1]= 0.1650; pRB26[1][14][1]= 0.2545; | |
634 | pRB24[1][15][2]= 0.0263; pRB26[1][15][2]=-0.0013; pRB24[1][15][0]= 0.0909; pRB26[1][15][0]= 0.0709; pRB24[1][15][1]= 0.1093; pRB26[1][15][1]= 0.1321; | |
635 | pRB24[1][16][2]= 0.0025; pRB26[1][16][2]=-0.0045; pRB24[1][16][0]= 0.0672; pRB26[1][16][0]= 0.0955; pRB24[1][16][1]= 0.0745; pRB26[1][16][1]= 0.0901; | |
636 | pRB24[1][17][2]= 0.0060; pRB26[1][17][2]= 0.0035; pRB24[1][17][0]= 0.0664; pRB26[1][17][0]= 0.0739; pRB24[1][17][1]= 0.0471; pRB26[1][17][1]= 0.0598; | |
637 | pRB24[1][18][2]=-0.0124; pRB26[1][18][2]=-0.0168; pRB24[1][18][0]= 0.0710; pRB26[1][18][0]= 0.0866; pRB24[1][18][1]= 0.0123; pRB26[1][18][1]= 0.0237; | |
638 | pRB24[1][19][2]=-0.0125; pRB26[1][19][2]=-0.0178; pRB24[1][19][0]= 0.0433; pRB26[1][19][0]= 0.0535; pRB24[1][19][1]= 0.0234; pRB26[1][19][1]= 0.0262; | |
639 | pRB24[1][20][2]=-0.0021; pRB26[1][20][2]= 0.0100; pRB24[1][20][0]= 0.0213; pRB26[1][20][0]= 0.0394; pRB24[1][20][1]= 0.0734; pRB26[1][20][1]= 0.0677; | |
640 | pRB24[1][21][2]=-0.0490; pRB26[1][21][2]=-0.0222; pRB24[1][21][0]=-0.0269; pRB26[1][21][0]=-0.0039; pRB24[1][21][1]= 0.0160; pRB26[1][21][1]= 0.0076; | |
641 | ||
642 | ||
643 | ||
644 | Int_t iLadd = 0; | |
645 | ||
646 | for (Int_t ilayer = 0; ilayer < 2; ilayer ++) | |
647 | { | |
648 | Int_t nLadder = 14; // layer SDD1 | |
649 | if (ilayer == 1) nLadder = 22; // layer SDD2 | |
650 | ||
651 | for (Int_t iLadder = 0; iLadder < nLadder; iLadder++) { | |
652 | TString ladName = sddName; | |
653 | ladName += (ilayer+2); | |
654 | ladName += "/Ladder"; | |
655 | ladName += iLadder; | |
656 | Double_t drLoc[3]; | |
657 | // for(Int_t i=0; i<3; i++) drLoc[i]=(pRB26[ilayer][iLadder][i]+pRB24[ilayer][iLadder][i])/20.; // average | |
658 | ||
659 | ||
660 | ///////////////////////////////////////////////////////////////////////////// | |
661 | AliSurveyPoint *p24 = (AliSurveyPoint*) ladderPoints->FindObject(ladName+"/RB24"); | |
662 | AliSurveyPoint *p26 = (AliSurveyPoint*) ladderPoints->FindObject(ladName+"/RB26"); | |
663 | if (p24 == 0) { | |
664 | AliWarning(Form("Cannot find RB24 side point for ladder %s",ladName.Data())); | |
665 | continue; | |
666 | } | |
667 | if (p26 == 0) { | |
668 | AliWarning(Form("Cannot find RB26 side point for ladder %s",ladName.Data())); | |
669 | continue; | |
670 | } | |
671 | ||
672 | TString tmpStr; | |
673 | tmpStr.Insert(0,p24->GetName(),3); | |
674 | Int_t ladder = tmpStr.Atoi(); | |
675 | tmpStr=""; | |
676 | tmpStr.Insert(0,p26->GetName(),3); | |
677 | if (tmpStr.Atoi() != ladder) | |
678 | AliError(Form("Survey data file error. Expect pairs of RB24, RB26 points. Got ladders %d %d",ladder,tmpStr.Atoi())); | |
679 | ||
680 | for(Int_t i=0; i<3; i++) drLoc[i]=pRB24[ilayer][iLadder][i]/10.; | |
681 | ||
682 | Double_t x24, y24, z24; | |
683 | Double_t x26, y26, z26; | |
684 | ||
685 | x24=p24->GetX(); | |
686 | y24=p24->GetY(); | |
687 | z24=p24->GetZ(); | |
688 | x26=p26->GetX(); | |
689 | y26=p26->GetY(); | |
690 | z26=p26->GetZ(); | |
691 | ||
692 | // for top ladders: RS(local) = RS(global) + Y_shift | |
693 | // rot around z-axis | |
694 | Double_t phi = 0; // Not measured | |
695 | // rot around y-axis | |
696 | Double_t theta = 0; | |
697 | // rot around x-axis | |
698 | Double_t psi = 0; | |
699 | ||
700 | ||
701 | psi=TMath::ATan((y26-y24)/(kLaddLenz[ilayer]+z24-z26)); | |
702 | Double_t tgtet0 = kLaddLenx/kLaddLenz[ilayer]; | |
703 | Double_t tgtet1 = (x24-x26+kLaddLenx)/(kLaddLenz[ilayer]+z24-z26); | |
704 | theta=TMath::ATan((tgtet1-tgtet0)/(1+tgtet1*tgtet0)); | |
705 | ||
706 | Double_t x0=x24-theta*kLaddLenz[ilayer]/2; | |
707 | Double_t y0=y24+psi*kLaddLenz[ilayer]/2; | |
708 | Double_t z0=z24+theta*kLaddLenx/2; | |
709 | ||
710 | theta*= kRadToDeg; | |
711 | psi*= kRadToDeg; | |
712 | ||
713 | AliDebug(1,Form("ladname %f %f %f %f %f %f ",drLoc[0],drLoc[1],drLoc[2],psi,theta,phi)); | |
714 | // local delta transformation by passing 3 shifts (in centimeters) and 3 angles (expressed in degrees) | |
715 | // new((*fAlignObjArray)[500+1698+144+iLadd]) AliAlignObjParams(ladName,0,drLoc[0],drLoc[1],drLoc[2],psi,theta,phi,kFALSE); | |
716 | fsymnameSDDl[iLadd]=TString(ladName); | |
717 | fuidSDDl[iLadd]=0; | |
718 | fxSDDl[iLadd]=x0/10.; | |
719 | fySDDl[iLadd]=y0/10.; | |
720 | fzSDDl[iLadd]=z0/10.; | |
721 | fpsiSDDl[iLadd]=psi; | |
722 | ftetSDDl[iLadd]=theta; | |
723 | fphiSDDl[iLadd]=phi; | |
724 | // new((*fAlignObjArray)[240+iLadd]) AliAlignObjParams(fsymnameSDDl[iLadd].Data(), fuidSDDl[iLadd], | |
725 | // fxSDDl[iLadd] , fySDDl[iLadd] , fzSDDl[iLadd] , | |
726 | // fpsiSDDl[iLadd], ftetSDDl[iLadd], fphiSDDl[iLadd], kFALSE); | |
727 | // printf("INDEX: Ladder: %d\n",iLadd); | |
728 | iLadd++; | |
729 | } // Ladder loop | |
730 | } // Layer loop | |
731 | } | |
732 | //////////////////////////////////////////////////////////////////////////////////////// | |
733 | ||
734 | ||
2afbf330 | 735 | |
736 | //______________________________________________________________________ | |
02078bdf | 737 | void AliITSSurveyToAlign::CreateAlignObjSSDLadders(){ |
738 | // | |
2afbf330 | 739 | // Alignment objects from survey for SSD ladders (Torino data) |
02078bdf | 740 | // |
741 | const Float_t kLaddLen5 = 90.27; // Layer 5: distance between mouting points | |
742 | const Float_t kLaddLen6 = 102.0; // Layer 6: distance between mouting points | |
98380f3e | 743 | const Float_t zLag = 2.927; // Distance between V mounting point and Zloc = 0 |
02078bdf | 744 | // = half ladder length - nom z-position of ladder from gGeoManager |
745 | const Float_t kMu2Cm = 1e-4; | |
746 | ||
747 | TString ssdName = "ITS/SSD"; | |
748 | ||
98380f3e | 749 | TObjArray *ladderPoints = fSurveyPoints; |
750 | if (ladderPoints == 0 || ladderPoints->GetEntries() == 0) { | |
02078bdf | 751 | AliWarning("No SSD Ladder alignment points found. Skipping"); |
752 | return; | |
753 | } | |
98380f3e | 754 | if (ladderPoints->GetEntries()!= 2*(34+38)) { |
755 | AliWarning(Form("Unexpected number of survey points %d, should be 144",ladderPoints->GetEntries())); | |
02078bdf | 756 | } |
757 | Int_t iLadd = 0; | |
758 | for (Int_t ilayer = 4; ilayer <= 5; ilayer ++) { | |
759 | Int_t nLadder = 34; // layer 5 | |
760 | if (ilayer == 5) | |
761 | nLadder = 38; // layer 6 | |
762 | ||
763 | for (Int_t iLadder = 0; iLadder < nLadder; iLadder++) { | |
764 | TString ladName = ssdName; | |
765 | ladName += ilayer; | |
766 | ladName += "/Ladder"; | |
767 | ladName += iLadder; | |
768 | ||
98380f3e | 769 | AliSurveyPoint *vPoint = (AliSurveyPoint*) ladderPoints->FindObject(ladName+"/V"); |
770 | AliSurveyPoint *qPoint = (AliSurveyPoint*) ladderPoints->FindObject(ladName+"/Q"); | |
771 | if (vPoint == 0) { | |
02078bdf | 772 | AliWarning(Form("Cannot find V side point for ladder %s",ladName.Data())); |
773 | continue; | |
774 | } | |
98380f3e | 775 | if (qPoint == 0) { |
02078bdf | 776 | AliWarning(Form("Cannot find Q side point for ladder %s",ladName.Data())); |
777 | continue; | |
778 | } | |
779 | ||
98380f3e | 780 | TString tmpStr; |
781 | tmpStr.Insert(0,vPoint->GetName(),3); | |
782 | Int_t ladder = tmpStr.Atoi(); | |
783 | tmpStr=""; | |
784 | tmpStr.Insert(0,qPoint->GetName(),3); | |
785 | if (tmpStr.Atoi() != ladder) | |
786 | AliError(Form("Survey data file error. Expect pairs of V,Q points. Got ladders %d %d",ladder,tmpStr.Atoi())); | |
02078bdf | 787 | |
788 | // Note: file gives meas-nom in local offline coordinates, | |
789 | // ie. local z = - global z and local x = - global x (for ladder 508, i.e. top ladder) | |
98380f3e | 790 | Double_t dxLoc = vPoint->GetX() * kMu2Cm; |
791 | Double_t dyLoc = vPoint->GetY() * kMu2Cm; | |
792 | Double_t dzLoc = vPoint->GetZ() * kMu2Cm; | |
02078bdf | 793 | |
794 | // rot around z-axis | |
795 | Double_t phi = 0; // Not measured | |
796 | // rot around y-axis | |
797 | Double_t theta = 0; | |
798 | Double_t psi = 0; | |
799 | ||
800 | // Note: local psi = -global psi, psi = atan(-(y(z1) - y(z0)) / (z1-z0)) | |
801 | // local theta = global theta = atan(dx/dz) | |
802 | // V side is A side is large global z | |
803 | // Q side is C side is large local z | |
804 | ||
7640ec1d | 805 | |
02078bdf | 806 | if (ladder >= 600) { |
98380f3e | 807 | theta = TMath::ATan((qPoint->GetX() - vPoint->GetX())*kMu2Cm/kLaddLen6); |
808 | psi = TMath::ATan((vPoint->GetY() - qPoint->GetY())*kMu2Cm/kLaddLen6); | |
02078bdf | 809 | } |
810 | else { | |
98380f3e | 811 | theta = TMath::ATan((qPoint->GetX() - vPoint->GetX())*kMu2Cm/kLaddLen5); |
812 | psi = TMath::ATan((vPoint->GetY() - qPoint->GetY())*kMu2Cm/kLaddLen5); | |
02078bdf | 813 | } |
814 | ||
815 | // Move along ladder to local Z = 0 point | |
98380f3e | 816 | dxLoc += zLag*theta; |
817 | dyLoc -= zLag*psi; | |
02078bdf | 818 | |
819 | // Convert to degrees | |
98380f3e | 820 | theta *= kRadToDeg; |
821 | psi *= kRadToDeg; | |
822 | AliDebug(1,Form("ladname %f %f %f %f %f %f ",dxLoc,dyLoc,dzLoc,psi,theta,phi)); | |
02078bdf | 823 | |
7640ec1d | 824 | new((*fAlignObjArray)[500+36+1698+iLadd]) AliAlignObjParams(ladName,0,dxLoc,dyLoc,dzLoc,psi,theta,phi,kFALSE); |
02078bdf | 825 | |
826 | iLadd++; | |
827 | } // Ladder loop | |
828 | } // Layer loop | |
829 | } | |
7640ec1d | 830 | //////////////////////////////////////////////////////////////////////////////////////// |
02078bdf | 831 | |
2afbf330 | 832 | //______________________________________________________________________ |
02078bdf | 833 | void AliITSSurveyToAlign::CreateAlignObjDummySSDModules(){ |
834 | // | |
835 | // Create empty alignment objects | |
836 | // Used when fSurveySSD == 0 | |
837 | // | |
838 | for(Int_t imod = 0; imod < 1698; imod++) { | |
839 | Int_t ilayer = (imod < 748) ? AliGeomManager::kSSD1 : AliGeomManager::kSSD2; | |
840 | Int_t imodule = (imod < 748) ? imod : imod - 748; | |
841 | ||
842 | Int_t uid = AliGeomManager::LayerToVolUID(ilayer,imodule); | |
843 | const Char_t *symname = AliGeomManager::SymName(uid); | |
844 | ||
7640ec1d | 845 | new((*fAlignObjArray)[500+36+imod]) AliAlignObjParams(symname, uid, 0., 0., 0., 0., 0., 0., kTRUE); |
02078bdf | 846 | }//module loop |
847 | } | |
848 | ||
849 | ||
2afbf330 | 850 | //______________________________________________________________________ |
02078bdf | 851 | void AliITSSurveyToAlign::GetIdPosSDD(Int_t uid, Int_t layer, Int_t module, Int_t iPoint) |
852 | { | |
853 | // | |
854 | // Utility function used by CreateAlignObjSDD | |
855 | // | |
856 | TGeoHMatrix gMod = *AliGeomManager::GetMatrix(uid); //global matrix of sensor | |
857 | TGeoPNEntry* pne = gGeoManager->GetAlignableEntryByUID(uid); | |
858 | // TString ladderPath = AliGeomManager::SymName(uid); | |
859 | TString ladderPath(pne->GetTitle()); | |
860 | if(ladderPath.EndsWith("/")) ladderPath.Remove(TString::kTrailing,'/'); | |
861 | ladderPath.Remove(ladderPath.Last('/')); | |
7640ec1d | 862 | // ladderPath.Remove(ladderPath.Last('/')); |
02078bdf | 863 | gGeoManager->cd(ladderPath.Data()); |
864 | TGeoHMatrix gLad = *gGeoManager->GetCurrentMatrix(); // global matrix of ladder | |
7640ec1d | 865 | |
866 | ||
02078bdf | 867 | TGeoHMatrix rel = gMod; // to equal relative matrix ladder to sensor. |
868 | TGeoHMatrix invgLad = gLad.Inverse(); | |
869 | rel.MultiplyLeft(&invgLad); | |
870 | TGeoRotation* rr = new TGeoRotation("rr",90,90,0,0,90,180); | |
871 | TGeoCombiTrans* ct = 0; | |
872 | if(layer==3) ct= new TGeoCombiTrans(25.,0.,0.,rr); | |
873 | if(layer==4) ct= new TGeoCombiTrans(25.+7.5,0.,0.,rr); | |
874 | ||
875 | rel.MultiplyLeft(ct); | |
876 | ||
877 | if((layer==3)&&(module<3)) rel.LocalToMaster(fgkLocR[iPoint],fSDDidP[iPoint]); | |
878 | if((layer==3)&&(module>2)) rel.LocalToMaster(fgkLocL[iPoint],fSDDidP[iPoint]); | |
879 | if((layer==4)&&(module<4)) rel.LocalToMaster(fgkLocR[iPoint],fSDDidP[iPoint]); | |
880 | if((layer==4)&&(module>3)) rel.LocalToMaster(fgkLocL[iPoint],fSDDidP[iPoint]); | |
881 | ||
7640ec1d | 882 | for(Int_t i=0; i<3; i++) fSDDidP[iPoint][i]*=10; |
883 | fSDDidP[iPoint][2]-=0.5205; | |
884 | ||
885 | // if(ladderPath.Data(),"/ALIC_1/ITSV_1/ITSsddLayer3_1/ITSsddLadd_3"); | |
886 | // if(ladderPath.Contains("ITSsddLayer3_1") && (ladderPath.Contains("ITSsddLadd_3")|| ladderPath.Contains("ITSsddLadd_10"))) | |
887 | // { | |
888 | ///ALIC_1/ITSV_1/ITSsddLayer4_1/ITSsddLadd_5 | |
889 | ///ALIC_1/ITSV_1/ITSsddLayer4_1/ITSsddLadd_16 | |
890 | // gLad.Print(); | |
891 | // printf("%s : Module# %d Point# %d\n",ladderPath.Data(), module, iPoint); | |
892 | // printf("ID {%f, %f, %f}\n", fSDDidP[iPoint][0],fSDDidP[iPoint][1],fSDDidP[iPoint][2]); | |
893 | // printf("Me {%f, %f, %f}\n", fSDDmeP[iPoint][0],fSDDmeP[iPoint][1],fSDDmeP[iPoint][2]); | |
894 | // } | |
02078bdf | 895 | } |
896 | ||
2afbf330 | 897 | //______________________________________________________________________ |
98380f3e | 898 | void AliITSSurveyToAlign::ReadPointNameSDD(const char str[], Int_t &iLayer, Int_t &iLader, Int_t &iModul, Int_t &iPoint) const |
02078bdf | 899 | { |
900 | // | |
901 | // Utility function used by CreateAlignObjSDD | |
902 | // | |
903 | iLayer=-1; | |
904 | iLader=-1; | |
905 | iModul=-1; | |
906 | iPoint=-1; | |
907 | ||
908 | if(str[7]=='2') iLayer=3; | |
909 | if(str[7]=='3') iLayer=4; | |
910 | ||
911 | if(str[15]=='0') iLader=0; | |
912 | if(str[15]=='1') iLader=1; | |
913 | if(str[15]=='2') iLader=2; | |
914 | if(str[15]=='3') iLader=3; | |
915 | if(str[15]=='4') iLader=4; | |
916 | if(str[15]=='5') iLader=5; | |
917 | if(str[15]=='6') iLader=6; | |
918 | if(str[15]=='7') iLader=7; | |
919 | if(str[15]=='8') iLader=8; | |
920 | if(str[15]=='9') iLader=9; | |
921 | ||
922 | Int_t ord=0; | |
923 | if(str[16]=='0') {iLader=10*iLader+0; ord=1;} | |
924 | if(str[16]=='1') {iLader=10*iLader+1; ord=1;} | |
925 | if(str[16]=='2') {iLader=10*iLader+2; ord=1;} | |
926 | if(str[16]=='3') {iLader=10*iLader+3; ord=1;} | |
927 | if(str[16]=='4') {iLader=10*iLader+4; ord=1;} | |
928 | if(str[16]=='5') {iLader=10*iLader+5; ord=1;} | |
929 | if(str[16]=='6') {iLader=10*iLader+6; ord=1;} | |
930 | if(str[16]=='7') {iLader=10*iLader+7; ord=1;} | |
931 | if(str[16]=='8') {iLader=10*iLader+8; ord=1;} | |
932 | if(str[16]=='9') {iLader=10*iLader+9; ord=1;} | |
933 | ||
7640ec1d | 934 | /* |
935 | //tmp solution | |
936 | Int_t module=-1; | |
937 | if(str[23+ord]=='0') module=0; | |
938 | if(str[23+ord]=='1') module=1; | |
939 | if(str[23+ord]=='2') module=2; | |
940 | if(str[23+ord]=='3') module=3; | |
941 | if(str[23+ord]=='4') module=4; | |
942 | if(str[23+ord]=='5') module=5; | |
943 | if(str[23+ord]=='6') module=6; | |
944 | if(str[23+ord]=='7') module=7; | |
945 | if(str[23+ord]=='8') module=8; | |
946 | if(str[23+ord]=='9') module=9; | |
947 | ||
948 | if(iLayer==3) | |
949 | { | |
950 | if(module==0) iModul= 5; | |
951 | if(module==1) iModul= 4; | |
952 | if(module==2) iModul= 3; | |
953 | if(module==3) iModul= 2; | |
954 | if(module==4) iModul= 1; | |
955 | if(module==5) iModul= 0; | |
956 | } | |
957 | ||
958 | ||
959 | if(iLayer==4) | |
960 | { | |
961 | if(module==0) iModul= 7; | |
962 | if(module==1) iModul= 6; | |
963 | if(module==2) iModul= 5; | |
964 | if(module==3) iModul= 4; | |
965 | if(module==4) iModul= 3; | |
966 | if(module==5) iModul= 2; | |
967 | if(module==6) iModul= 1; | |
968 | if(module==7) iModul= 0; | |
969 | } | |
970 | ||
971 | if(module<0) {printf("ERROR MOULE\n"); iModul=0;} | |
972 | */ | |
973 | ||
02078bdf | 974 | if(str[23+ord]=='0') iModul=0; |
975 | if(str[23+ord]=='1') iModul=1; | |
976 | if(str[23+ord]=='2') iModul=2; | |
977 | if(str[23+ord]=='3') iModul=3; | |
978 | if(str[23+ord]=='4') iModul=4; | |
979 | if(str[23+ord]=='5') iModul=5; | |
980 | if(str[23+ord]=='6') iModul=6; | |
981 | if(str[23+ord]=='7') iModul=7; | |
982 | if(str[23+ord]=='8') iModul=8; | |
983 | if(str[23+ord]=='9') iModul=9; | |
984 | ||
7640ec1d | 985 | |
02078bdf | 986 | if((str[25+ord]=='R')&&(str[26+ord]=='D')) iPoint=0; |
987 | if((str[25+ord]=='R')&&(str[26+ord]=='C')) iPoint=1; | |
988 | if((str[25+ord]=='R')&&(str[26+ord]=='U')) iPoint=2; | |
989 | if((str[25+ord]=='L')&&(str[26+ord]=='U')) iPoint=3; | |
990 | if((str[25+ord]=='L')&&(str[26+ord]=='C')) iPoint=4; | |
991 | if((str[25+ord]=='L')&&(str[26+ord]=='D')) iPoint=5; | |
7640ec1d | 992 | |
993 | ||
02078bdf | 994 | return; |
995 | } | |
996 | ||
997 | ||
2afbf330 | 998 | //______________________________________________________________________ |
02078bdf | 999 | void AliITSSurveyToAlign::ConvertToRSofModulesAndRotSDD(Int_t Layer, Int_t Module) |
1000 | { | |
1001 | // | |
1002 | // Utility function used by CreateAlignObjSDD | |
1003 | // | |
1004 | ||
98380f3e | 1005 | Double_t ymId; |
1006 | Double_t zmId; | |
02078bdf | 1007 | |
98380f3e | 1008 | Double_t ymMe; |
1009 | Double_t zmMe; | |
1010 | Double_t ymMeE; | |
1011 | Double_t zmMeE; | |
02078bdf | 1012 | |
1013 | Double_t x0=fSDDidP[1][0]; | |
7640ec1d | 1014 | Double_t z0=fSDDidP[1][2];//-0.5205; |
1015 | // Double_t z0=fSDDidP[1][2]-0.5; | |
02078bdf | 1016 | for(Int_t i=0; i<6; i++) |
1017 | { | |
7640ec1d | 1018 | // fSDDidP[i][2]-=0.5205; |
1019 | // fSDDidP[i][2]-=0.5; | |
02078bdf | 1020 | |
1021 | if(!fSDDisMe[i]) continue; | |
1022 | ||
1023 | fSDDidP[i][0]-=x0; | |
1024 | fSDDidP[i][2]-=z0; | |
1025 | fSDDmeP[i][0]-=x0; | |
1026 | fSDDmeP[i][2]-=z0; | |
1027 | ||
98380f3e | 1028 | ymId=fSDDidP[i][1]; |
1029 | zmId=fSDDidP[i][2]; | |
02078bdf | 1030 | |
1031 | fSDDidP[i][2]=fSDDidP[i][0]; | |
98380f3e | 1032 | fSDDidP[i][0]=ymId; |
1033 | fSDDidP[i][1]=zmId; | |
02078bdf | 1034 | |
98380f3e | 1035 | ymMe=fSDDmeP[i][1]; |
1036 | zmMe=fSDDmeP[i][2]; | |
02078bdf | 1037 | |
98380f3e | 1038 | ymMeE=fSDDmeP[i][4]; |
1039 | zmMeE=fSDDmeP[i][5]; | |
02078bdf | 1040 | |
1041 | fSDDmeP[i][2]=fSDDmeP[i][0]; | |
98380f3e | 1042 | fSDDmeP[i][0]=ymMe; |
1043 | fSDDmeP[i][1]=zmMe; | |
02078bdf | 1044 | fSDDmeP[i][5]=fSDDmeP[i][3]; |
98380f3e | 1045 | fSDDmeP[i][3]=ymMeE; |
1046 | fSDDmeP[i][4]=zmMeE; | |
02078bdf | 1047 | |
1048 | ||
1049 | if(((Layer==3)&&(Module>2))||((Layer==4)&&(Module>3))) | |
1050 | { | |
1051 | fSDDidP[i][0]*=(-1); | |
1052 | fSDDidP[i][2]*=(-1); | |
1053 | fSDDmeP[i][0]*=(-1); | |
1054 | fSDDmeP[i][2]*=(-1); | |
1055 | } | |
1056 | } | |
1057 | } | |
1058 | ||
1059 | ||
2afbf330 | 1060 | //______________________________________________________________________ |
98380f3e | 1061 | void AliITSSurveyToAlign::CalcShiftSDD(Double_t &x0,Double_t &y0,Double_t &z0) const |
02078bdf | 1062 | { |
98380f3e | 1063 | // Calculates the 3 shifts for the present SDD module |
1064 | // and sets the three reference arguments | |
1065 | // | |
1066 | Double_t xId, yId, zId; | |
1067 | Double_t xMe, yMe, zMe, sX2, sY2, sZ2; | |
02078bdf | 1068 | Double_t aX=0., bX=0.; |
1069 | Double_t aY=0., bY=0.; | |
1070 | Double_t aZ=0., bZ=0.; | |
1071 | for(Int_t iP1=0; iP1<6; iP1++) | |
1072 | { | |
1073 | if(!fSDDisMe[iP1]) continue; | |
98380f3e | 1074 | xId=fSDDidP[iP1][0]; |
1075 | yId=fSDDidP[iP1][1]; | |
1076 | zId=fSDDidP[iP1][2]; | |
1077 | xMe=fSDDmeP[iP1][0]; | |
1078 | yMe=fSDDmeP[iP1][1]; | |
1079 | zMe=fSDDmeP[iP1][2]; | |
02078bdf | 1080 | sX2 =fSDDmeP[iP1][3]*fSDDmeP[iP1][3]; |
1081 | sY2 =fSDDmeP[iP1][4]*fSDDmeP[iP1][4]; | |
1082 | sZ2 =fSDDmeP[iP1][5]*fSDDmeP[iP1][5]; | |
1083 | aX+=(1./sX2); | |
98380f3e | 1084 | bX+=((xMe-xId)/sX2); |
02078bdf | 1085 | aY+=(1./sY2); |
98380f3e | 1086 | bY+=((yMe-yId)/sY2); |
02078bdf | 1087 | aZ+=(1./sZ2); |
98380f3e | 1088 | bZ+=((zMe-zId)/sZ2); |
02078bdf | 1089 | } |
1090 | Double_t x1 = bX/aX; | |
1091 | Double_t x2 = bY/aY; | |
1092 | Double_t x3 = bZ/aZ; | |
1093 | x0=x1; | |
1094 | y0=x2; | |
1095 | z0=x3; | |
1096 | return; | |
1097 | } | |
1098 | ||
1099 | ||
2afbf330 | 1100 | //______________________________________________________________________ |
02078bdf | 1101 | void AliITSSurveyToAlign::CalcShiftRotSDD(Double_t &tet,Double_t &psi,Double_t &phi,Double_t &x0,Double_t &y0,Double_t &z0) |
1102 | { | |
98380f3e | 1103 | // Calculates the 3 shifts and 3 euler angles for the present SDD module |
1104 | // and sets the six reference arguments | |
1105 | // | |
02078bdf | 1106 | TMatrixD pC(6,6); |
1107 | ||
98380f3e | 1108 | Double_t a[6][6]; |
1109 | for(Int_t ii=0; ii<6; ii++){ | |
1110 | for(Int_t jj=0; jj<6; jj++){ | |
1111 | a[ii][jj]=0.; | |
1112 | } | |
1113 | } | |
1114 | ||
1115 | Double_t c[6]; | |
1116 | for(Int_t ii=0; ii<6; ii++) | |
1117 | c[ii]=0.; | |
1118 | ||
1119 | Double_t xId, yId, zId; | |
1120 | Double_t xMe, yMe, zMe, sX2, sY2, sZ2; | |
02078bdf | 1121 | |
7640ec1d | 1122 | // printf("\n"); |
1123 | ||
02078bdf | 1124 | for(Int_t iP1=0; iP1<=6; iP1++) |
1125 | { | |
1126 | if(!fSDDisMe[iP1]) continue; | |
1127 | ||
98380f3e | 1128 | //ideal x,y,z for fiducial mark iP1 |
1129 | xId= fSDDidP[iP1][0]; | |
1130 | yId= fSDDidP[iP1][1]; | |
1131 | zId= fSDDidP[iP1][2]; | |
02078bdf | 1132 | |
98380f3e | 1133 | //measured x,y,z for fiducial mark iP1 |
1134 | xMe= fSDDmeP[iP1][0]; | |
1135 | yMe= fSDDmeP[iP1][1]; | |
1136 | zMe= fSDDmeP[iP1][2]; | |
02078bdf | 1137 | |
7640ec1d | 1138 | |
1139 | ||
98380f3e | 1140 | //squared precisions of measured x,y,z for fiducial mark iP1 |
02078bdf | 1141 | sX2 = fSDDmeP[iP1][3]* fSDDmeP[iP1][3]; |
1142 | sY2 = fSDDmeP[iP1][4]* fSDDmeP[iP1][4]; | |
1143 | sZ2 = fSDDmeP[iP1][5]* fSDDmeP[iP1][5]; | |
1144 | ||
98380f3e | 1145 | a[0][0]+=(zId*zId/sX2+xId*xId/sZ2); |
1146 | a[0][1]-=(zId*yId/sX2); | |
1147 | a[0][2]-=(xId*yId/sZ2); | |
1148 | a[0][3]-=(zId/sX2); | |
1149 | a[0][4] =0.; | |
1150 | a[0][5]+=(xId/sZ2); | |
1151 | c[0]+=(xId*(zMe-zId)/sZ2-zId*(xMe-xId)/sX2); | |
1152 | ||
1153 | a[1][0]-=(yId*zId/sX2); | |
1154 | a[1][1]+=(xId*xId/sY2+yId*yId/sX2); | |
1155 | a[1][2]-=(xId*zId/sY2); | |
1156 | a[1][3]+=(yId/sX2); | |
1157 | a[1][4]-=(xId/sY2); | |
1158 | a[1][5] =0.; | |
1159 | c[1]+=(yId*(xMe-xId)/sX2-xId*(yMe-yId)/sY2); | |
1160 | ||
1161 | a[2][0]-=(yId*xId/sZ2); | |
1162 | a[2][1]-=(xId*zId/sY2); | |
1163 | a[2][2]+=(zId*zId/sY2+yId*yId/sZ2); | |
1164 | a[2][3] =0.; | |
1165 | a[2][4]+=(zId/sY2); | |
1166 | a[2][5]-=(yId/sZ2); | |
1167 | c[2]+=(zId*(yMe-yId)/sY2-yId*(zMe-zId)/sZ2); | |
1168 | ||
1169 | a[3][0]-=(zId/sX2); | |
1170 | a[3][1]+=(yId/sX2); | |
1171 | a[3][2] =0.; | |
1172 | a[3][3]+=(1./sX2); | |
1173 | a[3][4] =0.; | |
1174 | a[3][5] =0.; | |
1175 | c[3]+=((xMe-xId)/sX2); | |
1176 | ||
1177 | a[4][0] =0.; | |
1178 | a[4][1]-=(xId/sY2); | |
1179 | a[4][2]+=(zId/sY2); | |
1180 | a[4][3] =0.; | |
1181 | a[4][4]+=(1./sY2); | |
1182 | a[4][5] =0.; | |
1183 | c[4]+=((yMe-yId)/sY2); | |
1184 | ||
1185 | a[5][0]+=(xId/sZ2); | |
1186 | a[5][1] =0.; | |
1187 | a[5][2]-=(yId/sZ2); | |
1188 | a[5][3] =0.; | |
1189 | a[5][4] =0.; | |
1190 | a[5][5]+=(1./sZ2); | |
1191 | c[5]+=((zMe-zId)/sZ2); | |
02078bdf | 1192 | } |
1193 | ||
1194 | /////////////////////////////////////////////////////////////// | |
1195 | ||
98380f3e | 1196 | pC.SetMatrixArray(&(a[0][0])); |
1197 | TMatrixD p1(pC); | |
1198 | TMatrixD p2(pC); | |
1199 | TMatrixD p3(pC); | |
1200 | TMatrixD p4(pC); | |
1201 | TMatrixD p5(pC); | |
1202 | TMatrixD p6(pC); | |
1203 | ||
1204 | for(Int_t raw=0; raw<6; raw++) | |
1205 | p1[raw][0]=c[raw]; | |
1206 | for(Int_t raw=0; raw<6; raw++) | |
1207 | p2[raw][1]=c[raw]; | |
1208 | for(Int_t raw=0; raw<6; raw++) | |
1209 | p3[raw][2]=c[raw]; | |
1210 | for(Int_t raw=0; raw<6; raw++) | |
1211 | p4[raw][3]=c[raw]; | |
1212 | for(Int_t raw=0; raw<6; raw++) | |
1213 | p5[raw][4]=c[raw]; | |
1214 | for(Int_t raw=0; raw<6; raw++) | |
1215 | p6[raw][5]=c[raw]; | |
02078bdf | 1216 | |
1217 | // cout << "calculating determinants" << endl; | |
1218 | Double_t det0=pC.Determinant(); | |
1219 | Double_t x1 = p1.Determinant()/det0; | |
1220 | Double_t x2 = p2.Determinant()/det0; | |
1221 | Double_t x3 = p3.Determinant()/det0; | |
1222 | Double_t x4 = p4.Determinant()/det0; | |
1223 | Double_t x5 = p5.Determinant()/det0; | |
1224 | Double_t x6 = p6.Determinant()/det0; | |
1225 | //cout << "calculating determinants done" << endl; | |
7640ec1d | 1226 | if (TMath::Abs(x1) < 1.e-10) { |
02078bdf | 1227 | AliInfo("p1 singular "); |
1228 | p1.Print(); | |
1229 | } | |
7640ec1d | 1230 | if (TMath::Abs(x2) < 1.e-10) { |
02078bdf | 1231 | AliInfo("p2 singular "); |
1232 | p2.Print(); | |
1233 | } | |
7640ec1d | 1234 | if (TMath::Abs(x3) < 1.e-10) { |
02078bdf | 1235 | AliInfo("p3 singular "); |
1236 | p3.Print(); | |
1237 | } | |
7640ec1d | 1238 | if (TMath::Abs(x4) < 1.e-10) { |
02078bdf | 1239 | AliInfo("p4 singular "); |
1240 | p4.Print(); | |
1241 | } | |
7640ec1d | 1242 | if (TMath::Abs(x5) < 1.e-10) { |
02078bdf | 1243 | AliInfo("p5 singular "); |
1244 | p5.Print(); | |
1245 | } | |
7640ec1d | 1246 | if (TMath::Abs(x6) < 1.e-10) { |
02078bdf | 1247 | AliInfo("p6 singular "); |
1248 | p6.Print(); | |
1249 | } | |
1250 | ||
1251 | ||
1252 | tet=x1; | |
1253 | psi=x2; | |
1254 | phi=x3; | |
1255 | x0=x4; | |
1256 | y0=x5; | |
1257 | z0=x6; | |
1258 | return; | |
1259 | } |