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   maxntr=minNtracks+1;
 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::kSSD1,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   maxntr=minNtracks+1;
 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   Int_t pointsdim=0;
 825   // Start the iterations
 826   while (iterations > 0) {
 827     Int_t nArrays = LoadPoints(volids, points,pointsdim);
 828     if (nArrays < fmintracks) {
 829       failed=kTRUE;
 830       printf("Not enough tracks to try minimization \n");
 831       UnloadPoints(pointsdim, points);
 832       break;
 833     }
 834
 835     AliTrackResiduals *minimizer = CreateMinimizer();
 836     minimizer->SetNTracks(nArrays);
 837     minimizer->InitAlignObj();
 838     AliTrackFitter *fitter = CreateFitter();
 839     for (Int_t iArray = 0; iArray < nArrays; iArray++) {
 840       if (!points[iArray]) continue;
 841       fitter->SetTrackPointArray(points[iArray], kTRUE);
 842       if (fitter->Fit(volids,volidsfit,layerRangeMin,layerRangeMax) == kFALSE) continue;
 843       AliTrackPointArray *pVolId,*pTrack;
 844       fitter->GetTrackResiduals(pVolId,pTrack);
 845       minimizer->AddTrackPointArrays(pVolId,pTrack);
 846     }
 847     if(minimizer->GetNFilledTracks()<=fmintracks){
 848       printf("No good tracks found: could not find parameter for volume %d (and following in volids)\n",volids->At(0));
 849       UnloadPoints(pointsdim, points);
 850       failed=kTRUE;
 851       break;
 852     }
 853     failed=(!minimizer->Minimize());
 854
 855     // Update the alignment object(s)
 856     if (fDoUpdate) for (Int_t iVolId = 0; iVolId < nVolIds; iVolId++) {
 857       UShort_t volid = (*volids)[iVolId];
 858       Int_t iModule;
 859       AliGeomManager::ELayerID iLayer = AliGeomManager::VolUIDToLayer(volid,iModule);
 860
 861       AliAlignObj *alignObj = fAlignObjs[iLayer-AliGeomManager::kFirstLayer][iModule];
 862       AliAlignObj *alignObjSurv = fSurveyObjs[iLayer-AliGeomManager::kFirstLayer][iModule];
 863
 864       if(!failed){
 865         if(fUpdateCov)*alignObj *= *minimizer->GetAlignObj();
 866         else{
 867           TMatrixDSym covmatrx(6);
 868           alignObj->GetCovMatrix(covmatrx);
 869           *alignObj *= *minimizer->GetAlignObj();
 870           alignObj->SetCorrMatrix(covmatrx);
 871           alignObj->SetUniqueID(1);
 872         }
 873         alignObjSurv->GetCovMatrix(surveycov);
 874         alignObj->GetPars(transl,rot);
 875
 876         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])){
 877           printf("Results for module %d out of Survey: reinitializing it from survey \n",volid);
 878           //      *alignObj = *alignObjSurv;
 879           alignObj->SetPars(0.,0.,0.,0.,0.,0.);
 880           alignObj->SetUniqueID(0);
 881           if(fUpdateCov)alignObj->SetCorrMatrix(surveycov);
 882           if(iterations==1){
 883             failed=kTRUE;
 884           }
 885         }
 886       }
 887       else {
 888         printf("Minimization failed: cannot update AlignObj for volume: %d \n",volid);
 889       }
 890       if(iterations==1)alignObj->Print("");
 891     }
 892
 893     UnloadPoints(pointsdim,points);
 894     if(failed)break;
 895     iterations--;
 896   }
 897   return (!failed);
 898 }
 899
 900
 901
 902 //______________________________________________
 903 Bool_t AliITSRealignTracks::AlignSPDBarrel(Int_t iterations){
 904
 905   Int_t size=0,size2=0;
 906   Int_t layers[6]={1,1,0,0,0,0};
 907   for(Int_t k=1;k<=2;k++){
 908     size+=AliGeomManager::LayerSize(k);
 909   }
 910   for(Int_t k=3;k<=6;k++){
 911     size2+=AliGeomManager::LayerSize(k);
 912     printf("size: %d \n",size2);
 913   }
 914
 915   printf("Aligning SPDBarrel: nmodules: %d \n",size);
 916   printf("Fitting modules: %d \n",size2);
 917
 918   TArrayI *volIDs=GetLayersVolUID(layers);
 919   layers[0]=0;
 920   layers[1]=0;
 921   layers[2]=1;
 922   layers[3]=1;
 923   layers[4]=1;
 924   layers[5]=1;
 925   TArrayI *volIDsFit=GetLayersVolUID(layers);
 926
 927   AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSDD1,AliGeomManager::kTPC1,iterations);
 928
 929   return kTRUE;
 930 }
 931
 932 //______________________
 933 Bool_t AliITSRealignTracks::AlignSPDHalfBarrel(Int_t method,Int_t iterations){
 934
 935   Int_t size=0,size2=0;
 936   Int_t layers[6]={0,0,1,1,1,1};
 937   Int_t sectorsUp[10]={1,1,1,1,1,0,0,0,0,0};
 938   Int_t sectorsDown[10]={0,0,0,0,0,1,1,1,1,1};
 939
 940   TString updownstr;
 941   if(method==0)updownstr="UpNoDown";
 942   else if (method==1)updownstr="DownNoUp";
 943   else if (method==10)updownstr="UpWithDown";
 944   else if (method==11)updownstr="DownWithUp";
 945   else {
 946     AliWarning("Wrong AlignSPDHalfBarrel method selected ");
 947     return kFALSE;
 948   }
 949
 950   for(Int_t i=1;i<=2;i++){
 951     size+=AliGeomManager::LayerSize(i);
 952   }
 953
 954   for(Int_t i=3;i<=6;i++){
 955     size2+=AliGeomManager::LayerSize(i);
 956   }
 957
 958   size=size/2;
 959   if(method==10||method==11)size2+=size;
 960
 961   printf("Aligning  SPDHalfBarrel %s: nmodules: %d \n",updownstr.Data(),size);
 962   printf("Fitting modules: %d \n",size2);
 963   TArrayI *volIDsFit2;
 964   TArrayI *volids = NULL;
 965   TArrayI *volIDsFit=GetLayersVolUID(layers);
 966   if(method==0||method==10)volids=GetSPDSectorsVolids(sectorsUp);
 967   if(method==1||method==11)volids=GetSPDSectorsVolids(sectorsDown);
 968
 969   if(method==10)volIDsFit2=JoinVolArrays(GetSPDSectorsVolids(sectorsDown),volIDsFit);
 970   else if(method==11)volIDsFit2=JoinVolArrays(GetSPDSectorsVolids(sectorsUp),volIDsFit);
 971   else volIDsFit2=volIDsFit;
 972
 973   AlignVolumesITS(volids,volIDsFit2,AliGeomManager::kSPD1,AliGeomManager::kSSD2,iterations);
 974
 975   return kTRUE;
 976 }
 977
 978
 979 //______________________________________________________
 980 Bool_t AliITSRealignTracks::AlignLayer(Int_t layer,Int_t iterations){
 981
 982   Int_t size=0,size2=0;
 983   Int_t layers[6]={0,0,0,0,0,0};
 984   layers[layer-1]=1;
 985   TString layerstr[6]={"SPD1","SPD2","SDD1","SDD2","SSD1","SSD2"};
 986   for(Int_t k=1;k<=6;k++){
 987     if(k!=layer)size2+=AliGeomManager::LayerSize(k);
 988   }
 989   size=AliGeomManager::LayerSize(layer);
 990
 991   printf("Aligning layer %s, nmodules %d ,fitted modules %d \n",layerstr[layer-1].Data(),size,size2);
 992
 993
 994   TArrayI *volIDs=GetLayersVolUID(layers);
 995   layers[0]=1;
 996   layers[1]=1;
 997   layers[2]=1;
 998   layers[3]=1;
 999   layers[4]=1;
1000   layers[5]=1;
1001   layers[layer]=0;
1002   TArrayI *volIDsFit=GetLayersVolUID(layers);
1003
1004   AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSDD1,AliGeomManager::kSSD2,iterations);
1005
1006   return kTRUE;
1007 }
1008
1009 //___________________________________________
1010
1011 Bool_t AliITSRealignTracks::AlignLayersToLayers(Int_t *layer,Int_t iterations){
1012
1013   UShort_t volid;
1014   Int_t size=0,size2=0,j=0,k=0;
1015   Int_t iLayer;
1016   TString layerstr[6]={"SPD1","SPD2","SDD1","SDD2","SSD1","SSD2"};
1017   TString command="",str;
1018   for(Int_t i=1;i<=6;i++){
1019     if(layer[i-1]==1||layer[i-1]==3){
1020       size+=AliGeomManager::LayerSize(i);
1021       command.Append(" ");
1022       command.Append(layerstr[i-1]);
1023     }
1024     if(layer[i-1]==2||layer[i-1]==3){
1025       size2+=AliGeomManager::LayerSize(i);
1026       str.Append(" ");
1027       str.Append(layerstr[i-1]);
1028     }
1029   }
1030
1031   printf("Aligning layers %s To layers %s, nmodules %d ,fitted modules %d \n",command.Data(),str.Data(),size,size2);
1032
1033
1034   TArrayI volIDs(size);
1035   TArrayI volIDsFit(size2);
1036
1037   for (iLayer=(Int_t)AliGeomManager::kSPD1;iLayer<(Int_t)AliGeomManager::kTPC1;iLayer++){
1038     if(layer[iLayer-AliGeomManager::kFirstLayer]==0)continue;
1039     if(layer[iLayer-AliGeomManager::kFirstLayer]==1){
1040       for (Int_t iModule2=0;iModule2<AliGeomManager::LayerSize(iLayer);iModule2++){
1041         volid = AliGeomManager::LayerToVolUID(iLayer,iModule2);
1042         volIDs.AddAt(volid,j);
1043         j++;
1044       }
1045     }
1046     else if(layer[iLayer-AliGeomManager::kFirstLayer]==2){
1047       for (Int_t iModule2=0;iModule2<AliGeomManager::LayerSize(iLayer);iModule2++){
1048         volid = AliGeomManager::LayerToVolUID(iLayer,iModule2);
1049         volIDsFit.AddAt(volid,k);
1050         k++;
1051       }
1052     }
1053     else if(layer[iLayer-AliGeomManager::kFirstLayer]==3){
1054       for (Int_t iModule2=0;iModule2<AliGeomManager::LayerSize(iLayer);iModule2++){
1055         volid = AliGeomManager::LayerToVolUID(iLayer,iModule2);
1056         volIDs.AddAt(volid,j);
1057         j++;
1058         volIDsFit.AddAt(volid,k);
1059         k++;
1060       }
1061     }
1062   }
1063
1064   AlignVolumesITS(&volIDs,&volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSSD2,iterations);
1065
1066   return kTRUE;
1067 }
1068
1069 //______________________________________________
1070
1071 Bool_t AliITSRealignTracks::AlignSPDSectorToOuterLayers(Int_t sector,Int_t iterations){
1072
1073
1074   Int_t layers[6]={0,0,1,1,1,1};
1075   Bool_t spd=kFALSE;
1076   Int_t sectorsIN[10]={0,0,0,0,0,0,0,0,0,0};
1077   Int_t sectorsFit[10]={1,1,1,1,1,1,1,1,1,1};
1078
1079   if(sector<0){
1080     sector=-sector;
1081     spd=kTRUE;
1082   }
1083   sectorsIN[sector]=1;
1084   sectorsFit[sector]=0;
1085   TArrayI *volIDs=GetSPDSectorsVolids(sectorsIN);
1086   TArrayI *volIDsFit;
1087   if(spd){
1088     volIDsFit=JoinVolArrays(GetSPDSectorsVolids(sectorsFit),GetLayersVolUID(layers));
1089   }
1090   else volIDsFit=GetLayersVolUID(layers);
1091
1092   printf("Aligning SPD sector %d: nmodules: %d \n",sector,volIDs->GetSize());
1093   printf("Fitting modules: %d \n",volIDsFit->GetSize());
1094
1095   AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSPD2,iterations);
1096
1097   return kTRUE;
1098 }
1099
1100 //______________________________________________
1101 Bool_t AliITSRealignTracks::AlignSPDSectorWithSectors(Int_t sector,Int_t iterations){
1102
1103
1104   Int_t sectorsIN[10]={0,0,0,0,0,0,0,0,0,0};
1105   Int_t sectorsFit[10]={1,1,1,1,1,1,1,1,1,1};
1106
1107   sectorsIN[sector]=1;
1108   sectorsFit[sector]=0;
1109   TArrayI *volIDs=GetSPDSectorsVolids(sectorsIN);
1110   TArrayI *volIDsFit=GetSPDSectorsVolids(sectorsFit);;
1111
1112   printf("Aligning SPD sector %d: nmodules: %d \n",sector,volIDs->GetSize());
1113   printf("Fitting modules: %d \n",volIDsFit->GetSize());
1114
1115
1116   AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSDD1,iterations);
1117
1118   return kTRUE;
1119 }
1120
1121
1122
1123 //___________________________________________________
1124 Bool_t AliITSRealignTracks::AlignSPDSectorsWithSectors(Int_t *sectorsIN,Int_t *sectorsFit,Int_t iterations){
1125
1126   TArrayI *volIDs=GetSPDSectorsVolids(sectorsIN);
1127   TArrayI *volIDsFit=GetSPDSectorsVolids(sectorsFit);;
1128
1129   printf("Aligning SPD sectors: modules: %d \n",volIDs->GetSize());
1130   printf("Fitting modules: %d \n",volIDsFit->GetSize());
1131
1132   AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSDD1,iterations);
1133
1134   return kTRUE;
1135 }
1136
1137
1138 //___________________________________________
1139
1140 Bool_t AliITSRealignTracks::AlignLayerToSPDHalfBarrel(Int_t layer,Int_t updown,Int_t iterations){
1141
1142
1143   Int_t sectorsDown[10]={0,0,0,0,0,1,1,1,1,1};
1144   Int_t sectorsUp[10]={1,1,1,1,1,0,0,0,0,0};
1145   TString layerstr[6]={"SPD1","SPD2","SDD1","SDD2","SSD1","SSD2"};
1146   TArrayI *volIDsFit;
1147   Int_t layers[6]={0,0,0,0,0,0};
1148   layers[layer]=1;
1149   Int_t size=AliGeomManager::LayerSize(layer);
1150   TArrayI *volIDs=GetLayersVolUID(layers);
1151
1152   if(updown==0){
1153     volIDsFit=GetSPDSectorsVolids(sectorsUp);
1154     printf("Aligning layer %s, nmodules %d ,to half barrel Up \n",layerstr[layer-1].Data(),size);
1155   }
1156   else if(updown==1){
1157     volIDsFit=GetSPDSectorsVolids(sectorsDown);
1158     printf("Aligning layer %s, nmodules %d ,to half barrel Down \n",layerstr[layer-1].Data(),size);
1159   }
1160   else {
1161     printf("Wrong Half Barrel selection! \n");
1162     return kFALSE;
1163   }
1164
1165   AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSSD2,iterations);
1166
1167   return kTRUE;
1168 }
1169
1170 //___________________________________________
1171
1172 Bool_t AliITSRealignTracks::AlignLayerToSector(Int_t layer,Int_t sector,Int_t iterations){
1173
1174   if(sector>9){
1175     printf("Wrong Sector selection! \n");
1176     return kFALSE;
1177   }
1178   Int_t sectors[10]={0,0,0,0,0,0,0,0,0,0};
1179   sectors[sector]=1;
1180   TString layerstr[6]={"SPD1","SPD2","SDD1","SDD2","SSD1","SSD2"};
1181   TArrayI *volIDsFit;
1182   Int_t layers[6]={0,0,0,0,0,0};
1183   layers[layer]=1;
1184   TArrayI *volIDs=GetLayersVolUID(layers);
1185   Int_t size=AliGeomManager::LayerSize(layer);
1186
1187
1188   volIDsFit=GetSPDSectorsVolids(sectors);
1189   printf("Aligning layer %s, nmodules %d ,to half barrel Up \n",layerstr[layer-1].Data(),size);
1190
1191   AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSSD2,iterations);
1192
1193   return kTRUE;
1194 }
1195
1196 //_______________________________________________
1197
1198 Bool_t AliITSRealignTracks::AlignSPDHalfBarrelToHalfBarrel(Int_t updown,Int_t iterations){
1199
1200
1201   Int_t sectorsDown[10]={0,0,0,0,0,1,1,1,1,1};
1202   Int_t sectorsUp[10]={1,1,1,1,1,0,0,0,0,0};
1203
1204   TArrayI *volIDsUp=GetSPDSectorsVolids(sectorsUp);
1205   TArrayI *volIDsDown=GetSPDSectorsVolids(sectorsDown);
1206
1207   if(updown==0){
1208     printf("Aligning SPD HalfBarrel up to half Barrel down : nmodules: %d \n",volIDsUp->GetSize());
1209     printf("Fitting modules: %d \n",volIDsDown->GetSize());
1210     AlignVolumesITS(volIDsUp,volIDsDown,AliGeomManager::kSPD1,AliGeomManager::kSPD2,iterations);
1211   }
1212   else if(updown==1){
1213     printf("Aligning SPD HalfBarrel down to half Barrel Up : nmodules: %d \n",volIDsDown->GetSize());
1214     printf("Fitting modules: %d \n",volIDsUp->GetSize());
1215     AlignVolumesITS(volIDsDown,volIDsUp,AliGeomManager::kSPD1,AliGeomManager::kSPD2,iterations);
1216   }
1217   else {
1218     printf("Wrong Half Barrel selection! \n");
1219     return kFALSE;
1220   }
1221
1222   return kTRUE;
1223 }
1224
1225
1226 //_______________________
1227 Bool_t AliITSRealignTracks::AlignSPDHalfBarrelToSectorRef(Int_t sector,Int_t iterations){
1228
1229   Int_t sectorsIN[10]={0,0,0,0,0,1,1,1,1,1};
1230   Int_t sectorsFit[10]={0,0,0,0,0,0,0,0,0,0};
1231
1232   sectorsFit[sector]=1;
1233
1234   TArrayI *volIDs=GetSPDSectorsVolids(sectorsIN);
1235   TArrayI *volIDsFit=GetSPDSectorsVolids(sectorsFit);
1236
1237   printf("Aligning SPD HalfBarrel to sector 0 %d: nmodules: %d \n",sector,volIDs->GetSize());
1238   printf("Fitting modules: %d \n",volIDsFit->GetSize());
1239
1240
1241   AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSPD2,iterations);
1242
1243
1244   return kTRUE;
1245 }
1246 //_________________________________________
1247 Bool_t AliITSRealignTracks::AlignSPD1SectorRef(Int_t sector,Int_t iterations){
1248
1249   Int_t sectorsIN[10]={0,0,0,0,0,0,0,0,0,0};
1250   Int_t sectorsFit[10]={1,1,1,1,1,1,1,1,1,1};
1251   sectorsIN[sector]=1;
1252   sectorsFit[sector]=0;
1253   TArrayI *volIDs=GetSPDSectorsVolids(sectorsIN);
1254   TArrayI *volIDsFit=GetSPDSectorsVolids(sectorsFit);
1255   Int_t size=volIDs->GetSize();
1256   Int_t size2=volIDsFit->GetSize();
1257   UShort_t volID;
1258   Int_t k=0;
1259
1260   TArrayI *volIDsSPD1=new TArrayI(size-8);
1261   TArrayI *volIDsFit2=new TArrayI(size2+8);
1262
1263   for(Int_t j=0;j<size;j++){
1264     volID=volIDs->At(j);
1265     if(AliGeomManager::VolUIDToLayer(volID)==AliGeomManager::kSPD1){
1266       volIDsSPD1->AddAt(volID,size2+k);
1267       k++;
1268     }
1269     else volIDsFit2->AddAt(volID,j-k);
1270   }
1271
1272
1273   for(Int_t j=0;j<size2;j++){
1274     volID=volIDsFit->At(j);
1275     volIDsFit2->AddAt(volID,size-k+j);
1276   }
1277
1278   printf("Aligning SPD Sector %d: nmodules: %d \n",sector,volIDsSPD1->GetSize());
1279   printf("Fitting modules: %d \n",volIDsFit2->GetSize());
1280
1281   AlignVolumesITS(volIDsSPD1,volIDsFit2,AliGeomManager::kSPD1,AliGeomManager::kSPD2,iterations);
1282
1283   return kTRUE;
1284 }
1285
1286 //_____________________________________________
1287
1288 AliAlignObjParams* AliITSRealignTracks::MediateAlignObj(TArrayI *volIDs,Int_t lastVolid){
1289   UShort_t volid;
1290
1291   TGeoHMatrix hm;
1292   Double_t *rot,*transl;
1293   Double_t rotSum[9],translSum[3]={0.,0.,0.};
1294   for(Int_t k=0;k<8;k++)rotSum[k]=0.;
1295
1296
1297   for(Int_t ivol=0;ivol<lastVolid;ivol++){
1298     volid=volIDs->At(ivol);
1299
1300     GetAlignObj(volIDs->At(ivol))->GetMatrix(hm);
1301
1302     rot=hm.GetRotationMatrix();
1303     transl=hm.GetTranslation();
1304
1305     for(Int_t j=0;j<9;j++)rotSum[j]+=rot[j];
1306     for(Int_t jt=0;jt<3;jt++)translSum[jt]+=transl[jt];
1307   }
1308   if(lastVolid!=0){
1309     for(Int_t j=0;j<9;j++)rotSum[j]=rotSum[j]/lastVolid;
1310     for(Int_t jt=0;jt<3;jt++)translSum[jt]=translSum[jt]/lastVolid;
1311   }
1312   else printf("Try to mediate results for zero modules \n");
1313
1314   hm.SetRotation(rotSum);
1315   hm.SetTranslation(translSum);
1316
1317
1318
1319   AliAlignObjParams *alignObj=new AliAlignObjParams("average", 0,hm, kTRUE);
1320   return alignObj;
1321
1322 }
1323
1324 //________________________________________________
1325 TArrayI* AliITSRealignTracks::GetSPDSectorsVolids(Int_t *sectors)
1326 {
1327   //
1328   // This method gets the volID Array for the chosen sectors.
1329   // You have to pass an array with a 1 for each selected sector.
1330   // i.e. sectors[10] = {1,1,0,0,0,0,0,0,1,0} -> Sector 0, 1, 9 selected.
1331   //
1332
1333   Int_t nSect=0;
1334   Int_t iModule=0;
1335
1336
1337   for(Int_t co=0;co<10;co++){ //counts the number of sectors chosen
1338     if(sectors[co]==1) nSect++;
1339   }
1340
1341   if(nSect<1){ //if no sector chosen -> exit
1342     Printf("Error! No Sector/s Selected!");
1343     return 0x0;
1344   }
1345
1346   TArrayI *volIDs = new TArrayI(nSect*24);
1347
1348     if(sectors[0]==1){ //--->cSect = 0 <---
1349       volIDs->AddAt(2048,iModule); iModule++;
1350       volIDs->AddAt(2049,iModule); iModule++;
1351       volIDs->AddAt(2050,iModule); iModule++;
1352       volIDs->AddAt(2051,iModule); iModule++;
1353       volIDs->AddAt(2052,iModule); iModule++;
1354       volIDs->AddAt(2053,iModule); iModule++;
1355       volIDs->AddAt(2054,iModule); iModule++;
1356       volIDs->AddAt(2055,iModule); iModule++;
1357       volIDs->AddAt(4096,iModule); iModule++;
1358       volIDs->AddAt(4097,iModule); iModule++;
1359       volIDs->AddAt(4098,iModule); iModule++;
1360       volIDs->AddAt(4099,iModule); iModule++;
1361       volIDs->AddAt(4100,iModule); iModule++;
1362       volIDs->AddAt(4101,iModule); iModule++;
1363       volIDs->AddAt(4102,iModule); iModule++;
1364       volIDs->AddAt(4103,iModule); iModule++;
1365       volIDs->AddAt(4104,iModule); iModule++;
1366       volIDs->AddAt(4105,iModule); iModule++;
1367       volIDs->AddAt(4106,iModule); iModule++;
1368       volIDs->AddAt(4107,iModule); iModule++;
1369       volIDs->AddAt(4108,iModule); iModule++;
1370       volIDs->AddAt(4109,iModule); iModule++;
1371       volIDs->AddAt(4110,iModule); iModule++;
1372       volIDs->AddAt(4111,iModule); iModule++;
1373     }
1374     if(sectors[1]==1){ //--->cSect = 1 <//---
1375       volIDs->AddAt(2056,iModule); iModule++;
1376       volIDs->AddAt(2057,iModule); iModule++;
1377       volIDs->AddAt(2058,iModule); iModule++;
1378       volIDs->AddAt(2059,iModule); iModule++;
1379       volIDs->AddAt(2060,iModule); iModule++;
1380       volIDs->AddAt(2061,iModule); iModule++;
1381       volIDs->AddAt(2062,iModule); iModule++;
1382       volIDs->AddAt(2063,iModule); iModule++;
1383       volIDs->AddAt(4112,iModule); iModule++;
1384       volIDs->AddAt(4113,iModule); iModule++;
1385       volIDs->AddAt(4114,iModule); iModule++;
1386       volIDs->AddAt(4115,iModule); iModule++;
1387       volIDs->AddAt(4116,iModule); iModule++;
1388       volIDs->AddAt(4117,iModule); iModule++;
1389       volIDs->AddAt(4118,iModule); iModule++;
1390       volIDs->AddAt(4119,iModule); iModule++;
1391       volIDs->AddAt(4120,iModule); iModule++;
1392       volIDs->AddAt(4121,iModule); iModule++;
1393       volIDs->AddAt(4122,iModule); iModule++;
1394       volIDs->AddAt(4123,iModule); iModule++;
1395       volIDs->AddAt(4124,iModule); iModule++;
1396       volIDs->AddAt(4125,iModule); iModule++;
1397       volIDs->AddAt(4126,iModule); iModule++;
1398       volIDs->AddAt(4127,iModule); iModule++;
1399     }
1400     if(sectors[2]==1){//--->cSect = 2 <//---
1401       volIDs->AddAt(2064,iModule); iModule++;
1402       volIDs->AddAt(2065,iModule); iModule++;
1403       volIDs->AddAt(2066,iModule); iModule++;
1404       volIDs->AddAt(2067,iModule); iModule++;
1405       volIDs->AddAt(2068,iModule); iModule++;
1406       volIDs->AddAt(2069,iModule); iModule++;
1407       volIDs->AddAt(2070,iModule); iModule++;
1408       volIDs->AddAt(2071,iModule); iModule++;
1409       volIDs->AddAt(4128,iModule); iModule++;
1410       volIDs->AddAt(4129,iModule); iModule++;
1411       volIDs->AddAt(4130,iModule); iModule++;
1412       volIDs->AddAt(4131,iModule); iModule++;
1413       volIDs->AddAt(4132,iModule); iModule++;
1414       volIDs->AddAt(4133,iModule); iModule++;
1415       volIDs->AddAt(4134,iModule); iModule++;
1416       volIDs->AddAt(4135,iModule); iModule++;
1417       volIDs->AddAt(4136,iModule); iModule++;
1418       volIDs->AddAt(4137,iModule); iModule++;
1419       volIDs->AddAt(4138,iModule); iModule++;
1420       volIDs->AddAt(4139,iModule); iModule++;
1421       volIDs->AddAt(4140,iModule); iModule++;
1422       volIDs->AddAt(4141,iModule); iModule++;
1423       volIDs->AddAt(4142,iModule); iModule++;
1424       volIDs->AddAt(4143,iModule); iModule++;
1425     }
1426     if(sectors[3]==1){//--->cSect = 3 <//---
1427       volIDs->AddAt(2072,iModule); iModule++;
1428       volIDs->AddAt(2073,iModule); iModule++;
1429       volIDs->AddAt(2074,iModule); iModule++;
1430       volIDs->AddAt(2075,iModule); iModule++;
1431       volIDs->AddAt(2076,iModule); iModule++;
1432       volIDs->AddAt(2077,iModule); iModule++;
1433       volIDs->AddAt(2078,iModule); iModule++;
1434       volIDs->AddAt(2079,iModule); iModule++;
1435       volIDs->AddAt(4144,iModule); iModule++;
1436       volIDs->AddAt(4145,iModule); iModule++;
1437       volIDs->AddAt(4146,iModule); iModule++;
1438       volIDs->AddAt(4147,iModule); iModule++;
1439       volIDs->AddAt(4148,iModule); iModule++;
1440       volIDs->AddAt(4149,iModule); iModule++;
1441       volIDs->AddAt(4150,iModule); iModule++;
1442       volIDs->AddAt(4151,iModule); iModule++;
1443       volIDs->AddAt(4152,iModule); iModule++;
1444       volIDs->AddAt(4153,iModule); iModule++;
1445       volIDs->AddAt(4154,iModule); iModule++;
1446       volIDs->AddAt(4155,iModule); iModule++;
1447       volIDs->AddAt(4156,iModule); iModule++;
1448       volIDs->AddAt(4157,iModule); iModule++;
1449       volIDs->AddAt(4158,iModule); iModule++;
1450       volIDs->AddAt(4159,iModule); iModule++;
1451     }
1452     if(sectors[4]==1){//--->cSect = 4 <//---
1453       volIDs->AddAt(2080,iModule); iModule++;
1454       volIDs->AddAt(2081,iModule); iModule++;
1455       volIDs->AddAt(2082,iModule); iModule++;
1456       volIDs->AddAt(2083,iModule); iModule++;
1457       volIDs->AddAt(2084,iModule); iModule++;
1458       volIDs->AddAt(2085,iModule); iModule++;
1459       volIDs->AddAt(2086,iModule); iModule++;
1460       volIDs->AddAt(2087,iModule); iModule++;
1461       volIDs->AddAt(4160,iModule); iModule++;
1462       volIDs->AddAt(4161,iModule); iModule++;
1463       volIDs->AddAt(4162,iModule); iModule++;
1464       volIDs->AddAt(4163,iModule); iModule++;
1465       volIDs->AddAt(4164,iModule); iModule++;
1466       volIDs->AddAt(4165,iModule); iModule++;
1467       volIDs->AddAt(4166,iModule); iModule++;
1468       volIDs->AddAt(4167,iModule); iModule++;
1469       volIDs->AddAt(4168,iModule); iModule++;
1470       volIDs->AddAt(4169,iModule); iModule++;
1471       volIDs->AddAt(4170,iModule); iModule++;
1472       volIDs->AddAt(4171,iModule); iModule++;
1473       volIDs->AddAt(4172,iModule); iModule++;
1474       volIDs->AddAt(4173,iModule); iModule++;
1475       volIDs->AddAt(4174,iModule); iModule++;
1476       volIDs->AddAt(4175,iModule); iModule++;
1477     }
1478     if(sectors[5]==1){//--->cSect = 5 <//---
1479       volIDs->AddAt(2088,iModule); iModule++;
1480       volIDs->AddAt(2089,iModule); iModule++;
1481       volIDs->AddAt(2090,iModule); iModule++;
1482       volIDs->AddAt(2091,iModule); iModule++;
1483       volIDs->AddAt(2092,iModule); iModule++;
1484       volIDs->AddAt(2093,iModule); iModule++;
1485       volIDs->AddAt(2094,iModule); iModule++;
1486       volIDs->AddAt(2095,iModule); iModule++;
1487       volIDs->AddAt(4176,iModule); iModule++;
1488       volIDs->AddAt(4177,iModule); iModule++;
1489       volIDs->AddAt(4178,iModule); iModule++;
1490       volIDs->AddAt(4179,iModule); iModule++;
1491       volIDs->AddAt(4180,iModule); iModule++;
1492       volIDs->AddAt(4181,iModule); iModule++;
1493       volIDs->AddAt(4182,iModule); iModule++;
1494       volIDs->AddAt(4183,iModule); iModule++;
1495       volIDs->AddAt(4184,iModule); iModule++;
1496       volIDs->AddAt(4185,iModule); iModule++;
1497       volIDs->AddAt(4186,iModule); iModule++;
1498       volIDs->AddAt(4187,iModule); iModule++;
1499       volIDs->AddAt(4188,iModule); iModule++;
1500       volIDs->AddAt(4189,iModule); iModule++;
1501       volIDs->AddAt(4190,iModule); iModule++;
1502       volIDs->AddAt(4191,iModule); iModule++;
1503     }
1504     if(sectors[6]==1){//--->cSect = 6 <//---
1505       volIDs->AddAt(2096,iModule); iModule++;
1506       volIDs->AddAt(2097,iModule); iModule++;
1507       volIDs->AddAt(2098,iModule); iModule++;
1508       volIDs->AddAt(2099,iModule); iModule++;
1509       volIDs->AddAt(2100,iModule); iModule++;
1510       volIDs->AddAt(2101,iModule); iModule++;
1511       volIDs->AddAt(2102,iModule); iModule++;
1512       volIDs->AddAt(2103,iModule); iModule++;
1513       volIDs->AddAt(4192,iModule); iModule++;
1514       volIDs->AddAt(4193,iModule); iModule++;
1515       volIDs->AddAt(4194,iModule); iModule++;
1516       volIDs->AddAt(4195,iModule); iModule++;
1517       volIDs->AddAt(4196,iModule); iModule++;
1518       volIDs->AddAt(4197,iModule); iModule++;
1519       volIDs->AddAt(4198,iModule); iModule++;
1520       volIDs->AddAt(4199,iModule); iModule++;
1521       volIDs->AddAt(4200,iModule); iModule++;
1522       volIDs->AddAt(4201,iModule); iModule++;
1523       volIDs->AddAt(4202,iModule); iModule++;
1524       volIDs->AddAt(4203,iModule); iModule++;
1525       volIDs->AddAt(4204,iModule); iModule++;
1526       volIDs->AddAt(4205,iModule); iModule++;
1527       volIDs->AddAt(4206,iModule); iModule++;
1528       volIDs->AddAt(4207,iModule); iModule++;
1529     }
1530      if(sectors[7]==1){ //--->cSect = 7 <//---
1531        volIDs->AddAt(2104,iModule); iModule++;
1532        volIDs->AddAt(2105,iModule); iModule++;
1533        volIDs->AddAt(2106,iModule); iModule++;
1534        volIDs->AddAt(2107,iModule); iModule++;
1535        volIDs->AddAt(2108,iModule); iModule++;
1536        volIDs->AddAt(2109,iModule); iModule++;
1537        volIDs->AddAt(2110,iModule); iModule++;
1538        volIDs->AddAt(2111,iModule); iModule++;
1539        volIDs->AddAt(4208,iModule); iModule++;
1540        volIDs->AddAt(4209,iModule); iModule++;
1541        volIDs->AddAt(4210,iModule); iModule++;
1542        volIDs->AddAt(4211,iModule); iModule++;
1543        volIDs->AddAt(4212,iModule); iModule++;
1544        volIDs->AddAt(4213,iModule); iModule++;
1545        volIDs->AddAt(4214,iModule); iModule++;
1546        volIDs->AddAt(4215,iModule); iModule++;
1547        volIDs->AddAt(4216,iModule); iModule++;
1548        volIDs->AddAt(4217,iModule); iModule++;
1549        volIDs->AddAt(4218,iModule); iModule++;
1550        volIDs->AddAt(4219,iModule); iModule++;
1551        volIDs->AddAt(4220,iModule); iModule++;
1552        volIDs->AddAt(4221,iModule); iModule++;
1553        volIDs->AddAt(4222,iModule); iModule++;
1554        volIDs->AddAt(4223,iModule); iModule++;
1555      }
1556      if(sectors[8]==1){//--->cSect = 8 <//---
1557        volIDs->AddAt(2112,iModule); iModule++;
1558        volIDs->AddAt(2113,iModule); iModule++;
1559        volIDs->AddAt(2114,iModule); iModule++;
1560        volIDs->AddAt(2115,iModule); iModule++;
1561        volIDs->AddAt(2116,iModule); iModule++;
1562        volIDs->AddAt(2117,iModule); iModule++;
1563        volIDs->AddAt(2118,iModule); iModule++;
1564        volIDs->AddAt(2119,iModule); iModule++;
1565        volIDs->AddAt(4224,iModule); iModule++;
1566        volIDs->AddAt(4225,iModule); iModule++;
1567        volIDs->AddAt(4226,iModule); iModule++;
1568        volIDs->AddAt(4227,iModule); iModule++;
1569        volIDs->AddAt(4228,iModule); iModule++;
1570        volIDs->AddAt(4229,iModule); iModule++;
1571        volIDs->AddAt(4230,iModule); iModule++;
1572        volIDs->AddAt(4231,iModule); iModule++;
1573        volIDs->AddAt(4232,iModule); iModule++;
1574        volIDs->AddAt(4233,iModule); iModule++;
1575        volIDs->AddAt(4234,iModule); iModule++;
1576        volIDs->AddAt(4235,iModule); iModule++;
1577        volIDs->AddAt(4236,iModule); iModule++;
1578        volIDs->AddAt(4237,iModule); iModule++;
1579        volIDs->AddAt(4238,iModule); iModule++;
1580        volIDs->AddAt(4239,iModule); iModule++;
1581      }
1582      if(sectors[9]==1){//--->cSect = 9 <//---
1583        volIDs->AddAt(2120,iModule); iModule++;
1584        volIDs->AddAt(2121,iModule); iModule++;
1585        volIDs->AddAt(2122,iModule); iModule++;
1586        volIDs->AddAt(2123,iModule); iModule++;
1587        volIDs->AddAt(2124,iModule); iModule++;
1588        volIDs->AddAt(2125,iModule); iModule++;
1589        volIDs->AddAt(2126,iModule); iModule++;
1590        volIDs->AddAt(2127,iModule); iModule++;
1591        volIDs->AddAt(4240,iModule); iModule++;
1592        volIDs->AddAt(4241,iModule); iModule++;
1593        volIDs->AddAt(4242,iModule); iModule++;
1594        volIDs->AddAt(4243,iModule); iModule++;
1595        volIDs->AddAt(4244,iModule); iModule++;
1596        volIDs->AddAt(4245,iModule); iModule++;
1597        volIDs->AddAt(4246,iModule); iModule++;
1598        volIDs->AddAt(4247,iModule); iModule++;
1599        volIDs->AddAt(4248,iModule); iModule++;
1600        volIDs->AddAt(4249,iModule); iModule++;
1601        volIDs->AddAt(4250,iModule); iModule++;
1602        volIDs->AddAt(4251,iModule); iModule++;
1603        volIDs->AddAt(4252,iModule); iModule++;
1604        volIDs->AddAt(4253,iModule); iModule++;
1605        volIDs->AddAt(4254,iModule); iModule++;
1606        volIDs->AddAt(4255,iModule); iModule++;
1607      }
1608
1609   return volIDs;
1610 }
1611
1612 //___________________________________
1613 TArrayI* AliITSRealignTracks::GetLayersVolUID(Int_t *layer){
1614
1615   TArrayI *out=new TArrayI(2198);
1616   Int_t last=0;
1617   UShort_t voluid;
1618   for(Int_t i=0;i<6;i++){
1619     if(layer[i]==1){
1620       for(Int_t mod=0;mod<AliGeomManager::LayerSize(i+AliGeomManager::kFirstLayer);mod++){
1621         voluid=AliGeomManager::LayerToVolUID(i+AliGeomManager::kFirstLayer,mod);
1622         out->AddAt(voluid,last);
1623         //      printf("voluid %d at position %d \n",out->At(last),last);
1624         last++;
1625       }
1626     }
1627   }
1628   out->Set(last);
1629   return out;
1630 }
1631
1632 //_________________
1633 TArrayI* AliITSRealignTracks::SelectLayerInVolids(const TArrayI *volidsIN,AliGeomManager::ELayerID layer){
1634
1635   Int_t size=volidsIN->GetSize();
1636   Int_t count=0;
1637   for(Int_t j=0;j<size;j++){
1638     if(AliGeomManager::VolUIDToLayer(volidsIN->At(j))==layer)count++;
1639   }
1640   TArrayI *volidsOUT=new TArrayI(count);
1641   count=0;
1642   for(Int_t j=0;j<size;j++){
1643     if(AliGeomManager::VolUIDToLayer(volidsIN->At(j))==layer){
1644       volidsOUT->AddAt(volidsIN->At(j),count);
1645       count++;
1646     }
1647   }
1648   return volidsOUT;
1649 }
1650
1651 //______________________________________________
1652
1653 TArrayI* AliITSRealignTracks::IntersectVolArray(const TArrayI *vol1,const TArrayI *vol2){
1654
1655   Int_t size1=vol1->GetSize();
1656   Int_t size2=vol2->GetSize();
1657   Int_t last=0,volid;
1658   Bool_t found;
1659   TArrayI *volidOut=new TArrayI(size1+size2);
1660
1661   for(Int_t k=0;k<size1;k++){
1662     found=kFALSE;
1663     volid=vol1->At(k);
1664     for(Int_t j=0;j<size2;j++){
1665       if(vol2->At(j)==volid)found=kTRUE;
1666     }
1667     if(found){
1668       volidOut->AddAt(volid,last);
1669       last++;
1670     }
1671   }
1672   volidOut->Set(last);
1673   return volidOut;
1674 }
1675 //_________________________________________
1676
1677 TArrayI* AliITSRealignTracks::JoinVolArrays(const TArrayI *vol1,const TArrayI *vol2){
1678   //!BE CAREFUL: If an index is repeated in vol1 or vol2 will be repeated also in the final array
1679
1680   Int_t size1=vol1->GetSize();
1681   Int_t size2=vol2->GetSize();
1682   Int_t count=0;
1683   UShort_t volid;
1684   Bool_t found;
1685   TArrayI *volidOut=new TArrayI(size1+size2);
1686
1687   for(Int_t k=0;k<size1;k++){
1688     volid=vol1->At(k);
1689     volidOut->AddAt(volid,k);
1690   }
1691
1692   for(Int_t k=0;k<size1;k++){
1693     found=kFALSE;
1694     volid=vol1->At(k);
1695     for(Int_t j=0;j<size2;j++){
1696       if(vol2->At(j)==volid)found=kTRUE;
1697     }
1698     if(!found){
1699       volidOut->AddAt(volid,size1+count);
1700       count++;
1701     }
1702   }
1703   volidOut->Set(size1+count);
1704   return volidOut;
1705 }
1706
1707 //______________________________________
1708
1709 TArrayI* AliITSRealignTracks::ExcludeVolidsFromVolidsArray(const TArrayI *volidsToExclude,const TArrayI *volStart){
1710
1711   Int_t size1=volidsToExclude->GetSize();
1712   Int_t size2=volStart->GetSize();
1713   Int_t last=0;
1714   UShort_t volid;
1715   Bool_t found;
1716   TArrayI *volidOut=new TArrayI(size2);
1717
1718   for(Int_t k=0;k<size2;k++){
1719     found=kFALSE;
1720     volid=volStart->At(k);
1721     for(Int_t j=0;j<size1;j++){
1722       if(volidsToExclude->At(j)==volid){
1723         found=kTRUE;
1724         break;
1725       }
1726     }
1727     if(!found){
1728       volidOut->AddAt(volid,last);
1729       last++;
1730     }
1731   }
1732   volidOut->Set(last);
1733   return volidOut;
1734 }
1735
1736
1737 //________________________________________
1738
1739 TArrayI* AliITSRealignTracks::GetLayerVolumes(Int_t *layer){
1740
1741   TArrayI *out=new TArrayI(2198);
1742   Int_t last=0;
1743   UShort_t voluid;
1744   for(Int_t i=0;i<6;i++){
1745     if(layer[i]==1){
1746       for(Int_t mod=0;mod<AliGeomManager::LayerSize(i+AliGeomManager::kFirstLayer);mod++){
1747         voluid=AliGeomManager::LayerToVolUID(i+AliGeomManager::kFirstLayer,mod);
1748         out->AddAt(voluid,last);
1749         //      printf("voluid %d at position %d \n",out->At(last),last);
1750         last++;
1751       }
1752     }
1753   }
1754   out->Set(last);
1755   return out;
1756 }