The present commit corresponds to an important change in the way the
[u/mrichter/AliRoot.git] / ITS / AliITSv11Hybrid.cxx
index 6a381e4..3ec260d 100644 (file)
@@ -1,5 +1,5 @@
 /**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
  *                                                                        *
  * Author: The ALICE Off-line Project.                                    *
  * Contributors are mentioned in the code where appropriate.              *
  **************************************************************************/
 
 
-// $Id$
+/* $Id$ */
 
 
 //========================================================================
 //
 //            Geometry of the Inner Tracking System
-//
+//           ---------------------------------------
 //  This geometry is a mix between the old geometry (originally coded
 //  in AliITSvPPRasymmFMD) and the new TGeo geometry (v11).
 //  The flags which indicate whether the old or the new part is used
 
 
 
-// $Log$
+// $Log: AliITSv11Hybrid.cxx,v $
+// Revision 1.14  2008/01/10 11:14:13  masera
+// SPD/SDD thermal shield and SPD cones updated (M. Sitta)
+//
+// Revision 1.13  2007/12/20 16:58:46  masera
+// bug fixes for SPD1 and SDD1 (A. Dainese)
+//
+// Revision 1.12  2007/12/17 14:48:23  masera
+// Thermal shield between SPD and SDD (M. Sitta)
+//
+// Revision 1.11  2007/11/22 08:32:48  masera
+// Second thermal shield updated in agreement with the installed one. Correction concerning the chemical composition of Rohacell (M.Sitta)
+//
+// Revision 1.10  2007/11/19 17:01:26  masera
+// SSD ladder supports + endcaps systems (E. Cattaruzza)
+//
+// Revision 1.9  2007/10/21 19:22:53  masera
+// Coding conventions
+//
 // Revision 1.8  2007/10/21 18:59:10  masera
 // SPD new geometry added to Hybrid V11
 //
 // Updates concerning the geometry: versioning system, new V11hybrid version, bug fixes (B.Nilsend and L. Gaudichet
 //
 
-
 #include <TClonesArray.h>
-#include <TGeometry.h>
-#include <TLorentzVector.h>
+#include <TGeoGlobalMagField.h>
+#include <TGeoManager.h>
 #include <TGeoMatrix.h>
 #include <TGeoPhysicalNode.h>
-#include <TString.h>
-#include <TNode.h>
-#include <TTUBE.h>
-#include <TGeoManager.h>
 #include <TGeoVolume.h>
+#include <TGeoXtru.h>
+#include <TLorentzVector.h>
+#include <TString.h>
 #include <TVirtualMC.h>
 
 #include "AliITS.h"
 #include "AliITSDetTypeSim.h"
 #include "AliITSgeom.h"
-#include "AliITSgeomSDD.h"
-#include "AliITSgeomSPD.h"
-#include "AliITSgeomSSD.h"
 #include "AliITShit.h"
 #include "AliITSCalibrationSDD.h"
 #include "AliITSsegmentationSDD.h"
 #include "AliITSv11GeometrySPD.h"
 #include "AliITSv11GeometrySDD.h"
 #include "AliITSv11GeometrySSD.h"
+#include "AliITSv11GeometrySupport.h"
+#include "AliGeomManager.h"
 
 
 ClassImp(AliITSv11Hybrid)
 
 //______________________________________________________________________
 AliITSv11Hybrid::AliITSv11Hybrid():
-  AliITS(),
-  fGeomDetOut(kFALSE),
-  fGeomDetIn(kFALSE),
   fByThick(kTRUE),
   fMajorVersion(IsVersion()),
   fMinorVersion(-1),
@@ -108,7 +120,8 @@ AliITSv11Hybrid::AliITSv11Hybrid():
   fInitGeom((AliITSVersion_t)fMajorVersion,fMinorVersion),
   fSPDgeom(0),
   fSDDgeom(0),
