1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 ***************************************************************************/
18 Revision 1.19 2007/10/02 09:46:08 arcelli
19 add methods to retrieve real survey data, and make some analysis (by B. Guerzoni)
21 Revision 1.17 2007/06/06 16:26:46 arcelli
22 remove fall-back call to local CDB storage
24 Revision 1.16 2007/05/15 16:25:44 cvetan
25 Moving the alignment-related static methods from AliAlignObj to the new geometry steering class AliGeomManager (macro from Raffaele)
27 Revision 1.15 2007/05/03 09:25:10 decaro
28 Coding convention: RN13 violation -> suppression
30 Revision 1.14 2007/04/18 14:49:54 arcelli
31 Some code cleanup, added more debug info
33 Revision 1.13 2007/04/17 16:38:36 arcelli
34 Include Methods to derive TOF AlignObjs from Survey Data
36 Revision 1.12 2007/02/28 18:09:23 arcelli
37 Add protection against failed retrieval of the CDB cal object
39 Revision 1.11 2006/09/19 14:31:26 cvetan
40 Bugfixes and clean-up of alignment object classes. Introduction of so called symbolic names used to identify the alignable volumes (Raffaele and Cvetan)
42 Revision 1.10 2006/08/22 13:26:05 arcelli
43 removal of effective c++ warnings (C.Zampolli)
45 Revision 1.9 2006/08/10 14:46:54 decaro
46 TOF raw data format: updated version
48 Revision 1.8 2006/05/04 19:41:42 hristov
49 Possibility for partial TOF geometry (S.Arcelli)
51 Revision 1.7 2006/04/27 13:13:29 hristov
52 Moving the destructor to the implementation file
54 Revision 1.6 2006/04/20 22:30:49 hristov
55 Coding conventions (Annalisa)
57 Revision 1.5 2006/04/16 22:29:05 hristov
58 Coding conventions (Annalisa)
60 Revision 1.4 2006/04/05 08:35:38 hristov
61 Coding conventions (S.Arcelli, C.Zampolli)
63 Revision 1.3 2006/03/31 13:49:07 arcelli
64 Removing some junk printout
66 Revision 1.2 2006/03/31 11:26:30 arcelli
67 changing CDB Ids according to standard convention
69 Revision 1.1 2006/03/28 14:54:48 arcelli
70 class for TOF alignment
72 author: Silvia Arcelli, arcelli@bo.infn.it
75 /////////////////////////////////////////////////////////
77 // Class for alignment procedure //
81 /////////////////////////////////////////////////////////
90 #include "AliAlignObj.h"
91 #include "AliAlignObjParams.h"
92 #include "AliAlignObjMatrix.h"
93 #include "AliCDBManager.h"
94 #include "AliCDBMetaData.h"
96 #include "AliCDBEntry.h"
97 #include "AliTOFAlignment.h"
98 #include "AliSurveyObj.h"
99 #include "AliSurveyPoint.h"
100 #include "TObjString.h"
101 ClassImp(AliTOFAlignment)
103 const Double_t AliTOFAlignment::fgkRorigTOF = 384.5; // Mean Radius of the TOF ext. volume, cm
104 const Double_t AliTOFAlignment::fgkX1BTOF = 124.5; //x1 size of BTOF
105 const Double_t AliTOFAlignment::fgkX2BTOF = 134.7262; //x2 size of BTOF
106 const Double_t AliTOFAlignment::fgkYBTOF = 747.2; //y size of BTOF
107 const Double_t AliTOFAlignment::fgkZBTOF = 29.0; //z size of BTOF
108 const Double_t AliTOFAlignment::fgkXFM = 38.0; //x pos of FM in BTOF, cm
109 const Double_t AliTOFAlignment::fgkYFM = 457.3; //y pos of FM in BTOF, cm
110 const Double_t AliTOFAlignment::fgkZFM = 11.2; //z pos of FM in BTOF, cm
112 //_____________________________________________________________________________
113 AliTOFAlignment::AliTOFAlignment():
114 TTask("AliTOFAlignment",""),
117 fTOFAlignObjArray(0x0)
119 //AliTOFalignment main Ctor
120 for(Int_t i=0; i<18;i++)
121 for(Int_t j=0; j<5; j++)
123 for(Int_t i=0; i<72; i++)
124 for (Int_t j=0; j<6; j++)
127 //_____________________________________________________________________________
128 AliTOFAlignment::AliTOFAlignment(const AliTOFAlignment &t):
129 TTask("AliTOFAlignment",""),
132 fTOFAlignObjArray(0x0)
134 //AliTOFAlignment copy Ctor
136 fNTOFAlignObj=t.fNTOFAlignObj;
137 fTOFAlignObjArray=t.fTOFAlignObjArray;
138 //AliTOFalignment main Ctor
139 for(Int_t i=0; i<18;i++)
140 for(Int_t j=0; j<5; j++)
141 fNFMforSM[i][j]=t.fNFMforSM[i][j];
142 for(Int_t i=0; i<72; i++)
143 for (Int_t j=0; j<6; j++)
144 fCombFMData[i][j]=t.fCombFMData[i][j];
146 //_____________________________________________________________________________
147 AliTOFAlignment& AliTOFAlignment::operator=(const AliTOFAlignment &t){
148 //AliTOFAlignment assignment operator
150 this->fNTOFAlignObj=t.fNTOFAlignObj;
151 this->fTOFmgr=t.fTOFmgr;
152 this->fTOFAlignObjArray=t.fTOFAlignObjArray;
156 //_____________________________________________________________________________
157 AliTOFAlignment::~AliTOFAlignment() {
158 delete fTOFAlignObjArray;
162 //_____________________________________________________________________________
163 void AliTOFAlignment::Smear( Float_t *tr, Float_t *rot)
165 //Introduce Random Offset/Tilts
166 fTOFAlignObjArray = new TObjArray(kMaxAlignObj);
167 Float_t dx, dy, dz; // shifts
168 Float_t dpsi, dtheta, dphi; // angular displacements
169 TRandom *rnd = new TRandom(1567);
172 AliGeomManager::ELayerID iLayer = AliGeomManager::kInvalidLayer;
173 UShort_t iIndex=0; //dummy volume index
174 // AliGeomManager::ELayerID iLayer = AliGeomManager::kTOF;
175 // Int_t iIndex=1; //dummy volume index
176 UShort_t dvoluid = AliGeomManager::LayerToVolUID(iLayer,iIndex); //dummy volume identity
178 for (i = 0; i<nSMTOF ; i++) {
180 sprintf(path,"/ALIC_1/B077_1/BSEGMO%i_1/BTOF%i_1",i,i);
182 dx = (rnd->Gaus(0.,1.))*tr[0];
183 dy = (rnd->Gaus(0.,1.))*tr[1];
184 dz = (rnd->Gaus(0.,1.))*tr[2];
188 AliAlignObjParams *o =new AliAlignObjParams(path, dvoluid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
189 fTOFAlignObjArray->Add(o);
192 fNTOFAlignObj=fTOFAlignObjArray->GetEntries();
193 AliInfo(Form("Number of Alignable Volumes: %d",fNTOFAlignObj));
197 //_____________________________________________________________________________
198 void AliTOFAlignment::Align( Float_t *tr, Float_t *rot)
200 //Introduce Offset/Tilts
202 fTOFAlignObjArray = new TObjArray(kMaxAlignObj);
203 Float_t dx, dy, dz; // shifts
204 Float_t dpsi, dtheta, dphi; // angular displacements
208 AliGeomManager::ELayerID iLayer = AliGeomManager::kInvalidLayer;
209 UShort_t iIndex=0; //dummy volume index
210 UShort_t dvoluid = AliGeomManager::LayerToVolUID(iLayer,iIndex); //dummy volume identity
212 for (i = 0; i<nSMTOF ; i++) {
215 sprintf(path,"/ALIC_1/B077_1/BSEGMO%i_1/BTOF%i_1",i,i);
223 AliAlignObjParams *o =new AliAlignObjParams(path, dvoluid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
224 fTOFAlignObjArray->Add(o);
226 fNTOFAlignObj=fTOFAlignObjArray->GetEntries();
227 AliInfo(Form("Number of Alignable Volumes: %d",fNTOFAlignObj));
229 //_____________________________________________________________________________
230 void AliTOFAlignment::WriteParOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
232 //Write Align Par on CDB
233 AliCDBManager *man = AliCDBManager::Instance();
234 Char_t *sel1 = "AlignPar" ;
236 sprintf(out,"%s/%s",sel,sel1);
237 AliCDBId idTOFAlign(out,minrun,maxrun);
238 AliCDBMetaData *mdTOFAlign = new AliCDBMetaData();
239 mdTOFAlign->SetResponsible("TOF");
240 AliInfo(Form("Number of Alignable Volumes: %d",fNTOFAlignObj));
241 man->Put(fTOFAlignObjArray,idTOFAlign,mdTOFAlign);
243 //_____________________________________________________________________________
244 void AliTOFAlignment::ReadParFromCDB(Char_t *sel, Int_t nrun)
246 //Read Align Par from CDB
247 AliCDBManager *man = AliCDBManager::Instance();
248 Char_t *sel1 = "AlignPar" ;
250 sprintf(out,"%s/%s",sel,sel1);
251 AliCDBEntry *entry = man->Get(out,nrun);
253 AliError(Form("Failed to get entry: %s",out));
256 fTOFAlignObjArray=(TObjArray*)entry->GetObject();
257 fNTOFAlignObj=fTOFAlignObjArray->GetEntries();
258 AliInfo(Form("Number of Alignable Volumes from CDB: %d",fNTOFAlignObj));
261 //_____________________________________________________________________________
262 void AliTOFAlignment::WriteSimParOnCDB(Char_t *sel, Int_t minrun, Int_t maxrun)
264 //Write Sim Align Par on CDB
265 AliCDBManager *man = AliCDBManager::Instance();
266 Char_t *sel1 = "AlignSimPar" ;
268 sprintf(out,"%s/%s",sel,sel1);
269 AliCDBId idTOFAlign(out,minrun,maxrun);
270 AliCDBMetaData *mdTOFAlign = new AliCDBMetaData();
271 mdTOFAlign->SetResponsible("TOF");
272 AliInfo(Form("Number of Alignable Volumes: %d",fNTOFAlignObj));
273 man->Put(fTOFAlignObjArray,idTOFAlign,mdTOFAlign);
275 //_____________________________________________________________________________
276 void AliTOFAlignment::ReadSimParFromCDB(Char_t *sel, Int_t nrun){
277 //Read Sim Align Par from CDB
278 AliCDBManager *man = AliCDBManager::Instance();
279 Char_t *sel1 = "AlignSimPar" ;
281 sprintf(out,"%s/%s",sel,sel1);
282 AliCDBEntry *entry = man->Get(out,nrun);
283 fTOFAlignObjArray=(TObjArray*)entry->GetObject();
284 fNTOFAlignObj=fTOFAlignObjArray->GetEntries();
285 AliInfo(Form("Number of Alignable Volumes from CDB: %d",fNTOFAlignObj));
288 //_____________________________________________________________________________
289 void AliTOFAlignment::WriteOnCDBforDC()
291 //Write Align Par on CDB for DC06
292 AliCDBManager *man = AliCDBManager::Instance();
293 AliCDBId idTOFAlign("TOF/Align/Data",0,0);
294 AliCDBMetaData *mdTOFAlign = new AliCDBMetaData();
295 mdTOFAlign->SetComment("Alignment objects for ideal geometry, i.e. applying them to TGeo has to leave geometry unchanged");
296 mdTOFAlign->SetResponsible("TOF");
297 AliInfo(Form("Number of Alignable Volumes: %d",fNTOFAlignObj));
298 man->Put(fTOFAlignObjArray,idTOFAlign,mdTOFAlign);
300 //_____________________________________________________________________________
301 void AliTOFAlignment::ReadFromCDBforDC()
303 //Read Sim Align Par from CDB for DC06
304 AliCDBManager *man = AliCDBManager::Instance();
305 AliCDBEntry *entry = man->Get("TOF/Align/Data",0);
306 fTOFAlignObjArray=(TObjArray*)entry->GetObject();
307 fNTOFAlignObj=fTOFAlignObjArray->GetEntries();
308 AliInfo(Form("Number of Alignable Volumes from CDB: %d",fNTOFAlignObj));
312 //_____________________________________________________________________________
313 void AliTOFAlignment::BuildGeomForSurvey()
316 //Generates the ideal TOF structure with four Fiducial Marks in each
317 //supermodule (two on each z side) in their expected position.
320 fTOFmgr = new TGeoManager("Geom","survey to alignment for TOF");
321 TGeoMedium *medium = 0;
322 TGeoVolume *top = fTOFmgr->MakeBox("TOP",medium,1000,1000,1000);
323 fTOFmgr->SetTopVolume(top);
324 // make shape components:
325 // This is the BTOF containing the FTOA
326 TGeoTrd1 *strd1 = new TGeoTrd1(fgkX1BTOF*0.5,fgkX2BTOF*0.5, fgkYBTOF*0.5,fgkZBTOF*0.5);
327 TGeoVolume* trd1[18];
329 // Now four fiducial marks on SM, expressed in local coordinates
330 // They are positioned at x=+/- 38 cm, y=+/- 457.3 cm, z=11.2 cm
332 TGeoBBox *fmbox = new TGeoBBox(1,1,1);
333 TGeoVolume* fm = new TGeoVolume("FM",fmbox);
337 TGeoTranslation* mAtr = new TGeoTranslation("mAtr",-fgkXFM, -fgkYFM ,fgkZFM);
338 TGeoTranslation* mBtr = new TGeoTranslation("mBtr",fgkXFM, -fgkYFM ,fgkZFM );
339 TGeoTranslation* mCtr = new TGeoTranslation("mCtr",fgkXFM, fgkYFM ,fgkZFM );
340 TGeoTranslation* mDtr = new TGeoTranslation("mDtr",-fgkXFM, fgkYFM ,fgkZFM );
342 // position all this stuff in the global ALICE frame
348 Float_t smR = fgkRorigTOF;
349 for (Int_t iSM = 0; iSM < 18; iSM++) {
350 Int_t mod = iSM + 13;
351 if (mod > 17) mod -= 18;
352 sprintf(name, "BTOF%d",mod);
353 trd1[iSM] = new TGeoVolume(name,strd1);
354 Float_t phi = iSM * 20.;
355 Float_t phi2 = 270 + phi;
356 if (phi2 >= 360.) phi2 -= 360.;
357 smX = TMath::Sin(phi*TMath::Pi()/180.)*smR;
358 smY = -TMath::Cos(phi*TMath::Pi()/180.)*smR;
360 TGeoRotation* bTOFRot = new TGeoRotation("bTOFRot",phi,90,0.);
361 TGeoCombiTrans trans = *(new TGeoCombiTrans(smX,smY,smZ, bTOFRot));
362 TGeoMatrix* id = new TGeoHMatrix();
363 TGeoHMatrix transMat = *id * trans;
364 TGeoHMatrix *smTrans = new TGeoHMatrix(transMat);
366 trd1[iSM]->AddNode(fm,1,mAtr); //place FM in BTOF
367 trd1[iSM]->AddNode(fm,2,mBtr);
368 trd1[iSM]->AddNode(fm,3,mCtr);
369 trd1[iSM]->AddNode(fm,4,mDtr);
370 top->AddNode(trd1[iSM],1,smTrans); //place BTOF_iSM in ALICE
371 trd1[iSM]->SetVisDaughters();
372 trd1[iSM]->SetLineColor(iSM); //black
376 fTOFmgr->CloseGeometry();
377 fTOFmgr->GetTopVolume()->Draw();
378 fTOFmgr->SetVisOption(0);
379 fTOFmgr->SetVisLevel(6);
381 // Now Store the "Ideal" Global Matrices (local to global) for later use
383 for (Int_t iSM = 0; iSM < 18; iSM++) {
385 sprintf(name, "TOP_1/BTOF%d_1", iSM);
386 printf("\n\n***************** TOF SuperModule: %s ****************** \n",name);
387 TGeoPhysicalNode* pn3 = fTOFmgr->MakePhysicalNode(name);
388 fTOFMatrixId[iSM] = pn3->GetMatrix(); //save "ideal" global matrix
389 printf("\n\n*************** The Ideal Matrix in GRS *****************\n");
390 fTOFMatrixId[iSM]->Print();
395 //_____________________________________________________________________________
396 void AliTOFAlignment::InsertMisAlignment(Float_t *mis)
398 // Now Apply the Displacements and store the misaligned FM positions...
402 Double_t lA[3]={-fgkXFM, -fgkYFM ,fgkZFM};
403 Double_t lB[3]={fgkXFM, -fgkYFM ,fgkZFM};
404 Double_t lC[3]={fgkXFM, fgkYFM ,fgkZFM};
405 Double_t lD[3]={-fgkXFM, fgkYFM ,fgkZFM};
407 for(Int_t iSM=0;iSM<18;iSM++){
409 sprintf(name, "TOP_1/BTOF%d_1", iSM);
411 printf("\n\n******Misaligning TOF SuperModule ************** %s \n",name);
413 // ************* get ideal global matrix *******************
414 TGeoHMatrix g3 = *fTOFmgr->GetCurrentMatrix();
415 AliInfo(Form("This is the ideal global trasformation of SM %i",iSM));
416 g3.Print(); // g3 is the local(BTOF) to global (ALICE) matrix and is the same of fTOFMatrixId
417 TGeoNode* n3 = fTOFmgr->GetCurrentNode();
418 TGeoMatrix* l3 = n3->GetMatrix();
420 Double_t gA[3], gB[3], gC[3], gD[3]; // ideal global FM point coord.
421 g3.LocalToMaster(lA,gA);
422 g3.LocalToMaster(lB,gB);
423 g3.LocalToMaster(lC,gC);
424 g3.LocalToMaster(lD,gD);
426 // We apply a delta transformation to the surveyed vol to represent
427 // its real position, given below by ng3 nl3, which differs from its
428 // ideal position saved above in g3 and l3
430 //we have to express the displacements as regards the old local RS (non misaligned BTOF)
431 Double_t dx = mis[0]; // shift along x
432 Double_t dy = mis[1]; // shift along y
433 Double_t dz = mis[2]; // shift along z
434 Double_t dphi = mis[3]; // rot around z
435 Double_t dtheta = mis[4]; // rot around x'
436 Double_t dpsi = mis[5]; // rot around z''
438 TGeoRotation* rrot = new TGeoRotation("rot",dphi,dtheta,dpsi);
439 TGeoCombiTrans localdelta = *(new TGeoCombiTrans(dx,dy,dz, rrot));
440 AliInfo(Form("This is the local delta trasformation for SM %i \n",iSM));
442 TGeoHMatrix nlocal = *l3 * localdelta;
443 TGeoHMatrix* nl3 = new TGeoHMatrix(nlocal); // new matrix, representing real position (from new local mis RS to the global one)
445 TGeoPhysicalNode* pn3 = fTOFmgr->MakePhysicalNode(name);
449 TGeoHMatrix* ng3 = pn3->GetMatrix(); //"real" global matrix, what survey sees
450 printf("\n\n************* The Misaligned Matrix in GRS **************\n");
452 Double_t ngA[3], ngB[3], ngC[3], ngD[3];// real FM point coord., global RS
453 ng3->LocalToMaster(lA,ngA);
454 ng3->LocalToMaster(lB,ngB);
455 ng3->LocalToMaster(lC,ngC);
456 ng3->LocalToMaster(lD,ngD);
458 for(Int_t coord=0;coord<3;coord++){
459 fCombFMData[iSM*4][2*coord]=ngA[coord];
460 fCombFMData[iSM*4][2*coord+1]=1;
461 fCombFMData[iSM*4+1][2*coord]=ngB[coord];
462 fCombFMData[iSM*4+1][2*coord+1]=1;
463 fCombFMData[iSM*4+2][2*coord]=ngC[coord];
464 fCombFMData[iSM*4+2][2*coord+1]=1;
465 fCombFMData[iSM*4+3][2*coord]=ngD[coord];
466 fCombFMData[iSM*4+3][2*coord+1]=1;
472 //____________________________________________________________________________
473 void AliTOFAlignment::WriteCombData(const Char_t *nomefile, Int_t option)
475 // 1 for simulated data; 0 for data from survey file
476 // write combined data on a file
480 /* Open file in text mode: */
481 if( (data = fopen( nomefile, "w+t" )) != NULL ){
483 fprintf( data, "simulated data\n" );} else {
484 fprintf( data, "survey data\n" );}
486 fprintf( data, "data from InsertMisAlignmentBTOF method\n");}
487 else {fprintf( data, "real survey data from text file (coordinate in global RS)\n");}
488 fprintf( data, "Point Name,XPH,YPH,ZPH,PrecisionX(mm),PrecisionY(mm),PrecisionZ(mm)\n");
489 fprintf( data, "> Data:\n");
490 for(Int_t i=0;i<72;i++){
491 if (fCombFMData[i][0]!=0){
492 fprintf( data, "SM%02iFM%i %f %f %f M Y %f %f %f\n", (i-i%4)/4, i%4, fCombFMData[i][0],fCombFMData[i][2],fCombFMData[i][4],fCombFMData[i][1]*10,fCombFMData[i][3]*10,fCombFMData[i][5]*10);
498 printf( "Problem opening the file\n" );
504 //____________________________________________________________________________
505 void AliTOFAlignment::WriteSimSurveyData(const Char_t *nomefile)
507 // write sim data in standard format
512 /* Open file in text mode: */
513 if( (data = fopen( nomefile, "w+t" )) != NULL )
515 fprintf( data, "> Title:\n" );
516 fprintf( data, "simulated data\n" );
517 fprintf( data, "> Date:\n" );
518 fprintf( data, "24.09.2007\n" );
519 fprintf( data, "> Subdetector:\n" );
520 fprintf( data, "TOF\n" );
521 fprintf( data, "> Report URL:\n" );
522 fprintf( data, "https://edms.cern.ch/document/835615\n" );
523 fprintf( data, "> Version:\n" );
524 fprintf( data, "1\n");
525 fprintf( data, "> General Observations:\n");
526 fprintf( data, "data from InsertMisAlignmentBTOF method\n");
527 fprintf( data, "> Coordinate System:\n");
528 fprintf( data, "\\ALICEPH\n");
529 fprintf( data, "> Units:\n");
530 fprintf( data, "cm\n");
531 fprintf( data, "> Nr Columns:\n");
532 fprintf( data, "9\n");
533 fprintf( data, "> Column Names:\n");
534 fprintf( data, "Point Name,XPH,YPH,ZPH,Point Type,Target Used,PrecisionX(mm),PrecisionY(mm),PrecisionZ(mm)\n");
535 fprintf( data, "> Data:\n");
536 for(Int_t i=0;i<72;i++)
537 if (fCombFMData[i][0]!=0)
538 fprintf( data, "SM%02iFM%i %f %f %f M Y %f %f %f\n", (i-i%4)/4, i%4, fCombFMData[i][0],fCombFMData[i][2],fCombFMData[i][4],fCombFMData[i][1],fCombFMData[i][3],fCombFMData[i][5]);
543 printf( "Problem opening the file\n" );
546 //____________________________________________________________________________
547 void AliTOFAlignment::MakeDefData(const Int_t nf,TString namefiles[])
549 //this method combines survey data from different files (namefiles[])
553 Float_t data[72][6][100];
554 for (Int_t i=0;i<72;i++)
555 for (Int_t j=0; j<6; j++)
556 for(Int_t k=0; k<100; k++)
560 Long64_t totdata[72]={0};
562 for (Int_t i=0;i<nf; i++)
564 AliSurveyObj *so = new AliSurveyObj();
565 const Char_t *nome=namefiles[i];
566 so->FillFromLocalFile(nome);
567 TObjArray *points = so->GetData();
568 Int_t nSurveyPoint=points->GetEntries();
569 for(Int_t i=0;i<nSurveyPoint;i++){
570 const char* pointName= ((AliSurveyPoint *) points->At(i))->GetPointName().Data();
571 nfm=atoi(&pointName[6]);
572 nsm=atoi(&pointName[2]);
573 data[nsm*4+nfm][0][totdata[nsm*4+nfm]]=((AliSurveyPoint *) points->At(i))->GetX();
574 data[nsm*4+nfm][2][totdata[nsm*4+nfm]]=((AliSurveyPoint *) points->At(i))->GetY();
575 data[nsm*4+nfm][4][totdata[nsm*4+nfm]]=((AliSurveyPoint *) points->At(i))->GetZ();
576 data[nsm*4+nfm][1][totdata[nsm*4+nfm]]=((AliSurveyPoint *) points->At(i))->GetPrecisionX();
577 data[nsm*4+nfm][3][totdata[nsm*4+nfm]]=((AliSurveyPoint *) points->At(i))->GetPrecisionY();
578 data[nsm*4+nfm][5][totdata[nsm*4+nfm]]=((AliSurveyPoint *) points->At(i))->GetPrecisionZ();
579 totdata[nsm*4+nfm]=totdata[nsm*4+nfm]+1;
586 for(Int_t i=0; i<72 ;i++){
587 Float_t numx=0, numy=0,numz=0, comodox=0, comodoy=0, comodoz=0,denx=0, deny=0, denz=0;
589 for(Int_t j=0; j<totdata[i]; j++){
590 comodox=1/(data[i][1][j]/10*data[i][1][j]/10);//precision in mm, position in cm
591 numx=numx+data[i][0][j]*comodox;
593 comodoy=1/(data[i][3][j]/10*data[i][3][j]/10);
594 numy=numy+data[i][2][j]*comodoy;
596 comodoz=1/(data[i][5][j]/10*data[i][5][j]/10);
597 numz=numz+data[i][4][j]*comodoz;
600 fCombFMData[i][1]=TMath::Sqrt(1/denx); //error for x position
601 fCombFMData[i][3]=TMath::Sqrt(1/deny); //error for y position
602 fCombFMData[i][5]=TMath::Sqrt(1/denz); //error for z position
603 fCombFMData[i][0]=numx/denx; //combined survey data for x position of FM
604 fCombFMData[i][2]=numy/deny; //combined survey data for y position of FM
605 fCombFMData[i][4]=numz/denz; //combined survey data for z position of FM
609 for(Int_t i=0;i<72;i++)
610 if (fCombFMData[i][0]!=0){
611 fNFMforSM[(i-i%4)/4][i%4]=1;
612 fNFMforSM[(i-i%4)/4][4]=fNFMforSM[(i-i%4)/4][4]+1;
616 //_____________________________________________________________________________
617 void AliTOFAlignment::ReadSurveyDataAndAlign(){
619 // read the survey data and, if we know the positions of at least 3 FM
620 //for a SM, call the right Alignement procedure
622 fTOFAlignObjArray = new TObjArray(kMaxAlignObj);
624 Float_t deltaFM0=0, deltaFM1=0, deltaFM2=0, deltaFM3=0;
626 for(Int_t i=0; i<18; i++){
627 switch(fNFMforSM[i][4]){
629 printf("we don't know the position of any FM of SM %i\n",i);
632 printf("we know the position of only one FM for SM %i\n",i);
636 printf("we know the position of only 2 FM for SM %i\n",i);
640 if (fNFMforSM[i][0]==1 && fNFMforSM[i][1]==1 && fNFMforSM[i][2]==1){
641 printf("we know the position of FM A B C for SM %i\n",i);
642 AliTOFAlignment::AlignFromSurveyABC(i);};
645 if (fNFMforSM[i][0]==1 && fNFMforSM[i][1]==1 && fNFMforSM[i][3]==1){
646 printf("we know the position of FM A B D for SM %i\n",i);
647 AliTOFAlignment::AlignFromSurveyABD(i);};
650 if (fNFMforSM[i][0]==1 && fNFMforSM[i][2]==1 && fNFMforSM[i][3]==1){
651 printf("we know the position of FM A C D for SM %i\n",i);
652 AliTOFAlignment::AlignFromSurveyACD(i);};
655 if (fNFMforSM[i][1]==1 && fNFMforSM[i][2]==1 && fNFMforSM[i][3]==1){
656 printf("we know the position of FM B C D for SM %i\n",i);
657 AliTOFAlignment::AlignFromSurveyBCD(i);};
662 printf("we know the position of all the 4 FM for SM %i\n",i);
663 //check the precision of the measurement
665 deltaFM0=fCombFMData[i*4][1]/TMath::Abs(fCombFMData[i*4][0])+fCombFMData[i*4][3]/TMath::Abs(fCombFMData[i*4][2])+fCombFMData[i*4][5]/TMath::Abs(fCombFMData[i*4][4]);
666 deltaFM1=fCombFMData[i*4+1][1]/TMath::Abs(fCombFMData[i*4+1][0])+fCombFMData[i*4+1][3]/TMath::Abs(fCombFMData[i*4+1][2])+fCombFMData[i*4+1][5]/TMath::Abs(fCombFMData[i*4+1][4]);
667 deltaFM2=fCombFMData[i*4+2][1]/TMath::Abs(fCombFMData[i*4+2][0])+fCombFMData[i*4+2][3]/TMath::Abs(fCombFMData[i*4+2][2])+fCombFMData[i*4+2][5]/TMath::Abs(fCombFMData[i*4+2][4]);
668 deltaFM3=fCombFMData[i*4+3][1]/TMath::Abs(fCombFMData[i*4+3][0])+fCombFMData[i*4+3][3]/TMath::Abs(fCombFMData[i*4+3][2])+fCombFMData[i*4+3][5]/TMath::Abs(fCombFMData[i*4+3][4]);
670 //to AlignFromSurvey we use the 3 FM whose positions are known with greatest precision
671 if(deltaFM0>=deltaFM1 && deltaFM0>=deltaFM2 && deltaFM0>=deltaFM3){
672 printf("to Align we use FM B,C,D");
673 AliTOFAlignment::AlignFromSurveyBCD(i);} else
674 if(deltaFM1>=deltaFM0 && deltaFM1>=deltaFM2 && deltaFM1>=deltaFM3){
675 printf("to Align we use FM A,C,D");
676 AliTOFAlignment::AlignFromSurveyACD(i);} else
677 if(deltaFM2>=deltaFM0 && deltaFM2>=deltaFM1 && deltaFM2>=deltaFM3){
678 printf("to Align we use FM A,B,D");
679 AliTOFAlignment::AlignFromSurveyABD(i);} else{
680 printf("to Align we use FM A,B,C");
681 AliTOFAlignment::AlignFromSurveyABC(i);}
688 // saving TOF AligObjs from survey on a file, for the moment..
689 fNTOFAlignObj=fTOFAlignObjArray->GetEntries();
690 AliInfo(Form("Number of Alignable Volumes: %d",fNTOFAlignObj));
691 TFile f("TOFAlignFromSurvey.root","RECREATE");
693 f.WriteObject(fTOFAlignObjArray,"TOFAlignObjs","kSingleKey");
699 //_____________________________________________________________________________
700 void AliTOFAlignment::AlignFromSurveyABC(Int_t iSM)
703 //From Survey data, derive the needed transformations to get the
705 //Again, highly "inspired" to Raffaele's example...
708 Double_t ngA[3], ngB[3], ngC[3]; // real FM point coord., global RS
709 // Get the 'realistic' input from the Survey Matrix
710 for(Int_t coord=0;coord<3;coord++){
711 ngA[coord]= fCombFMData[iSM*4][coord*2];
712 ngB[coord]= fCombFMData[iSM*4+1][coord*2];
713 ngC[coord]= fCombFMData[iSM*4+2][coord*2];
716 printf("\n\n******Survey analysis for TOF SuperModule ************** %i \n",iSM);
718 // From the real fiducial marks coordinates derive back the
719 // new global position of the surveyed volume
720 //*** What follows is the actual survey-to-alignment procedure
722 Double_t ab[3], bc[3], n[3];
723 Double_t plane[4], s=1.;
725 // first vector on the plane of the fiducial marks
726 for(Int_t i=0;i<3;i++){
727 ab[i] = (ngB[i] - ngA[i]);
730 // second vector on the plane of the fiducial marks
731 for(Int_t i=0;i<3;i++){
732 bc[i] = (ngC[i] - ngB[i]);
735 // vector normal to the plane of the fiducial marks obtained
736 // as cross product of the two vectors on the plane d0^d1
737 n[0] = (ab[1] * bc[2] - ab[2] * bc[1]);
738 n[1] = (ab[2] * bc[0] - ab[0] * bc[2]);
739 n[2] = (ab[0] * bc[1] - ab[1] * bc[0]);
741 Double_t sizen = TMath::Sqrt( n[0]*n[0] + n[1]*n[1] + n[2]*n[2] );
743 s = Double_t(1.)/sizen ; //normalization factor
745 AliInfo("Problem in normalizing the vector");
748 // plane expressed in the hessian normal form, see:
749 // http://mathworld.wolfram.com/HessianNormalForm.html
750 // the first three are the coordinates of the orthonormal vector
751 // the fourth coordinate is equal to the distance from the origin
753 for(Int_t i=0;i<3;i++){
756 plane[3] = ( plane[0] * ngA[0] + plane[1] * ngA[1] + plane[2] * ngA[2] );
758 // The center of the square with fiducial marks as corners
759 // as the middle point of one diagonal - md
760 // Used below to get the center - orig - of the surveyed box
762 Double_t orig[3], md[3];
763 for(Int_t i=0;i<3;i++){
764 md[i] = (ngA[i] + ngC[i]) * 0.5;
767 // The center of the box, gives the global translation
768 for(Int_t i=0;i<3;i++){
769 orig[i] = md[i] - plane[i]*fgkZFM;
772 // get local directions needed to write the global rotation matrix
773 // for the surveyed volume by normalising vectors ab and bc
774 Double_t sx = TMath::Sqrt(ab[0]*ab[0] + ab[1]*ab[1] + ab[2]*ab[2]);
778 for(Int_t i=0;i<3;i++){
782 Double_t sy = TMath::Sqrt(bc[0]*bc[0] + bc[1]*bc[1] + bc[2]*bc[2]);
784 for(Int_t i=0;i<3;i++){
788 Double_t rot[9] = {ab[0],bc[0],plane[0],ab[1],bc[1],plane[1],ab[2],bc[2],plane[2]}; // the rotation matrix
789 // the Aligned matrix for the current TOF SM in the Global RS, as derived from Survey
791 ng.SetTranslation(orig);
793 printf("\n\n**** The Misaligned Matrix in GRS, as from Survey data ***\n");
796 // Calculate the delta transformation wrt Ideal geometry
797 // (Should be gdelta.rot ==I and gdelta.tr=0 if no misalignment is applied.)
799 printf("\n\n**** The ideal matrix ***\n");
800 fTOFMatrixId[iSM]->Print();
802 TGeoHMatrix gdelta =fTOFMatrixId[iSM]->Inverse();
803 printf("\n\n**** The inverse of the ideal matrix ***\n");
806 gdelta.MultiplyLeft(&ng);
807 printf("\n\n**** The Delta Matrix in GRS, as from Survey data ***\n");
808 gdelta.Print(); //this is the global delta trasformation
810 // Now Write the Alignment Objects....
811 Int_t index=0; //let all SM modules have index=0
812 AliGeomManager::ELayerID layer = AliGeomManager::kInvalidLayer;
813 UShort_t dvoluid = AliGeomManager::LayerToVolUID(layer,index); //dummy vol id
814 TString symname(Form("TOF/sm%02d",iSM));
815 AliAlignObjMatrix* o = new AliAlignObjMatrix(symname.Data(),dvoluid,gdelta,kTRUE);
816 fTOFAlignObjArray->Add(o);
821 //_____________________________________________________________________________
822 void AliTOFAlignment::AlignFromSurveyABD(Int_t iSM)
825 //From Survey data, derive the needed transformations to get the
827 //Again, highly "inspired" to Raffaele's example...
830 Double_t ngA[3], ngB[3], ngD[3];// real FM point coord., global RS
832 // Get the 'realistic' input from the Survey Matrix
833 for(Int_t coord=0;coord<3;coord++){
834 ngA[coord]= fCombFMData[iSM*4][coord*2];
835 ngB[coord]= fCombFMData[iSM*4+1][coord*2];
836 ngD[coord]= fCombFMData[iSM*4+3][coord*2];
839 printf("\n\n******Survey analysis for TOF SuperModule ************** %i \n",iSM);
841 // From the new fiducial marks coordinates derive back the
842 // new global position of the surveyed volume
843 //*** What follows is the actual survey-to-alignment procedure
845 Double_t ab[3], ad[3], n[3];
846 Double_t plane[4], s=1.;
848 // first vector on the plane of the fiducial marks
849 for(Int_t i=0;i<3;i++){
850 ab[i] = (ngB[i] - ngA[i]);
853 // second vector on the plane of the fiducial marks
854 for(Int_t i=0;i<3;i++){
855 ad[i] = (ngD[i] - ngA[i]);
858 // vector normal to the plane of the fiducial marks obtained
859 // as cross product of the two vectors on the plane d0^d1
860 n[0] = (ab[1] * ad[2] - ab[2] * ad[1]);
861 n[1] = (ab[2] * ad[0] - ab[0] * ad[2]);
862 n[2] = (ab[0] * ad[1] - ab[1] * ad[0]);
864 Double_t sizen = TMath::Sqrt( n[0]*n[0] + n[1]*n[1] + n[2]*n[2] );
866 s = Double_t(1.)/sizen ; //normalization factor
868 AliInfo("Problem in normalizing the vector");
871 // plane expressed in the hessian normal form, see:
872 // http://mathworld.wolfram.com/HessianNormalForm.html
873 // the first three are the coordinates of the orthonormal vector
874 // the fourth coordinate is equal to the distance from the origin
876 for(Int_t i=0;i<3;i++){
879 plane[3] = ( plane[0] * ngA[0] + plane[1] * ngA[1] + plane[2] * ngA[2] );
881 // The center of the square with fiducial marks as corners
882 // as the middle point of one diagonal - md
883 // Used below to get the center - orig - of the surveyed box
885 Double_t orig[3], md[3];
886 for(Int_t i=0;i<3;i++){
887 md[i] = (ngB[i] + ngD[i]) * 0.5;
890 // The center of the box, gives the global translation
891 for(Int_t i=0;i<3;i++){
892 orig[i] = md[i] - plane[i]*fgkZFM;
895 // get local directions needed to write the global rotation matrix
896 // for the surveyed volume by normalising vectors ab and bc
897 Double_t sx = TMath::Sqrt(ab[0]*ab[0] + ab[1]*ab[1] + ab[2]*ab[2]);
899 for(Int_t i=0;i<3;i++){
903 Double_t sy = TMath::Sqrt(ad[0]*ad[0] + ad[1]*ad[1] + ad[2]*ad[2]);
905 for(Int_t i=0;i<3;i++){
909 Double_t rot[9] = {ab[0],ad[0],plane[0],ab[1],ad[1],plane[1],ab[2],ad[2],plane[2]};
910 // the Aligned matrix for the current TOF SM in the Global RS, as derived from Survey:
912 ng.SetTranslation(orig);
914 printf("\n\n**** The Misaligned Matrix in GRS, as from Survey data ***\n");
917 // Calculate the delta transformation wrt Ideal geometry
918 // (Should be gdelta.rot ==I and gdelta.tr=0 if no misalignment is applied.)
920 printf("\n\n**** The ideal matrix ***\n");
921 fTOFMatrixId[iSM]->Print();
923 TGeoHMatrix gdelta =fTOFMatrixId[iSM]->Inverse();
924 printf("\n\n**** The inverse of the ideal matrix ***\n");
927 gdelta.MultiplyLeft(&ng);
928 printf("\n\n**** The Delta Matrix in GRS, as from Survey data ***\n");
929 gdelta.Print(); //global delta trasformation
931 // Now Write the Alignment Objects....
932 Int_t index=0; //let all SM modules have index=0
933 AliGeomManager::ELayerID layer = AliGeomManager::kInvalidLayer;
934 UShort_t dvoluid = AliGeomManager::LayerToVolUID(layer,index); //dummy vol id
935 TString symname(Form("TOF/sm%02d",iSM));
936 AliAlignObjMatrix* o = new AliAlignObjMatrix(symname.Data(),dvoluid,gdelta,kTRUE);
937 fTOFAlignObjArray->Add(o);
940 //_____________________________________________________________________________
941 void AliTOFAlignment::AlignFromSurveyACD(Int_t iSM)
943 //From Survey data, derive the needed transformations to get the
945 //Again, highly "inspired" to Raffaele's example...
949 Double_t ngA[3], ngC[3], ngD[3];// real FM point coord., global RS
951 // Get the 'realistic' input from the Survey Matrix
952 for(Int_t coord=0;coord<3;coord++){
953 ngA[coord]= fCombFMData[iSM*4][coord*2];
954 ngC[coord]= fCombFMData[iSM*4+2][coord*2];
955 ngD[coord]= fCombFMData[iSM*4+3][coord*2];
958 printf("\n\n******Survey analysis for TOF SuperModule ************** %i \n",iSM);
960 // From the new fiducial marks coordinates derive back the
961 // new global position of the surveyed volume
962 //*** What follows is the actual survey-to-alignment procedure
964 Double_t cd[3], ad[3], n[3];
965 Double_t plane[4], s=1.;
967 // first vector on the plane of the fiducial marks
968 for(Int_t i=0;i<3;i++){
969 cd[i] = (ngC[i] - ngD[i]);
972 // second vector on the plane of the fiducial marks
973 for(Int_t i=0;i<3;i++){
974 ad[i] = (ngD[i] - ngA[i]);
977 // vector normal to the plane of the fiducial marks obtained
978 // as cross product of the two vectors on the plane d0^d1
979 n[0] = (ad[1] * cd[2] - ad[2] * cd[1]);
980 n[1] = (ad[2] * cd[0] - ad[0] * cd[2]);
981 n[2] = (ad[0] * cd[1] - ad[1] * cd[0]);
983 Double_t sizen = TMath::Sqrt( n[0]*n[0] + n[1]*n[1] + n[2]*n[2] );
985 s = Double_t(1.)/sizen ; //normalization factor
987 AliInfo("Problem in normalizing the vector");
990 // plane expressed in the hessian normal form, see:
991 // http://mathworld.wolfram.com/HessianNormalForm.html
992 // the first three are the coordinates of the orthonormal vector
993 // the fourth coordinate is equal to the distance from the origin
995 for(Int_t i=0;i<3;i++){
998 plane[3] = ( plane[0] * ngA[0] + plane[1] * ngA[1] + plane[2] * ngA[2] );
1000 // The center of the square with fiducial marks as corners
1001 // as the middle point of one diagonal - md
1002 // Used below to get the center - orig - of the surveyed box
1004 Double_t orig[3], md[3];
1005 for(Int_t i=0;i<3;i++){
1006 md[i] = (ngA[i] + ngC[i]) * 0.5;
1009 // The center of the box, gives the global translation
1010 for(Int_t i=0;i<3;i++){
1011 orig[i] = md[i] + plane[i]*fgkZFM;
1014 // get local directions needed to write the global rotation matrix
1015 // for the surveyed volume by normalising vectors ab and bc
1016 Double_t sx = TMath::Sqrt(ad[0]*ad[0] + ad[1]*ad[1] + ad[2]*ad[2]);
1018 for(Int_t i=0;i<3;i++){
1022 Double_t sy = TMath::Sqrt(cd[0]*cd[0] + cd[1]*cd[1] + cd[2]*cd[2]);
1024 for(Int_t i=0;i<3;i++){
1028 Double_t rot[9] = {cd[0],ad[0],-plane[0],cd[1],ad[1],-plane[1],cd[2],ad[2],-plane[2]};
1029 // the Aligned matrix for the current TOF SM in the Global RS, as derived from Survey:
1031 ng.SetTranslation(orig);
1032 ng.SetRotation(rot);
1033 printf("\n\n**** The Misaligned Matrix in GRS, as from Survey data ***\n");
1036 // Calculate the delta transformation wrt Ideal geometry
1037 // (Should be gdelta.rot ==I and gdelta.tr=0 if no misalignment is applied.)
1039 printf("\n\n**** The ideal matrix ***\n");
1040 fTOFMatrixId[iSM]->Print();
1042 TGeoHMatrix gdelta =fTOFMatrixId[iSM]->Inverse();
1043 printf("\n\n**** The inverse of the ideal matrix ***\n");
1046 gdelta.MultiplyLeft(&ng);
1047 printf("\n\n**** The Delta Matrix in GRS, as from Survey data ***\n");
1048 gdelta.Print(); //global delta trasformation
1050 // Now Write the Alignment Objects....
1051 Int_t index=0; //let all SM modules have index=0
1052 AliGeomManager::ELayerID layer = AliGeomManager::kInvalidLayer;
1053 UShort_t dvoluid = AliGeomManager::LayerToVolUID(layer,index); //dummy vol id
1054 TString symname(Form("TOF/sm%02d",iSM));
1055 AliAlignObjMatrix* o = new AliAlignObjMatrix(symname.Data(),dvoluid,gdelta,kTRUE);
1056 fTOFAlignObjArray->Add(o);
1059 //___________________________________________________________________________
1060 void AliTOFAlignment::AlignFromSurveyBCD(Int_t iSM)
1062 //From Survey data, derive the needed transformations to get the
1063 //Alignment Objects.
1064 //Again, highly "inspired" to Raffaele's example...
1067 Double_t ngB[3], ngC[3], ngD[3];// real FM point coord., global RS
1070 // Get the 'realistic' input from the Survey Matrix
1071 for(Int_t coord=0;coord<3;coord++){
1072 ngB[coord]= fCombFMData[iSM*4+1][coord*2];
1073 ngC[coord]= fCombFMData[iSM*4+2][coord*2];
1074 ngD[coord]= fCombFMData[iSM*4+3][coord*2];
1077 printf("\n\n******Survey analysis for TOF SuperModule ************** %i \n",iSM);
1079 // From the new fiducial marks coordinates derive back the
1080 // new global position of the surveyed volume
1081 //*** What follows is the actual survey-to-alignment procedure
1083 Double_t cd[3], bc[3], n[3];
1084 Double_t plane[4], s=1.;
1086 // first vector on the plane of the fiducial marks
1087 for(Int_t i=0;i<3;i++){
1088 cd[i] = (ngC[i] - ngD[i]);
1091 // second vector on the plane of the fiducial marks
1092 for(Int_t i=0;i<3;i++){
1093 bc[i] = (ngC[i] - ngB[i]);
1096 // vector normal to the plane of the fiducial marks obtained
1097 // as cross product of the two vectors on the plane d0^d1
1098 n[0] = (bc[1] * cd[2] - bc[2] * cd[1]);
1099 n[1] = (bc[2] * cd[0] - bc[0] * cd[2]);
1100 n[2] = (bc[0] * cd[1] - bc[1] * cd[0]);
1102 Double_t sizen = TMath::Sqrt( n[0]*n[0] + n[1]*n[1] + n[2]*n[2] );
1104 s = Double_t(1.)/sizen ; //normalization factor
1106 AliInfo("Problem in normalizing the vector");
1109 // plane expressed in the hessian normal form, see:
1110 // http://mathworld.wolfram.com/HessianNormalForm.html
1111 // the first three are the coordinates of the orthonormal vector
1112 // the fourth coordinate is equal to the distance from the origin
1114 for(Int_t i=0;i<3;i++){
1115 plane[i] = n[i] * s;
1117 plane[3] = ( plane[0] * ngB[0] + plane[1] * ngB[1] + plane[2] * ngB[2] );
1119 // The center of the square with fiducial marks as corners
1120 // as the middle point of one diagonal - md
1121 // Used below to get the center - orig - of the surveyed box
1123 Double_t orig[3], md[3];
1124 for(Int_t i=0;i<3;i++){
1125 md[i] = (ngB[i] + ngD[i]) * 0.5;
1128 // The center of the box, gives the global translation
1129 for(Int_t i=0;i<3;i++){
1130 orig[i] = md[i] + plane[i]*fgkZFM;
1133 // get local directions needed to write the global rotation matrix
1134 // for the surveyed volume by normalising vectors ab and bc
1135 Double_t sx = TMath::Sqrt(cd[0]*cd[0] + cd[1]*cd[1] + cd[2]*cd[2]);
1137 for(Int_t i=0;i<3;i++){
1141 Double_t sy = TMath::Sqrt(bc[0]*bc[0] + bc[1]*bc[1] + bc[2]*bc[2]);
1143 for(Int_t i=0;i<3;i++){
1147 Double_t rot[9] = {cd[0],bc[0],-plane[0],cd[1],bc[1],-plane[1],cd[2],bc[2],-plane[2]};
1148 // the Aligned matrix for the current TOF SM in the Global RS, as derived from Survey:
1150 ng.SetTranslation(orig);
1151 ng.SetRotation(rot);
1152 printf("\n\n**** The Misaligned Matrix in GRS, as from Survey data ***\n");
1155 // Calculate the delta transformation wrt Ideal geometry
1156 // (Should be gdelta.rot ==I and gdelta.tr=0 if no misalignment is applied.)
1158 printf("\n\n**** The ideal matrix ***\n");
1159 fTOFMatrixId[iSM]->Print();
1161 TGeoHMatrix gdelta =fTOFMatrixId[iSM]->Inverse();
1162 printf("\n\n**** The inverse of the ideal matrix ***\n");
1165 gdelta.MultiplyLeft(&ng);
1166 printf("\n\n**** The Delta Matrix in GRS, as from Survey data ***\n");
1167 gdelta.Print(); //global delta trasformation
1169 // Now Write the Alignment Objects....
1170 Int_t index=0; //let all SM modules have index=0
1171 AliGeomManager::ELayerID layer = AliGeomManager::kInvalidLayer;
1172 UShort_t dvoluid = AliGeomManager::LayerToVolUID(layer,index); //dummy vol id
1173 TString symname(Form("TOF/sm%02d",iSM));
1174 AliAlignObjMatrix* o = new AliAlignObjMatrix(symname.Data(),dvoluid,gdelta,kTRUE);
1175 fTOFAlignObjArray->Add(o);