/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/


//*************************************************************************
// SSD geometry, based on ROOT geometrical modeler
//
// Enrico Cattaruzza                                    ecattar@ts.infn.it
//*************************************************************************
#include "TMath.h"
#include "TGeoVolume.h"
#include "TGeoMedium.h"
#include "TGeoMatrix.h"
#include <TGeoManager.h>
#include "AliITSv11GeometrySSD.h"
#include "TVector3.h"
#include "TGeoArb8.h"
#include "TList.h"
#include "TGeoMatrix.h"
#include "TGeoCompositeShape.h"
#include "TGeoTube.h"
#include "TGeoBBox.h"
#include "TGeoTrd1.h"
#include <iostream>
using namespace std;
/////////////////////////////////////////////////////////////////////////////////
//Parameters for SSD Geometry
/////////////////////////////////////////////////////////////////////////////////
// Layer5 (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength      = 950.7;
const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber        =  22;
const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber         =  34;
const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin         = 378.0;
const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax         = 384.0;
const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition    = 467.85;
/////////////////////////////////////////////////////////////////////////////////
// Layer6 (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength      = 1068.0;
const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber        =   25;
const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber         =   38;
const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin         =  428.0;
const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax         =  434.0;
const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition    = 526.50;
/////////////////////////////////////////////////////////////////////////////////
// SSD Chips and Hybrid (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber               =   6;
const Double_t AliITSv11GeometrySSD::fgkSSDChipLength            =  11.100; 
const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth             =   3.850;
const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight            =   0.180;
const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength  =   1.000;
const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength        =   fgkSSDChipLength;
const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth         =   fgkSSDChipWidth;
const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight        =   0.030;
/////////////////////////////////////////////////////////////////////////////////
// Stiffener (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength       =  73.000;
const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth        =   6.500;
//const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight       =   3.315;
const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight       =   0.315;
const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist   =   2.500;
const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length   =   1.600;
const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width    =   0.870;
const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height   =   0.800;
const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length   =   4.600;
const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width    =   3.400;
const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height   =   1.400;
const Double_t AliITSv11GeometrySSD::fgkSSDWireLength            =  30.000;
const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius            =   0.185;
const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2]  = {44.32, 0.33};
const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation   = 0.44;
const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength       = 2.16;
const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth        = 3.60;
const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight       = 
													  0.25*fgkSSDStiffenerHeight;
/////////////////////////////////////////////////////////////////////////////////
// Cooling Block (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength    =   3.000;
const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth     =   4.000;
const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] = 
													 {1.950, 0.240, 0.300};
const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] = 
														    {1.000, 0.120};
const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] = 
															{1.900, 0.400};
const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter    =  
																	 1.500;
const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight    =  
																	 0.300;
/////////////////////////////////////////////////////////////////////////////////
// SSD Sensor (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const char*  AliITSv11GeometrySSD::fgkSSDSensitiveVolName       = 
                                                          "SSDSensorSensitiveVol";
const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength          =  42.000;
const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight          =   0.300;
const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth           =  75.000;
const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap         = 
	   											   fgkSSDSensorLength-39.1;
const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength      = 1.; 
const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth       = 1.;
/////////////////////////////////////////////////////////////////////////////////
// Flex (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength       =  106.000; 
const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4]        = 
			{0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
						+(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
			 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
						+(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)-4.000,
						  9.500, 10.000};
const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2]         = 
														 {  9.340,  5.380};
const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2]        =
														 {  0.030,  0.020};      
const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle            =   30.000;
const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength       =    1.430;
const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth        =    3.000;
const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] = 
										   {3.30,4.12,4.22,1.70,0.75,7.18};
const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
													   {15.03,23.48,12.28};
/////////////////////////////////////////////////////////////////////////////////
// SSD Ladder Cable (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth     =   23.5;
const Double_t AliITSv11GeometrySSD::fgkSSDEndLadderCableLength =   50.000; /////to be modified
/////////////////////////////////////////////////////////////////////////////////
// SSD Module (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2]  = 
														   { 1.000, 3.900};
const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =  
																	45.600;
const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor  =  
																	 5.075;
/////////////////////////////////////////////////////////////////////////////////
// Sensor Support (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength		   = 
																	   5.800;
const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth          =  
																	   2.000;
const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2]      =
														     { 4.620, 5.180};
const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] = 
														     { 0.450, 0.450};
const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition       =  
									  0.5*(fgkSSDModuleSensorSupportDistance
							       +    fgkSSDSensorSideSupportThickness[0])
								   -           fgkSSDSensorSideSupportLength;
const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength	   =  
									   								   5.250;
const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth        =
																       1.680;
const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]    =
	   {fgkSSDSensorSideSupportHeight[0]+fgkSSDSensorSideSupportThickness[0],
	   fgkSSDSensorSideSupportHeight[1]+fgkSSDSensorSideSupportThickness[1]};
const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2] =
   {fgkSSDSensorSideSupportThickness[0],fgkSSDSensorSideSupportThickness[1]};
const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition     = 
																      19.000;
/////////////////////////////////////////////////////////////////////////////////
// Chip Cables (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2]   = 
						 {73.12/fgkSSDChipNumber,fgkSSDChipLength+2.*0.19};
const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4]   = 
						{  0.014,  0.010, fgkSSDModuleCoolingBlockToSensor
  -  (fgkSSDSensorSideSupportHeight[1]-fgkSSDSensorSideSupportHeight[0])
  -   fgkSSDCoolingBlockHoleCenter-fgkSSDStiffenerHeight
  -   fgkSSDChipHeight-fgkSSDSensorHeight,
      fgkSSDModuleCoolingBlockToSensor
  -   fgkSSDCoolingBlockHoleCenter-fgkSSDStiffenerHeight
  -   fgkSSDChipHeight-fgkSSDSensorHeight};
const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3]    = 
												 { 11.000,  0.800,  0.600};
/////////////////////////////////////////////////////////////////////////////////
// Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength          = 
																	   3.820;
//const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength          = 
//																	   3.780;
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth           = 
									  fgkSSDSensorLength-fgkSSDSensorOverlap;
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2]         = 
															 {  0.86,  0.30};
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2]        = 
															 { 30.00, 90.00};
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport = 
																	    1.78;
/////////////////////////////////////////////////////////////////////////////////
//Carbon Fiber Parameters (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength          = 
  fgkSSDModuleSensorSupportDistance-2.*fgkCarbonFiberJunctionToSensorSupport;  
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle           = 
																	   60.00;
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2]   = 
														   {  0.751,  0.482};
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength       =  
																	   1.630;
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth            = 
																	   0.950;
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength      = 
	     fgkCarbonFiberTriangleLength-0.5*fgkCarbonFiberSupportTopEdgeDist[1]
	             / TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad());
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength      = 
				  0.5*(fgkCarbonFiberJunctionWidth-fgkCarbonFiberSupportWidth)
			 - fgkCarbonFiberSupportTopEdgeDist[0]-fgkCarbonFiberSupportWidth;
/////////////////////////////////////////////////////////////////////////////////
// Carbon Fiber Lower Support Parameters (lengths are in mm)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth             
																	  =  0.950;
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght       
																	  =  1.600;
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight            
																	  =  0.830;
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation  
											  = 0.5*fgkCarbonFiberSupportWidth;
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth   
								 = fgkCarbonFiberJunctionWidth
                                 - 2.*(fgkCarbonFiberLowerSupportWidth
								 + fgkCarbonFiberLowerSupportVolumeSeparation);
const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2] 
								 = {fgkCarbonFiberLowerSupportWidth
								 +  fgkCarbonFiberLowerSupportVolumeSeparation,
									fgkCarbonFiberLowerSupportWidth
								 +  fgkCarbonFiberLowerSupportVolumeSeparation							
								 +  fgkCarbonFiberLowerSupportTransverseWidth};
/////////////////////////////////////////////////////////////////////////////////
// End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] = 
  {0.5*(fgkSSDLay5LadderLength
	  -fgkSSDLay5SensorsNumber*fgkCarbonFiberJunctionWidth
	  -fgkCarbonFiberLowerSupportWidth),
       0.5*(fgkSSDLay5LadderLength
	  -fgkSSDLay5SensorsNumber*fgkCarbonFiberJunctionWidth
	  +fgkCarbonFiberLowerSupportWidth)};
const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] = 
		{fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4,
		 fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6};
const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] = 
						   {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50,
						   fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50};
/////////////////////////////////////////////////////////////////////////////////
// Cooling Tube Support (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax          =  1.45;
const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin          
											  = fgkSSDCoolingBlockHoleRadius[0];
const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength        =  8.55;
const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight        =  0.85;
const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth         =  2.00;
const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation    = 
                                      fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber = 11.70;
/////////////////////////////////////////////////////////////////////////////////
// Cooling Tube (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax       = 
													  fgkCoolingTubeSupportRmin;
const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin       =  0.96;
const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength     = 
													fgkCarbonFiberJunctionWidth;
const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation = 
					fgkSSDModuleSensorSupportDistance+fgkSSDCoolingBlockLength;
//const Double_t AliITSv11GeometrySSD_ct::fgkCoolingTubeLength               =  39.1;
/////////////////////////////////////////////////////////////////////////////////
// SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
/////////////////////////////////////////////////////////////////////////////////
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3]            = 
															{ 60.0, 42.2, 34.0};
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4]            =
													  {  4.0,  8.0,  5.0,  0.2};
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth                =   
																		   20.0;
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle   =   
																		   40.0;
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight  = 
	           0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =    
																			2.5;
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2]    = 
																  { 56.0, 12.0}; 
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2]     = 
																  {  5.0,  2.9}; 
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius           = 
																			1.0;
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge        =   
																			6.0;
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeigth      =  
																			4.0;
const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2]   =
									{  1.5,fgkSSDMountingBlockScrewHoleEdge/6.};
/////////////////////////////////////////////////////////////////////////////////
AliITSv11GeometrySSD::AliITSv11GeometrySSD(){           
  ///////////////////////////////// 
  // Standard Default Constructor
  ///////////////////////////////// 
  // Initializing display colors  
  ////////////////////////////// 
  fColorCarbonFiber =  4;
  fColorRyton       =  5;
  fColorPhynox      =  5;
  fColorSilicon     =  3;
  fColorAl          =  7;
  fColorKapton      =  6;
  fColorPolyhamide  =  5;
  fColorStiffener   =  9;
  fColorEpoxy       = 30;
  CreateMaterials();
}
/////////////////////////////////////////////////////////////////////////////////
// Setting the transformation Matrices
/////////////////////////////////////////////////////////////////////////////////
void AliITSv11GeometrySSD::SetSSDSensorSupportCombiTransMatrix(){
  ////////////////////////////////////////////////////////
  //Translation Parameters SSDSensorSupportAssembly:
  ////////////////////////////////////////////////////////
  const Double_t SSDSensorSupportTransX[3] = {-0.5*fgkSSDSensorSideSupportWidth,
					                           0.5*fgkSSDSensorSideSupportWidth,
					                   0.5*fgkSSDSensorCenterSupportThickness[0]
									  -    fgkSSDSensorCenterSupportPosition}; 
  const Double_t SSDSensorSupportTransY[3] = 
									   {0.5*fgkSSDSensorSideSupportThickness[0],
					                   -0.5*fgkSSDSensorSideSupportThickness[0]
						               -fgkSSDModuleSensorSupportDistance,
					                    0.5*fgkSSDSensorCenterSupportWidth
									   -0.5*fgkSSDModuleSensorSupportDistance}; 
  const Double_t SSDSensorSupportTransZ[3] = {0.,0.,
										fgkSSDSensorCenterSupportThickness[0]}; 
  ////////////////////////////////////////////////////////
  //Rotational Parameters SSDSensorSupportAssembly:
  ////////////////////////////////////////////////////////  
  const Double_t SSDSensorSupportRotPhi[3]   = {   0., 180., 270.};
  const Double_t SSDSensorSupportRotTheta[3] = {  90.,  90.,  90.};
  const Double_t SSDSensorSupportRotPsi[3]   = {- 90.,- 90.,- 90.};
  ////////////////////////////////////////////////////////////////
  //Name of CombiTrans Transformation of SSDSensorSupportAssembly:
  ////////////////////////////////////////////////////////////////
  char SSDSensorSupportCombiTransName[40];
  char SSDSensorSupportRotName[40];
  TGeoCombiTrans *SSDSensorSupportLocalMatrix[fgkSSDSensorSupportCombiTransNumber];
  for(Int_t i=0; i<fgkSSDSensorSupportCombiTransNumber; i++){ 
		sprintf(SSDSensorSupportCombiTransName,"SSDSensorSupportCombiTrans%i",i);
		sprintf(SSDSensorSupportRotName,"SSDSensorSupportRot%i",i);
		SSDSensorSupportLocalMatrix[i] =
				 new TGeoCombiTrans(SSDSensorSupportCombiTransName,
									SSDSensorSupportTransX[i],
									SSDSensorSupportTransY[i],
									SSDSensorSupportTransZ[i],
									new TGeoRotation(SSDSensorSupportRotName,
													  SSDSensorSupportRotPhi[i],
													SSDSensorSupportRotTheta[i],
												    SSDSensorSupportRotPsi[i]));
           SSDSensorSupportCombiTransMatrix[i] = SSDSensorSupportLocalMatrix[i];
  }
}
/////////////////////////////////////////////////////////////////////////////////
void AliITSv11GeometrySSD::SetSSDModuleCombiTransMatrix(Double_t SSDChipCablesHeigth){
/////////////////////////////////////////////////////////////////////////////////
//Translation Parameters SSDModuleAssembly:
////////////////////////////////////////////////////////
  const Double_t SSDModuleTransX[7] = {0.5*fgkSSDStiffenerLength,
           				         0.5*fgkSSDChipLength+0.5*(fgkSSDStiffenerLength
				       - (fgkSSDChipNumber*fgkSSDChipLength+(fgkSSDChipNumber-1)
					   * fgkSSDChipSeparationLength)),
				       - fgkSSDModuleStiffenerPosition[0]+0.5*fgkSSDSensorWidth,
				   0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
					   -       (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
				0.5*fgkSSDStiffenerLength-0.5*fgkSSDModuleSensorSupportDistance
			   - fgkSSDCoolingBlockLength,
				0.5*(fgkSSDStiffenerLength+fgkSSDChipCablesLength[1]
			   + (fgkSSDChipNumber-1)*fgkSSDChipCablesLength[0]),
				0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
			   +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)}; 
  const Double_t SSDModuleTransY[7] = {0.5*fgkSSDStiffenerWidth,
				       0.5*fgkSSDChipWidth+(fgkSSDStiffenerWidth
					 - fgkSSDStiffenerToChipDist-fgkSSDChipWidth),
				     - fgkSSDModuleStiffenerPosition[1]+0.5*fgkSSDSensorLength,
				       fgkSSDStiffenerWidth,
				       0.,
				       fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
					 - fgkSSDStiffenerWidth
				     + fgkSSDStiffenerToChipDist+fgkSSDChipWidth,
				       fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
					 - fgkSSDStiffenerWidth}; 
  const Double_t SSDModuleTransZ[7] = {0.5*fgkSSDStiffenerHeight,
				     - 0.5*fgkSSDChipHeight,
				       0.5*fgkSSDSensorHeight-fgkSSDStiffenerHeight-fgkSSDChipHeight
					 - SSDChipCablesHeigth,
				     - 0.5*fgkSSDFlexHeight[0],
				       fgkSSDStiffenerHeight,
				     - fgkSSDChipHeight,
				     - 0.5*fgkSSDChipHeight}; 
  ////////////////////////////////////////////////////////
  //Rotational Parameters SSDModuleAssembly:
  ////////////////////////////////////////////////////////  
  const Double_t SSDModuleRotPhi[7]   = {   0.,   0.,  90.,   0.,   0.,  90., 180.};
  const Double_t SSDModuleRotTheta[7] = {   0.,   0.,   0.,   0.,   0.,   0.,   0.};
  const Double_t SSDModuleRotPsi[7]   = {   0.,   0.,   0.,   0.,   0.,   0.,   0.};
  ////////////////////////////////////////////////////////  
  //Name of CombiTrans Transformation of SSDModuleAssembly:
  ////////////////////////////////////////////////////////  
  const char* SSDModuleCombiTransName[7] = {"SSDStiffenerCombiTrans",
											     "SSDChipCombiTrans",
											   "SSDSensorCombiTrans",
											    "SSDFlex0CombiTrans",
										 "SSDCoolingBlockCombiTrans",
										   "SSDChipCablesCombiTrans",
										        "SSDFlex1CombiTrans"};
  const char* SSDModuleRotName[7] = {"SSDStiffenerRotName",
										  "SSDChipRotName",
										"SSDSensorRotName",
										 "SSDFlex0RotName",
								  "SSDCoolingBlockRotName",
									"SSDChipCablesRotName",
										"SSDFlex1RotName"};
  TGeoCombiTrans *SSDModuleLocalMatrix[fgkSSDModuleCombiTransNumber];
  for(Int_t i=0; i<fgkSSDModuleCombiTransNumber; i++){ 
					SSDModuleLocalMatrix[i] =
					new TGeoCombiTrans(SSDModuleCombiTransName[i],
									   SSDModuleTransX[i],
									   SSDModuleTransY[i],
									   SSDModuleTransZ[i],
									   new TGeoRotation(SSDModuleRotName[i],
														SSDModuleRotPhi[i],
												        SSDModuleRotTheta[i],
												        SSDModuleRotPsi[i]));
    SSDModuleCombiTransMatrix[i] = SSDModuleLocalMatrix[i];
  }
}
/////////////////////////////////////////////////////////////////////////////////
void AliITSv11GeometrySSD::SetCarbonFiberJunctionCombiTransMatrix(){
/////////////////////////////////////////////////////////////////////////////////
  //Translation Parameters CarbonFiberJunction:
  ////////////////////////////////////////////////////////
  const Double_t CarbonFiberJunctionTransX[3] = 
				{  0.0,fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength
				 * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
  const Double_t CarbonFiberJunctionTransY[3] = 
									  {  0.0, 0.0,fgkCarbonFiberTriangleLength
				 *   TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
  const Double_t CarbonFiberJunctionTransZ[3] = {  0.0,  0.0,  0.0};
  ////////////////////////////////////////////////////////
  //Rotational Parameters CarbonFiberJunction:
  ////////////////////////////////////////////////////////
  const Double_t CarbonFiberJunctionRotPhi[3]   = {   0., 120., 240.};
  const Double_t CarbonFiberJunctionRotTheta[3] = {   0.,   0.,   0.};
  const Double_t CarbonFiberJunctionRotPsi[3]   = {   0.,   0.,   0.};
  ///////////////////////////////////////////////////////////
  //Name of CombiTrans Transformation of CarbonFiberJunction:
  ///////////////////////////////////////////////////////////
  char CarbonFiberJunctionCombiTransName[40];
  char CarbonFiberJunctionRotName[40];
  TGeoCombiTrans *CarbonFiberJunctionLocalMatrix[fgkCarbonFiberJunctionCombiTransNumber];
  for(Int_t i=0; i<fgkCarbonFiberJunctionCombiTransNumber; i++) {
		sprintf(CarbonFiberJunctionCombiTransName,"CarbonFiberJunctionCombiTrans%i",i);
		sprintf(CarbonFiberJunctionRotName,"CarbonFiberJunctionRot%i",i);
		CarbonFiberJunctionLocalMatrix[i] =
					new TGeoCombiTrans(CarbonFiberJunctionCombiTransName,
									   CarbonFiberJunctionTransX[i],
									   CarbonFiberJunctionTransY[i],
									   CarbonFiberJunctionTransZ[i],
								new TGeoRotation(CarbonFiberJunctionRotName,
												CarbonFiberJunctionRotPhi[i],
												CarbonFiberJunctionRotTheta[i],
												CarbonFiberJunctionRotPsi[i]));
    CarbonFiberJunctionCombiTransMatrix[i] = CarbonFiberJunctionLocalMatrix[i];
  }
}
/////////////////////////////////////////////////////////////////////////////////
void AliITSv11GeometrySSD::SetEndLadderCarbonFiberJunctionCombiTransMatrix(Int_t i){
/////////////////////////////////////////////////////////////////////////////////
  //Translation Parameters EndLadderCarbonFiberJunction:
  ////////////////////////////////////////////////////////
  const Double_t EndLadderCarbonFiberJunctionTransX[3] = 
				{  0.0,fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength
		*            TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
  const Double_t EndLadderCarbonFiberJunctionTransY[3] = 
										{  0.0, 0.0,fgkCarbonFiberTriangleLength
		*            TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
  const Double_t EndLadderCarbonFiberJunctionTransZ[3] = {  0.0,  0.0,  
						   0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
							   -fgkEndLadderCarbonFiberUpperJunctionLength[i])};
  ////////////////////////////////////////////////////////
  //Rotational Parameters EndLadderCarbonFiberJunction:
  ////////////////////////////////////////////////////////
  const Double_t EndLadderCarbonFiberJunctionRotPhi[3]   = {   0., 120., 240.};
  const Double_t EndLadderCarbonFiberJunctionRotTheta[3] = {   0.,   0.,   0.};
  const Double_t EndLadderCarbonFiberJunctionRotPsi[3]   = {   0.,   0.,   0.};
  ///////////////////////////////////////////////////////////
  //Name of CombiTrans Transformation of CarbonFiberJunction:
  ///////////////////////////////////////////////////////////
  char EndLadderCarbonFiberJunctionCombiTransName[40];
  char EndLadderCarbonFiberJunctionRotName[40];
  TGeoCombiTrans *EndLadderCarbonFiberJunctionLocalMatrix[fgkEndLadderCarbonFiberJunctionCombiTransNumber];
  for(Int_t i=0; i<fgkEndLadderCarbonFiberJunctionCombiTransNumber; i++) {
	sprintf(EndLadderCarbonFiberJunctionCombiTransName,"EndLadderCarbonFiberJunctionCombiTrans%i",i);
	sprintf(EndLadderCarbonFiberJunctionRotName,"EndLadderCarbonFiberJunctionRot%i",i);
	EndLadderCarbonFiberJunctionLocalMatrix[i] =
	new TGeoCombiTrans(EndLadderCarbonFiberJunctionCombiTransName,
										  EndLadderCarbonFiberJunctionTransX[i],
										  EndLadderCarbonFiberJunctionTransY[i],
										  EndLadderCarbonFiberJunctionTransZ[i],
						new TGeoRotation(EndLadderCarbonFiberJunctionRotName,
									  	  EndLadderCarbonFiberJunctionRotPhi[i],
										EndLadderCarbonFiberJunctionRotTheta[i],
									    EndLadderCarbonFiberJunctionRotPsi[i]));
    EndLadderCarbonFiberJunctionCombiTransMatrix[i] = 
									 EndLadderCarbonFiberJunctionLocalMatrix[i];
  }
}
////////////////////////////////////////////////////////////////////////////////
void AliITSv11GeometrySSD::SetCarbonFiberAssemblyCombiTransMatrix(){
/////////////////////////////////////////////////////////////////////////////////
  //Translation Parameters CarbonFiberAssembly:
  ////////////////////////////////////////////////////////
  const Double_t CarbonFiberAssemblyTransX[3] = {  0.0,  0.0,  0.0};
  const Double_t CarbonFiberAssemblyTransY[3] = 
										{  0.5*fgkCarbonFiberJunctionWidth, 0.0, 
					fgkCarbonFiberJunctionWidth-fgkCarbonFiberLowerSupportWidth
			   -    fgkCarbonFiberLowerSupportVolumePosition[0]
			   -    fgkCarbonFiberLowerSupportVolumePosition[1]};
  const Double_t CarbonFiberAssemblyTransZ[3] = 
						  {  0.0,  0.0,-  0.5*fgkCarbonFiberLowerSupportHeight};
  ////////////////////////////////////////////////////////
  //Rotational Parameters CarbonFiberAssembly:
  ////////////////////////////////////////////////////////
  const Double_t CarbonFiberAssemblyRotPhi[3]   = {   0.,  90.,   0.};
  const Double_t CarbonFiberAssemblyRotTheta[3] = {  90.,
											-fgkCarbonFiberTriangleAngle,   0.};
  const Double_t CarbonFiberAssemblyRotPsi[3]   = {   0.,- 90.,   0.};
  ///////////////////////////////////////////////////////////
  //Name of CombiTrans Transformation of CarbonFiberAssembly:
  ///////////////////////////////////////////////////////////
  char CarbonFiberAssemblyCombiTransName[30];
  char CarbonFiberAssemblyRotName[30];
  TGeoCombiTrans *CarbonFiberAssemblyLocalMatrix[fgkCarbonFiberAssemblyCombiTransNumber];
  for(Int_t i=0; i<fgkCarbonFiberAssemblyCombiTransNumber; i++) {
	sprintf(CarbonFiberAssemblyCombiTransName,"CarbonFiberAssemblyCombiTrans%i",i);
	sprintf(CarbonFiberAssemblyRotName,"CarbonFiberAssemblyRot%i",i);
	CarbonFiberAssemblyLocalMatrix[i] =
						new TGeoCombiTrans(CarbonFiberAssemblyCombiTransName,
										   CarbonFiberAssemblyTransX[i],
										   CarbonFiberAssemblyTransY[i],
										   CarbonFiberAssemblyTransZ[i],
						 new TGeoRotation(CarbonFiberAssemblyRotName,
										   CarbonFiberAssemblyRotPhi[i],
										   CarbonFiberAssemblyRotTheta[i],
										   CarbonFiberAssemblyRotPsi[i]));
    CarbonFiberAssemblyCombiTransMatrix[i] = CarbonFiberAssemblyLocalMatrix[i];
  }
}
/////////////////////////////////////////////////////////////////////////////////
void AliITSv11GeometrySSD::SetCoolingTubeSupportCombiTransMatrix(){
  ////////////////////////////////////////////////////////
  //Translation Parameters CoolingTubeSupport:
  ////////////////////////////////////////////////////////
  Double_t Phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
													/fgkCoolingTubeSupportRmax);
  const Double_t CoolingTubeSupportTransX[2] = 
						  {0.,2.*fgkCoolingTubeSupportRmax*TMath::Cos(Phi)
						+  2.*(fgkCoolingTubeSupportLength
						-  fgkCoolingTubeSupportRmax*(1.+TMath::Cos(Phi)))
						+  fgkCarbonFiberTriangleLength
						-  2.0*fgkCarbonFiberJunctionLength};
  const Double_t CoolingTubeSupportTransY[2] = {  0.0,  0.0};
  const Double_t CoolingTubeSupportTransZ[2] = {  0.0,  0.0};
  ////////////////////////////////////////////////////////
  //Rotational Parameters CoolingTubeSupport:
  ////////////////////////////////////////////////////////
  const Double_t CoolingTubeSupportRotPhi[2]   = {   0., 180.};
  const Double_t CoolingTubeSupportRotTheta[2] = {   0.,   0.};
  const Double_t CoolingTubeSupportRotPsi[2]   = {   0.,   0.};
  ///////////////////////////////////////////////////////////
  //Name of CombiTrans Transformation of CarbonFiberJunction:
  ///////////////////////////////////////////////////////////
  char CoolingTubeSupportCombiTransName[40];
  char CoolingTubeSupportRotName[40];
  TGeoCombiTrans *CoolingTubeSupportLocalMatrix[fgkCoolingTubeSupportCombiTransNumber];
  for(Int_t i=0; i<fgkCoolingTubeSupportCombiTransNumber; i++) {
	sprintf(CoolingTubeSupportCombiTransName,"CoolingTubeSupportCombiTrans%i",i);
	sprintf(CoolingTubeSupportRotName,"CoolingTubeSupportRot%i",i);
	CoolingTubeSupportLocalMatrix[i] =
			new TGeoCombiTrans(CoolingTubeSupportCombiTransName,
							   CoolingTubeSupportTransX[i],
							   CoolingTubeSupportTransY[i],
							   CoolingTubeSupportTransZ[i],
							   new TGeoRotation(CoolingTubeSupportRotName,
												CoolingTubeSupportRotPhi[i],
												CoolingTubeSupportRotTheta[i],
												CoolingTubeSupportRotPsi[i]));
    CoolingTubeSupportCombiTransMatrix[i] = CoolingTubeSupportLocalMatrix[i];
  }
}
/////////////////////////////////////////////////////////////////////////////////
void AliITSv11GeometrySSD::SetCoolingTubeCombiTransMatrix(){
  ////////////////////////////////////////////////////////
  //Translation Parameters CoolingTube:
  ////////////////////////////////////////////////////////
  const Double_t CoolingTubeTransX[2] = {  0.,  fgkCoolingTubeSeparation};
  const Double_t CoolingTubeTransY[2] = {  fgkCoolingTubeLength/2.0, fgkCoolingTubeLength/2.0};
  const Double_t CoolingTubeTransZ[2] = {  0.0,  0.};
  ////////////////////////////////////////////////////////
  //Rotational Parameters CoolingTube:
  ////////////////////////////////////////////////////////
  const Double_t CoolingTubeRotPhi[2]   = {   0.,   0.};
  const Double_t CoolingTubeRotTheta[2] = {  90.,  90.};
  const Double_t CoolingTubeRotPsi[2]   = {   0.,   0.};
  ///////////////////////////////////////////////////////////
  //Name of CombiTrans Transformation of CarbonFiberJunction:
  ///////////////////////////////////////////////////////////
  const char* CoolingTubeCombiTransName[fgkCoolingTubeCombiTransNumber] = 
							{"CoolingTubeCombiTrans0","CoolingTubeCombiTrans1"};
  const char* CoolingTubeRorationName[fgkCoolingTubeCombiTransNumber] = 
								{"CoolingTubeRotation0","CoolingTubeRotation1"};
  TGeoCombiTrans *CoolingTubeLocalMatrix[fgkCoolingTubeCombiTransNumber];
  for(Int_t i=0; i<fgkCoolingTubeCombiTransNumber; i++) {
	CoolingTubeLocalMatrix[i] =
			new TGeoCombiTrans(CoolingTubeCombiTransName[i],
							   CoolingTubeTransX[i],
							   CoolingTubeTransY[i],
							   CoolingTubeTransZ[i], 
							   new TGeoRotation(CoolingTubeRorationName[i],
							                    CoolingTubeRotPhi[i],
							                    CoolingTubeRotTheta[i],
									    CoolingTubeRotPsi[i]    ) );
    CoolingTubeTransMatrix[i] = CoolingTubeLocalMatrix[i];
  }
}
/////////////////////////////////////////////////////////////////////////////////
void AliITSv11GeometrySSD::SetLadderSegmentCombiTransMatrix(){
/////////////////////////////////////////////////////////////////////////////////
  //Translation Parameters LadderSegment:
  ////////////////////////////////////////////////////////
	const Double_t LadderSegmentTransX[fgkLadderSegmentCombiTransNumber] = {  0.,
	 -  0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
			 fgkCarbonFiberTriangleLength+fgkCarbonFiberJunctionToSensorSupport,
			 fgkCarbonFiberJunctionLength-(fgkCoolingTubeSupportLength
	 -       fgkCoolingTubeSupportRmax),
		0.5*(fgkCarbonFiberTriangleLength-fgkCoolingTubeSeparation)}; 
	const Double_t LadderSegmentTransY[fgkLadderSegmentCombiTransNumber] = {  0.,
	 -      (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
			 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
	 +		 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
	 -		 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
	 -            fgkSSDSensorCenterSupportThickness[0]),
				  fgkCarbonFiberJunctionWidth-0.5*(fgkCarbonFiberLowerSupportWidth
	 +            fgkSSDSensorCenterSupportLength
	 -            fgkSSDSensorCenterSupportThickness[0])
	 -			  fgkSSDSensorCenterSupportPosition,
				  fgkCarbonFiberJunctionWidth-fgkCarbonFiberLowerSupportWidth
	 -			  fgkCoolingTubeSupportToCarbonFiber,
												 0.0};
	const Double_t LadderSegmentTransZ[fgkLadderSegmentCombiTransNumber] = {  0.,
	 -        (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
	 -         fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight),
																			 0.,
	 -     0.5*fgkCoolingTubeSupportHeight,
	 -     0.5*fgkCoolingTubeSupportHeight};
//////////////////////////////////////////////////
  //Rotational Parameters LadderSegment:
  ////////////////////////////////////////////////////////
  const Double_t LadderSegmentRotPhi[fgkLadderSegmentCombiTransNumber]   =
													  {   0.,   0.,- 90.,   0.,  0.};
  const Double_t LadderSegmentRotTheta[fgkLadderSegmentCombiTransNumber] = 
													  {   0.,   0.,   0.,  90.,  0.};
  const Double_t LadderSegmentRotPsi[fgkLadderSegmentCombiTransNumber]   = 
													  {   0.,   0.,   0.,   0.,  0.};
  //////////////////////////////////////////////////////
  //Name of CombiTrans Transformation of LadderSegment:
  //////////////////////////////////////////////////////
  char LadderSegmentCombiTransName[40];
  char LadderSegmentRotName[40];
  TGeoCombiTrans *LadderSegmentLocalMatrix[fgkLadderSegmentCombiTransNumber];
  for(Int_t i=0; i<fgkLadderSegmentCombiTransNumber; i++) {
		sprintf(LadderSegmentCombiTransName,"LadderSegmentCombiTrans%i",i);
		sprintf(LadderSegmentRotName,"LadderSegmentRot%i",i);
		LadderSegmentLocalMatrix[i] =
					new TGeoCombiTrans(LadderSegmentCombiTransName,
									   LadderSegmentTransX[i],
									   LadderSegmentTransY[i],
									   LadderSegmentTransZ[i],
									   new TGeoRotation(LadderSegmentRotName,
														LadderSegmentRotPhi[i],
														LadderSegmentRotTheta[i],
														LadderSegmentRotPsi[i]));
    LadderSegmentCombiTransMatrix[i] = LadderSegmentLocalMatrix[i];
  }
}
/////////////////////////////////////////////////////////////////////////////////
void AliITSv11GeometrySSD::SetEndLadderSegmentCombiTransMatrix(Int_t i){
/////////////////////////////////////////////////////////////////////////////////
  //Translation Parameters EndLadderSegment:
  ////////////////////////////////////////////////////////
  const Double_t EndLadderSegmentTransX[4] = {0.0,
											  0.0,
	         -  0.25*(fgkSSDMountingBlockLength[0]
			 +	fgkSSDMountingBlockLength[1])
			 +  0.5*fgkCarbonFiberTriangleLength,
											  0.0}; 
  const Double_t EndLadderSegmentTransY[4] = 
							 {0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],
					          i==0 ? 0. : fgkCarbonFiberLowerSupportWidth,
					                 fgkEndLadderMountingBlockPosition[i],
					           (1-i)*(fgkEndLadderMountingBlockPosition[i]
										 +  0.5*fgkSSDMountingBlockWidth)}; 
  const Double_t EndLadderSegmentTransZ[4] = {0.0,
											  0.0,
										-  fgkSSDMountingBlockHeight[1]
										+  0.5*fgkSSDMountingBlockHeight[0],
									    -  0.5*fgkCarbonFiberLowerSupportHeight}; 
  ////////////////////////////////////////////////////////
  //Rotational Parameters EndLadderSegment:
  ////////////////////////////////////////////////////////  
  const Double_t EndLadderSegmentRotPhi[4]   = {   0.,  90.,   0.,   0.};
  const Double_t EndLadderSegmentRotTheta[4] = {  90.,-fgkCarbonFiberTriangleAngle,
												   0.,   0.};
  const Double_t EndLadderSegmentRotPsi[4]   = {   0.,- 90.,   0.,   0.};
  ////////////////////////////////////////////////////////
  //Name of CombiTrans Transformation of EndLadderSegment:
  ////////////////////////////////////////////////////////
  char EndLadderSegmentCombiTransName[30];
  char EndLadderSegmentRotName[30];
  TGeoCombiTrans *EndLadderSegmentLocalMatrix[fgkEndLadderSegmentCombiTransNumber];
  for(Int_t i=0; i<fgkEndLadderSegmentCombiTransNumber; i++){ 
  		sprintf(EndLadderSegmentCombiTransName,"EndLadderSegmentCombiTrans%i",i);
		sprintf(EndLadderSegmentRotName,"EndLadderSegmentRot%i",i);
		EndLadderSegmentLocalMatrix[i] =
				new TGeoCombiTrans(EndLadderSegmentCombiTransName,
								   EndLadderSegmentTransX[i],
								   EndLadderSegmentTransY[i],
								   EndLadderSegmentTransZ[i],
								   new TGeoRotation(EndLadderSegmentRotName,
													EndLadderSegmentRotPhi[i],
													EndLadderSegmentRotTheta[i],
													EndLadderSegmentRotPsi[i]));
    EndLadderSegmentCombiTransMatrix[i] = EndLadderSegmentLocalMatrix[i];
  }
}
/////////////////////////////////////////////////////////////////////////////////
void AliITSv11GeometrySSD::SetLadderCableCombiTransMatrix(Int_t iLayer){
////////////////////////////////////////////////////////////////////////////////
// Translation Parameters for LadderCable
/////////////////////////////////////////
  Double_t SSDFlexRadius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
					     + fgkSSDFlexHeight[1];  
  Double_t SSDFlexRadiusMax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
							/  TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
  Double_t SSDLadderCableTransX[3];
  SSDLadderCableTransX[0] = (SSDFlexRadiusMax-fgkSSDFlexHeight[1]-SSDFlexRadius)
						  *   TMath::Sin(2.*fgkSSDFlexAngle*TMath::DegToRad())
						  *	  TMath::Cos(2.*fgkSSDFlexAngle*TMath::DegToRad());
  SSDLadderCableTransX[1] = ((SSDFlexRadiusMax-fgkSSDFlexHeight[1]-SSDFlexRadius)
						  -     SSDLadderCableTransX[0]
						  /     TMath::Sin(2.*fgkSSDFlexAngle*TMath::DegToRad()))
						  *     TMath::Cos(fgkSSDFlexAngle*TMath::DegToRad());						
  SSDLadderCableTransX[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
						  *	  TMath::DegToRad()*SSDFlexRadiusMax
						  -     fgkSSDFlexLength[2]-TMath::Pi()
						  *	  fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
						  -	  fgkSSDLadderCableWidth)
						  *	  TMath::Cos(2.*fgkSSDFlexAngle*TMath::DegToRad());
  Double_t SSDLadderCableTransZ[3] = {SSDLadderCableTransX[0]
						  *	TMath::Tan(2.*fgkSSDFlexAngle*TMath::DegToRad()),
							SSDLadderCableTransX[1]
						  *	TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad()),
							SSDLadderCableTransX[2]
						  *	TMath::Tan(2.*fgkSSDFlexAngle*TMath::DegToRad())};	
  TGeoRotation* LocalLadderCableRot[3];	
  LocalLadderCableRot[0] = new TGeoRotation("LocalLadderCableRot0",90.,0.,0.);
  LocalLadderCableRot[1] = new TGeoRotation("LocalLadderCableRot1",90.,60.,-90.);
  LocalLadderCableRot[2] = new TGeoRotation("LocalLadderCableRot2");
  LocalLadderCableRot[2]->SetRotation((*LocalLadderCableRot[1])
						 *			  (*LocalLadderCableRot[0]));
////////////////////////////////////////////
// LocalLadderCableCombiTransMatrix
////////////////////////////////////////////
  const Int_t LocalLadderSideCablesNumber = 2;
  const Int_t LocalLadderCombiTransNumber = 5;
  TGeoCombiTrans** LocalLadderCableCombiTransMatrix[LocalLadderSideCablesNumber];
  for(Int_t i=0; i<LocalLadderSideCablesNumber; i++) 
	LocalLadderCableCombiTransMatrix[i] = 
							   new TGeoCombiTrans*[LocalLadderCombiTransNumber];
///////////////////////////////////////////
// Left Side Ladder Cables Transformations
///////////////////////////////////////////
  LocalLadderCableCombiTransMatrix[0][0]  =
						new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
						0.,0.,NULL);
  LocalLadderCableCombiTransMatrix[0][1] = LadderSegmentCombiTransMatrix[1];
  LocalLadderCableCombiTransMatrix[0][2] = 
						new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
										   fgkSSDModuleStiffenerPosition[1],0.,0);
  LocalLadderCableCombiTransMatrix[0][3] = SSDModuleCombiTransMatrix[6];
  LocalLadderCableCombiTransMatrix[0][4] = 
						new TGeoCombiTrans(-SSDLadderCableTransX[0]
						-     SSDLadderCableTransX[1]-SSDLadderCableTransX[2]
						+     fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
							  0.,
							  0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
						+	  fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
						+     SSDLadderCableTransZ[0]-SSDLadderCableTransZ[1]
						+	  SSDLadderCableTransZ[2],LocalLadderCableRot[2]);