-  fSSDgeom(0)
+  fSSDgeom(0),
+  fSupgeom(0)
  {
     //    Standard default constructor
     // Inputs:
@@ -122,8 +135,6 @@ AliITSv11Hybrid::AliITSv11Hybrid():
 //______________________________________________________________________
 AliITSv11Hybrid::AliITSv11Hybrid(const char *title) 
   : AliITS("ITS", title),
-    fGeomDetOut(kFALSE),
-    fGeomDetIn(kFALSE),
     fByThick(kTRUE),
     fMajorVersion(IsVersion()),
     fMinorVersion(1),
@@ -137,7 +148,9 @@ AliITSv11Hybrid::AliITSv11Hybrid(const char *title)
     fInitGeom((AliITSVersion_t)fMajorVersion,fMinorVersion),
     fSPDgeom(0),
     fSDDgeom(0),
-    fSSDgeom(0) {
+    fSSDgeom(0),
+    fSupgeom(0)
+{
     //    Standard constructor for the v11Hybrid geometry.
     // Inputs:
     //   const char * title  Arbitrary title
@@ -150,6 +163,7 @@ AliITSv11Hybrid::AliITSv11Hybrid(const char *title)
   fSPDgeom = new AliITSv11GeometrySPD();
   fSDDgeom = new AliITSv11GeometrySDD(0);
   fSSDgeom = new AliITSv11GeometrySSD();
+  fSupgeom = new AliITSv11GeometrySupport();
 
   fIdN = 6;
   fIdName = new TString[fIdN];
@@ -186,18 +200,11 @@ AliITSv11Hybrid::AliITSv11Hybrid(const char *title)
   SetThicknessChip2();
   SetDensityServicesByThickness();
   
-  fEuclidGeometry="$ALICE_ROOT/ITS/ITSgeometry_vPPRasymm2.euc";
-  strncpy(fEuclidGeomDet,"$ALICE_ROOT/ITS/ITSgeometry_vPPRasymm2.det",60);
-  strncpy(fRead,fEuclidGeomDet,60);
-  strncpy(fWrite,fEuclidGeomDet,60);
-  strncpy(fRead,"$ALICE_ROOT/ITS/ITSgeometry_vPPRasymmFMD.det",60);
 }
 
 //______________________________________________________________________
 AliITSv11Hybrid::AliITSv11Hybrid(const char *name, const char *title) 
   : AliITS("ITS", title),
-    fGeomDetOut(kFALSE),
-    fGeomDetIn(kFALSE),
     fByThick(kTRUE),
     fMajorVersion(IsVersion()),
     fMinorVersion(1),
@@ -211,7 +218,9 @@ AliITSv11Hybrid::AliITSv11Hybrid(const char *name, const char *title)
     fInitGeom((AliITSVersion_t)fMajorVersion,fMinorVersion),
     fSPDgeom(0),
     fSDDgeom(0),
-    fSSDgeom(0) {
+    fSSDgeom(0),
+    fSupgeom(0)
+{
     //    Standard constructor for the v11Hybrid geometry.
     // Inputs:
     //   const char * name   Ignored, set to "ITS"
@@ -225,6 +234,7 @@ AliITSv11Hybrid::AliITSv11Hybrid(const char *name, const char *title)
   fSPDgeom = new AliITSv11GeometrySPD();
   fSDDgeom = new AliITSv11GeometrySDD(0);
   fSSDgeom = new AliITSv11GeometrySSD();
+  fSupgeom = new AliITSv11GeometrySupport();
 
   fIdN = 6;
   fIdName = new TString[fIdN];
@@ -263,11 +273,6 @@ AliITSv11Hybrid::AliITSv11Hybrid(const char *name, const char *title)
   SetThicknessChip2();
   SetDensityServicesByThickness();
   
-  fEuclidGeometry="$ALICE_ROOT/ITS/ITSgeometry_vPPRasymm2.euc";
-  strncpy(fEuclidGeomDet,"$ALICE_ROOT/ITS/ITSgeometry_vPPRasymm2.det",60);
-  strncpy(fRead,fEuclidGeomDet,60);
-  strncpy(fWrite,fEuclidGeomDet,60);
-  strncpy(fRead,"$ALICE_ROOT/ITS/ITSgeometry_vPPRasymmFMD.det",60);
 }
 
 //______________________________________________________________________
@@ -282,10 +287,11 @@ AliITSv11Hybrid::~AliITSv11Hybrid() {
   delete fSPDgeom;
   delete fSDDgeom;
   delete fSSDgeom;
+  delete fSupgeom;
 }
 
 //______________________________________________________________________
-void AliITSv11Hybrid::SetT2Lmatrix(const char *name, Double_t yShift, 
+void AliITSv11Hybrid::SetT2Lmatrix(Int_t uid, Double_t yShift, 
                                   Bool_t yFlip, Bool_t yRot180)
   const {
 
@@ -295,12 +301,8 @@ void AliITSv11Hybrid::SetT2Lmatrix(const char *name, Double_t yShift,
   //
   // This function is used in AddAlignableVolumes()
 
-  TGeoPNEntry *alignableEntry = gGeoManager->GetAlignableEntry(name);
-  const char *path = alignableEntry->GetTitle();
-
-  if (!gGeoManager->cd(path))
-    AliFatal(Form("Volume path %s not valid!",path));
-  TGeoHMatrix* globMatrix = gGeoManager->GetCurrentMatrix();
+  TGeoPNEntry *alignableEntry = gGeoManager->GetAlignableEntryByUID(uid);
+  TGeoHMatrix* globMatrix = alignableEntry->GetGlobalOrig();
 
   Double_t *gtrans = globMatrix->GetTranslation(), rotMatrix[9];
   memcpy(&rotMatrix[0], globMatrix->GetRotationMatrix(), 9*sizeof(Double_t));
@@ -308,22 +310,26 @@ void AliITSv11Hybrid::SetT2Lmatrix(const char *name, Double_t yShift,
   if (yRot180) {
     al = TMath::ATan2(rotMatrix[1],-rotMatrix[0]);
   }
+  Double_t xShift = gtrans[0]*TMath::Cos(al)+gtrans[1]*TMath::Sin(al);
+  Double_t zShift = -gtrans[2];
 
   TGeoHMatrix *matLtoT = new TGeoHMatrix;
-  matLtoT->SetDx( gtrans[0]*TMath::Cos(al)+gtrans[1]*TMath::Sin(al) ); // translation
+  matLtoT->SetDx( xShift ); // translation
   matLtoT->SetDy( yShift );
-  matLtoT->SetDz(-gtrans[2]);
+  matLtoT->SetDz( zShift );
   rotMatrix[0]= 0;  rotMatrix[1]= 1;  rotMatrix[2]= 0; // + rotation
   rotMatrix[3]= 1;  rotMatrix[4]= 0;  rotMatrix[5]= 0;
   rotMatrix[6]= 0;  rotMatrix[7]= 0;  rotMatrix[8]=-1;
   if (yFlip) rotMatrix[3] = -1;  // flipping in y  (for SPD1)
+  if (yFlip) rotMatrix[1] = -1;  // flipping in y  (for SPD1)
 
   if (yRot180) { // rotation of pi around the axis perpendicular to the wafer
+    if (yFlip) matLtoT->SetDx( -xShift ); // flipping in y  (for SPD1)
     matLtoT->SetDy( -yShift );
+    matLtoT->SetDz( -zShift );
+    rotMatrix[8]=1;
     rotMatrix[3] = -1;
     if (yFlip) rotMatrix[3] = 1;  // flipping in y  (for SPD1)
-    matLtoT->SetDz(gtrans[2]);
-    rotMatrix[8]=1;
   }
 
   TGeoRotation rot;
@@ -335,9 +341,7 @@ void AliITSv11Hybrid::SetT2Lmatrix(const char *name, Double_t yShift,
 }
 
 //______________________________________________________________________
-void AliITSv11Hybrid::AddAlignableVolumes() const
-{
-  //
+void AliITSv11Hybrid::AddAlignableVolumes() const{
   // Creates entries for alignable volumes associating the symbolic volume
   // name with the corresponding volume path.
   // 
@@ -346,6 +350,12 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
   // system
   // For this, this function has to run before the misalignment because we
   // are using the ideal positions in the AliITSgeom object.
+  // Inputs:
+  //   none.
+  // Outputs:
+  //   none.
+  // Return:
+  //   none.
 
   AliInfo("Add ITS alignable volumes");
 
@@ -354,8 +364,12 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
     return;
   }
 
+  AliGeomManager::ELayerID layerId;
+  Int_t modUID, modnum;
+
   if( !gGeoManager->SetAlignableEntry("ITS","ALIC_1/ITSV_1") )
-    AliFatal("Unable to set alignable entry!!");    
+    AliFatal(Form("Unable to set alignable entry ! %s :: %s",
+                  "ITS","ALIC_1/ITSV_1"));    
 
   TString strSPD = "ITS/SPD";
   TString strSDD = "ITS/SDD";
@@ -371,19 +385,23 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
   TString strEntryName4;
 
   //===== SPD layers =====
+  
   if (AliITSInitGeometry::SPDIsTGeoNative()) { // new SPD geometry
 
-    TString str0 = "ALIC_1/ITSV_1/ITSSPDCarbonFiberSectorV_";
-    TString str1 = "/ITSSPDSensitiveVirtualvolumeM0_1/LAY1_STAVE_";
-    TString str1Bis = "/HALF-STAVE";
+    TString str0 = "ALIC_1/ITSV_1/ITSSPD_1/ITSSPDCarbonFiberSectorV_";
+    TString str1 = "/ITSSPDSensitiveVirtualvolumeM0_1/ITSSPDlay1-Stave_";
+    TString str1Bis = "/ITSSPDhalf-Stave";
     TString str1Tierce = "_1";
-    TString str2 = "/LAY1_LADDER_";
+    TString str2 = "/ITSSPDlay1-Ladder_";
   
     TString sector;
     TString stave;
     TString halfStave;
     TString module;
 
+    layerId = AliGeomManager::kSPD1;
+    modnum = 0;
+    
     for(Int_t cSect = 0; cSect<10; cSect++) {
 
       sector = str0;
@@ -393,14 +411,14 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
       strEntryName1 += strSector;
       strEntryName1 += cSect;
       if(!gGeoManager->SetAlignableEntry(strEntryName1.Data(),sector.Data()))
-       AliFatal("Unable to set alignable entry!!");    
-      //printf("%s   ==   %s\n",strEntryName1.Data(),sector.Data());
-      
+       AliFatal(Form("New lay 1: Unable to set alignable entry 1! %s::%s",
+                 strEntryName1.Data(),sector.Data()));
+
       for(Int_t cStave=0; cStave<2; cStave++) {
        
        stave = sector;
        stave += str1;
-       stave += cStave;
+       stave += cStave+1;
        strEntryName2 = strEntryName1;
        strEntryName2 += strStave;
        strEntryName2 += cStave;
@@ -415,31 +433,37 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
          strEntryName3 += strHalfStave;
          strEntryName3 += cHS;
 
-         if(!gGeoManager->SetAlignableEntry(strEntryName3.Data(),halfStave.Data()))
-           AliFatal(Form("Unable to set alignable entry!! %s :: %s",strEntryName3.Data(),halfStave.Data()));    
+         if(!gGeoManager->SetAlignableEntry(strEntryName3.Data(),
+                                             halfStave.Data()))
+           AliFatal(Form("New lay 1: Unable to set alignable entry 3! %s::%s",
+                          strEntryName3.Data(),halfStave.Data()));    
 
          for(Int_t cLad=0; cLad<2; cLad++) {
          
+           modUID = AliGeomManager::LayerToVolUID(layerId,modnum++);
            module = halfStave;
            module += str2;
-           module += cLad+cHS*2;
+           module += cLad+cHS*2+1;
            strEntryName4 = strEntryName3;
            strEntryName4 += strLadder;
            strEntryName4 += cLad+cHS*2;
-           if(!gGeoManager->SetAlignableEntry(strEntryName4.Data(),module.Data()))
-             AliFatal("Unable to set alignable entry!!");    
-           
-           SetT2Lmatrix(strEntryName4.Data(), -0.0081, kTRUE, kTRUE);
-           // -0.0081 is the shift between the centers of alignable and sensitive volumes
-           // It is directly extracted from the new SPD geometry
-         }
-       }
-      }
-    }
-    
-    str1 = "/ITSSPDSensitiveVirtualvolumeM0_1/LAY2_STAVE_";
-    str2 = "/LAY2_LADDER_";
+           if(!gGeoManager->SetAlignableEntry(strEntryName4.Data(),module.Data(),modUID))
+             AliFatal(Form("New lay 1: Unable to set alignable entry 4! %s::%s",
+                       strEntryName4.Data(),module.Data()));
+
+           SetT2Lmatrix(modUID, 0.0081, kTRUE, kTRUE);
+           // 0.0081 is the shift between the centers of alignable 
+            // and sensitive volumes. It is directly extracted from 
+            // the new SPD geometry
+         } // end for cLad
+       } // end for cHS
+      } // end for cStave
+    } // end for cSect
+
+    layerId = AliGeomManager::kSPD2;
+    modnum = 0;
+    str1 = "/ITSSPDSensitiveVirtualvolumeM0_1/ITSSPDlay2-Stave_";
+    str2 = "/ITSSPDlay2-Ladder_";
 
     for(Int_t cSect = 0; cSect<10; cSect++) {
 
@@ -454,7 +478,7 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
        
        stave = sector;
        stave += str1;
-       stave += cStave;
+       stave += cStave+1;
        strEntryName2 = strEntryName1;
        strEntryName2 += strStave;
        strEntryName2 += cStave;
@@ -469,25 +493,29 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
          strEntryName3 += strHalfStave;
          strEntryName3 += cHS;
 
-         if(!gGeoManager->SetAlignableEntry(strEntryName3.Data(),halfStave.Data()))
-           AliFatal("Unable to set alignable entry!!");    
+         if(!gGeoManager->SetAlignableEntry(strEntryName3.Data(),
+                                             halfStave.Data()))
+           AliFatal(Form("New lay 2: Unable to set alignable entry 3! %s::%s",
+                     strEntryName3.Data(),halfStave.Data()));    
 
          for(Int_t cLad=0; cLad<2; cLad++) {
-         
+
+           modUID = AliGeomManager::LayerToVolUID(layerId,modnum++);
            module = halfStave;
            module += str2;
-           module += cLad+cHS*2;
+           module += cLad+cHS*2 +1;
            strEntryName4 = strEntryName3;
            strEntryName4 += strLadder;
            strEntryName4 += cLad+cHS*2;
-           if(!gGeoManager->SetAlignableEntry(strEntryName4.Data(),module.Data()))
-             AliFatal("Unable to set alignable entry!!");    
+           if(!gGeoManager->SetAlignableEntry(strEntryName4.Data(),module.Data(),modUID))
+             AliFatal(Form("New lay 2: Unable to set alignable entry 4! %s::%s",
+                       strEntryName4.Data(),module.Data()));
 
-           SetT2Lmatrix(strEntryName4.Data(), -0.0081, kFALSE);
-         }
-       }
-      }
-    }
+           SetT2Lmatrix(modUID, -0.0081, kFALSE);
+         } // end for cLad
+       } // end for cHS
+      } // end for cStave
+    } // cSect
 
   } else {  // else old SPD geometry
 
@@ -502,6 +530,9 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
     TString halfStave;
     TString module;
 
+    layerId = AliGeomManager::kSPD1;
+    modnum = 0;
+
     for(Int_t cSect = 0; cSect<10; cSect++) {
 
       sector = str0;
@@ -510,19 +541,20 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
       strEntryName1 += 0;
       strEntryName1 += strSector;
       strEntryName1 += cSect;
-      //printf("%s   ==   %s\n",strEntryName1.Data(),sector.Data());
       if(!gGeoManager->SetAlignableEntry(strEntryName1.Data(),sector.Data()))
-       AliFatal("Unable to set alignable entry!!");    
-      
+       AliFatal(Form("Old lay1: Unable to set alignable entry 1! %s::%s",
+                 strEntryName1.Data(),sector.Data()));    
+
       for(Int_t cStave = 0; cStave<2; cStave++) {
-       
+
        stave = sector;
        stave += str1;
        stave += cStave+1;
        strEntryName2 = strEntryName1;
        strEntryName2 += strStave;
        strEntryName2 += cStave;
-       //printf("%s   ==   %s\n",strEntryName2.Data(),stave.Data()); // this is a stave
+        // this is a stave
+       //printf("%s   ==   %s\n",strEntryName2.Data(),stave.Data()); 
 
        for(Int_t cHS=0; cHS<2; cHS++) {
 
@@ -533,12 +565,16 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
          strEntryName3 = strEntryName2;
          strEntryName3 += strHalfStave;
          strEntryName3 += cHS;
-         //printf("%s   ==   %s\n",strEntryName3.Data(),halfStave.Data()); // this is a half-stave
-         if(!gGeoManager->SetAlignableEntry(strEntryName3.Data(),halfStave.Data()))
-           AliFatal("Unable to set alignable entry!!");    
+          // this is a half-stave
+         //printf("%s   ==   %s\n",strEntryName3.Data(),halfStave.Data()); 
+         if(!gGeoManager->SetAlignableEntry(strEntryName3.Data(),
+                                             halfStave.Data()))
+           AliFatal(Form("Old lay 1: Unable to set alignable entry 3! %s::%s",
+                     strEntryName3.Data(),halfStave.Data()));
 
          for(Int_t cLadder = 0; cLadder<2; cLadder++) {
            
+           modUID = AliGeomManager::LayerToVolUID(layerId,modnum++);
            module = halfStave;
            module += str2;
            module += cLadder+cHS*2+1;
@@ -546,14 +582,18 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
            strEntryName4 += strLadder;
            strEntryName4 += cLadder+cHS*2;
            //printf("%s   ==   %s\n",strEntryName4.Data(),module.Data());
-           if(!gGeoManager->SetAlignableEntry(strEntryName4.Data(),module.Data()))
-             AliFatal("Unable to set alignable entry!!");    
+           if(!gGeoManager->SetAlignableEntry(strEntryName4.Data(),module.Data(),modUID))
+             AliFatal(Form("Old lay 1: Unable to set alignable entry 4! %s::%s",
+                   strEntryName4.Data(),module.Data()));
 
-           SetT2Lmatrix(strEntryName4.Data(), -fChip1*0.0001/2., kTRUE);
-         }
-       }
-      }
-    }
+           SetT2Lmatrix(modUID, -fChip1*0.0001/2., kTRUE);
+         } // end for cLadder
+       } // end for cHS
+      } // end for cStave
+    } // end for cSect
+
+    layerId = AliGeomManager::kSPD2;
+    modnum = 0;
 
     str1Bis = "/L2H-STAVE";
     str1 = "/I20B_";
