ITS/AliITSRealignTracks.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 #include <TArray.h>
  18 #include <TFile.h>
  19 #include <TStopwatch.h>
  20 #include <TArray.h>
  21 #include <TNtuple.h>
  22 #include <TClonesArray.h>
  23 #include <TMath.h>
  24 #include <TGeoManager.h>
  25 #include <TSystem.h>
  26 #include <TGeoMatrix.h>
  27 #include "AliITSRealignTracks.h"
  28 #include "AliAlignmentTracks.h"
  29 #include "AliAlignObjParams.h"
  30 #include "AliGeomManager.h"
  31 #include "AliTrackFitter.h"
  32 #include "AliTrackFitterKalman.h"
  33 #include "AliTrackFitterRieman.h"
  34 #include "AliTrackResidualsFast.h"
  35 #include "AliTrackResidualsChi2.h"
  36 #include "AliTrackResidualsLinear.h"
  37 #include "AliLog.h"
  38
  39
  40 ClassImp(AliITSRealignTracks)
  41
  42 const Int_t referSect=2;
  43
  44
  45 AliITSRealignTracks::AliITSRealignTracks(TString minimizer,Int_t fit,Bool_t covUsed,TString fileintro,TString geometryfile,TString misalignmentFile,TString startingfile):
  46   AliAlignmentTracks(),
  47   fSurveyObjs(0),
  48   fgeomfilename(),
  49   fmintracks(),
  50   fCovIsUsed(covUsed),
  51   fUpdateCov(kFALSE)
  52 {
  53
  54   // minimizer="fast"->AliTrackResidualFast minimizer
  55   //           "minuit"->AliTrackResidualChi2 minimizer
  56   //           "minuitnorot"->AliTrackResidualChi2 minimizer without rotations degrees of freedom
  57   //           "linear"->AliTrackResidualLinear minimizer
  58   //fit=0-> Riemann Fitter, fit=1->Kalman
  59   //fileintro=file into which the Tree with the space points is stored
  60   //geometryfile=file containing the geometry
  61
  62
  63   SetPointsFilename(fileintro.Data());
  64   SetGeomFilename(geometryfile);
  65   InitAlignObjs();
  66   if(!InitSurveyObjs(kFALSE))AliWarning("Unable to set Survey AlignObjs!");
  67
  68   if(startingfile=="")printf("Starting from default geometry \n");
  69   else ReadAlignObjs(startingfile.Data(),"ITSAlignObjs");
  70
  71   if(misalignmentFile=="")printf("NO FAKE MISALIGNMENT INTRODUCED \n");
  72   else {
  73     Bool_t misal=Misalign(misalignmentFile,"ITSAlignObjs");
  74     if(!misal)AliWarning("Incorrect fake misalignment filename!");;
  75   }
  76
  77   if(!gGeoManager) AliGeomManager::LoadGeometry(fgeomfilename.Data());
  78   if(covUsed)SetCovIsUsed(kTRUE);
  79   if(!SelectFitter(fit))AliWarning("Incorrect fitter assignment!");
  80   if(!SelectMinimizer(minimizer))AliWarning("Incorrect minimizer assignment!");
  81
  82   fmintracks=1;
  83   BuildIndex();
  84
  85 }
  86
  87 AliITSRealignTracks::AliITSRealignTracks(const AliITSRealignTracks &realignTracks):
  88   AliAlignmentTracks(),
  89   fSurveyObjs(new AliAlignObj**(*realignTracks.fSurveyObjs)),
  90   fgeomfilename(realignTracks.fgeomfilename),
  91   fmintracks(realignTracks.fmintracks),
  92   fCovIsUsed(realignTracks.fCovIsUsed),
  93   fUpdateCov(realignTracks.fUpdateCov)
  94 {//Copy Constructor
  95   AliWarning("Can't copy AliAlignmentTracks Data member!");
  96 }
  97
  98 AliITSRealignTracks& AliITSRealignTracks::operator=(const AliITSRealignTracks &obj){
  99   ////////////////////////
 100   // Assignment operator
 101   ////////////////////////
 102   this->~AliITSRealignTracks();
 103   new(this) AliITSRealignTracks(obj);
 104   return *this;
 105 }
 106
 107 AliITSRealignTracks::~AliITSRealignTracks(){
 108   //destructor
 109
 110   if(fSurveyObjs)   DeleteSurveyObjs();
 111   //delete [] fSurveyObjs;
 112
 113 }
 114
 115
 116 //_____________________________
 117 Bool_t AliITSRealignTracks::SelectFitter(Int_t fit,Int_t minTrackPoint){
 118
 119   if(fit==1){
 120      AliTrackFitterKalman *fitter= new AliTrackFitterKalman();
 121      fitter->SetMinNPoints(minTrackPoint);
 122      SetTrackFitter(fitter);
 123   }
 124
 125   else if(fit==0){
 126     AliTrackFitterRieman *fitter=new AliTrackFitterRieman();
 127     fitter=new AliTrackFitterRieman();
 128     fitter->SetMinNPoints(minTrackPoint);
 129     SetTrackFitter(fitter);
 130   }
 131   else return kFALSE;
 132
 133   return kTRUE;
 134 }
 135
 136
 137 Bool_t AliITSRealignTracks::SelectMinimizer(TString minimizer,Int_t minpoints,const Bool_t *coord){
 138   AliTrackResiduals *res;
 139   if(minimizer=="minuit"){
 140     res = new AliTrackResidualsChi2();
 141     if(coord){
 142       for(Int_t j=0;j<6;j++){
 143         if(coord[j])res->FixParameter(j);
 144       }
 145     }
 146   }
 147   else if(minimizer=="minuitnorot"){
 148     res = new AliTrackResidualsChi2();
 149     res->FixParameter(3);
 150     res->FixParameter(4);
 151     res->FixParameter(5);
 152   }
 153
 154   else if(minimizer=="fast"){
 155     res = new AliTrackResidualsFast();
 156     if(coord){
 157       for(Int_t j=0;j<6;j++){
 158         if(coord[j])res->FixParameter(j);
 159       }
 160     }
 161   }
 162   else if(minimizer=="linear"){
 163     res = new AliTrackResidualsLinear();
 164   }
 165
 166   else {
 167     printf("Trying to set a non existing minimizer! \n");
 168     return kFALSE;
 169   }
 170
 171   res->SetMinNPoints(minpoints);
 172   SetMinimizer(res);
 173
 174   return kTRUE;
 175 }
 176
 177
 178 void AliITSRealignTracks::RealignITSVolIndependent(Int_t iter1,Int_t iterations,Int_t minNtracks,Int_t layer,Int_t minTrackPoint){
 179
 180
 181   //iter1=#iterations inside AliAlignmentTracks::AliAlignVolumesITS method
 182   //iterations=#iterations on the all procedure
 183   //layer=0->all ITS, otherways the usual notation is considered (1=SPD1,2=SPD2,3=SDD1,4=SDD2,5=SSD1,6=SSD2)
 184   //minNtracks=minimun number of tracks passing through a module in order to try to realign the module itsself
 185   //           if minNtracks<0, minimun number of tracks is |minNtracks|*minNumPoint[layer]/fact (see the code below): this allows a different
 186   //           choice of the number of tracks required on different layers and to vary these numbers once tuned the relative proportions.
 187   //minTrackPoint=minimun number of "good" points required to a track (THE POINT ON THE MODULE THAT IS GOING TO BE REALIGNED
 188   //IS NEVER CONSIDERED->max number can be required is 11 for cosmics tracks) for the track being considered in the minimization
 189
 190
 191   fTrackFitter->SetMinNPoints(minTrackPoint);
 192   TArrayI volIDs2(2200);
 193   volIDs2.Reset(0);
 194   TArrayI volIDs(1);
 195   TString command;
 196   TArrayI volIDsFit;
 197
 198   Int_t iLayer,iLayerToAlign;
 199
 200   Int_t minNumPoint[6]={100,100,100,100,50,50};
 201   Double_t fact=10;
 202   Int_t j=0;
 203
 204   Int_t size=0;
 205   Int_t layerNum,modNum,lastVolid=0;
 206   TNtuple *ntVolumeAlign=new TNtuple("ntVolumeAlign","NTuple with volume tried to be realigned","layerNum:modNum:volumeIDnum");
 207
 208   TStopwatch *timer=new TStopwatch();
 209   timer->Start();
 210   BuildIndex();
 211   j=0;
 212   UShort_t volid;
 213
 214   for(Int_t iter=0;iter<iterations;iter++){
 215
 216     //Starting Independent Modules Realignment
 217     for(iLayerToAlign=(Int_t)AliGeomManager::kSPD1;iLayerToAlign<=(Int_t)AliGeomManager::kSSD2;iLayerToAlign++){
 218       if(layer!=0&&iLayerToAlign!=layer)continue;
 219       j=0;
 220       size=0;
 221       for(Int_t k=(Int_t)AliGeomManager::kSPD1;k<=(Int_t)AliGeomManager::kSSD2;k++){
 222         size+=AliGeomManager::LayerSize(k);
 223         printf("size: %d \n",size);
 224       }
 225
 226       for (Int_t iModule=0;iModule<AliGeomManager::LayerSize(iLayerToAlign);iModule++){
 227         j=0;
 228         if(minNtracks<0){
 229           if(GetLastIndex(iLayerToAlign-(Int_t)AliGeomManager::kFirstLayer,iModule)<minNumPoint[iLayerToAlign-(Int_t)AliGeomManager::kFirstLayer]*(-1*minNtracks/fact))continue;        }
 230         else if(GetLastIndex(iLayerToAlign-(Int_t)AliGeomManager::kFirstLayer,iModule)<minNtracks)continue;
 231
 232         UShort_t volidAl = AliGeomManager::LayerToVolUID(iLayerToAlign,iModule);
 233
 234         volIDsFit.Reset(0);
 235         volIDsFit.Set(size-1);
 236         for (iLayer=AliGeomManager::kSPD1;iLayer<AliGeomManager::kTPC1;iLayer++){
 237           for (Int_t iModule2=0;iModule2<AliGeomManager::LayerSize(iLayer);iModule2++){
 238             volid = AliGeomManager::LayerToVolUID(iLayer,iModule2);
 239             if(AliGeomManager::LayerToVolUID(iLayer,iModule2)==volidAl)continue;
 240             volIDsFit.AddAt(volid,j);
 241             j++;
 242           }
 243         }
 244         volIDs.AddAt((Int_t)volidAl,0);
 245         if(iter==iterations-1){
 246           volIDs2.AddAt(volidAl,lastVolid);
 247           lastVolid++;
 248         }
 249         volIDs2.AddAt(volidAl,lastVolid);
 250         AlignVolumesITS(&volIDs,&volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSSD2,iter1);
 251       }
 252     }
 253
 254
 255     if((iter+1)%5==0||iter==0||iter==1||iter==2||iter==3||iter==iterations-1){
 256       command="RealignObj";
 257       command+=(iter+1);
 258       command.Append(".root");
 259       WriteRealignObjArray(command.Data(),AliGeomManager::kSPD1,AliGeomManager::kSSD2);
 260     }
 261   }
 262
 263
 264   if(j==0){printf("j=0 \n");return;}
 265   for(Int_t k=0;k<volIDs2.GetSize();k++){
 266     if(volIDs2.At(k)==0)break;
 267     layerNum=AliGeomManager::VolUIDToLayer(volIDs2.At(k),modNum);
 268     ntVolumeAlign->Fill(layerNum,modNum,volIDs2.At(k));
 269   }
 270   printf("End of selecting modules cycle: %d modules selected \n",j);
 271   TFile *f=new TFile("RealignVolNt.root","RECREATE");
 272   f->cd();
 273   ntVolumeAlign->Write();
 274   f->Close();
 275
 276   timer->Stop();
 277   timer->Print();
 278   return;
 279 }
 280
 281
 282 void AliITSRealignTracks::RealignITStracks(TString minimizer,Int_t fit=0,Int_t iter1=1,Int_t iterations=5,Int_t minNtracks=-10,Int_t layer=0,Int_t minTrackPoint=6,Bool_t covUsed=kFALSE,TString misalignmentFile="",TString startingfile="",Int_t doGlobal=1)
 283 {
 284
 285   // minimizer="fast"->AliTrackResidualFast minimizer
 286   //           "minuit"->AliTrackResidualChi2 minimizer
 287   //           "minuitnorot"->AliTrackResidualChi2 minimizer without rotations degrees of freedom
 288   //           "linear"->AliTrackResidualLinear minimizer
 289   //fit=0-> Riemann Fitter, fit=1->Kalman
 290   //iter1=#iterations inside AliAlignmentTracks::AliAlignVolumesITS method
 291   //iterations=#iterations on the all procedure
 292   //layer=0->all ITS, otherways the usual notation is considered (1=SPD1,2=SPD2,3=SDD1,4=SDD2,5=SSD1,6=SSD2)
 293   //minNtracks=minimun number of tracks passing through a module in order to try to realign the module itsself
 294   //           if minNtracks<0, minimun number of tracks is |minNtracks|*minNumPoint[layer]/fact (see the code below): this allows a different
 295   //           choice of the number of tracks required on different layers and to vary these numbers once tuned the relative proportions.
 296   //minTrackPoint=minimun number of "good" points required to a track (THE POINT ON THE MODULE THAT IS GOING TO BE REALIGNED
 297   //              IS NEVER CONSIDERED->max number that can be required is 11 for cosmics tracks) for the track being considered in the minimization
 298   //doGlobal : do global realignment, 0=no, 1= yes, 2=only global
 299
 300
 301   TArrayI volIDs2(2200);
 302   volIDs2.Reset(0);
 303   TArrayI volIDs(1);
 304   TString command;
 305   TArrayI volIDsFit;
 306
 307   Int_t iLayer,iLayerToAlign;
 308
 309   Int_t minNumPoint[6]={100,100,100,100,50,50};
 310   Double_t fact=10;
 311   Int_t count=0;
 312
 313   Int_t size=0;
 314   Int_t layerNum,modNum,lastVolid=0;
 315   TNtuple *ntVolumeAlign=new TNtuple("ntVolumeAlign","NTuple with volume tried to be realigned","layerNum:modNum:volumeIDnum");
 316
 317
 318   if(!SelectFitter(fit))AliWarning("Incorrect fitter assignment!");
 319   if(!SelectMinimizer(minimizer))AliWarning("Incorrect minimizer assignment!");
 320   if(misalignmentFile=="")printf("NO FAKE MISALIGNMENT INTRODUCED \n");
 321   else {
 322     Bool_t misal=Misalign(misalignmentFile,"ITSAlignObjs");
 323     if(!misal)return;
 324   }
 325
 326
 327   TStopwatch *timer=new TStopwatch();
 328   timer->Start();
 329   BuildIndex();
 330   count=0;
 331   UShort_t volid;
 332
 333   if(startingfile=="")printf("Starting from default geometry \n");
 334   else {
 335     printf("Starting from AlignObjs file: %s",startingfile.Data());
 336     ReadAlignObjs(startingfile.Data(),"ITSAlignObjs");
 337   }
 338
 339   for(Int_t iter=0;iter<iterations;iter++){
 340     if(covUsed)SetCovIsUsed(kTRUE);
 341
 342
 343     //START HIERARCHY REALIGNMENT
 344
 345     if(layer==0&&(doGlobal==1||doGlobal==2)){
 346       for(Int_t siter=0;siter<5;siter++){
 347         fTrackFitter->SetMinNPoints(2);
 348         SetCovUpdate(kFALSE);
 349         AlignSPDHalfBarrelToSectorRef(referSect,3);
 350         //      AlignSPDBarrel(1);
 351         //      if(siter==0)SetCovUpdate(kFALSE);
 352         //      AlignSPDHalfBarrel(0,3);
 353         //      SetCovUpdate(kTRUE);
 354         AlignSPDHalfBarrelToHalfBarrel(1,3);
 355         //      AlignSPDHalfBarrelToSectorRef(referSect,3);
 356         for(Int_t sector=0;sector<10;sector++){
 357           SetMinNtracks(100);
 358           if(sector==referSect)continue;
 359           AlignSPDSectorWithSectors(sector,1);
 360         }
 361
 362
 363         for(Int_t lay=1;lay<=6;lay++){
 364           if(!AlignLayerToSector(lay,referSect,3))AlignLayerToSPDHalfBarrel(lay,0,3);
 365         }
 366         AlignSPDHalfBarrel(0,3);
 367
 368         Int_t layers[6]={2,2,1,0,0,0};
 369         fTrackFitter->SetMinNPoints(4);
 370         AlignLayersToLayers(layers,1);
 371
 372         fTrackFitter->SetMinNPoints(6);
 373         layers[2]=2;
 374         layers[3]=1;//{2,2,2,1,0,0};
 375         AlignLayersToLayers(layers,1);
 376
 377         fTrackFitter->SetMinNPoints(6);
 378         layers[3]=2;
 379         layers[4]=1;//{2,2,2,2,1,0};
 380         AlignLayersToLayers(layers,1);
 381
 382         fTrackFitter->SetMinNPoints(6);
 383         layers[4]=2;
 384         layers[5]=1;//{2,2,2,2,2,1};
 385         AlignLayersToLayers(layers,1);
 386
 387
 388         for(Int_t sector=0;sector<10;sector++){
 389           AlignSPDSectorToOuterLayers(sector,1);
 390         }
 391         WriteRealignObjArray("AfterGlobal.root",AliGeomManager::kSPD1,AliGeomManager::kSSD2);
 392       }
 393     }
 394
 395     if(doGlobal==2)return;
 396
 397     if(covUsed)SetCovUpdate(kTRUE);
 398     SetMinNtracks(1);
 399
 400
 401     // STARTS INDEPENDENT MOULES REALIGNMENT
 402
 403     fTrackFitter->SetMinNPoints(minTrackPoint);
 404     for(iLayerToAlign=(Int_t)AliGeomManager::kSPD1;iLayerToAlign<=(Int_t)AliGeomManager::kSSD2;iLayerToAlign++){
 405       if(layer!=0&&iLayerToAlign!=layer)continue;
 406       count=0;
 407       size=0;
 408       for(Int_t k=(Int_t)AliGeomManager::kSPD1;k<=(Int_t)AliGeomManager::kSSD2;k++){
 409         size+=AliGeomManager::LayerSize(k);
 410         printf("size: %d \n",size);
 411       }
 412
 413       for (Int_t iModule=0;iModule<AliGeomManager::LayerSize(iLayerToAlign);iModule++){
 414         count=0;
 415         if(minNtracks<0){
 416           if(GetLastIndex(iLayerToAlign-(Int_t)AliGeomManager::kFirstLayer,iModule)<minNumPoint[iLayerToAlign-(Int_t)AliGeomManager::kFirstLayer]*(-1*minNtracks/fact))continue;
 417         }
 418         else if(GetLastIndex(iLayerToAlign-(Int_t)AliGeomManager::kFirstLayer,iModule)<minNtracks)continue;
 419
 420         UShort_t volidAl = AliGeomManager::LayerToVolUID(iLayerToAlign,iModule);
 421
 422         volIDsFit.Reset(0);
 423         volIDsFit.Set(size-1);
 424         for (iLayer=(Int_t)AliGeomManager::kSPD1;iLayer<(Int_t)AliGeomManager::kTPC1;iLayer++){
 425           for (Int_t iModule2=0;iModule2<AliGeomManager::LayerSize(iLayer);iModule2++){
 426
 427
 428             volid = AliGeomManager::LayerToVolUID(iLayer,iModule2);
 429
 430             if(AliGeomManager::LayerToVolUID(iLayer,iModule2)==volidAl)continue;
 431             volIDsFit.AddAt(volid,count);
 432             count++;
 433           }
 434         }
 435
 436         volIDs.AddAt((Int_t)volidAl,0);
 437         if(iter==iterations-1){
 438           volIDs2.AddAt(volidAl,lastVolid);
 439           lastVolid++;
 440         }
 441         volIDs2.AddAt(volidAl,lastVolid);
 442         AlignVolumesITS(&volIDs,&volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSSD2,iter1);
 443       }
 444     }
 445
 446     if((iter+1)%2==0||(iter+1)%5==0||iter==0||iter==1||iter==2||iter==3||iter==iterations-1){
 447       command="RealignObj";
 448       command+=(iter+1);
 449       command.Append(".root");
 450       WriteRealignObjArray(command.Data(),AliGeomManager::kSPD1,AliGeomManager::kSSD2);
 451     }
 452
 453   }
 454
 455   if(count==0){printf("count=0 \n");return;}
 456   for(Int_t k=0;k<volIDs2.GetSize();k++){
 457     if(volIDs2.At(k)==0)break;
 458     layerNum=AliGeomManager::VolUIDToLayer(volIDs2.At(k),modNum);
 459     ntVolumeAlign->Fill(layerNum,modNum,volIDs2.At(k));
 460   }
 461   printf("End of selecting modules cycle: %d modules selected \n",count);
 462   TFile *f=new TFile("RealignVolNt.root","RECREATE");
 463   f->cd();
 464   ntVolumeAlign->Write();
 465   f->Close();
 466
 467   timer->Stop();
 468   timer->Print();
 469   return;
 470
 471 }
 472
 473
 474 //______________________________________________________________________________
 475 void AliITSRealignTracks::InitAlignObjs()
 476 {
 477   // Initialize the alignment objects array
 478   TMatrixDSym c(6);
 479   Double_t cov[21];
 480   for(Int_t i=0;i<21;i++)cov[i]=0.;
 481   for(Int_t i=0;i<3;i++)cov[i*(i+1)/2+i]=0.05*0.05;//Set Default Error to 500 micron for Translations
 482   for(Int_t i=3;i<6;i++)cov[i*(i+1)/2+i]=0.001*0.001*180*180/3.14/3.14;//and 1 mrad for rotations (global ref. sysytem->~40 micron for SPD1,~450 micron for SSD2)
 483
 484   Int_t nLayers = AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer;
 485   fAlignObjs = new AliAlignObj**[nLayers];
 486   for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) {
 487     fAlignObjs[iLayer] = new AliAlignObj*[AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer)];
 488     for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) {
 489       UShort_t volid = AliGeomManager::LayerToVolUID(iLayer+ AliGeomManager::kFirstLayer,iModule);
 490       fAlignObjs[iLayer][iModule] = new AliAlignObjParams(AliGeomManager::SymName(volid),volid,0,0,0,0,0,0,kTRUE);
 491       fAlignObjs[iLayer][iModule]->SetCorrMatrix(cov);
 492       fAlignObjs[iLayer][iModule]->SetUniqueID(0);
 493     }
 494   }
 495 }
 496
 497 //______________________________________________________________________________
 498 Bool_t AliITSRealignTracks::InitSurveyObjs(Bool_t infinite,Double_t factor,Bool_t fromfile,TString filename,TString arrayName){
 499
 500   if(filename!=""){
 501     //Initialize from file
 502     if(gSystem->AccessPathName(filename.Data(),kFileExists)){
 503       printf("Wrong Survey AlignObjs File Name \n");
 504       return kFALSE;
 505     }
 506
 507   TFile *surveyObj=TFile::Open(filename.Data());
 508   if (!surveyObj || !surveyObj->IsOpen()) {
 509     AliError(Form("Could not open SurveyObjs file: file %s !",filename.Data()));
 510     return kFALSE;
 511   }
 512   printf("Getting TClonesArray \n");
 513   TClonesArray *clnarray=(TClonesArray*)surveyObj->Get(arrayName);
 514   Int_t size=clnarray->GetSize();
 515   UShort_t volid;
 516   for(Int_t ivol=0;ivol<size;ivol++){
 517     AliAlignObjParams *a=(AliAlignObjParams*)clnarray->At(ivol);
 518     volid=a->GetVolUID();
 519     Int_t iModule;
 520     AliGeomManager::ELayerID iLayer = AliGeomManager::VolUIDToLayer(volid,iModule);
 521     printf("Updating volume: %d ,layer: %d module: %d \n",volid,iLayer,iModule);
 522     *fSurveyObjs[iLayer-AliGeomManager::kFirstLayer][iModule] *= *a;
 523   }
 524
 525   delete clnarray;
 526   surveyObj->Close();
 527   return kTRUE;
 528   }
 529
 530   // Initialize the alignment objects array with default values
 531   Double_t v=1.*factor;
 532   if(infinite)v*=100000.;
 533   TMatrixDSym c(6);
 534   Double_t cov[21];
 535   for(Int_t i=0;i<21;i++)cov[i]=0.;
 536   for(Int_t i=0;i<3;i++)cov[i*(i+1)/2+i]=0.1*0.1*v;//Set Default Error to 1 mm  for Translation
 537   for(Int_t i=3;i<6;i++)cov[i*(i+1)/2+i]=0.01*0.01*180.*180./3.14/3.14*v;//and 10 mrad (~0.5 degrees)for rotations (global ref. sysytem)
 538   Int_t nLayers = AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer;
 539   fSurveyObjs = new AliAlignObj**[nLayers];
 540   for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) {
 541     fSurveyObjs[iLayer] = new AliAlignObj*[AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer)];
 542     for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) {
 543       UShort_t volid = AliGeomManager::LayerToVolUID(iLayer+ AliGeomManager::kFirstLayer,iModule);
 544       if(!fromfile){
 545         fSurveyObjs[iLayer][iModule] = new AliAlignObjParams(AliGeomManager::SymName(volid),volid,0,0,0,0,0,0,kTRUE);
 546         fSurveyObjs[iLayer][iModule]->SetCorrMatrix(cov);
 547         fSurveyObjs[iLayer][iModule]->SetUniqueID(0);
 548       }
 549     }
 550   }
 551   return kTRUE;
 552 }
 553
 554
 555 //______________________________________________________________________________
 556 void AliITSRealignTracks::ResetAlignObjs()
 557 {
 558   // Reset the alignment objects array
 559   for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) {
 560     for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++)
 561       fAlignObjs[iLayer][iModule]->SetPars(0,0,0,0,0,0);
 562   }
 563 }
 564
 565 //______________________________________________-
 566 void AliITSRealignTracks::DeleteSurveyObjs()
 567 {
 568   // Delete the alignment objects array
 569   for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) {
 570     for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++)
 571       if (fSurveyObjs[iLayer][iModule])
 572         delete fSurveyObjs[iLayer][iModule];
 573     delete [] fSurveyObjs[iLayer];
 574   }
 575   delete [] fSurveyObjs;
 576   fSurveyObjs = 0;
 577 }
 578
 579
 580 //______________________________________________________________________________
 581 Bool_t AliITSRealignTracks::ReadAlignObjs(const char *alignObjFileName, const char* arrayName){
 582
 583   // Read alignment object from a file: update the alignobj already present with the one in the file
 584   // To be replaced by a call to CDB
 585
 586   if(gSystem->AccessPathName(alignObjFileName,kFileExists)){
 587     printf("Wrong AlignObjs File Name \n");
 588     return kFALSE;
 589   }
 590
 591   TFile *fRealign=TFile::Open(alignObjFileName);
 592   if (!fRealign || !fRealign->IsOpen()) {
 593     AliError(Form("Could not open Align Obj File file %s !",alignObjFileName));
 594     return kFALSE;
 595   }
 596   printf("Getting TClonesArray \n");
 597   TClonesArray *clnarray=(TClonesArray*)fRealign->Get(arrayName);
 598   Int_t size=clnarray->GetSize();
 599   UShort_t volid;
 600
 601   for(Int_t ivol=0;ivol<size;ivol++){
 602     AliAlignObjParams *a=(AliAlignObjParams*)clnarray->At(ivol);
 603     volid=a->GetVolUID();
 604     Int_t iModule;
 605     AliGeomManager::ELayerID iLayer = AliGeomManager::VolUIDToLayer(volid,iModule);
 606     if(iLayer<AliGeomManager::kFirstLayer||iLayer>AliGeomManager::kSSD2)continue;
 607     printf("Updating volume: %d ,layer: %d module: %d \n",volid,iLayer,iModule);
 608     *fAlignObjs[iLayer-AliGeomManager::kFirstLayer][iModule] *= *a;
 609   }
 610
 611   delete clnarray;
 612   fRealign->Close();
 613   return kTRUE;
 614 }
 615
 616 //_________________________________________
 617 Bool_t AliITSRealignTracks::FirstAlignmentLayers(Bool_t *layers,Int_t minNtracks,Int_t iterations,TArrayI *volidsSet){
 618
 619   //Align all modules in the set of layers independently according to a sequence based on the number of tracks passing through a given module
 620
 621   BuildIndex();
 622
 623   UShort_t voluid;
 624   Int_t **lastIndex;
 625   Int_t laymax = 0;
 626   Int_t modmax = 0;
 627   Int_t maxntr=0,nMod=0;
 628   Int_t size=0;
 629   for(Int_t i=0;i<6;i++){
 630     if(layers[i]==1)size+=AliGeomManager::LayerSize(i+AliGeomManager::kFirstLayer);
 631   }
 632   TArrayI *volFit3;
 633   TArrayI *volFit=new TArrayI(size);
 634   TArrayI *volFit2=new TArrayI(size-1);
 635   TArrayI *sequence=new TArrayI(size);
 636   TArrayI *volIn=new TArrayI(1);
 637
 638   // Initialize the index arrays
 639   Int_t nLayers = AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer;
 640   lastIndex = new Int_t*[nLayers];
 641   for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) {
 642     lastIndex[iLayer] = new Int_t[AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer)];
 643     for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) {
 644       lastIndex[iLayer][iModule] =  fLastIndex[iLayer][iModule];
 645       if(layers[iLayer]==1){
 646         volFit->AddAt(AliGeomManager::LayerToVolUID(iLayer+AliGeomManager::kFirstLayer,iModule),maxntr);
 647         maxntr++;
 648       }
 649     }
 650   }
 651   Int_t found=0;
 652
 653   while (maxntr>minNtracks){
 654     maxntr=minNtracks;
 655     for (Int_t iLayer = 0; iLayer <= (AliGeomManager::kSSD2 - AliGeomManager::kFirstLayer); iLayer++) {
 656       if(layers[iLayer]==0)continue;
 657       for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) {
 658         if(lastIndex[iLayer][iModule]>maxntr){
 659           maxntr=lastIndex[iLayer][iModule];
 660           laymax=iLayer;
 661           modmax=iModule;
 662         }
 663       }
 664     }
 665     if(maxntr>minNtracks){
 666       voluid=AliGeomManager::LayerToVolUID(laymax+AliGeomManager::kFirstLayer,modmax);
 667       sequence->AddAt(voluid,nMod);
 668       lastIndex[laymax][modmax]=0;
 669       nMod++;
 670     }
 671   }
 672
 673   Int_t ilayer,imod;
 674   for(Int_t iter=0;iter<iterations;iter++){
 675     for(Int_t k=0;k<nMod;k++){
 676       voluid=sequence->At(k);
 677       ilayer=AliGeomManager::VolUIDToLayer(voluid,imod);
 678       volIn->AddAt(voluid,0);
 679       found=0;
 680       for(Int_t j=0;j<volFit->GetSize();j++){
 681         if(volFit->At(j)!=volIn->At(0))volFit2->AddAt(volFit->At(j),j-found);
 682         else found=1;
 683       }
 684
 685       if(volidsSet){
 686         volFit3=IntersectVolArray(volidsSet,volFit2);
 687       }
 688       else volFit3=volFit2;
 689       AlignVolumesITS(volIn,volFit3,AliGeomManager::kSPD1,AliGeomManager::kSDD1,2);
 690     }
 691   }
 692   return kTRUE;
 693 }
 694
 695 //__________________________________________
 696 Bool_t AliITSRealignTracks::FirstAlignmentSPD(Int_t minNtracks,Int_t iterations,TArrayI *volidsSet){
 697
 698   BuildIndex();
 699
 700   UShort_t voluid;
 701   Int_t **lastIndex;
 702   Int_t laymax = 0;
 703   Int_t modmax = 0;
 704   Int_t maxntr=0,nMod=0;
 705   TArrayI *volFit=new TArrayI(AliGeomManager::LayerSize(1)+AliGeomManager::LayerSize(2));
 706   TArrayI *volFit2=new TArrayI(AliGeomManager::LayerSize(1)+AliGeomManager::LayerSize(2)-1);
 707   TArrayI *sequence=new TArrayI(AliGeomManager::LayerSize(1)+AliGeomManager::LayerSize(2));
 708   TArrayI *volIn=new TArrayI(1);
 709
 710   // Initialize the index arrays
 711   Int_t nLayers = AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer;
 712   lastIndex = new Int_t*[nLayers];
 713   for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) {
 714     lastIndex[iLayer] = new Int_t[AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer)];
 715     for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) {
 716       lastIndex[iLayer][iModule] =  fLastIndex[iLayer][iModule];
 717       if(iLayer+AliGeomManager::kFirstLayer<=AliGeomManager::kSPD2){
 718         volFit->AddAt(AliGeomManager::LayerToVolUID(iLayer+AliGeomManager::kFirstLayer,iModule),maxntr);
 719         maxntr++;
 720       }
 721     }
 722   }
 723   Int_t found=0;
 724
 725   while (maxntr>minNtracks){
 726     maxntr=minNtracks;
 727     for (Int_t iLayer = 0; iLayer <= (AliGeomManager::kSPD2 - AliGeomManager::kFirstLayer); iLayer++) {
 728       for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) {
 729         if(lastIndex[iLayer][iModule]>maxntr){
 730           laymax=iLayer;
 731           modmax=iModule;
 732           maxntr=lastIndex[iLayer][iModule];
 733         }
 734       }
 735     }
 736     if(maxntr>minNtracks){
 737       voluid=AliGeomManager::LayerToVolUID(laymax+AliGeomManager::kFirstLayer,modmax);
 738       sequence->AddAt(voluid,nMod);
 739       lastIndex[laymax][modmax]=0;
 740       nMod++;
 741       volIn->AddAt(voluid,0);
 742     }
 743   }
 744
 745   TArrayI *volFit3;
 746   Int_t ilayer,imod;
 747   for(Int_t iter=0;iter<iterations;iter++){
 748     for(Int_t k=0;k<nMod;k++){
 749       voluid=sequence->At(k);
 750       ilayer=AliGeomManager::VolUIDToLayer(voluid,imod);
 751       volIn->AddAt(voluid,0);
 752       found=0;
 753       for(Int_t j=0;j<volFit->GetSize();j++){
 754         if(volFit->At(j)!=volIn->At(0))volFit2->AddAt(volFit->At(j),j-found);
 755         else found=1;
 756       }
 757
 758       if(volidsSet){
 759         volFit3=IntersectVolArray(volidsSet,volFit2);
 760       }
 761       else volFit3=volFit2;
 762
 763       AlignVolumesITS(volIn,volFit3,AliGeomManager::kSPD1,AliGeomManager::kSDD1,2);
 764     }
 765   }
 766   return kTRUE;
 767 }
 768
 769
 770 //__________________________________
 771 Bool_t AliITSRealignTracks::SPDmodulesAlignToSSD(Int_t minNtracks,Int_t iterations){
 772
 773   Int_t volSSD[6]={0,0,0,0,1,1};
 774   TArrayI *volOuter=GetLayersVolUID(volSSD);
 775   TArrayI *voluid=new TArrayI(1);
 776   for(Int_t iter=0;iter<iterations;iter++){
 777     //SPD1
 778     for(Int_t imod=0;imod<AliGeomManager::LayerSize(AliGeomManager::kSPD1);imod++){    if(GetLastIndex(AliGeomManager::kSPD1-AliGeomManager::kFirstLayer,imod)<minNtracks){
 779       printf("Not enough tracks for module: lay %d mod %d \n",1,imod );
 780       continue;
 781     }
 782     voluid->AddAt(AliGeomManager::LayerToVolUID(AliGeomManager::kSPD1,imod),0);
 783     AlignVolumesITS(voluid,volOuter,AliGeomManager::kSSD1,AliGeomManager::kSSD2,2);
 784     }
 785     //SPD2
 786     for(Int_t imod=0;imod<AliGeomManager::LayerSize(AliGeomManager::kSPD2);imod++){
 787       if(GetLastIndex(AliGeomManager::kSPD2-AliGeomManager::kFirstLayer,imod)<minNtracks){
 788         printf("Not enough tracks for module: lay %d mod %d \n",2,imod );
 789         continue;
 790       }
 791       voluid->AddAt(AliGeomManager::LayerToVolUID(AliGeomManager::kSPD2,imod),0);
 792       AlignVolumesITS(voluid,volOuter,AliGeomManager::kSSD1,AliGeomManager::kSSD2,2);
 793     }
 794   }
 795   return kTRUE;
 796 }
 797
 798 //______________________________________________________________________________
 799 Bool_t AliITSRealignTracks::AlignVolumesITS(const TArrayI *volids, const TArrayI *volidsfit,
 800                                      AliGeomManager::ELayerID layerRangeMin,
 801                                      AliGeomManager::ELayerID layerRangeMax,
 802                                      Int_t iterations){
 803
 804   // Align a set of detector volumes.
 805   // Tracks are fitted only within
 806   // the range defined by the user
 807   // (by layerRangeMin and layerRangeMax)
 808   // or within the set of volidsfit
 809   // Repeat the procedure 'iterations' times
 810
 811   Int_t nVolIds = volids->GetSize();
 812   if (nVolIds == 0) {
 813     AliError("Volume IDs array is empty!");
 814     return kFALSE;
 815   }
 816
 817   Double_t surveycov[21],transl[3],rot[3];
 818
 819   // Load only the tracks with at least one
 820   // space point in the set of volume (volids)
 821   BuildIndex();
 822   AliTrackPointArray **points;
 823   Bool_t failed=kFALSE;
 824   // Start the iterations
 825   while (iterations > 0) {
 826     Int_t nArrays = LoadPoints(volids, points);
 827     if (nArrays < fmintracks) {
 828       failed=kTRUE;
 829       printf("Not enough tracks to try minimization \n");
 830       UnloadPoints(nArrays, points);
 831       break;
 832     }
 833
 834     AliTrackResiduals *minimizer = CreateMinimizer();
 835     minimizer->SetNTracks(nArrays);
 836     minimizer->InitAlignObj();
 837     AliTrackFitter *fitter = CreateFitter();
 838     for (Int_t iArray = 0; iArray < nArrays; iArray++) {
 839       if (!points[iArray]) continue;
 840       fitter->SetTrackPointArray(points[iArray], kTRUE);
 841       if (fitter->Fit(volids,volidsfit,layerRangeMin,layerRangeMax) == kFALSE) continue;
 842       AliTrackPointArray *pVolId,*pTrack;
 843       fitter->GetTrackResiduals(pVolId,pTrack);
 844       minimizer->AddTrackPointArrays(pVolId,pTrack);
 845     }
 846     if(minimizer->GetNFilledTracks()<=fmintracks){
 847       printf("No good tracks found: could not find parameter for volume %d (and following in volids)\n",volids->At(0));
 848       UnloadPoints(nArrays, points);
 849       failed=kTRUE;
 850       break;
 851     }
 852     failed=(!minimizer->Minimize());
 853
 854     // Update the alignment object(s)
 855     if (fDoUpdate) for (Int_t iVolId = 0; iVolId < nVolIds; iVolId++) {
 856       UShort_t volid = (*volids)[iVolId];
 857       Int_t iModule;
 858       AliGeomManager::ELayerID iLayer = AliGeomManager::VolUIDToLayer(volid,iModule);
 859
 860       AliAlignObj *alignObj = fAlignObjs[iLayer-AliGeomManager::kFirstLayer][iModule];
 861       AliAlignObj *alignObjSurv = fSurveyObjs[iLayer-AliGeomManager::kFirstLayer][iModule];
 862
 863       if(!failed){
 864         if(fUpdateCov)*alignObj *= *minimizer->GetAlignObj();
 865         else{
 866           TMatrixDSym covmatrx(6);
 867           alignObj->GetCovMatrix(covmatrx);
 868           *alignObj *= *minimizer->GetAlignObj();
 869           alignObj->SetCorrMatrix(covmatrx);
 870           alignObj->SetUniqueID(1);
 871         }
 872         alignObjSurv->GetCovMatrix(surveycov);
 873         alignObj->GetPars(transl,rot);
 874
 875         if(TMath::Sqrt(TMath::Abs(surveycov[0]))*2<TMath::Abs(transl[0])||TMath::Sqrt(TMath::Abs(surveycov[2]))*2<TMath::Abs(transl[1])||TMath::Sqrt(TMath::Abs(surveycov[5]))*2<TMath::Abs(transl[2])||TMath::Sqrt(TMath::Abs(surveycov[9]))*2<TMath::Abs(rot[0])||TMath::Sqrt(TMath::Abs(surveycov[14]))*2<TMath::Abs(rot[1])||TMath::Sqrt(TMath::Abs(surveycov[20]))*2<TMath::Abs(rot[2])){
 876           printf("Results for module %d out of Survey: reinitializing it from survey \n",volid);
 877           //      *alignObj = *alignObjSurv;
 878           alignObj->SetPars(0.,0.,0.,0.,0.,0.);
 879           alignObj->SetUniqueID(0);
 880           if(fUpdateCov)alignObj->SetCorrMatrix(surveycov);
 881           if(iterations==1){
 882             failed=kTRUE;
 883             UnloadPoints(nArrays, points);
 884             break;
 885           }
 886         }
 887       }
 888       else {
 889         printf("Minimization failed: cannot update AlignObj for volume: %d \n",volid);
 890         UnloadPoints(nArrays, points);
 891         break;
 892       }
 893       if(iterations==1)alignObj->Print("");
 894     }
 895
 896     UnloadPoints(nArrays, points);
 897     iterations--;
 898   }
 899   return (!failed);
 900 }
 901
 902
 903
 904 //______________________________________________
 905 Bool_t AliITSRealignTracks::AlignSPDBarrel(Int_t iterations){
 906
 907   Int_t size=0,size2=0;
 908   Int_t layers[6]={1,1,0,0,0,0};
 909   for(Int_t k=1;k<=2;k++){
 910     size+=AliGeomManager::LayerSize(k);
 911   }
 912   for(Int_t k=3;k<=6;k++){
 913     size2+=AliGeomManager::LayerSize(k);
 914     printf("size: %d \n",size2);
 915   }
 916
 917   printf("Aligning SPDBarrel: nmodules: %d \n",size);
 918   printf("Fitting modules: %d \n",size2);
 919
 920   TArrayI *volIDs=GetLayersVolUID(layers);
 921   layers[0]=0;
 922   layers[1]=0;
 923   layers[2]=1;
 924   layers[3]=1;
 925   layers[4]=1;
 926   layers[5]=1;
 927   TArrayI *volIDsFit=GetLayersVolUID(layers);
 928
 929   AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSDD1,AliGeomManager::kTPC1,iterations);
 930
 931   return kTRUE;
 932 }
 933
 934 //______________________
 935 Bool_t AliITSRealignTracks::AlignSPDHalfBarrel(Int_t method,Int_t iterations){
 936
 937   Int_t size=0,size2=0;
 938   Int_t layers[6]={0,0,1,1,1,1};
 939   Int_t sectorsUp[10]={1,1,1,1,1,0,0,0,0,0};
 940   Int_t sectorsDown[10]={0,0,0,0,0,1,1,1,1,1};
 941
 942   TString updownstr;
 943   if(method==0)updownstr="UpNoDown";
 944   else if (method==1)updownstr="DownNoUp";
 945   else if (method==10)updownstr="UpWithDown";
 946   else if (method==11)updownstr="DownWithUp";
 947   else {
 948     AliWarning("Wrong AlignSPDHalfBarrel method selected ");
 949     return kFALSE;
 950   }
 951
 952   for(Int_t i=1;i<=2;i++){
 953     size+=AliGeomManager::LayerSize(i);
 954   }
 955
 956   for(Int_t i=3;i<=6;i++){
 957     size2+=AliGeomManager::LayerSize(i);
 958   }
 959
 960   size=size/2;
 961   if(method==10||method==11)size2+=size;
 962
 963   printf("Aligning  SPDHalfBarrel %s: nmodules: %d \n",updownstr.Data(),size);
 964   printf("Fitting modules: %d \n",size2);
 965   TArrayI *volIDsFit2;
 966   TArrayI *volids = NULL;
 967   TArrayI *volIDsFit=GetLayersVolUID(layers);
 968   if(method==0||method==10)volids=GetSPDSectorsVolids(sectorsUp);
 969   if(method==1||method==11)volids=GetSPDSectorsVolids(sectorsDown);
 970
 971   if(method==10)volIDsFit2=JoinVolArrays(GetSPDSectorsVolids(sectorsDown),volIDsFit);
 972   else if(method==11)volIDsFit2=JoinVolArrays(GetSPDSectorsVolids(sectorsUp),volIDsFit);
 973   else volIDsFit2=volIDsFit;
 974
 975   AlignVolumesITS(volids,volIDsFit2,AliGeomManager::kSPD1,AliGeomManager::kSSD2,iterations);
 976
 977   return kTRUE;
 978 }
 979
 980
 981 //______________________________________________________
 982 Bool_t AliITSRealignTracks::AlignLayer(Int_t layer,Int_t iterations){
 983
 984   Int_t size=0,size2=0;
 985   Int_t layers[6]={0,0,0,0,0,0};
 986   layers[layer-1]=1;
 987   TString layerstr[6]={"SPD1","SPD2","SDD1","SDD2","SSD1","SSD2"};
 988   for(Int_t k=1;k<=6;k++){
 989     if(k!=layer)size2+=AliGeomManager::LayerSize(k);
 990   }
 991   size=AliGeomManager::LayerSize(layer);
 992
 993   printf("Aligning layer %s, nmodules %d ,fitted modules %d \n",layerstr[layer-1].Data(),size,size2);
 994
 995
 996   TArrayI *volIDs=GetLayersVolUID(layers);
 997   layers[0]=1;
 998   layers[1]=1;
 999   layers[2]=1;
1000   layers[3]=1;
1001   layers[4]=1;
1002   layers[5]=1;
1003   layers[layer]=0;
1004   TArrayI *volIDsFit=GetLayersVolUID(layers);
1005
1006   AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSDD1,AliGeomManager::kSSD2,iterations);
1007
1008   return kTRUE;
1009 }
1010
1011 //___________________________________________
1012
1013 Bool_t AliITSRealignTracks::AlignLayersToLayers(Int_t *layer,Int_t iterations){
1014
1015   UShort_t volid;
1016   Int_t size=0,size2=0,j=0,k=0;
1017   Int_t iLayer;
1018   TString layerstr[6]={"SPD1","SPD2","SDD1","SDD2","SSD1","SSD2"};
1019   TString command="",str;
1020   for(Int_t i=1;i<=6;i++){
1021     if(layer[i-1]==1||layer[i-1]==3){
1022       size+=AliGeomManager::LayerSize(i);
1023       command.Append(" ");
1024       command.Append(layerstr[i-1]);
1025     }
1026     if(layer[i-1]==2||layer[i-1]==3){
1027       size2+=AliGeomManager::LayerSize(i);
1028       str.Append(" ");
1029       str.Append(layerstr[i-1]);
1030     }
1031   }
1032
1033   printf("Aligning layers %s To layers %s, nmodules %d ,fitted modules %d \n",command.Data(),str.Data(),size,size2);
1034
1035
1036   TArrayI volIDs(size);
1037   TArrayI volIDsFit(size2);
1038
1039   for (iLayer=(Int_t)AliGeomManager::kSPD1;iLayer<(Int_t)AliGeomManager::kTPC1;iLayer++){
1040     if(layer[iLayer-AliGeomManager::kFirstLayer]==0)continue;
1041     if(layer[iLayer-AliGeomManager::kFirstLayer]==1){
1042       for (Int_t iModule2=0;iModule2<AliGeomManager::LayerSize(iLayer);iModule2++){
1043         volid = AliGeomManager::LayerToVolUID(iLayer,iModule2);
1044         volIDs.AddAt(volid,j);
1045         j++;
1046       }
1047     }
1048     else if(layer[iLayer-AliGeomManager::kFirstLayer]==2){
1049       for (Int_t iModule2=0;iModule2<AliGeomManager::LayerSize(iLayer);iModule2++){
1050         volid = AliGeomManager::LayerToVolUID(iLayer,iModule2);
1051         volIDsFit.AddAt(volid,k);
1052         k++;
1053       }
1054     }
1055     else if(layer[iLayer-AliGeomManager::kFirstLayer]==3){
1056       for (Int_t iModule2=0;iModule2<AliGeomManager::LayerSize(iLayer);iModule2++){
1057         volid = AliGeomManager::LayerToVolUID(iLayer,iModule2);
1058         volIDs.AddAt(volid,j);
1059         j++;
1060         volIDsFit.AddAt(volid,k);
1061         k++;
1062       }
1063     }
1064   }
1065
1066   AlignVolumesITS(&volIDs,&volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSSD2,iterations);
1067
1068   return kTRUE;
1069 }
1070
1071 //______________________________________________
1072
1073 Bool_t AliITSRealignTracks::AlignSPDSectorToOuterLayers(Int_t sector,Int_t iterations){
1074
1075
1076   Int_t layers[6]={0,0,1,1,1,1};
1077   Bool_t spd=kFALSE;
1078   Int_t sectorsIN[10]={0,0,0,0,0,0,0,0,0,0};
1079   Int_t sectorsFit[10]={1,1,1,1,1,1,1,1,1,1};
1080
1081   if(sector<0){
1082     sector=-sector;
1083     spd=kTRUE;
1084   }
1085   sectorsIN[sector]=1;
1086   sectorsFit[sector]=0;
1087   TArrayI *volIDs=GetSPDSectorsVolids(sectorsIN);
1088   TArrayI *volIDsFit;
1089   if(spd){
1090     volIDsFit=JoinVolArrays(GetSPDSectorsVolids(sectorsFit),GetLayersVolUID(layers));
1091   }
1092   else volIDsFit=GetLayersVolUID(layers);
1093
1094   printf("Aligning SPD sector %d: nmodules: %d \n",sector,volIDs->GetSize());
1095   printf("Fitting modules: %d \n",volIDsFit->GetSize());
1096
1097   AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSPD2,iterations);
1098
1099   return kTRUE;
1100 }
1101
1102 //______________________________________________
1103 Bool_t AliITSRealignTracks::AlignSPDSectorWithSectors(Int_t sector,Int_t iterations){
1104
1105
1106   Int_t sectorsIN[10]={0,0,0,0,0,0,0,0,0,0};
1107   Int_t sectorsFit[10]={1,1,1,1,1,1,1,1,1,1};
1108
1109   sectorsIN[sector]=1;
1110   sectorsFit[sector]=0;
1111   TArrayI *volIDs=GetSPDSectorsVolids(sectorsIN);
1112   TArrayI *volIDsFit=GetSPDSectorsVolids(sectorsFit);;
1113
1114   printf("Aligning SPD sector %d: nmodules: %d \n",sector,volIDs->GetSize());
1115   printf("Fitting modules: %d \n",volIDsFit->GetSize());
1116
1117
1118   AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSDD1,iterations);
1119
1120   return kTRUE;
1121 }
1122
1123
1124
1125 //___________________________________________________
1126 Bool_t AliITSRealignTracks::AlignSPDSectorsWithSectors(Int_t *sectorsIN,Int_t *sectorsFit,Int_t iterations){
1127
1128   TArrayI *volIDs=GetSPDSectorsVolids(sectorsIN);
1129   TArrayI *volIDsFit=GetSPDSectorsVolids(sectorsFit);;
1130
1131   printf("Aligning SPD sectors: modules: %d \n",volIDs->GetSize());
1132   printf("Fitting modules: %d \n",volIDsFit->GetSize());
1133
1134   AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSDD1,iterations);
1135
1136   return kTRUE;
1137 }
1138
1139
1140 //___________________________________________
1141
1142 Bool_t AliITSRealignTracks::AlignLayerToSPDHalfBarrel(Int_t layer,Int_t updown,Int_t iterations){
1143
1144
1145   Int_t sectorsDown[10]={0,0,0,0,0,1,1,1,1,1};
1146   Int_t sectorsUp[10]={1,1,1,1,1,0,0,0,0,0};
1147   TString layerstr[6]={"SPD1","SPD2","SDD1","SDD2","SSD1","SSD2"};
1148   TArrayI *volIDsFit;
1149   Int_t layers[6]={0,0,0,0,0,0};
1150   layers[layer]=1;
1151   Int_t size=AliGeomManager::LayerSize(layer);
1152   TArrayI *volIDs=GetLayersVolUID(layers);
1153
1154   if(updown==0){
1155     volIDsFit=GetSPDSectorsVolids(sectorsUp);
1156     printf("Aligning layer %s, nmodules %d ,to half barrel Up \n",layerstr[layer-1].Data(),size);
1157   }
1158   else if(updown==1){
1159     volIDsFit=GetSPDSectorsVolids(sectorsDown);
1160     printf("Aligning layer %s, nmodules %d ,to half barrel Down \n",layerstr[layer-1].Data(),size);
1161   }
1162   else {
1163     printf("Wrong Half Barrel selection! \n");
1164     return kFALSE;
1165   }
1166
1167   AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSSD2,iterations);
1168
1169   return kTRUE;
1170 }
1171
1172 //___________________________________________
1173
1174 Bool_t AliITSRealignTracks::AlignLayerToSector(Int_t layer,Int_t sector,Int_t iterations){
1175
1176   if(sector>9){
1177     printf("Wrong Sector selection! \n");
1178     return kFALSE;
1179   }
1180   Int_t sectors[10]={0,0,0,0,0,0,0,0,0,0};
1181   sectors[sector]=1;
1182   TString layerstr[6]={"SPD1","SPD2","SDD1","SDD2","SSD1","SSD2"};
1183   TArrayI *volIDsFit;
1184   Int_t layers[6]={0,0,0,0,0,0};
1185   layers[layer]=1;
1186   TArrayI *volIDs=GetLayersVolUID(layers);
1187   Int_t size=AliGeomManager::LayerSize(layer);
1188
1189
1190   volIDsFit=GetSPDSectorsVolids(sectors);
1191   printf("Aligning layer %s, nmodules %d ,to half barrel Up \n",layerstr[layer-1].Data(),size);
1192
1193   AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSSD2,iterations);
1194
1195   return kTRUE;
1196 }
1197
1198 //_______________________________________________
1199
1200 Bool_t AliITSRealignTracks::AlignSPDHalfBarrelToHalfBarrel(Int_t updown,Int_t iterations){
1201
1202
1203   Int_t sectorsDown[10]={0,0,0,0,0,1,1,1,1,1};
1204   Int_t sectorsUp[10]={1,1,1,1,1,0,0,0,0,0};
1205
1206   TArrayI *volIDsUp=GetSPDSectorsVolids(sectorsUp);
1207   TArrayI *volIDsDown=GetSPDSectorsVolids(sectorsDown);
1208
1209   if(updown==0){
1210     printf("Aligning SPD HalfBarrel up to half Barrel down : nmodules: %d \n",volIDsUp->GetSize());
1211     printf("Fitting modules: %d \n",volIDsDown->GetSize());
1212     AlignVolumesITS(volIDsUp,volIDsDown,AliGeomManager::kSPD1,AliGeomManager::kSPD2,iterations);
1213   }
1214   else if(updown==1){
1215     printf("Aligning SPD HalfBarrel down to half Barrel Up : nmodules: %d \n",volIDsDown->GetSize());
1216     printf("Fitting modules: %d \n",volIDsUp->GetSize());
1217     AlignVolumesITS(volIDsDown,volIDsUp,AliGeomManager::kSPD1,AliGeomManager::kSPD2,iterations);
1218   }
1219   else {
1220     printf("Wrong Half Barrel selection! \n");
1221     return kFALSE;
1222   }
1223
1224   return kTRUE;
1225 }
1226
1227
1228 //_______________________
1229 Bool_t AliITSRealignTracks::AlignSPDHalfBarrelToSectorRef(Int_t sector,Int_t iterations){
1230
1231   Int_t sectorsIN[10]={0,0,0,0,0,1,1,1,1,1};
1232   Int_t sectorsFit[10]={0,0,0,0,0,0,0,0,0,0};
1233
1234   sectorsFit[sector]=1;
1235
1236   TArrayI *volIDs=GetSPDSectorsVolids(sectorsIN);
1237   TArrayI *volIDsFit=GetSPDSectorsVolids(sectorsFit);
1238
1239   printf("Aligning SPD HalfBarrel to sector 0 %d: nmodules: %d \n",sector,volIDs->GetSize());
1240   printf("Fitting modules: %d \n",volIDsFit->GetSize());
1241
1242
1243   AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSPD2,iterations);
1244
1245
1246   return kTRUE;
1247 }
1248 //_________________________________________
1249 Bool_t AliITSRealignTracks::AlignSPD1SectorRef(Int_t sector,Int_t iterations){
1250
1251   Int_t sectorsIN[10]={0,0,0,0,0,0,0,0,0,0};
1252   Int_t sectorsFit[10]={1,1,1,1,1,1,1,1,1,1};
1253   sectorsIN[sector]=1;
1254   sectorsFit[sector]=0;
1255   TArrayI *volIDs=GetSPDSectorsVolids(sectorsIN);
1256   TArrayI *volIDsFit=GetSPDSectorsVolids(sectorsFit);
1257   Int_t size=volIDs->GetSize();
1258   Int_t size2=volIDsFit->GetSize();
1259   UShort_t volID;
1260   Int_t k=0;
1261
1262   TArrayI *volIDsSPD1=new TArrayI(size-8);
1263   TArrayI *volIDsFit2=new TArrayI(size2+8);
1264
1265   for(Int_t j=0;j<size;j++){
1266     volID=volIDs->At(j);
1267     if(AliGeomManager::VolUIDToLayer(volID)==AliGeomManager::kSPD1){
1268       volIDsSPD1->AddAt(volID,size2+k);
1269       k++;
1270     }
1271     else volIDsFit2->AddAt(volID,j-k);
1272   }
1273
1274
1275   for(Int_t j=0;j<size2;j++){
1276     volID=volIDsFit->At(j);
1277     volIDsFit2->AddAt(volID,size-k+j);
1278   }
1279
1280   printf("Aligning SPD Sector %d: nmodules: %d \n",sector,volIDsSPD1->GetSize());
1281   printf("Fitting modules: %d \n",volIDsFit2->GetSize());
1282
1283   AlignVolumesITS(volIDsSPD1,volIDsFit2,AliGeomManager::kSPD1,AliGeomManager::kSPD2,iterations);
1284
1285   return kTRUE;
1286 }
1287
1288 //_____________________________________________
1289
1290 AliAlignObjParams* AliITSRealignTracks::MediateAlignObj(TArrayI *volIDs,Int_t lastVolid){
1291   UShort_t volid;
1292
1293   TGeoHMatrix hm;
1294   Double_t *rot,*transl;
1295   Double_t rotSum[9],translSum[3]={0.,0.,0.};
1296   for(Int_t k=0;k<8;k++)rotSum[k]=0.;
1297
1298
1299   for(Int_t ivol=0;ivol<lastVolid;ivol++){
1300     volid=volIDs->At(ivol);
1301
1302     GetAlignObj(volIDs->At(ivol))->GetMatrix(hm);
1303
1304     rot=hm.GetRotationMatrix();
1305     transl=hm.GetTranslation();
1306
1307     for(Int_t j=0;j<9;j++)rotSum[j]+=rot[j];
1308     for(Int_t jt=0;jt<3;jt++)translSum[jt]+=transl[jt];
1309   }
1310   if(lastVolid!=0){
1311     for(Int_t j=0;j<9;j++)rotSum[j]=rotSum[j]/lastVolid;
1312     for(Int_t jt=0;jt<3;jt++)translSum[jt]=translSum[jt]/lastVolid;
1313   }
1314   else printf("Try to mediate results for zero modules \n");
1315
1316   hm.SetRotation(rotSum);
1317   hm.SetTranslation(translSum);
1318
1319
1320
1321   AliAlignObjParams *alignObj=new AliAlignObjParams("average", 0,hm, kTRUE);
1322   return alignObj;
1323
1324 }
1325
1326 //________________________________________________
1327 TArrayI* AliITSRealignTracks::GetSPDSectorsVolids(Int_t *sectors)
1328 {
1329   //
1330   // This method gets the volID Array for the chosen sectors.
1331   // You have to pass an array with a 1 for each selected sector.
1332   // i.e. sectors[10] = {1,1,0,0,0,0,0,0,1,0} -> Sector 0, 1, 9 selected.
1333   //
1334
1335   Int_t nSect=0;
1336   Int_t iModule=0;
1337
1338
1339   for(Int_t co=0;co<10;co++){ //counts the number of sectors chosen
1340     if(sectors[co]==1) nSect++;
1341   }
1342
1343   if(nSect<1){ //if no sector chosen -> exit
1344     Printf("Error! No Sector/s Selected!");
1345     return 0x0;
1346   }
1347
1348   TArrayI *volIDs = new TArrayI(nSect*24);
1349
1350     if(sectors[0]==1){ //--->cSect = 0 <---
1351       volIDs->AddAt(2048,iModule); iModule++;
1352       volIDs->AddAt(2049,iModule); iModule++;
1353       volIDs->AddAt(2050,iModule); iModule++;
1354       volIDs->AddAt(2051,iModule); iModule++;
1355       volIDs->AddAt(2052,iModule); iModule++;
1356       volIDs->AddAt(2053,iModule); iModule++;
1357       volIDs->AddAt(2054,iModule); iModule++;
1358       volIDs->AddAt(2055,iModule); iModule++;
1359       volIDs->AddAt(4096,iModule); iModule++;
1360       volIDs->AddAt(4097,iModule); iModule++;
1361       volIDs->AddAt(4098,iModule); iModule++;
1362       volIDs->AddAt(4099,iModule); iModule++;
1363       volIDs->AddAt(4100,iModule); iModule++;
1364       volIDs->AddAt(4101,iModule); iModule++;
1365       volIDs->AddAt(4102,iModule); iModule++;
1366       volIDs->AddAt(4103,iModule); iModule++;
1367       volIDs->AddAt(4104,iModule); iModule++;
1368       volIDs->AddAt(4105,iModule); iModule++;
1369       volIDs->AddAt(4106,iModule); iModule++;
1370       volIDs->AddAt(4107,iModule); iModule++;
1371       volIDs->AddAt(4108,iModule); iModule++;
1372       volIDs->AddAt(4109,iModule); iModule++;
1373       volIDs->AddAt(4110,iModule); iModule++;
1374       volIDs->AddAt(4111,iModule); iModule++;
1375     }
1376     if(sectors[1]==1){ //--->cSect = 1 <//---
1377       volIDs->AddAt(2056,iModule); iModule++;
1378       volIDs->AddAt(2057,iModule); iModule++;
1379       volIDs->AddAt(2058,iModule); iModule++;
1380       volIDs->AddAt(2059,iModule); iModule++;
1381       volIDs->AddAt(2060,iModule); iModule++;
1382       volIDs->AddAt(2061,iModule); iModule++;
1383       volIDs->AddAt(2062,iModule); iModule++;
1384       volIDs->AddAt(2063,iModule); iModule++;
1385       volIDs->AddAt(4112,iModule); iModule++;
1386       volIDs->AddAt(4113,iModule); iModule++;
1387       volIDs->AddAt(4114,iModule); iModule++;
1388       volIDs->AddAt(4115,iModule); iModule++;
1389       volIDs->AddAt(4116,iModule); iModule++;
1390       volIDs->AddAt(4117,iModule); iModule++;
1391       volIDs->AddAt(4118,iModule); iModule++;
1392       volIDs->AddAt(4119,iModule); iModule++;
1393       volIDs->AddAt(4120,iModule); iModule++;
1394       volIDs->AddAt(4121,iModule); iModule++;
1395       volIDs->AddAt(4122,iModule); iModule++;
1396       volIDs->AddAt(4123,iModule); iModule++;
1397       volIDs->AddAt(4124,iModule); iModule++;
1398       volIDs->AddAt(4125,iModule); iModule++;
1399       volIDs->AddAt(4126,iModule); iModule++;
1400       volIDs->AddAt(4127,iModule); iModule++;
1401     }
1402     if(sectors[2]==1){//--->cSect = 2 <//---
1403       volIDs->AddAt(2064,iModule); iModule++;
1404       volIDs->AddAt(2065,iModule); iModule++;
1405       volIDs->AddAt(2066,iModule); iModule++;
1406       volIDs->AddAt(2067,iModule); iModule++;
1407       volIDs->AddAt(2068,iModule); iModule++;
1408       volIDs->AddAt(2069,iModule); iModule++;
1409       volIDs->AddAt(2070,iModule); iModule++;
1410       volIDs->AddAt(2071,iModule); iModule++;
1411       volIDs->AddAt(4128,iModule); iModule++;
1412       volIDs->AddAt(4129,iModule); iModule++;
1413       volIDs->AddAt(4130,iModule); iModule++;
1414       volIDs->AddAt(4131,iModule); iModule++;
1415       volIDs->AddAt(4132,iModule); iModule++;
1416       volIDs->AddAt(4133,iModule); iModule++;
1417       volIDs->AddAt(4134,iModule); iModule++;
1418       volIDs->AddAt(4135,iModule); iModule++;
1419       volIDs->AddAt(4136,iModule); iModule++;
1420       volIDs->AddAt(4137,iModule); iModule++;
1421       volIDs->AddAt(4138,iModule); iModule++;
1422       volIDs->AddAt(4139,iModule); iModule++;
1423       volIDs->AddAt(4140,iModule); iModule++;
1424       volIDs->AddAt(4141,iModule); iModule++;
1425       volIDs->AddAt(4142,iModule); iModule++;
1426       volIDs->AddAt(4143,iModule); iModule++;
1427     }
1428     if(sectors[3]==1){//--->cSect = 3 <//---
1429       volIDs->AddAt(2072,iModule); iModule++;
1430       volIDs->AddAt(2073,iModule); iModule++;
1431       volIDs->AddAt(2074,iModule); iModule++;
1432       volIDs->AddAt(2075,iModule); iModule++;
1433       volIDs->AddAt(2076,iModule); iModule++;
1434       volIDs->AddAt(2077,iModule); iModule++;
1435       volIDs->AddAt(2078,iModule); iModule++;
1436       volIDs->AddAt(2079,iModule); iModule++;
1437       volIDs->AddAt(4144,iModule); iModule++;
1438       volIDs->AddAt(4145,iModule); iModule++;
1439       volIDs->AddAt(4146,iModule); iModule++;
1440       volIDs->AddAt(4147,iModule); iModule++;
1441       volIDs->AddAt(4148,iModule); iModule++;
1442       volIDs->AddAt(4149,iModule); iModule++;
1443       volIDs->AddAt(4150,iModule); iModule++;
1444       volIDs->AddAt(4151,iModule); iModule++;
1445       volIDs->AddAt(4152,iModule); iModule++;
1446       volIDs->AddAt(4153,iModule); iModule++;
1447       volIDs->AddAt(4154,iModule); iModule++;
1448       volIDs->AddAt(4155,iModule); iModule++;
1449       volIDs->AddAt(4156,iModule); iModule++;
1450       volIDs->AddAt(4157,iModule); iModule++;
1451       volIDs->AddAt(4158,iModule); iModule++;
1452       volIDs->AddAt(4159,iModule); iModule++;
1453     }
1454     if(sectors[4]==1){//--->cSect = 4 <//---
1455       volIDs->AddAt(2080,iModule); iModule++;
1456       volIDs->AddAt(2081,iModule); iModule++;
1457       volIDs->AddAt(2082,iModule); iModule++;
1458       volIDs->AddAt(2083,iModule); iModule++;
1459       volIDs->AddAt(2084,iModule); iModule++;
1460       volIDs->AddAt(2085,iModule); iModule++;
1461       volIDs->AddAt(2086,iModule); iModule++;
1462       volIDs->AddAt(2087,iModule); iModule++;
1463       volIDs->AddAt(4160,iModule); iModule++;
1464       volIDs->AddAt(4161,iModule); iModule++;
1465       volIDs->AddAt(4162,iModule); iModule++;
1466       volIDs->AddAt(4163,iModule); iModule++;
1467       volIDs->AddAt(4164,iModule); iModule++;
1468       volIDs->AddAt(4165,iModule); iModule++;
1469       volIDs->AddAt(4166,iModule); iModule++;
1470       volIDs->AddAt(4167,iModule); iModule++;
1471       volIDs->AddAt(4168,iModule); iModule++;
1472       volIDs->AddAt(4169,iModule); iModule++;
1473       volIDs->AddAt(4170,iModule); iModule++;
1474       volIDs->AddAt(4171,iModule); iModule++;
1475       volIDs->AddAt(4172,iModule); iModule++;
1476       volIDs->AddAt(4173,iModule); iModule++;
1477       volIDs->AddAt(4174,iModule); iModule++;
1478       volIDs->AddAt(4175,iModule); iModule++;
1479     }
1480     if(sectors[5]==1){//--->cSect = 5 <//---
1481       volIDs->AddAt(2088,iModule); iModule++;
1482       volIDs->AddAt(2089,iModule); iModule++;
1483       volIDs->AddAt(2090,iModule); iModule++;
1484       volIDs->AddAt(2091,iModule); iModule++;
1485       volIDs->AddAt(2092,iModule); iModule++;
1486       volIDs->AddAt(2093,iModule); iModule++;
1487       volIDs->AddAt(2094,iModule); iModule++;
1488       volIDs->AddAt(2095,iModule); iModule++;
1489       volIDs->AddAt(4176,iModule); iModule++;
1490       volIDs->AddAt(4177,iModule); iModule++;
1491       volIDs->AddAt(4178,iModule); iModule++;
1492       volIDs->AddAt(4179,iModule); iModule++;
1493       volIDs->AddAt(4180,iModule); iModule++;
1494       volIDs->AddAt(4181,iModule); iModule++;
1495       volIDs->AddAt(4182,iModule); iModule++;
1496       volIDs->AddAt(4183,iModule); iModule++;
1497       volIDs->AddAt(4184,iModule); iModule++;
1498       volIDs->AddAt(4185,iModule); iModule++;
1499       volIDs->AddAt(4186,iModule); iModule++;
1500       volIDs->AddAt(4187,iModule); iModule++;
1501       volIDs->AddAt(4188,iModule); iModule++;
1502       volIDs->AddAt(4189,iModule); iModule++;
1503       volIDs->AddAt(4190,iModule); iModule++;
1504       volIDs->AddAt(4191,iModule); iModule++;
1505     }
1506     if(sectors[6]==1){//--->cSect = 6 <//---
1507       volIDs->AddAt(2096,iModule); iModule++;
1508       volIDs->AddAt(2097,iModule); iModule++;
1509       volIDs->AddAt(2098,iModule); iModule++;
1510       volIDs->AddAt(2099,iModule); iModule++;
1511       volIDs->AddAt(2100,iModule); iModule++;
1512       volIDs->AddAt(2101,iModule); iModule++;
1513       volIDs->AddAt(2102,iModule); iModule++;
1514       volIDs->AddAt(2103,iModule); iModule++;
1515       volIDs->AddAt(4192,iModule); iModule++;
1516       volIDs->AddAt(4193,iModule); iModule++;
1517       volIDs->AddAt(4194,iModule); iModule++;
1518       volIDs->AddAt(4195,iModule); iModule++;
1519       volIDs->AddAt(4196,iModule); iModule++;
1520       volIDs->AddAt(4197,iModule); iModule++;
1521       volIDs->AddAt(4198,iModule); iModule++;
1522       volIDs->AddAt(4199,iModule); iModule++;
1523       volIDs->AddAt(4200,iModule); iModule++;
1524       volIDs->AddAt(4201,iModule); iModule++;
1525       volIDs->AddAt(4202,iModule); iModule++;
1526       volIDs->AddAt(4203,iModule); iModule++;
1527       volIDs->AddAt(4204,iModule); iModule++;
1528       volIDs->AddAt(4205,iModule); iModule++;
1529       volIDs->AddAt(4206,iModule); iModule++;
1530       volIDs->AddAt(4207,iModule); iModule++;
1531     }
1532      if(sectors[7]==1){ //--->cSect = 7 <//---
1533        volIDs->AddAt(2104,iModule); iModule++;
1534        volIDs->AddAt(2105,iModule); iModule++;
1535        volIDs->AddAt(2106,iModule); iModule++;
1536        volIDs->AddAt(2107,iModule); iModule++;
1537        volIDs->AddAt(2108,iModule); iModule++;
1538        volIDs->AddAt(2109,iModule); iModule++;
1539        volIDs->AddAt(2110,iModule); iModule++;
1540        volIDs->AddAt(2111,iModule); iModule++;
1541        volIDs->AddAt(4208,iModule); iModule++;
1542        volIDs->AddAt(4209,iModule); iModule++;
1543        volIDs->AddAt(4210,iModule); iModule++;
1544        volIDs->AddAt(4211,iModule); iModule++;
1545        volIDs->AddAt(4212,iModule); iModule++;
1546        volIDs->AddAt(4213,iModule); iModule++;
1547        volIDs->AddAt(4214,iModule); iModule++;
1548        volIDs->AddAt(4215,iModule); iModule++;
1549        volIDs->AddAt(4216,iModule); iModule++;
1550        volIDs->AddAt(4217,iModule); iModule++;
1551        volIDs->AddAt(4218,iModule); iModule++;
1552        volIDs->AddAt(4219,iModule); iModule++;
1553        volIDs->AddAt(4220,iModule); iModule++;
1554        volIDs->AddAt(4221,iModule); iModule++;
1555        volIDs->AddAt(4222,iModule); iModule++;
1556        volIDs->AddAt(4223,iModule); iModule++;
1557      }
1558      if(sectors[8]==1){//--->cSect = 8 <//---
1559        volIDs->AddAt(2112,iModule); iModule++;
1560        volIDs->AddAt(2113,iModule); iModule++;
1561        volIDs->AddAt(2114,iModule); iModule++;
1562        volIDs->AddAt(2115,iModule); iModule++;
1563        volIDs->AddAt(2116,iModule); iModule++;
1564        volIDs->AddAt(2117,iModule); iModule++;
1565        volIDs->AddAt(2118,iModule); iModule++;
1566        volIDs->AddAt(2119,iModule); iModule++;
1567        volIDs->AddAt(4224,iModule); iModule++;
1568        volIDs->AddAt(4225,iModule); iModule++;
1569        volIDs->AddAt(4226,iModule); iModule++;
1570        volIDs->AddAt(4227,iModule); iModule++;
1571        volIDs->AddAt(4228,iModule); iModule++;
1572        volIDs->AddAt(4229,iModule); iModule++;
1573        volIDs->AddAt(4230,iModule); iModule++;
1574        volIDs->AddAt(4231,iModule); iModule++;
1575        volIDs->AddAt(4232,iModule); iModule++;
1576        volIDs->AddAt(4233,iModule); iModule++;
1577        volIDs->AddAt(4234,iModule); iModule++;
1578        volIDs->AddAt(4235,iModule); iModule++;
1579        volIDs->AddAt(4236,iModule); iModule++;
1580        volIDs->AddAt(4237,iModule); iModule++;
1581        volIDs->AddAt(4238,iModule); iModule++;
1582        volIDs->AddAt(4239,iModule); iModule++;
1583      }
1584      if(sectors[9]==1){//--->cSect = 9 <//---
1585        volIDs->AddAt(2120,iModule); iModule++;
1586        volIDs->AddAt(2121,iModule); iModule++;
1587        volIDs->AddAt(2122,iModule); iModule++;
1588        volIDs->AddAt(2123,iModule); iModule++;
1589        volIDs->AddAt(2124,iModule); iModule++;
1590        volIDs->AddAt(2125,iModule); iModule++;
1591        volIDs->AddAt(2126,iModule); iModule++;
1592        volIDs->AddAt(2127,iModule); iModule++;
1593        volIDs->AddAt(4240,iModule); iModule++;
1594        volIDs->AddAt(4241,iModule); iModule++;
1595        volIDs->AddAt(4242,iModule); iModule++;
1596        volIDs->AddAt(4243,iModule); iModule++;
1597        volIDs->AddAt(4244,iModule); iModule++;
1598        volIDs->AddAt(4245,iModule); iModule++;
1599        volIDs->AddAt(4246,iModule); iModule++;
1600        volIDs->AddAt(4247,iModule); iModule++;
1601        volIDs->AddAt(4248,iModule); iModule++;
1602        volIDs->AddAt(4249,iModule); iModule++;
1603        volIDs->AddAt(4250,iModule); iModule++;
1604        volIDs->AddAt(4251,iModule); iModule++;
1605        volIDs->AddAt(4252,iModule); iModule++;
1606        volIDs->AddAt(4253,iModule); iModule++;
1607        volIDs->AddAt(4254,iModule); iModule++;
1608        volIDs->AddAt(4255,iModule); iModule++;
1609      }
1610
1611   return volIDs;
1612 }
1613
1614 //___________________________________
1615 TArrayI* AliITSRealignTracks::GetLayersVolUID(Int_t *layer){
1616
1617   TArrayI *out=new TArrayI(2198);
1618   Int_t last=0;
1619   UShort_t voluid;
1620   for(Int_t i=0;i<6;i++){
1621     if(layer[i]==1){
1622       for(Int_t mod=0;mod<AliGeomManager::LayerSize(i+AliGeomManager::kFirstLayer);mod++){
1623         voluid=AliGeomManager::LayerToVolUID(i+AliGeomManager::kFirstLayer,mod);
1624         out->AddAt(voluid,last);
1625         //      printf("voluid %d at position %d \n",out->At(last),last);
1626         last++;
1627       }
1628     }
1629   }
1630   out->Set(last);
1631   return out;
1632 }
1633
1634 //_________________
1635 TArrayI* AliITSRealignTracks::SelectLayerInVolids(const TArrayI *volidsIN,AliGeomManager::ELayerID layer){
1636
1637   Int_t size=volidsIN->GetSize();
1638   Int_t count=0;
1639   for(Int_t j=0;j<size;j++){
1640     if(AliGeomManager::VolUIDToLayer(volidsIN->At(j))==layer)count++;
1641   }
1642   TArrayI *volidsOUT=new TArrayI(count);
1643   count=0;
1644   for(Int_t j=0;j<size;j++){
1645     if(AliGeomManager::VolUIDToLayer(volidsIN->At(j))==layer){
1646       volidsOUT->AddAt(volidsIN->At(j),count);
1647       count++;
1648     }
1649   }
1650   return volidsOUT;
1651 }
1652
1653 //______________________________________________
1654
1655 TArrayI* AliITSRealignTracks::IntersectVolArray(const TArrayI *vol1,const TArrayI *vol2){
1656
1657   Int_t size1=vol1->GetSize();
1658   Int_t size2=vol2->GetSize();
1659   Int_t last=0,volid;
1660   Bool_t found;
1661   TArrayI *volidOut=new TArrayI(size1+size2);
1662
1663   for(Int_t k=0;k<size1;k++){
1664     found=kFALSE;
1665     volid=vol1->At(k);
1666     for(Int_t j=0;j<size2;j++){
1667       if(vol2->At(j)==volid)found=kTRUE;
1668     }
1669     if(found){
1670       volidOut->AddAt(volid,last);
1671       last++;
1672     }
1673   }
1674   volidOut->Set(last);
1675   return volidOut;
1676 }
1677 //_________________________________________
1678
1679 TArrayI* AliITSRealignTracks::JoinVolArrays(const TArrayI *vol1,const TArrayI *vol2){
1680   //!BE CAREFUL: If an index is repeated in vol1 or vol2 will be repeated also in the final array
1681
1682   Int_t size1=vol1->GetSize();
1683   Int_t size2=vol2->GetSize();
1684   Int_t count=0;
1685   UShort_t volid;
1686   Bool_t found;
1687   TArrayI *volidOut=new TArrayI(size1+size2);
1688
1689   for(Int_t k=0;k<size1;k++){
1690     volid=vol1->At(k);
1691     volidOut->AddAt(volid,k);
1692   }
1693
1694   for(Int_t k=0;k<size1;k++){
1695     found=kFALSE;
1696     volid=vol1->At(k);
1697     for(Int_t j=0;j<size2;j++){
1698       if(vol2->At(j)==volid)found=kTRUE;
1699     }
1700     if(!found){
1701       volidOut->AddAt(volid,size1+count);
1702       count++;
1703     }
1704   }
1705   volidOut->Set(size1+count);
1706   return volidOut;
1707 }
1708
1709 //______________________________________
1710
1711 TArrayI* AliITSRealignTracks::ExcludeVolidsFromVolidsArray(const TArrayI *volidsToExclude,const TArrayI *volStart){
1712
1713   Int_t size1=volidsToExclude->GetSize();
1714   Int_t size2=volStart->GetSize();
1715   Int_t last=0;
1716   UShort_t volid;
1717   Bool_t found;
1718   TArrayI *volidOut=new TArrayI(size2);
1719
1720   for(Int_t k=0;k<size2;k++){
1721     found=kFALSE;
1722     volid=volStart->At(k);
1723     for(Int_t j=0;j<size1;j++){
1724       if(volidsToExclude->At(j)==volid){
1725         found=kTRUE;
1726         break;
1727       }
1728     }
1729     if(!found){
1730       volidOut->AddAt(volid,last);
1731       last++;
1732     }
1733   }
1734   volidOut->Set(last);
1735   return volidOut;
1736 }
1737
1738
1739 //________________________________________
1740
1741 TArrayI* AliITSRealignTracks::GetLayerVolumes(Int_t *layer){
1742
1743   TArrayI *out=new TArrayI(2198);
1744   Int_t last=0;
1745   UShort_t voluid;
1746   for(Int_t i=0;i<6;i++){
1747     if(layer[i]==1){
1748       for(Int_t mod=0;mod<AliGeomManager::LayerSize(i+AliGeomManager::kFirstLayer);mod++){
1749         voluid=AliGeomManager::LayerToVolUID(i+AliGeomManager::kFirstLayer,mod);
1750         out->AddAt(voluid,last);
1751         //      printf("voluid %d at position %d \n",out->At(last),last);
1752         last++;
1753       }
1754     }
1755   }
1756   out->Set(last);
1757   return out;
1758 }