///////////////////////////////////////////
// Rigth Side Ladder Cables Transformations
///////////////////////////////////////////
 for(Int_t i=0; i<LocalLadderCombiTransNumber; i++)
   LocalLadderCableCombiTransMatrix[1][i] = 
			(i!=3 ? LocalLadderCableCombiTransMatrix[0][i]:
					SSDModuleCombiTransMatrix[3]); 	
///////////////////////////////////////////
// Setting LadderCableCombiTransMatrix
///////////////////////////////////////////
Int_t BeamAxisTrans[3] = {0,0,0};
switch(iLayer){
case 5: 
	BeamAxisTrans[0] = fgkSSDLay5SensorsNumber/2;
	BeamAxisTrans[1] = BeamAxisTrans[0]+1;
	BeamAxisTrans[2] = BeamAxisTrans[0]-1;
	break;
case 6:
	BeamAxisTrans[0] = (fgkSSDLay6SensorsNumber-1)/2;
	BeamAxisTrans[1] = BeamAxisTrans[0]+1;
	BeamAxisTrans[2] = BeamAxisTrans[0];
	break;
}
 TGeoHMatrix* LocalLadderCableHMatrix[LocalLadderSideCablesNumber];
 TGeoRotation* LadderCableRot;
 TGeoTranslation* LadderCableTrans;
 for(Int_t i=0; i<LocalLadderSideCablesNumber; i++){
	LocalLadderCableHMatrix[i] = new TGeoHMatrix();
	for(Int_t j=0; j<LocalLadderCombiTransNumber; j++){
		  LocalLadderCableHMatrix[i]->MultiplyLeft(
		  LocalLadderCableCombiTransMatrix[i][LocalLadderCombiTransNumber-j-1]);
	}
	LadderCableRot = new TGeoRotation();
	LadderCableRot->SetMatrix(LocalLadderCableHMatrix[i]->GetRotationMatrix());
    LadderCableTrans = new TGeoTranslation();
    Double_t* LadderCableTransVector = LocalLadderCableHMatrix[i]->GetTranslation();
    LadderCableTrans->SetTranslation(LadderCableTransVector[0],
									 LadderCableTransVector[1]
					+                (i==0 ? BeamAxisTrans[0] : 0.)
					*				 fgkCarbonFiberJunctionWidth,
									 LadderCableTransVector[2]);	 
	LadderCableCombiTransMatrix[i] = new TGeoCombiTrans(*LadderCableTrans,
												   *LadderCableRot);
	} 
	LadderCableCombiTransMatrix[2] = 
					AddTranslationToCombiTrans(LadderCableCombiTransMatrix[1],0.,
					BeamAxisTrans[1]*fgkCarbonFiberJunctionWidth,0.);
	LadderCableCombiTransMatrix[3] = 
					AddTranslationToCombiTrans(LadderCableCombiTransMatrix[0],0.,
					BeamAxisTrans[2]*fgkCarbonFiberJunctionWidth,0.);
 }
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupportShape(Double_t length, 
							Double_t height,Double_t width,Double_t* thickness){
////////////////////////////////////////////////////////////////////////////////
  const Int_t VertexNumber = 4;
  const Int_t ShapesNumber = 2;
  Double_t Width[2] = {width,width};
  TVector3** VertexPosition[ShapesNumber];
  for(Int_t i = 0; i<ShapesNumber; i++) VertexPosition[i] = 
													new TVector3*[VertexNumber];
  //First Shape Vertex Positioning
  VertexPosition[0][0] = new TVector3();
  VertexPosition[0][1] = new TVector3(height);
  VertexPosition[0][2] = new TVector3(thickness[0]);
  VertexPosition[0][3] = new TVector3(*VertexPosition[0][1]);
  //Second Shape Vertex Positioning
  VertexPosition[1][0] = new TVector3(*VertexPosition[0][0]);
  VertexPosition[1][1] = new TVector3(length);
  VertexPosition[1][2] = new TVector3(thickness[1]);
  VertexPosition[1][3] = new TVector3(VertexPosition[1][1]->X());
  char* SSDSensorSupportShapeName[ShapesNumber] = 
							{"SSDSensorSupportShape1","SSDSensorSupportShape2"};
  TGeoArb8* SSDSensorSupportShape[ShapesNumber];
  for(Int_t i = 0; i< ShapesNumber; i++) SSDSensorSupportShape[i] = 
					   GetArbShape(VertexPosition[i],Width,i==0 ? 
													 thickness[1]: thickness[0],
												  SSDSensorSupportShapeName[i]);
  /////////////////////////////////////
  //Setting Translations and Rotations: 
  /////////////////////////////////////
  TGeoRotation* SSDSensorSupportShapeRot[2];
  SSDSensorSupportShapeRot[0] = 
					 new TGeoRotation("SSDSensorSupportShapeRot1",180.,0.,0.);
  SSDSensorSupportShapeRot[1] = 
					 new TGeoRotation("SSDSensorSupportShapeRot2",90.,90.,-90.);
  TGeoTranslation* SSDSensorSupportShapeTrans = 
					 new TGeoTranslation("SSDSensorSupportShapeTrans",0.,0.,
															  0.5*thickness[0]);
  TGeoCombiTrans* SSDSensorSupportCombiTrans = 
	  new TGeoCombiTrans("SSDSensorSupportCombiTrans",0.5*thickness[0],width,0.,
						  new TGeoRotation((*SSDSensorSupportShapeRot[1])
						*                  (*SSDSensorSupportShapeRot[0])));
  TGeoVolume* SSDSensorSupportCompVolume = 
						  new TGeoVolumeAssembly("SSDSensorSupportCompVolume");
  SSDSensorSupportCompVolume->AddNode(new TGeoVolume("SSDSensorSupportVolume1",
							SSDSensorSupportShape[0],fgkSSDSensorSupportMedium),1,
							SSDSensorSupportShapeTrans);
  SSDSensorSupportCompVolume->AddNode(new TGeoVolume("SSDSensorSupportVolume2",
							SSDSensorSupportShape[1],fgkSSDSensorSupportMedium),1,
							SSDSensorSupportCombiTrans);
  return SSDSensorSupportCompVolume;
}
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Int_t VolumeKind, Int_t n){
////////////////////////////////////////////////////////////////////////////////
  TGeoVolume* SSDSensorSupport;
  Double_t SideSupportThickness[2] = {fgkSSDSensorSideSupportThickness[0],
										   fgkSSDSensorSideSupportThickness[1]};
  VolumeKind == 0 ? SSDSensorSupport = GetSSDSensorSupportShape(
								fgkSSDSensorSideSupportLength,
								fgkSSDSensorSideSupportHeight[(n==0 ? 0 : 1)],
								fgkSSDSensorSideSupportWidth,
								SideSupportThickness) :
    SSDSensorSupport = GetSSDSensorSupportShape(fgkSSDSensorCenterSupportLength,
						        fgkSSDSensorCenterSupportHeight[(n==0 ? 0 : 1)],
							    fgkSSDSensorCenterSupportWidth,
							    SideSupportThickness);
  return SSDSensorSupport;
}
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupportAssembly(Int_t n){
////////////////////////////////////////////////////////////////////////////////
  TGeoVolume* SSDSensorSupportAssembly = 
							 new TGeoVolumeAssembly("SSDSensorSupportAssembly");
  const Int_t VolumeNumber = 2;
  TGeoVolume* SSDSensorSupport[VolumeNumber];
  for(Int_t i=0; i<VolumeNumber; i++) SSDSensorSupport[i] = 
														GetSSDSensorSupport(i,n);
  SetSSDSensorSupportCombiTransMatrix();
  for(Int_t i=0; i<fgkSSDSensorSupportCombiTransNumber; i++) 
	SSDSensorSupportAssembly->AddNode((i<2 ? SSDSensorSupport[0]:
											 SSDSensorSupport[1]),
										 i+1,SSDSensorSupportCombiTransMatrix[i]);
  return SSDSensorSupportAssembly;
}
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetSSDModule(Int_t iChipCablesHeight){
////////////////////////////////////////////////////////////////////////////////
  TGeoVolume* SSDModuleVolume[fgkSSDModuleCombiTransNumber-1];
  SSDModuleVolume[0] = GetSSDStiffenerAssembly();
  SSDModuleVolume[1] = GetSSDChipAssembly();
  SSDModuleVolume[2] = GetSSDSensor();
  SSDModuleVolume[3] = GetSSDFlexAssembly();
  SSDModuleVolume[4] = GetSSDCoolingBlockAssembly();
  SSDModuleVolume[5] = GetSSDChipCablesAssembly(fgkSSDChipCablesHeight[iChipCablesHeight+2]);
  SetSSDModuleCombiTransMatrix(fgkSSDChipCablesHeight[iChipCablesHeight+2]);
  TGeoCombiTrans* SSDModuleGlobalCombiTrans = 
								   new TGeoCombiTrans("SSDModuleGlobalCombiTrans",
									   fgkSSDModuleStiffenerPosition[0],
									   fgkSSDModuleStiffenerPosition[1],0.,NULL);
  TGeoHMatrix* SSDModuleHMatrix[fgkSSDModuleCombiTransNumber];
  TGeoVolume* SSDModule = new TGeoVolumeAssembly("SSDModule");
  for(Int_t i=0; i<fgkSSDModuleCombiTransNumber; i++){ 
	SSDModuleHMatrix[i] = new TGeoHMatrix((*SSDModuleGlobalCombiTrans)
						*				  (*SSDModuleCombiTransMatrix[i]));
	SSDModule->AddNode(i==fgkSSDModuleCombiTransNumber-1 ? SSDModuleVolume[3] : 
						  SSDModuleVolume[i],i!=fgkSSDModuleCombiTransNumber-1?1:2,
						  SSDModuleHMatrix[i]);
  }
  return SSDModule;
}
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetSSDSensor(){
////////////////////////////////////////////////////////////////////////////////
  Double_t fgkSSDSensorSensitiveLength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
  Double_t fgkSSDSensorSensitiveWidth  = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
  TGeoBBox* SSDSensorSensitiveShape = new TGeoBBox("SSDSensorSensitiveShape",
                                                0.5*fgkSSDSensorSensitiveLength,
                                                0.5*fgkSSDSensorSensitiveWidth,
                                                0.5*fgkSSDSensorHeight);
  TGeoVolume* SSDSensorSensitive = 
      new TGeoVolume(fgkSSDSensitiveVolName,SSDSensorSensitiveShape,fgkSSDSensorMedium);
  SSDSensorSensitive->SetLineColor(fColorSilicon);
  TGeoBBox* SSDSensorInsensitiveShape[2];
  SSDSensorInsensitiveShape[0] = new TGeoBBox("SSDSensorInSensitiveShape1",
                                                0.5*fgkSSDSensorLength,
                                                0.5*fgkSSDSensorInsensitiveWidth,
                                                0.5*fgkSSDSensorHeight);
  SSDSensorInsensitiveShape[1] = new TGeoBBox("SSDSensorInSensitiveShape2",
                                                0.5*fgkSSDSensorInsensitiveWidth,
                                                0.5*fgkSSDSensorSensitiveWidth,
                                                0.5*fgkSSDSensorHeight);
  const char* SSDSensorInsensitiveName[2] = {"SSDSensorInsensitive1",
                                             "SSDSensorInsensitive2"};
  TGeoVolume* SSDSensorInsensitive[2];
  for(Int_t i=0; i<2; i++){ SSDSensorInsensitive[i] = 
      new TGeoVolume(SSDSensorInsensitiveName[i],SSDSensorInsensitiveShape[i],
                     fgkSSDSensorMedium);
      SSDSensorInsensitive[i]->SetLineColor(fColorCarbonFiber);
  }
  TGeoVolume* SSDSensorInsensitiveVol = 
                              new TGeoVolumeAssembly("SSDSensorInsensitiveVol");
  for(Int_t i=0; i<4; i++) 
            SSDSensorInsensitiveVol->AddNode(i%2==0 ? SSDSensorInsensitive[0]:
            SSDSensorInsensitive[1],i<2?1:2,
                  new TGeoTranslation(0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
      *     (SSDSensorSensitiveShape->GetDX()+SSDSensorInsensitiveShape[1]->GetDX()),
                        0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
      *     (SSDSensorSensitiveShape->GetDY()+SSDSensorInsensitiveShape[0]->GetDY()),0.));            
  TGeoVolume* SSDSensor = new TGeoVolumeAssembly("SSDSensor");
  SSDSensor->AddNode(SSDSensorSensitive,1),SSDSensor->AddNode(SSDSensorInsensitiveVol,1);
  return SSDSensor;
}
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetSSDChipAssembly(){
////////////////////////////////////////////////////////////////////////////////
  const Int_t SSDChipRowNumber = 2;
  TGeoBBox* SSDChipCompShape[2];
  SSDChipCompShape[0] =  new TGeoBBox("SSDChipCompShape",
										0.5*fgkSSDChipLength,
										0.5*fgkSSDChipWidth,
										0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
  SSDChipCompShape[1] =  new TGeoBBox("SSDChipGlueCompShape",
										0.5*fgkSSDChipLength,
										0.5*fgkSSDChipWidth,
										0.5*fgkSSDChipGlueHeight);
  TGeoVolume* SSDChipComp[2];
  SSDChipComp[0] = new TGeoVolume("SSDChipComp",SSDChipCompShape[0],fgkSSDChipMedium);
  SSDChipComp[1] = new TGeoVolume("SSDChipGlueComp",SSDChipCompShape[1],
								  fgkSSDChipGlueMedium);
  SSDChipComp[0]->SetLineColor(fColorSilicon);  
  SSDChipComp[1]->SetLineColor(fColorEpoxy);
  TGeoTranslation* SSDChipCompTrans[2];
  SSDChipCompTrans[0] = new TGeoTranslation(0.,0.,-SSDChipCompShape[1]->GetDZ());
  SSDChipCompTrans[1] = new TGeoTranslation(0.,0.,SSDChipCompShape[0]->GetDZ());
  TGeoVolume* SSDChip = new TGeoVolumeAssembly("SSDChip");  
  for(Int_t i=0; i<2; i++) SSDChip->AddNode(SSDChipComp[i],1,SSDChipCompTrans[i]);
  Double_t SSDChipSeparation[2] = {fgkSSDChipLength+fgkSSDChipSeparationLength,
						  fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
				   -  2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
				   -  0.5*fgkSSDChipWidth)};
  TGeoVolume* SSDChipAssembly = new TGeoVolumeAssembly("SSDChipAssembly"); 
  for(Int_t i=0; i<SSDChipRowNumber; i++)
    for(Int_t j=0; j<fgkSSDChipNumber; j++) 
		SSDChipAssembly->AddNode(SSDChip,fgkSSDChipNumber*i+j+1,
		new TGeoTranslation(j*SSDChipSeparation[0],i*SSDChipSeparation[1],0.));
  return SSDChipAssembly;
}
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerAssembly(){
////////////////////////////////////////////////////////////////////////////////
  const Int_t SSDStiffenerNumber = 2;
  Double_t SSDStiffenerSeparation = fgkSSDSensorLength
								  - 2.*fgkSSDModuleStiffenerPosition[1]
								  -    fgkSSDStiffenerWidth;
  TGeoVolume* SSDStiffener = new TGeoVolumeAssembly("SSDStiffener");
////////////////////////////
// Stiffener Volumes
///////////////////////////
  const Int_t StiffenerBoxNumber = 6;
  TGeoBBox* SSDStiffenerBoxShapes[StiffenerBoxNumber];
  SSDStiffenerBoxShapes[0] = new TGeoBBox("SSDStiffenerBoxShape1",
										  0.5* fgkSSDStiffenerLength,
										  0.5* fgkSSDStiffenerWidth,
										  0.5*(fgkSSDStiffenerHeight
						   -                   fgkSSDConnectorHeight));
  SSDStiffenerBoxShapes[1] = new TGeoBBox("SSDStiffenerBoxShape2",
										  0.5*(fgkSSDConnectorPosition[0]
						   -              2.0* fgkSSDConnectorLength
						   -				   fgkSSDConnectorSeparation),
										  0.5* fgkSSDStiffenerWidth,
										  0.5* fgkSSDConnectorHeight);
  SSDStiffenerBoxShapes[2] = new TGeoBBox("SSDStiffenerBoxShape3",
										  0.5*(fgkSSDConnectorSeparation
						   +              2.*  fgkSSDConnectorLength),
										  0.5* fgkSSDConnectorPosition[1],
										  0.5* fgkSSDConnectorHeight);
  SSDStiffenerBoxShapes[3] = new TGeoBBox("SSDStiffenerBoxShape4",
											SSDStiffenerBoxShapes[2]->GetDX(),
										  0.5*(fgkSSDStiffenerWidth
						   -                   fgkSSDConnectorPosition[1]
						   -                   fgkSSDConnectorWidth),
										  0.5* fgkSSDConnectorHeight);
   SSDStiffenerBoxShapes[4] = new TGeoBBox("SSDStiffenerBoxShape5",
										  0.5* fgkSSDConnectorSeparation,
										  0.5* fgkSSDConnectorWidth,
										  0.5* fgkSSDConnectorHeight);
   SSDStiffenerBoxShapes[5] = new TGeoBBox("SSDStiffenerBoxShape6",
										  0.5*(fgkSSDStiffenerLength
							 -				   fgkSSDConnectorPosition[0]),
										  0.5* fgkSSDStiffenerWidth,
										  0.5* fgkSSDConnectorHeight);
  TGeoVolume* SSDStiffenerBox[StiffenerBoxNumber];
  char SSDStiffenerBoxName[30];
  for(Int_t i=0; i<StiffenerBoxNumber; i++){ 
	sprintf(SSDStiffenerBoxName,"SSDStiffenerBox%i",i+1);
    SSDStiffenerBox[i] = new TGeoVolume(SSDStiffenerBoxName,SSDStiffenerBoxShapes[i],
									  fgkSSDStiffenerMedium);
	SSDStiffenerBox[i]->SetLineColor(fColorStiffener);
  }
////////////////////////////
// Connector 
///////////////////////////
  TGeoBBox* SSDConnectorShape =  new TGeoBBox("SSDConnectorShape",
											 0.5*fgkSSDConnectorLength,
											 0.5*fgkSSDConnectorWidth,
											 0.5*fgkSSDConnectorHeight);
  TGeoVolume* SSDConnector    = new TGeoVolume("SSDConnector",SSDConnectorShape,
												fgkSSDStiffenerConnectorMedium); 
  SSDConnector->SetLineColor(fColorAl);
  const Int_t SSDConnectorNumber = 2;
  TGeoTranslation* SSDConnectorTrans[SSDConnectorNumber];
  SSDConnectorTrans[0] = new TGeoTranslation("SSDConnectorTrans1",
        -  SSDStiffenerBoxShapes[0]->GetDX()+fgkSSDConnectorPosition[0]
		-  fgkSSDConnectorSeparation-1.5*fgkSSDConnectorLength,
		   SSDStiffenerBoxShapes[0]->GetDY()-fgkSSDConnectorPosition[1]
		-  SSDConnectorShape->GetDY(),
		   SSDStiffenerBoxShapes[0]->GetDZ()+SSDConnectorShape->GetDZ());	
  SSDConnectorTrans[1] = new TGeoTranslation("SSDConnectorTrans2",
        -  SSDStiffenerBoxShapes[0]->GetDX()+fgkSSDConnectorPosition[0]
        -  0.5*fgkSSDConnectorLength,
           SSDStiffenerBoxShapes[0]->GetDY()-fgkSSDConnectorPosition[1]
		-  SSDConnectorShape->GetDY(),
		   SSDStiffenerBoxShapes[0]->GetDZ()+SSDConnectorShape->GetDZ());
  for(Int_t i=0; i<SSDConnectorNumber; i++)
			SSDStiffener->AddNode(SSDConnector,i+1,SSDConnectorTrans[i]);	
//////////////////////////////////////
// TGeoTranslation for Stiffener Boxes
//////////////////////////////////////
  TGeoTranslation* SSDStiffenerBoxTrans[StiffenerBoxNumber];
  SSDStiffenerBoxTrans[0] = new TGeoTranslation("SSDStiffenerBoxTrans1",0.,0.,0.);
  SSDStiffenerBoxTrans[1] = new TGeoTranslation("SSDStiffenerBoxTrans2",
		 - (SSDStiffenerBoxShapes[0]->GetDX()-SSDStiffenerBoxShapes[1]->GetDX()),
		    0.,
			SSDStiffenerBoxShapes[0]->GetDZ()+SSDStiffenerBoxShapes[1]->GetDZ());
  SSDStiffenerBoxTrans[2] = new TGeoTranslation("SSDStiffenerBoxTrans3",
         - SSDStiffenerBoxShapes[0]->GetDX()-SSDStiffenerBoxShapes[2]->GetDX()
		 + fgkSSDConnectorPosition[0],
		   SSDStiffenerBoxShapes[0]->GetDY()-SSDStiffenerBoxShapes[2]->GetDY(),
		   SSDStiffenerBoxShapes[0]->GetDZ()+SSDStiffenerBoxShapes[2]->GetDZ());
  SSDStiffenerBoxTrans[3] = new TGeoTranslation("SSDStiffenerBoxTrans4",
         - SSDStiffenerBoxShapes[0]->GetDX()-SSDStiffenerBoxShapes[3]->GetDX()
		 + fgkSSDConnectorPosition[0],
		 - SSDStiffenerBoxShapes[0]->GetDY()+SSDStiffenerBoxShapes[3]->GetDY(),
		   SSDStiffenerBoxShapes[0]->GetDZ()+SSDStiffenerBoxShapes[3]->GetDZ());
  SSDStiffenerBoxTrans[4] = new TGeoTranslation("SSDStiffenerBoxTrans5",
		 - SSDStiffenerBoxShapes[0]->GetDX()+fgkSSDConnectorPosition[0]
		 - 0.5*fgkSSDConnectorSeparation-2.*SSDConnectorShape->GetDX(),
		   SSDStiffenerBoxShapes[0]->GetDY()-fgkSSDConnectorPosition[1]
		 - SSDConnectorShape->GetDY(),
		   SSDStiffenerBoxShapes[0]->GetDZ()+SSDConnectorShape->GetDZ());
  SSDStiffenerBoxTrans[5] = new TGeoTranslation("SSDStiffenerBoxTrans6",
         - SSDStiffenerBoxShapes[0]->GetDX()+fgkSSDConnectorPosition[0]
		 + SSDStiffenerBoxShapes[5]->GetDX(),
		   0.,
		   SSDStiffenerBoxShapes[0]->GetDZ()+SSDStiffenerBoxShapes[5]->GetDZ());
  for(Int_t i=0; i<StiffenerBoxNumber; i++) 
		SSDStiffener->AddNode(SSDStiffenerBox[i],1,SSDStiffenerBoxTrans[i]);	
  TGeoCombiTrans* SSDStiffenerCombiTrans[SSDStiffenerNumber];
  char SSDStiffenerCombiTransName[30];
    for(Int_t i=0; i<SSDStiffenerNumber; i++){ 
	sprintf(SSDStiffenerCombiTransName,"SSDStiffenerCombiTrans%i",i+1);
    SSDStiffenerCombiTrans[i] = new TGeoCombiTrans(SSDStiffenerCombiTransName,
			0.,i*SSDStiffenerSeparation,0.,new TGeoRotation("",180*(1-i),0.,0.));
  }
////////////////////////////
// Capacitor 0603-2200 nF
///////////////////////////
  const Int_t Capacitor0603Number = 5;
  TGeoBBox* Capacitor0603Shape =  new TGeoBBox("Capacitor0603Shape",
											 0.5*fgkSSDCapacitor0603Length,
											 0.5*fgkSSDCapacitor0603Width,
											 0.5*fgkSSDCapacitor0603Height);
  TGeoVolume* Capacitor0603 = new TGeoVolume("Capacitor0603",Capacitor0603Shape,
                                             fgkSSDStiffener0603CapacitorMedium); 
  Capacitor0603->SetLineColor(fColorAl);
////////////////////////////
// Capacitor 1812-330 nF
///////////////////////////
  TGeoBBox* Capacitor1812Shape =  new TGeoBBox("Capacitor1812Shape",
											 0.5*fgkSSDCapacitor1812Length,
											 0.5*fgkSSDCapacitor1812Width,
											 0.5*fgkSSDCapacitor1812Height);
  TGeoVolume* Capacitor1812 = new TGeoVolume("Capacitor1812",Capacitor1812Shape,
                                             fgkSSDStiffener1812CapacitorMedium); 
  Capacitor1812->SetLineColor(fColorAl);
  TGeoTranslation* Capacitor1812Trans = new TGeoTranslation("Capacitor1812Trans",
			  0.,
			  0.5*fgkSSDStiffenerWidth+SSDStiffenerSeparation
	       -  Capacitor1812Shape->GetDY()-fgkSSDConnectorPosition[1],
			  SSDStiffenerBoxShapes[0]->GetDZ()+fgkSSDConnectorHeight
		   +  0.5*fgkSSDCapacitor1812Height);
////////////////////////////
//Hybrid Wire
////////////////////////////
  Double_t WireX = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
				 - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
				 - fgkSSDConnectorSeparation;
  Double_t WireY = SSDStiffenerSeparation+fgkSSDStiffenerWidth
				 - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
  Double_t SSDWireRadius = TMath::Sqrt(TMath::Power(WireX,2.)
				         + TMath::Power(WireY,2));
  Double_t WireAngle = TMath::ATan(WireX/WireY);
  TGeoTube *HybridWireShape = new TGeoTube("HybridWireShape", 0., 
						fgkSSDWireRadius, 0.5*SSDWireRadius);
  TGeoVolume* HybridWire = new TGeoVolume("HybridWire",HybridWireShape,
                                             fgkSSDStiffenerHybridWireMedium); 
  HybridWire->SetLineColor(fColorPhynox);
  TGeoCombiTrans* HybridWireCombiTrans[2];
  HybridWireCombiTrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
                   0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
				 + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
                   0.5*SSDWireRadius-0.5*fgkSSDStiffenerWidth
				 + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
				   SSDStiffenerBoxShapes[0]->GetDZ()+fgkSSDConnectorHeight
				 + fgkSSDWireRadius,
                   new TGeoRotation("HybridWireRot1",0.,90.,0.));
  HybridWireCombiTrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
				   0.,
				 - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
				   0.,	
                   new TGeoRotation("HybridWireRot2",
				 -                  WireAngle*TMath::RadToDeg(),0.,0.));
  TGeoHMatrix* HybridWireMatrix = new TGeoHMatrix();
  HybridWireMatrix->MultiplyLeft(HybridWireCombiTrans[0]);
  HybridWireMatrix->MultiplyLeft(HybridWireCombiTrans[1]);
