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