technial fix to suppress the warning
[u/mrichter/AliRoot.git] / ITS / AliITSSurveyToAlign.cxx
index 6ab590e..b5228f5 100644 (file)
@@ -23,8 +23,6 @@
 //           Martin Poghosyan (Martin.Poghosyan@to.infn.it)
 //////////////////////////////////////////////////////////////////////////
 
-#include "Riostream.h"
-#include "TClonesArray.h"
 #include "TGeoManager.h"
 #include "TGeoPhysicalNode.h"
 #include "TMatrixD.h"
@@ -41,6 +39,8 @@
 
 #include "AliITSgeomTGeo.h"
 
+
+//#include "dataSDDladder.h"
 ClassImp(AliITSSurveyToAlign)
 
 const Double_t AliITSSurveyToAlign::fgkLocR[6][3]={{ 3.24,0.21905,-2.4},
@@ -60,16 +60,41 @@ const Double_t AliITSSurveyToAlign::fgkLocL[6][3]={{-3.24,0.21905, 2.4},
 const Double_t kRadToDeg = 180./TMath::Pi();
 
 //________________________________________________________________________
-AliITSSurveyToAlign::AliITSSurveyToAlign(Int_t run, Int_t repSDD, Int_t repVerSDD, Int_t repModSSD, Int_t repModVerSSD, Int_t repLaddSSD, Int_t repLaddVerSSD) :
+AliITSSurveyToAlign::AliITSSurveyToAlign(Int_t run, Int_t repModSDD, Int_t repModVerSDD, Int_t repLadSDD, Int_t repLadVerSDD, Int_t repModSSD, Int_t repModVerSSD, Int_t repLaddSSD, Int_t repLaddVerSSD) :
   AliSurveyToAlignObjs(),
   fRun(run),
-  fSDDrepNumber(repSDD),
-  fSDDrepVersion(repVerSDD),
+  fSDDModuleRepNumber(repModSDD),
+  fSDDModuleRepVersion(repModVerSDD),
+  fSDDLadderRepNumber(repLadSDD),
+  fSDDLadderRepVersion(repLadVerSDD),
   fSSDModuleRepNumber(repModSSD),
   fSSDModuleRepVersion(repModVerSSD),
   fSSDLadderRepNumber(repLaddSSD),
   fSSDLadderRepVersion(repLaddVerSSD)
  {
+   // Standard constructor
+  for(Int_t i=0; i<260; i++)
+    {
+      fuidSDDm[i]= 0;
+      fsymnameSDDm[i]=TString("");
+      fxSDDm[i]=0;
+      fySDDm[i]=0;
+      fzSDDm[i]=0;
+      fpsiSDDm[i]=0;
+      ftetSDDm[i]=0;
+      fphiSDDm[i]=0;
+      if(i>35) continue;
+      fuidSDDl[i]=0;
+      fsymnameSDDl[i]=TString("");
+      fxSDDl[i]=0;
+      fySDDl[i]=0;
+      fzSDDl[i]=0;
+      fpsiSDDl[i]=0;
+      ftetSDDl[i]=0;
+      fphiSDDl[i]=0;
+    }
+
+   //   ftypeSDDlad=0;
   //
   //  default constructor
   //  Arguments are report numbers for survey data. 
@@ -81,8 +106,10 @@ AliITSSurveyToAlign::AliITSSurveyToAlign(Int_t run, Int_t repSDD, Int_t repVerSD
 AliITSSurveyToAlign::AliITSSurveyToAlign(const AliITSSurveyToAlign &align) :
   AliSurveyToAlignObjs(align),
   fRun(align.fRun),
-  fSDDrepNumber(align.fSDDrepNumber),
-  fSDDrepVersion(align.fSDDrepVersion),
+  fSDDModuleRepNumber(align.fSDDModuleRepNumber),
+  fSDDModuleRepVersion(align.fSDDModuleRepVersion),
+  fSDDLadderRepNumber(align.fSDDLadderRepNumber),
+  fSDDLadderRepVersion(align.fSDDLadderRepVersion),
   fSSDModuleRepNumber(align.fSSDModuleRepNumber),
   fSSDModuleRepVersion(align.fSSDModuleRepVersion),
   fSSDLadderRepNumber(align.fSSDLadderRepNumber),
@@ -91,15 +118,37 @@ AliITSSurveyToAlign::AliITSSurveyToAlign(const AliITSSurveyToAlign &align) :
   //
   //  copy constructor 
   //
+  for(Int_t i=0; i<260; i++)
+    {
+      fuidSDDm[i]= align.fuidSDDm[i];
+      fsymnameSDDm[i]=TString(align.fsymnameSDDm[i]);
+      fxSDDm[i]=align.fxSDDm[i];
+      fySDDm[i]=align.fySDDm[i];
+      fzSDDm[i]=align.fzSDDm[i];
+      fpsiSDDm[i]=align.fpsiSDDm[i];
+      ftetSDDm[i]=align.ftetSDDm[i];
+      fphiSDDm[i]=align.fphiSDDm[i];
+      if(i>35) continue;
+      fuidSDDl[i]=align.fuidSDDl[i];
+      fsymnameSDDl[i]=TString(align.fsymnameSDDl[i]);
+      fxSDDl[i]=align.fxSDDl[i];
+      fySDDl[i]=align.fySDDl[i];
+      fzSDDl[i]=align.fzSDDl[i];
+      fpsiSDDl[i]=align.fpsiSDDl[i];
+      ftetSDDl[i]=align.ftetSDDl[i];
+      fphiSDDl[i]=align.fphiSDDl[i];
+    }
+
 }
 
 //__________________________________________________________________________
-AliITSSurveyToAlign & AliITSSurveyToAlign::operator =(const AliITSSurveyToAlign& /* align */) {
+AliITSSurveyToAlign & AliITSSurveyToAlign::operator =(const AliITSSurveyToAlign& align)  {
   //
-  // assignment operator - dummy
+  // assignment operator
   //
-
-  return (*this);
+  this->~AliITSSurveyToAlign();
+  new(this) AliITSSurveyToAlign(align);
+  return *this;
 }
 
 //__________________________________________________________________________
@@ -135,12 +184,21 @@ Bool_t AliITSSurveyToAlign::CreateAlignObjs() {
   //for SPD
   CreateAlignObjDummySPD();
 
+  ///////////////////////////
   // for SDD
-  if(!LoadSurveyFromAlienFile("ITS", fSDDrepNumber, fSDDrepVersion)){
-      AliError("Loading of alignment objects from survey for SDD failed!");
+  if(!LoadSurveyFromAlienFile("ITS", fSDDModuleRepNumber, fSDDModuleRepVersion)){
+      AliError("Loading of alignment objects from survey for SDD modules failed!");
+      return kFALSE;
+  }
+  CreateAlignObjSDDModules();
+
+  if(!LoadSurveyFromAlienFile("ITS", fSDDLadderRepNumber, fSDDLadderRepVersion)){
+      AliError("Loading of alignment objects from survey for SDD ladder failed!");
       return kFALSE;
   }
-  CreateAlignObjSDD();
+  CreateAlignObjSDDLadders();
+  if(!ApplyAlignObjSDD()) return kFALSE;
+
 
   // for SSD ladders
   if(!LoadSurveyFromAlienFile("ITS", fSSDLadderRepNumber, fSSDLadderRepVersion)){
@@ -177,9 +235,61 @@ void AliITSSurveyToAlign::CreateAlignObjDummySPD(){
   }//module loop
 
 }
+Bool_t AliITSSurveyToAlign::ApplyAlignObjSDD()
+{
+  // Apply alignment for SDD
+  Int_t applied=0;
+
+  for(Int_t iLadd=0; iLadd<36; iLadd++)
+    {
+      new((*fAlignObjArray)[240+iLadd]) AliAlignObjParams(fsymnameSDDl[iLadd].Data(), fuidSDDl[iLadd], 
+                                              fxSDDl[iLadd]  , fySDDl[iLadd]  , fzSDDl[iLadd]  , 
+                                              fpsiSDDl[iLadd], ftetSDDl[iLadd], fphiSDDl[iLadd], kFALSE);
+      //      new((*fAlignObjArray)[240+iLadd]) AliAlignObjParams(fsymnameSDDl[iLadd].Data(), fuidSDDl[iLadd], 
+      //                              fxSDDl[iLadd]  , fySDDl[iLadd]  , fzSDDl[iLadd]  , 
+      //                              0, 0, 0, kFALSE);
+
+      AliAlignObjParams* ap = dynamic_cast<AliAlignObjParams*> (fAlignObjArray->UncheckedAt(240+iLadd));
+      //      printf("%s  %f  %f  %f\n",fxSDDl[iLadd], fsymnameSDDl[iLadd].Data(), fySDDl[iLadd]  , fzSDDl[iLadd]);
+      //printf("%d  %f\n", iLadd, fzSDDl[iLadd]);
+
+      if(ap != 0 && fsymnameSDDl[iLadd].Contains("SDD") && fsymnameSDDl[iLadd].Contains("Ladder"))
+       {
+         //      printf("%d  %s  %d\n",240+iLadd, fsymnameSDDl[iLadd].Data(),fuidSDDl[iLadd] );
+
+         if(!ap->ApplyToGeometry()) return kFALSE;
+         applied++;
+       }
+      else
+       {
+         AliError("SDD Ladder array is not initialized correctly");
+         return kFALSE;
+       }
+    }
+
+  for(Int_t iMod=0; iMod<260; iMod++)
+    {
+      //           printf("%d s=%s  x= %f  y= %f  z= %f\n",240+36+iMod, fsymnameSDDm[iMod].Data(),fxSDDm[iMod], fySDDm[iMod], fzSDDm[iMod] );
+
+      new((*fAlignObjArray)[240+36+iMod]) AliAlignObjParams(fsymnameSDDm[iMod].Data(), fuidSDDm[iMod], 
+                                            fxSDDm[iMod]  , fySDDm[iMod]  , fzSDDm[iMod], 
+                                            fpsiSDDm[iMod], ftetSDDm[iMod], fphiSDDm[iMod], kFALSE);
+
+     
+          if(!fsymnameSDDm[iMod].Contains("SDD") || !fsymnameSDDm[iMod].Contains("Sensor"))
+           {
+         AliError("SDD Module array is not initialized correctly\n");
+         return kFALSE;
+           }
+
+    }
+
+  AliInfo(Form(" %d alignment objects for SDD ladders applied to geometry.",applied));
+  return kTRUE;
+}
 
 //______________________________________________________________________
-void AliITSSurveyToAlign::CreateAlignObjSDD(){
+void AliITSSurveyToAlign::CreateAlignObjSDDModules(){
   //
   // Create alignment objects for SDD
   // Called by Run()
@@ -196,7 +306,7 @@ void AliITSSurveyToAlign::CreateAlignObjSDD(){
 
   if (fSurveyPoints == 0 || fSurveyPoints->GetEntries() == 0) {
     AliWarning("SDD survey data are not available, using zero values");
-    CreateAlignObjDummySDD();
+    CreateAlignObjDummySDDModules();
     return;
   }
 
@@ -207,14 +317,34 @@ void AliITSSurveyToAlign::CreateAlignObjSDD(){
     Int_t iLayer, iLadder, iModule, iPoint;
     ReadPointNameSDD(pt->GetName(),iLayer, iLadder, iModule, iPoint);
 
-    if(iModule==iModule0)
+      Double_t x =pt->GetX();
+      Double_t y =pt->GetY();
+      Double_t z =pt->GetZ();
+      Double_t xE=pt->GetPrecisionX();
+      Double_t yE=pt->GetPrecisionY();
+      Double_t zE=pt->GetPrecisionZ();
+  
+         if(iLayer==3 && iLadder==2)
+       {
+         if(iPoint<3) iPoint+=3;
+         else if(iPoint>2) iPoint-=3;
+         iModule=TMath::Abs(iModule - 5);
+         x=500-x;
+         y*=-1;
+       }
+      
+
+      iModuleIndex = AliITSgeomTGeo::GetModuleIndex(iLayer0,iLadder0+1,iModule0+1);
+      Int_t iModuleIndex1 = AliITSgeomTGeo::GetModuleIndex(iLayer,iLadder+1,iModule+1);
+
+    if(iModuleIndex==iModuleIndex1)
     {
-      fSDDmeP[iPoint][0]=pt->GetX();
-      fSDDmeP[iPoint][1]=pt->GetY();
-      fSDDmeP[iPoint][2]=pt->GetZ();
-      fSDDmeP[iPoint][3]=pt->GetPrecisionX();
-      fSDDmeP[iPoint][4]=pt->GetPrecisionY();
-      fSDDmeP[iPoint][5]=pt->GetPrecisionZ();
+      fSDDmeP[iPoint][0]=x;
+      fSDDmeP[iPoint][1]=y;
+      fSDDmeP[iPoint][2]=z;
+      fSDDmeP[iPoint][3]=xE;
+      fSDDmeP[iPoint][4]=yE;
+      fSDDmeP[iPoint][5]=zE;
       fSDDisMe[iPoint]=kTRUE;
 
       if(iLayer==3) uid = AliGeomManager::LayerToVolUID(iLayer0,iModuleIndex-240);
@@ -222,42 +352,61 @@ void AliITSSurveyToAlign::CreateAlignObjSDD(){
       symname = AliGeomManager::SymName(uid);
       GetIdPosSDD(uid,iLayer0, iModule0, iPoint);
       nModules++;
+
+
+      //      printf("%s\n",pt->GetName());
+      //      printf("Me: %7.4f  %7.4f  %7.4f\n", fSDDmeP[iPoint][0], fSDDmeP[iPoint][1], fSDDmeP[iPoint][2]);
+      //      printf("Id: %7.4f  %7.4f  %7.4f\n", fSDDidP[iPoint][0], fSDDidP[iPoint][1], fSDDidP[iPoint][2]);
     }
+
     //    cout << "Points red module " << imod << endl;
-    if((iModule!=iModule0)||(imod==(fSurveyPoints->GetEntries()-1)))
+    if((iModuleIndex!=iModuleIndex1)||(imod==(fSurveyPoints->GetEntries()-1)))
     {
       ConvertToRSofModulesAndRotSDD(iLayer0, iModule0);
 
       Double_t tet = 0.;
-      Double_t psi =0.;
+      Double_t psi = 0.;
       Double_t phi = 0.;
       Double_t x0  = 0.;
-      Double_t y0  =0.;
+      Double_t y0  = 0.;
       Double_t z0  = 0.;
 
       if(nModules==2) CalcShiftSDD(x0,y0,z0);
       if(nModules>2)   CalcShiftRotSDD(tet, psi, phi, x0, y0, z0);
+      //          printf("%s  %d  %f  %f  %f  %f  %f  %f\n",symname, uid, x0/10., y0/10., z0/10., psi, tet, phi);
       tet*=kRadToDeg;
       psi*=kRadToDeg;
       phi*=kRadToDeg;
-
-//    printf("%s  %d  %f  %f  %f  %f  %f  %f\n",symname, uid, x0/10., y0/10., z0/10., psi, tet, phi);
 //      cout << "Allocate alignobjparams " << imod << endl;
-      new((*fAlignObjArray)[iModuleIndex]) AliAlignObjParams(symname, uid, x0/10., y0/10., z0/10., psi, tet, phi, kFALSE);
-
+//      new((*fAlignObjArray)[iModuleIndex]) AliAlignObjParams(symname, uid, x0/10., y0/10., z0/10., psi, tet, phi, kFALSE);
+//       printf("INDEX:   Module: %d\n",iModuleIndex);
+
+
+      fsymnameSDDm[iModuleIndex-240]=TString(symname);
+      fuidSDDm[iModuleIndex-240]=uid;
+      fxSDDm[iModuleIndex-240]=x0/10.;
+      fySDDm[iModuleIndex-240]=y0/10.;
+      fzSDDm[iModuleIndex-240]=z0/10.;
+      fpsiSDDm[iModuleIndex-240]=psi;
+      ftetSDDm[iModuleIndex-240]=tet;
+      fphiSDDm[iModuleIndex-240]=phi;
+      //      new((*fAlignObjArray)[36+iModuleIndex]) AliAlignObjParams(fsymnameSDDm[iModuleIndex-240].Data(), fuidSDDm[iModuleIndex-240], 
+      //                                            fxSDDm[iModuleIndex-240], fySDDm[iModuleIndex-240], fzSDDm[iModuleIndex-240], 
+      //                                            fpsiSDDm[iModuleIndex-240], ftetSDDm[iModuleIndex-240], fphiSDDm[iModuleIndex-240], kFALSE);
       iModule0=iModule;
       iLayer0=iLayer;
       iLadder0=iLadder;
       nModules=0;
-      iModuleIndex = AliITSgeomTGeo::GetModuleIndex(iLayer,iLadder+1,iModule+1);
+      //      iModuleIndex = AliITSgeomTGeo::GetModuleIndex(iLayer,iLadder+1,iModule+1);
       for(Int_t i=0; i<6;i++) fSDDisMe[i]=kFALSE;
       if(imod!=(fSurveyPoints->GetEntries()-1)) imod--;
     }
   }//module loop
+//  printf("done\n");
 }
 
 //______________________________________________________________________
-void AliITSSurveyToAlign::CreateAlignObjDummySDD(){
+void AliITSSurveyToAlign::CreateAlignObjDummySDDModules(){
   // 
   // Create empty alignment objects
   // Used when fSurveySDD == 0
@@ -270,7 +419,16 @@ void AliITSSurveyToAlign::CreateAlignObjDummySDD(){
     Int_t uid = AliGeomManager::LayerToVolUID(ilayer,imodule);
     const Char_t *symname = AliGeomManager::SymName(uid);
 
-    new((*fAlignObjArray)[imod+240]) AliAlignObjParams(symname, uid, 0., 0., 0., 0., 0., 0., kTRUE);
+      fsymnameSDDm[imod]=TString(symname);
+      fuidSDDm[imod]=uid;
+      fxSDDm[imod]=0.;
+      fySDDm[imod]=0.;
+      fzSDDm[imod]=0.;
+      fpsiSDDm[imod]=0.;
+      ftetSDDm[imod]=0.;
+      fphiSDDm[imod]=0.;
+
+    //    new((*fAlignObjArray)[imod+36+240]) AliAlignObjParams(symname, uid, 0., 0., 0., 0., 0., 0., kTRUE);
   }//module loop
 }
 
@@ -333,7 +491,7 @@ void AliITSSurveyToAlign::CreateAlignObjSSDModules(){
           << " theta " << theta << endl;
     }
     */
-    new((*fAlignObjArray)[imod]) AliAlignObjParams(symname, uid, sx, 0, sz, 0., theta, 0., kFALSE);
+    new((*fAlignObjArray)[imod+36]) AliAlignObjParams(symname, uid, sx, 0, sz, 0., theta, 0., kFALSE);
   } //module loop
 }
 
@@ -362,6 +520,193 @@ Bool_t AliITSSurveyToAlign::ApplyAlignObjSSDLadders(){
 
   return kTRUE;
 }
+//______________________________________________________________________
+/*
+Bool_t AliITSSurveyToAlign::ApplyAlignObjSDDLadders(){
+  //
+  //   Apply alignment objects for SDD ladders to geometry, needed to correctly
+  //   build alignment objects for SDD modules
+  // 
+  Int_t applied=0;
+
+  for(Int_t jj=0; jj<fAlignObjArray->GetEntriesFast(); jj++)
+  {
+      AliAlignObjParams* ap = dynamic_cast<AliAlignObjParams*> (fAlignObjArray->UncheckedAt(jj));
+      if(ap) 
+      {
+         TString sName(ap->GetSymName());
+//       printf("%s\n",sName.Data());
+         if(sName.Contains("SDD") && sName.Contains("Ladder"))
+         {
+             if(!ap->ApplyToGeometry()) return kFALSE;
+             applied++;
+         }
+      }
+  }
+  AliInfo(Form(" %d alignment objects for SDD ladders applied to geometry.",applied));
+
+  return kTRUE;
+}
+*/
+//______________________________________________________________________
+void AliITSSurveyToAlign::CreateAlignObjDummySDDLadders()
+{
+  // 
+  // Create empty alignment objects
+  TString sddName = "ITS/SDD";
+  Int_t iLadd = 0;
+
+  for (Int_t ilayer =  0; ilayer <  2; ilayer ++)
+    {
+    Int_t nLadder = 14;              // layer SDD1
+    if (ilayer == 1)  nLadder = 22;  // layer SDD2
+    for (Int_t iLadder = 0; iLadder < nLadder; iLadder++) {
+      TString ladName = sddName;
+      ladName += (ilayer+2);      
+      ladName += "/Ladder";
+      ladName += iLadder;
+      fsymnameSDDl[iLadd]=TString(ladName);
+      fuidSDDl[iLadd]=0;
+      fxSDDl[iLadd]=0;
+      fySDDl[iLadd]=0;
+      fzSDDl[iLadd]=0;
+      fpsiSDDl[iLadd]=0;
+      ftetSDDl[iLadd]=0;
+      fphiSDDl[iLadd]=0;
+      iLadd++;
+    }  // Ladder loop
+  }  // Layer loop
+
+}
+
+
+
+void AliITSSurveyToAlign::CreateAlignObjSDDLadders(){
+  //
+  //   Alignment objects from survey for SDD ladders
+  // 
+  const Float_t kLaddLenz[2] ={500, 650};  // Layer 2,3: distance between mouting points along z (mm)
+  const Float_t kLaddLenx    = 28 ;        // Layer 2,3: distance between mouting points along x (mm)
+
+  TString sddName = "ITS/SDD";
+
+ TObjArray *ladderPoints = fSurveyPoints;  
+  if (ladderPoints == 0 || ladderPoints->GetEntries() == 0) {
+    AliWarning("No SDD Ladder alignment points found. Skipping");
+    return;
+  }
+  if (ladderPoints->GetEntries()!= 72) {
+    AliWarning(Form("Unexpected number of survey points %d, should be 72",ladderPoints->GetEntries())); 
+  }
+
+/*
+TAlien::Connect("alien://");
+gSystem->Load("libXMLParser.so");
+.x loadlibs.C 
+
+AliCDBManager *cdb = AliCDBManager::Instance();
+cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
+cdb->SetRun(0);
+AliGeomManager::LoadGeometry();
+AliITSSurveyToAlign *a = new AliITSSurveyToAlign(); 
+
+a->CreateAlignObjSDDLadders()                     
+a->ApplyAlignObjSDDLadders();
+
+a->LoadSurveyFromAlienFile("ITS", 845069, 1);
+a->CreateAlignObjSDD();
+
+a->CreateAlignObjs();
+*/
+
+  Int_t iLadd = 0;
+
+  for (Int_t ilayer =  0; ilayer <  2; ilayer ++)
+    {
+    Int_t nLadder = 14;              // layer SDD1
+    if (ilayer == 1)  nLadder = 22;  // layer SDD2
+
+    for (Int_t iLadder = 0; iLadder < nLadder; iLadder++) {
+      TString ladName = sddName;
+      ladName += (ilayer+2);      
+      ladName += "/Ladder";
+      ladName += iLadder;
+
+
+      /////////////////////////////////////////////////////////////////////////////
+      AliSurveyPoint *p24 =  (AliSurveyPoint*) ladderPoints->FindObject(ladName+"/RB24");
+      AliSurveyPoint *p26 =  (AliSurveyPoint*) ladderPoints->FindObject(ladName+"/RB26");
+      if (p24 == 0) {
+       AliWarning(Form("Cannot find RB24 side point for ladder %s",ladName.Data()));
+       continue;
+      }
+      if (p26 == 0) {
+       AliWarning(Form("Cannot find RB26 side point for ladder %s",ladName.Data()));
+       continue;
+      }
+
+      TString tmpStr;
+      tmpStr.Insert(0,p24->GetName(),3);
+      Int_t ladder = tmpStr.Atoi();
+      tmpStr="";
+      tmpStr.Insert(0,p26->GetName(),3);
+      if (tmpStr.Atoi() != ladder) 
+       AliError(Form("Survey data file error. Expect pairs of RB24, RB26 points. Got ladders %d %d",ladder,tmpStr.Atoi()));
+
+
+      Double_t x24, y24, z24;
+      Double_t x26, y26, z26;
+
+      x24=p24->GetX();
+      y24=p24->GetY();
+      z24=p24->GetZ();
+      x26=p26->GetX();
+      y26=p26->GetY();
+      z26=p26->GetZ();
+
+      // for top ladders: RS(local) = RS(global) + Y_shift 
+      // rot around z-axis
+      Double_t phi = 0;  // Not measured
+      // rot around y-axis
+      Double_t theta = 0;
+      // rot around x-axis
+      Double_t psi = 0;
+
+
+      psi=TMath::ATan((y26-y24)/(kLaddLenz[ilayer]+z24-z26));
+      Double_t tgtet0 = kLaddLenx/kLaddLenz[ilayer];
+      Double_t tgtet1 = (x24-x26+kLaddLenx)/(kLaddLenz[ilayer]+z24-z26);
+      theta=TMath::ATan((tgtet1-tgtet0)/(1+tgtet1*tgtet0));
+
+      Double_t x0=x24-theta*kLaddLenz[ilayer]/2;
+      Double_t y0=y24+psi*kLaddLenz[ilayer]/2;
+      Double_t z0=z24+theta*kLaddLenx/2;
+
+      theta*= kRadToDeg;
+      psi*= kRadToDeg;
+
+      // local delta transformation by passing 3 shifts (in centimeters) and 3 angles (expressed in degrees)    
+      //      new((*fAlignObjArray)[500+1698+144+iLadd]) AliAlignObjParams(ladName,0,drLoc[0],drLoc[1],drLoc[2],psi,theta,phi,kFALSE);
+      fsymnameSDDl[iLadd]=TString(ladName);
+      fuidSDDl[iLadd]=0;
+      fxSDDl[iLadd]=x0/10.;
+      fySDDl[iLadd]=y0/10.;
+      fzSDDl[iLadd]=z0/10.;
+      fpsiSDDl[iLadd]=psi;
+      ftetSDDl[iLadd]=theta;
+      fphiSDDl[iLadd]=phi;
+      //      new((*fAlignObjArray)[240+iLadd]) AliAlignObjParams(fsymnameSDDl[iLadd].Data(), fuidSDDl[iLadd], 
+      //                                              fxSDDl[iLadd]  , fySDDl[iLadd]  , fzSDDl[iLadd]  , 
+      //                                              fpsiSDDl[iLadd], ftetSDDl[iLadd], fphiSDDl[iLadd], kFALSE);
+      //       printf("INDEX:   Ladder: %d\n",iLadd);
+      iLadd++;
+    }  // Ladder loop
+  }  // Layer loop
+}
+////////////////////////////////////////////////////////////////////////////////////////
+
+
 
 //______________________________________________________________________
 void AliITSSurveyToAlign::CreateAlignObjSSDLadders(){
@@ -432,6 +777,7 @@ void AliITSSurveyToAlign::CreateAlignObjSSDLadders(){
       // V side is A side is large global z 
       // Q side is C side is large local z
 
+
       if (ladder >= 600) {
        theta = TMath::ATan((qPoint->GetX() - vPoint->GetX())*kMu2Cm/kLaddLen6);
        psi = TMath::ATan((vPoint->GetY() - qPoint->GetY())*kMu2Cm/kLaddLen6);
@@ -450,12 +796,13 @@ void AliITSSurveyToAlign::CreateAlignObjSSDLadders(){
       psi *= kRadToDeg;
       AliDebug(1,Form("ladname %f %f %f %f %f %f ",dxLoc,dyLoc,dzLoc,psi,theta,phi));  
       
-      new((*fAlignObjArray)[500+1698+iLadd]) AliAlignObjParams(ladName,0,dxLoc,dyLoc,dzLoc,psi,theta,phi,kFALSE);
+      new((*fAlignObjArray)[500+36+1698+iLadd]) AliAlignObjParams(ladName,0,dxLoc,dyLoc,dzLoc,psi,theta,phi,kFALSE);
 
       iLadd++;
     }  // Ladder loop
   }  // Layer loop
 }
+////////////////////////////////////////////////////////////////////////////////////////
 
 //______________________________________________________________________
 void AliITSSurveyToAlign::CreateAlignObjDummySSDModules(){
@@ -470,7 +817,7 @@ void AliITSSurveyToAlign::CreateAlignObjDummySSDModules(){
     Int_t uid = AliGeomManager::LayerToVolUID(ilayer,imodule);
     const Char_t *symname = AliGeomManager::SymName(uid);
 
-    new((*fAlignObjArray)[500+imod]) AliAlignObjParams(symname, uid, 0., 0., 0., 0., 0., 0., kTRUE);
+    new((*fAlignObjArray)[500+36+imod]) AliAlignObjParams(symname, uid, 0., 0., 0., 0., 0., 0., kTRUE);
   }//module loop
 }
 
@@ -487,9 +834,11 @@ void AliITSSurveyToAlign::GetIdPosSDD(Int_t uid, Int_t layer, Int_t module, Int_
   TString ladderPath(pne->GetTitle());
   if(ladderPath.EndsWith("/")) ladderPath.Remove(TString::kTrailing,'/');
   ladderPath.Remove(ladderPath.Last('/'));
-  ladderPath.Remove(ladderPath.Last('/'));
+  //  ladderPath.Remove(ladderPath.Last('/'));
   gGeoManager->cd(ladderPath.Data());
   TGeoHMatrix gLad = *gGeoManager->GetCurrentMatrix(); // global matrix of ladder
+
+
   TGeoHMatrix rel = gMod; // to equal relative matrix ladder to sensor.
   TGeoHMatrix invgLad = gLad.Inverse();
   rel.MultiplyLeft(&invgLad);
@@ -505,8 +854,28 @@ void AliITSSurveyToAlign::GetIdPosSDD(Int_t uid, Int_t layer, Int_t module, Int_
   if((layer==4)&&(module<4)) rel.LocalToMaster(fgkLocR[iPoint],fSDDidP[iPoint]);
   if((layer==4)&&(module>3)) rel.LocalToMaster(fgkLocL[iPoint],fSDDidP[iPoint]);
 
-  for(Int_t i=0; i<3; i++) fSDDidP[iPoint][i]*=10;
-
+  for(Int_t i=0; i<3; i++) fSDDidP[iPoint][i]*=10; 
+  fSDDidP[iPoint][2]-=0.5205;
+
+  //  if(ladderPath.Data(),"/ALIC_1/ITSV_1/ITSsddLayer3_1/ITSsddLadd_3");
+  //  if(ladderPath.Contains("ITSsddLayer3_1") && (ladderPath.Contains("ITSsddLadd_3")|| ladderPath.Contains("ITSsddLadd_10")))
+  //  {
+  ///ALIC_1/ITSV_1/ITSsddLayer4_1/ITSsddLadd_5
+  ///ALIC_1/ITSV_1/ITSsddLayer4_1/ITSsddLadd_16
+  //  gLad.Print();
+  //  printf("%s  : Module# %d  Point# %d\n",ladderPath.Data(), module, iPoint);
+
+  if((layer==3)&&(module<3)) rel.LocalToMaster(fgkLocR[1],fSDDidP[1]);
+  if((layer==3)&&(module>2)) rel.LocalToMaster(fgkLocL[1],fSDDidP[1]);
+  if((layer==4)&&(module<4)) rel.LocalToMaster(fgkLocR[1],fSDDidP[1]);
+  if((layer==4)&&(module>3)) rel.LocalToMaster(fgkLocL[1],fSDDidP[1]);
+  for(Int_t i=0; i<3; i++) fSDDidP[1][i]*=10;
+  fSDDidP[1][2]-=0.5205;
+
+  //  rel.LocalToMaster(fgkLocR[1],fSDDidP[1]);
+  //  printf("ID   {%f, %f, %f}\n", fSDDidP[iPoint][0],fSDDidP[iPoint][1],fSDDidP[iPoint][2]);
+  //  printf("Me   {%f, %f, %f}\n", fSDDmeP[iPoint][0],fSDDmeP[iPoint][1],fSDDmeP[iPoint][2]);
+  //  }
 }
 
 //______________________________________________________________________
@@ -546,6 +915,46 @@ void AliITSSurveyToAlign::ReadPointNameSDD(const char str[], Int_t &iLayer, Int_
   if(str[16]=='8') {iLader=10*iLader+8; ord=1;}
   if(str[16]=='9') {iLader=10*iLader+9; ord=1;}
 
+  /*
+  //tmp solution
+  Int_t module=-1;
+  if(str[23+ord]=='0') module=0;
+  if(str[23+ord]=='1') module=1;
+  if(str[23+ord]=='2') module=2;
+  if(str[23+ord]=='3') module=3;
+  if(str[23+ord]=='4') module=4;
+  if(str[23+ord]=='5') module=5;
+  if(str[23+ord]=='6') module=6;
+  if(str[23+ord]=='7') module=7;
+  if(str[23+ord]=='8') module=8;
+  if(str[23+ord]=='9') module=9;
+
+  if(iLayer==3)
+    {
+      if(module==0) iModul= 5;
+      if(module==1) iModul= 4;
+      if(module==2) iModul= 3;
+      if(module==3) iModul= 2;
+      if(module==4) iModul= 1;
+      if(module==5) iModul= 0;
+    }
+
+
+  if(iLayer==4)
+    {
+      if(module==0) iModul= 7;
+      if(module==1) iModul= 6;
+      if(module==2) iModul= 5;
+      if(module==3) iModul= 4;
+      if(module==4) iModul= 3;
+      if(module==5) iModul= 2;
+      if(module==6) iModul= 1;
+      if(module==7) iModul= 0;
+    }
+
+  if(module<0) {printf("ERROR MOULE\n"); iModul=0;}
+  */
+
   if(str[23+ord]=='0') iModul=0;
   if(str[23+ord]=='1') iModul=1;
   if(str[23+ord]=='2') iModul=2;
@@ -557,12 +966,14 @@ void AliITSSurveyToAlign::ReadPointNameSDD(const char str[], Int_t &iLayer, Int_
   if(str[23+ord]=='8') iModul=8;
   if(str[23+ord]=='9') iModul=9;
 
+
   if((str[25+ord]=='R')&&(str[26+ord]=='D')) iPoint=0;
   if((str[25+ord]=='R')&&(str[26+ord]=='C')) iPoint=1;
   if((str[25+ord]=='R')&&(str[26+ord]=='U')) iPoint=2;
   if((str[25+ord]=='L')&&(str[26+ord]=='U')) iPoint=3;
   if((str[25+ord]=='L')&&(str[26+ord]=='C')) iPoint=4;
   if((str[25+ord]=='L')&&(str[26+ord]=='D')) iPoint=5;
+
   return;
 }
 
@@ -583,13 +994,19 @@ void AliITSSurveyToAlign::ConvertToRSofModulesAndRotSDD(Int_t Layer, Int_t Modul
   Double_t zmMeE;
 
   Double_t x0=fSDDidP[1][0];
-  Double_t z0=fSDDidP[1][2]-0.52;
+  Double_t z0=fSDDidP[1][2];//-0.5205;
+  //  Double_t z0=fSDDidP[1][2]-0.5;
+  //  printf("x0= %f   z0= %f \n",x0,z0);
   for(Int_t i=0; i<6; i++)
     {
-      fSDDidP[i][2]-=0.52;
+      //      fSDDidP[i][2]-=0.5205;
+      //      fSDDidP[i][2]-=0.5;
 
       if(!fSDDisMe[i]) continue; 
 
+      //      printf("Me1_0: %d:  %f  %f  %f\n",i, fSDDmeP[i][0], fSDDmeP[i][1], fSDDmeP[i][2]);
+      //      printf("Id1_0: %d:  %f  %f  %f\n",i, fSDDidP[i][0], fSDDidP[i][1], fSDDidP[i][2]);
+
       fSDDidP[i][0]-=x0;
       fSDDidP[i][2]-=z0;
       fSDDmeP[i][0]-=x0;
@@ -623,6 +1040,9 @@ void AliITSSurveyToAlign::ConvertToRSofModulesAndRotSDD(Int_t Layer, Int_t Modul
          fSDDmeP[i][0]*=(-1);
          fSDDmeP[i][2]*=(-1);
        }
+      //      printf("Me1_1: %d:  %f  %f  %f\n",i, fSDDmeP[i][0], fSDDmeP[i][1], fSDDmeP[i][2] );
+      //      printf("Id1_1: %d:  %f  %f  %f\n",i, fSDDidP[i][0], fSDDidP[i][1], fSDDidP[i][2]);
+
     }  
 }
 
@@ -663,6 +1083,16 @@ void AliITSSurveyToAlign::CalcShiftSDD(Double_t &x0,Double_t &y0,Double_t &z0) c
   x0=x1;
   y0=x2;
   z0=x3;
+
+/*
+  for(Int_t iP1=0; iP1<6; iP1++)
+    {
+      if(!fSDDisMe[iP1]) continue;
+      printf("%d Me: %6.3f  %6.3f  %6.3f\n",iP1, fSDDmeP[iP1][0], fSDDmeP[iP1][1], fSDDmeP[iP1][2]);
+      printf("%d Id: %6.3f  %6.3f  %6.3f\n",iP1, fSDDidP[iP1][0], fSDDidP[iP1][1], fSDDidP[iP1][2]);
+    }
+*/
+
   return;
 }
 
@@ -689,7 +1119,9 @@ void AliITSSurveyToAlign::CalcShiftRotSDD(Double_t &tet,Double_t &psi,Double_t &
   Double_t xId, yId, zId;
   Double_t xMe, yMe, zMe, sX2, sY2, sZ2;
 
-  for(Int_t iP1=0; iP1<=6; iP1++)
+  //  printf("\n");
+
+  for(Int_t iP1=0; iP1<6; iP1++)
     {
       if(!fSDDisMe[iP1]) continue;
 
@@ -703,12 +1135,18 @@ void AliITSSurveyToAlign::CalcShiftRotSDD(Double_t &tet,Double_t &psi,Double_t &
       yMe= fSDDmeP[iP1][1];
       zMe= fSDDmeP[iP1][2];
 
+      //      printf("Me1: %d:  %f  %f  %f\n",iP1, xMe, yMe, zMe );
+      //      printf("MeE: %d:  %f  %f  %f\n",iP1, fSDDmeP[iP1][3], fSDDmeP[iP1][4], fSDDmeP[iP1][5] );
+      //      printf("Id1: %d:  %f  %f  %f\n",iP1, xId, yId, zId );
+      //      printf("Res: %d:  %f  %f  %f\n",iP1, xMe-xId, yMe-yId, zMe-zId );
+
       //squared precisions of measured x,y,z for fiducial mark iP1
       sX2 = fSDDmeP[iP1][3]* fSDDmeP[iP1][3];
       sY2 = fSDDmeP[iP1][4]* fSDDmeP[iP1][4];
       sZ2 = fSDDmeP[iP1][5]* fSDDmeP[iP1][5];
 
       a[0][0]+=(zId*zId/sX2+xId*xId/sZ2);
+      //      printf("%f\n",a[0][0]);
       a[0][1]-=(zId*yId/sX2);
       a[0][2]-=(xId*yId/sZ2);
       a[0][3]-=(zId/sX2);
@@ -789,27 +1227,27 @@ void AliITSSurveyToAlign::CalcShiftRotSDD(Double_t &tet,Double_t &psi,Double_t &
   Double_t x5 = p5.Determinant()/det0;
   Double_t x6 = p6.Determinant()/det0;
   //cout << "calculating determinants done" << endl;
-  if (x1 == 0) {
+  if (TMath::Abs(x1) < 1.e-10) {
     AliInfo("p1 singular ");
     p1.Print();
   }
-  if (x2 == 0) {
+  if (TMath::Abs(x2) < 1.e-10) {
     AliInfo("p2 singular ");
     p2.Print();
   }
-  if (x3 == 0) {
+  if (TMath::Abs(x3) < 1.e-10) {
     AliInfo("p3 singular ");
     p3.Print();
   }
-  if (x4 == 0) {
+  if (TMath::Abs(x4) < 1.e-10) {
     AliInfo("p4 singular ");
     p4.Print();
   }
-  if (x5 == 0) {
+  if (TMath::Abs(x5) < 1.e-10) {
     AliInfo("p5 singular ");
     p5.Print();
   }
-  if (x6 == 0) {
+  if (TMath::Abs(x6) < 1.e-10) {
     AliInfo("p6 singular ");
     p6.Print();
   }
@@ -821,5 +1259,20 @@ void AliITSSurveyToAlign::CalcShiftRotSDD(Double_t &tet,Double_t &psi,Double_t &
   x0=x4;
   y0=x5;
   z0=x6;
+
+  //  for(Int_t i=0; i<6; i++)
+    //  printf("%f  %f  %f  %f  %f  %f\n",a[i][0], a[i][1], a[i][2], a[i][3], a[i][4], a[i][5]);
+
+  //  pC.Print();
+  //  p1.Print();
+  //  p2.Print();
+  //  p3.Print();
+  //  p4.Print();
+  //  p5.Print();
+  //  p6.Print();
+
+
+  //  printf("fit: %f  %f  %f  %f  %f  %f\n",x0, y0, z0, tet, psi, phi);
+
   return;
 }