1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
16 //---------------------------------
17 //Class to perform the realignment if the Inner Tracking System
18 //with an iterative approach based on track to cluster residuals
19 // minimization. A chi2 function of the residuals is minimized with
20 //respect to alignment parameters. The class allows both single module
21 //realignment and set of modules realignment. Tracks are fitted with
22 //AliTrackFitter* fitters. AliTrackFitterKalman is more suited for
23 //straight line (e.g. cosmic in the absence of magnetic field) but can't
24 //work with helixes. AliTrackFitterRieman is suited for helixes.
25 //The minimization is performed by AliTrackResiduals* classes: default
26 //one is AliTrackResidualsFast (analytic minimization by inversion).
27 //For numerical minimization using MINUIT, use AliTrackResidualChi2.
28 //Methods are present to defined both the set of modules where the tracks
29 //are fittef and the set of modules which are to be realigned
30 //The main method is AlignVolumesITS
32 //Class by: A. Rossi, andrea,rossi@ts.infn.it
35 #include <TStopwatch.h>
37 #include <TClonesArray.h>
42 #include "AliITSRealignTracks.h"
43 #include "AliAlignObjParams.h"
44 #include "AliAlignObj.h"
45 #include "AliGeomManager.h"
46 #include "AliTrackFitter.h"
47 #include "AliTrackFitterKalman.h"
48 #include "AliTrackFitterRieman.h"
49 #include "AliTrackResidualsFast.h"
50 #include "AliTrackResidualsChi2.h"
51 #include "AliTrackResidualsLinear.h"
55 #include <TGeoManager.h>
57 class AliAlignmentTracks;
65 ClassImp(AliITSRealignTracks)
67 const Int_t kreferSect=2;
70 AliITSRealignTracks::AliITSRealignTracks(TString minimizer,Int_t fit,Bool_t covUsed,TString fileintro,TString geometryfile,TString misalignmentFile,TString startingfile):
98 // minimizer="fast"->AliTrackResidualFast minimizer
99 // "minuit"->AliTrackResidualChi2 minimizer
100 // "minuitnorot"->AliTrackResidualChi2 minimizer without rotations degrees of freedom
101 // "linear"->AliTrackResidualLinear minimizer
102 //fit=0-> Riemann Fitter, fit=1->Kalman
103 //fileintro=file into which the Tree with the space points is stored
104 //geometryfile=file containing the geometry
107 SetPointsFilename(fileintro.Data());
108 SetGeomFilename(geometryfile);
110 if(!InitSurveyObjs(kFALSE))AliWarning("Unable to set Survey AlignObjs!");
112 if(startingfile=="")printf("Starting from default geometry \n");
113 else ReadAlignObjs(startingfile.Data(),"ITSAlignObjs");
115 if(misalignmentFile=="")printf("NO FAKE MISALIGNMENT INTRODUCED \n");
117 Bool_t misal=Misalign(misalignmentFile,"ITSAlignObjs");
118 if(!misal)AliWarning("Incorrect fake misalignment filename!");;
121 if(!gGeoManager) AliGeomManager::LoadGeometry(fgeomfilename.Data());
122 if(covUsed)SetCovIsUsed(kTRUE);
123 if(!SelectFitter(fit))AliWarning("Incorrect fitter assignment!");
124 if(!SelectMinimizer(minimizer))AliWarning("Incorrect minimizer assignment!");
131 AliITSRealignTracks::AliITSRealignTracks(const AliITSRealignTracks &realignTracks):
132 AliAlignmentTracks(),
133 fSurveyObjs(new AliAlignObj**(*realignTracks.fSurveyObjs)),
134 fgeomfilename(realignTracks.fgeomfilename),
135 fmintracks(realignTracks.fmintracks),
136 fUpdateCov(realignTracks.fUpdateCov),
137 fVarySigmaY(realignTracks.fVarySigmaY),
138 fCorrModules(new Double_t *(*realignTracks.fCorrModules)),
139 fLimitCorr(realignTracks.fLimitCorr),
140 fsigmaY(realignTracks.fsigmaY),
142 fAlignDrawObjs(realignTracks.fAlignDrawObjs),
143 fCanvPar(realignTracks.fCanvPar),
144 fCanvGr(realignTracks.fCanvGr),
145 fgrIterMeanX(realignTracks.fgrIterMeanX),
146 fgrIterRMSX(realignTracks.fgrIterRMSX),
147 fgrIterMeanY(realignTracks.fgrIterMeanY),
148 fgrIterRMSY(realignTracks.fgrIterRMSY),
149 fgrIterMeanZ(realignTracks.fgrIterMeanZ),
150 fgrIterRMSZ(realignTracks.fgrIterRMSZ),
151 fgrIterMeanPsi(realignTracks.fgrIterMeanPsi),
152 fgrIterRMSPsi(realignTracks.fgrIterRMSPsi),
153 fgrIterMeanTheta(realignTracks.fgrIterMeanTheta),
154 fgrIterRMSTheta(realignTracks.fgrIterRMSTheta),
155 fgrIterMeanPhi(realignTracks.fgrIterMeanPhi),
156 fgrIterRMSPhi(realignTracks.fgrIterRMSPhi)
159 AliWarning("Can't copy AliAlignmentTracks Data member!");
162 AliITSRealignTracks& AliITSRealignTracks::operator=(const AliITSRealignTracks &obj){
163 ////////////////////////
164 // Assignment operator
165 ////////////////////////
166 this->~AliITSRealignTracks();
167 new(this) AliITSRealignTracks(obj);
171 AliITSRealignTracks::~AliITSRealignTracks(){
174 if(fSurveyObjs) DeleteSurveyObjs();
175 if(fAlignDrawObjs) DeleteDrawHists();
176 //delete [] fSurveyObjs;
181 //_____________________________
182 Bool_t AliITSRealignTracks::SelectFitter(Int_t fit,Int_t minTrackPoint){
183 //Method to select the fitter: 0 for AliTrackFitterRieman (use this for helixes)
184 // 1 for AliTrackFitterKalman
185 //minTrackPoint defines the minimum number of points (not rejected by the fit itself)
186 //a track should have to fit it
189 AliTrackFitterKalman *fitter= new AliTrackFitterKalman();
190 fitter->SetMinNPoints(minTrackPoint);
191 SetTrackFitter(fitter);
195 AliTrackFitterRieman *fitter=new AliTrackFitterRieman();
196 fitter->SetMinNPoints(minTrackPoint);
197 SetTrackFitter(fitter);
205 Bool_t AliITSRealignTracks::SelectMinimizer(TString minimizer,Int_t minpoints,const Bool_t *coord){
206 //Method to select the minimizer: "minuit" for AliTrackFitterChi2 (numerical minimization by MINUIT)
207 // "fast" for AliTrackResidualsFast
208 // "linear" for AliTrackResidualsLinear
209 // "minuitnorot" for AliTrackFitterChi2 by
210 // coord[6] allows to fix the degrees of freedom in the minimization (e.g. look only for tranlsations,
211 // or only for rotations). The coord are: dTx,dTy,dTz,dPsi,dTheta,dPhi where "d" stands for
212 // "differential" and "T" for translation. If coord[i] is set to kTRUE then the i coord is fixed
213 // When a coordinate is fixed the value returnd for it is 0
214 // minnpoints fix the minimum number of residuals to perform the minimization: it's not safe
215 // to align a module with a small number of track passing through it since the results could be
216 // not reliable. For single modules the number of residuals and the number of tracks passing
217 // through it and accepted bu the fit procedure coincide. This is not the case for sets of modules,
218 // since a given track can pass through two or more modules in the set (e.g a cosmic track can give
219 // two cluster on a layer)
221 AliTrackResiduals *res;
222 if(minimizer=="minuit"){
223 res = new AliTrackResidualsChi2();
225 for(Int_t j=0;j<6;j++){
226 if(coord[j])res->FixParameter(j);
230 else if(minimizer=="minuitnorot"){
231 res = new AliTrackResidualsChi2();
232 res->FixParameter(3);
233 res->FixParameter(4);
234 res->FixParameter(5);
237 else if(minimizer=="fast"){
238 res = new AliTrackResidualsFast();
240 for(Int_t j=0;j<6;j++){
241 if(coord[j])res->FixParameter(j);
245 else if(minimizer=="linear"){
246 res = new AliTrackResidualsLinear();
250 printf("Trying to set a non existing minimizer! \n");
254 res->SetMinNPoints(minpoints);
260 //____________________________________
261 void AliITSRealignTracks::SetVarySigmaY(Bool_t varysigmay,Double_t sigmaYfixed){
262 //SigmaY is the value of the error along the track direction assigned
263 //to the AliTrackPoint constructed from the extrapolation of the fit of a track
264 //to the module one is realigning. This error simulate the uncertainty on the
265 //position of the cluster in space due to the misalingment of the module (i.e.
266 //you don't the real position and orientation of the plane of the desired extrapolation
267 //but you rely on the fit and consider the point to lie along the track)
270 fVarySigmaY=varysigmay;
272 if(sigmaYfixed>0.)fsigmaY=sigmaYfixed;
274 printf("Negative assignment to sigmaY! set it to default value (1 cm) \n");
280 //_______________________________________
281 void AliITSRealignTracks::RealignITSVolIndependent(Int_t iter1,Int_t iterations,Int_t minNtracks,Int_t layer,Int_t minTrackPoint){
284 //iter1=#iterations inside AliAlignmentTracks::AliAlignVolumesITS method
285 //iterations=#iterations on the all procedure
286 //layer=0->all ITS, otherways the usual notation is considered (1=SPD1,2=SPD2,3=SDD1,4=SDD2,5=SSD1,6=SSD2)
287 //minNtracks=minimun number of tracks passing through a module in order to try to realign the module itsself
288 // if minNtracks<0, minimun number of tracks is |minNtracks|*minNumPoint[layer]/fact (see the code below): this allows a different
289 // choice of the number of tracks required on different layers and to vary these numbers once tuned the relative proportions.
290 //minTrackPoint=minimun number of "good" points required to a track (THE POINT ON THE MODULE THAT IS GOING TO BE REALIGNED
291 //IS NEVER CONSIDERED->max number can be required is 11 for cosmics tracks) for the track being considered in the minimization
294 fTrackFitter->SetMinNPoints(minTrackPoint);
295 TArrayI volIDs2(2200);
301 Int_t iLayer,iLayerToAlign;
303 Int_t minNumPoint[6]={100,100,100,100,50,50};
308 Int_t layerNum,modNum,lastVolid=0;
309 TNtuple *ntVolumeAlign=new TNtuple("ntVolumeAlign","NTuple with volume tried to be realigned","layerNum:modNum:volumeIDnum");
311 TStopwatch *timer=new TStopwatch();
317 for(Int_t iter=0;iter<iterations;iter++){
319 //Starting Independent Modules Realignment
320 for(iLayerToAlign=(Int_t)AliGeomManager::kSPD1;iLayerToAlign<=(Int_t)AliGeomManager::kSSD2;iLayerToAlign++){
321 if(layer!=0&&iLayerToAlign!=layer)continue;
324 for(Int_t k=(Int_t)AliGeomManager::kSPD1;k<=(Int_t)AliGeomManager::kSSD2;k++){
325 size+=AliGeomManager::LayerSize(k);
326 printf("size: %d \n",size);
329 for (Int_t iModule=0;iModule<AliGeomManager::LayerSize(iLayerToAlign);iModule++){
332 if(GetLastIndex(iLayerToAlign-(Int_t)AliGeomManager::kFirstLayer,iModule)<minNumPoint[iLayerToAlign-(Int_t)AliGeomManager::kFirstLayer]*(-1*minNtracks/fact))continue; }
333 else if(GetLastIndex(iLayerToAlign-(Int_t)AliGeomManager::kFirstLayer,iModule)<minNtracks)continue;
335 UShort_t volidAl = AliGeomManager::LayerToVolUID(iLayerToAlign,iModule);
338 volIDsFit.Set(size-1);
339 for (iLayer=AliGeomManager::kSPD1;iLayer<AliGeomManager::kTPC1;iLayer++){
340 for (Int_t iModule2=0;iModule2<AliGeomManager::LayerSize(iLayer);iModule2++){
341 volid = AliGeomManager::LayerToVolUID(iLayer,iModule2);
342 if(AliGeomManager::LayerToVolUID(iLayer,iModule2)==volidAl)continue;
343 volIDsFit.AddAt(volid,j);
347 volIDs.AddAt((Int_t)volidAl,0);
348 if(iter==iterations-1){
349 volIDs2.AddAt(volidAl,lastVolid);
352 volIDs2.AddAt(volidAl,lastVolid);
353 AlignVolumesITS(&volIDs,&volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSSD2,iter1);
358 if((iter+1)%5==0||iter==0||iter==1||iter==2||iter==3||iter==iterations-1){
359 command="RealignObj";
361 command.Append(".root");
362 WriteRealignObjArray(command.Data(),AliGeomManager::kSPD1,AliGeomManager::kSSD2);
367 if(j==0){printf("j=0 \n");return;}
368 for(Int_t k=0;k<volIDs2.GetSize();k++){
369 if(volIDs2.At(k)==0)break;
370 layerNum=AliGeomManager::VolUIDToLayer(volIDs2.At(k),modNum);
371 ntVolumeAlign->Fill(layerNum,modNum,volIDs2.At(k));
373 printf("End of selecting modules cycle: %d modules selected \n",j);
374 TFile *f=new TFile("RealignVolNt.root","RECREATE");
376 ntVolumeAlign->Write();
385 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)
388 // minimizer="fast"->AliTrackResidualFast minimizer
389 // "minuit"->AliTrackResidualChi2 minimizer
390 // "minuitnorot"->AliTrackResidualChi2 minimizer without rotations degrees of freedom
391 // "linear"->AliTrackResidualLinear minimizer
392 //fit=0-> Riemann Fitter, fit=1->Kalman
393 //iter1=#iterations inside AliAlignmentTracks::AliAlignVolumesITS method
394 //iterations=#iterations on the all procedure
395 //layer=0->all ITS, otherways the usual notation is considered (1=SPD1,2=SPD2,3=SDD1,4=SDD2,5=SSD1,6=SSD2)
396 //minNtracks=minimun number of tracks passing through a module in order to try to realign the module itsself
397 // if minNtracks<0, minimun number of tracks is |minNtracks|*minNumPoint[layer]/fact (see the code below): this allows a different
398 // choice of the number of tracks required on different layers and to vary these numbers once tuned the relative proportions.
399 //minTrackPoint=minimun number of "good" points required to a track (THE POINT ON THE MODULE THAT IS GOING TO BE REALIGNED
400 // IS NEVER CONSIDERED->max number that can be required is 11 for cosmics tracks) for the track being considered in the minimization
401 //doGlobal : do global realignment, 0=no, 1= yes, 2=only global
404 TArrayI volIDs2(2200);
410 Int_t iLayer,iLayerToAlign;
412 Int_t minNumPoint[6]={100,100,100,100,50,50};
417 Int_t layerNum,modNum,lastVolid=0;
418 TNtuple *ntVolumeAlign=new TNtuple("ntVolumeAlign","NTuple with volume tried to be realigned","layerNum:modNum:volumeIDnum");
421 if(!SelectFitter(fit))AliWarning("Incorrect fitter assignment!");
422 if(!SelectMinimizer(minimizer))AliWarning("Incorrect minimizer assignment!");
423 if(misalignmentFile=="")printf("NO FAKE MISALIGNMENT INTRODUCED \n");
425 Bool_t misal=Misalign(misalignmentFile,"ITSAlignObjs");
430 TStopwatch *timer=new TStopwatch();
436 if(startingfile=="")printf("Starting from default geometry \n");
438 printf("Starting from AlignObjs file: %s",startingfile.Data());
439 ReadAlignObjs(startingfile.Data(),"ITSAlignObjs");
442 for(Int_t iter=0;iter<iterations;iter++){
443 if(covUsed)SetCovIsUsed(kTRUE);
446 //START HIERARCHY REALIGNMENT
448 if(layer==0&&(doGlobal==1||doGlobal==2)){
449 for(Int_t siter=0;siter<5;siter++){
450 fTrackFitter->SetMinNPoints(2);
451 SetCovUpdate(kFALSE);
452 AlignSPDHalfBarrelToSectorRef(kreferSect,3);
453 // AlignSPDBarrel(1);
454 // if(siter==0)SetCovUpdate(kFALSE);
455 // AlignSPDHalfBarrel(0,3);
456 // SetCovUpdate(kTRUE);
457 AlignSPDHalfBarrelToHalfBarrel(1,3);
458 // AlignSPDHalfBarrelToSectorRef(kreferSect,3);
459 for(Int_t sector=0;sector<10;sector++){
461 if(sector==kreferSect)continue;
462 AlignSPDSectorWithSectors(sector,1);
466 for(Int_t lay=1;lay<=6;lay++){
467 if(!AlignLayerToSector(lay,kreferSect,3))AlignLayerToSPDHalfBarrel(lay,0,3);
469 AlignSPDHalfBarrel(0,3);
471 Int_t layers[6]={2,2,1,0,0,0};
472 fTrackFitter->SetMinNPoints(4);
473 AlignLayersToLayers(layers,1);
475 fTrackFitter->SetMinNPoints(6);
477 layers[3]=1;//{2,2,2,1,0,0};
478 AlignLayersToLayers(layers,1);
480 fTrackFitter->SetMinNPoints(6);
482 layers[4]=1;//{2,2,2,2,1,0};
483 AlignLayersToLayers(layers,1);
485 fTrackFitter->SetMinNPoints(6);
487 layers[5]=1;//{2,2,2,2,2,1};
488 AlignLayersToLayers(layers,1);
491 for(Int_t sector=0;sector<10;sector++){
492 AlignSPDSectorToOuterLayers(sector,1);
494 WriteRealignObjArray("AfterGlobal.root",AliGeomManager::kSPD1,AliGeomManager::kSSD2);
498 if(doGlobal==2)return;
500 if(covUsed)SetCovUpdate(kTRUE);
504 // STARTS INDEPENDENT MOULES REALIGNMENT
506 fTrackFitter->SetMinNPoints(minTrackPoint);
507 for(iLayerToAlign=(Int_t)AliGeomManager::kSPD1;iLayerToAlign<=(Int_t)AliGeomManager::kSSD2;iLayerToAlign++){
508 if(layer!=0&&iLayerToAlign!=layer)continue;
511 for(Int_t k=(Int_t)AliGeomManager::kSPD1;k<=(Int_t)AliGeomManager::kSSD2;k++){
512 size+=AliGeomManager::LayerSize(k);
513 printf("size: %d \n",size);
516 for (Int_t iModule=0;iModule<AliGeomManager::LayerSize(iLayerToAlign);iModule++){
519 if(GetLastIndex(iLayerToAlign-(Int_t)AliGeomManager::kFirstLayer,iModule)<minNumPoint[iLayerToAlign-(Int_t)AliGeomManager::kFirstLayer]*(-1*minNtracks/fact))continue;
521 else if(GetLastIndex(iLayerToAlign-(Int_t)AliGeomManager::kFirstLayer,iModule)<minNtracks)continue;
523 UShort_t volidAl = AliGeomManager::LayerToVolUID(iLayerToAlign,iModule);
526 volIDsFit.Set(size-1);
527 for (iLayer=(Int_t)AliGeomManager::kSPD1;iLayer<(Int_t)AliGeomManager::kTPC1;iLayer++){
528 for (Int_t iModule2=0;iModule2<AliGeomManager::LayerSize(iLayer);iModule2++){
531 volid = AliGeomManager::LayerToVolUID(iLayer,iModule2);
533 if(AliGeomManager::LayerToVolUID(iLayer,iModule2)==volidAl)continue;
534 volIDsFit.AddAt(volid,count);
539 volIDs.AddAt((Int_t)volidAl,0);
540 if(iter==iterations-1){
541 volIDs2.AddAt(volidAl,lastVolid);
544 volIDs2.AddAt(volidAl,lastVolid);
545 AlignVolumesITS(&volIDs,&volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSSD2,iter1);
549 if((iter+1)%2==0||(iter+1)%5==0||iter==0||iter==1||iter==2||iter==3||iter==iterations-1){
550 command="RealignObj";
552 command.Append(".root");
553 WriteRealignObjArray(command.Data(),AliGeomManager::kSPD1,AliGeomManager::kSSD2);
558 if(count==0){printf("count=0 \n");return;}
559 for(Int_t k=0;k<volIDs2.GetSize();k++){
560 if(volIDs2.At(k)==0)break;
561 layerNum=AliGeomManager::VolUIDToLayer(volIDs2.At(k),modNum);
562 ntVolumeAlign->Fill(layerNum,modNum,volIDs2.At(k));
564 printf("End of selecting modules cycle: %d modules selected \n",count);
565 TFile *f=new TFile("RealignVolNt.root","RECREATE");
567 ntVolumeAlign->Write();
577 //______________________________________________________________________________
578 void AliITSRealignTracks::InitAlignObjs()
580 // Initialize the alignment objects array
583 for(Int_t i=0;i<21;i++)cov[i]=0.;
584 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
585 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)
587 Int_t nLayers = AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer;
588 fAlignObjs = new AliAlignObj**[nLayers];
589 for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) {
590 fAlignObjs[iLayer] = new AliAlignObj*[AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer)];
591 for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) {
592 UShort_t volid = AliGeomManager::LayerToVolUID(iLayer+ AliGeomManager::kFirstLayer,iModule);
593 fAlignObjs[iLayer][iModule] = new AliAlignObjParams(AliGeomManager::SymName(volid),volid,0,0,0,0,0,0,kTRUE);
594 fAlignObjs[iLayer][iModule]->SetCorrMatrix(cov);
595 fAlignObjs[iLayer][iModule]->SetUniqueID(0);
600 //______________________________________________________________________________
601 void AliITSRealignTracks::ResetCorrModules(){
602 // Initialize and reset to 0 the array with the information on correlation
604 Int_t nLayers = AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer;
605 fCorrModules = new Double_t*[nLayers];
606 for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) {
607 fCorrModules[iLayer] = new Double_t[AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer)];
608 for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) {
609 fCorrModules[iLayer][iModule]=0.;
614 for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) {
615 for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) {
616 fCorrModules[iLayer][iModule]=0.;
622 //______________________________________________________________________________
623 Bool_t AliITSRealignTracks::InitSurveyObjs(Bool_t infinite,Double_t factor,TString filename,TString arrayName){
624 //Initialize the Survey Objects. There is the possibility to set them equal to external objects
625 // stored in file filename. Otherwuse they are set equal to 0 and with default values for the variances
626 //infinite: set the cov matrix to extremly large values, so that the results of a minimization
627 // are never rejected by the comparison with the survey
628 //factor: multiplication factor for the variances of the cov. matrix of the survey obj.
630 if(fSurveyObjs)DeleteSurveyObjs();
631 Bool_t fromfile=kFALSE;
633 TClonesArray *clnarray;
634 if(!filename.IsNull()){
635 //Initialize from file
636 if(gSystem->AccessPathName(filename.Data(),kFileExists)){
637 printf("Wrong Survey AlignObjs File Name \n");
640 if(arrayName.IsNull()){
641 printf("Null Survey Object Name! \n");
648 // Initialize the alignment objects array with default values
649 Double_t v=1.*factor;
650 if(infinite)v*=100000.;
653 for(Int_t i=0;i<21;i++)cov[i]=0.;
654 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
655 for(Int_t i=3;i<6;i++)cov[i*(i+1)/2+i]=0.03*0.03*180.*180./3.14/3.14*v;//and 30 mrad (~1.7 degrees)for rotations (global ref. sysytem)
657 Int_t nLayers = AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer;
658 fSurveyObjs = new AliAlignObj**[nLayers];
659 for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) {
660 fSurveyObjs[iLayer] = new AliAlignObj*[AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer)];
661 for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) {
662 fSurveyObjs[iLayer][iModule] = 0x0;
667 surveyObj=TFile::Open(filename.Data());
668 if (!surveyObj || !surveyObj->IsOpen()) {
669 AliError(Form("Could not open SurveyObjs file: %s !",filename.Data()));
672 printf("Getting TClonesArray \n");
673 clnarray=(TClonesArray*)surveyObj->Get(arrayName);
674 Int_t size=clnarray->GetSize();
676 for(Int_t ivol=0;ivol<size;ivol++){
677 AliAlignObjParams *a=(AliAlignObjParams*)clnarray->At(ivol);
678 volid=a->GetVolUID();
680 AliGeomManager::ELayerID iLayer = AliGeomManager::VolUIDToLayer(volid,iModule);
681 if(iLayer<=0)continue;
682 if(a->GetUniqueID()==0)continue;
683 printf("Updating survey for volume: %d ,layer: %d module: %d from file\n",volid,iLayer,iModule);
684 fSurveyObjs[iLayer-AliGeomManager::kFirstLayer][iModule] = new AliAlignObjParams(*a);
685 fSurveyObjs[iLayer-AliGeomManager::kFirstLayer][iModule]->SetUniqueID(a->GetUniqueID());
686 fSurveyObjs[iLayer-AliGeomManager::kFirstLayer][iModule]->Print("");
692 for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) {
693 for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) {
694 UShort_t volid = AliGeomManager::LayerToVolUID(iLayer+ AliGeomManager::kFirstLayer,iModule);
695 if(!fSurveyObjs[iLayer][iModule]){
696 printf("Updating survey for volume: %d ,layer: %d module: %d with default values \n",volid,iLayer,iModule);
697 fSurveyObjs[iLayer][iModule] = new AliAlignObjParams(AliGeomManager::SymName(volid),volid,0,0,0,0,0,0,kTRUE);
698 fSurveyObjs[iLayer][iModule]->SetCorrMatrix(cov);
699 fSurveyObjs[iLayer][iModule]->SetUniqueID(0);
710 //______________________________________________________________________________
711 Int_t AliITSRealignTracks::CheckWithSurvey(Double_t factor,const TArrayI *volids){
713 // Check the parameters of the alignment objects in volids (or of all objects if volids is null)
714 // are into the boundaries set by the cov. matrix of the survey objs
715 // Returns the number of objects out of boudaries
716 AliAlignObj *alignObj;
719 Double_t surveycov[21],transl[3],rot[3],survtransl[3],survrot[3];
721 for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) {
722 for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++){
723 volid=AliGeomManager::LayerToVolUIDSafe(iLayer+AliGeomManager::kFirstLayer,iModule);
724 alignObj=GetAlignObj(volid);
725 alignObj->GetPars(transl,rot);
726 fSurveyObjs[iLayer][iModule]->GetCovMatrix(surveycov);
727 fSurveyObjs[iLayer][iModule]->GetPars(survtransl,survrot);
728 if(TMath::Sqrt(TMath::Abs(surveycov[0]))*factor<TMath::Abs(transl[0]-survtransl[0])||TMath::Sqrt(TMath::Abs(surveycov[2]))*factor<TMath::Abs(transl[1]-survtransl[1])||TMath::Sqrt(TMath::Abs(surveycov[5]))*factor<TMath::Abs(transl[2]-survtransl[2])||TMath::Sqrt(TMath::Abs(surveycov[9]))*factor<TMath::Abs(rot[0]-survrot[0])||TMath::Sqrt(TMath::Abs(surveycov[14]))*factor<TMath::Abs(rot[1]-survrot[1])||TMath::Sqrt(TMath::Abs(surveycov[20]))*factor<TMath::Abs(rot[2]-survrot[2])){
729 printf("Results for module %d out of Survey: reinitializing it from survey \n",volid);
730 // *alignObj = *alignObjSurv;
731 alignObj->SetPars(survtransl[0],survtransl[1],survtransl[2],survrot[0],survrot[1],survrot[2]);
732 alignObj->SetUniqueID(0);
733 if(fUpdateCov)alignObj->SetCorrMatrix(surveycov);
742 for(Int_t j=0;j<volids->GetSize();j++){
744 alignObj=GetAlignObj(volid);
745 alignObj->GetPars(transl,rot);
746 iLayer=(Int_t)AliGeomManager::VolUIDToLayerSafe(volid,iModule)-(Int_t)AliGeomManager::kFirstLayer;
747 fSurveyObjs[iLayer][iModule]->GetCovMatrix(surveycov);
748 fSurveyObjs[iLayer][iModule]->GetPars(survtransl,survrot);
749 if(TMath::Sqrt(TMath::Abs(surveycov[0]))*factor<TMath::Abs(transl[0]-survtransl[0])||TMath::Sqrt(TMath::Abs(surveycov[2]))*factor<TMath::Abs(transl[1]-survtransl[1])||TMath::Sqrt(TMath::Abs(surveycov[5]))*factor<TMath::Abs(transl[2]-survtransl[2])||TMath::Sqrt(TMath::Abs(surveycov[9]))*factor<TMath::Abs(rot[0]-survrot[0])||TMath::Sqrt(TMath::Abs(surveycov[14]))*factor<TMath::Abs(rot[1]-survrot[1])||TMath::Sqrt(TMath::Abs(surveycov[20]))*factor<TMath::Abs(rot[2]-survrot[2])){
750 printf("Results for module %d out of Survey: reinitializing it from survey \n",volid);
751 // *alignObj = *alignObjSurv;
752 alignObj->SetPars(survtransl[0],survtransl[1],survtransl[2],survrot[0],survrot[1],survrot[2]);
753 alignObj->SetUniqueID(0);
754 if(fUpdateCov)alignObj->SetCorrMatrix(surveycov);
762 //___________________________________________________________________
764 void AliITSRealignTracks::ResetAlignObjs(Bool_t all,TArrayI *volids)
766 // Reset the alignment objects in volids or all if all=kTRUE
768 for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) {
769 for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++)
770 fAlignObjs[iLayer][iModule]->SetPars(0,0,0,0,0,0);
776 for(Int_t j=0;j<volids->GetSize();j++){
777 layer=(Int_t)AliGeomManager::VolUIDToLayer(volids->At(j),mod)-(Int_t)AliGeomManager::kFirstLayer;
778 fAlignObjs[layer][mod]->SetPars(0,0,0,0,0,0);
783 //______________________________________________-
784 void AliITSRealignTracks::DeleteSurveyObjs()
785 {//destructor for the survey objs. array
787 if(!fSurveyObjs)return;
788 // Delete the alignment objects array
789 for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) {
790 for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++){
791 if (fSurveyObjs[iLayer][iModule]) delete fSurveyObjs[iLayer][iModule];
794 if(fSurveyObjs[iLayer])delete [] fSurveyObjs[iLayer];
797 delete [] fSurveyObjs;
802 //______________________________________________________________________________
803 Bool_t AliITSRealignTracks::ReadAlignObjs(const char *alignObjFileName, const char* arrayName){
805 // Read alignment object from a file: update the alignobj already present with the one in the file
806 // To be replaced by a call to CDB
808 if(gSystem->AccessPathName(alignObjFileName,kFileExists)){
809 printf("Wrong AlignObjs File Name \n");
813 TFile *fRealign=TFile::Open(alignObjFileName);
814 if (!fRealign || !fRealign->IsOpen()) {
815 AliError(Form("Could not open Align Obj File file %s !",alignObjFileName));
818 printf("Getting TClonesArray \n");
819 TClonesArray *clnarray=(TClonesArray*)fRealign->Get(arrayName);
820 Int_t size=clnarray->GetSize();
823 for(Int_t ivol=0;ivol<size;ivol++){
824 AliAlignObjParams *a=(AliAlignObjParams*)clnarray->At(ivol);
825 volid=a->GetVolUID();
827 AliGeomManager::ELayerID iLayer = AliGeomManager::VolUIDToLayer(volid,iModule);
828 if(iLayer<AliGeomManager::kFirstLayer||iLayer>AliGeomManager::kSSD2)continue;
829 printf("Updating volume: %d ,layer: %d module: %d \n",volid,iLayer,iModule);
830 *fAlignObjs[iLayer-AliGeomManager::kFirstLayer][iModule] *= *a;
838 //_________________________________________
839 Bool_t AliITSRealignTracks::FirstAlignmentLayers(const Bool_t *layers,Int_t minNtracks,Int_t iterations,Bool_t fitall,const TArrayI *volidsSet){
841 //Align all modules in the set of layers independently according to a sequence based on the number of tracks passing through a given module
844 TString name="DrawFirstAlignment_Layers";
849 Int_t maxntr=0,nMod=0,modAligned=0,size=0;
850 for(Int_t i=0;i<6;i++){
852 size+=AliGeomManager::LayerSize(i+AliGeomManager::kFirstLayer);
857 TArrayI *volFit=new TArrayI(size);
858 TArrayI *volFit2=new TArrayI(size-1);
859 TArrayI *sequence=new TArrayI(size);
860 TArrayI *volIn=new TArrayI(1);
862 // Initialize the index arrays
863 Int_t nLayers = AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer;
864 lastIndex = new Int_t*[nLayers];
865 for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) {
866 lastIndex[iLayer] = new Int_t[AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer)];
867 for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) {
868 lastIndex[iLayer][iModule] = fLastIndex[iLayer][iModule];
869 if(iLayer<=(AliGeomManager::kSSD2-AliGeomManager::kFirstLayer)&&layers[iLayer]==1){
870 volFit->AddAt(AliGeomManager::LayerToVolUID(iLayer+AliGeomManager::kFirstLayer,iModule),maxntr);
877 while (maxntr>minNtracks){
879 for (Int_t iLayer = 0; iLayer <= (AliGeomManager::kSSD2 - AliGeomManager::kFirstLayer); iLayer++) {
880 if(layers[iLayer]==0)continue;
881 for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) {
882 if(lastIndex[iLayer][iModule]>maxntr){
883 maxntr=lastIndex[iLayer][iModule];
889 if(maxntr>minNtracks){
890 voluid=AliGeomManager::LayerToVolUID(laymax+AliGeomManager::kFirstLayer,modmax);
891 sequence->AddAt(voluid,nMod);
892 lastIndex[laymax][modmax]=0;
900 for(Int_t iter=0;iter<iterations;iter++){
901 if(iter>0&&fDraw)UpdateDraw(sequence,iter,iter);
903 for(Int_t k=0;k<nMod;k++){
905 voluid=sequence->At(k);
906 // ilayer=AliGeomManager::VolUIDToLayer(voluid,imod);
907 volIn->AddAt(voluid,0);
910 for(Int_t j=0;j<nMod;j++){
915 else volFit2->AddAt(sequence->At(j),j-found);
917 volFit2->Set(nMod-1);
920 for(Int_t j=0;j<volFit->GetSize();j++){
921 if(volFit->At(j)!=volIn->At(0))volFit2->AddAt(volFit->At(j),j-found);
927 volFit3=IntersectVolArray(volidsSet,volFit2);
929 else volFit3=new TArrayI(*volFit2);
932 if(AlignVolumesITS(volIn,volFit3,AliGeomManager::kSPD1,AliGeomManager::kTPC1,2))modAligned++;
937 Int_t noutofsurv=CheckWithSurvey(2.,sequence);
938 printf("%d modules into the sequence \n %d modules re-aligned \n %d modules moved far away from survey (-> reset) \n",nMod,modAligned,noutofsurv);
939 name.Append("_iter");
941 name.Append(".root");
942 if(fDraw)WriteHists(name.Data());
946 for(Int_t m=0;m<nLayers;m++){
947 delete [] lastIndex[m];
954 //__________________________________________
955 Bool_t AliITSRealignTracks::FirstAlignmentSPD(Int_t minNtracks,Int_t iterations,Bool_t fitall,const TArrayI *volidsSet){
957 //OBSOLETE METHOD: perform a stand-alone realignment of the SPD modules
958 // based on a sequence constructed accordingly to the number of tracks
959 // passing through each module
967 Int_t maxntr=0,nMod=0,modAligned=0;
968 TArrayI *volFit=new TArrayI(AliGeomManager::LayerSize(1)+AliGeomManager::LayerSize(2));
969 TArrayI *volFit2=new TArrayI(AliGeomManager::LayerSize(1)+AliGeomManager::LayerSize(2)-1);
970 TArrayI *sequence=new TArrayI(AliGeomManager::LayerSize(1)+AliGeomManager::LayerSize(2));
971 TArrayI *volIn=new TArrayI(1);
973 // Initialize the index arrays
974 Int_t nLayers = AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer;
975 lastIndex = new Int_t*[nLayers];
976 for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) {
977 lastIndex[iLayer] = new Int_t[AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer)];
978 for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) {
979 lastIndex[iLayer][iModule] = fLastIndex[iLayer][iModule];
980 if(iLayer+AliGeomManager::kFirstLayer<=AliGeomManager::kSPD2){
981 volFit->AddAt(AliGeomManager::LayerToVolUID(iLayer+AliGeomManager::kFirstLayer,iModule),maxntr);
988 while (maxntr>minNtracks){
990 for (Int_t iLayer = 0; iLayer <= (AliGeomManager::kSPD2 - AliGeomManager::kFirstLayer); iLayer++) {
991 for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) {
992 if(lastIndex[iLayer][iModule]>maxntr){
995 maxntr=lastIndex[iLayer][iModule];
999 if(maxntr>minNtracks){
1000 voluid=AliGeomManager::LayerToVolUID(laymax+AliGeomManager::kFirstLayer,modmax);
1001 sequence->AddAt(voluid,nMod);
1002 lastIndex[laymax][modmax]=0;
1004 volIn->AddAt(voluid,0);
1007 sequence->Set(nMod);
1009 for(Int_t iter=0;iter<iterations;iter++){
1011 for(Int_t k=0;k<nMod;k++){
1013 voluid=sequence->At(k);
1014 // ilayer=AliGeomManager::VolUIDToLayer(voluid,imod);
1015 volIn->AddAt(voluid,0);
1018 for(Int_t j=0;j<nMod;j++){
1023 else volFit2->AddAt(sequence->At(j),j-found);
1025 volFit2->Set(nMod-1);
1028 for(Int_t j=0;j<volFit->GetSize();j++){
1029 if(volFit->At(j)!=volIn->At(0))volFit2->AddAt(volFit->At(j),j-found);
1035 volFit3=IntersectVolArray(volidsSet,volFit2);
1037 else volFit3=new TArrayI(*volFit2);
1040 if(AlignVolumesITS(volIn,volFit3,AliGeomManager::kSPD1,AliGeomManager::kSDD1,2))modAligned++;
1042 // if(volidsSet)delete volFit3;
1045 Int_t noutofsurv=CheckWithSurvey(2.,sequence);
1046 printf("%d modules into the sequence \n %d modules re-aligned \n %d modules moved far away from survey (-> reset) \n",nMod,modAligned,noutofsurv);
1050 for(Int_t m=0;m<nLayers;m++){
1051 delete [] lastIndex[m];
1053 delete [] lastIndex;
1059 //__________________________________
1060 Bool_t AliITSRealignTracks::SPDmodulesAlignToSSD(Int_t minNtracks,Int_t iterations){
1061 //Align each SPD module with at least minNtracks passing through it with respect to SSD
1062 //The selection based on the minimum number of tracks is a fast one:
1063 // the number considere here doesn't coincide with the tracks effectively used then in the
1064 // minimization, it's just the total number of tracks in the sample passing through the module
1065 // The procedure is iterated "iterations" times
1066 Int_t volSSD[6]={0,0,0,0,1,1};
1067 TArrayI *volOuter=GetLayersVolUID(volSSD);
1068 TArrayI *voluid=new TArrayI(1);
1069 for(Int_t iter=0;iter<iterations;iter++){
1071 for(Int_t imod=0;imod<AliGeomManager::LayerSize(AliGeomManager::kSPD1);imod++){ if(GetLastIndex(AliGeomManager::kSPD1-AliGeomManager::kFirstLayer,imod)<minNtracks){
1072 printf("Not enough tracks for module: lay %d mod %d \n",1,imod );
1075 voluid->AddAt(AliGeomManager::LayerToVolUID(AliGeomManager::kSPD1,imod),0);
1076 AlignVolumesITS(voluid,volOuter,AliGeomManager::kSSD1,AliGeomManager::kSSD2,2);
1079 for(Int_t imod=0;imod<AliGeomManager::LayerSize(AliGeomManager::kSPD2);imod++){
1080 if(GetLastIndex(AliGeomManager::kSPD2-AliGeomManager::kFirstLayer,imod)<minNtracks){
1081 printf("Not enough tracks for module: lay %d mod %d \n",2,imod );
1084 voluid->AddAt(AliGeomManager::LayerToVolUID(AliGeomManager::kSPD2,imod),0);
1085 AlignVolumesITS(voluid,volOuter,AliGeomManager::kSSD1,AliGeomManager::kSSD2,2);
1091 //______________________________________________________________________________
1092 Bool_t AliITSRealignTracks::AlignVolumesITS(const TArrayI *volids, const TArrayI *volidsfit,
1093 AliGeomManager::ELayerID layerRangeMin,
1094 AliGeomManager::ELayerID layerRangeMax,
1097 // Align a set of detector volumes.
1098 // Tracks are fitted only within
1099 // the range defined by the user
1100 // (by layerRangeMin and layerRangeMax)
1101 // or within the set of volidsfit
1102 // Repeat the procedure 'iterations' times
1104 Int_t nVolIds = volids->GetSize();
1106 AliError("Volume IDs array is empty!");
1109 Bool_t correlated=kFALSE;
1110 Double_t surveycov[21],transl[3],rot[3],survtransl[3],survrot[3];
1114 Double_t smearing,rotorig[9],normplanevect[3]={0.,0.,0.},normplanevect2[3]={0.,0.,0.};
1116 TMatrixDSym covmatrx(6);
1117 AliAlignObj *modAlign;
1119 // Load only the tracks with at least one
1120 // space point in the set of volume (volids)
1122 AliTrackPointArray **points;
1123 Bool_t failed=kFALSE;
1124 Int_t pointsdim=0,skipped=0;
1125 // Start the iterations
1126 while (iterations > 0){
1127 normplanevect2[0]=0.;
1128 normplanevect2[1]=0.;
1129 normplanevect2[2]=0.;
1134 Int_t nArrays = LoadPoints(volids, points,pointsdim);
1136 if (nArrays < fmintracks||nArrays<=0){
1138 printf("Not enough tracks to try minimization: volUID %d and following in volids \n", volids->At(0));
1139 UnloadPoints(pointsdim, points);
1142 frac=1./(Double_t)nArrays;
1143 AliTrackResiduals *minimizer = CreateMinimizer();
1144 minimizer->SetNTracks(nArrays);
1145 minimizer->InitAlignObj();
1146 AliTrackFitter *fitter = CreateFitter();
1148 //Here prepare to set the plane for GetPCArot
1149 // if(volids->GetSize()==1){//TEMPORARY: to be improved
1150 AliGeomManager::GetOrigRotation(volids->At(0),rotorig);
1151 if((Int_t)AliGeomManager::VolUIDToLayer(volids->At(0))==1){//TEMPORARY: to be improved
1152 normplanevect[0]=-rotorig[1];
1153 normplanevect[1]=-rotorig[4];
1154 normplanevect[2]=0.;
1157 normplanevect[0]=rotorig[1];
1158 normplanevect[1]=rotorig[4];
1159 normplanevect[2]=0.;
1162 // phiglob=TMath::ATan2(normplanevect[1],normplanevect[0]);
1164 modAlign=GetAlignObj(volids->At(0));
1165 modAlign->GetMatrix(hM);
1166 deltarot=hM.GetRotationMatrix();
1167 for(Int_t j=0;j<3;j++){
1168 for(Int_t i=0;i<3;i++){
1169 normplanevect2[j]+=deltarot[j*3+i]*normplanevect[i];
1171 // printf("Here the difference: norm1[%d]=%f norm2[%d]=%f \n",j,normplanevect[j],j,normplanevect2[j]);
1175 if(modAlign->GetUniqueID()==0)smearing=fsigmaY;
1177 modAlign->GetCovMatrix(covmatrx);
1178 smearing=5.*5.*(covmatrx(0,0)+covmatrx(1,1)+covmatrx(2,2)+10.*10.*covmatrx(3,3)+10.*10.*covmatrx(4,4)+10.*10.*covmatrx(5,5))/6.;
1179 //This is a sort of average: the trace with the variances of the angles
1180 //weighted with 10 cm divided per 6 and the result multiplied per 25
1181 // (the sqrt would be 5 times a sort of "mean sigma" )
1185 else smearing=fsigmaY;
1186 printf("This is the sigmaY value: %f \n",smearing);
1187 // the plane will be set into the loop on tracks
1190 for (Int_t iArray = 0; iArray < nArrays; iArray++) {
1191 if (!points[iArray]) continue;
1192 points[iArray]->Sort(kTRUE);
1193 fitter->SetTrackPointArray(points[iArray], kFALSE);
1194 // printf("Here normplane vect: %f \n",normplanevect2[1]); //TO BE REPLACED BY fitter->SetNormPlaneVect(normplanevect2);
1195 if (fitter->Fit(volids,volidsfit,layerRangeMin,layerRangeMax) == kFALSE) continue;
1201 TArrayI *volparray=new TArrayI(points[iArray]->GetNPoints());
1202 for(Int_t point=0;point<points[iArray]->GetNPoints();point++){
1203 points[iArray]->GetPoint(p,point);
1204 volparray->AddAt(p.GetVolumeID(),point);
1206 TArrayI *volpArray=ExcludeVolidsFromVolidsArray(volids,volparray);
1207 for(Int_t point=0;point<volpArray->GetSize();point++){
1208 layer=(Int_t)AliGeomManager::VolUIDToLayerSafe(volpArray->At(point),module);
1209 if(fCorrModules[layer-AliGeomManager::kFirstLayer][module]>fLimitCorr){
1211 // printf("volid %d, iarray = %d : skipping %d for Volume: %d \n",volids->At(0),iArray,skipped,volpArray->At(point));
1217 for(Int_t point=0;point<volpArray->GetSize();point++){
1218 layer=(Int_t)AliGeomManager::VolUIDToLayerSafe(volpArray->At(point),module);
1219 //printf("Number of common tracks: %d \n",fCorrModules[layer-AliGeomManager::kFirstLayer][module]);
1220 fCorrModules[layer-AliGeomManager::kFirstLayer][module]+=frac;
1232 AliTrackPointArray *pVolId,*pTrack;
1233 fitter->GetTrackResiduals(pVolId,pTrack);
1234 minimizer->AddTrackPointArrays(pVolId,pTrack);
1237 printf("Number of tracks considered: %d \n",nArrays);
1238 frac=(Double_t)skipped/(Double_t)nArrays;
1239 printf("Number of tracks skipped cause of correlation: %d (fraction: %f )\n",skipped,frac);
1241 Int_t ntracks=minimizer->GetNFilledTracks();
1242 frac=(Double_t)ntracks/(Double_t)nArrays;
1243 printf("Number of tracks into the minimizer: %d (fraction: %f )\n",ntracks,frac);
1244 if(ntracks<=fmintracks){
1245 printf("Not enough good tracks found: could not find parameter for volume %d (and following in volids)\n",volids->At(0));
1246 UnloadPoints(pointsdim, points);
1251 failed=(!minimizer->Minimize());
1253 // Update the alignment object(s)
1254 if (fDoUpdate) for (Int_t iVolId = 0; iVolId < nVolIds; iVolId++) {
1255 UShort_t volid = (*volids)[iVolId];
1258 AliGeomManager::ELayerID iLayer = AliGeomManager::VolUIDToLayer(volid,iModule);
1259 AliAlignObj *alignObj = fAlignObjs[iLayer-AliGeomManager::kFirstLayer][iModule];
1261 //Check the last minimization is not too large
1262 minimizer->GetAlignObj()->GetPars(transl,rot);
1263 fSurveyObjs[iLayer-AliGeomManager::kFirstLayer][iModule]->GetCovMatrix(surveycov);
1264 fSurveyObjs[iLayer-AliGeomManager::kFirstLayer][iModule]->GetPars(survtransl,survrot);
1265 if(TMath::Sqrt(TMath::Abs(surveycov[0]))*2<TMath::Abs(transl[0]-survtransl[0])||TMath::Sqrt(TMath::Abs(surveycov[2]))*2<TMath::Abs(transl[1]-survtransl[1])||TMath::Sqrt(TMath::Abs(surveycov[5]))*2<TMath::Abs(transl[2]-survtransl[2])||TMath::Sqrt(TMath::Abs(surveycov[9]))*2<TMath::Abs(rot[0]-survrot[0])||TMath::Sqrt(TMath::Abs(surveycov[14]))*2<TMath::Abs(rot[1]-survrot[1])||TMath::Sqrt(TMath::Abs(surveycov[20]))*2<TMath::Abs(rot[2]-survrot[2])){
1266 printf("Results for module %d too large: can't update them \n",volid);
1267 alignObj->SetUniqueID(2);
1274 *alignObj *= *minimizer->GetAlignObj();
1275 alignObj->SetUniqueID(1);
1278 alignObj->GetCovMatrix(covmatrx);
1279 *alignObj *= *minimizer->GetAlignObj();
1280 alignObj->SetCorrMatrix(covmatrx);
1281 alignObj->SetUniqueID(1);
1284 /*alignObj->GetPars(transl,rot);
1286 if(TMath::Sqrt(TMath::Abs(surveycov[0]))*20<TMath::Abs(transl[0])||TMath::Sqrt(TMath::Abs(surveycov[2]))*20<TMath::Abs(transl[1])||TMath::Sqrt(TMath::Abs(surveycov[5]))*20<TMath::Abs(transl[2])||TMath::Sqrt(TMath::Abs(surveycov[9]))*20<TMath::Abs(rot[0])||TMath::Sqrt(TMath::Abs(surveycov[14]))*20<TMath::Abs(rot[1])||TMath::Sqrt(TMath::Abs(surveycov[20]))*20<TMath::Abs(rot[2])){
1287 printf("Results for module %d out of Survey: reinitializing it from survey \n",volid);
1288 // *alignObj = *alignObjSurv;
1289 alignObj->SetPars(0.,0.,0.,0.,0.,0.);
1290 alignObj->SetUniqueID(0);
1291 if(fUpdateCov)alignObj->SetCorrMatrix(surveycov);
1297 if(iterations==1)alignObj->Print("");
1300 printf("Minimization failed: cannot update AlignObj for volume: %d \n",volid);
1303 UnloadPoints(pointsdim,points);
1305 minimizer->InitAlignObj();
1316 //______________________________________________
1317 Bool_t AliITSRealignTracks::AlignSPDBarrel(Int_t iterations){
1318 //Align the SPD barrel "iterations" times
1320 Int_t size=0,size2=0;
1321 Int_t layers[6]={1,1,0,0,0,0};
1322 for(Int_t k=1;k<=2;k++){
1323 size+=AliGeomManager::LayerSize(k);
1325 for(Int_t k=3;k<=6;k++){
1326 size2+=AliGeomManager::LayerSize(k);
1327 printf("size: %d \n",size2);
1330 printf("Aligning SPDBarrel: nmodules: %d \n",size);
1331 printf("Fitting modules: %d \n",size2);
1333 TArrayI *volIDs=GetLayersVolUID(layers);
1340 TArrayI *volIDsFit=GetLayersVolUID(layers);
1342 AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSDD1,AliGeomManager::kTPC1,iterations);
1347 //______________________
1348 Bool_t AliITSRealignTracks::AlignSPDHalfBarrel(Int_t method,Int_t iterations){
1349 //Align a SPD Half barrel "iterations" times
1350 //method 0 : align SPDHalfBarrel Up without using the points on SPD Half Barrel down in the fits (only outer layers)
1351 //method 1 : align SPDHalfBarrel Down without using the points on SPD Half Barrel up in the fits (only outer layers)
1352 //method 10 : align SPDHalfBarrel Up using also the points on SPD Half Barrel down in the fits (and points on outer layers)
1353 //method 11 : align SPDHalfBarrel Down using also the points on SPD Half Barrel up in the fits (and points on outer layers)
1355 Int_t size=0,size2=0;
1356 Int_t layers[6]={0,0,1,1,1,1};
1357 Int_t sectorsUp[10]={1,1,1,1,1,0,0,0,0,0};
1358 Int_t sectorsDown[10]={0,0,0,0,0,1,1,1,1,1};
1361 if(method==0)updownstr="UpNoDown";
1362 else if (method==1)updownstr="DownNoUp";
1363 else if (method==10)updownstr="UpWithDown";
1364 else if (method==11)updownstr="DownWithUp";
1366 AliWarning("Wrong AlignSPDHalfBarrel method selected ");
1370 for(Int_t i=1;i<=2;i++){
1371 size+=AliGeomManager::LayerSize(i);
1374 for(Int_t i=3;i<=6;i++){
1375 size2+=AliGeomManager::LayerSize(i);
1379 if(method==10||method==11)size2+=size;
1381 printf("Aligning SPDHalfBarrel %s: nmodules: %d \n",updownstr.Data(),size);
1382 printf("Fitting modules: %d \n",size2);
1383 TArrayI *volIDsFit2;
1384 TArrayI *volids = NULL;
1385 TArrayI *volIDsFit=GetLayersVolUID(layers);
1386 if(method==0||method==10)volids=GetSPDSectorsVolids(sectorsUp);
1387 if(method==1||method==11)volids=GetSPDSectorsVolids(sectorsDown);
1389 if(method==10)volIDsFit2=JoinVolArrays(GetSPDSectorsVolids(sectorsDown),volIDsFit);
1390 else if(method==11)volIDsFit2=JoinVolArrays(GetSPDSectorsVolids(sectorsUp),volIDsFit);
1391 else volIDsFit2=volIDsFit;
1393 AlignVolumesITS(volids,volIDsFit2,AliGeomManager::kSPD1,AliGeomManager::kSSD2,iterations);
1399 //______________________________________________________
1400 Bool_t AliITSRealignTracks::AlignLayer(Int_t layer,Int_t iterations){
1401 //Align the layer "layer" iterations times
1403 Int_t size=0,size2=0;
1404 Int_t layers[6]={0,0,0,0,0,0};
1406 TString layerstr[6]={"SPD1","SPD2","SDD1","SDD2","SSD1","SSD2"};
1407 for(Int_t k=1;k<=6;k++){
1408 if(k!=layer)size2+=AliGeomManager::LayerSize(k);
1410 size=AliGeomManager::LayerSize(layer);
1412 printf("Aligning layer %s, nmodules %d ,fitted modules %d \n",layerstr[layer-1].Data(),size,size2);
1415 TArrayI *volIDs=GetLayersVolUID(layers);
1423 TArrayI *volIDsFit=GetLayersVolUID(layers);
1425 AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSDD1,AliGeomManager::kSSD2,iterations);
1430 //___________________________________________
1432 Bool_t AliITSRealignTracks::AlignLayersToLayers(const Int_t *layer,Int_t iterations){
1434 //Align the set of layers A with respect to the set of layers B iterations time.
1435 //The two sets A and B are defined into *layer==layer[6] the following way:
1436 // layer[i]=0 the layer is skipped both in the fits than in the minimization
1437 // layer[i]=1 the layer is skipped in the fits and considered in the minimization
1438 // layer[i]=2 the layer is considered in the fits and skipped in the minimization
1439 // layer[i]=3 the layer is considered both in the fits and in the minimization
1442 Int_t size=0,size2=0,j=0,k=0;
1444 TString layerstr[6]={"SPD1","SPD2","SDD1","SDD2","SSD1","SSD2"};
1445 TString command="",str;
1446 for(Int_t i=1;i<=6;i++){
1447 if(layer[i-1]==1||layer[i-1]==3){
1448 size+=AliGeomManager::LayerSize(i);
1449 command.Append(" ");
1450 command.Append(layerstr[i-1]);
1452 if(layer[i-1]==2||layer[i-1]==3){
1453 size2+=AliGeomManager::LayerSize(i);
1455 str.Append(layerstr[i-1]);
1459 printf("Aligning layers %s To layers %s, nmodules %d ,fitted modules %d \n",command.Data(),str.Data(),size,size2);
1462 TArrayI volIDs(size);
1463 TArrayI volIDsFit(size2);
1465 for (iLayer=(Int_t)AliGeomManager::kSPD1;iLayer<(Int_t)AliGeomManager::kTPC1;iLayer++){
1466 if(layer[iLayer-AliGeomManager::kFirstLayer]==0)continue;
1467 if(layer[iLayer-AliGeomManager::kFirstLayer]==1){
1468 for (Int_t iModule2=0;iModule2<AliGeomManager::LayerSize(iLayer);iModule2++){
1469 volid = AliGeomManager::LayerToVolUID(iLayer,iModule2);
1470 volIDs.AddAt(volid,j);
1474 else if(layer[iLayer-AliGeomManager::kFirstLayer]==2){
1475 for (Int_t iModule2=0;iModule2<AliGeomManager::LayerSize(iLayer);iModule2++){
1476 volid = AliGeomManager::LayerToVolUID(iLayer,iModule2);
1477 volIDsFit.AddAt(volid,k);
1481 else if(layer[iLayer-AliGeomManager::kFirstLayer]==3){
1482 for (Int_t iModule2=0;iModule2<AliGeomManager::LayerSize(iLayer);iModule2++){
1483 volid = AliGeomManager::LayerToVolUID(iLayer,iModule2);
1484 volIDs.AddAt(volid,j);
1486 volIDsFit.AddAt(volid,k);
1492 AlignVolumesITS(&volIDs,&volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSSD2,iterations);
1497 //______________________________________________
1499 Bool_t AliITSRealignTracks::AlignSPDSectorToOuterLayers(Int_t sector,Int_t iterations){
1500 //Align the SPD sector "sector" with respect to outer layers iterations times
1503 Int_t layers[6]={0,0,1,1,1,1};
1505 Int_t sectorsIN[10]={0,0,0,0,0,0,0,0,0,0};
1506 Int_t sectorsFit[10]={1,1,1,1,1,1,1,1,1,1};
1512 sectorsIN[sector]=1;
1513 sectorsFit[sector]=0;
1514 TArrayI *volIDs=GetSPDSectorsVolids(sectorsIN);
1517 volIDsFit=JoinVolArrays(GetSPDSectorsVolids(sectorsFit),GetLayersVolUID(layers));
1519 else volIDsFit=GetLayersVolUID(layers);
1521 printf("Aligning SPD sector %d: nmodules: %d \n",sector,volIDs->GetSize());
1522 printf("Fitting modules: %d \n",volIDsFit->GetSize());
1524 AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSPD2,iterations);
1529 //______________________________________________
1530 Bool_t AliITSRealignTracks::AlignSPDSectorWithSectors(Int_t sector,Int_t iterations){
1531 //Align the SPD sector "sector" with respect to the other SPD sectors iterations times
1533 Int_t sectorsIN[10]={0,0,0,0,0,0,0,0,0,0};
1534 Int_t sectorsFit[10]={1,1,1,1,1,1,1,1,1,1};
1536 sectorsIN[sector]=1;
1537 sectorsFit[sector]=0;
1538 TArrayI *volIDs=GetSPDSectorsVolids(sectorsIN);
1539 TArrayI *volIDsFit=GetSPDSectorsVolids(sectorsFit);;
1541 printf("Aligning SPD sector %d: nmodules: %d \n",sector,volIDs->GetSize());
1542 printf("Fitting modules: %d \n",volIDsFit->GetSize());
1545 AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSDD1,iterations);
1552 //___________________________________________________
1553 Bool_t AliITSRealignTracks::AlignSPDSectorsWithSectors(const Int_t *sectorsIN,const Int_t *sectorsFit,Int_t iterations){
1554 //Align SPD sectors defined in "sectorsIN" with respect to
1555 //SPD sectors defined in "sectorsFit" iterations time
1557 TArrayI *volIDs=GetSPDSectorsVolids(sectorsIN);
1558 TArrayI *volIDsFit=GetSPDSectorsVolids(sectorsFit);;
1560 printf("Aligning SPD sectors: modules: %d \n",volIDs->GetSize());
1561 printf("Fitting modules: %d \n",volIDsFit->GetSize());
1565 return AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSDD1,iterations);;
1568 //___________________________________________________
1569 Bool_t AliITSRealignTracks::AlignSPDStaves(const Int_t *staves,const Int_t *sectorsIN,const Int_t *sectorsFit,Int_t iterations){
1570 //Align SPD staves defined by staves and sectorsIN with respect to sectorsFit volumes iterations times
1572 TArrayI *volIDs=GetSPDStavesVolids(sectorsIN,staves);
1573 TArrayI *volIDsFit=GetSPDSectorsVolids(sectorsFit);
1575 if(volIDs->GetSize()==0){
1576 printf("EMPTY ARRAY !! \n");
1579 printf("Aligning SPD staves: modules: %d \n",volIDs->GetSize());
1580 printf("Fitting modules: %d \n",volIDsFit->GetSize());
1582 TArrayI *volIDsFit2=ExcludeVolidsFromVolidsArray(volIDs,volIDsFit);
1583 return AlignVolumesITS(volIDs,volIDsFit2,AliGeomManager::kSPD1,AliGeomManager::kSSD1,iterations);
1587 //___________________________________________
1589 Bool_t AliITSRealignTracks::AlignLayerToSPDHalfBarrel(Int_t layer,Int_t updown,Int_t iterations){
1590 //Align the layer "layer" with respect to SPD Half Barrel Up (updowon=0)
1591 //or Down (updown=1) iterations times
1595 Int_t sectorsDown[10]={0,0,0,0,0,1,1,1,1,1};
1596 Int_t sectorsUp[10]={1,1,1,1,1,0,0,0,0,0};
1597 TString layerstr[6]={"SPD1","SPD2","SDD1","SDD2","SSD1","SSD2"};
1599 Int_t layers[6]={0,0,0,0,0,0};
1601 Int_t size=AliGeomManager::LayerSize(layer);
1602 TArrayI *volIDs=GetLayersVolUID(layers);
1605 volIDsFit=GetSPDSectorsVolids(sectorsUp);
1606 printf("Aligning layer %s, nmodules %d ,to half barrel Up \n",layerstr[layer-1].Data(),size);
1609 volIDsFit=GetSPDSectorsVolids(sectorsDown);
1610 printf("Aligning layer %s, nmodules %d ,to half barrel Down \n",layerstr[layer-1].Data(),size);
1613 printf("Wrong Half Barrel selection! \n");
1617 AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSSD2,iterations);
1622 //___________________________________________
1624 Bool_t AliITSRealignTracks::AlignLayerToSector(Int_t layer,Int_t sector,Int_t iterations){
1625 //Align the layer "layer" with respect to SPD sector "sector" iterations times
1628 printf("Wrong Sector selection! \n");
1631 Int_t sectors[10]={0,0,0,0,0,0,0,0,0,0};
1633 TString layerstr[6]={"SPD1","SPD2","SDD1","SDD2","SSD1","SSD2"};
1635 Int_t layers[6]={0,0,0,0,0,0};
1637 TArrayI *volIDs=GetLayersVolUID(layers);
1638 Int_t size=AliGeomManager::LayerSize(layer);
1641 volIDsFit=GetSPDSectorsVolids(sectors);
1642 printf("Aligning layer %s, nmodules %d ,to half barrel Up \n",layerstr[layer-1].Data(),size);
1644 AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSSD2,iterations);
1649 //_______________________________________________
1651 Bool_t AliITSRealignTracks::AlignSPDHalfBarrelToHalfBarrel(Int_t updown,Int_t iterations){
1652 //Align the SPD Half Barrel Up[Down] with respect to HB Down[Up] iterations time if
1656 Int_t sectorsDown[10]={0,0,0,0,0,1,1,1,1,1};
1657 Int_t sectorsUp[10]={1,1,1,1,1,0,0,0,0,0};
1659 TArrayI *volIDsUp=GetSPDSectorsVolids(sectorsUp);
1660 TArrayI *volIDsDown=GetSPDSectorsVolids(sectorsDown);
1663 printf("Aligning SPD HalfBarrel up to half Barrel down : nmodules: %d \n",volIDsUp->GetSize());
1664 printf("Fitting modules: %d \n",volIDsDown->GetSize());
1665 AlignVolumesITS(volIDsUp,volIDsDown,AliGeomManager::kSPD1,AliGeomManager::kSPD2,iterations);
1668 printf("Aligning SPD HalfBarrel down to half Barrel Up : nmodules: %d \n",volIDsDown->GetSize());
1669 printf("Fitting modules: %d \n",volIDsUp->GetSize());
1670 AlignVolumesITS(volIDsDown,volIDsUp,AliGeomManager::kSPD1,AliGeomManager::kSPD2,iterations);
1673 printf("Wrong Half Barrel selection! \n");
1681 //_______________________
1682 Bool_t AliITSRealignTracks::AlignSPDHalfBarrelToSectorRef(Int_t sector,Int_t iterations){
1683 //Align the SPD Half Barrel Down with respect to sector "sector" iterations times
1685 Int_t sectorsIN[10]={0,0,0,0,0,1,1,1,1,1};
1686 Int_t sectorsFit[10]={0,0,0,0,0,0,0,0,0,0};
1688 sectorsFit[sector]=1;
1690 TArrayI *volIDs=GetSPDSectorsVolids(sectorsIN);
1691 TArrayI *volIDsFit=GetSPDSectorsVolids(sectorsFit);
1693 printf("Aligning SPD HalfBarrel to sector 0 %d: nmodules: %d \n",sector,volIDs->GetSize());
1694 printf("Fitting modules: %d \n",volIDsFit->GetSize());
1697 AlignVolumesITS(volIDs,volIDsFit,AliGeomManager::kSPD1,AliGeomManager::kSPD2,iterations);
1702 //_________________________________________
1703 Bool_t AliITSRealignTracks::AlignSPD1SectorRef(Int_t sector,Int_t iterations){
1704 //OBSOLETE METHOD: Align the SPD1 modules of sector "sector" with respect
1705 // to the other SPD volumes iterations times
1707 Int_t sectorsIN[10]={0,0,0,0,0,0,0,0,0,0};
1708 Int_t sectorsFit[10]={1,1,1,1,1,1,1,1,1,1};
1709 sectorsIN[sector]=1;
1710 sectorsFit[sector]=0;
1711 TArrayI *volIDs=GetSPDSectorsVolids(sectorsIN);
1712 TArrayI *volIDsFit=GetSPDSectorsVolids(sectorsFit);
1713 Int_t size=volIDs->GetSize();
1714 Int_t size2=volIDsFit->GetSize();
1718 TArrayI *volIDsSPD1=new TArrayI(size-8);
1719 TArrayI *volIDsFit2=new TArrayI(size2+8);
1721 for(Int_t j=0;j<size;j++){
1722 volID=volIDs->At(j);
1723 if(AliGeomManager::VolUIDToLayer(volID)==AliGeomManager::kSPD1){
1724 volIDsSPD1->AddAt(volID,size2+k);
1727 else volIDsFit2->AddAt(volID,j-k);
1731 for(Int_t j=0;j<size2;j++){
1732 volID=volIDsFit->At(j);
1733 volIDsFit2->AddAt(volID,size-k+j);
1736 printf("Aligning SPD Sector %d: nmodules: %d \n",sector,volIDsSPD1->GetSize());
1737 printf("Fitting modules: %d \n",volIDsFit2->GetSize());
1739 AlignVolumesITS(volIDsSPD1,volIDsFit2,AliGeomManager::kSPD1,AliGeomManager::kSPD2,iterations);
1744 //_____________________________________________
1746 AliAlignObjParams* AliITSRealignTracks::MediateAlignObj(const TArrayI *volIDs,Int_t lastVolid){
1747 //TEMPORARY METHOD: perform an average of the values of the parameters of the AlignObjs
1748 // defined by the array volIDs up to lastVolid position in this array
1749 //The aim of such a method is to look for collective movement of a given set of modules
1754 Double_t *rot,*transl;
1755 Double_t rotSum[9],translSum[3]={0.,0.,0.};
1756 for(Int_t k=0;k<8;k++)rotSum[k]=0.;
1759 for(Int_t ivol=0;ivol<lastVolid;ivol++){
1760 // volid=volIDs->At(ivol);
1762 GetAlignObj(volIDs->At(ivol))->GetMatrix(hm);
1764 rot=hm.GetRotationMatrix();
1765 transl=hm.GetTranslation();
1767 for(Int_t j=0;j<9;j++)rotSum[j]+=rot[j];
1768 for(Int_t jt=0;jt<3;jt++)translSum[jt]+=transl[jt];
1771 for(Int_t j=0;j<9;j++)rotSum[j]=rotSum[j]/lastVolid;
1772 for(Int_t jt=0;jt<3;jt++)translSum[jt]=translSum[jt]/lastVolid;
1774 else printf("Try to mediate results for zero modules \n");
1776 hm.SetRotation(rotSum);
1777 hm.SetTranslation(translSum);
1781 AliAlignObjParams *alignObj=new AliAlignObjParams("average", 0,hm, kTRUE);
1787 //________________________________________________
1788 TArrayI* AliITSRealignTracks::GetSPDStavesVolids(const Int_t *sectors,const Int_t* staves){
1791 // This method gets the volID Array for the chosen staves into the
1792 // chosen sectors. You have to pass an array (10 dim) with a 1 for each
1793 // selected sector and an array (6 dim) with a 1 for each chosen stave.
1794 // The staves are numbered in this way: 0,1 for SPD1 and 2,3,4,5 for SPD2
1795 // i.e. sectors[10] = {1,1,0,0,0,0,0,0,1,0} -> Sector 0, 1, 9 selected.
1796 // staves[6]={0,1,1,0,0,1} -> Staves 1 on SPD1 and 0 and 3 on SPD2 selected
1798 Int_t nSect=0,nStaves=0;
1802 for(Int_t co=0;co<10;co++){ //counts the number of sectors chosen
1803 if(sectors[co]==1) nSect++;
1806 for(Int_t co=0;co<6;co++){ //counts the number of sectors chosen
1807 if(staves[co]==1) nStaves++;
1810 if(nSect<1||nStaves<1){ //if no sector chosen -> exit
1811 Printf("Error! No Sector/s or staves Selected!");
1815 TArrayI *volIDs = new TArrayI(nSect*nStaves*4);
1816 TString stave="/Stave",str,symn,laystr;
1818 TArrayI *sectvol=GetSPDSectorsVolids(sectors);
1821 for(Int_t k=0;k<2;k++){
1825 for(Int_t i=0;i<sectvol->GetSize();i++){
1826 symn=AliGeomManager::SymName(sectvol->At(i));
1827 if(symn.Contains(str)&&symn.Contains(laystr)){
1828 // printf("Adding: %s \n",symn.Data());
1829 volIDs->AddAt(sectvol->At(i),last);
1837 for(Int_t k=2;k<6;k++){
1841 for(Int_t i=0;i<sectvol->GetSize();i++){
1842 symn=AliGeomManager::SymName(sectvol->At(i));
1843 if(symn.Contains(str)&&symn.Contains(laystr)){
1844 volIDs->AddAt(sectvol->At(i),last);
1845 printf("Adding: %s \n",symn.Data());
1856 //________________________________________________
1857 TArrayI* AliITSRealignTracks::GetSPDSectorsVolids(const Int_t *sectors)
1860 // This method gets the volID Array for the chosen sectors.
1861 // You have to pass an array with a 1 for each selected sector.
1862 // i.e. sectors[10] = {1,1,0,0,0,0,0,0,1,0} -> Sector 0, 1, 9 selected.
1869 for(Int_t co=0;co<10;co++){ //counts the number of sectors chosen
1870 if(sectors[co]==1) nSect++;
1873 if(nSect<1){ //if no sector chosen -> exit
1874 Printf("Error! No Sector/s Selected!");
1878 TArrayI *volIDs = new TArrayI(nSect*24);
1880 if(sectors[0]==1){ //--->cSect = 0 <---
1881 volIDs->AddAt(2048,iModule); iModule++;
1882 volIDs->AddAt(2049,iModule); iModule++;
1883 volIDs->AddAt(2050,iModule); iModule++;
1884 volIDs->AddAt(2051,iModule); iModule++;
1885 volIDs->AddAt(2052,iModule); iModule++;
1886 volIDs->AddAt(2053,iModule); iModule++;
1887 volIDs->AddAt(2054,iModule); iModule++;
1888 volIDs->AddAt(2055,iModule); iModule++;
1889 volIDs->AddAt(4096,iModule); iModule++;
1890 volIDs->AddAt(4097,iModule); iModule++;
1891 volIDs->AddAt(4098,iModule); iModule++;
1892 volIDs->AddAt(4099,iModule); iModule++;
1893 volIDs->AddAt(4100,iModule); iModule++;
1894 volIDs->AddAt(4101,iModule); iModule++;
1895 volIDs->AddAt(4102,iModule); iModule++;
1896 volIDs->AddAt(4103,iModule); iModule++;
1897 volIDs->AddAt(4104,iModule); iModule++;
1898 volIDs->AddAt(4105,iModule); iModule++;
1899 volIDs->AddAt(4106,iModule); iModule++;
1900 volIDs->AddAt(4107,iModule); iModule++;
1901 volIDs->AddAt(4108,iModule); iModule++;
1902 volIDs->AddAt(4109,iModule); iModule++;
1903 volIDs->AddAt(4110,iModule); iModule++;
1904 volIDs->AddAt(4111,iModule); iModule++;
1906 if(sectors[1]==1){ //--->cSect = 1 <//---
1907 volIDs->AddAt(2056,iModule); iModule++;
1908 volIDs->AddAt(2057,iModule); iModule++;
1909 volIDs->AddAt(2058,iModule); iModule++;
1910 volIDs->AddAt(2059,iModule); iModule++;
1911 volIDs->AddAt(2060,iModule); iModule++;
1912 volIDs->AddAt(2061,iModule); iModule++;
1913 volIDs->AddAt(2062,iModule); iModule++;
1914 volIDs->AddAt(2063,iModule); iModule++;
1915 volIDs->AddAt(4112,iModule); iModule++;
1916 volIDs->AddAt(4113,iModule); iModule++;
1917 volIDs->AddAt(4114,iModule); iModule++;
1918 volIDs->AddAt(4115,iModule); iModule++;
1919 volIDs->AddAt(4116,iModule); iModule++;
1920 volIDs->AddAt(4117,iModule); iModule++;
1921 volIDs->AddAt(4118,iModule); iModule++;
1922 volIDs->AddAt(4119,iModule); iModule++;
1923 volIDs->AddAt(4120,iModule); iModule++;
1924 volIDs->AddAt(4121,iModule); iModule++;
1925 volIDs->AddAt(4122,iModule); iModule++;
1926 volIDs->AddAt(4123,iModule); iModule++;
1927 volIDs->AddAt(4124,iModule); iModule++;
1928 volIDs->AddAt(4125,iModule); iModule++;
1929 volIDs->AddAt(4126,iModule); iModule++;
1930 volIDs->AddAt(4127,iModule); iModule++;
1932 if(sectors[2]==1){//--->cSect = 2 <//---
1933 volIDs->AddAt(2064,iModule); iModule++;
1934 volIDs->AddAt(2065,iModule); iModule++;
1935 volIDs->AddAt(2066,iModule); iModule++;
1936 volIDs->AddAt(2067,iModule); iModule++;
1937 volIDs->AddAt(2068,iModule); iModule++;
1938 volIDs->AddAt(2069,iModule); iModule++;
1939 volIDs->AddAt(2070,iModule); iModule++;
1940 volIDs->AddAt(2071,iModule); iModule++;
1941 volIDs->AddAt(4128,iModule); iModule++;
1942 volIDs->AddAt(4129,iModule); iModule++;
1943 volIDs->AddAt(4130,iModule); iModule++;
1944 volIDs->AddAt(4131,iModule); iModule++;
1945 volIDs->AddAt(4132,iModule); iModule++;
1946 volIDs->AddAt(4133,iModule); iModule++;
1947 volIDs->AddAt(4134,iModule); iModule++;
1948 volIDs->AddAt(4135,iModule); iModule++;
1949 volIDs->AddAt(4136,iModule); iModule++;
1950 volIDs->AddAt(4137,iModule); iModule++;
1951 volIDs->AddAt(4138,iModule); iModule++;
1952 volIDs->AddAt(4139,iModule); iModule++;
1953 volIDs->AddAt(4140,iModule); iModule++;
1954 volIDs->AddAt(4141,iModule); iModule++;
1955 volIDs->AddAt(4142,iModule); iModule++;
1956 volIDs->AddAt(4143,iModule); iModule++;
1958 if(sectors[3]==1){//--->cSect = 3 <//---
1959 volIDs->AddAt(2072,iModule); iModule++;
1960 volIDs->AddAt(2073,iModule); iModule++;
1961 volIDs->AddAt(2074,iModule); iModule++;
1962 volIDs->AddAt(2075,iModule); iModule++;
1963 volIDs->AddAt(2076,iModule); iModule++;
1964 volIDs->AddAt(2077,iModule); iModule++;
1965 volIDs->AddAt(2078,iModule); iModule++;
1966 volIDs->AddAt(2079,iModule); iModule++;
1967 volIDs->AddAt(4144,iModule); iModule++;
1968 volIDs->AddAt(4145,iModule); iModule++;
1969 volIDs->AddAt(4146,iModule); iModule++;
1970 volIDs->AddAt(4147,iModule); iModule++;
1971 volIDs->AddAt(4148,iModule); iModule++;
1972 volIDs->AddAt(4149,iModule); iModule++;
1973 volIDs->AddAt(4150,iModule); iModule++;
1974 volIDs->AddAt(4151,iModule); iModule++;
1975 volIDs->AddAt(4152,iModule); iModule++;
1976 volIDs->AddAt(4153,iModule); iModule++;
1977 volIDs->AddAt(4154,iModule); iModule++;
1978 volIDs->AddAt(4155,iModule); iModule++;
1979 volIDs->AddAt(4156,iModule); iModule++;
1980 volIDs->AddAt(4157,iModule); iModule++;
1981 volIDs->AddAt(4158,iModule); iModule++;
1982 volIDs->AddAt(4159,iModule); iModule++;
1984 if(sectors[4]==1){//--->cSect = 4 <//---
1985 volIDs->AddAt(2080,iModule); iModule++;
1986 volIDs->AddAt(2081,iModule); iModule++;
1987 volIDs->AddAt(2082,iModule); iModule++;
1988 volIDs->AddAt(2083,iModule); iModule++;
1989 volIDs->AddAt(2084,iModule); iModule++;
1990 volIDs->AddAt(2085,iModule); iModule++;
1991 volIDs->AddAt(2086,iModule); iModule++;
1992 volIDs->AddAt(2087,iModule); iModule++;
1993 volIDs->AddAt(4160,iModule); iModule++;
1994 volIDs->AddAt(4161,iModule); iModule++;
1995 volIDs->AddAt(4162,iModule); iModule++;
1996 volIDs->AddAt(4163,iModule); iModule++;
1997 volIDs->AddAt(4164,iModule); iModule++;
1998 volIDs->AddAt(4165,iModule); iModule++;
1999 volIDs->AddAt(4166,iModule); iModule++;
2000 volIDs->AddAt(4167,iModule); iModule++;
2001 volIDs->AddAt(4168,iModule); iModule++;
2002 volIDs->AddAt(4169,iModule); iModule++;
2003 volIDs->AddAt(4170,iModule); iModule++;
2004 volIDs->AddAt(4171,iModule); iModule++;
2005 volIDs->AddAt(4172,iModule); iModule++;
2006 volIDs->AddAt(4173,iModule); iModule++;
2007 volIDs->AddAt(4174,iModule); iModule++;
2008 volIDs->AddAt(4175,iModule); iModule++;
2010 if(sectors[5]==1){//--->cSect = 5 <//---
2011 volIDs->AddAt(2088,iModule); iModule++;
2012 volIDs->AddAt(2089,iModule); iModule++;
2013 volIDs->AddAt(2090,iModule); iModule++;
2014 volIDs->AddAt(2091,iModule); iModule++;
2015 volIDs->AddAt(2092,iModule); iModule++;
2016 volIDs->AddAt(2093,iModule); iModule++;
2017 volIDs->AddAt(2094,iModule); iModule++;
2018 volIDs->AddAt(2095,iModule); iModule++;
2019 volIDs->AddAt(4176,iModule); iModule++;
2020 volIDs->AddAt(4177,iModule); iModule++;
2021 volIDs->AddAt(4178,iModule); iModule++;
2022 volIDs->AddAt(4179,iModule); iModule++;
2023 volIDs->AddAt(4180,iModule); iModule++;
2024 volIDs->AddAt(4181,iModule); iModule++;
2025 volIDs->AddAt(4182,iModule); iModule++;
2026 volIDs->AddAt(4183,iModule); iModule++;
2027 volIDs->AddAt(4184,iModule); iModule++;
2028 volIDs->AddAt(4185,iModule); iModule++;
2029 volIDs->AddAt(4186,iModule); iModule++;
2030 volIDs->AddAt(4187,iModule); iModule++;
2031 volIDs->AddAt(4188,iModule); iModule++;
2032 volIDs->AddAt(4189,iModule); iModule++;
2033 volIDs->AddAt(4190,iModule); iModule++;
2034 volIDs->AddAt(4191,iModule); iModule++;
2036 if(sectors[6]==1){//--->cSect = 6 <//---
2037 volIDs->AddAt(2096,iModule); iModule++;
2038 volIDs->AddAt(2097,iModule); iModule++;
2039 volIDs->AddAt(2098,iModule); iModule++;
2040 volIDs->AddAt(2099,iModule); iModule++;
2041 volIDs->AddAt(2100,iModule); iModule++;
2042 volIDs->AddAt(2101,iModule); iModule++;
2043 volIDs->AddAt(2102,iModule); iModule++;
2044 volIDs->AddAt(2103,iModule); iModule++;
2045 volIDs->AddAt(4192,iModule); iModule++;
2046 volIDs->AddAt(4193,iModule); iModule++;
2047 volIDs->AddAt(4194,iModule); iModule++;
2048 volIDs->AddAt(4195,iModule); iModule++;
2049 volIDs->AddAt(4196,iModule); iModule++;
2050 volIDs->AddAt(4197,iModule); iModule++;
2051 volIDs->AddAt(4198,iModule); iModule++;
2052 volIDs->AddAt(4199,iModule); iModule++;
2053 volIDs->AddAt(4200,iModule); iModule++;
2054 volIDs->AddAt(4201,iModule); iModule++;
2055 volIDs->AddAt(4202,iModule); iModule++;
2056 volIDs->AddAt(4203,iModule); iModule++;
2057 volIDs->AddAt(4204,iModule); iModule++;
2058 volIDs->AddAt(4205,iModule); iModule++;
2059 volIDs->AddAt(4206,iModule); iModule++;
2060 volIDs->AddAt(4207,iModule); iModule++;
2062 if(sectors[7]==1){ //--->cSect = 7 <//---
2063 volIDs->AddAt(2104,iModule); iModule++;
2064 volIDs->AddAt(2105,iModule); iModule++;
2065 volIDs->AddAt(2106,iModule); iModule++;
2066 volIDs->AddAt(2107,iModule); iModule++;
2067 volIDs->AddAt(2108,iModule); iModule++;
2068 volIDs->AddAt(2109,iModule); iModule++;
2069 volIDs->AddAt(2110,iModule); iModule++;
2070 volIDs->AddAt(2111,iModule); iModule++;
2071 volIDs->AddAt(4208,iModule); iModule++;
2072 volIDs->AddAt(4209,iModule); iModule++;
2073 volIDs->AddAt(4210,iModule); iModule++;
2074 volIDs->AddAt(4211,iModule); iModule++;
2075 volIDs->AddAt(4212,iModule); iModule++;
2076 volIDs->AddAt(4213,iModule); iModule++;
2077 volIDs->AddAt(4214,iModule); iModule++;
2078 volIDs->AddAt(4215,iModule); iModule++;
2079 volIDs->AddAt(4216,iModule); iModule++;
2080 volIDs->AddAt(4217,iModule); iModule++;
2081 volIDs->AddAt(4218,iModule); iModule++;
2082 volIDs->AddAt(4219,iModule); iModule++;
2083 volIDs->AddAt(4220,iModule); iModule++;
2084 volIDs->AddAt(4221,iModule); iModule++;
2085 volIDs->AddAt(4222,iModule); iModule++;
2086 volIDs->AddAt(4223,iModule); iModule++;
2088 if(sectors[8]==1){//--->cSect = 8 <//---
2089 volIDs->AddAt(2112,iModule); iModule++;
2090 volIDs->AddAt(2113,iModule); iModule++;
2091 volIDs->AddAt(2114,iModule); iModule++;
2092 volIDs->AddAt(2115,iModule); iModule++;
2093 volIDs->AddAt(2116,iModule); iModule++;
2094 volIDs->AddAt(2117,iModule); iModule++;
2095 volIDs->AddAt(2118,iModule); iModule++;
2096 volIDs->AddAt(2119,iModule); iModule++;
2097 volIDs->AddAt(4224,iModule); iModule++;
2098 volIDs->AddAt(4225,iModule); iModule++;
2099 volIDs->AddAt(4226,iModule); iModule++;
2100 volIDs->AddAt(4227,iModule); iModule++;
2101 volIDs->AddAt(4228,iModule); iModule++;
2102 volIDs->AddAt(4229,iModule); iModule++;
2103 volIDs->AddAt(4230,iModule); iModule++;
2104 volIDs->AddAt(4231,iModule); iModule++;
2105 volIDs->AddAt(4232,iModule); iModule++;
2106 volIDs->AddAt(4233,iModule); iModule++;
2107 volIDs->AddAt(4234,iModule); iModule++;
2108 volIDs->AddAt(4235,iModule); iModule++;
2109 volIDs->AddAt(4236,iModule); iModule++;
2110 volIDs->AddAt(4237,iModule); iModule++;
2111 volIDs->AddAt(4238,iModule); iModule++;
2112 volIDs->AddAt(4239,iModule); iModule++;
2114 if(sectors[9]==1){//--->cSect = 9 <//---
2115 volIDs->AddAt(2120,iModule); iModule++;
2116 volIDs->AddAt(2121,iModule); iModule++;
2117 volIDs->AddAt(2122,iModule); iModule++;
2118 volIDs->AddAt(2123,iModule); iModule++;
2119 volIDs->AddAt(2124,iModule); iModule++;
2120 volIDs->AddAt(2125,iModule); iModule++;
2121 volIDs->AddAt(2126,iModule); iModule++;
2122 volIDs->AddAt(2127,iModule); iModule++;
2123 volIDs->AddAt(4240,iModule); iModule++;
2124 volIDs->AddAt(4241,iModule); iModule++;
2125 volIDs->AddAt(4242,iModule); iModule++;
2126 volIDs->AddAt(4243,iModule); iModule++;
2127 volIDs->AddAt(4244,iModule); iModule++;
2128 volIDs->AddAt(4245,iModule); iModule++;
2129 volIDs->AddAt(4246,iModule); iModule++;
2130 volIDs->AddAt(4247,iModule); iModule++;
2131 volIDs->AddAt(4248,iModule); iModule++;
2132 volIDs->AddAt(4249,iModule); iModule++;
2133 volIDs->AddAt(4250,iModule); iModule++;
2134 volIDs->AddAt(4251,iModule); iModule++;
2135 volIDs->AddAt(4252,iModule); iModule++;
2136 volIDs->AddAt(4253,iModule); iModule++;
2137 volIDs->AddAt(4254,iModule); iModule++;
2138 volIDs->AddAt(4255,iModule); iModule++;
2144 //___________________________________
2145 TArrayI* AliITSRealignTracks::GetLayersVolUID(const Int_t *layer){
2147 //return a TArrayI with the volUIDs of the modules into the set of layers
2148 //defined by layer[6]
2150 TArrayI *out=new TArrayI(2198);
2153 for(Int_t i=0;i<6;i++){
2155 for(Int_t mod=0;mod<AliGeomManager::LayerSize(i+AliGeomManager::kFirstLayer);mod++){
2156 voluid=AliGeomManager::LayerToVolUID(i+AliGeomManager::kFirstLayer,mod);
2157 out->AddAt(voluid,last);
2158 // printf("voluid %d at position %d \n",out->At(last),last);
2168 TArrayI* AliITSRealignTracks::SelectLayerInVolids(const TArrayI *volidsIN,AliGeomManager::ELayerID layer){
2169 //Select between the modules specified by their volUIDs in volidsIN only those
2170 // of a given layer "layer"
2172 Int_t size=volidsIN->GetSize();
2174 for(Int_t j=0;j<size;j++){
2175 if(AliGeomManager::VolUIDToLayer(volidsIN->At(j))==layer)count++;
2177 TArrayI *volidsOUT=new TArrayI(count);
2179 for(Int_t j=0;j<size;j++){
2180 if(AliGeomManager::VolUIDToLayer(volidsIN->At(j))==layer){
2181 volidsOUT->AddAt(volidsIN->At(j),count);
2188 //______________________________________________
2190 TArrayI* AliITSRealignTracks::IntersectVolArray(const TArrayI *vol1,const TArrayI *vol2){
2192 //Perform the intersection between the array vol1 and vol2
2194 Int_t size1=vol1->GetSize();
2195 Int_t size2=vol2->GetSize();
2198 TArrayI *volidOut=new TArrayI(size1+size2);
2200 for(Int_t k=0;k<size1;k++){
2203 for(Int_t j=0;j<size2;j++){
2204 if(vol2->At(j)==volid)found=kTRUE;
2207 volidOut->AddAt(volid,last);
2211 volidOut->Set(last);
2214 //_________________________________________
2216 TArrayI* AliITSRealignTracks::JoinVolArrays(const TArrayI *vol1,const TArrayI *vol2){
2217 //!BE CAREFUL: If an index is repeated into vol1 or into vol2 will be repeated also in the final array
2219 Int_t size1=vol1->GetSize();
2220 Int_t size2=vol2->GetSize();
2224 TArrayI *volidOut=new TArrayI(size1+size2);
2226 for(Int_t k=0;k<size1;k++){
2228 volidOut->AddAt(volid,k);
2231 for(Int_t k=0;k<size2;k++){
2234 for(Int_t j=0;j<size1;j++){
2235 if(volidOut->At(j)==volid)found=kTRUE;
2238 volidOut->AddAt(volid,size1+count);
2242 volidOut->Set(size1+count);
2246 //______________________________________
2248 TArrayI* AliITSRealignTracks::ExcludeVolidsFromVolidsArray(const TArrayI *volidsToExclude,const TArrayI *volStart){
2249 //Excludes the modules defined by their volUID in the array volidsToExclude from the array volStart
2251 Int_t size1=volidsToExclude->GetSize();
2252 Int_t size2=volStart->GetSize();
2256 TArrayI *volidOut=new TArrayI(size2);
2258 for(Int_t k=0;k<size2;k++){
2260 volid=volStart->At(k);
2261 for(Int_t j=0;j<size1;j++){
2262 if(volidsToExclude->At(j)==volid){
2268 volidOut->AddAt(volid,last);
2272 volidOut->Set(last);
2277 //________________________________________
2279 TArrayI* AliITSRealignTracks::GetLayerVolumes(const Int_t *layer){
2280 //returns a TArrayI with the volUIDs of the modules of the layers
2281 //specified into *layer
2283 TArrayI *out=new TArrayI(2198);
2286 for(Int_t i=0;i<6;i++){
2288 for(Int_t mod=0;mod<AliGeomManager::LayerSize(i+AliGeomManager::kFirstLayer);mod++){
2289 voluid=AliGeomManager::LayerToVolUID(i+AliGeomManager::kFirstLayer,mod);
2290 out->AddAt(voluid,last);
2291 // printf("voluid %d at position %d \n",out->At(last),last);
2302 //______________________________
2303 TArrayI* AliITSRealignTracks::GetAlignedVolumes(char *filename){
2304 //Open the file "filename" which is expected to contain
2305 //a TClonesArray named "ITSAlignObjs" with stored a set of AlignObjs
2306 //returns an array with the volumes UID of the modules considered realigned
2308 if(gSystem->AccessPathName(filename)){
2309 printf("Wrong Realignment file name \n");
2312 TFile *f=TFile::Open(filename,"READ");
2313 TClonesArray *array=(TClonesArray*)f->Get("ITSAlignObjs");
2314 AliAlignObjParams *a;
2316 TArrayI *volidOut=new TArrayI(2200);
2317 for(Int_t j=0;j<array->GetSize();j++){
2318 a=(AliAlignObjParams*)array->At(j);
2319 if(a->GetUniqueID()==0)continue;
2322 volidOut->AddAt(a->GetVolUID(),last);
2326 volidOut->Set(last);
2332 //________________________________________
2333 void AliITSRealignTracks::SetDraw(Bool_t draw,Bool_t refresh){
2334 //TEPMORARY METHOD: method to switch on/off the drawing of histograms
2335 // if refresh=kTRUE deletes the old histos and constructs new ones
2339 if(fAlignDrawObjs)DeleteDrawHists();
2346 void AliITSRealignTracks::DeleteDrawHists(){
2347 //Delete the pointers to the histograms
2349 for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) {
2350 for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) {
2351 delete fAlignDrawObjs[iLayer][iModule];
2353 if(fAlignDrawObjs[iLayer])delete [] fAlignDrawObjs[iLayer];
2356 delete [] fAlignDrawObjs;
2362 delete fgrIterMeanX;
2364 delete fgrIterMeanY;
2366 delete fgrIterMeanZ;
2368 delete fgrIterMeanPsi;
2369 delete fgrIterRMSPsi;
2370 delete fgrIterMeanTheta;
2371 delete fgrIterRMSTheta;
2372 delete fgrIterMeanPhi;
2373 delete fgrIterRMSPhi;
2377 void AliITSRealignTracks::InitDrawHists(){
2378 //Initialize the histograms to monitor the results
2380 Int_t nLayers = AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer;
2381 fAlignDrawObjs = new AliAlignObj**[nLayers];
2382 for (Int_t iLayer = 0; iLayer < (AliGeomManager::kLastLayer - AliGeomManager::kFirstLayer); iLayer++) {
2383 fAlignDrawObjs[iLayer] = new AliAlignObj*[AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer)];
2384 for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer + AliGeomManager::kFirstLayer); iModule++) {
2385 UShort_t volid = AliGeomManager::LayerToVolUID(iLayer+ AliGeomManager::kFirstLayer,iModule);
2386 fAlignDrawObjs[iLayer][iModule] = new AliAlignObjParams(AliGeomManager::SymName(volid),volid,0,0,0,0,0,0,kTRUE);
2387 fAlignDrawObjs[iLayer][iModule]->SetUniqueID(1);
2392 TH1F *hX=new TH1F("hX","hX",1000,-10000.,10000.);
2393 TH1F *hY=new TH1F("hY","hY",1000,-10000.,10000.);
2394 TH1F *hZ=new TH1F("hZ","hZ",1000,-10000.,10000.);
2395 TH1F *hPsi=new TH1F("hPsi","hPsi",1000,-5000.,5000.);
2396 TH1F *hTheta=new TH1F("hTheta","hTheta",1000,-5000.,5000.);
2397 TH1F *hPhi=new TH1F("hPhi","hPhi",1000,-5000.,5000.);
2399 fCanvPar=new TCanvas("fCanvPar","Parameters trend during iterations: Convergence \n");
2400 fCanvPar->Divide(3,2);
2403 hX->SetXTitle("#mum");
2406 hY->SetXTitle("#mum");
2408 hZ->SetXTitle("#mum");
2411 hPsi->SetXTitle("mdeg");
2414 hTheta->SetXTitle("mdeg");
2417 hPhi->SetXTitle("mdeg");
2422 fCanvGr=new TCanvas("fCanvGr","Parameters trend during iterations: Convergence \n");
2423 fCanvGr->Divide(3,2);
2426 fgrIterMeanX=new TGraph(1);
2427 fgrIterRMSX=new TGraph(1);
2428 fgrIterRMSX->GetYaxis()->SetRangeUser(-1000.,1000.);
2429 fgrIterRMSX->SetName("fgrIterRMSX");
2430 fgrIterRMSX->SetLineColor(2);
2431 fgrIterMeanX->SetName("fgrIterMeanX");
2432 fgrIterMeanX->SetTitle("Convergence of #deltaX \n");
2433 fgrIterMeanX->GetXaxis()->SetTitle("#mum");
2434 fgrIterRMSX->Draw("acp");
2435 fgrIterMeanX->Draw("cp");
2438 fgrIterMeanY=new TGraph(1);
2439 fgrIterRMSY=new TGraph(1);
2440 fgrIterRMSY->GetYaxis()->SetRangeUser(-1000.,1000.);
2441 fgrIterRMSY->SetName("fgrIterRMSY");
2442 fgrIterRMSY->SetLineColor(2);
2443 fgrIterMeanY->SetName("fgrIterMeanY");
2444 fgrIterMeanY->SetTitle("Convergence of #deltaY \n");
2445 fgrIterMeanY->GetXaxis()->SetTitle("#mum");
2446 fgrIterRMSY->Draw("acp");
2447 fgrIterMeanY->Draw("cp");
2450 fgrIterMeanZ=new TGraph(1);
2451 fgrIterRMSZ=new TGraph(1);
2452 fgrIterRMSZ->GetYaxis()->SetRangeUser(-1000.,1000.);
2453 fgrIterRMSZ->SetName("fgrIterRMSZ");
2454 fgrIterRMSZ->SetLineColor(2);
2455 fgrIterMeanZ->SetName("fgrIterMeanZ");
2456 fgrIterMeanZ->SetTitle("Convergence of #deltaZ \n");
2457 fgrIterMeanZ->GetXaxis()->SetTitle("#mum");
2458 fgrIterRMSZ->Draw("acp");
2459 fgrIterMeanZ->Draw("cp");
2462 fgrIterMeanPsi=new TGraph(1);
2463 fgrIterRMSPsi=new TGraph(1);
2464 fgrIterRMSPsi->GetYaxis()->SetRangeUser(-1000.,1000.);
2465 fgrIterRMSPsi->SetName("fgrIterRMSPsi");
2466 fgrIterRMSPsi->SetLineColor(2);
2467 fgrIterMeanPsi->SetName("fgrIterMeanPsi");
2468 fgrIterMeanPsi->SetTitle("Convergence of #deltaPsi \n");
2469 fgrIterMeanPsi->GetXaxis()->SetTitle("mdeg");
2470 fgrIterRMSPsi->Draw("acp");
2471 fgrIterMeanPsi->Draw("cp");
2474 fgrIterMeanTheta=new TGraph(1);
2475 fgrIterRMSTheta=new TGraph(1);
2476 fgrIterRMSTheta->GetYaxis()->SetRangeUser(-1000.,1000.);
2477 fgrIterRMSTheta->SetName("fgrIterRMSTheta");
2478 fgrIterRMSTheta->SetLineColor(2);
2479 fgrIterMeanTheta->SetName("fgrIterMeanTheta");
2480 fgrIterMeanTheta->SetTitle("Convergence of #deltaTheta \n");
2481 fgrIterMeanTheta->GetXaxis()->SetTitle("mdeg");
2482 fgrIterRMSTheta->Draw("acp");
2483 fgrIterMeanTheta->Draw("cp");
2486 fgrIterMeanPhi=new TGraph(1);
2487 fgrIterRMSPhi=new TGraph(1);
2488 fgrIterRMSPhi->GetYaxis()->SetRangeUser(-1000.,1000.);
2489 fgrIterRMSPhi->SetName("fgrIterRMSPhi");
2490 fgrIterRMSPhi->SetLineColor(2);
2491 fgrIterMeanPhi->SetName("fgrIterMeanPhi");
2492 fgrIterMeanPhi->SetTitle("Convergence of #deltaPhi \n");
2493 fgrIterMeanPhi->GetXaxis()->SetTitle("mdeg");
2494 fgrIterRMSPhi->Draw("acp");
2495 fgrIterMeanPhi->Draw("cp");
2501 void AliITSRealignTracks::UpdateDraw(TArrayI *volids,Int_t iter,Int_t color){
2502 //Updates the histograms to monitor the results. Only the histograms
2503 //of the volumes specified in *volids will be updated.
2504 // iter is just a flag for the names of the histo
2505 // color specifies the color of the lines of the histograms for this update
2509 name.Append("iter");
2510 TH1F *hX=new TH1F("hX",name.Data(),1000,-10000.,10000.);
2514 name.Append("iter");
2515 TH1F *hY=new TH1F("hY",name.Data(),1000,-10000.,10000.);
2519 name.Append("iter");
2520 TH1F *hZ=new TH1F("hZ",name.Data(),1000,-10000.,10000.);
2524 name.Append("iter");
2525 TH1F *hPsi=new TH1F("hPsi",name.Data(),1000,-5000.,5000.);
2529 name.Append("iter");
2530 TH1F *hTheta=new TH1F("hTheta",name.Data(),1000,-5000.,5000.);
2534 name.Append("iter");
2535 TH1F *hPhi=new TH1F("hPhi",name.Data(),1000,-5000.,5000.);
2538 Double_t transl[3],rot[3],transldr[3],rotdr[3];
2540 for(Int_t i=0;i<volids->GetSize();i++){
2541 layer=AliGeomManager::VolUIDToLayer(volids->At(i),mod);
2542 fAlignObjs[layer-AliGeomManager::kFirstLayer][mod]->GetPars(transl,rot);
2543 fAlignDrawObjs[layer-AliGeomManager::kFirstLayer][mod]->GetPars(transldr,rotdr);
2545 hX->Fill(10000.*(transl[0]-transldr[0]));
2546 hY->Fill(10000.*(transl[1]-transldr[1]));
2547 hZ->Fill(10000.*(transl[2]-transldr[2]));
2548 hPsi->Fill(1000.*(rot[0]-rotdr[0]));
2549 hTheta->Fill(1000.*(rot[1]-rotdr[1]));
2550 hPhi->Fill(1000.*(rot[1]-rotdr[2]));
2551 //Update the pars of the draw object
2552 fAlignDrawObjs[layer-AliGeomManager::kFirstLayer][mod]->SetPars(transl[0],transl[1],transl[2],rot[0],rot[1],rot[2]);
2555 hX->SetLineColor(color);
2556 hY->SetLineColor(color);
2557 hZ->SetLineColor(color);
2558 hPsi->SetLineColor(color);
2559 hTheta->SetLineColor(color);
2560 hPhi->SetLineColor(color);
2572 hTheta->Draw("Same");
2577 fCanvPar->Modified();
2579 fgrIterMeanX->SetPoint(fgrIterMeanX->GetN()+1,iter,hX->GetMean());
2580 fgrIterRMSX->SetPoint(fgrIterRMSX->GetN()+1,iter,hX->GetRMS());
2581 fgrIterMeanY->SetPoint(fgrIterMeanY->GetN()+1,iter,hY->GetMean());
2582 fgrIterRMSY->SetPoint(fgrIterRMSY->GetN()+1,iter,hY->GetRMS());
2583 fgrIterMeanZ->SetPoint(fgrIterMeanZ->GetN()+1,iter,hZ->GetMean());
2584 fgrIterRMSZ->SetPoint(fgrIterRMSZ->GetN()+1,iter,hZ->GetRMS());
2585 fgrIterMeanPsi->SetPoint(fgrIterMeanPsi->GetN()+1,iter,hPsi->GetMean());
2586 fgrIterRMSPsi->SetPoint(fgrIterRMSPsi->GetN()+1,iter,hPsi->GetRMS());
2587 fgrIterMeanTheta->SetPoint(fgrIterMeanTheta->GetN()+1,iter,hTheta->GetMean());
2588 fgrIterRMSTheta->SetPoint(fgrIterRMSTheta->GetN()+1,iter,hTheta->GetRMS());
2589 fgrIterMeanPhi->SetPoint(fgrIterMeanPhi->GetN()+1,iter,hPhi->GetMean());
2590 fgrIterRMSPhi->SetPoint(fgrIterRMSPhi->GetN()+1,iter,hPhi->GetRMS());
2597 void AliITSRealignTracks::WriteHists(const char *outfile){
2598 //Writes the histograms for the monitoring of the results
2599 // in a file named "outfile"
2601 TFile *f=new TFile(outfile,"RECREATE");
2605 fgrIterMeanX->Write();
2606 fgrIterRMSX->Write();
2607 fgrIterMeanY->Write();
2608 fgrIterRMSY->Write();
2609 fgrIterMeanZ->Write();
2610 fgrIterRMSZ->Write();
2611 fgrIterMeanPsi->Write();
2612 fgrIterRMSPsi->Write();
2613 fgrIterMeanTheta->Write();
2614 fgrIterRMSTheta->Write();
2615 fgrIterMeanPhi->Write();
2616 fgrIterRMSPhi->Write();