////////////////////////////
// Stiffener Assembly
///////////////////////////
  TGeoVolume* SSDStiffenerAssembly = 
								new TGeoVolumeAssembly("SSDStiffenerAssembly");
  SSDStiffenerAssembly->AddNode(HybridWire,1,HybridWireMatrix);
  for(Int_t i=0; i<SSDStiffenerNumber; i++) {
	SSDStiffenerAssembly->AddNode(SSDStiffener,i+1,SSDStiffenerCombiTrans[i]);
	for(Int_t j=1; j<Capacitor0603Number+1; j++){
    SSDStiffenerAssembly->AddNode(Capacitor0603,Capacitor0603Number*i+j,new TGeoTranslation("",(j-3.
	)/6*fgkSSDStiffenerLength,
					i*SSDStiffenerSeparation+
					0.5*((i==0? 1:-1)*fgkSSDStiffenerWidth
					+(i==0? -1:+1)*fgkSSDCapacitor0603Width),
					-0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height)));
	}
	if(i==1) SSDStiffenerAssembly->AddNode(Capacitor1812,1,Capacitor1812Trans);
}
  return SSDStiffenerAssembly;
}
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth, 
																	char* side){
////////////////////////////////////////////////////////////////////////////////
  const Int_t SSDChipCablesLayNumber = 2;
  Int_t SSDChipCablesColor[2] = {fColorAl,fColorPolyhamide};
  Double_t SSDChipCablesRadius[2];
  SSDChipCablesRadius[0] = 0.25*(SSDChipCablesHeigth
						 -  fgkSSDChipCablesHeight[0]
						 -  fgkSSDChipCablesHeight[1]);
  SSDChipCablesRadius[1] = SSDChipCablesRadius[0]-fgkSSDChipCablesHeight[0];
  Double_t SSDChipCablesPieceLength = 0.5*(fgkSSDChipCablesWidth[0]
								    - 2.*TMath::Pi()*SSDChipCablesRadius[0]
									- SSDChipCablesRadius[0]
									- fgkSSDChipCablesWidth[1]
									- fgkSSDChipCablesWidth[2]
									- (side=="Right" ? 0 : 
									  fgkSSDModuleStiffenerPosition[1]
									+ TMath::Pi()*(0.5*fgkSSDSensorHeight
									+ fgkSSDChipCablesHeight[0]
									+ fgkSSDChipCablesHeight[1])));
  //////////////////////////
  //Box and Tube Seg Shapes
  //////////////////////////
  char* SSDChipCablesBoxShapeName[2*SSDChipCablesLayNumber] = 
					  {"SSDChipCablesBoxLay0Shape0","SSDChipCablesBoxLay0Shape1",
					   "SSDChipCablesBoxLay1Shape0","SSDChipCablesBoxLay1Shape1"};
  char* SSDChipCablesTubeSegShapeName[2*SSDChipCablesLayNumber] = 
			  {"SSDChipCablesTubeSegLay0Shape0","SSDChipCablesTubeSegLay0Shape1",
			   "SSDChipCablesTubeSegLay1Shape0","SSDChipCablesTubeSegLay1Shape1"};
  TGeoBBox** SSDChipCablesBoxShape[SSDChipCablesLayNumber];
  TGeoTubeSeg** SSDChipCablesTubeSegShape[SSDChipCablesLayNumber];
  for(Int_t i=0; i<SSDChipCablesLayNumber; i++){
    SSDChipCablesBoxShape[i]        = new TGeoBBox*[2];
    SSDChipCablesTubeSegShape[i]    = new TGeoTubeSeg*[2+(side=="Right" ? 0 : 1)];
    SSDChipCablesBoxShape[i][0]     = new TGeoBBox(SSDChipCablesBoxShapeName[2*i],
												   0.5*SSDChipCablesPieceLength,
												   0.5*fgkSSDChipCablesLength[1],
												   0.5*fgkSSDChipCablesHeight[i]);
    SSDChipCablesBoxShape[i][1]     = new TGeoBBox(SSDChipCablesBoxShapeName[2*i+1],
						   0.5*(SSDChipCablesPieceLength+SSDChipCablesRadius[0]
					 + (side=="Right" ? 0. : fgkSSDModuleStiffenerPosition[1])),		
				    0.5*fgkSSDChipCablesLength[1],0.5*fgkSSDChipCablesHeight[i]);
    SSDChipCablesTubeSegShape[i][0] = 
					   new TGeoTubeSeg(SSDChipCablesTubeSegShapeName[2*i],						
						   SSDChipCablesRadius[1]-i*fgkSSDChipCablesHeight[1],
						   SSDChipCablesRadius[i],0.5*fgkSSDChipCablesLength[1],
						   0.,180.);
    SSDChipCablesTubeSegShape[i][1] = 
					   new TGeoTubeSeg(SSDChipCablesTubeSegShapeName[2*i+1],
					         SSDChipCablesRadius[0]+i*fgkSSDChipCablesHeight[0],
							 SSDChipCablesRadius[0]+fgkSSDChipCablesHeight[0]
					 +		 i*fgkSSDChipCablesHeight[1],
							 0.5*fgkSSDChipCablesLength[1],0.,180.);
    if(side!="Right") SSDChipCablesTubeSegShape[i][2] = 
					 new TGeoTubeSeg(SSDChipCablesTubeSegShapeName[2*i],
						 0.5*fgkSSDSensorHeight+(1-i)*fgkSSDChipCablesHeight[1],
						 0.5*fgkSSDSensorHeight+(1-i)*fgkSSDChipCablesHeight[0]
					 +   fgkSSDChipCablesHeight[1],
						 0.5*fgkSSDChipCablesLength[1],0.,180.);
  }
  //////////////////////////
  //Box under Chip
  //////////////////////////
  char SSDUnderChipCablesBoxShapeName[30];
  char SSDUnderChipCablesBoxName[30];	
  char SSDUnderChipCablesBoxTransName[30];	
  TGeoBBox* SSDUnderChipCablesBoxShape[SSDChipCablesLayNumber];
  TGeoVolume* SSDUnderChipCablesBox[SSDChipCablesLayNumber]; 
  TGeoTranslation* SSDUnderChipCablesBoxTrans[SSDChipCablesLayNumber];
  for(Int_t i=0; i<SSDChipCablesLayNumber; i++){ 
		sprintf(SSDUnderChipCablesBoxShapeName,"SSDUnderChipCablesBoxShape%i",i+1);
		sprintf(SSDUnderChipCablesBoxName,"SSDUnderChipCablesBox%i",i+1);
		sprintf(SSDUnderChipCablesBoxTransName,"SSDUnderChipCablesBoxTrans%i",i+1);
		SSDUnderChipCablesBoxShape[i] = 
								   new TGeoBBox(SSDUnderChipCablesBoxShapeName,
								   0.5*fgkSSDChipWidth,
								   0.5*fgkSSDChipCablesLength[1],
								   0.5*fgkSSDChipCablesHeight[i]);
		SSDUnderChipCablesBox[i] = new TGeoVolume(SSDUnderChipCablesBoxName,
									SSDUnderChipCablesBoxShape[i],
									(i==0?fgkSSDAlTraceChipCableMedium:fgkSSDKaptonChipCableMedium));		
        SSDUnderChipCablesBox[i]->SetLineColor(SSDChipCablesColor[i]);
		SSDUnderChipCablesBoxTrans[i] = 
						new TGeoTranslation(SSDUnderChipCablesBoxTransName,
						(side=="Right"?-1.:1.)*0.5*fgkSSDChipWidth,
						0.5*(fgkSSDChipCablesLength[0]-fgkSSDChipCablesLength[1])
						+0.5*fgkSSDChipCablesLength[1],
						(i==0?1.:-1.)*0.5*fgkSSDChipCablesHeight[1-i]);
  }
  //////////////////
  //Trapezoid Shapes
  //////////////////
  const Int_t SSDChipCablesVertexNumber = 2;
  const Int_t SSDChipCablesTrapezoidNumber = 2;
  TVector3** SSDChipCablesTrapezoidVertex[SSDChipCablesVertexNumber];
  for(Int_t i = 0; i< SSDChipCablesTrapezoidNumber; i++) 
	 SSDChipCablesTrapezoidVertex[i] = new TVector3*[SSDChipCablesVertexNumber];
  //First Shape Vertex Positioning
  SSDChipCablesTrapezoidVertex[0][0] = new TVector3();
  SSDChipCablesTrapezoidVertex[0][1] = 
		new TVector3(0.5*(fgkSSDChipCablesLength[0]-fgkSSDChipCablesLength[1]));
  //Second Shape Vertex Positioning
  SSDChipCablesTrapezoidVertex[1][0] = 
							  new TVector3(*SSDChipCablesTrapezoidVertex[0][0]);
  SSDChipCablesTrapezoidVertex[1][1] = 
							  new TVector3(*SSDChipCablesTrapezoidVertex[0][1]);
  //Setting the names of shapes and volumes
  char* SSDChipCablesTrapezoidBoxShapeName[SSDChipCablesTrapezoidNumber] = 
		  {"SSDChipCablesTrapezoidBoxShape1","SSDChipCablesTrapezoidBoxShape2"};
  char* SSDChipCablesTrapezoidShapeName[SSDChipCablesTrapezoidNumber] = 
		  {"SSDChipCablesTrapezoidShape1","SSDChipCablesTrapezoidShape2"};
  char* SSDChipCablesTrapezoidBoxName[SSDChipCablesTrapezoidNumber] = 
		  {"SSDChipCablesTrapezoidBox1","SSDChipCablesTrapezoidBox2"};
  char* SSDChipCablesTrapezoidName[SSDChipCablesTrapezoidNumber] = 
		  {"SSDChipCablesTrapezoid1","SSDChipCablesTrapezoid2"};
  char* SSDChipCablesTrapezoidAssemblyName[SSDChipCablesTrapezoidNumber] = 
		  {"SSDChipCablesTrapezoidAssembly1","SSDChipCablesTrapezoidAssembly2"};
  //Setting the Shapes
  TGeoBBox* SSDChipCablesTrapezoidBoxShape[SSDChipCablesTrapezoidNumber]; 
  TGeoArb8* SSDChipCablesTrapezoidShape[SSDChipCablesTrapezoidNumber];
  //Setting the Volumes
  TGeoVolume* SSDChipCablesTrapezoidBox[SSDChipCablesTrapezoidNumber];
  TGeoVolume* SSDChipCablesTrapezoid[SSDChipCablesTrapezoidNumber];
  TGeoVolume* SSDChipCablesTrapezoidAssembly[SSDChipCablesTrapezoidNumber]; 
  Double_t SSDChipCablesTrapezoidWidth[SSDChipCablesVertexNumber] = 
   {fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2],fgkSSDChipCablesWidth[1]};
  for(Int_t i=0; i<SSDChipCablesTrapezoidNumber; i++){
    SSDChipCablesTrapezoidBoxShape[i] = 
					new TGeoBBox(SSDChipCablesTrapezoidBoxShapeName[i],
						0.5*fgkSSDChipCablesLength[1],
					    0.5*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]),
						0.5*fgkSSDChipCablesHeight[i]);
    SSDChipCablesTrapezoidShape[i] = 
							  GetTrapezoidShape(SSDChipCablesTrapezoidVertex[i],
							  SSDChipCablesTrapezoidWidth,
							  fgkSSDChipCablesHeight[i],
							  SSDChipCablesTrapezoidShapeName[i]);
    SSDChipCablesTrapezoidBox[i] = 
						new TGeoVolume(SSDChipCablesTrapezoidBoxName[i],
									   SSDChipCablesTrapezoidBoxShape[i],
									   (i==0?fgkSSDAlTraceChipCableMedium:fgkSSDKaptonChipCableMedium));
    SSDChipCablesTrapezoid[i] = new TGeoVolume(SSDChipCablesTrapezoidName[i],
											   SSDChipCablesTrapezoidShape[i],
											   (i==0?fgkSSDAlTraceChipCableMedium:fgkSSDKaptonChipCableMedium));
    SSDChipCablesTrapezoidBox[i]->SetLineColor(SSDChipCablesColor[i]);
    SSDChipCablesTrapezoid[i]->SetLineColor(SSDChipCablesColor[i]);
    SSDChipCablesTrapezoidAssembly[i] = 
				new TGeoVolumeAssembly(SSDChipCablesTrapezoidAssemblyName[i]);
    SSDChipCablesTrapezoidAssembly[i]->AddNode(SSDChipCablesTrapezoidBox[i],1,
				new TGeoTranslation(0.5*fgkSSDChipCablesLength[1],
				   0.5*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]),0.));
    SSDChipCablesTrapezoidAssembly[i]->AddNode(SSDChipCablesTrapezoid[i],0,
			new TGeoCombiTrans(0.,0.,0.,new TGeoRotation("",90.,180.,-90.)));
    SSDChipCablesTrapezoidAssembly[i]->AddNode(SSDChipCablesTrapezoid[i],1,
			new TGeoTranslation(fgkSSDChipCablesLength[1],0.,0.));
  }
  /////////////////////////////
  //Box and Tube Seg CombiTrans
  /////////////////////////////
  TGeoTranslation* SSDChipCablesBoxTrans[2*SSDChipCablesLayNumber];
  SSDChipCablesBoxTrans[0] = 
					new TGeoTranslation("SSDChipCablesLay1Box1Trans",0.,0.,0.);
  SSDChipCablesBoxTrans[1] = 
					new TGeoTranslation("SSDChipCablesLay1Box2Trans",
										 SSDChipCablesBoxShape[0][1]->GetDX()
						   -             0.5*SSDChipCablesPieceLength,
                       0.0,
						   -             2.*SSDChipCablesRadius[0]
						   -             fgkSSDChipCablesHeight[0]);
  SSDChipCablesBoxTrans[2] = new TGeoTranslation("SSDChipCablesLay2Box1Trans",
										 0.0,
										 0.0,
										 0.5*(fgkSSDChipCablesHeight[0]
						   +			 fgkSSDChipCablesHeight[1]));
  SSDChipCablesBoxTrans[3] = 
							 new TGeoTranslation("SSDChipCablesLay2Box2Trans",
										 SSDChipCablesBoxShape[1][1]->GetDX()
						   -			 0.5*SSDChipCablesPieceLength,
										 0.0,
						   -			 2.*SSDChipCablesRadius[0]
						   -			 0.5*fgkSSDChipCablesHeight[1]
						   -			 1.5*fgkSSDChipCablesHeight[0]);
  TGeoRotation* SSDChipCablesRot[3];
  SSDChipCablesRot[0] = new TGeoRotation("SSDChipCablesRot1",0.,90.,0.);
  SSDChipCablesRot[1] = new TGeoRotation("SSDChipCablesRot2",90.,90.,-90.);
  SSDChipCablesRot[2] = new TGeoRotation("SSDChipCablesRot3",90.,-90.,-90.);
  TGeoCombiTrans* SSDChipCablesTubeSegCombiTrans[2*(SSDChipCablesLayNumber+
													  (side=="Right" ? 0 : 1))];
  SSDChipCablesTubeSegCombiTrans[0] = 
				new TGeoCombiTrans("SSDChipCablesLay1TubeSeg1CombiTrans",
				0.5*SSDChipCablesPieceLength,
				0.0,
				SSDChipCablesRadius[0]
			-   0.5*fgkSSDChipCablesHeight[0],
				new TGeoRotation((*SSDChipCablesRot[1])*(*SSDChipCablesRot[0])));
  SSDChipCablesTubeSegCombiTrans[1] = 
				new TGeoCombiTrans("SSDChipCablesLay1TubeSeg2CombiTrans",
			-   0.5*SSDChipCablesPieceLength,
				0.0,
			-   SSDChipCablesRadius[0]-0.5*fgkSSDChipCablesHeight[0],
				new TGeoRotation((*SSDChipCablesRot[2])*(*SSDChipCablesRot[0])));
  SSDChipCablesTubeSegCombiTrans[2] = 
  new TGeoCombiTrans("SSDChipCablesLay2TubeSeg1CombiTrans",
				0.5*SSDChipCablesPieceLength,
				0.0,
				SSDChipCablesRadius[0]-0.5*fgkSSDChipCablesHeight[0],
				new TGeoRotation((*SSDChipCablesRot[1])*(*SSDChipCablesRot[0])));
  SSDChipCablesTubeSegCombiTrans[3] = 
				new TGeoCombiTrans("SSDChipCablesLay2TubeSeg2CombiTrans",
			-	0.5*SSDChipCablesPieceLength,
				0.0,
			-	SSDChipCablesRadius[0]+0.5*fgkSSDChipCablesHeight[0]
			-   fgkSSDChipCablesHeight[0],
				new TGeoRotation((*SSDChipCablesRot[2])*(*SSDChipCablesRot[0])));
  SSDChipCablesTubeSegCombiTrans[4] = 
				new TGeoCombiTrans("SSDChipCablesLay1TubeSeg4CombiTrans",
				0.5*SSDChipCablesPieceLength+SSDChipCablesRadius[0]
			+   fgkSSDModuleStiffenerPosition[1],
				0.0,
			-	2.*SSDChipCablesRadius[0]-0.5*fgkSSDChipCablesHeight[0]
			-   (0.5*fgkSSDSensorHeight+fgkSSDChipCablesHeight[0]
			+	fgkSSDChipCablesHeight[1]),
			new TGeoRotation((*SSDChipCablesRot[1])*(*SSDChipCablesRot[0])));
  SSDChipCablesTubeSegCombiTrans[5] = 
			new TGeoCombiTrans("SSDChipCablesLay2TubeSeg5CombiTrans",
				0.5*SSDChipCablesPieceLength+SSDChipCablesRadius[0]
			+	fgkSSDModuleStiffenerPosition[1],
				0.0,
			-	2.*SSDChipCablesRadius[0]-0.5*fgkSSDChipCablesHeight[0]
			-	(0.5*fgkSSDSensorHeight+fgkSSDChipCablesHeight[0]
			+	fgkSSDChipCablesHeight[1]),
			new TGeoRotation((*SSDChipCablesRot[1])*(*SSDChipCablesRot[0])));
  TGeoCombiTrans* SSDChipCablesTrapezoidCombiTrans[SSDChipCablesLayNumber];
  SSDChipCablesTrapezoidCombiTrans[0] = (side=="Right" ? 
			new TGeoCombiTrans("SSDChipCableLay1TrapezoidRightCombiTrans",
				0.5*SSDChipCablesPieceLength+SSDChipCablesTrapezoidWidth[0]
			+	SSDChipCablesRadius[0],
			-	0.5*fgkSSDChipCablesLength[1],
			-	fgkSSDChipCablesHeight[0]-2.*SSDChipCablesRadius[0],
			new TGeoRotation("",90.,0.,0.)) :
			new TGeoCombiTrans("SSDChipCableLay1TrapezoidLeftCombiTrans",
			-	2.*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2])
			+	0.5*SSDChipCablesPieceLength+SSDChipCablesTrapezoidWidth[0]
			+	SSDChipCablesRadius[0]+fgkSSDModuleStiffenerPosition[1],
				0.5*fgkSSDChipCablesLength[1],
			-	2.*(fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1])
			-	2.*SSDChipCablesRadius[0]-fgkSSDSensorHeight,
			new TGeoRotation("",-90.,0.,0.)));
  SSDChipCablesTrapezoidCombiTrans[1] = (side=="Right" ? 
			new TGeoCombiTrans("SSDChipCableLay2TrapezoidRightCombiTrans",
				0.5*SSDChipCablesPieceLength+SSDChipCablesTrapezoidWidth[0]
			+	SSDChipCablesRadius[0],
			-	0.5*fgkSSDChipCablesLength[1],
			-	0.5*(fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1])
			-	fgkSSDChipCablesHeight[0]-2.*SSDChipCablesRadius[0],
				new TGeoRotation("",90.,0.,0.)) :
				new TGeoCombiTrans("SSDChipCableLay2TrapezoidLeftCombiTrans",
			-	2.*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2])
			+	0.5*SSDChipCablesPieceLength+SSDChipCablesTrapezoidWidth[0]
			+	SSDChipCablesRadius[0]+fgkSSDModuleStiffenerPosition[1],
				0.5*fgkSSDChipCablesLength[1],-0.5*(fgkSSDChipCablesHeight[0]
			+	fgkSSDChipCablesHeight[1])-fgkSSDChipCablesHeight[1]
			-	fgkSSDChipCablesHeight[0]-2.*SSDChipCablesRadius[0]
			-	fgkSSDSensorHeight,new TGeoRotation("",-90.,0.,0.)));  
  //////////////////////////
  //Box and Tube Seg Volumes
  //////////////////////////
  char* SSDChipCablesBoxName[2*SSDChipCablesLayNumber] = 
							 {"SSDChipCablesLay1Box1","SSDChipCablesLay1Box2",
							  "SSDChipCablesLay2Box1","SSDChipCablesLay2Box2"};
  char* SSDChipRightCablesTubeSegName[2*SSDChipCablesLayNumber] = 
			  {"SSDChipRightCablesLay1TubeSeg1","SSDChipRightCablesLay1TubeSeg2",
			   "SSDChipRightCablesLay2TubeSeg1","SSDChipRightCablesLay2TubeSeg2"};
  char* SSDChipLeftCablesTubeSegName[2*SSDChipCablesLayNumber] = 
			  {"SSDChipLeftCablesLay1TubeSeg1","SSDChipLeftCablesLay1TubeSeg2",
			   "SSDChipLeftCablesLay2TubeSeg1","SSDChipLeftCablesLay2TubeSeg2"};
  char* SSDChipCablesLayAssemblyName[SSDChipCablesLayNumber] = 
			  {"SSDChipCablesLay1","SSDChipCablesLay2"};
  TGeoVolume** SSDChipCablesBox[SSDChipCablesLayNumber];
  TGeoVolume** SSDChipCablesTubeSeg[SSDChipCablesLayNumber];
  TGeoVolume* SSDChipCablesLayAssembly[SSDChipCablesLayNumber];
  for(Int_t i=0; i<SSDChipCablesLayNumber; i++){
    TGeoMedium* SSDChipCablesLayMed = 
            (i==0?fgkSSDAlTraceChipCableMedium:fgkSSDKaptonChipCableMedium);
    SSDChipCablesBox[i] = new TGeoVolume*[2];
    SSDChipCablesTubeSeg[i] = new TGeoVolume*[2+(side=="Right" ? 0 : 1)];
    SSDChipCablesBox[i][0] = new TGeoVolume(SSDChipCablesBoxName[2*i],
					   SSDChipCablesBoxShape[i][0],SSDChipCablesLayMed);
    SSDChipCablesBox[i][1] = new TGeoVolume(SSDChipCablesBoxName[2*i+1],
					   SSDChipCablesBoxShape[i][1],SSDChipCablesLayMed);
    SSDChipCablesTubeSeg[i][0] = new TGeoVolume(SSDChipRightCablesTubeSegName[2*i],
					   SSDChipCablesTubeSegShape[i][0],SSDChipCablesLayMed);
    SSDChipCablesTubeSeg[i][1] = new TGeoVolume(SSDChipRightCablesTubeSegName[2*i+1],
					   SSDChipCablesTubeSegShape[i][1],SSDChipCablesLayMed);
    SSDChipCablesBox[i][0]->SetLineColor(SSDChipCablesColor[i]);
    SSDChipCablesBox[i][1]->SetLineColor(SSDChipCablesColor[i]);
    SSDChipCablesTubeSeg[i][0]->SetLineColor(SSDChipCablesColor[i]);
    SSDChipCablesTubeSeg[i][1]->SetLineColor(SSDChipCablesColor[i]);
    SSDChipCablesLayAssembly[i] = new TGeoVolumeAssembly(SSDChipCablesLayAssemblyName[i]);
    SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesBox[i][0],1,
										 SSDChipCablesBoxTrans[2*i]);
    SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesBox[i][1],1,
										 SSDChipCablesBoxTrans[2*i+1]);
    SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesTubeSeg[i][0],1,
										 SSDChipCablesTubeSegCombiTrans[2*i]);
    SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesTubeSeg[i][1],1,
										 SSDChipCablesTubeSegCombiTrans[2*i+1]);
    if(side!="Right"){
      SSDChipCablesTubeSeg[i][2] = new TGeoVolume(SSDChipLeftCablesTubeSegName[2*i],
												  SSDChipCablesTubeSegShape[i][2],
												  SSDChipCablesLayMed);
      SSDChipCablesTubeSeg[i][2]->SetLineColor(SSDChipCablesColor[i]);
      SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesTubeSeg[i][2],1,
										   SSDChipCablesTubeSegCombiTrans[4+i]);
    }
    SSDChipCablesLayAssembly[i]->AddNode(SSDChipCablesTrapezoidAssembly[i],1,
										 SSDChipCablesTrapezoidCombiTrans[i]);
  }
  TGeoCombiTrans* SSDChipCablesCombiTrans[SSDChipCablesLayNumber];
  SSDChipCablesCombiTrans[0] = new TGeoCombiTrans("SSDChipCablesCombiTrans1",
					   (side=="Right" ? -1 : 1)*0.5*SSDChipCablesPieceLength,
						0.5*fgkSSDChipCablesLength[0],
					-	(2.*SSDChipCablesRadius[0]-fgkSSDChipCablesHeight[0]
					-	0.5*fgkSSDChipCablesHeight[1]),
						new TGeoRotation("",(side=="Right" ? 0 : 1)*180.,0.,0.));
  SSDChipCablesCombiTrans[1] = new TGeoCombiTrans("SSDChipCablesCombiTrans2",
						(side=="Right" ? -1 : 1)*0.5*SSDChipCablesPieceLength,
						0.5*fgkSSDChipCablesLength[0],
					-	(2.*SSDChipCablesRadius[0]-fgkSSDChipCablesHeight[0]
					-	0.5*fgkSSDChipCablesHeight[1]),
						new TGeoRotation("",(side=="Right" ? 0 : 1)*180.,0.,0.));
  TGeoVolume* SSDChipCablesAssembly = 
						new TGeoVolumeAssembly("SSDChipCables");
  for(Int_t i=0; i<SSDChipCablesLayNumber; i++){ 
		SSDChipCablesAssembly->AddNode(SSDChipCablesLayAssembly[i],1,
													SSDChipCablesCombiTrans[i]);
		SSDChipCablesAssembly->AddNode(SSDUnderChipCablesBox[i],1,SSDUnderChipCablesBoxTrans[i]);
  }
  return SSDChipCablesAssembly;
}
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCablesAssembly(Double_t SSDChipCablesHeigth){
////////////////////////////////////////////////////////////////////////////////
  const Int_t ChipCablesNumber = 2;
  Double_t ChipCablesTransVector = fgkSSDSensorLength
								 - 2.*fgkSSDModuleStiffenerPosition[1]
								 - 2.*(fgkSSDStiffenerWidth
								 - fgkSSDStiffenerToChipDist-fgkSSDChipWidth);
  char* SSDChipCablesName[ChipCablesNumber] = {"Right","Left"};
  TGeoVolume* SSDChipCables[ChipCablesNumber];  
  TGeoVolume* SSDChipCablesAssembly = 
					 new TGeoVolumeAssembly("SSDChipCablesAssembly");
  for(Int_t i=0; i<ChipCablesNumber; i++) SSDChipCables[i] = 
					 GetSSDChipCables(SSDChipCablesHeigth,SSDChipCablesName[i]);
  for(Int_t i=0; i<ChipCablesNumber; i++)
    for(Int_t j=0; j<fgkSSDChipNumber; j++)
      SSDChipCablesAssembly->AddNode(SSDChipCables[i],fgkSSDChipNumber*i+j+1,
			new TGeoTranslation(-(SSDChipCablesName[i]=="Left" ? 1. : 0.)
		*	ChipCablesTransVector,(j-0.5)*fgkSSDChipCablesLength[0]
		+	0.5*fgkSSDChipCablesLength[1],0.));
  return SSDChipCablesAssembly;
}
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetSSDFlex(Double_t SSDFlexRadius, Double_t SSDFlexHeigth){
////////////////////////////////////////////////////////////////////////////////  
  const Int_t SSDFlexVolumeNumber = 3;
  TGeoVolume* SSDFlexVolume[SSDFlexVolumeNumber];
  ////////////////////////
  // Setting Display Color
  ////////////////////////
  Int_t SSDFlexColor;
  SSDFlexColor = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fColorAl: fColorPolyhamide);
  TGeoMedium* SSDFlexMed = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fgkSSDAlTraceFlexMedium :
                            fgkSSDKaptonFlexMedium);
  ////////////////////////
  // SSDFlexTrapezoidShape
  ////////////////////////
  const Int_t SSDFlexVertexNumber = 2;
  Double_t SSDFlexWidth[SSDFlexVertexNumber] = {fgkSSDFlexWidth[1],
												fgkSSDFlexWidth[0]};
  TVector3* SSDFlexVertex[SSDFlexVertexNumber];
  SSDFlexVertex[0] = new TVector3();
  SSDFlexVertex[1] = new TVector3(fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
  TGeoArb8* SSDFlexTrapezoidShape = GetTrapezoidShape(SSDFlexVertex,
													  SSDFlexWidth,SSDFlexHeigth,
													  "SSDFlexTrapezoidShape");
  SSDFlexVolume[0] = new TGeoVolume("SSDFlexTrapezoid",SSDFlexTrapezoidShape,SSDFlexMed);
  SSDFlexVolume[0]->SetLineColor(SSDFlexColor);
  /////////////////////////
  //SSDFlexTubeSeg Assembly
  /////////////////////////
  const Int_t SSDFlexTubeSegNumber = 2;
  TGeoTubeSeg* SSDFlexTubeSegShape[SSDFlexTubeSegNumber];
  Double_t SSDFlexRadiusMax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
							/  TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
  SSDFlexTubeSegShape[0] = new TGeoTubeSeg("SSDFlexTubeSegShape1",
						   SSDFlexRadius,SSDFlexRadius+SSDFlexHeigth,
						   0.5*fgkSSDFlexWidth[0],0.,180.);
  SSDFlexTubeSegShape[1] = new TGeoTubeSeg("SSDFlexTubeSegShape2",
						   SSDFlexRadiusMax-SSDFlexRadius-SSDFlexHeigth,
						   SSDFlexRadiusMax-SSDFlexRadius,0.5*fgkSSDFlexWidth[0],
						   0.,2.*fgkSSDFlexAngle);
  TGeoRotation** SSDFlexTubSegRot[SSDFlexTubeSegNumber];
  for(Int_t i = 0; i<SSDFlexTubeSegNumber; i++) 
									  SSDFlexTubSegRot[i] = new TGeoRotation*[2]; 
  SSDFlexTubSegRot[0][0] = new TGeoRotation("SSDFlexTubeSeg1Rot1", 0., 90.,  0.);
  SSDFlexTubSegRot[0][1] = new TGeoRotation("SSDFlexTubeSeg1Rot2",90., 90.,-90.);
  SSDFlexTubSegRot[1][0] = new TGeoRotation("SSDFlexTubeSeg2Rot1", 0.,-90.,  0.);
  SSDFlexTubSegRot[1][1] = new TGeoRotation("SSDFlexTubeSeg2Rot2",90., 90.,-90.);
  TGeoCombiTrans* SSDFlexTubeSegCombiTrans[SSDFlexTubeSegNumber];
  SSDFlexTubeSegCombiTrans[0] = new TGeoCombiTrans("SSDFlexTubeSegCombiTrans1",
								fgkSSDFlexLength[0],0.5*fgkSSDFlexWidth[0],
								SSDFlexRadius+0.5*SSDFlexHeigth,
								new TGeoRotation((*SSDFlexTubSegRot[0][1])
							*	(*SSDFlexTubSegRot[0][0])));
  SSDFlexTubeSegCombiTrans[1] = new TGeoCombiTrans("SSDFlexTubeSegCombiTrans2",
								fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
								0.5*fgkSSDFlexWidth[0],
								SSDFlexRadiusMax+0.5*SSDFlexHeigth+SSDFlexRadius,
								new TGeoRotation((*SSDFlexTubSegRot[1][1])
							*	(*SSDFlexTubSegRot[1][0])));
  SSDFlexVolume[1] = new TGeoVolumeAssembly("SSDFlexTubeSegAssembly");
  TGeoVolume* SSDFlexTubeSeg[SSDFlexTubeSegNumber];
  char SSDFlexTubeSegName[30];
  for(Int_t i=0; i<SSDFlexTubeSegNumber; i++){ 
		sprintf(SSDFlexTubeSegName,"SSDFlexTubeSeg%i",i+1);
		SSDFlexTubeSeg[i] = new TGeoVolume(SSDFlexTubeSegName,SSDFlexTubeSegShape[i],
                                     SSDFlexMed);
		SSDFlexTubeSeg[i]->SetLineColor(SSDFlexColor);
        SSDFlexVolume[1]->AddNode(SSDFlexTubeSeg[i],1,SSDFlexTubeSegCombiTrans[i]);
  }
  ///////////
  //Box Shape 
  ///////////
  const Int_t SSDFlexBoxNumber = 7;
  Double_t SSDFlexBoxLength[SSDFlexBoxNumber];
  SSDFlexBoxLength[0] = 0.5*(fgkSSDChipNumber
					  *	fgkSSDChipLength+(fgkSSDChipNumber-1)
					  *	fgkSSDChipSeparationLength
					  - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
					  - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
  SSDFlexBoxLength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
  SSDFlexBoxLength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
					  -	fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth); 	
  SSDFlexBoxLength[3] = fgkSSDFlexHoleWidth;	
  SSDFlexBoxLength[4] = fgkSSDFlexLength[1]-SSDFlexBoxLength[0]
					  -	SSDFlexBoxLength[1];
  SSDFlexBoxLength[5] = fgkSSDFlexLength[2];	
  SSDFlexBoxLength[6] = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
					  *	TMath::DegToRad()*SSDFlexRadiusMax
					  - fgkSSDFlexLength[2]-TMath::Pi()
					  *	fgkSSDStiffenerHeight-fgkSSDFlexLength[0];	
  Double_t SSDFlexBoxWidth[SSDFlexBoxNumber];
  SSDFlexBoxWidth[0] = fgkSSDFlexWidth[0];
  SSDFlexBoxWidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
  SSDFlexBoxWidth[2] = fgkSSDFlexHoleWidth;
  SSDFlexBoxWidth[3] = SSDFlexBoxWidth[2]-fgkSSDFlexHoleLength;
  SSDFlexBoxWidth[4] = fgkSSDFlexWidth[0];
  SSDFlexBoxWidth[5] = fgkSSDFlexWidth[0];
  SSDFlexBoxWidth[6] = fgkSSDFlexWidth[0];
  TGeoBBox* SSDFlexBoxShape[SSDFlexBoxNumber+1];
  for(Int_t i=0; i<SSDFlexBoxNumber+1; i++) SSDFlexBoxShape[i] = 
						(i!= SSDFlexBoxNumber ? new TGeoBBox("SSDFlexBoxShape",
								0.5*SSDFlexBoxLength[i],
								0.5*SSDFlexBoxWidth[i],0.5*SSDFlexHeigth) : 
								SSDFlexBoxShape[2]);
  //////////////////////////////
  //SSDFlex Box Shape CombiTrans 
  //////////////////////////////
  TGeoCombiTrans* SSDFlexBoxCombiTrans[SSDFlexBoxNumber+1];
  SSDFlexBoxCombiTrans[0] = new TGeoCombiTrans("SSDFlexBoxCombiTrans0",
								SSDFlexVertex[1]->X()+0.5*SSDFlexBoxLength[0],
								0.5*fgkSSDFlexWidth[0],0.,0);
  SSDFlexBoxCombiTrans[1] = new TGeoCombiTrans("SSDFlexBoxCombiTrans1",
								SSDFlexVertex[1]->X()+SSDFlexBoxLength[0]
							+	0.5*SSDFlexBoxLength[1],
								fgkSSDFlexHoleWidth+0.5*SSDFlexBoxWidth[1],0.,0);
  SSDFlexBoxCombiTrans[2] = new TGeoCombiTrans("SSDFlexBoxCombiTrans2",
								SSDFlexVertex[1]->X()+SSDFlexBoxLength[0]
							+	fgkSSDFlexHoleLength+0.5*SSDFlexBoxLength[2],
								0.5*SSDFlexBoxWidth[2],0.,0);
  SSDFlexBoxCombiTrans[3] = new TGeoCombiTrans("SSDFlexBoxCombiTrans3",
								SSDFlexVertex[1]->X()+SSDFlexBoxLength[0]
							+	fgkSSDFlexHoleLength+SSDFlexBoxLength[2]
							+	0.5*fgkSSDFlexHoleWidth,
								fgkSSDFlexHoleLength+0.5*SSDFlexBoxWidth[3],0.,0);
  SSDFlexBoxCombiTrans[4] = new TGeoCombiTrans("SSDFlexBoxCombiTrans4",
								SSDFlexVertex[1]->X()+SSDFlexBoxLength[0]
							+	SSDFlexBoxLength[1]+0.5*SSDFlexBoxLength[4],
								0.5*fgkSSDFlexWidth[0],0.,0);
  SSDFlexBoxCombiTrans[5] = new TGeoCombiTrans("SSDFlexBoxCombiTrans5",
							-	0.5*fgkSSDFlexLength[2]+fgkSSDFlexLength[0],
								0.5*fgkSSDFlexWidth[0],
								2.*SSDFlexRadius+SSDFlexHeigth,0);
  SSDFlexBoxCombiTrans[6] = new TGeoCombiTrans("SSDFlexBoxCombiTrans6",
							-	SSDFlexBoxShape[6]->GetDX()
							+	SSDFlexBoxShape[6]->GetDX()
							*	TMath::Cos(2.*fgkSSDFlexAngle*TMath::DegToRad())
							+	fgkSSDFlexLength[0]-fgkSSDFlexLength[2]
							-	(SSDFlexRadiusMax-SSDFlexRadius-0.5*SSDFlexHeigth)
							*	TMath::Cos(fgkSSDFlexAngle*TMath::DegToRad()),
								0.5*fgkSSDFlexWidth[0],SSDFlexBoxShape[6]->GetDX()
								*TMath::Sin(2.*fgkSSDFlexAngle*TMath::DegToRad())
							+	SSDFlexHeigth+2.*SSDFlexRadius+(SSDFlexRadiusMax
							-	SSDFlexRadius-0.5*SSDFlexHeigth)
							*	TMath::Sin(fgkSSDFlexAngle*TMath::DegToRad()),
								new TGeoRotation("",90.,2.*fgkSSDFlexAngle,-90.));
  SSDFlexBoxCombiTrans[7] = new TGeoCombiTrans("SSDFlexBoxCombiTrans7",
								SSDFlexVertex[1]->X()+SSDFlexBoxLength[0]
							+	fgkSSDFlexHoleLength+1.5*SSDFlexBoxLength[2]
							+	SSDFlexBoxLength[3],
								0.5*SSDFlexBoxWidth[2],0.,0);
  ////////////////////////////
  //SSDFlex Box Shape Assembly 
  ////////////////////////////
  SSDFlexVolume[2] = new TGeoVolumeAssembly("SSDFlexBoxAssembly");
  TGeoVolume* SSDFlexBox[SSDFlexBoxNumber+1];
  TGeoVolume* SSDEndFlex = GetSSDEndFlex(SSDFlexBoxLength[6],SSDFlexHeigth);
  TGeoHMatrix* SSDEndFlexHMatrix = new TGeoHMatrix();
  TGeoRotation* SSDEndFlexRot= new TGeoRotation("SSDEndFlexRot",180.,0.,0);
  SSDEndFlexHMatrix->MultiplyLeft(SSDEndFlexRot);
  SSDEndFlexHMatrix->MultiplyLeft(SSDFlexBoxCombiTrans[6]);
  char SSDFlexBoxName[30];
  for(Int_t i=0; i<SSDFlexBoxNumber+1; i++){
	sprintf(SSDFlexBoxName,"SSDFlexBox%i",i!=SSDFlexBoxNumber?i+1:7);
	if(i==6){SSDFlexVolume[2]->AddNode(SSDEndFlex,1,SSDEndFlexHMatrix);}
	else{
    SSDFlexBox[i] = new TGeoVolume(SSDFlexBoxName,SSDFlexBoxShape[i],
                                   SSDFlexMed);
	SSDFlexBox[i]->SetLineColor(SSDFlexColor);
	SSDFlexVolume[2]->AddNode(SSDFlexBox[i],1,SSDFlexBoxCombiTrans[i]);}
 }
  //////////////////////
  //SSDFlex Construction
  //////////////////////
  TGeoVolume* SSDFlex = new TGeoVolumeAssembly("SSDFlex");
  for(Int_t i =0; i<SSDFlexVolumeNumber; i++) SSDFlex->AddNode(SSDFlexVolume[i],1);
  return SSDFlex;
}
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(Double_t SSDEndFlexLength, 
														Double_t SSDFlexHeigth){
  /////////////////////////////////////////
  // Setting Display Color, Media and Index
  /////////////////////////////////////////
  Int_t SSDFlexColor;
  SSDFlexColor = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fColorAl: fColorPolyhamide);
  TGeoMedium* SSDFlexMed = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fgkSSDAlTraceFlexMedium :
                            fgkSSDKaptonFlexMedium);
  ////////////////////////
  const Int_t SSDEndFlexBoxNumber = 5;
  TGeoBBox* SSDEndFlexBBoxShape[SSDEndFlexBoxNumber];
  SSDEndFlexBBoxShape[0] = new TGeoBBox("SSDFlexBoxShape1",
								   0.5*SSDEndFlexLength,0.5*fgkSSDFlexWidth[0],
								   0.5*SSDFlexHeigth);
  SSDEndFlexBBoxShape[1] = new TGeoBBox("SSDFlexBoxShape2",
				    0.5*fgkSSDEndFlexCompLength[1],
					0.5*(fgkSSDEndFlexCompWidth[0]-fgkSSDFlexWidth[0])/2,
					0.5*SSDFlexHeigth);
  SSDEndFlexBBoxShape[2] = new TGeoBBox("SSDFlexBoxShape3",
				    0.5*fgkSSDEndFlexCompLength[2],
					0.5*(fgkSSDEndFlexCompWidth[1]-fgkSSDFlexWidth[0])/2,
					0.5*SSDFlexHeigth);
  SSDEndFlexBBoxShape[3] = new TGeoBBox("SSDFlexBoxShape4",
				    0.5*fgkSSDEndFlexCompLength[3],
					0.5*(fgkSSDEndFlexCompWidth[0]-fgkSSDFlexWidth[0])/2,
					0.5*SSDFlexHeigth);
  SSDEndFlexBBoxShape[4] = new TGeoBBox("SSDFlexBoxShape5",
				    0.5*(fgkSSDEndFlexCompLength[4]+fgkSSDEndFlexCompLength[5]),
					0.25*(fgkSSDEndFlexCompWidth[2]-fgkSSDFlexWidth[0])/2,
					0.5*SSDFlexHeigth);
  TGeoVolume* SSDEndFlexBBox[SSDEndFlexBoxNumber];  
  char SSDEndFlexBBoxName[30];
  for(Int_t i=0; i<SSDEndFlexBoxNumber; i++){
	sprintf(SSDEndFlexBBoxName,"SSDEndFlexBBox%i",i+1);
	SSDEndFlexBBox[i] = new TGeoVolume(SSDEndFlexBBoxName,
                     SSDEndFlexBBoxShape[i],
                     SSDFlexMed);
	SSDEndFlexBBox[i]->SetLineColor(SSDFlexColor);
  }
  TGeoVolume* SSDEndFlex = new TGeoVolumeAssembly("SSDEndFlex");
  Double_t PartialSumLength = 0.;
  for(Int_t i=0; i<SSDEndFlexBoxNumber+1; i++) PartialSumLength += fgkSSDEndFlexCompLength[i];
  Double_t ReferenceLength = SSDEndFlexLength-PartialSumLength;
  SSDEndFlex->AddNode(SSDEndFlexBBox[0],1);
  SSDEndFlex->AddNode(SSDEndFlexBBox[1],1,new TGeoTranslation(
					-  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
					+  0.5*fgkSSDEndFlexCompLength[1],
					   0.5*fgkSSDFlexWidth[0]+SSDEndFlexBBoxShape[1]->GetDY(),
					   0.));
  SSDEndFlex->AddNode(SSDEndFlexBBox[1],2,new TGeoTranslation(
					-  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
					+  0.5*fgkSSDEndFlexCompLength[1],
					-  0.5*fgkSSDFlexWidth[0]-SSDEndFlexBBoxShape[1]->GetDY(),
					   0.));
  SSDEndFlex->AddNode(SSDEndFlexBBox[2],1,new TGeoTranslation(
					-  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
					+  fgkSSDEndFlexCompLength[1]+0.5*fgkSSDEndFlexCompLength[2],
					+  0.5*fgkSSDFlexWidth[0]+SSDEndFlexBBoxShape[2]->GetDY(),
					   0.));
  SSDEndFlex->AddNode(SSDEndFlexBBox[2],2,new TGeoTranslation(
					-  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
					+  fgkSSDEndFlexCompLength[1]+0.5*fgkSSDEndFlexCompLength[2],
					-  0.5*fgkSSDFlexWidth[0]-SSDEndFlexBBoxShape[2]->GetDY(),
					   0.));
  SSDEndFlex->AddNode(SSDEndFlexBBox[3],1,new TGeoTranslation(
					-  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
					+  fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
					+  0.5*fgkSSDEndFlexCompLength[3],
					+  0.5*fgkSSDFlexWidth[0]+SSDEndFlexBBoxShape[3]->GetDY(),
					   0.));
  SSDEndFlex->AddNode(SSDEndFlexBBox[3],2,new TGeoTranslation(
					-  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
					+  fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
					+  0.5*fgkSSDEndFlexCompLength[3],
					-  0.5*fgkSSDFlexWidth[0]-SSDEndFlexBBoxShape[3]->GetDY(),
					   0.));
  SSDEndFlex->AddNode(SSDEndFlexBBox[4],1,new TGeoTranslation(
					-  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
					+  fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
					+  fgkSSDEndFlexCompLength[3]+0.5*(fgkSSDEndFlexCompLength[4]+fgkSSDEndFlexCompLength[5]),
					+  0.5*fgkSSDFlexWidth[0]+SSDEndFlexBBoxShape[4]->GetDY(),
					   0.));
  SSDEndFlex->AddNode(SSDEndFlexBBox[4],2,new TGeoTranslation(
					-  0.5*SSDEndFlexLength+ReferenceLength+fgkSSDEndFlexCompLength[0]
					+  fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
					+  fgkSSDEndFlexCompLength[3]+0.5*(fgkSSDEndFlexCompLength[4]
					+  fgkSSDEndFlexCompLength[5]),
					-  0.5*fgkSSDFlexWidth[0]-SSDEndFlexBBoxShape[4]->GetDY(),
					   0.));
  return SSDEndFlex;
}
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetSSDFlexAssembly(){
////////////////////////////////////////////////////////////////////////////////
  TGeoVolume* SSDFlexAssembly = new TGeoVolumeAssembly("SSDFlexAssembly");
  const Int_t SSDFlexLayerNumber = 4;
  Double_t SSDFlexHeight[SSDFlexLayerNumber];
  Double_t SSDFlexRadius[SSDFlexLayerNumber];
  TGeoTranslation* SSDFlexTrans[SSDFlexLayerNumber];
  for(Int_t i=0; i<SSDFlexLayerNumber; i++){ 
    SSDFlexHeight[i] = (i%2==0 ? fgkSSDFlexHeight[0] : fgkSSDFlexHeight[1]);
    SSDFlexRadius[i] = (i==0 ? fgkSSDStiffenerHeight : SSDFlexRadius[i-1]
					 +					   SSDFlexHeight[i-1]);
    SSDFlexTrans[i]  = new TGeoTranslation(0.,0.,-0.5*i*(SSDFlexHeight[0]
					 +					   SSDFlexHeight[1])); 
    SSDFlexAssembly->AddNode(GetSSDFlex(SSDFlexRadius[i],SSDFlexHeight[i]),i+1,
										   SSDFlexTrans[i]);   
  }
  return SSDFlexAssembly;
}
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlockAssembly(){
////////////////////////////////////////////////////////////////////////////////
  const Int_t SSDCoolingBlockTransNumber = 2;
  Double_t SSDCoolingBlockTransVector[SSDCoolingBlockTransNumber] = 
					{fgkSSDModuleSensorSupportDistance+fgkSSDCoolingBlockLength,
					 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
				-	 fgkSSDCoolingBlockWidth};
  TGeoVolume* SSDCoolingBlock = GetSSDCoolingBlock();
  TGeoVolume* SSDCoolingBlockAssembly = 
							  new TGeoVolumeAssembly("SSDCoolingBlockAssembly");
  for(Int_t i=0; i<SSDCoolingBlockTransNumber; i++)
    for(Int_t j=0; j<SSDCoolingBlockTransNumber; j++) 
		SSDCoolingBlockAssembly->AddNode(SSDCoolingBlock,
						  SSDCoolingBlockTransNumber*i+j+1,
						  new TGeoTranslation(i*SSDCoolingBlockTransVector[0],
						  j*SSDCoolingBlockTransVector[1],0.));
  return SSDCoolingBlockAssembly;
}
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(){
/////////////////////////////////////////////////////////////////////////////////
  // Center Cooling Block Hole
  ////////////////////////////
  Double_t CoolingBlockHoleAngle = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
							/fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
  Double_t CoolingBlockHoleWidth = fgkSSDCoolingBlockWidth;
  /*TGeoTubeSeg* CoolingBlockHoleShape = */ new TGeoTubeSeg("CoolingBlockHoleShape",
						0.,
						fgkSSDCoolingBlockHoleRadius[0],
						0.5*CoolingBlockHoleWidth,
						180.-CoolingBlockHoleAngle,360.+CoolingBlockHoleAngle);
  TVector3* CoolingBlockHoleVertex[3];
  CoolingBlockHoleVertex[0] = new TVector3();
  CoolingBlockHoleVertex[1] = new TVector3(fgkSSDCoolingBlockHoleRadius[0]
					*	TMath::Cos((90.-CoolingBlockHoleAngle)*TMath::DegToRad()),
						fgkSSDCoolingBlockHoleRadius[0]
					*	TMath::Sin((90.-CoolingBlockHoleAngle)*TMath::DegToRad()));
  CoolingBlockHoleVertex[2] = new TVector3(CoolingBlockHoleVertex[1]->X(),
					-	CoolingBlockHoleVertex[1]->Y());
  /* TGeoArb8* CoolingBlockTriangleHoleShape = */
						GetTriangleShape(CoolingBlockHoleVertex,
						CoolingBlockHoleWidth,"CoolingBlockTriangleHoleShape");
  TGeoRotation* CoolingBlockHoleRot = 
							  new TGeoRotation("CoolingBlockHoleRot",90,0.,0.);
  CoolingBlockHoleRot->RegisterYourself();
  /* TGeoCompositeShape* CoolingTubeHoleShape  = */ 
                              new TGeoCompositeShape("CoolingTubeHoleShape",
							  "CoolingBlockTriangleHoleShape:CoolingBlockHoleRot+"
							  "CoolingBlockHoleShape");
  ///////////////////////////
  // Cooling Block Trapezoids
  ///////////////////////////
  const Int_t VertexNumber = 4;
  const Int_t TrapezoidNumber = 2;
  TVector3** CoolingBlockTrapezoidVertex[TrapezoidNumber];
  for(Int_t i = 0; i<TrapezoidNumber; i++) CoolingBlockTrapezoidVertex[i] = 
						new TVector3*[VertexNumber]; 
  Double_t CoolingBlockComponentHeight    = fgkSSDCoolingBlockHeight[0]
				    -	fgkSSDCoolingBlockHoleCenter
					-	fgkSSDCoolingBlockHoleRadius[0]
					*	TMath::Sin(CoolingBlockHoleAngle*TMath::DegToRad());
  Double_t CoolingBlockTrapezoidLength[TrapezoidNumber] = 
					{	fgkSSDCoolingBlockLength,
						0.5*(fgkSSDCoolingBlockLength-2.
					*	(fgkSSDCoolingBlockHoleLength[1]
					-	fgkSSDCoolingBlockHoleRadius[1])
					-	fgkSSDCoolingBlockHoleLength[0])}; 
  Double_t CoolingBlockTrapezoidHeigth[TrapezoidNumber] = 
					{	fgkSSDCoolingBlockHeight[0]-CoolingBlockComponentHeight
					-	fgkSSDCoolingBlockHeight[1]-fgkSSDCoolingBlockHeight[2]
					-	fgkSSDCoolingBlockHoleRadius[1],
						CoolingBlockComponentHeight};
  Double_t CoolingBlockTrapezoidWidth[TrapezoidNumber]  = 
						{fgkSSDCoolingBlockWidth,fgkSSDCoolingBlockWidth};
  //////////////////////////
  //Vertex Positioning Shape 
  //////////////////////////
  CoolingBlockTrapezoidVertex[0][0] = new TVector3();
  CoolingBlockTrapezoidVertex[0][1] = new TVector3(CoolingBlockTrapezoidLength[0]);
  CoolingBlockTrapezoidVertex[0][2] = new TVector3(
						0.5*(CoolingBlockTrapezoidVertex[0][1]->X()
					-	2.*CoolingBlockTrapezoidLength[1]
					-	fgkSSDCoolingBlockHoleLength[0]));
  CoolingBlockTrapezoidVertex[0][3] = 
						new TVector3(CoolingBlockTrapezoidVertex[0][1]->X()
					-	CoolingBlockTrapezoidVertex[0][2]->X());
  CoolingBlockTrapezoidVertex[1][0] = new TVector3(); 
  CoolingBlockTrapezoidVertex[1][1] = new TVector3(CoolingBlockTrapezoidLength[1]);
  CoolingBlockTrapezoidVertex[1][2] = 
						new TVector3(CoolingBlockTrapezoidHeigth[1]
					/				 CoolingBlockTrapezoidHeigth[0]
					*	CoolingBlockTrapezoidVertex[0][2]->X());
  CoolingBlockTrapezoidVertex[1][3] = 
						new TVector3(CoolingBlockTrapezoidVertex[1][1]->X());
  char* CoolingBlockTrapezoidShapeName[TrapezoidNumber] = 
					{"CoolingBlockTrapezoidShape0","CoolingBlockTrapezoidShape1"};
  TGeoArb8* CoolingBlockTrapezoidShape[TrapezoidNumber];
  for(Int_t i = 0; i< TrapezoidNumber; i++) CoolingBlockTrapezoidShape[i] = 
						GetArbShape(CoolingBlockTrapezoidVertex[i],
						CoolingBlockTrapezoidWidth,
						CoolingBlockTrapezoidHeigth[i],
						CoolingBlockTrapezoidShapeName[i]);
  TGeoTranslation* CoolingBlockTrapezoidTrans = 
						new TGeoTranslation("CoolingBlockTrapezoidTrans",
						CoolingBlockTrapezoidVertex[0][2]->X(),
						0.0,
						0.5*(CoolingBlockTrapezoidHeigth[0]
					+	CoolingBlockTrapezoidHeigth[1]));
  CoolingBlockTrapezoidTrans->RegisterYourself();
  TGeoCombiTrans* CoolingBlockTrapezoidCombiTrans = 
						new TGeoCombiTrans("CoolingBlockTrapezoidCombiTrans",
						CoolingBlockTrapezoidVertex[0][3]->X(),
						fgkSSDCoolingBlockWidth,
						0.5*(CoolingBlockTrapezoidHeigth[0]
					+	CoolingBlockTrapezoidHeigth[1]),
						new TGeoRotation("",180.,0.,0.));
  CoolingBlockTrapezoidCombiTrans->RegisterYourself();
  /* TGeoCompositeShape* CoolingBlockTrapezoidCompositeShape = */ 
	new TGeoCompositeShape("CoolingBlockTrapezoidCompositeShape",
	"CoolingBlockTrapezoidShape0+CoolingBlockTrapezoidShape1:CoolingBlockTrapezoidTrans+"
	"CoolingBlockTrapezoidShape1:CoolingBlockTrapezoidCombiTrans"); 
  /////////////////////////////
  // Cooling Block Boxes Shapes
  /////////////////////////////
  const Int_t BoxNumber = 3;
  TGeoBBox* CoolingBlockBoxShape[BoxNumber];
  CoolingBlockBoxShape[0] = new TGeoBBox("CoolingBlockBoxShape0",
						0.5*fgkSSDCoolingBlockLength,
						0.5*fgkSSDCoolingBlockWidth,
						0.5*fgkSSDCoolingBlockHoleRadius[1]);
  CoolingBlockBoxShape[1] = new TGeoBBox("CoolingBlockBoxShape1",
						0.5*(fgkSSDCoolingBlockLength
					-	2.*fgkSSDCoolingBlockHoleLength[1]),
						0.5*fgkSSDCoolingBlockWidth,
						0.5*fgkSSDCoolingBlockHeight[2]);
  CoolingBlockBoxShape[2] = new TGeoBBox("CoolingBlockBoxShape2",
						0.5*fgkSSDCoolingBlockLength,
						0.5*fgkSSDCoolingBlockWidth,
						0.5*fgkSSDCoolingBlockHeight[1]);
  TGeoTranslation* CoolingBlockBoxTrans[BoxNumber-1];
  CoolingBlockBoxTrans[0] = new TGeoTranslation("CoolingBlockBoxTrans0",0.,0.,
						0.5*(fgkSSDCoolingBlockHeight[1]
					+	fgkSSDCoolingBlockHoleRadius[1])
					+	fgkSSDCoolingBlockHeight[2]);
  CoolingBlockBoxTrans[1] = new TGeoTranslation("CoolingBlockBoxTrans1",
						0.0,
						0.0,
						0.5*(fgkSSDCoolingBlockHeight[1]
					+	fgkSSDCoolingBlockHeight[2]));
  for(Int_t i=0; i<BoxNumber-1; i++) CoolingBlockBoxTrans[i]->RegisterYourself();
  /* TGeoCompositeShape* CoolingBlockBoxCompositeShape = */
	new TGeoCompositeShape("CoolingBlockBoxCompositeShape",
						   "CoolingBlockBoxShape0:CoolingBlockBoxTrans0+"
	 "CoolingBlockBoxShape1:CoolingBlockBoxTrans1+CoolingBlockBoxShape2");
  ///////////////////////
  // Cooling Block Shape
  //////////////////////
  TGeoCombiTrans* CoolingTubeHoleShapeCombiTrans = 
						new TGeoCombiTrans("CoolingTubeHoleShapeCombiTrans",
						0.5*fgkSSDCoolingBlockLength,
						0.5*fgkSSDCoolingBlockWidth,
						fgkSSDCoolingBlockHoleCenter,
						new TGeoRotation("",0.,90.,0.));
  CoolingTubeHoleShapeCombiTrans->RegisterYourself();
  TGeoTranslation* CoolingBlockTrapezoidCompositeShapeTrans = 
						new TGeoTranslation("CoolingBlockTrapezoidCompositeShapeTrans",
						0.0,
						0.0,
						0.5*CoolingBlockTrapezoidHeigth[0]+fgkSSDCoolingBlockHeight[1]+
						fgkSSDCoolingBlockHeight[2]+fgkSSDCoolingBlockHoleRadius[1]);
  CoolingBlockTrapezoidCompositeShapeTrans->RegisterYourself();
  TGeoTranslation* CoolingBlockBoxCompositeShapeTrans = 
						new TGeoTranslation("CoolingBlockBoxCompositeShapeTrans",
						0.5*fgkSSDCoolingBlockLength,
						0.5*fgkSSDCoolingBlockWidth,
						0.5*fgkSSDCoolingBlockHeight[1]);
  CoolingBlockBoxCompositeShapeTrans->RegisterYourself();
  TGeoCompositeShape* SSDCoolingBlockShape = 
		new TGeoCompositeShape("SSDCoolingBlockShape",	
		"CoolingBlockBoxCompositeShape:CoolingBlockBoxCompositeShapeTrans+"
		"CoolingBlockTrapezoidCompositeShape:CoolingBlockTrapezoidCompositeShapeTrans-"
		"CoolingTubeHoleShape:CoolingTubeHoleShapeCombiTrans");
  TGeoVolume* SSDCoolingBlock = new TGeoVolume("SSDCoolingBlock",
		SSDCoolingBlockShape,fgkSSDAlCoolBlockMedium);
  return SSDCoolingBlock;
}
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
////////////////////////////////////////////////////////////////////////////////
  const Int_t VertexNumber = 4;
  TVector3* Vertex[VertexNumber];
  Vertex[0] = new TVector3();
  Vertex[1] = new TVector3(fgkCarbonFiberJunctionLength,0.);
  Vertex[2] = new TVector3(fgkCarbonFiberJunctionLength
	        -	  fgkCarbonFiberJunctionEdge[1]
			*	  TMath::Cos(fgkCarbonFiberJunctionAngle[1]*TMath::DegToRad()),
				  fgkCarbonFiberJunctionEdge[1]*TMath::Sin(fgkCarbonFiberJunctionAngle[1]
			*     TMath::DegToRad()));
  Vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
			*	  TMath::Cos(fgkCarbonFiberJunctionAngle[0]*TMath::DegToRad()),
				  fgkCarbonFiberJunctionEdge[0]
			*	  TMath::Sin(fgkCarbonFiberJunctionAngle[0]*TMath::DegToRad()));
  TGeoArb8* CarbonFiberJunctionShapePiece = 
						new TGeoArb8("CarbonFiberJunctionShapePiece",0.5*width);
  //////////////////////////////////
  //Setting the vertices in TGeoArb8
  //////////////////////////////////
  for(Int_t i = 0; i<2*VertexNumber; i++)
	CarbonFiberJunctionShapePiece->SetVertex(i,
							Vertex[(i < VertexNumber ? i: i-VertexNumber)]->X(),
							Vertex[(i < VertexNumber ? i : i-VertexNumber)]->Y());
  TGeoRotation* CarbonFiberJunctionRot = 
						new TGeoRotation("CarbonFiberJunctionRot",
										  180.,
										  180.,
										  180-2.*fgkCarbonFiberJunctionAngle[0]); 
  TGeoVolume* CarbonFiberJunctionPiece = 
						new TGeoVolume("CarbonFiberJunctionPiece",
						CarbonFiberJunctionShapePiece,fgkSSDCarbonFiberMedium);
  TGeoVolume* CarbonFiberJunction = 
						new TGeoVolumeAssembly("CarbonFiberJunction");
  CarbonFiberJunctionPiece->SetLineColor(fColorCarbonFiber);
  CarbonFiberJunction->AddNode(CarbonFiberJunctionPiece,1);
  CarbonFiberJunction->AddNode(CarbonFiberJunctionPiece,2,CarbonFiberJunctionRot);
  return CarbonFiberJunction;
}
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunctionAssembly(){
////////////////////////////////////////////////////////////////////////////////
  SetCarbonFiberJunctionCombiTransMatrix();
  TGeoVolume* CarbonFiberJunctionAssembly = 
						  new TGeoVolumeAssembly("CarbonFiberJunctionAssembly");
  TGeoVolume* CarbonFiberJunction = 
						  GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth);
  for(Int_t i=0; i<fgkCarbonFiberJunctionCombiTransNumber;i++) 
    CarbonFiberJunctionAssembly->AddNode(CarbonFiberJunction,i+1,
										 CarbonFiberJunctionCombiTransMatrix[i]);
  return CarbonFiberJunctionAssembly;
}
/////////////////////////////////////////////////////////////////////////////////
TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t SSDEndLadderCableLength){
/////////////////////////////////////////////////////////////////////////////////
const Int_t LadderCableSegmentNumber = 2;
/////////////////////////////////////////
// LadderSegmentBBox Volume
/////////////////////////////////////////
  TGeoBBox* LadderCableSegmentBBoxShape[LadderCableSegmentNumber];
  const char* LadderCableSegmentBBoxShapeName[LadderCableSegmentNumber] = 
				{"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
  for(Int_t i=0; i<LadderCableSegmentNumber; i++) LadderCableSegmentBBoxShape[i] = 
						  new TGeoBBox(LadderCableSegmentBBoxShapeName[i],
									   0.5*fgkSSDFlexWidth[0],
									   0.5*fgkSSDLadderCableWidth,
									   0.5*fgkSSDFlexHeight[i]); 
  const char* LadderCableSegmentBBoxName[LadderCableSegmentNumber] = 
						  {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
  TGeoVolume* LadderCableSegmentBBox[LadderCableSegmentNumber];
  for(Int_t i=0; i<LadderCableSegmentNumber; i++){ 
			LadderCableSegmentBBox[i] =
						  new TGeoVolume(LadderCableSegmentBBoxName[i],
										 LadderCableSegmentBBoxShape[i],
										 (i==0?fgkSSDAlTraceLadderCableMedium:
            fgkSSDKaptonLadderCableMedium));
			LadderCableSegmentBBox[i]->SetLineColor(i==0 ? fColorAl : 
														   fColorPolyhamide);
  }
  TGeoTranslation* LadderCableSegmentBBoxTrans[LadderCableSegmentNumber];										  
  LadderCableSegmentBBoxTrans[0] = 
						   new TGeoTranslation("LadderCableSegmentBBoxTrans1",
											   0.5*fgkSSDFlexWidth[0],
											   0.5*fgkSSDLadderCableWidth,
											   0.5*fgkSSDFlexHeight[0]);
  LadderCableSegmentBBoxTrans[1] = 
						   new TGeoTranslation("LadderCableSegmentBBoxTrans2",
											   0.5*fgkSSDFlexWidth[0],
											   0.5*fgkSSDLadderCableWidth,
											   fgkSSDFlexHeight[0]
											   +0.5*fgkSSDFlexHeight[1]);
  TGeoVolume* LadderCableSegmentBBoxAssembly = 
						   new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly"); 
  for(Int_t i=0; i<LadderCableSegmentNumber; i++)  
		LadderCableSegmentBBoxAssembly->AddNode(LadderCableSegmentBBox[i],1,
											    LadderCableSegmentBBoxTrans[i]);
/////////////////////////////////////////
// LadderSegmentArb8 Volume
/////////////////////////////////////////
  const Int_t VertexNumber = 4;
  TVector3** LadderCableSegmentVertexPosition[LadderCableSegmentNumber];
  for(Int_t i = 0; i<LadderCableSegmentNumber; i++) LadderCableSegmentVertexPosition[i] = 
												  new TVector3*[VertexNumber];
//Shape Vertex Positioning
  for(Int_t i=0; i<LadderCableSegmentNumber; i++){
	LadderCableSegmentVertexPosition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
	LadderCableSegmentVertexPosition[i][1] = new TVector3(fgkSSDLadderCableWidth,
														  i*fgkSSDFlexHeight[0]);
	LadderCableSegmentVertexPosition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
										   +			     fgkSSDFlexHeight[1]
										   +			  i*fgkSSDFlexHeight[0]);
	LadderCableSegmentVertexPosition[i][3] = 
						   new TVector3(LadderCableSegmentVertexPosition[i][1]->X(),
										LadderCableSegmentVertexPosition[i][2]->Y());
  }
  Double_t LadderCableSegmentWidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
							     		    {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};	
  char* LadderCableSegmentArbShapeName[LadderCableSegmentNumber] = 
					{"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
  TGeoArb8* LadderCableSegmentArbShape[LadderCableSegmentNumber];
  for(Int_t i = 0; i< LadderCableSegmentNumber; i++) LadderCableSegmentArbShape[i] = 
					GetArbShape(LadderCableSegmentVertexPosition[i],
								LadderCableSegmentWidth[i],
								fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
								LadderCableSegmentArbShapeName[i]);
  const char* LadderCableSegmentArbName[LadderCableSegmentNumber] = 
						  {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
  TGeoVolume* LadderCableSegmentArb[LadderCableSegmentNumber];
  for(Int_t i=0; i<LadderCableSegmentNumber; i++){
			 LadderCableSegmentArb[i] =
						   new TGeoVolume(LadderCableSegmentArbName[i],
										  LadderCableSegmentArbShape[i],
										  (i==0?fgkSSDAlTraceLadderCableMedium:
            fgkSSDKaptonLadderCableMedium)); 
			 LadderCableSegmentArb[i]->SetLineColor(i==0 ? fColorAl : 
														   fColorPolyhamide);
}
  TGeoRotation* LadderCableSegmentArbRot[LadderCableSegmentNumber];
  LadderCableSegmentArbRot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
												 90.,90,-90.);	 
  LadderCableSegmentArbRot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
												  0.,90.,0.);	 
  TGeoCombiTrans* LadderCableSegmentArbCombiTrans =  
						   new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
							   0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
							 + fgkSSDFlexWidth[0],0.,0.,
						   new TGeoRotation((*LadderCableSegmentArbRot[1])
						     *(*LadderCableSegmentArbRot[0])));
  TGeoVolume* LadderCableSegmentArbAssembly = 
						   new TGeoVolumeAssembly("LadderCableSegmentArbAssembly"); 
  for(Int_t i=0; i<LadderCableSegmentNumber; i++)
  LadderCableSegmentArbAssembly->AddNode(LadderCableSegmentArb[i],1,
										   LadderCableSegmentArbCombiTrans);
/////////////////////////////////////////
// End Ladder Cable Volume
/////////////////////////////////////////
  TGeoBBox* LadderEndCableSegmentBBoxShape[LadderCableSegmentNumber];
  const char* LadderEndCableSegmentBBoxShapeName[LadderCableSegmentNumber] = 
				{"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
  for(Int_t i=0; i<LadderCableSegmentNumber; i++) LadderEndCableSegmentBBoxShape[i] = 
						  new TGeoBBox(LadderEndCableSegmentBBoxShapeName[i],
									   0.5*SSDEndLadderCableLength,
									   0.5*fgkSSDLadderCableWidth,
									   0.5*fgkSSDFlexHeight[i]);
  const char* LadderEndCableSegmentBBoxName[LadderCableSegmentNumber] = 
						  {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
  TGeoVolume* LadderEndCableSegmentBBox[LadderCableSegmentNumber];
  for(Int_t i=0; i<LadderCableSegmentNumber; i++){ 
			LadderEndCableSegmentBBox[i] =
						  new TGeoVolume(LadderEndCableSegmentBBoxName[i],
										 LadderEndCableSegmentBBoxShape[i],
										 (i==0?fgkSSDAlTraceLadderCableMedium:
            fgkSSDKaptonLadderCableMedium));
			LadderEndCableSegmentBBox[i]->SetLineColor(i==0 ? fColorAl : 
														   fColorPolyhamide);
  }
  TGeoTranslation* LadderEndCableSegmentBBoxTrans[LadderCableSegmentNumber];										  
  LadderEndCableSegmentBBoxTrans[0] = 
						   new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
											   0.5*SSDEndLadderCableLength,
											   0.5*fgkSSDLadderCableWidth,
											   0.5*fgkSSDFlexHeight[0]);
  LadderEndCableSegmentBBoxTrans[1] = 
						   new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
											   0.5*SSDEndLadderCableLength,
											   0.5*fgkSSDLadderCableWidth,
											   fgkSSDFlexHeight[0]
											   +0.5*fgkSSDFlexHeight[1]);
  TGeoVolume* LadderEndCableSegmentBBoxAssembly = 
						   new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly"); 
  for(Int_t i=0; i<LadderCableSegmentNumber; i++)  
		LadderEndCableSegmentBBoxAssembly->AddNode(LadderEndCableSegmentBBox[i],1,
											    LadderEndCableSegmentBBoxTrans[i]);
/////////////////////////////////////////
  TList* LadderCableSegmentList = new TList();
  LadderCableSegmentList->Add(LadderCableSegmentBBoxAssembly);
  LadderCableSegmentList->Add(LadderCableSegmentArbAssembly);
  LadderCableSegmentList->Add(LadderEndCableSegmentBBoxAssembly);
  return LadderCableSegmentList;
  }
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t SSDEndLadderCableLength){
/////////////////////////////////////////////////////////////////////////////////
  TList* LadderCableSegmentList = GetLadderCableSegment(SSDEndLadderCableLength);
  TGeoVolume* LadderCable = new TGeoVolumeAssembly("LadderCable"); 
  for(Int_t i=0; i<n; i++){
	TGeoTranslation* LadderCableTrans = new TGeoTranslation(
							i*(fgkCarbonFiberJunctionWidth),
							fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
							i*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
    LadderCable->AddNode((TGeoVolume*)LadderCableSegmentList->At(0),i+1,LadderCableTrans);  
	if(i!=n-1) LadderCable->AddNode((TGeoVolume*)LadderCableSegmentList->At(1),i+1,LadderCableTrans);  
  }
  TGeoTranslation* EndLadderCableTrans = new TGeoTranslation("EndLadderCableTrans",
					  (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
								 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
					  (n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
  LadderCable->AddNode((TGeoVolume*)LadderCableSegmentList->At(2),1,EndLadderCableTrans);
  return LadderCable;
}
/////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t SSDEndLadderCableLength){
/////////////////////////////////////////////////////////////////////////////////
  TGeoVolume* LadderCableAssembly = new TGeoVolumeAssembly("LadderCableAssembly");
  char LadderCableTransName[30];
  for(Int_t i=0; i<n; i++){ 
	sprintf(LadderCableTransName,"LadderCableTrans%i",i+1);
    LadderCableAssembly->AddNode(GetLadderCable(n-i,SSDEndLadderCableLength),i+1,
	new TGeoTranslation(LadderCableTransName,i*fgkCarbonFiberJunctionWidth,0.,0.));
  }
  return LadderCableAssembly;
}
/////////////////////////////////////////////////////////////////////////////////
TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t SSDEndLadderCableLength){
/////////////////////////////////////////////////////////////////////////////////
  const Int_t LadderCableAssemblyNumber = 2;
  TGeoVolume* LadderCableAssembly = GetLadderCableAssembly(n,SSDEndLadderCableLength);
  TGeoVolume* LadderCable[LadderCableAssemblyNumber];
  char LadderCableAssemblyName[30];
  TList* LadderCableAssemblyList = new TList();
  for(Int_t i=0; i<LadderCableAssemblyNumber; i++){ 
	sprintf(LadderCableAssemblyName,"LadderCableAssembly%i",i+1);
	LadderCable[i] = new TGeoVolumeAssembly(LadderCableAssemblyName);
	LadderCable[i]->AddNode(LadderCableAssembly,i+1,i==0 ? NULL :
					 new TGeoCombiTrans((n-1)
					 *	 fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
					     2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
											0.,new TGeoRotation("",180,0.,0.)));
	LadderCableAssemblyList->Add(LadderCable[i]);
}
  return LadderCableAssemblyList;
}
/////////////////////////////////////////////////////////////////////////////////
TList* AliITSv11GeometrySSD::GetEndLadderCarbonFiberJunctionAssembly(){
////////////////////////////////////////////////////////////////////////////////
  const Int_t EndLabberCarbonFiberJunctionNumber = 2;
  TGeoVolume* EndLadderCarbonFiberJunctionAssembly[EndLabberCarbonFiberJunctionNumber];
  EndLadderCarbonFiberJunctionAssembly[0] = 
				new TGeoVolumeAssembly("EndLadderCarbonFiberJunctionAssembly1");
  EndLadderCarbonFiberJunctionAssembly[1] = 
				new TGeoVolumeAssembly("EndLadderCarbonFiberJunctionAssembly2");
  TGeoVolume** EndLadderCarbonFiberJunction[EndLabberCarbonFiberJunctionNumber];
  for(Int_t i=0; i<EndLabberCarbonFiberJunctionNumber; i++) 
						   EndLadderCarbonFiberJunction[i] = new TGeoVolume*[2];
  for(Int_t i=0; i<EndLabberCarbonFiberJunctionNumber; i++){
    EndLadderCarbonFiberJunction[i][0] = 
		  GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]);
    EndLadderCarbonFiberJunction[i][1] = 
		  GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]);
  }
  TList* EndLadderCarbonFiberJunctionList = new TList();
  for(Int_t i=0; i<EndLabberCarbonFiberJunctionNumber; i++){
    SetEndLadderCarbonFiberJunctionCombiTransMatrix(i);
    for(Int_t j=0; j<fgkCarbonFiberJunctionCombiTransNumber; j++)
      EndLadderCarbonFiberJunctionAssembly[i]->AddNode(j==2 ? 
						 EndLadderCarbonFiberJunction[i][1] : 
						 EndLadderCarbonFiberJunction[i][0],
						 j+1,EndLadderCarbonFiberJunctionCombiTransMatrix[j]);
    EndLadderCarbonFiberJunctionList->Add(EndLadderCarbonFiberJunctionAssembly[i]);
  }
  return EndLadderCarbonFiberJunctionList;
}
////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberSupport(){
////////////////////////////////////////////////////////////////////////////////
  const Int_t VertexNumber = 4;
  const Int_t ShapesNumber = 2;
  TVector3** VertexPosition[ShapesNumber];
  for(Int_t i=0; i<ShapesNumber; i++) VertexPosition[i] = new TVector3*[VertexNumber];
  Double_t CarbonFiberSupportXAxisEdgeProj = 
		fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
	*	TMath::DegToRad());
  Double_t Theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
				 /			   fgkCarbonFiberSupportXAxisLength);
  /////////////////////
  //Vertex Positioning
  ////////////////////
  VertexPosition[0][0] = new TVector3();
  VertexPosition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
									  fgkCarbonFiberSupportYAxisLength);
  VertexPosition[0][2] = new TVector3(CarbonFiberSupportXAxisEdgeProj,
									  CarbonFiberSupportXAxisEdgeProj
					   *			  TMath::Tan(Theta));
  VertexPosition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
					   -			  CarbonFiberSupportXAxisEdgeProj,
									  fgkCarbonFiberSupportYAxisLength
					   -			  VertexPosition[0][2]->Y());
  ////////////////////////////////////////////////////
  //Setting the parameters for Isometry Transformation
  ////////////////////////////////////////////////////
  Double_t SymmetryPlanePosition = (fgkCarbonFiberSupportYAxisLength
								 +	fgkCarbonFiberSupportTopEdgeDist[0]
								 +	fgkCarbonFiberSupportWidth);
  Double_t* param = new Double_t[4]; 
  param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -SymmetryPlanePosition;
  for(Int_t j=0; j<VertexNumber; j++) VertexPosition[1][j] = 
				  new TVector3((GetReflection(VertexPosition[0][j],param))->X(),
							  (GetReflection(VertexPosition[0][j],param))->Y());
  char* CarbonFiberSupportShapeName[ShapesNumber] = 
						{"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
  TGeoArb8* CarbonFiberSupportShape[ShapesNumber]; 
  Double_t Width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
  Double_t CarbonFiberSupportHeight = 
	  CarbonFiberSupportXAxisEdgeProj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
	  *TMath::DegToRad());
  for(Int_t i = 0; i< ShapesNumber; i++) CarbonFiberSupportShape[i] = 
					GetArbShape(VertexPosition[i],Width,CarbonFiberSupportHeight,
									CarbonFiberSupportShapeName[i],i==0 ? 1: -1);
  /////////////////////////////////////
  //Setting Translations and Rotations: 
  /////////////////////////////////////
  TGeoTranslation* CarbonFiberSupportTrans = 
						  new TGeoTranslation("CarbonFiberSupportTrans",
											  0.0,0.0,0.5*CarbonFiberSupportHeight);
  CarbonFiberSupportTrans->RegisterYourself();
  TGeoRotation* CarbonFiberCompShapeRot[2];
  CarbonFiberCompShapeRot[0] = new TGeoRotation("CarbonFiberCompShapeRot1",
											  0.0,180.0,0.0);
  CarbonFiberCompShapeRot[1] = new TGeoRotation("CarbonFiberCompShapeRot2",
										  90.,-fgkCarbonFiberTriangleAngle,-90.);
  Double_t TransVector[3] = {fgkCarbonFiberTriangleLength
						  *  TMath::Cos(fgkCarbonFiberTriangleAngle
						  *	 TMath::DegToRad()),0.,-fgkCarbonFiberTriangleLength
						  *	 TMath::Sin(fgkCarbonFiberTriangleAngle
						  *	 TMath::DegToRad())};
  TGeoCombiTrans* CarbonFiberSupportCombiTrans = 
							   new TGeoCombiTrans("CarbonFiberSupportCombiTrans",
							   TransVector[0],2.*SymmetryPlanePosition
						  +	   TransVector[1],TransVector[2],
							   new TGeoRotation((*CarbonFiberCompShapeRot[1])
						  *	   (*CarbonFiberCompShapeRot[0])));
  CarbonFiberSupportCombiTrans->RegisterYourself();
