]> git.uio.no Git - u/mrichter/AliRoot.git/blame - ITS/AliITSSurveyToAlign.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add protection on time stamp in macro to monitor SDD calibration
[u/mrichter/AliRoot.git] / ITS / AliITSSurveyToAlign.cxx
CommitLineData
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 44ClassImp(AliITSSurveyToAlign)
45
46const 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
53const 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 60const Double_t kRadToDeg = 180./TMath::Pi();
02078bdf 61
62//________________________________________________________________________
7640ec1d 63AliITSSurveyToAlign::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//_________________________________________________________________________
106AliITSSurveyToAlign::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 145AliITSSurveyToAlign & 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//__________________________________________________________________________
155AliITSSurveyToAlign::~AliITSSurveyToAlign() {
156 //
157 // destructor
158 //
159}
160
161//______________________________________________________________________
162void 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//______________________________________________________________________
179Bool_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//______________________________________________________________________
222void 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 238Bool_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 291void 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 384void 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 411void 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//______________________________________________________________________
474Bool_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/*
500Bool_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//______________________________________________________________________
527void 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
559void 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/*
579TAlien::Connect("alien://");
580gSystem->Load("libXMLParser.so");
581.x loadlibs.C
582
583AliCDBManager *cdb = AliCDBManager::Instance();
584cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
585cdb->SetRun(0);
586AliGeomManager::LoadGeometry();
587AliITSSurveyToAlign *a = new AliITSSurveyToAlign();
588
589a->CreateAlignObjSDDLadders()
590a->ApplyAlignObjSDDLadders();
591
592a->LoadSurveyFromAlienFile("ITS", 845069, 1);
593a->CreateAlignObjSDD();
594
595a->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
605pRB24[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;
606pRB24[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;
607pRB24[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;
608pRB24[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;
609pRB24[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;
610pRB24[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;
611pRB24[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;
612pRB24[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;
613pRB24[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;
614pRB24[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;
615pRB24[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;
616pRB24[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;
617pRB24[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;
618pRB24[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;
619pRB24[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;
620pRB24[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;
621pRB24[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;
622pRB24[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;
623pRB24[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;
624pRB24[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;
625pRB24[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;
626pRB24[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;
627pRB24[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;
628pRB24[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;
629pRB24[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;
630pRB24[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;
631pRB24[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;
632pRB24[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;
633pRB24[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;
634pRB24[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;
635pRB24[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;
636pRB24[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;
637pRB24[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;
638pRB24[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;
639pRB24[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;
640pRB24[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 737void 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 833void 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 851void 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 898void 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 999void 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 1061void 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 1101void 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}