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