@@ -567,11 +607,11 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
       strEntryName1 += 1;
       strEntryName1 += strSector;
       strEntryName1 += cSect;
-      //       if(!gGeoManager->SetAlignableEntry(strEntryName1.Data(),sector.Data()))
-      //       AliFatal("Unable to set alignable entry!!");    
-      // we don't need the previous lines because the whole sector is already define
-      // with first layer ...
-      
+      //if(!gGeoManager->SetAlignableEntry(strEntryName1.Data(),sector.Data()))
+      //       AliFatal(Form("Unable to set alignable entry!!");    
+      // we don't need the previous lines because the whole sector is 
+      // already define with first layer ...
+
       for(Int_t cStave =0; cStave<4; cStave++) {
        
        stave = sector;
@@ -590,12 +630,16 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
          strEntryName3 = strEntryName2;
          strEntryName3 += strHalfStave;
          strEntryName3 += cHS;
-         //printf("%s   ==   %s\n",strEntryName3.Data(),halfStave.Data()); // this is a half-stave
-         if(!gGeoManager->SetAlignableEntry(strEntryName3.Data(),halfStave.Data()))
-           AliFatal("Unable to set alignable entry!!");    
+          // this is a half-stave
+         //printf("%s   ==   %s\n",strEntryName3.Data(),halfStave.Data()); 
+         if(!gGeoManager->SetAlignableEntry(strEntryName3.Data(),
+                                             halfStave.Data()))
+           AliFatal(Form("Old lay 2: Unable to set alignable entry 3! %s::%s",
+                     strEntryName3.Data(),halfStave.Data()));
 
          for(Int_t cLad =0; cLad<2; cLad++) {
-         
+
+           modUID = AliGeomManager::LayerToVolUID(layerId,modnum++);
            module = halfStave;
            module += str2;
            module += cLad+cHS*2+1;
@@ -603,19 +647,22 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
            strEntryName4 += strLadder;
            strEntryName4 += cLad+cHS*2;
            //printf("%s   ==   %s\n",strEntryName4.Data(),module.Data());
-           if(!gGeoManager->SetAlignableEntry(strEntryName4.Data(),module.Data()))
-             AliFatal("Unable to set alignable entry!!");
+           if(!gGeoManager->SetAlignableEntry(strEntryName4.Data(),module.Data(),modUID))
+             AliFatal(Form("Old lay2: Unable to set alignable entry 4! %s::%s",
+                       strEntryName4.Data(),module.Data()));
 
-           SetT2Lmatrix(strEntryName4.Data(), -fChip2*0.0001/2., kFALSE);
-         }
-       }
-      }
-    }
-  }
+           SetT2Lmatrix(modUID, -fChip2*0.0001/2., kFALSE);
+         } // end for cLad
+       } // end for cHS
+      } // end for cStave
+    } // end for cSect
+  } // end if AliITSInitGeometry::SPSIsTGeoNative().
 
   //===== SDD layers =====
   if (AliITSInitGeometry::SDDIsTGeoNative()) { // new SDD geometry
     
+    layerId = AliGeomManager::kSDD1;
+    modnum = 0;
     TString str0 = "/ALIC_1/ITSV_1/ITSsddLayer3_1/ITSsddLadd_"; // SDD layer1
     TString str1 = "/ITSsddSensor3_";
     TString str2 = "/ITSsddWafer3_1";
@@ -632,10 +679,12 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
       strEntryName1 += c1;
       //printf("%s    ==    %s\n",strEntryName1.Data(),ladder.Data());
       if(!gGeoManager->SetAlignableEntry(strEntryName1.Data(),ladder.Data()))
-       AliFatal("Unable to set alignable entry!!");    
+       AliFatal(Form("Unable to set alignable entry 1! %s :: %s",
+                 strEntryName1.Data(),ladder.Data()));
 
       for(Int_t c2 =0; c2<6; c2++) {
 
+       modUID = AliGeomManager::LayerToVolUID(layerId,modnum++);
        wafer = ladder;
        wafer += str1;
        wafer += c2;
@@ -644,13 +693,20 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
        strEntryName2 += strSensor;
        strEntryName2 += c2;
        //printf("%s    ==    %s\n",strEntryName2.Data(),wafer.Data());
-       if(!gGeoManager->SetAlignableEntry(strEntryName2.Data(),wafer.Data()))
-         AliFatal("Unable to set alignable entry!!");
-
-       SetT2Lmatrix(strEntryName2.Data(), 0, kFALSE, c2>=3);
+       if(!gGeoManager->SetAlignableEntry(strEntryName2.Data(),wafer.Data(),modUID))
+         AliFatal(Form("Unable to set alignable entry 2! %s :: %s",
+                   strEntryName2.Data(),wafer.Data()));
+
+       if(c1 != 2) { 
+       SetT2Lmatrix(modUID, 0, kFALSE, c2>=3);
+                 } else {// for ladder 2, mounted with a pi rot around y
+         SetT2Lmatrix(modUID, 0, kFALSE, c2<3);
+         }
       }
     }
 
+    layerId = AliGeomManager::kSDD2;
+    modnum = 0;
     str0 = "/ALIC_1/ITSV_1/ITSsddLayer4_1/ITSsddLadd_"; // SDD layer2
     str1 = "/ITSsddSensor4_";
     str2 = "/ITSsddWafer4_1";
@@ -665,10 +721,12 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
       strEntryName1 += c1;
       //printf("%s    ==    %s\n",strEntryName1.Data(),ladder.Data());
       if(!gGeoManager->SetAlignableEntry(strEntryName1.Data(),ladder.Data()))
-       AliFatal("Unable to set alignable entry!!");    
+       AliFatal(Form("Unable to set alignable entry 1! %s :: %s",
+                 strEntryName1.Data(),ladder.Data()));
 
       for(Int_t c2 =0; c2<8; c2++) {
 
+       modUID = AliGeomManager::LayerToVolUID(layerId,modnum++);
        wafer = ladder;
        wafer += str1;
        wafer += c2;
@@ -677,15 +735,19 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
        strEntryName2 += strSensor;
        strEntryName2 += c2;
        //printf("%s    ==    %s\n",strEntryName2.Data(),wafer.Data());
-       if(!gGeoManager->SetAlignableEntry(strEntryName2.Data(),wafer.Data()))
-         AliFatal("Unable to set alignable entry!!");  
+       if(!gGeoManager->SetAlignableEntry(strEntryName2.Data(),wafer.Data(),modUID))
+         AliFatal(Form("Unable to set alignable entry 2! %s :: %s",
+                   strEntryName2.Data(),wafer.Data()));
 
-       SetT2Lmatrix(strEntryName2.Data(), 0, kFALSE, c2>=4);
+       SetT2Lmatrix(modUID, 0, kFALSE, c2>=4);
       }
     }
 
   } else {  // else old SDD geometry
 
+    layerId = AliGeomManager::kSDD1;
+    modnum = 0;
+    
     TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT34_1/I004_";
     TString str1 = "/I302_";
     
@@ -701,25 +763,28 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
       strEntryName1 +=strLadder;
       strEntryName1 += (c1-1);
       if(!gGeoManager->SetAlignableEntry(strEntryName1.Data(),ladder.Data()))
-       AliFatal("Unable to set alignable entry!!");    
-      //printf("%s    ==    %s\n",strEntryName1.Data(),ladder.Data());
+       AliFatal(Form("Unable to set alignable entry 1! %s :: %s",
+                 strEntryName1.Data(),ladder.Data()));
 
       for(Int_t c2 =1; c2<=6; c2++){
 
+       modUID = AliGeomManager::LayerToVolUID(layerId,modnum++);
        wafer = ladder;
        wafer += str1;
        wafer += c2;    // one wafer
        strEntryName2 = strEntryName1;
        strEntryName2 += strSensor;
        strEntryName2 += (c2-1);
-       if(!gGeoManager->SetAlignableEntry(strEntryName2.Data(),wafer.Data()))
-         AliFatal("Unable to set alignable entry!!");    
-       //printf("%s    ==    %s\n",strEntryName2.Data(),wafer.Data());
+       if(!gGeoManager->SetAlignableEntry(strEntryName2.Data(),wafer.Data(),modUID))
+         AliFatal(Form("Unable to set alignable entry 2! %s :: %s",
+                   strEntryName2.Data(),wafer.Data()));
 
-       SetT2Lmatrix(strEntryName2.Data(), 0, kFALSE);
+       SetT2Lmatrix(modUID, 0, kFALSE);
       }
     }
 
+    layerId = AliGeomManager::kSDD2;
+    modnum = 0;
     str0 = "ALIC_1/ITSV_1/ITSD_1/IT34_1/I005_";
     str1 = "/I402_";
 
@@ -732,22 +797,23 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
       strEntryName1 +=strLadder;
       strEntryName1 += (c1-1);
       if(!gGeoManager->SetAlignableEntry(strEntryName1.Data(),ladder.Data()))
