3d4786124a1645f1ffa90ace284f4a65eb7091f4
[u/mrichter/AliRoot.git] / TRD / AliTRDalignment.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, 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 //                                                                              //
20 // An AliTRDalignment object contains the alignment data (3 shifts and 3 tilts) //
21 // for all the alignable volumes of the TRD, i.e. for 18 supermodules and 540   //
22 // chambers. The class provides simple tools for reading and writing these data //
23 // in different formats, and for generating fake data that can be used to       //
24 // simulate misalignment.                                                       //
25 // The six alignment variables have the following meaning:                      //
26 // shift in rphi                                                                //
27 // shift in z                                                                   //
28 // shift in r                                                                   //
29 // tilt around rphi                                                             //
30 // tilt around z                                                                //
31 // tilt around r                                                                //
32 // The shifts are in cm and the tilts are in degrees.                           //
33 // The currently supported formats are:                                         //
34 // - ascii                                                                      //
35 // - root file containing a TClonesArray of alignment objects                   //
36 // - offline conditions database                                                //
37 // - OCDB-like root file                                                        //
38 // - geometry file (like misaligned_geometry.root)                              //
39 //                                                                              //
40 // D.Miskowiec, November 2006                                                   //
41 //                                                                              //
42 //////////////////////////////////////////////////////////////////////////////////
43
44 #include <fstream>
45 #include <string>
46
47 #include "TMath.h"
48 #include "TFile.h"
49 #include "TGeoManager.h"
50 #include "TGeoPhysicalNode.h"
51 #include "TClonesArray.h"
52
53 #include "AliLog.h"
54 #include "AliAlignObj.h"
55 #include "AliAlignObjAngles.h"
56 #include "AliCDBManager.h"
57 #include "AliCDBStorage.h"
58 #include "AliCDBMetaData.h"
59 #include "AliCDBEntry.h"
60 #include "AliCDBId.h"
61
62 #include "AliTRDalignment.h"
63
64 ClassImp(AliTRDalignment)
65
66 //_____________________________________________________________________________
67 AliTRDalignment::AliTRDalignment() 
68   :TObject()
69   ,fRan(0)
70 {
71   //
72   // constructor
73   //
74
75   SetZero();
76
77 }
78
79 //_____________________________________________________________________________
80 AliTRDalignment::AliTRDalignment(const AliTRDalignment& source) 
81   :TObject(source)
82   ,fRan(source.fRan) 
83 {
84   //
85   // copy constructor
86   //
87
88   for (int i = 0; i <  18; i++) {
89     SetSm(i,source.fSm[i]);
90   }
91   for (int i = 0; i < 540; i++) {
92     SetCh(i,source.fCh[i]);
93   }
94
95 }
96
97 //_____________________________________________________________________________
98 AliTRDalignment& AliTRDalignment::operator=(const AliTRDalignment &source) 
99 {
100   //
101   // assignment operator
102   //
103
104   if (this != &source) {
105     for (int i = 0; i <  18; i++) SetSm(i,source.fSm[i]);
106     for (int i = 0; i < 540; i++) SetCh(i,source.fCh[i]);
107   }
108
109   return *this;
110
111 }
112
113 //_____________________________________________________________________________
114 AliTRDalignment& AliTRDalignment::operator+=(const AliTRDalignment &source) 
115 {
116   //
117   // addition operator
118   //
119
120   for (int i = 0; i <  18; i++) {
121     for (int j = 0; j < 6; j++) {
122       this->fSm[i][j] =+ source.fSm[i][j];
123     }
124   }
125   for (int i = 0; i < 540; i++) {
126     for (int j = 0; j < 6; j++) {
127       this->fCh[i][j] =+ source.fCh[i][j];
128     }
129   }
130
131   return *this;
132
133 }
134
135 //_____________________________________________________________________________
136 AliTRDalignment& AliTRDalignment::operator-=(const AliTRDalignment &source) 
137 {
138   //
139   // subtraction operator
140   //
141
142   for (int i = 0; i <  18; i++) {
143     for (int j = 0; j < 6; j++) {
144       fSm[i][j] -= source.fSm[i][j];
145     }
146   }
147   for (int i = 0; i < 540; i++) {
148     for (int j = 0; j < 6; j++) {
149       fCh[i][j] -= source.fCh[i][j];
150     }
151   }
152
153   return *this;
154
155 }
156
157 //_____________________________________________________________________________
158 Bool_t AliTRDalignment::operator==(const AliTRDalignment &source) const
159 {
160   //
161   // comparison operator
162   //
163
164   Bool_t areEqual = 1;
165
166   for (int i = 0; i <  18; i++) {
167     for (int j = 0; j < 6; j++) {
168       areEqual &= (fSm[i][j] == source.fSm[i][j]);
169     }
170   }
171   for (int i = 0; i < 540; i++) {
172     for (int j = 0; j < 6; j++) {
173       areEqual &= (fCh[i][j] == source.fCh[i][j]);
174     }
175   }
176
177   return areEqual;
178
179 }
180
181 //_____________________________________________________________________________
182 void AliTRDalignment::SetSmZero() 
183 {
184   //
185   // reset to zero supermodule data
186   //
187
188   memset(&fSm[0][0],0,sizeof(fSm));
189
190 }
191
192 //_____________________________________________________________________________
193 void AliTRDalignment::SetChZero() 
194 {
195   //
196   // reset to zero chamber data
197   //
198
199   memset(&fCh[0][0],0,sizeof(fCh));
200
201 }
202
203 //_____________________________________________________________________________
204 void AliTRDalignment::SetSmRandom(Double_t a[6]) 
205 {
206   //
207   // generate random gaussian supermodule data with sigmas a
208   //
209
210   double x[6];
211
212   for (Int_t i = 0; i < 18; i++) {
213     fRan.Rannor(x[0],x[1]);
214     fRan.Rannor(x[2],x[3]);
215     fRan.Rannor(x[4],x[5]);
216     for (Int_t j = 0; j < 6; j++) {
217       x[j] *= a[j];
218     }
219     SetSm(i,x);
220     //PrintSm(i);
221   }
222
223 }
224
225 //_____________________________________________________________________________
226 void AliTRDalignment::SetChRandom(Double_t a[6]) 
227 {
228   //
229   // generate random gaussian chamber data with sigmas a
230   //
231
232   double x[6];
233
234   for (Int_t i = 0; i < 540; i++) {
235     fRan.Rannor(x[0],x[1]);
236     fRan.Rannor(x[2],x[3]);
237     fRan.Rannor(x[4],x[5]);
238     for (Int_t j = 0; j < 6; j++) {
239       x[j] *= a[j];
240     }
241     SetCh(i,x);
242     //PrintCh(i);
243   }
244
245 }
246
247 //_____________________________________________________________________________
248 void AliTRDalignment::SetSmFull() 
249 {
250   //
251   // generate random gaussian supermodule data similar to the misalignment 
252   // expected from the mechanical precision 
253   //
254
255   Double_t a[6];
256
257   a[0] = 0.3; // phi
258   a[1] = 0.3; // z
259   a[2] = 0.3; // r
260   a[3] = 0.4/1000.0 / TMath::Pi()*180.0; // phi
261   a[4] = 2.0/1000.0 / TMath::Pi()*180.0; // z
262   a[5] = 0.4/1000.0 / TMath::Pi()*180.0; // r
263
264   SetSmRandom(a);
265
266 }
267
268 //_____________________________________________________________________________
269 void AliTRDalignment::SetChFull() 
270 {
271   //
272   // generate random gaussian chamber data similar to the misalignment 
273   // expected from the mechanical precision 
274   //
275
276   Double_t a[6];
277
278   a[0] = 0.1; // phi
279   a[1] = 0.1; // z
280   a[2] = 0.1; // r
281   a[3] = 1.0/1000.0 / TMath::Pi()*180.0; // phi
282   a[4] = 1.0/1000.0 / TMath::Pi()*180.0; // z
283   a[5] = 0.7/1000.0 / TMath::Pi()*180.0; // r
284
285   SetChRandom(a);
286
287 }
288
289 //_____________________________________________________________________________
290 void AliTRDalignment::SetSmResidual() 
291 {
292   //
293   // generate random gaussian supermodule data similar to the misalignment 
294   // remaining after full calibration
295   // I assume that it will be negligible
296   //
297
298   SetSmZero();
299
300 }
301
302 //_____________________________________________________________________________
303 void AliTRDalignment::SetChResidual() 
304 {
305   //
306   // generate random gaussian chamber data similar to the misalignment 
307   // remaining after full calibration
308   //
309
310   Double_t a[6];
311
312   a[0] = 0.002; // phi
313   a[1] = 0.003; // z
314   a[2] = 0.007; // r
315   a[3] = 0.3/1000.0 / TMath::Pi()*180.0; // phi
316   a[4] = 0.3/1000.0 / TMath::Pi()*180.0; // z
317   a[5] = 0.1/1000.0 / TMath::Pi()*180.0; // r
318
319   SetChRandom(a);
320
321 }
322
323 //_____________________________________________________________________________
324 void AliTRDalignment::PrintSm(Int_t i, FILE *fp) const 
325 {
326   //
327   // print the supermodule data
328   //
329
330   fprintf(fp,"%4d   %11.4f %11.4f  %11.4f      %11.5f  %11.5f  %11.5f   %6d  %s\n"
331          ,i,fSm[i][0],fSm[i][1],fSm[i][2],fSm[i][3],fSm[i][4],fSm[i][5]
332          ,0,GetSmName(i));
333
334 }
335
336 //_____________________________________________________________________________
337 void AliTRDalignment::PrintCh(Int_t i, FILE *fp) const 
338 {
339   //
340   // print the chamber data
341   //
342
343   fprintf(fp,"%4d   %11.4f %11.4f  %11.4f      %11.5f  %11.5f  %11.5f   %6d  %s\n"
344          ,i,fCh[i][0],fCh[i][1],fCh[i][2],fCh[i][3],fCh[i][4],fCh[i][5]
345          ,GetVoi(i),GetChName(i));
346
347 }
348
349 //_____________________________________________________________________________
350 void AliTRDalignment::ReadAscii(char *filename) 
351 {
352   //
353   // read the alignment data from ascii file
354   //
355
356   double x[6];      // alignment data
357   int volid;        // volume id
358   std::string syna; // symbolic name
359   int j;            // dummy index
360
361   fstream fi(filename,fstream::in);
362   if (!fi) {
363     AliFatal(Form("cannot open input file %s",filename));
364   }
365
366   // supermodules
367
368   for (int i = 0; i < 18; i++) {
369     fi>>j>>x[0]>>x[1]>>x[2]>>x[3]>>x[4]>>x[5]>>volid>>syna;
370     if (j != i) {
371       AliError(Form("sm %d expected, %d found",i,j));
372     }
373     if (volid != 0) {
374       AliError(Form("sm %d volume id %d expected, %d found",i,0,volid));
375     }
376     std::string symnam = GetSmName(i);
377     if (syna != symnam) {
378       AliError(Form("sm %d name %s expected, %s found",i,symnam.data(),syna.data()));
379     }
380     SetSm(i,x);
381   }
382
383   // chambers
384
385   for (int i = 0; i < 540; i++) {
386     fi>>j>>x[0]>>x[1]>>x[2]>>x[3]>>x[4]>>x[5]>>volid>>syna;
387     if (j != i) {
388       AliError(Form("ch %d expected, %d found",i,j));
389     }
390     if (volid != GetVoi(i)) {
391       AliError(Form("ch %d volume id %d expected, %d found",i,GetVoi(i),volid));
392     }
393     std::string symnam = GetChName(i);
394     if (syna != symnam) {
395       AliError(Form("ch %d name %s expected, %s found",i,symnam.data(),syna.data()));
396     }
397     SetCh(i,x);
398   }
399
400   fi.close();
401
402 }
403
404 //_____________________________________________________________________________
405 void AliTRDalignment::ReadRoot(char *filename) 
406 {
407   //
408   // read the alignment data from root file
409   // here I expect a fixed order and number of elements
410   // it would be much better to identify the alignment objects 
411   // one by one and set the parameters of the corresponding sm or ch
412   //
413
414   TFile fi(filename,"READ");
415
416   if (fi.IsOpen()) {
417     TClonesArray *ar = (TClonesArray*) fi.Get("TRDAlignObjs");
418     ArToNumbers(ar);
419     fi.Close();
420   } 
421   else {
422     AliError(Form("cannot open input file %s",filename));
423   }
424
425   return;
426
427 }
428
429 //_____________________________________________________________________________
430 void AliTRDalignment::ReadDB(char *filename) 
431 {
432   //
433   // read the alignment data from database file
434   //
435
436   TFile fi(filename,"READ");
437
438   if (fi.IsOpen()) {
439     AliCDBEntry  *e  = (AliCDBEntry *) fi.Get("AliCDBEntry");
440     e->PrintMetaData();
441     TClonesArray *ar = (TClonesArray *) e->GetObject();
442     ArToNumbers(ar);
443     fi.Close();
444   } 
445   else {
446     AliError(Form("cannot open input file %s",filename));
447   }
448
449   return;
450
451 }
452
453 //_____________________________________________________________________________
454 void AliTRDalignment::ReadDB(char *db, char *path, Int_t run
455                            , Int_t version, Int_t subversion)
456 {
457   //
458   // read the alignment data from database
459   //
460
461   AliCDBManager *cdb     = AliCDBManager::Instance();
462   AliCDBStorage *storLoc = cdb->GetStorage(db);
463   AliCDBEntry   *e       = storLoc->Get(path,run,version,subversion);
464   e->PrintMetaData();
465   TClonesArray  *ar      =  (TClonesArray *) e->GetObject();
466   ArToNumbers(ar);
467
468 }
469
470 //_____________________________________________________________________________
471 void AliTRDalignment::ReadGeo(char *misaligned) 
472 {
473   //
474   // determine misalignment by comparing original and misaligned matrix 
475   // of the last node on the misaligned_geometry file 
476   // an alternative longer way is in attic.C
477   //
478
479   TGeoHMatrix *ideSm[18];  // ideal
480   TGeoHMatrix *ideCh[540];
481   TGeoHMatrix *misSm[18];  // misaligned
482   TGeoHMatrix *misCh[540];
483
484   // read misaligned and original matrices
485
486   TGeoManager::Import(misaligned);
487   for (int i = 0; i < 18; i++) {
488     TGeoPNEntry      *pne  = gGeoManager->GetAlignableEntry(GetSmName(i));
489     if (!pne) {
490       AliError(Form("no such physical node entry: %s",GetSmName(i))); 
491       return;
492     }
493     TGeoPhysicalNode *node = pne->GetPhysicalNode();
494     if (!node) {
495       AliError(Form("physical node entry %s has no physical node",GetSmName(i))); 
496       return;
497     }
498     misSm[i] = new TGeoHMatrix(*node->GetNode(node->GetLevel())->GetMatrix());
499     ideSm[i] = new TGeoHMatrix(*node->GetOriginalMatrix());
500   }
501   for (int i = 0; i < 540; i++) {
502     TGeoPNEntry      *pne  = gGeoManager->GetAlignableEntry(GetChName(i));
503     if (!pne) {
504       AliError(Form("no such physical node entry: %s",GetChName(i))); 
505       return;
506     }
507     TGeoPhysicalNode *node = pne->GetPhysicalNode();
508     if (!node) {
509       AliError(Form("physical node entry %s has no physical node",GetChName(i))); 
510       return;
511     }
512     misCh[i] = new TGeoHMatrix(*node->GetNode(node->GetLevel())->GetMatrix());
513     ideCh[i] = new TGeoHMatrix(*node->GetOriginalMatrix());
514   }
515
516   // calculate the local misalignment matrices as inverse misaligned times ideal
517
518   for (int i = 0; i < 18; i++) {
519     TGeoHMatrix mat(ideSm[i]->Inverse()); 
520     mat.Multiply(misSm[i]);
521     double *tra = mat.GetTranslation();
522     double *rot = mat.GetRotationMatrix();
523     double pars[6];
524     pars[0] = tra[0];
525     pars[1] = tra[1];
526     pars[2] = tra[2];
527     if (TMath::Abs(rot[0])<1e-7 || TMath::Abs(rot[8])<1e-7) {
528       AliError("Failed to extract roll-pitch-yall angles!");
529       return;
530     }
531     double raddeg = TMath::RadToDeg();
532     pars[3] = raddeg * TMath::ATan2(-rot[5],rot[8]);
533     pars[4] = raddeg * TMath::ASin(rot[2]);
534     pars[5] = raddeg * TMath::ATan2(-rot[1],rot[0]);
535     SetSm(i,pars);
536   }
537
538   for (int i = 0; i < 540; i++) {
539     TGeoHMatrix mat(ideCh[i]->Inverse()); 
540     mat.Multiply(misCh[i]);
541     double *tra = mat.GetTranslation();
542     double *rot = mat.GetRotationMatrix();
543     double pars[6];
544     pars[0] = tra[0];
545     pars[1] = tra[1];
546     pars[2] = tra[2];
547     if(TMath::Abs(rot[0])<1e-7 || TMath::Abs(rot[8])<1e-7) {
548       AliError("Failed to extract roll-pitch-yall angles!");
549       return;
550     }
551     double raddeg = TMath::RadToDeg();
552     pars[3] = raddeg * TMath::ATan2(-rot[5],rot[8]);
553     pars[4] = raddeg * TMath::ASin(rot[2]);
554     pars[5] = raddeg * TMath::ATan2(-rot[1],rot[0]);
555     SetCh(i,pars);
556   }
557
558   // cleanup
559   for (int i = 0; i <  18; i++) delete ideSm[i];
560   for (int i = 0; i <  18; i++) delete misSm[i];
561   for (int i = 0; i < 540; i++) delete ideCh[i];
562   for (int i = 0; i < 540; i++) delete misCh[i];
563
564   return;
565
566 }
567
568 //_____________________________________________________________________________
569 void AliTRDalignment::ReadSurveyReport(char *filename) 
570 {
571   // read survey report and set the supermodule parameters correspondingly
572
573   fstream fi(filename,fstream::in);
574   if (!fi) {
575     AliFatal(Form("cannot open input file %s",filename));
576   }
577
578   // to be continued...
579
580 }
581
582 //_____________________________________________________________________________
583 void AliTRDalignment::ReadAny(char *filename) 
584 {
585   //
586   // read the alignment data from any kind of file
587   //
588
589   TString fist(filename);
590   if (fist.EndsWith(".txt")) {
591     ReadAscii(filename);
592   }
593   if (fist.EndsWith(".dat")) {
594     ReadAscii(filename);
595   }
596   if (fist.EndsWith(".root")) {
597     if (fist.Contains("Run")) {
598       ReadDB(filename);
599     }
600     else {
601       ReadRoot(filename);
602     }
603   }
604
605 }
606
607 //_____________________________________________________________________________
608 void AliTRDalignment::WriteAscii(char *filename) const
609 {
610   //
611   // store the alignment data on ascii file
612   //
613
614   FILE *fp = fopen(filename, "w");
615   if (!fp) {
616     AliError(Form("cannot open output file %s",filename));
617     return;
618   }
619
620   PrintSm(fp);
621   PrintCh(fp);
622   
623   fclose(fp);
624
625 }
626
627 //_____________________________________________________________________________
628 void AliTRDalignment::WriteRoot(char *filename) 
629 {
630   //
631   // store the alignment data on root file
632   //
633
634   TClonesArray *ar = new TClonesArray("AliAlignObjAngles",10000);
635   NumbersToAr(ar);
636   TFile fo(filename,"RECREATE");
637   if (fo.IsOpen()) {
638     fo.cd();
639     fo.WriteObject(ar,"TRDAlignObjs","kSingleKey");
640     fo.Close();
641   } 
642   else {
643     AliError(Form("cannot open output file %s",filename));
644   }
645
646   delete ar;
647
648 }
649
650 //_____________________________________________________________________________
651 void AliTRDalignment::WriteDB(char *filename, char *comment, Int_t run0, Int_t run1) 
652 {
653   //
654   // dumping on a DB-like file
655   //
656
657   TClonesArray   *ar = new TClonesArray("AliAlignObjAngles",10000);
658   NumbersToAr(ar);
659   char *path = "di1/di2/di3";
660   AliCDBId id(path,run0,run1);
661   AliCDBMetaData *md = new AliCDBMetaData();
662   md->SetResponsible("Dariusz Miskowiec");
663   md->SetComment(comment);
664   AliCDBEntry    *e  = new AliCDBEntry(ar, id, md);
665   TFile fi(filename,"RECREATE");
666   if (fi.IsOpen()) {
667     e->Write();
668     fi.Close();
669   } 
670   else {
671     AliError(Form("cannot open input file %s",filename));
672   }
673
674   delete e;
675   delete md;
676   delete ar;
677
678   return;
679
680 }
681
682 //_____________________________________________________________________________
683 void AliTRDalignment::WriteDB(char *db, char *path, char *comment, Int_t run0, Int_t run1) 
684 {
685   //
686   // store the alignment data in database
687   //
688
689   TClonesArray   *ar      = new TClonesArray("AliAlignObjAngles",10000);
690   NumbersToAr(ar);
691   AliCDBManager  *cdb     = AliCDBManager::Instance();
692   AliCDBStorage  *storLoc = cdb->GetStorage(db);
693   AliCDBMetaData *md      = new AliCDBMetaData();
694   md->SetResponsible("Dariusz Miskowiec");
695   md->SetComment(comment);
696   AliCDBId id(path,run0,run1);
697   storLoc->Put(ar,id,md);
698   md->Delete();
699   delete ar;
700
701 }
702
703 //_____________________________________________________________________________
704 void AliTRDalignment::WriteGeo(char *filename) 
705 {
706   //
707   // apply misalignment to (currently loaded ideal) geometry and store the 
708   // resulting geometry on a root file
709   //
710
711   TClonesArray *ar = new TClonesArray("AliAlignObjAngles",10000);
712   NumbersToAr(ar);
713   for (int i = 0; i < ar->GetEntriesFast(); i++) {
714     AliAlignObj *alobj = (AliAlignObj *) ar->UncheckedAt(i);
715     alobj->ApplyToGeometry();
716   }
717   delete ar;
718   gGeoManager->Export(filename);
719
720 }
721
722 //_____________________________________________________________________________
723 Double_t AliTRDalignment::GetSmRMS(Int_t xyz) const 
724 {
725   //
726   // rms fSm[][xyz]
727   //
728
729   Double_t s1 = 0.0;
730   Double_t s2 = 0.0;
731   for (int i = 0; i < 18; i++) {
732     s1 += fSm[i][xyz];
733     s2 += fSm[i][xyz]*fSm[i][xyz];
734   }
735   Double_t rms2 = s2/18.0 - s1*s1/18.0/18.0;
736
737   return rms2>0 ? sqrt(rms2) : 0.0;
738
739 }
740
741 //_____________________________________________________________________________
742 Double_t AliTRDalignment::GetChRMS(Int_t xyz) const
743 {
744   //
745   // rms fCh[][xyz]
746   //
747
748   Double_t s1 =0.0;
749   Double_t s2 =0.0;
750   for (int i = 0; i < 540; i++) {
751     s1 += fCh[i][xyz];
752     s2 += fCh[i][xyz]*fCh[i][xyz];
753   }
754   Double_t rms2 = s2/540.0 - s1*s1/540.0/540.0;
755
756   return rms2>0 ? sqrt(rms2) : 0.0;
757
758 }
759
760 //_____________________________________________________________________________
761 void AliTRDalignment::PrintSmRMS() const
762 {
763   //
764   // dump rms of fSm
765   //
766
767   printf("       %11.4f %11.4f  %11.4f      %11.5f  %11.5f  %11.5f  supermodule rms\n"
768         ,GetSmRMS(0),GetSmRMS(1),GetSmRMS(2),GetSmRMS(3),GetSmRMS(4),GetSmRMS(5));
769
770 }
771
772 //_____________________________________________________________________________
773 void AliTRDalignment::PrintChRMS() const
774 {
775   //
776   // dump rms of fCh
777   //
778
779   printf("       %11.4f %11.4f  %11.4f      %11.5f  %11.5f  %11.5f  chamber rms\n"
780         ,GetChRMS(0),GetChRMS(1),GetChRMS(2),GetChRMS(3),GetChRMS(4),GetChRMS(5));
781
782 }
783
784 //_____________________________________________________________________________
785 void AliTRDalignment::ArToNumbers(TClonesArray *ar) 
786 {
787   //
788   // read numbers from the array of AliAlignObj objects and fill fSm and fCh
789   //
790
791   LoadIdealGeometry();
792   SetZero();
793   double pa[6];
794   for (int i = 0; i <  18; i++) {
795     AliAlignObj *aao = (AliAlignObj *) ar->At(i);
796     aao->GetLocalPars(pa,pa+3);
797     SetSm(i,pa);
798   }
799   for (int i = 0; i < 540; i++) {
800     AliAlignObj *aao = (AliAlignObj *) ar->At(18+i);
801     aao->GetLocalPars(pa,pa+3);
802     SetCh(i,pa);
803   }
804
805 }
806
807 //_____________________________________________________________________________
808 void AliTRDalignment::NumbersToAr(TClonesArray *ar) 
809 {
810   //
811   // build array of AliAlignObj objects based on fSm and fCh data
812   //
813
814   LoadIdealGeometry();
815   TClonesArray &alobj = *ar;
816   int nobj = 0;
817   for (int i = 0; i <  18; i++) {      
818       new(alobj[nobj]) AliAlignObjAngles(GetSmName(i)
819                                         ,0 
820                                         ,fSm[i][0],fSm[i][1],fSm[i][2]
821                                         ,fSm[i][3],fSm[i][4],fSm[i][5]
822                                         ,0);
823     nobj++;
824   }
825
826   for (int i = 0; i < 540; i++) {
827     new(alobj[nobj]) AliAlignObjAngles(GetChName(i)
828                                       ,GetVoi(i)
829                                       ,fCh[i][0],fCh[i][1],fCh[i][2]
830                                       ,fCh[i][3],fCh[i][4],fCh[i][5]
831                                       ,0);
832     nobj++;
833   }
834
835 }
836
837 //_____________________________________________________________________________
838 void AliTRDalignment::LoadIdealGeometry(char *filename) 
839 {
840   //
841   // load ideal geometry from filename
842   // it is needed for operations on AliAlignObj objects
843   // this needs to be straightened out
844   // particularly, sequences LoadIdealGeometry("file1"); LoadIdealGeometry("file2"); 
845   // do not work as one would naturally expect
846   //
847
848   static int attempt = 0; // which reload attempt is it? just to avoid endless loops
849
850   if (!gGeoManager) {
851     TGeoManager::Import(filename);
852   }
853   if (!gGeoManager) {
854     AliFatal(Form("cannot open geometry file %s",filename));
855   }
856   if (gGeoManager->GetListOfPhysicalNodes()->GetEntries()) {
857     if (attempt) {
858       AliFatal(Form("geometry on file %s is not ideal",filename));
859     }
860     AliWarning("current geometry is not ideal - it contains physical nodes");
861     AliWarning(Form("reloading geometry from %s - attempt nr %d",filename,attempt));
862     gGeoManager = 0;
863     attempt++;
864     LoadIdealGeometry(filename);
865   }
866
867   attempt = 0;
868
869 }