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