]> 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
Changes to have an option for storing like-sign V0s in the ESD
[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
26#include "Riostream.h"
27#include "TFile.h"
28#include "TSystem.h"
29#include "TClonesArray.h"
30#include "TGeoManager.h"
31#include "TGeoMatrix.h"
32#include "TGeoPhysicalNode.h"
33#include "TMatrixD.h"
34#include "TMath.h"
35
36#include "AliITSSurveyToAlign.h"
37#include "AliSurveyObj.h"
38#include "AliSurveyPoint.h"
39#include "AliAlignObjParams.h"
40#include "AliGeomManager.h"
41
42#include "AliLog.h"
43
44#include "AliCDBManager.h"
45#include "AliCDBEntry.h"
46#include "AliCDBStorage.h"
47
48#include "AliITSgeomTGeo.h"
49
50ClassImp(AliITSSurveyToAlign)
51
52const Double_t AliITSSurveyToAlign::fgkLocR[6][3]={{ 3.24,0.21905,-2.4},
53 { 3.58,0.21905, 0. },
54 { 3.24,0.21905,+2.4},
55 {-3.24,0.21905,+2.4},
56 {-3.58,0.21905, 0. },
57 {-3.24,0.21905,-2.4}};
58
59const Double_t AliITSSurveyToAlign::fgkLocL[6][3]={{-3.24,0.21905, 2.4},
60 {-3.58,0.21905, 0. },
61 {-3.24,0.21905,-2.4},
62 { 3.24,0.21905,-2.4},
63 { 3.58,0.21905, 0. },
64 { 3.24,0.21905, 2.4}};
65
66
67//________________________________________________________________________
68AliITSSurveyToAlign::AliITSSurveyToAlign(Int_t run, Int_t repSDD, Int_t repVerSDD, Int_t repModSSD, Int_t repModVerSSD, Int_t repLaddSSD, Int_t repLaddVerSSD) :
69 //TObject(),
70 AliSurveyToAlignObjs(),
71 fRun(run),
72 fSDDrepNumber(repSDD),
73 fSDDrepVersion(repVerSDD),
74 fSSDModuleRepNumber(repModSSD),
75 fSSDModuleRepVersion(repModVerSSD),
76 fSSDLadderRepNumber(repLaddSSD),
77 fSSDLadderRepVersion(repLaddVerSSD)
78 {
79 //
80 // default constructor
81 // Arguments are report numbers for survey data.
82 // The defaults point to reports from detector construction
83 //
84}
85
86//_________________________________________________________________________
87AliITSSurveyToAlign::AliITSSurveyToAlign(const AliITSSurveyToAlign &align) :
88 // TObject(),
89 AliSurveyToAlignObjs(align),
90 fRun(align.fRun),
91 fSDDrepNumber(align.fSDDrepNumber),
92 fSDDrepVersion(align.fSDDrepVersion),
93 fSSDModuleRepNumber(align.fSSDModuleRepNumber),
94 fSSDModuleRepVersion(align.fSSDModuleRepVersion),
95 fSSDLadderRepNumber(align.fSSDLadderRepNumber),
96 fSSDLadderRepVersion(align.fSSDLadderRepVersion)
97{
98 //
99 // copy constructor
100 //
101}
102
103//__________________________________________________________________________
104AliITSSurveyToAlign & AliITSSurveyToAlign::operator =(const AliITSSurveyToAlign & align) {
105 //
106 // assignment operator - dummy
107 //
108
109 return (*this);
110}
111
112//__________________________________________________________________________
113AliITSSurveyToAlign::~AliITSSurveyToAlign() {
114 //
115 // destructor
116 //
117}
118
119//______________________________________________________________________
120void AliITSSurveyToAlign::Run() {
121 //
122 // Runs the full chain
123 // User should call StoreAlignObj() or StoreAlignObjCDB() afterwards to
124 // store output
125 //
126
127 // Load ideal geometry from the OCDB
128 AliCDBManager *cdb = AliCDBManager::Instance();
129 cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
130 cdb->SetRun(fRun);
131 AliGeomManager::LoadGeometry();
132
133 CreateAlignObjSPD();
134 LoadSurveyFromAlienFile("ITS", fSDDrepNumber, fSDDrepVersion);
135 CreateAlignObjSDD();
136 LoadSurveyFromAlienFile("ITS", fSSDModuleRepNumber, fSSDModuleRepVersion);
137 CreateAlignObjSSDModules();
138 LoadSurveyFromAlienFile("ITS", fSSDLadderRepNumber, fSSDLadderRepVersion);
139 CreateAlignObjSSDLadders();
140}
141
142void AliITSSurveyToAlign::CreateAlignObjSPD(){
143 //
144 // Create alignObjs for SPD
145 // For the moment, uses 0,0,0,0,0,0
146 //
147 for(Int_t imod = 0; imod < 240; imod++) {
148 Int_t ilayer = (imod < 80) ? AliGeomManager::kSPD1 : AliGeomManager::kSPD2;
149 Int_t imodule = (imod < 80) ? imod : imod - 80;
150
151 Int_t uid = AliGeomManager::LayerToVolUID(ilayer,imodule);
152 const Char_t *symname = AliGeomManager::SymName(uid);
153
154 new((*fAlignObjArray)[imod]) AliAlignObjParams(symname, uid, 0., 0., 0., 0., 0., 0., kTRUE);
155 }//module loop
156
157}
158
159void AliITSSurveyToAlign::CreateAlignObjSDD(){
160 //
161 // Create alignment objects for SDD
162 // Called by Run()
163 //
164 Int_t uid = 0;
165 const char* symname = 0;
166 AliSurveyPoint* pt = 0;
167
168 Int_t iModuleIndex=240;
169 Int_t iModule0=0;
170 Int_t iLadder0=0;
171 Int_t iLayer0=3;
172 Int_t nModules=0;
173
174 if (fSurveyPoints == 0 || fSurveyPoints->GetEntries() == 0) {
175 AliWarning("SDD survey data are not available, using zero values");
176 CreateAlignObjDummySDD();
177 return;
178 }
179
180 for(Int_t imod = 1; imod < fSurveyPoints->GetEntries(); imod++) {
181 pt = (AliSurveyPoint*) fSurveyPoints->At(imod);
182 if(!pt) continue;
183
184 Int_t iLayer, iLadder, iModule, iPoint;
185 ReadPointNameSDD(pt->GetName(),iLayer, iLadder, iModule, iPoint);
186
187 if(iModule==iModule0)
188 {
189 fSDDmeP[iPoint][0]=pt->GetX();
190 fSDDmeP[iPoint][1]=pt->GetY();
191 fSDDmeP[iPoint][2]=pt->GetZ();
192 fSDDmeP[iPoint][3]=pt->GetPrecisionX();
193 fSDDmeP[iPoint][4]=pt->GetPrecisionY();
194 fSDDmeP[iPoint][5]=pt->GetPrecisionZ();
195 fSDDisMe[iPoint]=kTRUE;
196
197 if(iLayer==3) uid = AliGeomManager::LayerToVolUID(iLayer0,iModuleIndex-240);
198 if(iLayer==4) uid = AliGeomManager::LayerToVolUID(iLayer0,iModuleIndex-324);
199 symname = AliGeomManager::SymName(uid);
200 GetIdPosSDD(uid,iLayer0, iModule0, iPoint);
201 nModules++;
202 }
203 // cout << "Points red module " << imod << endl;
204 if((iModule!=iModule0)||(imod==(fSurveyPoints->GetEntries()-1)))
205 {
206 ConvertToRSofModulesAndRotSDD(iLayer0, iModule0);
207
208 Double_t tet = 0.;
209 Double_t psi =0.;
210 Double_t phi = 0.;
211 Double_t x0 = 0.;
212 Double_t y0 =0.;
213 Double_t z0 = 0.;
214
215 if(nModules==2) CalcShiftSDD(x0,y0,z0);
216 if(nModules>2) CalcShiftRotSDD(tet, psi, phi, x0, y0, z0);
217 tet*=(180/TMath::Pi());
218 psi*=(180/TMath::Pi());
219 phi*=(180/TMath::Pi());
220
221// printf("%s %d %f %f %f %f %f %f\n",symname, uid, x0/10., y0/10., z0/10., psi, tet, phi);
222// cout << "Allocate alignobjparams " << imod << endl;
223 new((*fAlignObjArray)[iModuleIndex]) AliAlignObjParams(symname, uid, x0/10., y0/10., z0/10., psi, tet, phi, kFALSE);
224
225 iModule0=iModule;
226 iLayer0=iLayer;
227 iLadder0=iLadder;
228 nModules=0;
229 iModuleIndex = AliITSgeomTGeo::GetModuleIndex(iLayer,iLadder+1,iModule+1);
230 for(Int_t i=0; i<6;i++) fSDDisMe[i]=kFALSE;
231 if(imod!=(fSurveyPoints->GetEntries()-1)) imod--;
232 }
233 }//module loop
234}
235
236void AliITSSurveyToAlign::CreateAlignObjDummySDD(){
237 //
238 // Create empty alignment objects
239 // Used when fSurveySDD == 0
240 //
241 for(Int_t imod = 0; imod < 260; imod++) {
242
243 Int_t ilayer = (imod < 84) ? AliGeomManager::kSDD1 : AliGeomManager::kSDD2;
244 Int_t imodule = (imod < 84) ? imod : imod - 84;
245
246 Int_t uid = AliGeomManager::LayerToVolUID(ilayer,imodule);
247 const Char_t *symname = AliGeomManager::SymName(uid);
248
249 new((*fAlignObjArray)[imod+240]) AliAlignObjParams(symname, uid, 0., 0., 0., 0., 0., 0., kTRUE);
250 }//module loop
251}
252
253void AliITSSurveyToAlign::CreateAlignObjSSDModules(){
254 //
255 // Create alignment objects for SDD
256 // Called by Run()
257 // Two sets of objects are made: 1 per module + 1 per ladder
258 //
259 Double_t sx, sz;
260 const Float_t kMu2Cm = 1e-4;
261 const Float_t kSensLength = 7.464;
262 const Int_t kSSDMODULES = 1698;
263
264 if (fSurveyPoints == 0 || fSurveyPoints->GetEntries() == 0) {
265 AliWarning("SSD module survey data not available; using dummy values");
266 CreateAlignObjDummySSDModules();
267 return;
268 }
269
270 // First do module-by-module
271
272 for(Int_t imod = 500; imod < kSSDMODULES + 500; imod++) {
273 Int_t iLayer, iLadder, iLaddMod;
274 AliITSgeomTGeo::GetModuleId(imod,iLayer,iLadder,iLaddMod); // returns 1-based numbers
275
276 TString pname="ITS/SSD";
277 pname += iLayer-1;
278 pname += "/Ladder";
279 pname += iLadder-1;
280 pname += "/Sensor";
281 pname += iLaddMod-1;
282 AliSurveyPoint *pt1 = (AliSurveyPoint*) fSurveyPoints->FindObject(pname+"/Point0");
283 AliSurveyPoint *pt2 = (AliSurveyPoint*) fSurveyPoints->FindObject(pname+"/Point1");
284 if(!pt1 || !pt2) {
285 AliWarning(Form("No Survey points for iladd %d imod %d",iLadder,iLaddMod));
286 continue;
287 }
288
289 sx = 0.5*(pt1->GetX() + pt2->GetX()) * kMu2Cm;
290 sz = 0.5*(pt1->GetZ() + pt2->GetZ()) * kMu2Cm;
291
292 // Minus sign to change local coordinate convention
293 Float_t theta = -(pt2->GetZ() - pt1->GetZ())*kMu2Cm/kSensLength;
294
295 theta *= 180./TMath::Pi();
296 Int_t iLayMod = imod - 500;
297 if (iLayer == 6)
298 iLayMod -= 748;
299 Int_t uid = AliGeomManager::LayerToVolUID(iLayer,iLayMod);
300
301 const Char_t *symname = AliGeomManager::SymName(uid);
302 if (pname.CompareTo(symname) != 0)
303 AliWarning(Form("Mapping mismatch survey point %s volume name %s",pname.Data(),symname));
304 /*
305 if (imod >= 676 && imod <= 697) {
306 cout << "ilayer " << iLayer << " imod " << imod
307 << " uid " << uid << " name " << symname
308 << " survey shift " << sx << " " << 0 << " " << sz << endl
309 << " theta " << theta << endl;
310 }
311 */
312 new((*fAlignObjArray)[imod]) AliAlignObjParams(symname, uid, sx, 0, sz, 0., theta, 0., kFALSE);
313 } //module loop
314}
315
316void AliITSSurveyToAlign::CreateAlignObjSSDLadders(){
317 //
318 // Now do ladders (Torino data)
319 //
320 const Float_t kLaddLen5 = 90.27; // Layer 5: distance between mouting points
321 const Float_t kLaddLen6 = 102.0; // Layer 6: distance between mouting points
322 const Float_t Z0 = 2.927; // Distance between V mounting point and Zloc = 0
323 // = half ladder length - nom z-position of ladder from gGeoManager
324 const Float_t kMu2Cm = 1e-4;
325
326 TString ssdName = "ITS/SSD";
327
328 TObjArray *ladd_points = fSurveyPoints;
329 if (ladd_points == 0 || ladd_points->GetEntries() == 0) {
330 AliWarning("No SSD Ladder alignment points found. Skipping");
331 return;
332 }
333 if (ladd_points->GetEntries()!= 2*(34+38)) {
334 AliWarning(Form("Unexpected number of survey points %d, should be 144",ladd_points->GetEntries()));
335 }
336 Int_t iLadd = 0;
337 for (Int_t ilayer = 4; ilayer <= 5; ilayer ++) {
338 Int_t nLadder = 34; // layer 5
339 if (ilayer == 5)
340 nLadder = 38; // layer 6
341
342 for (Int_t iLadder = 0; iLadder < nLadder; iLadder++) {
343 TString ladName = ssdName;
344 ladName += ilayer;
345 ladName += "/Ladder";
346 ladName += iLadder;
347
348 AliSurveyPoint *v_point = (AliSurveyPoint*) ladd_points->FindObject(ladName+"/V");
349 AliSurveyPoint *q_point = (AliSurveyPoint*) ladd_points->FindObject(ladName+"/Q");
350 if (v_point == 0) {
351 AliWarning(Form("Cannot find V side point for ladder %s",ladName.Data()));
352 continue;
353 }
354 if (q_point == 0) {
355 AliWarning(Form("Cannot find Q side point for ladder %s",ladName.Data()));
356 continue;
357 }
358
359 TString tmp_str;
360 tmp_str.Insert(0,v_point->GetName(),3);
361 Int_t ladder = tmp_str.Atoi();
362 tmp_str="";
363 tmp_str.Insert(0,q_point->GetName(),3);
364 if (tmp_str.Atoi() != ladder)
365 AliError(Form("Survey data file error. Expect pairs of V,Q points. Got ladders %d %d",ladder,tmp_str.Atoi()));
366
367 // Note: file gives meas-nom in local offline coordinates,
368 // ie. local z = - global z and local x = - global x (for ladder 508, i.e. top ladder)
369 Double_t dx_loc = v_point->GetX() * kMu2Cm;
370 Double_t dy_loc = v_point->GetY() * kMu2Cm;
371 Double_t dz_loc = v_point->GetZ() * kMu2Cm;
372
373 // rot around z-axis
374 Double_t phi = 0; // Not measured
375 // rot around y-axis
376 Double_t theta = 0;
377 Double_t psi = 0;
378
379 // Note: local psi = -global psi, psi = atan(-(y(z1) - y(z0)) / (z1-z0))
380 // local theta = global theta = atan(dx/dz)
381 // V side is A side is large global z
382 // Q side is C side is large local z
383
384 if (ladder >= 600) {
385 theta = TMath::ATan((q_point->GetX() - v_point->GetX())*kMu2Cm/kLaddLen6);
386 psi = TMath::ATan((v_point->GetY() - q_point->GetY())*kMu2Cm/kLaddLen6);
387 }
388 else {
389 theta = TMath::ATan((q_point->GetX() - v_point->GetX())*kMu2Cm/kLaddLen5);
390 psi = TMath::ATan((v_point->GetY() - q_point->GetY())*kMu2Cm/kLaddLen5);
391 }
392
393 // Move along ladder to local Z = 0 point
394 dx_loc += Z0*theta;
395 dy_loc -= Z0*psi;
396
397 // Convert to degrees
398 theta *= 180./TMath::Pi();
399 psi *= 180./TMath::Pi();
400 AliDebug(1,Form("ladname %f %f %f %f %f %f ",dx_loc,dy_loc,dz_loc,psi,theta,phi));
401
402 new((*fAlignObjArray)[500+1698+iLadd]) AliAlignObjParams(ladName,0,dx_loc,dy_loc,dz_loc,psi,theta,phi,kFALSE);
403
404 iLadd++;
405 } // Ladder loop
406 } // Layer loop
407}
408
409
410void AliITSSurveyToAlign::CreateAlignObjDummySSDModules(){
411 //
412 // Create empty alignment objects
413 // Used when fSurveySSD == 0
414 //
415 for(Int_t imod = 0; imod < 1698; imod++) {
416 Int_t ilayer = (imod < 748) ? AliGeomManager::kSSD1 : AliGeomManager::kSSD2;
417 Int_t imodule = (imod < 748) ? imod : imod - 748;
418
419 Int_t uid = AliGeomManager::LayerToVolUID(ilayer,imodule);
420 const Char_t *symname = AliGeomManager::SymName(uid);
421
422 new((*fAlignObjArray)[500+imod]) AliAlignObjParams(symname, uid, 0., 0., 0., 0., 0., 0., kTRUE);
423 }//module loop
424}
425
426
427void AliITSSurveyToAlign::GetIdPosSDD(Int_t uid, Int_t layer, Int_t module, Int_t iPoint)
428{
429 //
430 // Utility function used by CreateAlignObjSDD
431 //
432 TGeoHMatrix gMod = *AliGeomManager::GetMatrix(uid); //global matrix of sensor
433 TGeoPNEntry* pne = gGeoManager->GetAlignableEntryByUID(uid);
434 // TString ladderPath = AliGeomManager::SymName(uid);
435 TString ladderPath(pne->GetTitle());
436 if(ladderPath.EndsWith("/")) ladderPath.Remove(TString::kTrailing,'/');
437 ladderPath.Remove(ladderPath.Last('/'));
438 ladderPath.Remove(ladderPath.Last('/'));
439 gGeoManager->cd(ladderPath.Data());
440 TGeoHMatrix gLad = *gGeoManager->GetCurrentMatrix(); // global matrix of ladder
441 TGeoHMatrix rel = gMod; // to equal relative matrix ladder to sensor.
442 TGeoHMatrix invgLad = gLad.Inverse();
443 rel.MultiplyLeft(&invgLad);
444 TGeoRotation* rr = new TGeoRotation("rr",90,90,0,0,90,180);
445 TGeoCombiTrans* ct = 0;
446 if(layer==3) ct= new TGeoCombiTrans(25.,0.,0.,rr);
447 if(layer==4) ct= new TGeoCombiTrans(25.+7.5,0.,0.,rr);
448
449 rel.MultiplyLeft(ct);
450
451 if((layer==3)&&(module<3)) rel.LocalToMaster(fgkLocR[iPoint],fSDDidP[iPoint]);
452 if((layer==3)&&(module>2)) rel.LocalToMaster(fgkLocL[iPoint],fSDDidP[iPoint]);
453 if((layer==4)&&(module<4)) rel.LocalToMaster(fgkLocR[iPoint],fSDDidP[iPoint]);
454 if((layer==4)&&(module>3)) rel.LocalToMaster(fgkLocL[iPoint],fSDDidP[iPoint]);
455
456 for(Int_t i=0; i<3; i++) fSDDidP[iPoint][i]*=10;
457
458}
459
460void AliITSSurveyToAlign::ReadPointNameSDD(const char str[], Int_t &iLayer, Int_t &iLader, Int_t &iModul, Int_t &iPoint)
461{
462 //
463 // Utility function used by CreateAlignObjSDD
464 //
465 iLayer=-1;
466 iLader=-1;
467 iModul=-1;
468 iPoint=-1;
469
470 if(str[7]=='2') iLayer=3;
471 if(str[7]=='3') iLayer=4;
472
473 if(str[15]=='0') iLader=0;
474 if(str[15]=='1') iLader=1;
475 if(str[15]=='2') iLader=2;
476 if(str[15]=='3') iLader=3;
477 if(str[15]=='4') iLader=4;
478 if(str[15]=='5') iLader=5;
479 if(str[15]=='6') iLader=6;
480 if(str[15]=='7') iLader=7;
481 if(str[15]=='8') iLader=8;
482 if(str[15]=='9') iLader=9;
483
484 Int_t ord=0;
485 if(str[16]=='0') {iLader=10*iLader+0; ord=1;}
486 if(str[16]=='1') {iLader=10*iLader+1; ord=1;}
487 if(str[16]=='2') {iLader=10*iLader+2; ord=1;}
488 if(str[16]=='3') {iLader=10*iLader+3; ord=1;}
489 if(str[16]=='4') {iLader=10*iLader+4; ord=1;}
490 if(str[16]=='5') {iLader=10*iLader+5; ord=1;}
491 if(str[16]=='6') {iLader=10*iLader+6; ord=1;}
492 if(str[16]=='7') {iLader=10*iLader+7; ord=1;}
493 if(str[16]=='8') {iLader=10*iLader+8; ord=1;}
494 if(str[16]=='9') {iLader=10*iLader+9; ord=1;}
495
496 if(str[23+ord]=='0') iModul=0;
497 if(str[23+ord]=='1') iModul=1;
498 if(str[23+ord]=='2') iModul=2;
499 if(str[23+ord]=='3') iModul=3;
500 if(str[23+ord]=='4') iModul=4;
501 if(str[23+ord]=='5') iModul=5;
502 if(str[23+ord]=='6') iModul=6;
503 if(str[23+ord]=='7') iModul=7;
504 if(str[23+ord]=='8') iModul=8;
505 if(str[23+ord]=='9') iModul=9;
506
507 if((str[25+ord]=='R')&&(str[26+ord]=='D')) iPoint=0;
508 if((str[25+ord]=='R')&&(str[26+ord]=='C')) iPoint=1;
509 if((str[25+ord]=='R')&&(str[26+ord]=='U')) iPoint=2;
510 if((str[25+ord]=='L')&&(str[26+ord]=='U')) iPoint=3;
511 if((str[25+ord]=='L')&&(str[26+ord]=='C')) iPoint=4;
512 if((str[25+ord]=='L')&&(str[26+ord]=='D')) iPoint=5;
513 return;
514}
515
516
517void AliITSSurveyToAlign::ConvertToRSofModulesAndRotSDD(Int_t Layer, Int_t Module)
518{
519 //
520 // Utility function used by CreateAlignObjSDD
521 //
522
523 Double_t YmId;
524 Double_t ZmId;
525
526 Double_t YmMe;
527 Double_t ZmMe;
528 Double_t YmMeE;
529 Double_t ZmMeE;
530
531 Double_t x0=fSDDidP[1][0];
532 Double_t z0=fSDDidP[1][2]-0.52;
533 for(Int_t i=0; i<6; i++)
534 {
535 fSDDidP[i][2]-=0.52;
536
537 if(!fSDDisMe[i]) continue;
538
539 fSDDidP[i][0]-=x0;
540 fSDDidP[i][2]-=z0;
541 fSDDmeP[i][0]-=x0;
542 fSDDmeP[i][2]-=z0;
543
544 YmId=fSDDidP[i][1];
545 ZmId=fSDDidP[i][2];
546
547 fSDDidP[i][2]=fSDDidP[i][0];
548 fSDDidP[i][0]=YmId;
549 fSDDidP[i][1]=ZmId;
550
551 YmMe=fSDDmeP[i][1];
552 ZmMe=fSDDmeP[i][2];
553
554 YmMeE=fSDDmeP[i][4];
555 ZmMeE=fSDDmeP[i][5];
556
557 fSDDmeP[i][2]=fSDDmeP[i][0];
558 fSDDmeP[i][0]=YmMe;
559 fSDDmeP[i][1]=ZmMe;
560 fSDDmeP[i][5]=fSDDmeP[i][3];
561 fSDDmeP[i][3]=YmMeE;
562 fSDDmeP[i][4]=ZmMeE;
563
564
565 if(((Layer==3)&&(Module>2))||((Layer==4)&&(Module>3)))
566 {
567 fSDDidP[i][0]*=(-1);
568 fSDDidP[i][2]*=(-1);
569 fSDDmeP[i][0]*=(-1);
570 fSDDmeP[i][2]*=(-1);
571 }
572 }
573}
574
575
576void AliITSSurveyToAlign::CalcShiftSDD(Double_t &x0,Double_t &y0,Double_t &z0)
577{
578 Double_t Xid, Yid, Zid;
579 Double_t Xme, Yme, Zme, sX2, sY2, sZ2;
580 Double_t aX=0., bX=0.;
581 Double_t aY=0., bY=0.;
582 Double_t aZ=0., bZ=0.;
583 for(Int_t iP1=0; iP1<6; iP1++)
584 {
585 if(!fSDDisMe[iP1]) continue;
586 Xid=fSDDidP[iP1][0];
587 Yid=fSDDidP[iP1][1];
588 Zid=fSDDidP[iP1][2];
589 Xme=fSDDmeP[iP1][0];
590 Yme=fSDDmeP[iP1][1];
591 Zme=fSDDmeP[iP1][2];
592 sX2 =fSDDmeP[iP1][3]*fSDDmeP[iP1][3];
593 sY2 =fSDDmeP[iP1][4]*fSDDmeP[iP1][4];
594 sZ2 =fSDDmeP[iP1][5]*fSDDmeP[iP1][5];
595 aX+=(1./sX2);
596 bX+=((Xme-Xid)/sX2);
597 aY+=(1./sY2);
598 bY+=((Yme-Yid)/sY2);
599 aZ+=(1./sZ2);
600 bZ+=((Zme-Zid)/sZ2);
601 }
602 Double_t x1 = bX/aX;
603 Double_t x2 = bY/aY;
604 Double_t x3 = bZ/aZ;
605 x0=x1;
606 y0=x2;
607 z0=x3;
608 return;
609}
610
611
612void AliITSSurveyToAlign::CalcShiftRotSDD(Double_t &tet,Double_t &psi,Double_t &phi,Double_t &x0,Double_t &y0,Double_t &z0)
613{
614 TMatrixD p1(6,6);
615 TMatrixD p2(6,6);
616 TMatrixD p3(6,6);
617 TMatrixD p4(6,6);
618 TMatrixD p5(6,6);
619 TMatrixD p6(6,6);
620 TMatrixD pC(6,6);
621
622 Double_t a11 =0.;
623 Double_t a12 =0.;
624 Double_t a13 =0.;
625 Double_t a14 =0.;
626 Double_t a15 =0.;
627 Double_t a16 =0.;
628
629 Double_t a21 =0.;
630 Double_t a22 =0.;
631 Double_t a23 =0.;
632 Double_t a24 =0.;
633 Double_t a25 =0.;
634 Double_t a26 =0.;
635
636 Double_t a31 =0.;
637 Double_t a32 =0.;
638 Double_t a33 =0.;
639 Double_t a34 =0.;
640 Double_t a35 =0.;
641 Double_t a36 =0.;
642
643 Double_t a41 =0.;
644 Double_t a42 =0.;
645 Double_t a43 =0.;
646 Double_t a44 =0.;
647 Double_t a45 =0.;
648 Double_t a46 =0.;
649
650 Double_t a51 =0.;
651 Double_t a52 =0.;
652 Double_t a53 =0.;
653 Double_t a54 =0.;
654 Double_t a55 =0.;
655 Double_t a56 =0.;
656
657 Double_t a61 =0.;
658 Double_t a62 =0.;
659 Double_t a63 =0.;
660 Double_t a64 =0.;
661 Double_t a65 =0.;
662 Double_t a66 =0.;
663
664 Double_t c1 =0.;
665 Double_t c2 =0.;
666 Double_t c3 =0.;
667 Double_t c4 =0.;
668 Double_t c5 =0.;
669 Double_t c6 =0.;
670
671 Double_t Xid, Yid, Zid;
672 Double_t Xme, Yme, Zme, sX2, sY2, sZ2;
673
674 for(Int_t iP1=0; iP1<=6; iP1++)
675 {
676 if(!fSDDisMe[iP1]) continue;
677
678 Xid= fSDDidP[iP1][0];
679 Yid= fSDDidP[iP1][1];
680 Zid= fSDDidP[iP1][2];
681
682 Xme= fSDDmeP[iP1][0];
683 Yme= fSDDmeP[iP1][1];
684 Zme= fSDDmeP[iP1][2];
685
686 sX2 = fSDDmeP[iP1][3]* fSDDmeP[iP1][3];
687 sY2 = fSDDmeP[iP1][4]* fSDDmeP[iP1][4];
688 sZ2 = fSDDmeP[iP1][5]* fSDDmeP[iP1][5];
689
690 a11+=(Zid*Zid/sX2+Xid*Xid/sZ2);
691 a12-=(Zid*Yid/sX2);
692 a13-=(Xid*Yid/sZ2);
693 a14-=(Zid/sX2);
694 a15 =0.;
695 a16+=(Xid/sZ2);
696 c1+=(Xid*(Zme-Zid)/sZ2-Zid*(Xme-Xid)/sX2);
697
698 a21-=(Yid*Zid/sX2);
699 a22+=(Xid*Xid/sY2+Yid*Yid/sX2);
700 a23-=(Xid*Zid/sY2);
701 a24+=(Yid/sX2);
702 a25-=(Xid/sY2);
703 a26 =0.;
704 c2+=(Yid*(Xme-Xid)/sX2-Xid*(Yme-Yid)/sY2);
705
706 a31-=(Yid*Xid/sZ2);
707 a32-=(Xid*Zid/sY2);
708 a33+=(Zid*Zid/sY2+Yid*Yid/sZ2);
709 a34 =0.;
710 a35+=(Zid/sY2);
711 a36-=(Yid/sZ2);
712 c3+=(Zid*(Yme-Yid)/sY2-Yid*(Zme-Zid)/sZ2);
713
714 a41-=(Zid/sX2);
715 a42+=(Yid/sX2);
716 a43 =0.;
717 a44+=(1./sX2);
718 a45 =0.;
719 a46 =0.;
720 c4+=((Xme-Xid)/sX2);
721
722 a51 =0.;
723 a52-=(Xid/sY2);
724 a53+=(Zid/sY2);
725 a54 =0.;
726 a55+=(1./sY2);
727 a56 =0.;
728 c5+=((Yme-Yid)/sY2);
729
730 a61+=(Xid/sZ2);
731 a62 =0.;
732 a63-=(Yid/sZ2);
733 a64 =0.;
734 a65 =0.;
735 a66+=(1./sZ2);
736 c6+=((Zme-Zid)/sZ2);
737 }
738
739 ///////////////////////////////////////////////////////////////
740
741 Double_t dataC[]={a11, a12, a13, a14, a15, a16, a21, a22, a23, a24, a25, a26,
742 a31, a32, a33, a34, a35, a36, a41, a42, a43, a44, a45, a46,
743 a51, a52, a53, a54, a55, a56, a61, a62, a63, a64, a65, a66};
744 Double_t data1[]={c1, a12, a13, a14, a15, a16, c2, a22, a23, a24, a25, a26,
745 c3, a32, a33, a34, a35, a36, c4, a42, a43, a44, a45, a46,
746 c5, a52, a53, a54, a55, a56, c6, a62, a63, a64, a65, a66};
747 Double_t data2[]={a11, c1, a13, a14, a15, a16, a21, c2, a23, a24, a25, a26,
748 a31, c3, a33, a34, a35, a36, a41, c4, a43, a44, a45, a46,
749 a51, c5, a53, a54, a55, a56, a61, c6, a63, a64, a65, a66};
750 Double_t data3[]={a11, a12, c1, a14, a15, a16, a21, a22, c2, a24, a25, a26,
751 a31, a32, c3, a34, a35, a36, a41, a42, c4, a44, a45, a46,
752 a51, a52, c5, a54, a55, a56, a61, a62, c6, a64, a65, a66};
753 Double_t data4[]={a11, a12, a13, c1, a15, a16, a21, a22, a23, c2, a25, a26,
754 a31, a32, a33, c3, a35, a36, a41, a42, a43, c4, a45, a46,
755 a51, a52, a53, c5, a55, a56, a61, a62, a63, c6, a65, a66};
756 Double_t data5[]={a11, a12, a13, a14, c1, a16, a21, a22, a23, a24, c2, a26,
757 a31, a32, a33, a34, c3, a36, a41, a42, a43, a44, c4, a46,
758 a51, a52, a53, a54, c5, a56, a61, a62, a63, a64, c6, a66};
759 Double_t data6[]={a11, a12, a13, a14, a15, c1, a21, a22, a23, a24, a25, c2,
760 a31, a32, a33, a34, a35, c3, a41, a42, a43, a44, a45, c4,
761 a51, a52, a53, a54, a55, c5, a61, a62, a63, a64, a65, c6};
762
763 p1.SetMatrixArray(data1);
764 p2.SetMatrixArray(data2);
765 p3.SetMatrixArray(data3);
766 p4.SetMatrixArray(data4);
767 p5.SetMatrixArray(data5);
768 p6.SetMatrixArray(data6);
769 pC.SetMatrixArray(dataC);
770
771 // cout << "calculating determinants" << endl;
772 Double_t det0=pC.Determinant();
773 Double_t x1 = p1.Determinant()/det0;
774 Double_t x2 = p2.Determinant()/det0;
775 Double_t x3 = p3.Determinant()/det0;
776 Double_t x4 = p4.Determinant()/det0;
777 Double_t x5 = p5.Determinant()/det0;
778 Double_t x6 = p6.Determinant()/det0;
779 //cout << "calculating determinants done" << endl;
780 if (x1 == 0) {
781 AliInfo("p1 singular ");
782 p1.Print();
783 }
784 if (x2 == 0) {
785 AliInfo("p2 singular ");
786 p2.Print();
787 }
788 if (x3 == 0) {
789 AliInfo("p3 singular ");
790 p3.Print();
791 }
792 if (x4 == 0) {
793 AliInfo("p4 singular ");
794 p4.Print();
795 }
796 if (x5 == 0) {
797 AliInfo("p5 singular ");
798 p5.Print();
799 }
800 if (x6 == 0) {
801 AliInfo("p6 singular ");
802 p6.Print();
803 }
804
805
806 tet=x1;
807 psi=x2;
808 phi=x3;
809 x0=x4;
810 y0=x5;
811 z0=x6;
812 return;
813}
814
815
816