////////////////////////////////////////////////////////////////////////////////
  TGeoCompositeShape* CarbonFiberSupportCompShape = 
							new TGeoCompositeShape("CarbonFiberSupportCompShape",
							"CarbonFiberSupportShape1:CarbonFiberSupportTrans+"
							"CarbonFiberSupportShape2:CarbonFiberSupportTrans");
  TGeoVolume* CarbonFiberSupport = new TGeoVolume("CarbonFiberSupport",
						   CarbonFiberSupportCompShape,fgkSSDCarbonFiberMedium);
  CarbonFiberSupport->SetLineColor(fColorCarbonFiber);
  TGeoVolume* CarbonFiberSupportAssembly = 
						    new TGeoVolumeAssembly("CarbonFiberSupportAssembly");
  CarbonFiberSupportAssembly->AddNode(CarbonFiberSupport,1);
  CarbonFiberSupportAssembly->AddNode(CarbonFiberSupport,2,
									  CarbonFiberSupportCombiTrans);
  return CarbonFiberSupportAssembly;
}
////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberLowerSupport(Int_t ikind, Bool_t EndLadder){
////////////////////////////////////////////////////////////////////////////////
  const Int_t VertexNumber = 4;
  const Int_t ShapesNumber = 2;
  Double_t Width[2] = {fgkCarbonFiberLowerSupportWidth,
								fgkCarbonFiberLowerSupportWidth};
  TVector3** VertexPosition[ShapesNumber];
  for(Int_t i = 0; i<ShapesNumber; i++) VertexPosition[i] = 
						 new TVector3*[VertexNumber];
  //First Shape Vertex Positioning
  VertexPosition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
  VertexPosition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
					   -		fgkCarbonFiberLowerSupportLowerLenght);
  VertexPosition[0][2] = new TVector3();
  VertexPosition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
  //Second Shape Vertex Positioning
  Double_t Theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
				 -				fgkCarbonFiberLowerSupportVolumePosition[0])
				 /				fgkCarbonFiberTriangleLength);
  VertexPosition[1][0] = new TVector3(VertexPosition[0][0]->X(),
								VertexPosition[0][0]->X()*TMath::Tan(Theta)
				 +				fgkCarbonFiberLowerSupportVolumePosition[0]);
  VertexPosition[1][1] = new TVector3(VertexPosition[0][1]->X(),
								VertexPosition[0][1]->X()*TMath::Tan(Theta)
				 +				fgkCarbonFiberLowerSupportVolumePosition[0]);
  VertexPosition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
  VertexPosition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
								fgkCarbonFiberLowerSupportVolumePosition[1]);
  char* CarbonFiberLowerSupportName[ShapesNumber] = 
			  {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
  TGeoArb8* CarbonFiberLowerSupportShape[ShapesNumber];
  for(Int_t i = 0; i< ShapesNumber; i++) CarbonFiberLowerSupportShape[i] = 
								GetArbShape(VertexPosition[i],Width,
											fgkCarbonFiberLowerSupportHeight,
											CarbonFiberLowerSupportName[i]);
  ///////////////////////////////////////////////////////
  TGeoTranslation* CarbonFiberLowerSupportTrans[ShapesNumber];
  CarbonFiberLowerSupportTrans[0] = 
						new TGeoTranslation("CarbonFiberLowerSupportTrans1",
						0.0,
						VertexPosition[1][3]->Y()+VertexPosition[1][2]->Y(),
						0.0);
  CarbonFiberLowerSupportTrans[1] = 
						new TGeoTranslation("CarbonFiberLowerSupportTrans2",
						0.0,
				-		VertexPosition[1][3]->Y()-VertexPosition[1][2]->Y(),
						0.0);
  for(Int_t i = 0; i< ShapesNumber; i++) 
						CarbonFiberLowerSupportTrans[i]->RegisterYourself(); 
  ///////////////////////////////////////////////////////
  TGeoCompositeShape* CarbonFiberLowerSupportCompShape; 
  if(EndLadder==false)
    CarbonFiberLowerSupportCompShape = 
				new TGeoCompositeShape("CarbonFiberLowerSupportCompShape",
				"CarbonFiberLowerSupportShape2+"
				"CarbonFiberLowerSupportShape1:CarbonFiberLowerSupportTrans1");
  else
    if(ikind==0)
      CarbonFiberLowerSupportCompShape = 
						  (TGeoCompositeShape*)CarbonFiberLowerSupportShape[0];
    else
      CarbonFiberLowerSupportCompShape = 
	new TGeoCompositeShape("CarbonFiberLowerSupportCompShape",
				 "CarbonFiberLowerSupportShape1+"
				 "CarbonFiberLowerSupportShape1:CarbonFiberLowerSupportTrans1"); 
  TGeoVolume* CarbonFiberLowerSupport = new TGeoVolume("CarbonFiberLowerSupport",
					  CarbonFiberLowerSupportCompShape,fgkSSDCarbonFiberMedium);
  CarbonFiberLowerSupport->SetLineColor(fColorCarbonFiber);
  return CarbonFiberLowerSupport;
}
////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberAssemblySupport(){
////////////////////////////////////////////////////////////////////////////////
  SetCarbonFiberAssemblyCombiTransMatrix();
  TGeoVolume* CarbonFiberAssemblySupport = 
						new TGeoVolumeAssembly("CarbonFiberAssembly");
  TGeoVolume* CarbonFiberAssemblyVolumes[fgkCarbonFiberAssemblyCombiTransNumber];
  CarbonFiberAssemblyVolumes[0] = GetCarbonFiberJunctionAssembly();
  CarbonFiberAssemblyVolumes[1] = GetCarbonFiberSupport();
  CarbonFiberAssemblyVolumes[2] = GetCarbonFiberLowerSupport();
  for(Int_t i=0; i<fgkCarbonFiberAssemblyCombiTransNumber;i++) 
    CarbonFiberAssemblySupport->AddNode(CarbonFiberAssemblyVolumes[i],1,
						CarbonFiberAssemblyCombiTransMatrix[i]);
  return CarbonFiberAssemblySupport;
}
////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(){
////////////////////////////////////////////////////////////////////////////////
  const Int_t VertexNumber = 3;
  Double_t Phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
			   /			 fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
  /* TGeoTubeSeg* CoolingTubeSegShape =  */ 
						new TGeoTubeSeg("CoolingTubeSegShape",0.0,
							fgkCoolingTubeSupportRmax,
							0.5*fgkCoolingTubeSupportWidth,Phi,
							360-Phi);
  /* TGeoTube* CoolingTubeHoleShape =  */
						new TGeoTube("CoolingTubeHoleShape",0.0,
							fgkCoolingTubeSupportRmin,
							0.5*fgkCoolingTubeSupportWidth);
  TVector3* VertexPosition[VertexNumber];
  ///////////////////////////
  //Shape Vertex Positioning
  ///////////////////////////
  VertexPosition[0] = new TVector3();
  VertexPosition[1] = new TVector3(fgkCoolingTubeSupportRmax
					*		TMath::Cos(Phi*TMath::DegToRad()),
							fgkCoolingTubeSupportRmax
					*		TMath::Sin(Phi*TMath::DegToRad()));
  VertexPosition[2] = new TVector3(VertexPosition[1]->X(),
					-			   VertexPosition[1]->Y());
  /* TGeoArb8* CoolingTubeTriangleShape = */ GetTriangleShape(VertexPosition,
									   fgkCoolingTubeSupportWidth,
									   "CoolingTubeTriangleShape");
  Double_t* BoxOrigin = new Double_t[3];
  Double_t BoxLength = fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax
					 - VertexPosition[1]->X();
  BoxOrigin[0] = VertexPosition[1]->X()+0.5*BoxLength, BoxOrigin[1] = BoxOrigin[2] = 0.;
  /* TGeoBBox* CoolingTubeBoxShape = */
						new TGeoBBox("CoolingTubeBoxShape",0.5*BoxLength,
							0.5*fgkCoolingTubeSupportHeight,
							0.5*fgkCoolingTubeSupportWidth,BoxOrigin);
  TGeoCompositeShape* CoolingTubeSupportShape = 
						new TGeoCompositeShape("CoolingTubeSupportShape",
						 "(CoolingTubeSegShape+CoolingTubeTriangleShape"
						 "+CoolingTubeBoxShape)-CoolingTubeHoleShape"); 
  TGeoVolume* CoolingTubeSupport = new TGeoVolume("CoolingTubeSupport",
						 CoolingTubeSupportShape,fgkSSDTubeHolderMedium);
  return CoolingTubeSupport;
}
////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupportAssembly(){
////////////////////////////////////////////////////////////////////////////////
  TGeoVolume* CoolingTubeSupportAssembly = 
						   new TGeoVolumeAssembly("CoolingTubeSupportAssembly");
  TGeoVolume* CoolingTubeSupport = GetCoolingTubeSupport();
  SetCoolingTubeSupportCombiTransMatrix();
  for(Int_t i=0; i<fgkCoolingTubeSupportCombiTransNumber;i++) 
    CoolingTubeSupportAssembly->AddNode(CoolingTubeSupport,i+1,
										 CoolingTubeSupportCombiTransMatrix[i]);
  return CoolingTubeSupportAssembly;
}
////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetCoolingTube(){
////////////////////////////////////////////////////////////////////////////////
  TGeoVolume* CoolingTubeAssembly = new TGeoVolumeAssembly("CoolingTubeAssembly");
  TGeoTube *CoolingTubeShape = new TGeoTube("CoolingTubeShape", fgkCoolingTubeRmin, 
						fgkCoolingTubeRmax, fgkCoolingTubeLength/2.0);
  TGeoVolume* CoolingTube = new TGeoVolume("CoolingTube",
						 CoolingTubeShape,fgkSSDCoolingTubePhynox);
  TGeoTube *CoolingTubeInteriorShape = new TGeoTube("CoolingTubeInteriorShape", 
						0, fgkCoolingTubeRmin, 
						fgkCoolingTubeLength/2.0);
  TGeoVolume *CoolingTubeInterior = new TGeoVolume("CoolingTubeInterior",
						   CoolingTubeInteriorShape,fgkSSDCoolingTubeWater);
  CoolingTubeAssembly->AddNode(CoolingTube,1);
  CoolingTubeAssembly->AddNode(CoolingTubeInterior,2);
  return CoolingTubeAssembly;
}  
////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeAssembly(){
////////////////////////////////////////////////////////////////////////////////
  TGeoVolume* CoolingTubeAssembly =   new TGeoVolumeAssembly("CoolingTubeAssembly");
  TGeoVolume* CoolingTube = GetCoolingTube();
  SetCoolingTubeCombiTransMatrix();
  for(Int_t i=0; i<fgkCoolingTubeCombiTransNumber;i++) 
    CoolingTubeAssembly->AddNode(CoolingTube,i+1,CoolingTubeTransMatrix[i]);
  return CoolingTubeAssembly;
}
////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetLadderSegment(Int_t iChipCablesHeight){
////////////////////////////////////////////////////////////////////////////////
    TGeoVolume* LadderSegment = new TGeoVolumeAssembly("LadderSegment");
    TGeoVolume* LadderSegmentVolumes[fgkLadderSegmentCombiTransNumber];
    LadderSegmentVolumes[0] = GetCarbonFiberAssemblySupport();
    LadderSegmentVolumes[1] = GetSSDModule(iChipCablesHeight);
    LadderSegmentVolumes[2] = GetSSDSensorSupportAssembly(iChipCablesHeight);
    LadderSegmentVolumes[3] = GetCoolingTubeSupportAssembly();
	LadderSegmentVolumes[4] = GetCoolingTubeAssembly(); 
    SetLadderSegmentCombiTransMatrix();
    for(Int_t i=0; i<fgkLadderSegmentCombiTransNumber; i++) 
      LadderSegment->AddNode(LadderSegmentVolumes[i],1,
							 LadderSegmentCombiTransMatrix[i]);
    return LadderSegment;
}
////////////////////////////////////////////////////////////////////////////////
TList* AliITSv11GeometrySSD::GetEndLadderSegment(){
////////////////////////////////////////////////////////////////////////////////
  const Int_t EndLadderSegmentNumber = 2;
  TList* EndLadderCarbonFiberJunctionList = GetEndLadderCarbonFiberJunctionAssembly();
  TGeoVolume* EndLadderSegment[EndLadderSegmentNumber];
  EndLadderSegment[0] = new TGeoVolumeAssembly("EndLadderSegment1");
  EndLadderSegment[1] = new TGeoVolumeAssembly("EndLadderSegment2");
  TGeoVolume** LadderSegmentVolumes[EndLadderSegmentNumber];
  const Int_t LadderSegmentVolumeNumber = 4;
  for(Int_t i=0; i<EndLadderSegmentNumber; i++) LadderSegmentVolumes[i] = 
						new TGeoVolume*[LadderSegmentVolumeNumber];
  LadderSegmentVolumes[0][0] = (TGeoVolume*)EndLadderCarbonFiberJunctionList->At(0);
  LadderSegmentVolumes[0][1] = GetCarbonFiberSupport();
  LadderSegmentVolumes[0][2] = GetSSDMountingBlock();
  LadderSegmentVolumes[0][3] = GetCarbonFiberLowerSupport(0,true);
  LadderSegmentVolumes[1][0] = (TGeoVolume*)EndLadderCarbonFiberJunctionList->At(1);
  LadderSegmentVolumes[1][1] = LadderSegmentVolumes[0][1];
  LadderSegmentVolumes[1][2] = LadderSegmentVolumes[0][2];
  LadderSegmentVolumes[1][3] = GetCarbonFiberLowerSupport(1,true);
  TList* EndLadderSegmentList = new TList();
  for(Int_t i=0; i<EndLadderSegmentNumber; i++){
    SetEndLadderSegmentCombiTransMatrix(i);
    for(Int_t j=0; j<LadderSegmentVolumeNumber; j++)
      EndLadderSegment[i]->AddNode(LadderSegmentVolumes[i][j],1,
								   EndLadderSegmentCombiTransMatrix[j]);
    EndLadderSegmentList->Add(EndLadderSegment[i]);
  }
  return EndLadderSegmentList;
}
////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
////////////////////////////////////////////////////////////////////////////////
  // Mounting Block Boxes Shapes
  ///////////////////////////////////////
  const Int_t MountingBlockBoxNumber = 3;
  TGeoBBox* MountingBlockBoxShape[MountingBlockBoxNumber];
  MountingBlockBoxShape[0] = new TGeoBBox("MountingBlockBoxShape0",
							0.25*(fgkSSDMountingBlockLength[0]
						-	fgkSSDMountingBlockLength[1]),
							0.5*fgkSSDMountingBlockWidth,
							0.5*fgkSSDMountingBlockHeight[0]);
  MountingBlockBoxShape[1] = new TGeoBBox("MountingBlockBoxShape1",
							0.25*(fgkSSDMountingBlockLength[1]
						-	fgkSSDMountingBlockLength[2]),
							0.5*fgkSSDMountingBlockWidth,
							0.5*(fgkSSDMountingBlockHeight[1]
						-	fgkSSDMountingBlockHeight[3]));
  MountingBlockBoxShape[2] = new TGeoBBox("MountingBlockBoxShape2",
							0.5*fgkSSDMountingBlockLength[2],
							0.5*fgkSSDMountingBlockWidth,
							0.5*(fgkSSDMountingBlockHeight[2]
						-	fgkSSDMountingBlockHeight[3]));
  TGeoTranslation* MountingBlockBoxTrans[MountingBlockBoxNumber+2];
  MountingBlockBoxTrans[0] = new TGeoTranslation("MountingBlockBoxTrans0",0.,0.,0.);
  MountingBlockBoxTrans[1] = new TGeoTranslation("MountingBlockBoxTrans1",
							MountingBlockBoxShape[0]->GetDX()
						+	MountingBlockBoxShape[1]->GetDX(),
							0.0,
							MountingBlockBoxShape[1]->GetDZ()
						-	MountingBlockBoxShape[0]->GetDZ()
						+	fgkSSDMountingBlockHeight[3]);
  MountingBlockBoxTrans[2] = new TGeoTranslation("MountingBlockBoxTrans2",
							MountingBlockBoxShape[0]->GetDX()
						+	2.*MountingBlockBoxShape[1]->GetDX()
						+	MountingBlockBoxShape[2]->GetDX(),
							0.0,
							MountingBlockBoxShape[2]->GetDZ()
						-	MountingBlockBoxShape[0]->GetDZ()
						+	fgkSSDMountingBlockHeight[3]);
  MountingBlockBoxTrans[3] = new TGeoTranslation("MountingBlockBoxTrans3",
							MountingBlockBoxShape[0]->GetDX()
						+	MountingBlockBoxShape[1]->GetDX()
						+	2.*(MountingBlockBoxShape[1]->GetDX()
						+	MountingBlockBoxShape[2]->GetDX()),
							0.0,
							MountingBlockBoxShape[1]->GetDZ()
						-	MountingBlockBoxShape[0]->GetDZ()
						+	fgkSSDMountingBlockHeight[3]);
  MountingBlockBoxTrans[4] = new TGeoTranslation("MountingBlockBoxTrans4",
							2.*(MountingBlockBoxShape[0]->GetDX()
						+	2.*MountingBlockBoxShape[1]->GetDX()
						+   MountingBlockBoxShape[2]->GetDX()),
							0.0,
							0.0);
  for(Int_t i=0; i<MountingBlockBoxNumber+2; i++) 
									MountingBlockBoxTrans[i]->RegisterYourself();
  ///////////////////////////////////////
  // Mounting Block Trapezoid Hole Shapes
  ///////////////////////////////////////
  const Int_t HoleTrapezoidVertexNumber = 4;
  TVector3* HoleTrapezoidVertex[HoleTrapezoidVertexNumber];
  HoleTrapezoidVertex[0] = new TVector3();
  HoleTrapezoidVertex[1] = new TVector3(fgkSSDMountingBlockHoleTrapezoidHeight);
  HoleTrapezoidVertex[2] = new TVector3(*HoleTrapezoidVertex[0]);
  HoleTrapezoidVertex[3] = new TVector3(*HoleTrapezoidVertex[1]);
  Double_t HoleTrapezoidWidth[2] = {fgkSSDMountingBlockHoleTrapezoidUpBasis
						+	2.*MountingBlockBoxShape[1]->GetDX()
						*	TMath::Tan(fgkSSDMountingBlockHoleTrapezoidAngle
						*	TMath::DegToRad()),
							fgkSSDMountingBlockHoleTrapezoidUpBasis}; 
  /* TGeoArb8* HoleTrapezoidShape =*/ GetArbShape(HoleTrapezoidVertex,
							HoleTrapezoidWidth,
							2.*MountingBlockBoxShape[1]->GetDX(),
							"HoleTrapezoidShape");
  TGeoRotation* HoleTrapezoidShapeRot[2];
  HoleTrapezoidShapeRot[0] = new TGeoRotation("HoleTrapezoidShapeRot0",
							90.,-90.,-90.);
  HoleTrapezoidShapeRot[1] = new TGeoRotation("HoleTrapezoidShapeRot1",
							-180.,0.,0.);
  TGeoCombiTrans* HoleTrapezoidShapeCombiTrans = 
							new TGeoCombiTrans("HoleTrapezoidShapeCombiTrans",
							MountingBlockBoxShape[0]->GetDX()
						+	3.*MountingBlockBoxShape[1]->GetDX()
						+	2.*MountingBlockBoxShape[2]->GetDX(),
							0.5*fgkSSDMountingBlockWidth,
						-	fgkSSDMountingBlockHoleTrapezoidHeight
						+	2.*MountingBlockBoxShape[1]->GetDZ()
						-	MountingBlockBoxShape[0]->GetDZ()
						+	fgkSSDMountingBlockHeight[3],
							new TGeoRotation((*HoleTrapezoidShapeRot[1])
						*	(*HoleTrapezoidShapeRot[0])));
  HoleTrapezoidShapeCombiTrans->RegisterYourself();
  ///////////////////////////////////
  // Mounting Block Screw Hole Shapes
  ///////////////////////////////////
  const Int_t MountingBlockTubeNumber = 2;
  TGeoTube* MountingBlockTubeShape[MountingBlockTubeNumber];
  MountingBlockTubeShape[0] = new TGeoTube("MountingBlockTubeShape0",0.0,
							fgkSSDMountingBlockHoleRadius,
							MountingBlockBoxShape[0]->GetDZ());
  MountingBlockTubeShape[1] = new TGeoTube("MountingBlockTubeShape1",0.0,
							fgkSSDMountingBlockHoleRadius,
							MountingBlockBoxShape[2]->GetDZ());
  TGeoTranslation* MountingBlockTubeTrans[2*MountingBlockTubeNumber];
  MountingBlockTubeTrans[0] = new TGeoTranslation("MountingBlockTubeTrans0",
						-	0.5*(fgkSSDMountingBlockLength[0]
						-	fgkSSDMountingBlockHoleTubeLength[0]),
							0.5*fgkSSDMountingBlockWidth
						-	fgkSSDMountingBlockHoleTubeWidth[0],0.);
  MountingBlockTubeTrans[1] = new TGeoTranslation("MountingBlockTubeTrans1",
						-	0.5*(fgkSSDMountingBlockLength[0]
						-	fgkSSDMountingBlockHoleTubeLength[0])
						+	fgkSSDMountingBlockHoleTubeLength[0],
						-	0.5*fgkSSDMountingBlockWidth
						+	fgkSSDMountingBlockHoleTubeWidth[0],
							0.);
  MountingBlockTubeTrans[2] = new TGeoTranslation("MountingBlockTubeTrans2",
						-	MountingBlockBoxShape[0]->GetDX()
						+	0.5*fgkSSDMountingBlockLength[0]
						-	fgkSSDMountingBlockHoleTubeLength[1],
							0.5*fgkSSDMountingBlockWidth
						-	fgkSSDMountingBlockHoleTubeWidth[0],
							MountingBlockBoxShape[2]->GetDZ()
						-	MountingBlockBoxShape[0]->GetDZ()
						+	fgkSSDMountingBlockHeight[3]);
  MountingBlockTubeTrans[3] = new TGeoTranslation("MountingBlockTubeTrans3",
						-	MountingBlockBoxShape[0]->GetDX()
						+	0.5*fgkSSDMountingBlockLength[0],
						-	0.5*fgkSSDMountingBlockWidth
						+	fgkSSDMountingBlockHoleTubeWidth[1],
							MountingBlockBoxShape[2]->GetDZ()
						-	MountingBlockBoxShape[0]->GetDZ()
						+	fgkSSDMountingBlockHeight[3]);
  for(Int_t i=0; i<2*MountingBlockTubeNumber; i++) 
						MountingBlockTubeTrans[i]->RegisterYourself();
  /* TGeoCompositeShape* MountingBlockMainShape = */
						new TGeoCompositeShape("MountingBlockMainShape",
						"MountingBlockBoxShape0:MountingBlockBoxTrans0+"
						"MountingBlockBoxShape1:MountingBlockBoxTrans1+"
						"MountingBlockBoxShape2:MountingBlockBoxTrans2+"
						"MountingBlockBoxShape1:MountingBlockBoxTrans3+"
						"MountingBlockBoxShape0:MountingBlockBoxTrans4");
  ////////////////////////////////////////////
  // Mounting Block Screw Composite Hole Shapes
  ////////////////////////////////////////////
  const Int_t MountingBlockHoleTubeSegNumber = 4;
  /* TGeoTubeSeg* MountingBlockHoleTubeSegShape =  */ 
						new TGeoTubeSeg("MountingBlockHoleTubeSegShape",
						0.0,
						fgkSSDMountingBlockScrewHoleRadius[0],
						0.5*fgkSSDMountingBlockScrewHoleHeigth,-90.,180.);
  TGeoCombiTrans* MountingBlockHoleTubeSegCombiTrans[MountingBlockHoleTubeSegNumber];
  char* MountingBlockHoleTubeSegCombiTransName[MountingBlockHoleTubeSegNumber] = 
					{	"MountingBlockHoleTubeSegCombiTrans0",
						"MountingBlockHoleTubeSegCombiTrans1",
						"MountingBlockHoleTubeSegCombiTrans2",
						"MountingBlockHoleTubeSegCombiTrans3"};
  for(Int_t i=0; i<MountingBlockHoleTubeSegNumber; i++){
    MountingBlockHoleTubeSegCombiTrans[i] =
      new TGeoCombiTrans(MountingBlockHoleTubeSegCombiTransName[i],
						0.5*fgkSSDMountingBlockScrewHoleEdge*TMath::Sqrt(2)
					*	TMath::Cos(45*(2*i+1)*TMath::DegToRad()),
						0.5*fgkSSDMountingBlockScrewHoleEdge*TMath::Sqrt(2)
					*	TMath::Sin(45*(2*i+1)*TMath::DegToRad()),
						0.0,
						new TGeoRotation("",90.*i,0.,0.));
    MountingBlockHoleTubeSegCombiTrans[i]->RegisterYourself();
  }
  TGeoBBox* MountingBlockHoleBoxShape = 
						new TGeoBBox("MountingBlockHoleBoxShape",
						0.5*fgkSSDMountingBlockScrewHoleEdge,
						0.5*fgkSSDMountingBlockScrewHoleEdge,
						0.5*fgkSSDMountingBlockScrewHoleHeigth);
  TGeoCompositeShape* MountingBlockScrewHole[2];
  MountingBlockScrewHole[0] = 
			new TGeoCompositeShape("MountingBlockScrewHole0",
			"MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans0+"
			"MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans1+"
			"MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans2+"
			"MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans3+"
			"MountingBlockHoleBoxShape");
  /* TGeoTubeSeg* MountingBlockLowerHoleTubeSegShape = */
			new TGeoTubeSeg("MountingBlockLowerHoleTubeSegShape",
						0.0,
						fgkSSDMountingBlockScrewHoleRadius[1],
						0.5*(fgkSSDMountingBlockHoleTubeWidth[0]
					-	fgkSSDMountingBlockScrewHoleHeigth
					-	fgkSSDMountingBlockHeight[3]),0.,90.); 
  TGeoCombiTrans* MountingBlockLowerHoleTubeSegCombiTrans[MountingBlockHoleTubeSegNumber];
  char* MountingBlockLowerHoleTubeSegCombiTransName[MountingBlockHoleTubeSegNumber] =
					{	"MountingBlockLowerHoleTubeSegCombiTrans0",
						"MountingBlockLowerHoleTubeSegCombiTrans1",
						"MountingBlockLowerHoleTubeSegCombiTrans2",
						"MountingBlockLowerHoleTubeSegCombiTrans3"};
  for(Int_t i=0; i<MountingBlockHoleTubeSegNumber; i++){
    MountingBlockLowerHoleTubeSegCombiTrans[i] =
			new TGeoCombiTrans(MountingBlockLowerHoleTubeSegCombiTransName[i],
						0.5*(fgkSSDMountingBlockScrewHoleEdge
					-	2.*fgkSSDMountingBlockScrewHoleRadius[1])
					*	TMath::Sqrt(2)*TMath::Cos(45*(2*i+1)*TMath::DegToRad()),
						0.5*(fgkSSDMountingBlockScrewHoleEdge
					-	2.0*fgkSSDMountingBlockScrewHoleRadius[1])
					*	TMath::Sqrt(2)*TMath::Sin(45*(2*i+1)*TMath::DegToRad()),0.,
						new TGeoRotation("",90.*i,0.,0.));
					MountingBlockLowerHoleTubeSegCombiTrans[i]->RegisterYourself();
  }
  Double_t fgkSSDMountingBlockLowerScrewHoleEdge = fgkSSDMountingBlockScrewHoleEdge
					-	2.*fgkSSDMountingBlockScrewHoleRadius[1];
  TGeoBBox* MountingBlockLowerHoleBoxShape[2];
  MountingBlockLowerHoleBoxShape[0] = 
			new TGeoBBox("MountingBlockLowerHoleBoxShape0",
						0.5*fgkSSDMountingBlockLowerScrewHoleEdge,
						0.5*fgkSSDMountingBlockLowerScrewHoleEdge,
						0.5*(fgkSSDMountingBlockHoleTubeWidth[0]
					-	fgkSSDMountingBlockScrewHoleHeigth
					-	fgkSSDMountingBlockHeight[3]));
  MountingBlockLowerHoleBoxShape[1] = 
			new TGeoBBox("MountingBlockLowerHoleBoxShape1",
						0.5*fgkSSDMountingBlockLowerScrewHoleEdge,
						0.5*fgkSSDMountingBlockScrewHoleRadius[1],
						0.5*(fgkSSDMountingBlockHoleTubeWidth[0]
					-	fgkSSDMountingBlockScrewHoleHeigth
					-	fgkSSDMountingBlockHeight[3]));
  TGeoCombiTrans* MountingBlockLowerHoleBoxCombiTrans[MountingBlockHoleTubeSegNumber];
  char* MountingBlockLowerHoleBoxCombiTransName[MountingBlockHoleTubeSegNumber] = 
					{	"MountingBlockLowerHoleBoxCombiTrans0",
						"MountingBlockLowerHoleBoxCombiTrans1",
						"MountingBlockLowerHoleBoxCombiTrans2",
						"MountingBlockLowerHoleBoxCombiTrans3"};
  for(Int_t i=0; i<MountingBlockHoleTubeSegNumber; i++){
    MountingBlockLowerHoleBoxCombiTrans[i] =
			new TGeoCombiTrans(MountingBlockLowerHoleBoxCombiTransName[i],
						0.5*(fgkSSDMountingBlockLowerScrewHoleEdge
					+	fgkSSDMountingBlockScrewHoleRadius[1])
					*	TMath::Cos(90*(i+1)*TMath::DegToRad()),
						0.5*(fgkSSDMountingBlockLowerScrewHoleEdge
					+	fgkSSDMountingBlockScrewHoleRadius[1])
					*	TMath::Sin(90*(i+1)*TMath::DegToRad()),0.,
						new TGeoRotation("",90.*i,0.,0.));
    MountingBlockLowerHoleBoxCombiTrans[i]->RegisterYourself();
  }
  MountingBlockScrewHole[1] = new TGeoCompositeShape("MountingBlockScrewHole1",
	"MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans0+"
	"MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans1+"
	"MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans2+"
	"MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans3+"
	"MountingBlockLowerHoleBoxShape0+"
	"MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans0+"
	"MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans1+"
	"MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans2+"
	"MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans3");
  TGeoTranslation* MountingBlockScrewHole1Trans = 
			new TGeoTranslation("MountingBlockScrewHole1Trans",0.,0.,
					-	MountingBlockLowerHoleBoxShape[0]->GetDZ()
					-	MountingBlockHoleBoxShape->GetDZ());
  MountingBlockScrewHole1Trans->RegisterYourself();
  /* TGeoCompositeShape* MountingBlockHole = */ 
			new TGeoCompositeShape("MountingBlockHole",
	"MountingBlockScrewHole0+MountingBlockScrewHole1:MountingBlockScrewHole1Trans");
  TGeoTranslation* MountingBlockHoleTrans = new TGeoTranslation("MountingBlockHoleTrans",
						0.5*fgkSSDMountingBlockLength[0]
					-	MountingBlockBoxShape[0]->GetDZ(),
						0.0,
						2.*MountingBlockBoxShape[2]->GetDZ()
					-	MountingBlockBoxShape[0]->GetDZ()
					+	fgkSSDMountingBlockHeight[3]
					-	MountingBlockHoleBoxShape->GetDZ());
  MountingBlockHoleTrans->RegisterYourself();
  TGeoCompositeShape* MountingBlockShape = new TGeoCompositeShape("MountingBlockShape",
			"MountingBlockMainShape-(MountingBlockTubeShape0:MountingBlockTubeTrans0+"
			"MountingBlockTubeShape0:MountingBlockTubeTrans1+"
			"MountingBlockTubeShape1:MountingBlockTubeTrans2+"
			"MountingBlockTubeShape1:MountingBlockTubeTrans3+"
			"HoleTrapezoidShape:HoleTrapezoidShapeCombiTrans+"
			"MountingBlockHole:MountingBlockHoleTrans)");
  TGeoVolume* SSDMountingBlock = new TGeoVolume("SSDMountingBlock",
			MountingBlockShape,fgkSSDMountingBlockMedium);
  return SSDMountingBlock;
}
////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetLadder(Int_t iLayer){
  TGeoVolume* Ladder = new TGeoVolumeAssembly(iLayer==5 ? "ITSssdLay5Ladd" 
														: "ITSssdLay6Ladd");
  TGeoVolume* LadderSegment[2];
  LadderSegment[0] = GetLadderSegment(0);
  LadderSegment[1] = GetLadderSegment(1);
  TList* EndLadderSegmentList = GetEndLadderSegment();
  Double_t BeamAxisTransVector = fgkCarbonFiberJunctionWidth;
  Int_t SSDLaySensorsNumber = (iLayer==5 ? 
						fgkSSDLay5SensorsNumber : 
						fgkSSDLay6SensorsNumber);
  for(Int_t i=0; i<SSDLaySensorsNumber; i++) Ladder->AddNode(i%2==0 ? 
						LadderSegment[iLayer==5 ? 0 : 1] : 
						LadderSegment[iLayer==5 ? 1 : 0],
						SSDLaySensorsNumber-i,new TGeoTranslation("",-0.5*fgkCarbonFiberTriangleLength,
						BeamAxisTransVector*i,0.));
  Ladder->AddNode((TGeoVolume*)EndLadderSegmentList->At(0),1,
						new TGeoTranslation("",-0.5*fgkCarbonFiberTriangleLength,
						fgkCarbonFiberJunctionWidth*SSDLaySensorsNumber,0.));
  Ladder->AddNode((TGeoVolume*)EndLadderSegmentList->At(1),1,
						new TGeoCombiTrans("",0.5*fgkCarbonFiberTriangleLength,
						0.,0.,new TGeoRotation("",180.,0.,0.)));