-       AliFatal("Unable to set alignable entry!!");    
-      //printf("%s    ==    %s\n",strEntryName1.Data(),ladder.Data());
+       AliFatal(Form("Unable to set alignable entry 1! %s :: %s",
+                 strEntryName1.Data(),ladder.Data()));
 
       for(Int_t c2 =1; c2<=8; c2++){
 
+       modUID = AliGeomManager::LayerToVolUID(layerId,modnum++);
        wafer = ladder;
        wafer += str1;
        wafer += c2;    // one wafer
        strEntryName2 = strEntryName1;
        strEntryName2 += strSensor;
        strEntryName2 += (c2-1);
-       if(!gGeoManager->SetAlignableEntry(strEntryName2.Data(),wafer.Data()))
-         AliFatal("Unable to set alignable entry!!");    
-       //printf("%s    ==    %s\n",strEntryName2.Data(),wafer.Data());
+       if(!gGeoManager->SetAlignableEntry(strEntryName2.Data(),wafer.Data(),modUID))
+         AliFatal(Form("Unable to set alignable entry 2! %s,%s",
+                        strEntryName2.Data(),wafer.Data()));
 
-       SetT2Lmatrix(strEntryName2.Data(), 0, kFALSE);
+       SetT2Lmatrix(modUID, 0, kFALSE);
       }
     }
   }   // end SDD
@@ -755,8 +821,10 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
   //===== SSD layers =====
   if (AliITSInitGeometry::SSDIsTGeoNative()) { // new SSD geometry
 
-    TString str0 = "/ALIC_1/ITSV_1/ITSssdLayer5_1/ITSssdLay5Ladd_"; // SSD layer1
-    TString str1 = "/ITSsddSensor5_";
+    layerId = AliGeomManager::kSSD1;
+    modnum = 0;
+    TString str0 = "/ALIC_1/ITSV_1/ITSssdLayer5_1/ITSssdLay5Ladd_";//SSD layer1
+    TString str1 = "/ITSssdSensor5_";
     TString str2 = "";
     TString ladder;
     TString wafer;
@@ -771,10 +839,12 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
       strEntryName1 += c1;
       //printf("%s    ==    %s\n",strEntryName1.Data(),ladder.Data());
       if(!gGeoManager->SetAlignableEntry(strEntryName1.Data(),ladder.Data()))
-       AliFatal("Unable to set alignable entry!!");    
+       AliFatal(Form("Unable to set alignable entry 1! %s :: %s",
+                 strEntryName1.Data(),ladder.Data()));
 
       for(Int_t c2 =0; c2<22; c2++) {
 
+       modUID = AliGeomManager::LayerToVolUID(layerId,modnum++);
        wafer = ladder;
        wafer += str1;
        wafer += c2;
@@ -783,15 +853,18 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
        strEntryName2 += strSensor;
        strEntryName2 += c2;
        //printf("%s    ==    %s\n",strEntryName2.Data(),wafer.Data());
-       if(!gGeoManager->SetAlignableEntry(strEntryName2.Data(),wafer.Data()))
-         AliFatal("Unable to set alignable entry!!");
+       if(!gGeoManager->SetAlignableEntry(strEntryName2.Data(),wafer.Data(),modUID))
+         AliFatal(Form("Unable to set alignable entry 2! %s :: %s",
+                   strEntryName2.Data(),wafer.Data()));
 
-       SetT2Lmatrix(strEntryName2.Data(), 0, kFALSE, kFALSE);
+       SetT2Lmatrix(modUID, 0, kFALSE, kFALSE);
       }
     }
 
+    layerId = AliGeomManager::kSSD2;
+    modnum = 0;
     str0 = "/ALIC_1/ITSV_1/ITSssdLayer6_1/ITSssdLay6Ladd_"; // SSD layer2
-    str1 = "/ITSsddSensor6_";
+    str1 = "/ITSssdSensor6_";
     str2 = "";
     
     for(Int_t c1 = 0; c1<38; c1++) {
@@ -804,10 +877,12 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
       strEntryName1 += c1;
       //printf("%s    ==    %s\n",strEntryName1.Data(),ladder.Data());
       if(!gGeoManager->SetAlignableEntry(strEntryName1.Data(),ladder.Data()))
-       AliFatal("Unable to set alignable entry!!");    
+       AliFatal(Form("Unable to set alignable entry 1! %s :: %s",
+                 strEntryName1.Data(),ladder.Data()));
 
       for(Int_t c2 =0; c2<25; c2++) {
 
+       modUID = AliGeomManager::LayerToVolUID(layerId,modnum++);
        wafer = ladder;
        wafer += str1;
        wafer += c2;
@@ -816,14 +891,18 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
        strEntryName2 += strSensor;
        strEntryName2 += c2;
        //printf("%s    ==    %s\n",strEntryName2.Data(),wafer.Data());
-       if(!gGeoManager->SetAlignableEntry(strEntryName2.Data(),wafer.Data()))
-         AliFatal("Unable to set alignable entry!!");  
+       if(!gGeoManager->SetAlignableEntry(strEntryName2.Data(),wafer.Data(),modUID))
+         AliFatal(Form("Unable to set alignable entry 2! %s :: %s",
+                   strEntryName2.Data(),wafer.Data()));
 
-       SetT2Lmatrix(strEntryName2.Data(), 0, kFALSE, kFALSE);
+       SetT2Lmatrix(modUID, 0, kFALSE, kFALSE);
       }
     }
     
   } else { // else old SSD geometry
+    
+    layerId = AliGeomManager::kSSD1;
+    modnum = 0;
     TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT56_1/I565_";
     TString str1 = "/I562_";
     TString ladder;
@@ -838,25 +917,28 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
       strEntryName1 +=strLadder;
       strEntryName1 += (c1-1);
       if(!gGeoManager->SetAlignableEntry(strEntryName1.Data(),ladder.Data()))
-       AliFatal("Unable to set alignable entry!!");    
-      //printf("%s    ==    %s\n",strEntryName1.Data(),ladder.Data());
-      
+          AliFatal(Form("Unable to set alignable entry 1! %s :: %s",
+                   strEntryName1.Data(),ladder.Data()));
+
       for(Int_t c2 = 1; c2<=22; c2++){
        
+       modUID = AliGeomManager::LayerToVolUID(layerId,modnum++);
        wafer = ladder;
        wafer += str1;
        wafer += c2;     // one wafer
        strEntryName2 = strEntryName1;
        strEntryName2 += strSensor;
        strEntryName2 += (c2-1);
-       if(!gGeoManager->SetAlignableEntry(strEntryName2.Data(),wafer.Data()))
-         AliFatal("Unable to set alignable entry!!");    
-       //printf("%s    ==    %s\n",strEntryName2.Data(),wafer.Data());
-       
-       SetT2Lmatrix(strEntryName2.Data(), 0, kFALSE);
+       if(!gGeoManager->SetAlignableEntry(strEntryName2.Data(),wafer.Data(),modUID))
+         AliFatal(Form("Unable to set alignable entry 2! %s :: %s",
+                   strEntryName2.Data(),wafer.Data()));
+
+       SetT2Lmatrix(modUID, 0, kFALSE);
       }
     }
     
+    layerId = AliGeomManager::kSSD2;
+    modnum = 0;
     str0 = "ALIC_1/ITSV_1/ITSD_1/IT56_1/I569_";
     str1 = "/I566_";
     
@@ -869,85 +951,29 @@ void AliITSv11Hybrid::AddAlignableVolumes() const
       strEntryName1 +=strLadder;
       strEntryName1 += (c1-1);
       if(!gGeoManager->SetAlignableEntry(strEntryName1.Data(),ladder.Data()))
-       AliFatal("Unable to set alignable entry!!");    
-      //printf("%s    ==    %s\n",strEntryName1.Data(),ladder.Data());
-      
+       AliFatal(Form("Unable to set alignable entry 1! %s :: %s",
+                 strEntryName1.Data(),ladder.Data()));
+
       for(Int_t c2 = 1; c2<=25; c2++){
        
+       modUID = AliGeomManager::LayerToVolUID(layerId,modnum++);
        wafer = ladder;
        wafer += str1;
        wafer += c2;     // one wafer
        strEntryName2 = strEntryName1;
        strEntryName2 += strSensor;
        strEntryName2 += (c2-1);
-       if(!gGeoManager->SetAlignableEntry(strEntryName2.Data(),wafer.Data()))
-         AliFatal("Unable to set alignable entry!!");    
-       //printf("%s    ==    %s\n",strEntryName2.Data(),wafer.Data());
-       
-       SetT2Lmatrix(strEntryName2.Data(), 0, kFALSE);
+       if(!gGeoManager->SetAlignableEntry(strEntryName2.Data(),wafer.Data(),modUID))
+         AliFatal(Form("Unable to set alignable entry 2! %s :: %s",
+                   strEntryName2.Data(),wafer.Data()));
+
+       SetT2Lmatrix(modUID, 0, kFALSE);
       }
     }
   } // end SSD geometry 
 }
 
 //______________________________________________________________________
