MUON/AliMUONSurveyUtil.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 //-----------------------------------------------------------------------------
  17 /// \class AliMUONSurveyUtil
  18 /// Utility class for the survey processing of the ALICE DiMuon spectrometer
  19 ///
  20 /// This class contains various functions to calculate misalignement parameters
  21 /// from survey data and designed positions of survey targets.
  22 /// Macro also includes a method to get the new AliMUONGeometryTranformer.
  23 ///
  24 /// \author Javier Castillo
  25 //-----------------------------------------------------------------------------
  26
  27 #include <TClonesArray.h>
  28 #include <TMath.h>
  29 #include <TMatrixDSym.h>
  30 #include <TString.h>
  31
  32 #include "AliAlignObjMatrix.h"
  33
  34 #include "AliMUONSurveyUtil.h"
  35 #include "AliMUONGeometryTransformer.h"
  36 #include "AliMUONGeometryModuleTransformer.h"
  37 #include "AliMUONGeometryDetElement.h"
  38 #include "AliMUONGeometryBuilder.h"
  39 #include "AliMpExMap.h"
  40 #include "AliMpExMapIterator.h"
  41
  42 /// \cond CLASSIMP
  43 ClassImp(AliMUONSurveyUtil)
  44 /// \endcond
  45
  46 int AliMUONSurveyUtil::fgNDetElemCh[10] = {4,4,4,4,18,18,26,26,26,26};
  47 AliMUONSurveyUtil* AliMUONSurveyUtil::fgInstance(0x0);
  48
  49 AliMUONSurveyUtil::~AliMUONSurveyUtil(){
  50   printf("WHAT AM I DOING HERE????????????????\n");
  51   fgInstance = 0x0;
  52 }
  53
  54 AliMUONSurveyUtil* AliMUONSurveyUtil::Instance() {
  55   if (!fgInstance)
  56     fgInstance = new AliMUONSurveyUtil();
  57
  58   return fgInstance;
  59 }
  60
  61 Bool_t AliMUONSurveyUtil::MatrixToAngles(const Double_t *rot, Double_t *angles)
  62 {
  63   /// Calculates the Euler angles in "x y z" notation
  64   /// using the rotation matrix
  65   /// Returns false in case the rotation angles can not be
  66
  67   // extracted from the matrix
  68   //
  69   if(TMath::Abs(rot[0])<1e-7 || TMath::Abs(rot[8])<1e-7) {
  70     printf("Failed to extract roll-pitch-yall angles!");
  71     return kFALSE;
  72   }
  73   //   Double_t raddeg = TMath::RadToDeg();
  74   angles[0]=TMath::ATan2(-rot[5],rot[8]);
  75   angles[1]=TMath::ASin(rot[2]);
  76   angles[2]=TMath::ATan2(-rot[1],rot[0]);
  77   return kTRUE;
  78 }
  79
  80 void AliMUONSurveyUtil::AnglesToMatrix(const Double_t *angles, Double_t *rot)
  81 {
  82   // Calculates the rotation matrix using the
  83   // Euler angles in "x y z" notation
  84   //
  85   //  Double_t degrad = TMath::DegToRad();
  86   Double_t degrad = 1.;
  87   Double_t sinpsi = TMath::Sin(degrad*angles[0]);
  88   Double_t cospsi = TMath::Cos(degrad*angles[0]);
  89   Double_t sinthe = TMath::Sin(degrad*angles[1]);
  90   Double_t costhe = TMath::Cos(degrad*angles[1]);
  91   Double_t sinphi = TMath::Sin(degrad*angles[2]);
  92   Double_t cosphi = TMath::Cos(degrad*angles[2]);
  93
  94   rot[0] =  costhe*cosphi;
  95   rot[1] = -costhe*sinphi;
  96   rot[2] =  sinthe;
  97   rot[3] =  sinpsi*sinthe*cosphi + cospsi*sinphi;
  98   rot[4] = -sinpsi*sinthe*sinphi + cospsi*cosphi;
  99   rot[5] = -costhe*sinpsi;
 100   rot[6] = -cospsi*sinthe*cosphi + sinpsi*sinphi;
 101   rot[7] =  cospsi*sinthe*sinphi + sinpsi*cosphi;
 102   rot[8] =  costhe*cospsi;
 103 }
 104
 105 Double_t AliMUONSurveyUtil::XpCenter(const Double_t *x, const Double_t *par) const{
 106   /// Returns center x position using x coord. of 2 button targets. + solution.
 107   Double_t lCos2Tht = TMath::Cos(2*par[6]);
 108   Double_t lSinTht = TMath::Sin(par[6]);
 109
 110   Double_t inSqrt = TMath::Abs((par[0] - par[3])*(par[0] - par[3])
 111                                -2*(x[0] -x[1])*(x[0] -x[1])
 112                                +(par[1] - par[4] + par[2] - par[5])*(par[1] - par[4] - par[2] + par[5])
 113                                +((par[0] - par[3])*(par[0] - par[3])
 114                                  +(par[1] - par[4])*(par[1] - par[4])
 115                                  +(par[2] - par[5])*(par[2] - par[5]))*lCos2Tht
 116                                +4*(x[0] - x[1])*(par[2] - par[5])*lSinTht);
 117
 118   if (inSqrt<0) return inSqrt*1e10;
 119
 120   Double_t xD = ((2*(par[0]*par[0]*x[1]
 121                      -par[0]*par[3]*(x[0] + x[1])
 122                      +x[1]*par[1]*(par[1] - par[4])
 123                      +x[0]*(par[3]*par[3] - par[1]*par[4] + par[4]*par[4]))
 124                   -2*(par[3]*par[3]*par[2]
 125                       +par[0]*par[0]*par[5]
 126                       -par[0]*par[3]*(par[2] + par[5])
 127                       +(par[1] - par[4])*(-par[4]*par[2] +par[1]*par[5]))*lSinTht
 128                   +TMath::Sqrt(2)*(-par[3]*par[1] + par[0]*par[4])
 129                   *TMath::Sqrt(inSqrt))
 130                  /(2*((par[0] - par[3])*(par[0] - par[3]) + (par[1] - par[4])*(par[1] - par[4]))));
 131
 132   return xD;
 133 }
 134
 135 Double_t AliMUONSurveyUtil::XnCenter(const Double_t *x, const Double_t *par) const{
 136   /// Returns center x position using x coord. of 2 button targets. - solution.
 137   Double_t lCos2Tht = TMath::Cos(2*par[6]);
 138   Double_t lSinTht = TMath::Sin(par[6]);
 139
 140   Double_t inSqrt = TMath::Abs((par[0] - par[3])*(par[0] - par[3])
 141                                -2*(x[0] - x[1])*(x[0] - x[1])
 142                                +(par[1] - par[4] + par[2] - par[5])*(par[1] - par[4] - par[2] + par[5])
 143                                +((par[0] - par[3])*(par[0] - par[3])
 144                                  +(par[1] - par[4])*(par[1] - par[4])
 145                                  +(par[2] - par[5])*(par[2] - par[5]))*lCos2Tht
 146                                +4*(x[0] - x[1])*(par[2] - par[5])*lSinTht);
 147
 148   if (inSqrt<0) return inSqrt*1e10;
 149
 150   Double_t xD = ((2*(par[0]*par[0]*x[1]
 151                      -par[0]*par[3]*(x[0] + x[1])
 152                      +x[1]*par[1]*(par[1] - par[4])
 153                      +x[0]*(par[3]*par[3] - par[1]*par[4] + par[4]*par[4]))
 154                   -2*(par[3]*par[3]*par[2] + par[0]*par[0]*par[5]
 155                       -par[0]*par[3]*(par[2] + par[5])
 156                       +(par[1] - par[4])*(-par[4]*par[2] + par[1]*par[5]))*lSinTht
 157                   +TMath::Sqrt(2)*(par[3]*par[1] - par[0]*par[4])
 158                   *TMath::Sqrt(inSqrt))
 159                  /(2*((par[0] - par[3])*(par[0] - par[3]) + (par[1] - par[4])*(par[1] - par[4]))));
 160
 161   return xD;
 162 }
 163
 164 Double_t AliMUONSurveyUtil::PhiXpn(const Double_t *x, const Double_t *par) const{
 165   /// Returns phi rot. using x coord. of 2 button targets. +- solution.
 166   Double_t inSqrt = TMath::Abs(((par[0] - par[3])*(par[0] - par[3])
 167                                 -2*(x[0] - x[1])*(x[0] - x[1])
 168                                 +(par[1] - par[4] + par[2] - par[5])*(par[1] - par[4] - par[2] + par[5])
 169                                 +(+(par[0] - par[3])*(par[0] - par[3])
 170                                   +(par[1] - par[4])*(par[1] - par[4])
 171                                   +(par[2] - par[5])*(par[2] - par[5]))*TMath::Cos(2*par[6])
 172                                 +4*(x[0] - x[1])*(par[2] - par[5])*TMath::Sin(par[6])));
 173
 174   if (inSqrt<0) return inSqrt*1e10;
 175
 176   Double_t phix = ((+2*(par[0] - par[3])*(x[0] - x[1])
 177                     -2*(par[0] - par[3])*(par[2] - par[5])*TMath::Sin(par[6])
 178                     +TMath::Sqrt(2)*(par[1] - par[4])
 179                     *TMath::Sqrt(inSqrt))
 180                    /(2*(+(par[0] - par[3])*(par[0] - par[3])
 181                         +(par[1] - par[4])*(par[1] - par[4]))*TMath::Cos(par[6])));
 182
 183   phix = -TMath::ACos(phix);
 184
 185   return phix;
 186 }
 187
 188 Double_t AliMUONSurveyUtil::PhiXpp(const Double_t *x, const Double_t *par) const{
 189   /// Returns phi rot. using x coord. of 2 button targets. ++ solution.
 190   Double_t inSqrt = TMath::Abs(+(par[0] - par[3])*(par[0] - par[3])
 191                                -2*(x[0] - x[1])*(x[0] - x[1])
 192                                +(par[1] - par[4] + par[2] - par[5])*(par[1] - par[4] - par[2] + par[5])
 193                                +(+(par[0] - par[3])*(par[0] - par[3])
 194                                  +(par[1] - par[4])*(par[1] - par[4])
 195                                  +(par[2] - par[5])*(par[2] - par[5]))*TMath::Cos(2*par[6])
 196                                +4*(x[0] - x[1])*(par[2] - par[5])*TMath::Sin(par[6]));
 197
 198   if (inSqrt<0) return inSqrt*1e10;
 199
 200   Double_t phix = ((+2*(par[0] - par[3])*(x[0] - x[1])
 201                     -2*(par[0] - par[3])*(par[2] - par[5])*TMath::Sin(par[6])
 202                     +TMath::Sqrt(2)*(par[1] - par[4])
 203                     *TMath::Sqrt(inSqrt))
 204                    /(2*(+(par[0] - par[3])*(par[0] - par[3])
 205                         +(par[1] - par[4])*(par[1] - par[4]))*TMath::Cos(par[6])));
 206
 207   phix = TMath::ACos(phix);
 208
 209   return phix;
 210 }
 211
 212 Double_t AliMUONSurveyUtil::PhiXnn(const Double_t *x, const Double_t *par) const{
 213   /// Returns phi rot. using x coord. of 2 button targets. -- solution.
 214   Double_t inSqrt = TMath::Abs(+(par[0] - par[3])*(par[0] - par[3])
 215                                -2*(x[0] - x[1])*(x[0] - x[1])
 216                                +(par[1] - par[4] + par[2] - par[5])*(par[1] - par[4] - par[2] + par[5])
 217                                +(+(par[0] - par[3])*(par[0] - par[3])
 218                                  +(par[1] - par[4])*(par[1] - par[4])
 219                                  +(par[2] - par[5])*(par[2] - par[5]))*TMath::Cos(2*par[6])
 220                                + 4*(x[0] - x[1])*(par[2] - par[5])*TMath::Sin(par[6]));
 221
 222   if (inSqrt<0) return inSqrt*1e10;
 223
 224   Double_t phix = (+(+2*(par[0] - par[3])*(x[0] - x[1])
 225                      -2*(par[0] - par[3])*(par[2] - par[5])*TMath::Sin(par[6])
 226                      +TMath::Sqrt(2)*(-par[1] + par[4])
 227                      *TMath::Sqrt(inSqrt))
 228                    /(2*(+(par[0] - par[3])*(par[0] - par[3])
 229                         +(par[1] - par[4])*(par[1] - par[4]))*TMath::Cos(par[6])));
 230
 231   phix = -TMath::ACos(phix);
 232
 233   return phix;
 234 }
 235
 236 Double_t AliMUONSurveyUtil::PhiXnp(const Double_t *x, const Double_t *par) const{
 237   /// Returns phi rot. using x coord. of 2 button targets. +- solution.
 238   Double_t inSqrt = TMath::Abs(+(par[0] - par[3])*(par[0] - par[3])
 239                                -2*(x[0] - x[1])*(x[0] - x[1])
 240                                +(par[1] - par[4] + par[2] - par[5])*(par[1] - par[4] - par[2] + par[5])
 241                                +(+(par[0] - par[3])*(par[0] - par[3])
 242                                  +(par[1] - par[4])*(par[1] - par[4])
 243                                  +(par[2] - par[5])*(par[2] - par[5]))*TMath::Cos(2*par[6])
 244                                +4*(x[0] - x[1])*(par[2] - par[5])*TMath::Sin(par[6]));
 245
 246   if (inSqrt<0) return inSqrt*1e10;
 247
 248   Double_t phix = (+(+2*(par[0] - par[3])*(x[0] - x[1])
 249                      -2*(par[0] - par[3])*(par[2] - par[5])*TMath::Sin(par[6])
 250                      +TMath::Sqrt(2)*(-par[1] + par[4])
 251                      *TMath::Sqrt(inSqrt))
 252                    /(2*(+(par[0] - par[3])*(par[0] - par[3])
 253                         +(par[1] - par[4])*(par[1] - par[4]))*TMath::Cos(par[6])));
 254
 255   phix = TMath::ACos(phix);
 256
 257   return phix;
 258 }
 259
 260 Double_t AliMUONSurveyUtil::YpCenter(const Double_t *x, const Double_t *par) const{
 261   /// Returns center y position using y coord. of 2 button targets. + solution.
 262
 263   // par : x1l, y1l, z1l, x2l, y2l, z2, lpsi, tht,
 264   Double_t lCosPsi = TMath::Cos(par[6]);
 265   Double_t lSinPsi = TMath::Sin(par[6]);
 266   Double_t lCosTht = TMath::Cos(par[7]);
 267   Double_t lSinTht = TMath::Sin(par[7]);
 268
 269   Double_t yD = ((1./((par[0] - par[3])*(par[0] - par[3]) + (par[1] - par[4])*(par[1] - par[4])))
 270                  *(+par[3]*par[3]*x[0]
 271                    +par[0]*par[0]*x[1]
 272                    -par[0]*par[3]*(x[0] + x[1])
 273                    +(par[1] - par[4])*(-x[0]*par[4] + par[1]*x[1])
 274                    +(par[3]*par[3]*par[2]
 275                      +par[0]*par[0]*par[5]
 276                      -par[0]*par[3]*(par[2] + par[5])
 277                      +(par[1] - par[4])*(-par[4]*par[2] + par[1]*par[5]))*lCosTht*lSinPsi
 278                    +(-par[3]*par[1] + par[0]*par[4])
 279                    *TMath::Sqrt(-(x[0] - x[1]
 280                                   +(par[2] - par[5])*lCosTht*lSinPsi)
 281                                 *(x[0] - x[1]
 282                                   +(par[2] - par[5])*lCosTht*lSinPsi)
 283                                 + ((par[0] - par[3])*(par[0] - par[3])
 284                                    +(par[1] - par[4])*(par[1] - par[4]))*(lCosPsi*lCosPsi
 285                                                                           +lSinPsi*lSinPsi*lSinTht*lSinTht))));
 286
 287   return yD;
 288 }
 289
 290 Double_t AliMUONSurveyUtil::PhiYpn(const Double_t *x, const Double_t *par) const{
 291   /// Returns phi rot. using y coord. of 2 button targets. +- solution.
 292
 293   Double_t lCosPsi = TMath::Cos(par[6]);
 294   Double_t lSinPsi = TMath::Sin(par[6]);
 295   Double_t lCosTht = TMath::Cos(par[7]);
 296   Double_t lSinTht = TMath::Sin(par[7]);
 297
 298   Double_t phiy = ((lCosPsi*((par[1] - par[4])*(x[0] - x[1])
 299                              +(par[1] - par[4])*(par[2] - par[5])*lCosTht*lSinPsi
 300                              +(-par[0] + par[3])
 301                              *TMath::Sqrt(-(x[0] - x[1]
 302                                             +(par[2] - par[5])*lCosTht*lSinPsi)
 303                                           *(x[0] - x[1]
 304                                             +(par[2] - par[5])*lCosTht*lSinPsi)
 305                                           +(+(par[0] - par[3])*(par[0] - par[3])
 306                                             +(par[1] - par[4])*(par[1] - par[4]))*(lCosPsi*lCosPsi
 307                                                                                    +lSinPsi*lSinPsi*lSinTht*lSinTht)))
 308                     +lSinPsi*lSinTht*((par[0] - par[3])*(x[0] - x[1])
 309                                       +(par[0] - par[3])*(par[2] - par[5])*lCosTht*lSinPsi
 310                                       +(par[1] - par[4])
 311                                       *TMath::Sqrt(-(x[0] - x[1]
 312                                                      +(par[2] - par[5])*lCosTht*lSinPsi)
 313                                                    *(x[0] - x[1]
 314                                                      +(par[2] - par[5])*lCosTht*lSinPsi)
 315                                                    + ((par[0] - par[3])*(par[0] - par[3])
 316                                                       +(par[1] - par[4])*(par[1] - par[4]))*(lCosPsi*lCosPsi
 317                                                                                              +lSinPsi*lSinPsi*lSinTht*lSinTht))))
 318                    /((+(par[0] - par[3])*(par[0] - par[3])
 319                       +(par[1] - par[4])*(par[1] - par[4]))*(lCosPsi*lCosPsi
 320                                                              +lSinPsi*lSinPsi*lSinTht*lSinTht)));
 321
 322   phiy = -TMath::ACos(phiy);
 323
 324
 325   return phiy;
 326 }
 327
 328 Double_t AliMUONSurveyUtil::PhiYpp(const Double_t *x, const Double_t *par) const{
 329   /// Returns phi rot. using y coord. of 2 button targets. ++ solution.
 330
 331   Double_t lCosPsi = TMath::Cos(par[6]);
 332   Double_t lSinPsi = TMath::Sin(par[6]);
 333   Double_t lCosTht = TMath::Cos(par[7]);
 334   Double_t lSinTht = TMath::Sin(par[7]);
 335
 336   Double_t phiy = ((lCosPsi*((par[1] - par[4])*(x[0] - x[1])
 337                              +(par[1] - par[4])*(par[2] - par[5])*lCosTht*lSinPsi
 338                              +(-par[0] + par[3])
 339                              *TMath::Sqrt(-(x[0] - x[1]
 340                                             +(par[2] - par[5])*lCosTht*lSinPsi)
 341                                           *(x[0] - x[1]
 342                                             +(par[2] - par[5])*lCosTht*lSinPsi)
 343                                           +((par[0] - par[3])*(par[0] - par[3])
 344                                             +(par[1] - par[4])*(par[1] - par[4]))*(lCosPsi*lCosPsi
 345                                                                                    +lSinPsi*lSinPsi*lSinTht*lSinTht)))
 346                     +lSinPsi*lSinTht*((par[0] - par[3])*(x[0] - x[1])
 347                                       +(par[0] - par[3])*(par[2] - par[5])*lCosTht*lSinPsi
 348                                       +(par[1] - par[4])*TMath::Sqrt(-(x[0] - x[1]
 349                                                                        +(par[2] - par[5])*lCosTht*lSinPsi)
 350                                                                      *(x[0] - x[1]
 351                                                                        +(par[2] - par[5])*lCosTht*lSinPsi)
 352                                                                      +((par[0] - par[3])*(par[0] - par[3])
 353                                                                        +(par[1] - par[4])*(par[1] - par[4]))*(lCosPsi*lCosPsi
 354                                                                                                               +lSinPsi*lSinPsi*lSinTht*lSinTht))))
 355                    /(((par[0] - par[3])*(par[0] - par[3])
 356                       +(par[1] - par[4])*(par[1] - par[4]))*(lCosPsi*lCosPsi
 357                                                              +lSinPsi*lSinPsi*lSinTht*lSinTht)));
 358
 359   phiy = TMath::ACos(phiy);
 360
 361   return phiy;
 362 }
 363
 364 Double_t AliMUONSurveyUtil::YnCenter(const Double_t *x, const Double_t *par) const{
 365   /// Returns center y position using y coord. of 2 button targets. - solution.
 366   Double_t lCosPsi = TMath::Cos(par[6]);
 367   Double_t lSinPsi = TMath::Sin(par[6]);
 368   Double_t lCosTht = TMath::Cos(par[7]);
 369   Double_t lSinTht = TMath::Sin(par[7]);
 370
 371   Double_t yD = ((1./(+(par[0] - par[3])*(par[0] - par[3])
 372                       +(par[1] - par[4])*(par[1] - par[4])))
 373                  *(+par[3]*par[3]*x[0]
 374                    +par[0]*par[0]*x[1]
 375                    -par[0]*par[3]*(x[0] + x[1])
 376                    +(par[1] - par[4])*(-x[0]*par[4] + par[1]*x[1])
 377                    +(+par[3]*par[3]*par[2]
 378                      +par[0]*par[0]*par[5]
 379                      -par[0]*par[3]*(par[2] + par[5])
 380                      +(par[1] - par[4])*(-par[4]*par[2] + par[1]*par[5]))*lCosTht*lSinPsi
 381                    +(par[3]*par[1] - par[0]*par[4])
 382                    *TMath::Sqrt(-(+x[0] - x[1]
 383                                   +(par[2] - par[5])*lCosTht*lSinPsi)
 384                                 *(x[0] - x[1]
 385                                   +(par[2] - par[5])*lCosTht*lSinPsi)
 386                                 +((par[0] - par[3])*(par[0] - par[3])
 387                                   +(par[1] - par[4])*(par[1] - par[4]))*(+lCosPsi*lCosPsi
 388                                                                          +lSinPsi*lSinPsi*lSinTht*lSinTht))));
 389
 390   return yD;
 391 }
 392
 393
 394 Double_t AliMUONSurveyUtil::PhiYnn(const Double_t *x, const Double_t *par) const{
 395   /// Returns phi rot. using y coord. of 2 button targets. -- solution.
 396
 397   Double_t lCosPsi = TMath::Cos(par[6]);
 398   Double_t lSinPsi = TMath::Sin(par[6]);
 399   Double_t lCosTht = TMath::Cos(par[7]);
 400   Double_t lSinTht = TMath::Sin(par[7]);
 401
 402   Double_t phiy = ((lCosPsi*(+(par[1] - par[4])*(x[0] - x[1])
 403                              +(par[1] - par[4])*(par[2] - par[5])*lCosTht*lSinPsi
 404                              +(par[0] - par[3])
 405                              *TMath::Sqrt(-(x[0] - x[1]
 406                                             +(par[2] - par[5])*lCosTht*lSinPsi)
 407                                           *(x[0] - x[1]
 408                                             +(par[2] - par[5])*lCosTht*lSinPsi)
 409                                           +(+(par[0] - par[3])*(par[0] - par[3])
 410                                             +(par[1] - par[4])*(par[1] - par[4]))*(+lCosPsi*lCosPsi
 411                                                                                    +lSinPsi*lSinPsi*lSinTht*lSinTht)))
 412                     +lSinPsi*lSinTht*(+(par[0] - par[3])*(x[0] - x[1])
 413                                       +(par[0] - par[3])*(par[2] - par[5])*lCosTht*lSinPsi
 414                                       +(-par[1] + par[4])
 415                                       *TMath::Sqrt(-(x[0] - x[1]
 416                                                      +(par[2] - par[5])*lCosTht*lSinPsi)
 417                                                    *(x[0] - x[1]
 418                                                      +(par[2] - par[5])*lCosTht*lSinPsi)
 419                                                    +(+(par[0] - par[3])*(par[0] - par[3])
 420                                                      +(par[1] - par[4])*(par[1] - par[4]))*(+lCosPsi*lCosPsi
 421                                                                                             +lSinPsi*lSinPsi*lSinTht*lSinTht))))
 422                    /((+(par[0] - par[3])*(par[0] - par[3])
 423                       +(par[1] - par[4])*(par[1] - par[4]))*(+lCosPsi*lCosPsi
 424                                                              +lSinPsi*lSinPsi*lSinTht*lSinTht)));
 425
 426   phiy = -TMath::ACos(phiy);
 427
 428   return phiy;
 429 }
 430
 431
 432 Double_t AliMUONSurveyUtil::PhiYnp(const Double_t *x, const Double_t *par) const{
 433   /// Returns phi rot. using y coord. of 2 button targets. -+ solution.
 434
 435   Double_t lCosPsi = TMath::Cos(par[6]);
 436   Double_t lSinPsi = TMath::Sin(par[6]);
 437   Double_t lCosTht = TMath::Cos(par[7]);
 438   Double_t lSinTht = TMath::Sin(par[7]);
 439
 440   Double_t phiy = ((lCosPsi*(+(par[1] - par[4])*(x[0] - x[1])
 441                              +(par[1] - par[4])*(par[2] - par[5])*lCosTht*lSinPsi
 442                              +(par[0] - par[3])
 443                              *TMath::Sqrt(-(x[0] - x[1]
 444                                             +(par[2] - par[5])*lCosTht*lSinPsi)
 445                                           *(x[0] - x[1]
 446                                             +(par[2] - par[5])*lCosTht*lSinPsi)
 447                                           +((par[0] - par[3])*(par[0] - par[3])
 448                                             +(par[1] - par[4])*(par[1] - par[4]))*(+lCosPsi*lCosPsi
 449                                                                                    +lSinPsi*lSinPsi*lSinTht*lSinTht)))
 450                     +lSinPsi*lSinTht*(+(par[0] - par[3])*(x[0] - x[1])
 451                                       +(par[0] - par[3])*(par[2] - par[5])*lCosTht*lSinPsi
 452                                       +(-par[1] + par[4])
 453                                       *TMath::Sqrt(-(x[0] - x[1]
 454                                                      +(par[2] - par[5])*lCosTht*lSinPsi)
 455                                                    *(x[0] - x[1]
 456                                                      +(par[2] - par[5])*lCosTht*lSinPsi)
 457                                                    +((par[0] - par[3])*(par[0] - par[3])
 458                                                      +(par[1] - par[4])*(par[1] - par[4]))*(+lCosPsi*lCosPsi
 459                                                                                             +lSinPsi*lSinPsi*lSinTht*lSinTht))))
 460                    /((+(par[0] - par[3])*(par[0] - par[3])
 461                       +(par[1] - par[4])*(par[1] - par[4]))*(+lCosPsi*lCosPsi
 462                                                              +lSinPsi*lSinPsi*lSinTht*lSinTht)));
 463
 464   phiy = TMath::ACos(phiy);
 465
 466   return phiy;
 467 }
 468
 469 Double_t AliMUONSurveyUtil::ZnCenter(const Double_t *x, const Double_t *par) const{
 470   /// Returns center z position using z coord. of 2 button targets. - solution.
 471
 472   // par :  x1l, y1l, z1l, x2l, y2l, z2l, psi, tht
 473   Double_t lCosPsi = TMath::Cos(par[6]);
 474   Double_t lSinPsi = TMath::Sin(par[6]);
 475   Double_t lCosTht = TMath::Cos(par[7]);
 476   Double_t lSinTht = TMath::Sin(par[7]);
 477
 478   Double_t inSqrt = ((par[3]*par[1] - par[0]*par[4])*(par[3]*par[1] - par[0]*par[4])
 479                      *((-(x[0] - x[1])*(x[0] - x[1]))
 480                        +(((par[0] - par[3])*(par[0] - par[3])
 481                           +(par[1] - par[4])*(par[1] - par[4])))*lSinPsi*lSinPsi
 482                        +lCosPsi*((-(par[2] - par[5]))
 483                                  *lCosTht*(-2*x[0]+2*x[1]
 484                                            +(par[2] - par[5])*lCosPsi*lCosTht)
 485                                  +((par[0] - par[3])*(par[0] - par[3])
 486                                    +(par[1] - par[4])*(par[1] - par[4]))*lCosPsi*lSinTht*lSinTht)));
 487
 488   if (inSqrt<0) return inSqrt*1e10;
 489
 490   Double_t zD = ((1./((par[0] - par[3])*(par[0] - par[3])
 491                       +(par[1] - par[4])*(par[1] - par[4])))
 492                  *(-par[1]*par[4]*x[0]
 493                    +par[4]*par[4]*x[0]
 494                    +par[0]*par[0]*x[1]
 495                    +par[1]*par[1]*x[1]
 496                    -par[1]*par[4]*x[1]
 497                    -par[0]*par[3]*(x[0] + x[1])
 498                    +par[3]*par[3]*x[0]
 499                    +(+par[1]*par[4]*par[2]
 500                      -par[4]*par[4]*par[2]
 501                      -par[0]*par[0]*par[5]
 502                      -par[1]*par[1]*par[5]
 503                      +par[1]*par[4]*par[5]
 504                      +par[0]*par[3]*(par[2] + par[5])
 505                      -par[3]*par[3]*par[2])*lCosPsi*lCosTht
 506                    -TMath::Sqrt(inSqrt)));
 507
 508   return zD;
 509 }
 510
 511 Double_t AliMUONSurveyUtil::ZpCenter(const Double_t *x, const Double_t *par) const{
 512   /// Returns center z position using z coord. of 2 button targets. + solution.
 513
 514   // par :  x1l, y1l, z1l, x2l, y2l, z2l, psi, tht
 515   Double_t lCosPsi = TMath::Cos(par[6]);
 516   Double_t lSinPsi = TMath::Sin(par[6]);
 517   Double_t lCosTht = TMath::Cos(par[7]);
 518   Double_t lSinTht = TMath::Sin(par[7]);
 519
 520   Double_t inSqrt = ((par[3]*par[1] - par[0]*par[4])*(par[3]*par[1] - par[0]*par[4])
 521                      *((-(x[0] - x[1])*(x[0] - x[1]))
 522                        +(((par[0] - par[3])*(par[0] - par[3])
 523                           +(par[1] - par[4])*(par[1] - par[4])))*lSinPsi*lSinPsi
 524                        +lCosPsi*((-(par[2] - par[5]))
 525                                  *lCosTht*(-2*x[0]+2*x[1]
 526                                            +(par[2] - par[5])*lCosPsi*lCosTht)
 527                                  +((par[0] - par[3])*(par[0] - par[3])
 528                                    +(par[1] - par[4])*(par[1] - par[4]))*lCosPsi*lSinTht*lSinTht)));
 529
 530   if (inSqrt<0) return inSqrt*1e10;
 531
 532   Double_t zD = ((1./((par[0] - par[3])*(par[0] - par[3])
 533                       +(par[1] - par[4])*(par[1] - par[4])))
 534                  *(-par[1]*par[4]*x[0]
 535                    +par[4]*par[4]*x[0]
 536                    +par[0]*par[0]*x[1]
 537                    +par[1]*par[1]*x[1]
 538                    -par[1]*par[4]*x[1]
 539                    -par[0]*par[3]*(x[0] + x[1])
 540                    +par[3]*par[3]*x[0]
 541                    +(+par[1]*par[4]*par[2]
 542                      -par[4]*par[4]*par[2]
 543                      -par[0]*par[0]*par[5]
 544                      -par[1]*par[1]*par[5]
 545                      +par[1]*par[4]*par[5]
 546                      +par[0]*par[3]*(par[2] + par[5])
 547                      -par[3]*par[3]*par[2])*lCosPsi*lCosTht
 548                    +TMath::Sqrt(inSqrt)));
 549
 550   return zD;
 551 }
 552
 553 //______________________________________________________________________
 554 AliMUONGeometryTransformer* AliMUONSurveyUtil::ReAlign(const AliMUONGeometryTransformer * transformer,
 555                                                        int rMod, int rNDetElems, int rDetElemPseudoIdToDetElem[], TGeoCombiTrans deltaDetElemTransf[], Bool_t verbose)
 556 {
 557   /////////////////////////////////////////////////////////////////////
 558   ///   Takes the internal geometry module transformers, copies them
 559   /// and gets the Detection Elements from them.
 560   /// Takes misalignment parameters and applies these
 561   /// to the local transform of the Detection Element
 562   /// Obtains the global transform by multiplying the module transformer
 563   /// transformation with the local transformation
 564   /// Applies the global transform to a new detection element
 565   /// Adds the new detection element to a new module transformer
 566   /// Adds the new module transformer to a new geometry transformer
 567   /// Returns the new geometry transformer
 568
 569   Int_t iDetElemId = 0;
 570   Int_t iDetElemPseudoId = 0;
 571
 572   AliMUONGeometryTransformer *newGeometryTransformer =
 573     new AliMUONGeometryTransformer();
 574   for (Int_t iMt = 0; iMt < transformer->GetNofModuleTransformers(); iMt++) {
 575     // module transformers
 576     const AliMUONGeometryModuleTransformer *kModuleTransformer =
 577       transformer->GetModuleTransformer(iMt, true);
 578
 579     AliMUONGeometryModuleTransformer *newModuleTransformer =
 580       new AliMUONGeometryModuleTransformer(iMt);
 581     newGeometryTransformer->AddModuleTransformer(newModuleTransformer);
 582
 583     TGeoCombiTrans moduleTransform =
 584       TGeoCombiTrans(*kModuleTransformer->GetTransformation());
 585     // New module transformation
 586     TGeoCombiTrans *newModuleTransform;
 587     if ((rMod<4 && iMt==rMod) || (rMod>=4 && (iMt==4+(rMod-4)*2||iMt==4+(rMod-4)*2+1))) {
 588       newModuleTransform = new TGeoCombiTrans(moduleTransform*deltaDetElemTransf[rNDetElems]);
 589     } else {
 590       newModuleTransform = new TGeoCombiTrans(moduleTransform);
 591     }
 592     newModuleTransformer->SetTransformation(*newModuleTransform);
 593
 594     // For the selected chamber add misalign module
 595     if ((rMod<4 && iMt==rMod) || (rMod>=4 && (iMt==4+(rMod-4)*2||iMt==4+(rMod-4)*2+1))) {
 596       // Get delta transformation:
 597       // Tdelta = Tnew * Told.inverse
 598       TGeoHMatrix deltaModuleTransform =
 599         AliMUONGeometryBuilder::Multiply(*newModuleTransform,
 600                                          kModuleTransformer->GetTransformation()->Inverse());
 601       // Create module mis alignment matrix
 602       newGeometryTransformer
 603         ->AddMisAlignModule(kModuleTransformer->GetModuleId(), deltaModuleTransform);
 604     }
 605
 606     AliMpExMap *detElements = kModuleTransformer->GetDetElementStore();
 607
 608     if (verbose)
 609       printf("%i DEs in old GeometryStore  %i\n",detElements->GetSize(), iMt);
 610     TGeoCombiTrans *deltaLocalTransform;
 611     TIter next(detElements->CreateIterator());
 612     AliMUONGeometryDetElement *detElement;
 613     while ((detElement = static_cast<AliMUONGeometryDetElement*>(next()))){
 614       /// make a new detection element
 615       AliMUONGeometryDetElement *newDetElement =
 616         new AliMUONGeometryDetElement(detElement->GetId(),
 617                                       detElement->GetVolumePath());
 618       TString lDetElemName(detElement->GetDEName());
 619       lDetElemName.ReplaceAll("DE","");
 620       iDetElemId = lDetElemName.Atoi();
 621       iDetElemPseudoId = iDetElemId%100;
 622       if ((rMod<4 && iMt==rMod) || (rMod>=4 && (iMt==4+(rMod-4)*2||iMt==4+(rMod-4)*2+1))) {
 623         deltaLocalTransform = new TGeoCombiTrans(deltaDetElemTransf[rDetElemPseudoIdToDetElem[iDetElemPseudoId]]);
 624       } else {
 625         deltaLocalTransform = new TGeoCombiTrans(*gGeoIdentity);
 626       }
 627
 628       // local transformation of this detection element.
 629       TGeoCombiTrans localTransform
 630         = TGeoCombiTrans(*detElement->GetLocalTransformation());
 631       //      TGeoHMatrix newLocalMatrix = localTransform * (*deltaLocalTransform);
 632       TGeoCombiTrans newLocalTransform
 633         = TGeoCombiTrans(localTransform * (*deltaLocalTransform));
 634       newDetElement->SetLocalTransformation(newLocalTransform);
 635       // global transformation
 636       TGeoHMatrix newGlobalTransform =
 637         AliMUONGeometryBuilder::Multiply(*newModuleTransform,
 638                                          newLocalTransform);
 639       newDetElement->SetGlobalTransformation(newGlobalTransform);
 640
 641       // add this det element to module
 642       newModuleTransformer->GetDetElementStore()->Add(newDetElement->GetId(),
 643                                                       newDetElement);
 644
 645       // In the Alice Alignment Framework misalignment objects store
 646       // global delta transformation
 647       // Get detection "intermediate" global transformation
 648       TGeoHMatrix newOldGlobalTransform = (*newModuleTransform) * localTransform;
 649       // Get detection element global delta transformation:
 650       // Tdelta = Tnew * Told.inverse
 651       TGeoHMatrix  deltaGlobalTransform
 652         = AliMUONGeometryBuilder::Multiply(newGlobalTransform,
 653                                            newOldGlobalTransform.Inverse());
 654
 655       // Create mis alignment matrix
 656       newGeometryTransformer
 657         ->AddMisAlignDetElement(detElement->GetId(), deltaGlobalTransform);
 658     }
 659
 660     if (verbose)
 661       printf("Added module transformer %i to the transformer\n", iMt);
 662     newGeometryTransformer->AddModuleTransformer(newModuleTransformer);
 663   }
 664   return newGeometryTransformer;
 665 }
 666
 667 void AliMUONSurveyUtil::SetAlignmentResolution(const TClonesArray* misAlignArray, Int_t chId, Double_t chResX, Double_t chResY, Double_t deResX, Double_t deResY){
 668   /// Sets the alignment resolution to the AliAlignObjMatrix correlation matrix
 669
 670   TMatrixDSym mChCorrMatrix(6);
 671   mChCorrMatrix[0][0]=chResX*chResX;
 672   mChCorrMatrix[1][1]=chResY*chResY;
 673   //  mChCorrMatrix.Print();
 674
 675   TMatrixDSym mDECorrMatrix(6);
 676   mDECorrMatrix[0][0]=deResX*deResX;
 677   mDECorrMatrix[1][1]=deResY*deResY;
 678   //  mDECorrMatrix.Print();
 679
 680   AliAlignObjMatrix *alignMat = 0x0;
 681
 682 //  Int_t modId = (chId<4)? chId : 4+(chId-4)*2;
 683   TString chName1;
 684   TString chName2;
 685   if (chId<4){
 686     chName1 = Form("GM%d",chId);
 687     chName2 = Form("GM%d",chId);
 688   } else {
 689     chName1 = Form("GM%d",4+(chId-4)*2);
 690     chName2 = Form("GM%d",4+(chId-4)*2+1);
 691   }
 692
 693   for (int i=0; i<misAlignArray->GetEntries(); i++) {
 694     alignMat = (AliAlignObjMatrix*)misAlignArray->At(i);
 695     TString volName(alignMat->GetSymName());
 696     if((volName.Contains(chName1)&&
 697         volName.Last('/')<=volName.Index(chName1)+chName1.Length())||
 698        (volName.Contains(chName2)&&
 699         volName.Last('/')<=volName.Index(chName2)+chName2.Length())) {
 700       volName.Remove(0,volName.Last('/')+1);
 701       if (volName.Contains("GM")) {
 702         //      alignMat->Print("NULL");
 703         alignMat->SetCorrMatrix(mChCorrMatrix);
 704       } else if (volName.Contains("DE")) {
 705         //      alignMat->Print("NULL");
 706         alignMat->SetCorrMatrix(mDECorrMatrix);
 707       }
 708     }
 709   }
 710 }