ITS/AliITSMisalignMaker.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$  */
  17
  18 //========================================================================
  19 //
  20 // This class is a helper, producing ITS aligmnent objects.
  21 // It provides also some useful functions
  22 // See the parameters of the misalignment at the end of this script.
  23 //
  24 // Main author: L. Gaudichet
  25 // Contact: andrea.dainese@lnl.infn.it
  26 //
  27 //========================================================================
  28
  29 #include <TRandom3.h>
  30 #include <TClonesArray.h>
  31 #include <TMath.h>
  32
  33
  34 #include "AliLog.h"
  35 #include "AliAlignObjParams.h"
  36 #include "AliITSMisalignMaker.h"
  37
  38
  39 ClassImp(AliITSMisalignMaker)
  40
  41 const Int_t AliITSMisalignMaker::fgkNLadders[AliITSMisalignMaker::kNLayers] = {20,40,14,22,34,38};
  42 const Int_t AliITSMisalignMaker::fgkNDetectors[AliITSMisalignMaker::kNLayers] = {4,4,6,8,22,25};
  43
  44
  45 //________________________________________________________________________
  46 AliITSMisalignMaker::AliITSMisalignMaker():
  47   fRnd(),
  48   fInd(0),
  49   fAlobj(TClonesArray("AliAlignObjParams",4000)),
  50   fStrSPD("ITS/SPD"),
  51   fStrSDD("ITS/SDD"),
  52   fStrSSD("ITS/SSD"),
  53   fStrStave("/Stave"),
  54   fStrHalfStave("/HalfStave"),
  55   fStrLadder("/Ladder"),
  56   fStrSector("/Sector"),
  57   fStrSensor("/Sensor")
  58 {
  59   fRnd.SetSeed(23472341);
  60 }
  61 //________________________________________________________________________
  62 Int_t AliITSMisalignMaker::AddAlignObj(char* name,Double_t dx,Double_t dy,Double_t dz,
  63                                 Double_t dpsi,Double_t dtheta,Double_t dphi,Bool_t unif) {
  64
  65   Double_t vx,vy,vz,vpsi,vtheta,vphi;
  66
  67   if(!unif) {
  68     vx = GaussCut(0,dx/3.,dx); // mean, sigma, max absolute value
  69     vy = GaussCut(0,dy/3.,dy);
  70     vz = GaussCut(0,dz/3.,dz);
  71     vpsi   = GaussCut(0,dpsi/3.,  dpsi );
  72     vtheta = GaussCut(0,dtheta/3.,dtheta);
  73     vphi   = GaussCut(0,dphi/3.,  dphi);
  74   } else {
  75     vx = fRnd.Uniform(-dx,dx);
  76     vy = fRnd.Uniform(-dy,dy);
  77     vz = fRnd.Uniform(-dz,dz);
  78     vpsi = fRnd.Uniform(-dpsi,dpsi);
  79     vtheta = fRnd.Uniform(-dtheta,dtheta);
  80     vphi = fRnd.Uniform(-dphi,dphi);
  81   }
  82
  83   new(fAlobj[fInd]) AliAlignObjParams(name,0,vx,vy,vz,vpsi,vtheta,vphi,kFALSE);
  84
  85   AliAlignObjParams* its_alobj = (AliAlignObjParams*) fAlobj.UncheckedAt(fInd);
  86   its_alobj->ApplyToGeometry();
  87
  88   fInd++;
  89
  90   return kTRUE;
  91 }
  92
  93
  94 //________________________________________________________________________
  95 Int_t AliITSMisalignMaker::AddAlignObj(Int_t lay,Double_t dx,Double_t dy,Double_t dz,
  96                                  Double_t dpsi,Double_t dtheta,Double_t dphi,Bool_t unif) {
  97
  98   // misalignment at the level of ladders/modules
  99   lay+=1; // layers are numbered from 1 to 6 in AliGeomManager
 100
 101   printf("LAYER %d  MODULES %d\n",lay,AliGeomManager::LayerSize(lay));
 102
 103   for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(lay); iModule++) {
 104
 105     Double_t vx,vy,vz,vpsi,vtheta,vphi;
 106
 107     if(!unif) {
 108       vx = GaussCut(0,dx/3.,dx); // mean, sigma, max absolute value
 109       vy = GaussCut(0,dy/3.,dy);
 110       vz = GaussCut(0,dz/3.,dz);
 111       vpsi   = GaussCut(0,dpsi/3.,  dpsi );
 112       vtheta = GaussCut(0,dtheta/3.,dtheta);
 113       vphi   = GaussCut(0,dphi/3.,  dphi);
 114     } else {
 115       vx = fRnd.Uniform(-dx,dx);
 116       vy = fRnd.Uniform(-dy,dy);
 117       vz = fRnd.Uniform(-dz,dz);
 118       vpsi = fRnd.Uniform(-dpsi,dpsi);
 119       vtheta = fRnd.Uniform(-dtheta,dtheta);
 120       vphi = fRnd.Uniform(-dphi,dphi);
 121     }
 122
 123     UShort_t volid = AliGeomManager::LayerToVolUID(lay,iModule);
 124     const char *symname = AliGeomManager::SymName(volid);
 125
 126     new(fAlobj[fInd]) AliAlignObjParams(symname,volid,vx,vy,vz,vpsi,vtheta,vphi,kFALSE);
 127     AliAlignObjParams* its_alobj = (AliAlignObjParams*) fAlobj.UncheckedAt(fInd);
 128     its_alobj->ApplyToGeometry();
 129     fInd++;
 130   }
 131
 132   return kTRUE;
 133 }
 134
 135
 136 //________________________________________________________________________
 137 Int_t AliITSMisalignMaker::AddAlignObj(Int_t lay,Int_t ladd,Double_t dx,Double_t dy,Double_t dz,
 138                                  Double_t dpsi,Double_t dtheta,Double_t dphi,Bool_t unif) {
 139
 140   // misalignment at the level of half-staves/ladders (ladd=-1 means that all ladders are scanned)
 141
 142   Double_t vx,vy,vz,vpsi,vtheta,vphi;
 143
 144   Int_t laddMin = ladd;
 145   Int_t laddMax = laddMin+1;
 146   if (ladd<0) {
 147     laddMin = 0;
 148     laddMax = fgkNLadders[lay];
 149   }
 150
 151   for (Int_t iLadd=laddMin; iLadd<laddMax; iLadd++) {
 152
 153     Int_t nHS = 1;
 154     if (lay<2) nHS = 2;
 155     for (Int_t iHalfStave=0; iHalfStave<nHS; iHalfStave++) {
 156
 157       if(!unif) {
 158         vx = GaussCut(0,dx/3.,dx); // mean, sigma, max absolute value
 159         vy = GaussCut(0,dy/3.,dy);
 160         vz = GaussCut(0,dz/3.,dz);
 161         vpsi   = GaussCut(0,dpsi/3.,  dpsi );
 162         vtheta = GaussCut(0,dtheta/3.,dtheta);
 163         vphi   = GaussCut(0,dphi/3.,  dphi);
 164       } else {
 165         vx = fRnd.Uniform(-dx,dx);
 166         vy = fRnd.Uniform(-dy,dy);
 167         vz = fRnd.Uniform(-dz,dz);
 168         vpsi = fRnd.Uniform(-dpsi,dpsi);
 169         vtheta = fRnd.Uniform(-dtheta,dtheta);
 170         vphi = fRnd.Uniform(-dphi,dphi);
 171       }
 172
 173       TString name = GetHalfStaveLadderSymbName(lay,iLadd,iHalfStave);
 174       new(fAlobj[fInd]) AliAlignObjParams(name.Data(),0,vx,vy,vz,vpsi,vtheta,vphi,kFALSE);
 175       AliAlignObjParams* its_alobj = (AliAlignObjParams*) fAlobj.UncheckedAt(fInd);
 176       its_alobj->ApplyToGeometry();
 177       fInd++;
 178     }
 179   }
 180
 181   return kTRUE;
 182 }
 183
 184
 185 //________________________________________________________________________
 186 Int_t AliITSMisalignMaker::AddSectorAlignObj(Int_t sectMin,Int_t sectMax,
 187                                        Double_t dx,Double_t dy,Double_t dz,
 188                                        Double_t dpsi,Double_t dtheta,Double_t dphi,
 189                                        Double_t xShift,Double_t yShift,Double_t zShift,
 190                                        Double_t psiShift,Double_t thetaShift,Double_t phiShift,Bool_t unif) {
 191
 192   // misalignment at the level of SPD sectors and half-barrels
 193
 194   if ((sectMin<1) || (sectMax>10)) return kFALSE;
 195   Double_t vx,vy,vz,vpsi,vtheta,vphi;
 196   Double_t tr[3],rot[3];
 197
 198   for (Int_t iSect = sectMin-1; iSect<sectMax; iSect++) {
 199
 200     // first, apply sector level misalignment
 201     if(!unif) {
 202       vx = GaussCut(0,dx/3.,dx); // mean, sigma, max absolute value
 203       vy = GaussCut(0,dy/3.,dy);
 204       vz = GaussCut(0,dz/3.,dz);
 205       vpsi   = GaussCut(0,dpsi/3.,  dpsi );
 206       vtheta = GaussCut(0,dtheta/3.,dtheta);
 207       vphi   = GaussCut(0,dphi/3.,  dphi);
 208     } else {
 209       vx = fRnd.Uniform(-dx,dx);
 210       vy = fRnd.Uniform(-dy,dy);
 211       vz = fRnd.Uniform(-dz,dz);
 212       vpsi = fRnd.Uniform(-dpsi,dpsi);
 213       vtheta = fRnd.Uniform(-dtheta,dtheta);
 214       vphi = fRnd.Uniform(-dphi,dphi);
 215     }
 216
 217     TString name = GetSymbName(0);
 218     name += fStrSector;
 219     name += iSect;
 220
 221
 222     AliAlignObjParams aaop(name.Data(),0,vx,vy,vz,vpsi,vtheta,vphi,kFALSE); // set them as local
 223     aaop.GetPars(tr,rot); // global
 224
 225     // then, apply half-barrel level misalignment
 226     tr[0] += xShift;
 227     tr[1] += yShift;
 228     tr[2] += zShift;
 229     rot[0] += psiShift;
 230     rot[1] += thetaShift;
 231     rot[2] += phiShift;
 232
 233     new(fAlobj[fInd]) AliAlignObjParams(name.Data(),0,tr[0],tr[1],tr[2],rot[0],rot[1],rot[2],kTRUE); // set them as global
 234
 235     AliAlignObjParams* its_alobj = (AliAlignObjParams*) fAlobj.UncheckedAt(fInd);
 236     its_alobj->ApplyToGeometry();
 237     fInd++;
 238   }
 239   return kTRUE;
 240 }
 241
 242 //________________________________________________________________________
 243 Double_t AliITSMisalignMaker::GaussCut(Double_t mean,Double_t sigma,Double_t absMax) {
 244
 245   Double_t val = fRnd.Gaus(mean,sigma);
 246   while (TMath::Abs(val)>absMax)
 247     val = fRnd.Gaus(mean,sigma);
 248   return val;
 249 }
 250
 251 //________________________________________________________________________
 252 TString AliITSMisalignMaker::GetSymbName(Int_t layer) const {
 253
 254   // be careful : SPD0 and SPD1 are not physically separated
 255   TString name;
 256   switch (layer) {
 257   case 0:
 258   case 1: name = fStrSPD; name += layer; break;
 259   case 2:
 260   case 3: name = fStrSDD; name += layer; break;
 261   case 4:
 262   case 5: name = fStrSSD; name += layer; break;
 263   default: AliFatal("Wrong layer index");
 264   }
 265   return name;
 266 }
 267
 268 //________________________________________________________________________
 269 TString AliITSMisalignMaker::GetHalfStaveLadderSymbName(Int_t layer,Int_t ladd,Int_t halfStave) const {
 270
 271   // Get logical names at the level of half-staves (SPD) or ladders (SDD and SSD)
 272
 273   TString name = GetSymbName(layer);
 274   if (layer==0) { // SPD1
 275
 276     int sector = ladd/2;
 277     name += fStrSector;
 278     name += sector;
 279     int stave = ladd-sector*2;
 280     name += fStrStave;
 281     name += stave;
 282     name += fStrHalfStave;
 283     name += halfStave;
 284   }
 285   else if (layer==1) { // SPD2
 286
 287     int sector = ladd/4;
 288     name += fStrSector;
 289     name += sector;
 290     int stave = ladd-sector*4;
 291     name += fStrStave;
 292     name += stave;
 293     name += fStrHalfStave;
 294     name += halfStave;
 295   }
 296   else if (layer>=2 && layer<=5) { // SDD and SSD
 297     name += fStrLadder;
 298     name += ladd;
 299   }
 300   else {
 301     AliFatal("Wrong layer index");
 302   }
 303   return name;
 304 }
 305
 306 //________________________________________________________________________
 307 TString AliITSMisalignMaker::GetSymbName(Int_t layer,Int_t ladd) const {
 308
 309   // Get logical names at the level of staves / ladders
 310
 311   TString name = GetSymbName(layer);
 312   if (layer==0) { // SPD1
 313
 314     int sector = ladd/2;
 315     name += fStrSector;
 316     name += sector;
 317     int stave = ladd-sector*2;
 318     name += fStrStave;
 319     name += stave;
 320   }
 321   else if (layer==1) { // SPD2
 322
 323     int sector = ladd/4;
 324     name += fStrSector;
 325     name += sector;
 326     int stave = ladd-sector*4;
 327     name += fStrStave;
 328     name += stave;
 329   }
 330   else if (layer>=2 && layer<=5) { // SDD and SSD
 331     name += fStrLadder;
 332     name += ladd;
 333   }
 334   else {
 335     AliFatal("Wrong layer index");
 336   }
 337   return name;
 338 }
 339 /*
 340 //________________________________________________________________________
 341 TString AliITSMisalignMaker::GetSymbName(Int_t layer,Int_t ladd,Int_t mod) const {
 342
 343   // Get logical names at the level of SPD ladders / SDD and SSD modules
 344
 345   Int_t halfStave = mod/2;
 346   TString name = GetHalfStaveLadderSymbName(layer,ladd,halfStave);
 347
 348   if (layer<2) { // SPD
 349     name += fStrLadder;
 350     name += mod;
 351   }
 352   else if (layer>=2 && layer<=5) { // SDD and SSD
 353     name += fStrSensor;
 354     name += mod;
 355   }
 356   else {
 357     AliFatal("Wrong layer index");
 358   }
 359   return name;
 360 }
 361 */