/////////////////////////////////////////////////////////////////////////////						
/// Placing Ladder Cables
/////////////////////////////////////////////////////////////////////////////		
  SetLadderCableCombiTransMatrix(iLayer);
  Int_t SideCableNumber[2] = {0,0};
  switch(iLayer){
	case 5: 
		SideCableNumber[0] = fgkSSDLay5SensorsNumber/2+1; 
		SideCableNumber[1] = SideCableNumber[0]-2;
		break;
    case 6:
		SideCableNumber[0] = (fgkSSDLay6SensorsNumber-1)/2+1;
		SideCableNumber[1] = SideCableNumber[0]-1;
		break;
  }
  const Double_t* CarbonFiberToModulePosition = 
							 LadderSegmentCombiTransMatrix[1]->GetTranslation();
  Double_t SSDEndLadderCableLength[4];
  SSDEndLadderCableLength[0] = CarbonFiberToModulePosition[1]
							 + fgkSSDSensorLength
							 - fgkSSDModuleStiffenerPosition[1]
							 - fgkSSDStiffenerWidth 
							 - fgkSSDFlexWidth[0]
							 + fgkEndLadderCarbonFiberLowerJunctionLength[1];
  SSDEndLadderCableLength[1] = CarbonFiberToModulePosition[1]
							 + fgkSSDModuleStiffenerPosition[1]
							 + fgkSSDStiffenerWidth
							 + fgkEndLadderCarbonFiberLowerJunctionLength[1];
  SSDEndLadderCableLength[2] = SSDEndLadderCableLength[1]
							 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
							 + fgkEndLadderCarbonFiberLowerJunctionLength[0];
  SSDEndLadderCableLength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
							 + CarbonFiberToModulePosition[1]
							 - fgkSSDModuleStiffenerPosition[1]
							 - fgkSSDStiffenerWidth)
							 + fgkEndLadderCarbonFiberLowerJunctionLength[1];
  TList* LadderCableAssemblyList[4];
  const Int_t EndLadderCablesNumber = 4;
  for(Int_t i=0; i<EndLadderCablesNumber; i++){
	  LadderCableAssemblyList[i] = 
	  GetLadderCableAssemblyList(SideCableNumber[i<2?0:1],
								   SSDEndLadderCableLength[i]);
	  Ladder->AddNode((TGeoVolume*)LadderCableAssemblyList[i]->At(i%2==0?0:1),
									i<2?1:2,LadderCableCombiTransMatrix[i]);
  }
  return Ladder;
}								  
////////////////////////////////////////////////////////////////////////////////
TGeoVolume* AliITSv11GeometrySSD::GetLayer(Int_t iLayer){
  TGeoVolume* Layer = new TGeoVolumeAssembly(iLayer==5 ? "ITSssdLayer5" 
													   : "ITSssdLayer6");
  TGeoVolume* Ladder = GetLadder(iLayer);
  /////////////////////////////////////////////////////
  // Setting the CombiTransformation to pass ITS center 
  /////////////////////////////////////////////////////
  Double_t ITSCenterTransZ = iLayer==5 ? fgkSSDLay5LadderLength
                           -             fgkLay5CenterITSPosition: 
                                         fgkSSDLay6LadderLength
                           -             fgkLay6CenterITSPosition;
  Double_t ITSSensorYTrans = fgkSSDModuleCoolingBlockToSensor
                           + 0.5*        fgkCoolingTubeSupportHeight
                           -(iLayer==5 ? fgkSSDSensorSideSupportHeight[1]
                           -             fgkSSDSensorSideSupportHeight[0]: 0.);
  TGeoRotation* ITSCenterRot[3];
  ITSCenterRot[0] = new TGeoRotation("ITSCenterRot0",90.,180.,-90.);
  ITSCenterRot[1] = new TGeoRotation("ITSCenterRot1",0.,90.,0.);
  ITSCenterRot[2] = new TGeoRotation((*ITSCenterRot[1])*(*ITSCenterRot[0]));
  TGeoCombiTrans* ITSCenterCombiTrans = new TGeoCombiTrans("ITSCenterCombiTrans",0.,
                                        fgkSSDMountingBlockHeight[1]+ITSSensorYTrans,
                                        fgkEndLadderCarbonFiberLowerJunctionLength[1]
                                      - ITSCenterTransZ,ITSCenterRot[2]);
  /////////////////////////////////////////////////////
  // Setting the Ladder into the Layer 
  /////////////////////////////////////////////////////
  Double_t LayLadderAnglePosition = 360./(iLayer==5 ? fgkSSDLay5LadderNumber : 
                                          fgkSSDLay6LadderNumber);
  Int_t LayLadderNumber        = iLayer==5 ? fgkSSDLay5LadderNumber : 
                                             fgkSSDLay6LadderNumber; 
  Double_t LayRadiusMin        = iLayer==5 ? fgkSSDLay5RadiusMin    : 
                                             fgkSSDLay6RadiusMin;
  Double_t LayRadiusMax        = iLayer==5 ? fgkSSDLay5RadiusMax    : 
                                             fgkSSDLay6RadiusMax;
  TGeoCombiTrans* LadderCombiTrans[LayLadderNumber];
  TGeoHMatrix* LadderHMatrix[LayLadderNumber];
  Double_t LayerRadius = 0.;
  char LadderCombiTransName[30], LadderRotName[30];
  for(Int_t i=0; i<LayLadderNumber;i++){
      sprintf(LadderCombiTransName,"LadderCombiTrans%i",i);
      sprintf(LadderRotName,"LaddeRot%i",i);
      switch(iLayer){
            case 5: 
                  LayerRadius = (i%2==0 ? LayRadiusMin: LayRadiusMax);
                  break;
            case 6:
                  LayerRadius = (i%2==0 ? LayRadiusMax : LayRadiusMin);
                  break;
      }
      LadderCombiTrans[i] = new TGeoCombiTrans(LadderCombiTransName,
                            LayerRadius *	TMath::Cos((i+1)
                          * LayLadderAnglePosition*TMath::DegToRad()),
                            LayerRadius *	TMath::Sin((i+1)
                          * LayLadderAnglePosition*TMath::DegToRad()),0.,
                            new TGeoRotation(LadderRotName,(i+1)
                          * LayLadderAnglePosition-90,0.,0.));
    LadderHMatrix[i] = new TGeoHMatrix((*LadderCombiTrans[i])
                          * (*ITSCenterCombiTrans));
    Layer->AddNode(Ladder,i+1,LadderHMatrix[i]);          
  }   
  return Layer;
}
////////////////////////////////////////////////////////////////////////////////
void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
////////////////////////////////////////////////////////////////////////////////
// Insert the layer 5 in the mother volume. 
////////////////////////////////////////////////////////////////////////////////
	if(! moth){
		cout << "Error::AliITSv11GeometrySSD: Can't insert layer5, mother is null!"<< endl;
		return;
	}
	fMotherVol = moth;
	moth->AddNode(GetLayer(5),1,0);
}
////////////////////////////////////////////////////////////////////////////////
void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
////////////////////////////////////////////////////////////////////////////////
// Insert the layer 6 in the mother volume. 
////////////////////////////////////////////////////////////////////////////////
	if(! moth){
		cout << "Error::AliITSv11GeometrySSD: Can't insert layer6, mother is null!"<< endl;
		return;
	}
	fMotherVol = moth;
	moth->AddNode(GetLayer(6),1,0);
}
////////////////////////////////////////////////////////////////////////////////
TGeoArb8* AliITSv11GeometrySSD::GetTrapezoidShape(TVector3* vertexpos[], 
							Double_t* width, Double_t height, char* shapename){
////////////////////////////////////////////////////////////////////////////////
  const Int_t VertexNumber = 4;
  const Int_t TransVectNumber = 2;
  TVector3* Vertex[VertexNumber];
  TVector3* TransVector[2];
  for(Int_t i=0; i<TransVectNumber; i++) 
									TransVector[i] = new TVector3(0.,width[i]);
////////////////////////////////////////////////////////////////////////////////
  //Setting the vertices
////////////////////////////////////////////////////////////////////////////////
  Vertex[0] = new TVector3(*vertexpos[0]);
  Vertex[1] = new TVector3(*vertexpos[1]);
  Vertex[2] = new TVector3(*Vertex[1]+*TransVector[1]);
  Vertex[3] = new TVector3(*Vertex[0]+*TransVector[0]);
  TGeoArb8* TrapezoidShape = new TGeoArb8(shapename,0.5*height);
  for(Int_t i=0; i<2*VertexNumber; i++) 
	TrapezoidShape->SetVertex(i,Vertex[(i<VertexNumber ? i : i-VertexNumber)]->X(),
								Vertex[(i<VertexNumber ? i : i-VertexNumber)]->Y()); 
  return TrapezoidShape;
}
////////////////////////////////////////////////////////////////////////////////
TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width, 
									Double_t height, char* shapename, Int_t isign){
  const Int_t VertexNumber = 8;
  const Int_t TransVectNumber = 2;
  TVector3* Vertex[VertexNumber];
  TVector3* TransVector[2];
  for(Int_t i=0; i<TransVectNumber; i++) TransVector[i] = new TVector3(0.,width[i]);
////////////////////////////////////////////////////////////////////////////////
  //Setting the vertices for TGeoArb8
////////////////////////////////////////////////////////////////////////////////
  Vertex[0] = new TVector3(*vertexpos[0]);
  Vertex[1] = new TVector3(*vertexpos[1]);
  Vertex[2] = new TVector3(*Vertex[1]+isign*(*TransVector[0]));
  Vertex[3] = new TVector3(*Vertex[0]+isign*(*TransVector[0]));
  Vertex[4] = new TVector3(*vertexpos[2]);
  Vertex[5] = new TVector3(*vertexpos[3]);
  Vertex[6] = new TVector3(*Vertex[5]+isign*(*TransVector[1]));
  Vertex[7] = new TVector3(*Vertex[4]+isign*(*TransVector[1]));
////////////////////////////////////////////////////////////////////////////////
  TGeoArb8* ArbShape = new TGeoArb8(shapename,0.5*height);
  for(Int_t i = 0; i<VertexNumber;i++) 
							ArbShape->SetVertex(i,Vertex[i]->X(),Vertex[i]->Y());
  return ArbShape;
} 
////////////////////////////////////////////////////////////////////////////////
TGeoArb8* AliITSv11GeometrySSD::GetTriangleShape(TVector3* vertexpos[], 
											  Double_t height, char* shapename){
////////////////////////////////////////////////////////////////////////////////
  const Int_t VertexNumber = 4;
  TVector3* Vertex[VertexNumber];
//////////////////////////////////////
  //Setting the vertices for TGeoArb8
  ////////////////////////////////////
  for(Int_t i = 0; i<VertexNumber; i++)  
  Vertex[i] = new TVector3(i!=VertexNumber-1?*vertexpos[i]:*Vertex[VertexNumber-1-i]);
  TGeoArb8* TriangleShape = new TGeoArb8(shapename,0.5*height);
  for(Int_t i = 0; i<2*VertexNumber; i++) 
	TriangleShape->SetVertex(i,Vertex[(i < VertexNumber ? i: i-VertexNumber)]->X(),
							   Vertex[(i < VertexNumber ? i : i-VertexNumber)]->Y());
  return TriangleShape;
}
////////////////////////////////////////////////////////////////////////////////
TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* Vector,Double_t* Param){
////////////////////////////////////////////////////////////////////////////////
  TVector3* n = new TVector3(Param[0],Param[1],Param[2]);
  Double_t D = ((*Vector)*(*n)+Param[3])/n->Mag2();
  TVector3* ReflectedVector = new TVector3(*Vector-2*D*(*n));
  return ReflectedVector;
}
////////////////////////////////////////////////////////////////////////////////
TGeoCombiTrans* AliITSv11GeometrySSD::AddTranslationToCombiTrans(TGeoCombiTrans* ct,
                                                       Double_t dx,
                                                       Double_t dy,
                                                       Double_t dz) const{
  TGeoCombiTrans* CombiTrans = new TGeoCombiTrans(*ct);
  // Add a dx,dy,dz translation to the initial TGeoCombiTrans
  const Double_t *vect = CombiTrans->GetTranslation();
  Double_t newVect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
  CombiTrans->SetTranslation(newVect);
  return CombiTrans;
}
////////////////////////////////////////////////////////////////////////////////
//To be interfaced with AliRoot Materials file
////////////////////////////////////////////////////////////////////////////////
TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
  char ch[30];
  sprintf(ch, "ITS_%s",mediumName);
  TGeoMedium* medium =  gGeoManager->GetMedium(ch);
  if (! medium)
    printf("Error(AliITSv11GeometrySSD)::medium %s not found !\n", mediumName);
  return medium;
}
////////////////////////////////////////////////////////////////////////////////
//To be interfaced with AliRoot Materials file
////////////////////////////////////////////////////////////////////////////////
/*void AliITSv11GeometrySSD::CreateMaterials(){
///////////////////////////////////
// This part has to be modified
///////////////////////////////////
//  Float_t ifield =  2.000;
//  Float_t fieldm = 10.000;
//    Int_t   ifield = gAlice->Field()->Integ();
//    Float_t fieldm = gAlice->Field()->Max();
  ///////////////////////////////////
  // Silicon for Sensor
  /////////////////////////////////// 
  Int_t SINumber = 0;
  TGeoMaterial* SiMaterial = new TGeoMaterial("SiMaterial");
  TGeoMedium* Silicon = new TGeoMedium("Silicon",SINumber,SiMaterial);
  fgkSSDSensorMedium = Silicon;
  ///////////////////////////////////
  // Silicon Mixture for Sensor
  /////////////////////////////////// 
  Int_t SiMixtureNumber = 1;
  TGeoMaterial* SiMixtureMaterial = new TGeoMaterial("SiMixtureMaterial");
  TGeoMedium* SiliconMixture = new TGeoMedium("SiliconMixture",SiMixtureNumber,SiMixtureMaterial);
  fgkSSDChipMedium = SiliconMixture;
  ///////////////////////////////////
  // Stiffener Components Materials
  /////////////////////////////////// 
  Int_t K1100Number = 2;
  TGeoMaterial* K1100Material = new TGeoMaterial("K1100Material");
  TGeoMedium* K1100 = new TGeoMedium("K1100",K1100Number,K1100Material);
  fgkSSDStiffenerMedium = K1100;
  ///////////////////////////  
  // Stiffener Connectors 
  ///////////////////////////  
  Int_t SnMaterialNumber = 3;
  TGeoMaterial* SnMaterial = new TGeoMaterial("SnMaterial");
  TGeoMedium* SnMedium = new TGeoMedium("SnMedium",SnMaterialNumber,
                                                SnMaterial);
  fgkSSDStiffenerConnectorMedium = SnMedium;
  ////////////////////////////////  
  // Stiffener 0603-1812 Capacitor
  ////////////////////////////////  
  Int_t Al2O3Number = 4;
  TGeoMaterial* Al2O3Material = new TGeoMaterial("Al2O3Material");
  TGeoMedium* Al2O3Medium = new TGeoMedium("Al2O3Medium",
                                                Al2O3Number,
                                                Al2O3Material);
  fgkSSDStiffener0603CapacitorMedium = Al2O3Medium;
  fgkSSDStiffener1812CapacitorMedium = Al2O3Medium;
  ///////////////////////////  
  // Stiffener Hybrid Wire 
  ///////////////////////////  
  Int_t CuHybridWireNumber = 5;
  TGeoMaterial* CuHybridWireMaterial = new TGeoMaterial("CuHybridWireMaterial");
  TGeoMedium* CuHybridWireMedium = new TGeoMedium("CuHybridWireMedium",
                                                CuHybridWireNumber,
                                                CuHybridWireMaterial);
  fgkSSDStiffenerHybridWireMedium = CuHybridWireMedium;
  ///////////////////////////  
  // Al for Cooling Block
  ///////////////////////////  
  Int_t AlCoolBlockNumber = 6;
  TGeoMaterial* AlCoolBlockMaterial = new TGeoMaterial("AlCoolBlockMaterial");
  TGeoMedium* AlCoolBlockMedium = new TGeoMedium("AlCoolBlockMedium",
                                                AlCoolBlockNumber,
                                                AlCoolBlockMaterial);
  fgkSSDAlCoolBlockMedium = AlCoolBlockMedium;
  //////////////////////////////////////////////////////  
  // Kapton and Al for Chip Cable Flex and Ladder Cables
  //////////////////////////////////////////////////////  
  Int_t KaptonBlockNumber = 7;
  TGeoMaterial* KaptonMaterial = new TGeoMaterial("KaptonMaterial");
  TGeoMedium* KaptonMedium = new TGeoMedium("KaptonMedium",
                                                KaptonBlockNumber,
                                                KaptonMaterial);
  Int_t AlTraceBlockNumber = 8;
  TGeoMaterial* AlTraceMaterial = new TGeoMaterial("AlTraceMaterial");
  TGeoMedium* AlTraceMedium = new TGeoMedium("AlTraceMedium",
                                                AlTraceBlockNumber,
                                                AlTraceMaterial);
  fgkSSDKaptonChipCableMedium = KaptonMedium;
  fgkSSDAlTraceChipCableMedium = AlTraceMedium;
  fgkSSDKaptonFlexMedium = KaptonMedium;
  fgkSSDAlTraceFlexMedium = AlTraceMedium;
  fgkSSDKaptonLadderCableMedium = KaptonMedium;
  fgkSSDAlTraceLadderCableMedium = AlTraceMedium;
  /////////////////////////////////////////////////////////////////  
  // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
  //////////////////////////////////////////////////////////////////  
  Int_t M55JNumber = 9;
  TGeoMaterial* M55JMaterial = new TGeoMaterial("M55JMaterial");
  TGeoMedium* M55JMedium = new TGeoMedium("M55JMedium",M55JNumber,
                                           M55JMaterial);
  fgkSSDCarbonFiberMedium = M55JMedium;
  fgkSSDMountingBlockMedium = M55JMedium;
  /////////////////////////////////////////////////////////////////  
  // G10 for Detector Leg, TubeHolder
  //////////////////////////////////////////////////////////////////  
  Int_t G10Number = 10;
  TGeoMaterial* G10Material = new TGeoMaterial("G10Material");
  TGeoMedium* G10Medium = new TGeoMedium("G10Medium",G10Number,
                                           G10Material);
  fgkSSDTubeHolderMedium = G10Medium;
  fgkSSDSensorSupportMedium = G10Medium;
  /////////////////////////////////////////////////////////////////  
  // Water and Phynox for Cooling Tube
  //////////////////////////////////////////////////////////////////  
  Int_t WaterNumber = 11;
  TGeoMaterial* WaterMaterial = new TGeoMaterial("WaterMaterial");
  TGeoMedium* WaterMedium = new TGeoMedium("WaterMedium",WaterNumber,
                                           WaterMaterial);
  fgkSSDCoolingTubeWater = WaterMedium;
  Int_t PhynoxNumber = 12;
  TGeoMaterial* PhynoxMaterial = new TGeoMaterial("PhynoxMaterial");
  TGeoMedium* PhynoxMedium = new TGeoMedium("PhynoxMedium",PhynoxNumber,
                                           PhynoxMaterial);
  fgkSSDCoolingTubePhynox = PhynoxMedium;
}
*/
void AliITSv11GeometrySSD::CreateMaterials(){
///////////////////////////////////
// This part has to be modified
///////////////////////////////////
  ///////////////////////////////////
  // Silicon for Sensor
  /////////////////////////////////// 
  fgkSSDSensorMedium = GetMedium("Si");
  ///////////////////////////////////
  // Silicon Mixture for Sensor
  /////////////////////////////////// 
  fgkSSDChipMedium = GetMedium("SPD SI CHIP$");
  fgkSSDChipGlueMedium = GetMedium("EPOXY$");
  ///////////////////////////////////
  // Stiffener Components Materials
  /////////////////////////////////// 
  fgkSSDStiffenerMedium = GetMedium("ITSsddCarbonM55J");
  ///////////////////////////  
  // Stiffener Connectors 
  ///////////////////////////  
  fgkSSDStiffenerConnectorMedium = GetMedium("COPPER");
  ////////////////////////////////  
  // Stiffener 0603-1812 Capacitor
  ////////////////////////////////  
  fgkSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3");
  fgkSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3");
  ///////////////////////////  
  // Stiffener Hybrid Wire 
  ///////////////////////////  
  fgkSSDStiffenerHybridWireMedium = GetMedium("COPPER");
  ///////////////////////////  
  // Al for Cooling Block
  ///////////////////////////  
  fgkSSDAlCoolBlockMedium = GetMedium("ITSal");
  //////////////////////////////////////////////////////  
  // Kapton and Al for Chip Cable Flex and Ladder Cables
  //////////////////////////////////////////////////////  
  fgkSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)");
  fgkSSDAlTraceChipCableMedium = GetMedium("ITSal");
  fgkSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)");
  fgkSSDAlTraceFlexMedium = GetMedium("ITSal");
  fgkSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)");
  fgkSSDAlTraceLadderCableMedium = GetMedium("ITSal");
  /////////////////////////////////////////////////////////////////  
  // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
  //////////////////////////////////////////////////////////////////  
  fgkSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
  /////////////////////////////////////////////////////////////////  
  // G10 for Detector Leg, TubeHolder
  //////////////////////////////////////////////////////////////////  
  fgkSSDTubeHolderMedium = GetMedium("G10FR4$");
  fgkSSDSensorSupportMedium = GetMedium("G10FR4$");
  fgkSSDMountingBlockMedium = GetMedium("G10FR4$");
  fgkSSDMountingBlockMedium = GetMedium("G10FR4$");
  /////////////////////////////////////////////////////////////////  
  // Water and Phynox for Cooling Tube
  //////////////////////////////////////////////////////////////////  
  fgkSSDCoolingTubeWater = GetMedium("WATER");
  fgkSSDCoolingTubePhynox = GetMedium("INOX$");
}
/////////////////////////////////////////////////////////////////////