-void AliITSv11Hybrid::BuildGeometry(){
-    //    Geometry builder for the ITS version 10. Event Display geometry.
-    // Inputs:
-    //   none.
-    // Outputs:
-    //   none.
-    // Return:
-    //   none.
-
-    TNode *node, *top;
-    
-    const Int_t kColorITS=kYellow;
-    //
-    top = gAlice->GetGeometry()->GetNode("alice");
-
-
-    new TTUBE("S_layer1","Layer1 of ITS","void",
-             3.8095,3.8095+1.03*9.36/100.,14.35);
-    top->cd();
-    node = new TNode("Layer1","Layer1","S_layer1",0,0,0,"");
-    node->SetLineColor(kColorITS);
-    fNodes->Add(node);
-
-    new TTUBE("S_layer2","Layer2 of ITS","void",7.,7.+1.03*9.36/100.,14.35);
-    top->cd();
-    node = new TNode("Layer2","Layer2","S_layer2",0,0,0,"");
-    node->SetLineColor(kColorITS);
-    fNodes->Add(node);
-
-    new TTUBE("S_layer3","Layer3 of ITS","void",15.,15.+0.94*9.36/100.,25.1);
-    top->cd();
-    node = new TNode("Layer3","Layer3","S_layer3",0,0,0,"");
-    node->SetLineColor(kColorITS);
-    fNodes->Add(node);
-
-    new TTUBE("S_layer4","Layer4 of ITS","void",24.1,24.1+0.95*9.36/100.,32.1);
-    top->cd();
-    node = new TNode("Layer4","Layer4","S_layer4",0,0,0,"");
-    node->SetLineColor(kColorITS);
-    fNodes->Add(node);
-
-    new TTUBE("S_layer5","Layer5 of ITS","void",
-             38.5,38.5+0.91*9.36/100.,49.405);
-    top->cd();
-    node = new TNode("Layer5","Layer5","S_layer5",0,0,0,"");
-    node->SetLineColor(kColorITS);
-    fNodes->Add(node);
-
-    new TTUBE("S_layer6","Layer6 of ITS","void",
-             43.5765,43.5765+0.87*9.36/100.,55.27);
-    top->cd();
-    node = new TNode("Layer6","Layer6","S_layer6",0,0,0,"");
-    node->SetLineColor(kColorITS);
-    fNodes->Add(node);
-}
-
-//______________________________________________________________________
 void AliITSv11Hybrid::CreateGeometry() {
 
   // Create the geometry and insert it in ALIC
@@ -958,10 +984,8 @@ void AliITSv11Hybrid::CreateGeometry() {
   TGeoManager *geoManager = gGeoManager;
 
   CreateOldGeometry();
-  TGeoVolume *vITS = geoManager->GetVolume("ITSV");
-
-  TGeoVolume *vIS02 = geoManager->GetVolume("IS02");
 
+  TGeoVolume *vITS  = geoManager->GetVolume("ITSV");
 
 
   const Char_t *cvsDate="$Date$";
@@ -979,12 +1003,31 @@ void AliITSv11Hybrid::CreateGeometry() {
   if (AliITSInitGeometry::SDDIsTGeoNative()) {
     fSDDgeom->Layer3(vITS);
     fSDDgeom->Layer4(vITS);
-    fSDDgeom->ForwardLayer3(vIS02);
-    fSDDgeom->ForwardLayer4(vIS02);
+    fSDDgeom->ForwardLayer3(vITS);
+    fSDDgeom->ForwardLayer4(vITS);
   }
+
   if (AliITSInitGeometry::SSDIsTGeoNative()) {
     fSSDgeom->Layer5(vITS);
     fSSDgeom->Layer6(vITS);
+    fSSDgeom->LadderSupportLayer5(vITS);
+    fSSDgeom->LadderSupportLayer6(vITS);
+    fSSDgeom->EndCapSupportSystemLayer6(vITS);
+    fSSDgeom->EndCapSupportSystemLayer5(vITS);
+  }
+
+  if (AliITSInitGeometry::SPDshieldIsTGeoNative())
+    fSupgeom->SPDCone(vITS);
+
+  if (AliITSInitGeometry::SDDconeIsTGeoNative())
+    fSupgeom->SDDCone(vITS);
+
+  if (AliITSInitGeometry::SSDconeIsTGeoNative())
+    fSupgeom->SSDCone(vITS);
+
+  if (AliITSInitGeometry::ServicesAreTGeoNative()) {
+    fSDDgeom->SDDCables(vITS);
+    fSSDgeom->SSDCables(vITS);
   }
 }
 
@@ -1611,7 +1654,8 @@ void AliITSv11Hybrid::CreateOldGeometry(){
     dgh[48] = ztpc+4.+0.1;
     dgh[49] = 62.0;//62.4;
     dgh[50] = 85.;
-    gMC->Gsvolu("ITSV", "PCON", idtmed[205], dgh, 51);
+//    gMC->Gsvolu("ITSV", "PCON", idtmed[205], dgh, 51);
+    new TGeoVolumeAssembly("ITSV");
 
     // --- Place the ghost volume in its mother volume (ALIC) and make it 
     //     invisible
@@ -1670,9 +1714,15 @@ void AliITSv11Hybrid::CreateOldGeometry(){
     //======================================================================
 
     //TGeoVolumeAssembly *dITS = new TGeoVolumeAssembly("ITSD");
+    if (! AliITSInitGeometry::SPDshieldIsTGeoNative() ||
+        ! AliITSInitGeometry::SPDIsTGeoNative()       ||
+        ! AliITSInitGeometry::SDDIsTGeoNative()       ||
+        ! AliITSInitGeometry::SSDIsTGeoNative()       ||
+        ! AliITSInitGeometry::SDDconeIsTGeoNative()   ||
+        ! AliITSInitGeometry::SSDconeIsTGeoNative()   ) {
     new TGeoVolumeAssembly("ITSD");
     gMC->Gspos("ITSD", 1, "ITSV", 0., 0., 0., idrotm[199], "ONLY");
-
+    }
 
   // --- Define SPD (option 'b') volumes ----------------------------
   
@@ -2773,12 +2823,21 @@ void AliITSv11Hybrid::CreateOldGeometry(){
   dits[2] = 39.4;      
   gMC->Gsvolu("ICY1", "TUBE", idtmed[208], dits, 3);
          
-  // --- Define volume of second cylinder between SDD and SSD --------------
-  dits[0] = (59.5-0.128)/2.;      
+  // --- Define volumes of second cylinder between SDD and SSD ------------
+  // --- (from B. Giraudo plots - M.S. 20 Nov 2007)
+  dits[0] = 59.5/2. - 0.06;
   dits[1] = 59.5/2.;
-  dits[2] = 56.2;      // was 57
+  dits[2] = 102/2.;      // was 57
   gMC->Gsvolu("ICY2", "TUBE", idtmed[208], dits, 3);
 
+  dits[1] = dits[0];
+  dits[0] = dits[1] - 0.5;
+  gMC->Gsvolu("ICY3", "TUBE", idtmed[267], dits, 3);
+
+  dits[1] = dits[0];
+  dits[0] = dits[1] - 0.06;
+  gMC->Gsvolu("ICY4", "TUBE", idtmed[208], dits, 3);
+
   // --- Define volumes of SDD cone ---------------------------------- 
 
   dits[0] = 0;
@@ -4176,6 +4235,8 @@ void AliITSv11Hybrid::CreateOldGeometry(){
   if (! AliITSInitGeometry::SDDconeIsTGeoNative()) {
   gMC->Gspos("ICY1",1,"IS02",0.0,0.0,0.,0,"ONLY");    
   gMC->Gspos("ICY2",1,"IS01",0.0,0.0,0.,0,"ONLY");    
+  gMC->Gspos("ICY3",1,"IS01",0.0,0.0,0.,0,"ONLY");    
+  gMC->Gspos("ICY4",1,"IS01",0.0,0.0,0.,0,"ONLY");    
 
   // --- Place volumes of SDD cone ---------------------------------- 
   
@@ -4427,7 +4488,6 @@ void AliITSv11Hybrid::CreateOldGeometry(){
   gMC->Gspos("I2CC", 1, "ITSV", 0., 0., 83.5, 0, "ONLY");
   gMC->Gspos("I2CC", 2, "ITSV", 0., 0., -83.5, idrotm[200], "ONLY");  
 
-
   // --- DEFINE PATCH PANELS AT THE END OF THE ITS CONES
   //     UPPER PART
   
@@ -4454,11 +4514,13 @@ void AliITSv11Hybrid::CreateOldGeometry(){
   gMC->Gspos("IPA2", 1, "ITSV", 0., 0., 95.25, 0, "ONLY");  
   gMC->Gspos("IPA2", 2, "ITSV", 0., 0., -95.25, idrotm[200], "ONLY"); 
 
+  } // Move this graph down as you implement services in TGeo - M.S. 28may08
+
 
   // --- DEFINE CABLES/COOLING BELOW THE TPC ON THE ABSORBER SIDE - COPPER PART
   //     UPPER PART
   
-  dgh[0] = (ztpc-97.5)/2.;
+  dgh[0] = (ztpc-97.5-2.3)/2.;
   dgh[1] = 46.2;     
   dgh[2] = 46.2+1.0;  
   dgh[3] = 62.3;     
@@ -4466,12 +4528,13 @@ void AliITSv11Hybrid::CreateOldGeometry(){
   dgh[5] = 12.;    
   dgh[6] = 168.;
   gMC->Gsvolu("ICU1", "CONS", idtmed[213], dgh, 7);    
-  gMC->Gspos("ICU1", 1, "ITSV", 0., 0., 97.5+dgh[0], 0, "ONLY");   
+  //  gMC->Gspos("ICU1", 1, "ITSV", 0., 0.,97.5+dgh[0], 0, "ONLY");   
+  gMC->Gspos("ICU1", 1, "ITSV", 0., 0.,-(97.5+dgh[0]+4.6), idrotm[199], "ONLY");   
   
   // --- DEFINE CABLES/COOLING BELOW THE TPC ON THE ABSORBER SIDE - COPPER PART
   //     LOWER PART
   
-  dgh[0] = (ztpc-97.5)/2.;
+  dgh[0] = (ztpc-97.5-2.3)/2.;
   dgh[1] = 46.2;      
   dgh[2] = 46.2+1.0;  
   dgh[3] = 62.3;      
@@ -4479,13 +4542,14 @@ void AliITSv11Hybrid::CreateOldGeometry(){
   dgh[5] = 192.;    
   dgh[6] = 348.;
   gMC->Gsvolu("ICU2", "CONS", idtmed[213], dgh, 7);    
-  gMC->Gspos("ICU2", 1, "ITSV", 0., 0., 97.5+dgh[0], 0, "ONLY");  
+  //  gMC->Gspos("ICU2", 1, "ITSV", 0., 0., 97.5+dgh[0], 0, "ONLY");  
+  gMC->Gspos("ICU2", 1, "ITSV", 0., 0., -(97.5+dgh[0]+4.6), idrotm[199], "ONLY");  
 
 
    // -- DEFINE CABLES/COOLING BELOW THE TPC ON THE ABSORBER SIDE - CARBON PART
    //     UPPER PART
   
-  dgh[0] = (ztpc-97.5)/2.;
+  dgh[0] = (ztpc-97.5-2.3)/2.;
   dgh[1] = 46.2+1.0;      
   dgh[2] = 46.2+1.0+1.5;  
   dgh[3] = 62.3+1.0;      
@@ -4493,12 +4557,13 @@ void AliITSv11Hybrid::CreateOldGeometry(){
   dgh[5] = 12.;    
   dgh[6] = 168.;  
   gMC->Gsvolu("ICC1", "CONS", idtmed[225], dgh, 7);    
-  gMC->Gspos("ICC1", 1, "ITSV", 0., 0., 97.5+dgh[0], 0, "ONLY");   
+  //  gMC->Gspos("ICC1", 1, "ITSV", 0., 0., 97.5+dgh[0], 0, "ONLY");  
+  gMC->Gspos("ICC1", 1, "ITSV", 0., 0., -(97.5+dgh[0]+4.6), idrotm[199], "ONLY");   
   
   // --- DEFINE CABLES/COOLING BELOW THE TPC ON THE ABSORBER SIDE - CARBON PART
   //     LOWER PART
   
-  dgh[0] = (ztpc-97.5)/2.;
+  dgh[0] = (ztpc-97.5-2.3)/2.;
   dgh[1] = 46.2+1.0;    
   dgh[2] = 46.2+1.0+1.5;
   dgh[3] = 62.3+1.0;    
@@ -4506,161 +4571,216 @@ void AliITSv11Hybrid::CreateOldGeometry(){
   dgh[5] = 192.;    
   dgh[6] = 348.;  
   gMC->Gsvolu("ICC2", "CONS", idtmed[225], dgh, 7);    
-  gMC->Gspos("ICC2", 1, "ITSV", 0., 0., 97.5+dgh[0], 0, "ONLY");  
+  //  gMC->Gspos("ICC2", 1, "ITSV", 0., 0., 97.5+dgh[0], 0, "ONLY");
+  gMC->Gspos("ICC2", 1, "ITSV", 0., 0., -(97.5+dgh[0]+4.6), idrotm[199], "ONLY");  
    
   // -- DEFINE CABLES/COOLING BEHIND THE TPC ON THE ABSORBER SIDE - COPPER PART
   //     UPPER PART
     
-  dgh[0] = 62.; 
+  dgh[0] = 62.2; 
   dgh[1] = 74.5;
   dgh[2] = 0.5;
   dgh[3] = 12.;
   dgh[4] = 168.;
   gMC->Gsvolu("ICU3", "TUBS", idtmed[213], dgh, 5);    
-  gMC->Gspos("ICU3", 1, "ITSV", 0., 0., ztpc+1.5+dgh[2], 0, "ONLY");  
+  //  gMC->Gspos("ICU3", 1, "ITSV", 0., 0., ztpc+1.5+dgh[2], 0, "ONLY"); 
+  gMC->Gspos("ICU3", 1, "ITSV", 0., 0., -(ztpc+1.5+dgh[2]+1.), idrotm[199], "ONLY");  
 
   // -- DEFINE CABLES/COOLING BEHIND THE TPC ON THE ABSORBER SIDE - COPPER PART
   //     LOWER PART
   
-  dgh[0] = 62.;  
+  dgh[0] = 62.2; 
   dgh[1] = 74.5;
   dgh[2] = 0.5;
   dgh[3] = 192.;
   dgh[4] = 348.;
   gMC->Gsvolu("ICU4", "TUBS", idtmed[213], dgh, 5);    
-  gMC->Gspos("ICU4", 1, "ITSV", 0., 0., ztpc+1.5+dgh[2], 0, "ONLY");
+  //  gMC->Gspos("ICU4", 1, "ITSV", 0., 0., ztpc+1.5+dgh[2], 0, "ONLY");
+  gMC->Gspos("ICU4", 1, "ITSV", 0., 0., -(ztpc+1.5+dgh[2]+1.), idrotm[199], "ONLY");
 
   // -- DEFINE CABLES/COOLING BEHIND THE TPC ON THE ABSORBER SIDE - CARBON PART
   //    UPPER PART
 
-  dgh[0] = 62.1;  
+  dgh[0] = 64.8;  
   dgh[1] = 74.5;
   dgh[2] = 0.75;
   dgh[3] = 12.;
   dgh[4] = 168.;
   gMC->Gsvolu("ICC3", "TUBS", idtmed[225], dgh, 5);    
-  gMC->Gspos("ICC3", 1, "ITSV", 0., 0., ztpc+dgh[2], 0, "ONLY");   
+  //  gMC->Gspos("ICC3", 1, "ITSV", 0., 0., ztpc+dgh[2], 0, "ONLY");  
+  gMC->Gspos("ICC3", 1, "ITSV", 0., 0., -(ztpc+dgh[2]), idrotm[199], "ONLY");   
     
   // -- DEFINE CABLES/COOLING BEHIND THE TPC ON THE ABSORBER SIDE - CARBON PART
   //    LOWER PART
 
-  dgh[0] = 62.1;  
+  dgh[0] = 64.8;  
   dgh[1] = 74.5;
   dgh[2] = 0.75;
   dgh[3] = 192.;
   dgh[4] = 348.;
   gMC->Gsvolu("ICC4", "TUBS", idtmed[225], dgh, 5);    
-  gMC->Gspos("ICC4", 1, "ITSV", 0., 0., ztpc+dgh[2], 0, "ONLY");  
+  //  gMC->Gspos("ICC4", 1, "ITSV", 0., 0., ztpc+dgh[2], 0, "ONLY");  
+  gMC->Gspos("ICC4", 1, "ITSV", 0., 0., -(ztpc+dgh[2]), idrotm[199], "ONLY");  
   
   // --- DEFINE CABLES/COOLING BELOW THE TPC ON THE OTHER SIDE W.R.T.
   //     THE ABSORBER - COPPER PART - UPPER PART
-  
+
   dgh[0] = 46.;      
   dgh[1] = 46.+1.0;  
-  dgh[2] = (ztpc-97.5+1.5)/2.;
+//  dgh[2] = (ztpc-97.5+1.5-2.5)/2.;
+  dgh[2] = (186.6 - 101.1)/2.;
   dgh[3] = 12.;
   dgh[4] = 168.;
   gMC->Gsvolu("ICU5", "TUBS", idtmed[213], dgh, 5);   
-  gMC->Gspos("ICU5", 1, "ITSV", 0., 0., -97.5-dgh[2], 0, "ONLY");  
-  
+  //  gMC->Gspos("ICU5", 1, "ITSV", 0., 0., -97.5-dgh[2], 0, "ONLY");  
+  gMC->Gspos("ICU5", 1, "ITSV", 0., 0., -(-101.1-dgh[2]), idrotm[199], "ONLY");  
+
+  dgh[0] = (ztpc - 1.0 - 186.6)/2.;
+  dgh[1] = 64.0;
+  dgh[2] = 64.0+1.0;
+  dgh[3] = 46.;
+  dgh[4] = 46.+1.0;
+  dgh[5] = 12.;
+  dgh[6] = 168.;
+  gMC->Gsvolu("ICU9", "CONS", idtmed[213], dgh, 7);   
+  gMC->Gspos("ICU9", 1, "ITSV", 0., 0., -(-186.6-dgh[0]), idrotm[199], "ONLY");
+
   // --- DEFINE CABLES/COOLING BELOW THE TPC ON THE OTHER SIDE W.R.T.
   //     THE ABSORBER - COPPER PART - LOWER PART
   
   dgh[0] = 46.;  
   dgh[1] = 46.+1.0;  
-  dgh[2] = (ztpc-97.5+1.5)/2.;
+//  dgh[2] = (ztpc-97.5+1.5-2.5)/2.;
+  dgh[2] = (186.6 - 101.1)/2.;
   dgh[3] = 192.;
   dgh[4] = 348.;  
   gMC->Gsvolu("ICU6", "TUBS", idtmed[213], dgh, 5);   
-  gMC->Gspos("ICU6", 1, "ITSV", 0., 0., -97.5-dgh[2], 0, "ONLY");    
-  
+  //  gMC->Gspos("ICU6", 1, "ITSV", 0., 0., -97.5-dgh[2], 0, "ONLY"); 
+  gMC->Gspos("ICU6", 1, "ITSV", 0., 0., -(-101.1-dgh[2]), idrotm[199], "ONLY");    
+
+  dgh[0] = (ztpc - 1.0 - 186.6)/2.;
+  dgh[1] = 64.0;
+  dgh[2] = 64.0+1.0;
+  dgh[3] = 46.;
+  dgh[4] = 46.+1.0;
+  dgh[5] = 192.;
+  dgh[6] = 348.;
+  gMC->Gsvolu("ICU0", "CONS", idtmed[213], dgh, 7);   
+  gMC->Gspos("ICU0", 1, "ITSV", 0., 0., -(-186.6-dgh[0]), idrotm[199], "ONLY");
+
   // --- DEFINE CABLES/COOLING BELOW THE TPC ON THE OTHER SIDE W.R.T.
   //     THE ABSORBER - CARBON PART - UPPER PART
   
   dgh[0] = 46.+1.0;  
   dgh[1] = 46.+1.0+1.5; 
-  dgh[2] = (ztpc-97.5)/2.;
+//  dgh[2] = (ztpc-97.5)/2.;
+  dgh[2] = (186.6 - 101.1)/2.;
   dgh[3] = 12.;
   dgh[4] = 168.;  
   gMC->Gsvolu("ICC5", "TUBS", idtmed[225], dgh, 5);   
-  gMC->Gspos("ICC5", 1, "ITSV", 0., 0., -97.5-dgh[2], 0, "ONLY");   
-  
+  //  gMC->Gspos("ICC5", 1, "ITSV", 0., 0., -97.5-dgh[2], 0, "ONLY");
+  gMC->Gspos("ICC5", 1, "ITSV", 0., 0., -(-101.1-dgh[2]), idrotm[199], "ONLY");   
+  
+  dgh[0] = (ztpc - 1.0 - 186.6)/2.;
+  dgh[1] = 64.0+1.0;
+  dgh[2] = 64.0+1.0+1.5;
+  dgh[3] = 46.+1.0;
+  dgh[4] = 46.+1.0+1.5;
+  dgh[5] = 12.;
+  dgh[6] = 168.;
+  gMC->Gsvolu("ICC9", "CONS", idtmed[225], dgh, 7);   
+  gMC->Gspos("ICC9", 1, "ITSV", 0., 0., -(-186.6-dgh[0]), idrotm[199], "ONLY");
+
   // --- DEFINE CABLES/COOLING BELOW THE TPC ON THE OTHER SIDE W.R.T.
   //     THE ABSORBER - CARBON PART - LOWER PART
   
   dgh[0] = 46.+1.0;   
   dgh[1] = 46.+1.0+1.5;  
-  dgh[2] = (ztpc-97.5)/2.;
+//  dgh[2] = (ztpc-97.5)/2.;
+  dgh[2] = (186.6 - 101.1)/2.;
   dgh[3] = 192.;
   dgh[4] = 348.;  
   gMC->Gsvolu("ICC6", "TUBS", idtmed[225], dgh, 5);   
-  gMC->Gspos("ICC6", 1, "ITSV", 0., 0., -97.5-dgh[2], 0, "ONLY");      
+  //  gMC->Gspos("ICC6", 1, "ITSV", 0., 0., -97.5-dgh[2], 0, "ONLY"); 
+  gMC->Gspos("ICC6", 1, "ITSV", 0., 0., -(-101.1-dgh[2]), idrotm[199], "ONLY");      
+
+  dgh[0] = (ztpc - 1.0 - 186.6)/2.;
+  dgh[1] = 64.0+1.0;
+  dgh[2] = 64.0+1.0+1.5;
+  dgh[3] = 46.+1.0;
+  dgh[4] = 46.+1.0+1.5;
+  dgh[5] = 192.;
+  dgh[6] = 348.;
+  gMC->Gsvolu("ICC0", "CONS", idtmed[225], dgh, 7);   
+  gMC->Gspos("ICC0", 1, "ITSV", 0., 0., -(-186.6-dgh[0]), idrotm[199], "ONLY");
 
   // --- DEFINE CABLES/COOLING BEHIND THE TPC ON OTHER SIDE W.R.T. THE ABSORBER
   //     COPPER PART - UPPER PART
     
-  dgh[0] = 46.;   
+  dgh[0] = 64.0;   
   dgh[1] = 74.5;
   dgh[2] = 0.5;
   dgh[3] = 12.;
   dgh[4] = 168.;  
   gMC->Gsvolu("ICU7", "TUBS", idtmed[213], dgh, 5);   
-  gMC->Gspos("ICU7", 1, "ITSV", 0., 0., -(ztpc+1.5+dgh[2]), 0, "ONLY");  
+  gMC->Gspos("ICU7", 1, "ITSV", 0., 0., (ztpc+1.5+dgh[2]), idrotm[199], "ONLY");  
   
   // --- DEFINE CABLES/COOLING BEHIND THE TPC ON OTHER SIDE W.R.T. THE ABSORBER
   //     COPPER PART - LOWER PART
     
-  dgh[0] = 46.; 
+  dgh[0] = 64.0; 
   dgh[1] = 74.5;
   dgh[2] = 0.5;
   dgh[3] = 192.;
   dgh[4] = 348.;   
   gMC->Gsvolu("ICU8", "TUBS", idtmed[213], dgh, 5);   
-  gMC->Gspos("ICU8", 1, "ITSV", 0., 0., -(ztpc+1.5+dgh[2]), 0, "ONLY");      
+  gMC->Gspos("ICU8", 1, "ITSV", 0., 0., (ztpc+1.5+dgh[2]), idrotm[199], "ONLY");      
     
   // --- DEFINE CABLES/COOLING BEHIND THE TPC ON OTHER SIDE W.R.T. THE ABSORBER
   //     CARBON PART - UPPER PART
   
-  dgh[0] = 46.+1.0;  
+  dgh[0] = 64.0+1.0;  
   dgh[1] = 74.5;
   dgh[2] = 0.75;
   dgh[3] = 12.;
   dgh[4] = 168.;   
   gMC->Gsvolu("ICC7", "TUBS", idtmed[225], dgh, 5);   
-  gMC->Gspos("ICC7", 1, "ITSV", 0., 0., -(ztpc+dgh[2]), 0, "ONLY"); 
+  gMC->Gspos("ICC7", 1, "ITSV", 0., 0., (ztpc+dgh[2]), idrotm[199], "ONLY"); 
   
   // --- DEFINE CABLES/COOLING BEHIND THE TPC ON OTHER SIDE W.R.T. THE ABSORBER
   //     CARBON PART - LOWER PART
   
-  dgh[0] = 46.+1.0;  
+  dgh[0] = 64.0+1.0;  
   dgh[1] = 74.5;
   dgh[2] = 0.75;
   dgh[3] = 192.;
   dgh[4] = 348.;     
   gMC->Gsvolu("ICC8", "TUBS", idtmed[225], dgh, 5);   
-  gMC->Gspos("ICC8", 1, "ITSV", 0., 0., -(ztpc+dgh[2]), 0, "ONLY");        
+  gMC->Gspos("ICC8", 1, "ITSV", 0., 0., (ztpc+dgh[2]), idrotm[199], "ONLY");        
+
+
     
   // --- DEFINE HOOK TO THE TPC ON OTHER SIDE W.R.T. THE ABSORBER - UPPER PART
   
-  dgh[0] = 74.5;
-  dgh[1] = 79.5;
+  dgh[0] = 74.7;
+  dgh[1] = 75.3;
   dgh[2] = 2.5;
   dgh[3] = 12.;
   dgh[4] = 168.;    
   gMC->Gsvolu("IHK1", "TUBS", idtmed[264], dgh, 5);  
-  gMC->Gspos("IHK1", 1, "ITSV", 0., 0., -ztpc-dgh[2], 0, "ONLY");   
+  gMC->Gspos("IHK1", 1, "ITSV", 0., 0., -(-ztpc-dgh[2]), idrotm[199], "ONLY");   
   
   // --- DEFINE HOOK TO THE TPC ON OTHER SIDE W.R.T. THE ABSORBER - LOWER PART
   
-  dgh[0] = 74.5;
-  dgh[1] = 79.5;
+  dgh[0] = 74.7;
+  dgh[1] = 75.3;
   dgh[2] = 2.5;
   dgh[3] = 192.;
   dgh[4] = 348.;    
   gMC->Gsvolu("IHK2", "TUBS", idtmed[264], dgh, 5);  
-  gMC->Gspos("IHK2", 1, "ITSV", 0., 0., -ztpc-dgh[2], 0, "ONLY");      
+  gMC->Gspos("IHK2", 1, "ITSV", 0., 0., -(-ztpc-dgh[2]), idrotm[199], "ONLY");      
   
-  }
+//  }
 
 
   // --- DEFINE RAILS BETWEEN THE ITS AND THE TPC
@@ -4672,9 +4792,9 @@ void AliITSv11Hybrid::CreateOldGeometry(){
      dgh[1] = 8.;           
      dgh[2] = 190.;         
      gMC->Gsvolu("IRA1", "BOX ", idtmed[268], dgh, 3);
-     gMC->Gspos("IRA1", 1, "ITSV", 53.5, 0., -69.5, 0, "ONLY");   
+     gMC->Gspos("IRA1", 1, "ITSV", 53.5, 0., 69.5, idrotm[199], "ONLY");   
      gMC->Gsvolu("IRA2", "BOX ", idtmed[268], dgh, 3);    
-     gMC->Gspos("IRA2", 1, "ITSV", -53.5, 0., -69.5, 0, "ONLY");    
+     gMC->Gspos("IRA2", 1, "ITSV", -53.5, 0., 69.5, idrotm[199], "ONLY");    
 
      dgh[0] = 2.-0.5;// 0.5 was determined in such a way that the aluminum area is 20.9 cm^2      
      dgh[1] = 8.-0.5;// 0.5 was determined in such a way that the aluminum area is 20.9 cm^2       
@@ -4701,14 +4821,14 @@ void AliITSv11Hybrid::CreateOldGeometry(){
   dgh[1] = 3.;
   dgh[2] = 5.;// 5. comes from the fact that the volume has to be 567.6/2 cm^3
   gMC->Gsvolu("ISR1", "TUBE", idtmed[284], dgh, 3);   
-  gMC->Gspos("ISR1", 1, "ITSV", 53.4292, 10.7053, 79.75, 0, "ONLY");    
-  gMC->Gspos("ISR1", 2, "ITSV", 53.4292, -10.7053, 79.75, 0, "ONLY");   
-  gMC->Gspos("ISR1", 3, "ITSV", -53.4292, 10.7053, 79.75, 0, "ONLY"); 
-  gMC->Gspos("ISR1", 4, "ITSV", -53.4292, -10.7053, 79.75, 0, "ONLY");  
-  gMC->Gspos("ISR1", 5, "ITSV", 53.4292, 10.7053, -79.75, 0, "ONLY");   
-  gMC->Gspos("ISR1", 6, "ITSV", 53.4292, -10.7053, -79.75, 0, "ONLY");   
-  gMC->Gspos("ISR1", 7, "ITSV", -53.4292, 10.7053, -79.75, 0, "ONLY"); 
-  gMC->Gspos("ISR1", 8, "ITSV", -53.4292, -10.7053, -79.75, 0, "ONLY");
+  gMC->Gspos("ISR1", 1, "ITSV", 53.4292, 10.7053, -79.75,idrotm[199],"ONLY");    
+  gMC->Gspos("ISR1", 2, "ITSV", 53.4292, -10.7053, -79.75,idrotm[199],"ONLY");   
+  gMC->Gspos("ISR1", 3, "ITSV", -53.4292, 10.7053, -79.75,idrotm[199],"ONLY"); 
+  gMC->Gspos("ISR1", 4, "ITSV", -53.4292, -10.7053, -79.75,idrotm[199],"ONLY");  
+  gMC->Gspos("ISR1", 5, "ITSV", 53.4292, 10.7053, 79.75,idrotm[199],"ONLY");   
+  gMC->Gspos("ISR1", 6, "ITSV", 53.4292, -10.7053, 79.75,idrotm[199],"ONLY");   
+  gMC->Gspos("ISR1", 7, "ITSV", -53.4292, 10.7053, 79.75,idrotm[199],"ONLY"); 
+  gMC->Gspos("ISR1", 8, "ITSV", -53.4292, -10.7053, 79.75,idrotm[199],"ONLY");
   
   // --- DEFINE SUPPORTS FOR RAILS ATTACHED TO THE ABSORBER
 
@@ -4716,9 +4836,9 @@ void AliITSv11Hybrid::CreateOldGeometry(){
   dgh[1] = 12.;         
   dgh[2] = 5.;         
   gMC->Gsvolu("ISR2", "BOX ", idtmed[210], dgh, 3);   
-  gMC->Gspos("ISR2", 1, "ITSV", -53.5, 0., -125.5, idrotm[199], "ONLY");
+  gMC->Gspos("ISR2", 1, "ITSV", -53.5, 0., 125.5, 0, "ONLY");
   gMC->Gsvolu("ISR3", "BOX ", idtmed[210], dgh, 3);   
-  gMC->Gspos("ISR3", 1, "ITSV", 53.5, 0., -125.5, idrotm[199], "ONLY");  
+  gMC->Gspos("ISR3", 1, "ITSV", 53.5, 0., 125.5, 0, "ONLY");  
   
   dgh[0] = 5.-2.;        
   dgh[1] = 12.-2.;         
@@ -4734,20 +4854,12 @@ void AliITSv11Hybrid::CreateOldGeometry(){
   dgh[1] = 5.;         
   dgh[2] = 2.;         
   gMC->Gsvolu("ISR6", "TUBE", idtmed[210], dgh, 3);   
-  gMC->Gspos("ISR6", 1, "ITSV", 0., 54., -77., idrotm[199], "ONLY"); 
-  gMC->Gspos("ISR6", 2, "ITSV", 0., 54., 77., idrotm[199], "ONLY"); 
-  gMC->Gspos("ISR6", 3, "ITSV", 0., -54., 77., idrotm[199], "ONLY");                   
+  gMC->Gspos("ISR6", 1, "ITSV", 0., 54., 77., 0, "ONLY"); 
+  gMC->Gspos("ISR6", 2, "ITSV", 0., 54., -77., 0, "ONLY"); 
+  gMC->Gspos("ISR6", 3, "ITSV", 0., -54., -77., 0, "ONLY");                   
 
   }
 
-
-  // --- Outputs the geometry tree in the EUCLID/CAD format 
-  
-  if (fEuclidOut) {
-    gMC->WriteEuclid("ITSgeometry", "ITSV", 1, 5);
-  }
-
-
   {
     if (!gGeoManager) {
       AliError("TGeoManager doesn't exist !");
@@ -4979,8 +5091,8 @@ void AliITSv11Hybrid::CreateMaterials(){
     // Return:
     //   none.
 
-    Int_t   ifield = gAlice->Field()->Integ();
-    Float_t fieldm = gAlice->Field()->Max();
+    Int_t   ifield = ((AliMagF*)TGeoGlobalMagField::Instance()->GetField())->Integ();
+    Float_t fieldm = ((AliMagF*)TGeoGlobalMagField::Instance()->GetField())->Max();
 
     Float_t tmaxfd = 0.1; // 1.0; // Degree
     Float_t stemax = 1.0; // cm
@@ -5115,8 +5227,8 @@ void AliITSv11Hybrid::CreateMaterials(){
       // rohacell: C9 H13 N1 O2
     Float_t arohac[4] = {12.01,  1.01, 14.010, 16.};
     Float_t zrohac[4] = { 6.,    1.,    7.,     8.};
-    Float_t wrohac[4] = { 9.,   13.,    1.,     2.};
-    Float_t drohac    = 0.05;
+    Float_t wrohac[4] = { 14.,   10.,    2.,     6.};
+    Float_t drohac    = 0.052;
 
     // If he/she means stainless steel (inox) + Aluminium and Zeff=15.3383 then
 //
@@ -5140,6 +5252,12 @@ void AliITSv11Hybrid::CreateMaterials(){
     Float_t wAlOxide[2]  = {0.4707, 0.5293};
     Float_t dAlOxide     = 3.97;
 
+    // Silica for optical fibers: Si O2
+    Float_t aoptfib[2] = { 28.0855, 15.9994};
+    Float_t zoptfib[2] = { 14.,      8.    };
+    Float_t woptfib[2] = {  1.,      2.    };
+    Float_t doptfib    = 2.55;
+
     AliMaterial(1,"SI$",0.28086E+02,0.14000E+02,0.23300E+01,0.93600E+01,0.99900E+03);
     AliMedium(1,"SI$",1,0,ifield,fieldm,tmaxfdSi,stemaxSi,deemaxSi,epsilSi,stminSi);
 
@@ -5448,7 +5566,7 @@ void AliITSv11Hybrid::CreateMaterials(){
 
     // Special media
 
-    AliMaterial(90,"SPD shield$", 12.011, 6., 1.93/10. , 22.1*10., 999);
+    AliMaterial(90,"SPD shield$", 12.011, 6., 1.93 , 22.36, 999);
     AliMedium(90,"SPD shield$",90,0,ifield,fieldm,tmaxfdServ,stemaxServ,deemaxServ,epsilServ,stminServ);
 
     // SPD End Ladder (data from Petra Riedler)
@@ -5475,6 +5593,9 @@ void AliITSv11Hybrid::CreateMaterials(){
     */
     AliMaterial(96, "SSD cone$",63.546, 29., 1.15, 1.265, 999);
     AliMedium(96,"SSD cone$",96,0,ifield,fieldm,tmaxfdServ,stemaxServ,deemaxServ,epsilServ,stminServ);
+
+    AliMixture(98,"SDD OPTICFIB$",aoptfib,zoptfib,doptfib,-2,woptfib);
+    AliMedium(98,"SDD OPTICFIB$",98,0,ifield,fieldm,tmaxfd,stemax,deemax,epsil,stmin);
 }
 
 //______________________________________________________________________
@@ -5614,7 +5735,6 @@ void AliITSv11Hybrid::Init(){
                 fMinorVersion));
     UpdateInternalGeometry();
     AliITS::Init();
-    if(fGeomDetOut) GetITSgeom()->WriteNewFile(fWrite);
 
     fIDMother = gMC->VolId("ITSV"); // ITS Mother Volume ID.
 }
@@ -5629,92 +5749,14 @@ void AliITSv11Hybrid::SetDefaults(){
     // Return:
     //   none.
 
-    const Float_t kconv = 1.0e+04; // convert cm to microns
-
     if(!fDetTypeSim){
        Warning("SetDefaults","Error fDetTypeSim not defined");
        return;
     }
 
-    AliITSgeomSPD  *s0;
-    AliITSgeomSDD  *s1;
-    AliITSgeomSSD  *s2;
-    Int_t i;
-    Float_t bx[256],bz[280];
-
     fDetTypeSim->SetDefaults();
     
-    //SPD
-    s0 = (AliITSgeomSPD*) GetITSgeom()->GetShape(kSPD);
-    // Get shape info. Do it this way for now.
-    //AliITSCalibrationSPD* resp0=new AliITSCalibrationSPD();
-    AliITSsegmentationSPD* seg0 = 
-       (AliITSsegmentationSPD*)fDetTypeSim->GetSegmentationModel(0);
-    seg0->SetDetSize(s0->GetDx()*2.*kconv, // base this on AliITSgeomSPD
-                    s0->GetDz()*2.*kconv, // for now.
-                    s0->GetDy()*2.*kconv); // x,z,y full width in microns.
-    seg0->SetNPads(256,160);// Number of Bins in x and z
-    for(i=000;i<256;i++) bx[i] =  50.0; // in x all are 50 microns.
-    for(i=000;i<160;i++) bz[i] = 425.0; // most are 425 microns except below
-    for(i=160;i<280;i++) bz[i] =   0.0; // Outside of detector.
-    bz[ 31] = bz[ 32] = 625.0; // first chip boundry
-    bz[ 63] = bz[ 64] = 625.0; // first chip boundry
-    bz[ 95] = bz[ 96] = 625.0; // first chip boundry
-    bz[127] = bz[128] = 625.0; // first chip boundry
-    bz[160] = 425.0; // Set so that there is no zero pixel size for fNz.
-    seg0->SetBinSize(bx,bz); // Based on AliITSgeomSPD for now.
-    SetSegmentationModel(kSPD,seg0);
-    // set digit and raw cluster classes to be used
-    const char *kData0=(fDetTypeSim->GetCalibrationModel(
-                           GetITSgeom()->GetStartSPD()))->DataType();
-    if (strstr(kData0,"real")) fDetTypeSim->SetDigitClassName(kSPD,
-                                                             "AliITSdigit");
-    else fDetTypeSim->SetDigitClassName(kSPD,"AliITSdigitSPD");
-    // SDD
-    s1 = (AliITSgeomSDD*) GetITSgeom()->GetShape(kSDD);
-    // Get shape info. Do it this way for now.
-
-    //AliITSCalibrationSDD* resp1=new AliITSCalibrationSDD("simulated");
-    AliITSsegmentationSDD* seg1 = 
-       (AliITSsegmentationSDD*)fDetTypeSim->GetSegmentationModel(1);
-    seg1->SetDetSize(s1->GetDx()*kconv, // base this on AliITSgeomSDD
-                    s1->GetDz()*2.*kconv, // for now.
-                    s1->GetDy()*2.*kconv); // x,z,y full width in microns.
-    seg1->SetNPads(256,256);// Use AliITSgeomSDD for now
-    SetSegmentationModel(kSDD,seg1);
-    const char *kData1=(fDetTypeSim->GetCalibrationModel(
-                           GetITSgeom()->GetStartSDD()))->DataType();
-    AliITSCalibrationSDD* rsp = 
-       (AliITSCalibrationSDD*)fDetTypeSim->GetCalibrationModel(
-           GetITSgeom()->GetStartSDD());
-    const char *kopt=rsp->GetZeroSuppOption();
-    if((!strstr(kopt,"2D")) && (!strstr(kopt,"1D")) || strstr(kData1,"real") ){
-       fDetTypeSim->SetDigitClassName(kSDD,"AliITSdigit");
-    } else fDetTypeSim->SetDigitClassName(kSDD,"AliITSdigitSDD");
-    // SSD  Layer 5
-
-    s2 = (AliITSgeomSSD*) GetITSgeom()->GetShape(kSSD);
-    // Get shape info. Do it this way for now.
-
-
-    //SetCalibrationModel(GetITSgeom()->GetStartSSD(),
-    // new AliITSCalibrationSSD("simulated"));
-    AliITSsegmentationSSD* seg2 = 
-       (AliITSsegmentationSSD*)fDetTypeSim->GetSegmentationModel(2);
-    seg2->SetDetSize(s2->GetDx()*2.*kconv, // base this on AliITSgeomSSD
-                    s2->GetDz()*2.*kconv, // for now.
-                    s2->GetDy()*2.*kconv); // x,z,y full width in microns.
-    seg2->SetPadSize(95.,0.); // strip x pitch in microns
-    seg2->SetNPads(768,0); // number of strips on each side.
-    seg2->SetAngles(0.0075,0.0275); // strip angels rad P and N side.
-    seg2->SetAnglesLay5(0.0075,0.0275); // strip angels rad P and N side.
-    seg2->SetAnglesLay6(0.0275,0.0075); // strip angels rad P and N side.
-    SetSegmentationModel(kSSD,seg2); 
-        const char *kData2=(fDetTypeSim->GetCalibrationModel(
-                               GetITSgeom()->GetStartSSD()))->DataType();
-    if(strstr(kData2,"real") ) fDetTypeSim->SetDigitClassName(kSSD,
-                                                             "AliITSdigit");
-    else fDetTypeSim->SetDigitClassName(kSSD,"AliITSdigitSSD");
+
     if(fgkNTYPES>3){
        Warning("SetDefaults",
                "Only the four basic detector types are initialised!");
@@ -5892,3 +5934,4 @@ void AliITSv11Hybrid::StepManager(){
 
     return;
 }
+