Reduced QA output (Yves)
[u/mrichter/AliRoot.git] / ITS / AliITSAlignMilleModule.cxx
CommitLineData
d3603b4d 1/**************************************************************************
2 * Copyright(c) 2007-2009, 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/// \class AliITSAlignMilleModule
19/// Alignment class for the ALICE ITS detector
20///
21/// This class is used by AliITSAlignMille to build custom supermodules
22/// made of ITS sensitive modules. These supermodules are then aligned
23///
24/// Custom supermodules must have VolumeID > 14335
25///
26/// \author M. Lunardon
27//-----------------------------------------------------------------------------
28
29#include <TGeoManager.h>
75d480f6 30//#include <TGeoMatrix.h>
d3603b4d 31
32#include "AliITSAlignMilleModule.h"
33#include "AliITSgeomTGeo.h"
34#include "AliGeomManager.h"
35#include "AliAlignObjParams.h"
36#include "AliLog.h"
37
38/// \cond CLASSIMP
39ClassImp(AliITSAlignMilleModule)
40/// \endcond
41
42//-------------------------------------------------------------
43AliITSAlignMilleModule::AliITSAlignMilleModule() : TNamed(),
44 fNSensVol(0),
45 fIndex(-1),
46 fVolumeID(0),
47 fMatrix(NULL),
48 fSensVolMatrix(NULL),
49 fSensVolModifMatrix(NULL),
50 fTempAlignObj(NULL)
51{
52 /// void constructor
53 fMatrix = new TGeoHMatrix;
54 fSensVolMatrix = new TGeoHMatrix;
55 fSensVolModifMatrix = new TGeoHMatrix;
56 fTempAlignObj=new AliAlignObjParams;
57}
58//-------------------------------------------------------------
59AliITSAlignMilleModule::AliITSAlignMilleModule(Int_t index, UShort_t volid, char* symname, TGeoHMatrix *m, Int_t nsv, UShort_t *volidsv) : TNamed(),
60 fNSensVol(0),
61 fIndex(-1),
62 fVolumeID(0),
63 fMatrix(NULL),
64 fSensVolMatrix(NULL),
65 fSensVolModifMatrix(NULL),
66 fTempAlignObj(NULL)
67{
68 /// void constructor
69 fMatrix = new TGeoHMatrix;
70 fSensVolMatrix = new TGeoHMatrix;
71 fSensVolModifMatrix = new TGeoHMatrix;
72 fTempAlignObj=new AliAlignObjParams;
73 if (Set(index,volid,symname,m,nsv,volidsv)) {
74 AliInfo("Error in AliITSAlignMilleModule::Set() - initializing void supermodule...");
75 }
76}
77//-------------------------------------------------------------
78AliITSAlignMilleModule::AliITSAlignMilleModule(UShort_t volid) : TNamed(),
79 fNSensVol(0),
80 fIndex(-1),
81 fVolumeID(0),
82 fMatrix(NULL),
83 fSensVolMatrix(NULL),
84 fSensVolModifMatrix(NULL),
85 fTempAlignObj(NULL)
86{
87 /// simple constructor building a supermodule from a single sensitive volume
88 fMatrix = new TGeoHMatrix;
89 fSensVolMatrix = new TGeoHMatrix;
90 fSensVolModifMatrix = new TGeoHMatrix;
91 // temporary align object, just use the rotation...
92 fTempAlignObj=new AliAlignObjParams;
93
94 fIndex = GetIndexFromVolumeID(volid);
95 if (fIndex>=0 && gGeoManager) { // good sensitive module and geometry loaded
96 SetName(AliGeomManager::SymName(volid));
97 fVolumeID = volid;
98 AddSensitiveVolume(volid);
99 if (SensVolMatrix(volid, fMatrix))
100 AliInfo("Matrix not defined");
101 }
102 else {
103 AliInfo("Wrong VolumeID or Geometry not loaded - initializing void supermodule...");
104 }
105}
106//-------------------------------------------------------------
107AliITSAlignMilleModule::~AliITSAlignMilleModule() {
108 /// Destructor
109 delete fMatrix;
110 delete fSensVolMatrix;
111 delete fSensVolModifMatrix;
112 delete fTempAlignObj;
113}
114//-------------------------------------------------------------
75d480f6 115Int_t AliITSAlignMilleModule::Set(Int_t index, UShort_t volid, char* symname, const TGeoHMatrix * const m, Int_t nsv, UShort_t *volidsv)
d3603b4d 116{
117 // initialize a custom supermodule
118 // index, volid, symname and matrix must be given
119 // if (volidsv) add nsv sensitive volumes to the supermodules
120 // return 0 if success
121
122 if (index<2198) {
123 AliInfo("Index must be >= 2198");
124 return -1;
125 }
126 if (volid<14336) {
127 AliInfo("VolumeID must be >= 14336");
128 return -2;
129 }
130
131 if (!symname) return -3;
132 for (Int_t i=0; i<2198; i++) {
133 if (!strcmp(symname,AliITSgeomTGeo::GetSymName(i))) {
134 AliInfo("Symname already used by a Sensitive Volume");
135 return -3;
136 }
137 }
138
139 if (!m) return -4;
140
141 // can initialize needed stuffs
142 fIndex = index;
143 fVolumeID = volid;
144 SetName(symname);
145 (*fMatrix) = (*m);
146
147 // add sensitive volumes
148 for (Int_t i=0; i<nsv; i++) AddSensitiveVolume(volidsv[i]);
149
150 return 0;
151}
152//-------------------------------------------------------------
153Int_t AliITSAlignMilleModule::GetIndexFromVolumeID(UShort_t voluid) {
154 /// index from volume ID
155 AliGeomManager::ELayerID lay = AliGeomManager::VolUIDToLayer(voluid);
156 if (lay<1|| lay>6) return -1;
157 Int_t idx=Int_t(voluid)-2048*lay;
158 if (idx>=AliGeomManager::LayerSize(lay)) return -1;
159 for (Int_t ilay=1; ilay<lay; ilay++)
160 idx += AliGeomManager::LayerSize(ilay);
161 return idx;
162}
163//-------------------------------------------------------------
164void AliITSAlignMilleModule::AddSensitiveVolume(UShort_t voluid)
165{
166 /// add a sensitive volume to this supermodule
167 if (GetIndexFromVolumeID(voluid)<0) return; // bad volid
168 fSensVolVolumeID[fNSensVol] = voluid;
169 fSensVolIndex[fNSensVol] = GetIndexFromVolumeID(voluid);
170 fNSensVol++;
171}
172//-------------------------------------------------------------
173Bool_t AliITSAlignMilleModule::IsIn(UShort_t voluid) const
174{
175 /// check if voluid is defined
176 if (!voluid) return kFALSE; // only positive voluid are accepted
177 for (Int_t i=0; i<fNSensVol; i++) {
178 if (fSensVolVolumeID[i]==voluid) return kTRUE;
179 }
180 return kFALSE;
181}
182//-------------------------------------------------------------
75d480f6 183TGeoHMatrix *AliITSAlignMilleModule::GetSensitiveVolumeModifiedMatrix(UShort_t voluid, const Double_t * const deltalocal)
d3603b4d 184{
185 // modify the original TGeoHMatrix of the sensitive module 'voluid' according
186 // with a delta transform. applied to the supermodule matrix
187 // return NULL if error
188
189 if (!IsIn(voluid)) return NULL;
190 if (!gGeoManager) return NULL;
191
192 // prepare the TGeoHMatrix
193 Double_t tr[3],ang[3];
194 tr[0]=deltalocal[0]; // in centimeter
195 tr[1]=deltalocal[1];
196 tr[2]=deltalocal[2];
197 ang[0]=deltalocal[3]; // psi (X) in deg
198 ang[1]=deltalocal[4]; // theta (Y)
199 ang[2]=deltalocal[5]; // phi (Z)
200
201 // reset align object (may not be needed...)
75d480f6 202 fTempAlignObj->SetVolUID(0);
203 fTempAlignObj->SetSymName("");
d3603b4d 204 fTempAlignObj->SetRotation(ang[0],ang[1],ang[2]);
205 fTempAlignObj->SetTranslation(tr[0],tr[1],tr[2]);
206 AliDebug(3,Form("Delta angles: psi=%f theta=%f phi=%f",ang[0],ang[1],ang[2]));
207 TGeoHMatrix hm;
208 fTempAlignObj->GetMatrix(hm);
209 //printf("\n0: delta matrix\n");hm.Print();
210
211 // 1) start setting fSensVolModif = fSensVol
212 if (SensVolMatrix(voluid, fSensVolModifMatrix)) return NULL;
213 //printf("\n1: modif=orig del sensvol\n");fSensVolModifMatrix->Print();
214
215 // 2) set fSensVolModif = SensVolRel
216 fSensVolModifMatrix->MultiplyLeft( &fMatrix->Inverse() );
217 //printf("\n2: modif=relative del sensvol\n");fSensVolModifMatrix->Print();
218
219 // 3) multiply left by delta
220 fSensVolModifMatrix->MultiplyLeft( &hm );
221 //printf("\n3: modif= delta*relative\n");fSensVolModifMatrix->Print();
222
223 // 4) multiply left by fMatrix
224 fSensVolModifMatrix->MultiplyLeft( fMatrix );
225 //printf("\n4: modif=finale\n");fSensVolModifMatrix->Print();
226
227 return fSensVolModifMatrix;
228}
229//-------------------------------------------------------------
75d480f6 230AliAlignObjParams *AliITSAlignMilleModule::GetSensitiveVolumeMisalignment(UShort_t voluid, const Double_t * const deltalocal)
d3603b4d 231{
232 // calculate misalignment of sens.vol. 'voluid' according with a displacement 'deltalocal'
233 // of the mother volume. The misalignment is returned as AliAlignObjParams object
234
235 if (!IsIn(voluid)) return NULL;
236 if (!gGeoManager) return NULL;
237
238 // prepare the TGeoHMatrix
239 Double_t tr[3],ang[3];
240 tr[0]=deltalocal[0]; // in centimeter
241 tr[1]=deltalocal[1];
242 tr[2]=deltalocal[2];
243 ang[0]=deltalocal[3]; // psi (X) in deg
244 ang[1]=deltalocal[4]; // theta (Y)
245 ang[2]=deltalocal[5]; // phi (Z)
246
247 // reset align object (may not be needed...)
75d480f6 248 fTempAlignObj->SetVolUID(0);
249 fTempAlignObj->SetSymName("");
d3603b4d 250 fTempAlignObj->SetRotation(ang[0],ang[1],ang[2]);
251 fTempAlignObj->SetTranslation(tr[0],tr[1],tr[2]);
252 AliDebug(3,Form("Delta angles: psi=%f theta=%f phi=%f",ang[0],ang[1],ang[2]));
253
254 return GetSensitiveVolumeMisalignment(voluid,fTempAlignObj);
255}
256//-------------------------------------------------------------
257AliAlignObjParams *AliITSAlignMilleModule::GetSensitiveVolumeMisalignment(UShort_t voluid, AliAlignObjParams *a)
258{
259 // return the misalignment of the sens. vol. 'voluid' corresponding with
260 // a misalignment 'a' in the mother volume
261 // return NULL if error
262
263 // Gsv = Gg * Gg-1 * Gsv -> Lsv,g = Gg-1 * Gsv
264 // G'sv = Gg * Dg * Lsv,g === Gsv * Dsv
265 // Gg * Dg * Gg-1 * Gsv = Gsv * Gsv-1 * Gg * Dg * Gg-1 * Gsv
266 //
267 // => Dsv = (Gsv-1 * Gg * Dg * Gg-1 * Gsv)
268 //
269
270 if (!IsIn(voluid)) return NULL;
271 if (!gGeoManager) return NULL;
272
273 //a->Print("");
274
275 // prepare the Delta matrix Dg
276 TGeoHMatrix dg;
277 a->GetMatrix(dg);
278 //dg.Print();
279
280 // 1) start setting fSensVolModif = Gsv
281 if (SensVolMatrix(voluid, fSensVolModifMatrix)) return NULL;
282 //printf("\n1: modif=orig del sensvol\n");fSensVolModifMatrix->Print();
283
284 // 2) set fSensVolModif = Gg-1 * Gsv
285 fSensVolModifMatrix->MultiplyLeft( &fMatrix->Inverse() );
286 //printf("\n2: modif=relative del sensvol\n");fSensVolModifMatrix->Print();
287
288 // 3) set fSensVolModif = Dg * Gg-1 * Gsv
289 fSensVolModifMatrix->MultiplyLeft( &dg );
290 //printf("\n3: modif= delta*relative\n");fSensVolModifMatrix->Print();
291
292 // 4) set fSensVolModif = Gg * Dg * Gg-1 * Gsv
293 fSensVolModifMatrix->MultiplyLeft( fMatrix );
294 //printf("\n4: modif=quasi,manca il Gsv-1...\n");fSensVolModifMatrix->Print();
295
296 // 5) set fSensVolModif = Gsv-1 * Gg * Dg * Gg-1 * Gsv
297 if (SensVolMatrix(voluid, &dg)) return NULL;
298 fSensVolModifMatrix->MultiplyLeft( &dg.Inverse() );
299 //printf("\n5: modif=finale\n");fSensVolModifMatrix->Print();
300
75d480f6 301 // 6) mo' fSensVolModif dovrebbe essere la Dsv(loc) t.c. G'sv = Gsv*Dsv(loc)
302 // per trasformarla in Dsv(loc rispetto al Gsv0, non modificato) dovrebbe essere:
303 // Dsv(loc) -> Dpre * Dsv(loc) * Dpre-1
304 //TGeoHMatrix dpre; // dpre = Gsv0-1*Gsv
305 //if (SensVolOrigGlobalMatrix(voluid, &dg)) return NULL;
306 //if (SensVolMatrix(voluid, &dpre)) return NULL;
307 //dpre.MultiplyLeft( &dg.Inverse() );
308 //fSensVolModifMatrix->Multiply( &dpre.Inverse() );
309 //fSensVolModifMatrix->MultiplyLeft( &dpre );
310 // direi che NON FUNZIONA!!!!
311
d3603b4d 312 // reset align object (may not be needed...)
75d480f6 313 fTempAlignObj->SetVolUID(0);
314 fTempAlignObj->SetSymName("");
d3603b4d 315 fTempAlignObj->SetTranslation(0,0,0);
316 fTempAlignObj->SetRotation(0,0,0);
317
75d480f6 318 // correction for SPD y-shift
319 if (voluid>=2048 && voluid<4256) {
320 TGeoHMatrix deltay;
321 double dy[3]={0.,0.0081,0.};
322 deltay.SetTranslation(dy);
323 fSensVolModifMatrix->MultiplyLeft( &deltay );
324 fSensVolModifMatrix->Multiply( &deltay.Inverse() );
325 }
326
d3603b4d 327 if (!fTempAlignObj->SetMatrix(*fSensVolModifMatrix)) return NULL;
328 fTempAlignObj->SetVolUID(voluid);
329 fTempAlignObj->SetSymName(AliGeomManager::SymName(voluid));
330
331 //fTempAlignObj->Print("");
332
333 return fTempAlignObj;
334}
335//-------------------------------------------------------------
75d480f6 336
337
338//-------------------------------------------------------------
339AliAlignObjParams *AliITSAlignMilleModule::GetSensitiveVolumeTotalMisalignment(UShort_t voluid, const Double_t * const deltalocal)
340{
341 // calculate misalignment of sens.vol. 'voluid' according with a displacement 'deltalocal'
342 // of the mother volume. The misalignment is returned as AliAlignObjParams object including
343 // the (evenctual) prealignment => no merging needed
344
345 if (!IsIn(voluid)) return NULL;
346 if (!gGeoManager) return NULL;
347
348 // prepare the TGeoHMatrix
349 Double_t tr[3],ang[3];
350 tr[0]=deltalocal[0]; // in centimeter
351 tr[1]=deltalocal[1];
352 tr[2]=deltalocal[2];
353 ang[0]=deltalocal[3]; // psi (X) in deg
354 ang[1]=deltalocal[4]; // theta (Y)
355 ang[2]=deltalocal[5]; // phi (Z)
356
357 // reset align object (may not be needed...)
358 fTempAlignObj->SetVolUID(0);
359 fTempAlignObj->SetSymName("");
360 fTempAlignObj->SetRotation(ang[0],ang[1],ang[2]);
361 fTempAlignObj->SetTranslation(tr[0],tr[1],tr[2]);
362 AliDebug(3,Form("Delta angles: psi=%f theta=%f phi=%f",ang[0],ang[1],ang[2]));
363
364 // Gsv = Gg * Gg-1 * Gsv -> Lsv,g = Gg-1 * Gsv
365 // G'sv = Gg * Dg * Lsv,g === DGsv * Gsv
366 //
367 // => Dsv = (G0sv-1 * Gg * Dg * Gg-1 * GMsv) //
368 //
369
370 // prepare the Delta matrix Dg
371 TGeoHMatrix dg;
372 fTempAlignObj->GetMatrix(dg);
373 //dg.Print();
374
375 // 1) start setting fSensVolModif = Gsv
376 if (SensVolMatrix(voluid, fSensVolModifMatrix)) return NULL;
377 //printf("\n1: modif=orig del sensvol\n");fSensVolModifMatrix->Print();
378
379 // 2) set fSensVolModif = Gg-1 * Gsv
380 fSensVolModifMatrix->MultiplyLeft( &fMatrix->Inverse() );
381 //printf("\n2: modif=relative del sensvol\n");fSensVolModifMatrix->Print();
382
383 // 3) set fSensVolModif = Dg * Gg-1 * Gsv
384 fSensVolModifMatrix->MultiplyLeft( &dg );
385 //printf("\n3: modif= delta*relative\n");fSensVolModifMatrix->Print();
386
387 // 4) set fSensVolModif = Gg * Dg * Gg-1 * Gsv
388 fSensVolModifMatrix->MultiplyLeft( fMatrix );
389 //printf("\n4: modif=quasi,manca il Gsv-1...\n");fSensVolModifMatrix->Print();
390
391 // 5) set fSensVolModif = G0sv-1 * Gg * Dg * Gg-1 * Gsv
392 // qui usa l'orig anziche' la prealigned...
393 if (SensVolOrigGlobalMatrix(voluid, &dg)) return NULL;
394 fSensVolModifMatrix->MultiplyLeft( &dg.Inverse() );
395 //printf("\n5: modif=finale\n");fSensVolModifMatrix->Print();
396
397 // reset align object (may not be needed...)
398 fTempAlignObj->SetVolUID(0);
399 fTempAlignObj->SetSymName("");
400 fTempAlignObj->SetTranslation(0,0,0);
401 fTempAlignObj->SetRotation(0,0,0);
402
403 // correction for SPD y-shift
404 if (voluid>=2048 && voluid<4256) {
405 TGeoHMatrix deltay;
406 double dy[3]={0.,0.0081,0.};
407 deltay.SetTranslation(dy);
408 fSensVolModifMatrix->MultiplyLeft( &deltay );
409 fSensVolModifMatrix->Multiply( &deltay.Inverse() );
410 }
411 if (!fTempAlignObj->SetMatrix(*fSensVolModifMatrix)) return NULL;
412 fTempAlignObj->SetVolUID(voluid);
413 fTempAlignObj->SetSymName(AliGeomManager::SymName(voluid));
414
415
416 //fTempAlignObj->Print("");
417
418 return fTempAlignObj;
419}
420//-------------------------------------------------------------
421
422// //-------------------------------------------------------------
423// AliAlignObjParams *AliITSAlignMilleModule::GetSensitiveVolumeTotalMisalignment(UShort_t voluid, Double_t *deltalocal)
424// {
425// // calculate misalignment of sens.vol. 'voluid' according with a displacement 'deltalocal'
426// // of the mother volume. The misalignment is returned as AliAlignObjParams object including
427// // the (evenctual) prealignment => no merging needed
428
429// if (!IsIn(voluid)) return NULL;
430// if (!gGeoManager) return NULL;
431
432// // prepare the TGeoHMatrix
433// Double_t tr[3],ang[3];
434// tr[0]=deltalocal[0]; // in centimeter
435// tr[1]=deltalocal[1];
436// tr[2]=deltalocal[2];
437// ang[0]=deltalocal[3]; // psi (X) in deg
438// ang[1]=deltalocal[4]; // theta (Y)
439// ang[2]=deltalocal[5]; // phi (Z)
440
441// // reset align object (may not be needed...)
442// fTempAlignObj->SetVolUID(0);
443// fTempAlignObj->SetSymName("");
444// fTempAlignObj->SetRotation(ang[0],ang[1],ang[2]);
445// fTempAlignObj->SetTranslation(tr[0],tr[1],tr[2]);
446// AliDebug(3,Form("Delta angles: psi=%f theta=%f phi=%f",ang[0],ang[1],ang[2]));
447
448// // Gsv = Gg * Gg-1 * Gsv -> Lsv,g = Gg-1 * Gsv
449// // G'sv = Gg * Dg * Lsv,g === DGsv * Gsv
450// //
451// // => Dsv = (G0sv-1 * Gg * Dg * Gg-1 * GMsv) //
452// //
453
454// // prepare the Delta matrix Dg
455// TGeoHMatrix dg;
456// fTempAlignObj->GetMatrix(dg);
457// //dg.Print();
458
459// // 1) start setting fSensVolModif = Gsv
460// if (SensVolMatrix(voluid, fSensVolModifMatrix)) return NULL;
461// //printf("\n1: modif=orig del sensvol\n");fSensVolModifMatrix->Print();
462
463// // 2) set dg = Gg * Dg * Gg-1
464// dg.Multiply( &fMatrix->Inverse() );
465// dg.MultiplyLeft( fMatrix );
466
467// // 3) set dg = Gsv-1 * dg * Gsv locale nel sistema del SV preallineato
468// dg.Multiply( fSensVolModifMatrix );
469// dg.MultiplyLeft( &fSensVolModifMatrix->Inverse() );
470
471// // calcola la deltaPre
472// TGeoHMatrix hp;
473// if (SensVolOrigGlobalMatrix(voluid, &hp)) return NULL;
474// fSensVolModifMatrix->MultiplyLeft( &hp.Inverse() );
475
476// // mo' fSensVolModifMatrix e' la deltapre ideale
477// // col dg diventa la deltatot ideale
478// fSensVolModifMatrix->Multiply( &dg );
479// //fSensVolModifMatrix->MultiplyLeft( &dg );
480
481// // reset align object (may not be needed...)
482// fTempAlignObj->SetVolUID(0);
483// fTempAlignObj->SetSymName("");
484// fTempAlignObj->SetTranslation(0,0,0);
485// fTempAlignObj->SetRotation(0,0,0);
486
487// // correction for SPD y-shift
488// if (voluid>=2048 && voluid<4256) {
489// TGeoHMatrix deltay;
490// double dy[3]={0.,0.0081,0.};
491// deltay.SetTranslation(dy);
492// fSensVolModifMatrix->MultiplyLeft( &deltay );
493// fSensVolModifMatrix->Multiply( &deltay.Inverse() );
494// }
495// if (!fTempAlignObj->SetMatrix(*fSensVolModifMatrix)) return NULL;
496// fTempAlignObj->SetVolUID(voluid);
497// fTempAlignObj->SetSymName(AliGeomManager::SymName(voluid));
498
499
500// //fTempAlignObj->Print("");
501
502// return fTempAlignObj;
503// }
504// //-------------------------------------------------------------
505
506
507//-------------------------------------------------------------
508AliAlignObjParams *AliITSAlignMilleModule::GetSensitiveVolumeGlobalMisalignment(UShort_t voluid, const Double_t * const deltalocal)
509{
510 // calculate misalignment of sens.vol. 'voluid' according with a displacement 'deltalocal'
511 // of the mother volume. The misalignment is returned as AliAlignObjParams object
512
513 if (!IsIn(voluid)) return NULL;
514 if (!gGeoManager) return NULL;
515
516 // prepare the TGeoHMatrix
517 Double_t tr[3],ang[3];
518 tr[0]=deltalocal[0]; // in centimeter
519 tr[1]=deltalocal[1];
520 tr[2]=deltalocal[2];
521 ang[0]=deltalocal[3]; // psi (X) in deg
522 ang[1]=deltalocal[4]; // theta (Y)
523 ang[2]=deltalocal[5]; // phi (Z)
524
525 // reset align object (may not be needed...)
526 fTempAlignObj->SetTranslation(0,0,0);
527 fTempAlignObj->SetRotation(0,0,0);
528
529 fTempAlignObj->SetRotation(ang[0],ang[1],ang[2]);
530 fTempAlignObj->SetTranslation(tr[0],tr[1],tr[2]);
531 AliDebug(3,Form("Delta angles: psi=%f theta=%f phi=%f",ang[0],ang[1],ang[2]));
532
533 // Gsv = Gg * Gg-1 * Gsv -> Lsv,g = Gg-1 * Gsv
534 // G'sv = Gg * Dg * Lsv,g === DGsv * Gsv
535 //
536 // => DGsv = (Gg * Dg * Gg-1)
537 //
538
539 // prepare the Delta matrix Dg
540 TGeoHMatrix dg;
541 fTempAlignObj->GetMatrix(dg);
542 //dg.Print();
543
544 dg.MultiplyLeft( fMatrix );
545 dg.Multiply( &fMatrix->Inverse() );
546
547 // reset align object (may not be needed...)
548 fTempAlignObj->SetTranslation(0,0,0);
549 fTempAlignObj->SetRotation(0,0,0);
550
551 fTempAlignObj->SetVolUID(voluid);
552 fTempAlignObj->SetSymName(AliGeomManager::SymName(voluid));
553
554 if (!fTempAlignObj->SetMatrix(dg)) return NULL;
555
556 //fTempAlignObj->Print("");
557
558 return fTempAlignObj;
559}
560//-------------------------------------------------------------
561
d3603b4d 562TGeoHMatrix *AliITSAlignMilleModule::GetSensitiveVolumeMatrix(UShort_t voluid)
563{
564 // return TGeoHMatrix of the sens.vol. 'voluid' in the current geometry
565 if (SensVolMatrix(voluid,fSensVolMatrix)) return NULL;
566 return fSensVolMatrix;
567}
568//-------------------------------------------------------------
569TGeoHMatrix *AliITSAlignMilleModule::GetSensitiveVolumeOrigGlobalMatrix(UShort_t voluid)
570{
571 // return original ideal position (from AliGeomManager::GetOrigGlobalMatrix())
572 if (SensVolOrigGlobalMatrix(voluid,fSensVolMatrix)) return NULL;
573 return fSensVolMatrix;
574}
575//-------------------------------------------------------------
576Int_t AliITSAlignMilleModule::SensVolMatrix(UShort_t volid, TGeoHMatrix *m)
577{
578 // set matrix for sensitive modules (SPD corrected)
579 // return 0 if success
580 Double_t rot[9];
581 Int_t idx=GetIndexFromVolumeID(volid);
582 if (idx<0) return -1;
583 if (!AliITSgeomTGeo::GetRotation(idx,rot)) return -2;
584 m->SetRotation(rot);
585 Double_t oLoc[3]={0,0,0};
586 Double_t oGlo[3]={0,0,0};
587 if (!AliITSgeomTGeo::LocalToGlobal(idx,oLoc,oGlo)) return -3;
588 m->SetTranslation(oGlo);
589 return 0;
590}
591//-------------------------------------------------------------
592Int_t AliITSAlignMilleModule::SensVolOrigGlobalMatrix(UShort_t volid, TGeoHMatrix *m)
593{
594 // set original global matrix for sensitive modules (SPD corrected)
595 // return 0 if success
596 Int_t idx=GetIndexFromVolumeID(volid);
597 if (idx<0) return -1;
598 TGeoHMatrix mo;
75d480f6 599 if (!AliGeomManager::GetOrigGlobalMatrix(AliGeomManager::SymName(volid),mo)) return -1;
600
d3603b4d 601 (*m)=mo;
602
603 // SPD y-shift by 81 mu
604 if (volid<5000) {
605 Double_t oLoc[3]={0.0,0.0081,0.0};
606 Double_t oGlo[3]={0,0,0};
607 m->LocalToMaster(oLoc,oGlo);
608 m->SetTranslation(oGlo);
609 }
610 return 0;
611}
612//-------------------------------------------------------------
613UShort_t AliITSAlignMilleModule::GetVolumeIDFromSymname(const Char_t *symname) {
614 /// volume ID from symname
615 if (!symname) return 0;
616
617 for (UShort_t voluid=2000; voluid<13300; voluid++) {
618 Int_t modId;
619 AliGeomManager::ELayerID layerId = AliGeomManager::VolUIDToLayer(voluid,modId);
620 if (layerId>0 && layerId<7 && modId>=0 && modId<AliGeomManager::LayerSize(layerId)) {
621 if (!strcmp(symname,AliGeomManager::SymName(layerId,modId))) return voluid;
622 }
623 }
624
625 return 0;
626}
627
628UShort_t AliITSAlignMilleModule::GetVolumeIDFromIndex(Int_t index) {
629 /// volume ID from index
630 if (index<0 || index>2197) return 0;
631 return GetVolumeIDFromSymname(AliITSgeomTGeo::GetSymName(index));
632}
633//-------------------------------------------------------------
634void AliITSAlignMilleModule::Print(Option_t*) const
635{
636 ///
637 printf("*** ITS SuperModule for AliITSAlignMille ***\n");
638 printf("symname : %s\n",GetName());
639 printf("volumeID : %d\n",fVolumeID);
640 printf("index : %d\n",fIndex);
641 fMatrix->Print();
642 printf("number of sensitive modules : %d\n",fNSensVol);
643 for (Int_t i=0; i<fNSensVol; i++) printf(" voluid[%d] = %d\n",i,fSensVolVolumeID[i]);
644}
645//_____________________________________________________________________________
646AliITSAlignMilleModule::AliITSAlignMilleModule(const AliITSAlignMilleModule &m) :
647 TNamed(m),
648 fNSensVol(m.fNSensVol),
649 fIndex(m.fIndex),
650 fVolumeID(m.fVolumeID),
651 fMatrix(new TGeoHMatrix(*m.GetMatrix())),
652 fSensVolMatrix(new TGeoHMatrix),
653 fSensVolModifMatrix(new TGeoHMatrix),
654 fTempAlignObj(new AliAlignObjParams)
655{
656 // Copy constructor
657 for (int i=0; i<fNSensVol; i++) {
658 fSensVolIndex[i]=m.fSensVolIndex[i];
659 fSensVolVolumeID[i]=m.fSensVolVolumeID[i];
660 }
661}
662//_____________________________________________________________________________
663AliITSAlignMilleModule& AliITSAlignMilleModule::operator=(const AliITSAlignMilleModule &m)
664{
665 // operator =
666 //
667 if(this==&m) return *this;
668 ((TNamed *)this)->operator=(m);
669
670 fNSensVol=m.fNSensVol;
671 fIndex=m.fIndex;
672 fVolumeID=m.fVolumeID;
673 delete fMatrix;
674 fMatrix=new TGeoHMatrix(*m.GetMatrix());
675 for (int i=0; i<fNSensVol; i++) {
676 fSensVolIndex[i]=m.fSensVolIndex[i];
677 fSensVolVolumeID[i]=m.fSensVolVolumeID[i];
678 }
679 return *this;
680}
681
682//_____________________________________________________________________________
683
684