Update of SSD cable mass at ladder ends and on support cone to patch panels (outside...
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 26 Mar 2013 10:44:42 +0000 (10:44 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 26 Mar 2013 10:44:42 +0000 (10:44 +0000)
ITS/AliITSv11GeometrySSD.cxx
ITS/AliITSv11GeometrySSD.h

index 0b221e7..4775b20 100644 (file)
@@ -523,25 +523,7 @@ const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportRadius = 297.5*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportWidth = 6.28*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportLength = 60.0*fgkmm;
 const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportWidth = 2.5*fgkSSDCentralSupportWidth;
-/////////////////////////////////////////////////////////////////////////////////
-// SSD Cables Parameters (lengths are in mm and angles in degrees)
-/////////////////////////////////////////////////////////////////////////////////
-const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5TubeRadiusMin = 11.9*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay6TubeRadiusMin = 11.9*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5RightSideHeight = 7.*fgkmm;  // to be fixed in order to reproduce material budget
-const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay6RightSideHeight = 7.*fgkmm;  // to be fixed in order to reproduce material budget
-const Double_t AliITSv11GeometrySSD::fgkSSDCableAngle = 22.5;
-const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5RightSideWaterHeight = 2.5*fgkmm;  // to be fixed in order to reproduce material budget
-const Double_t AliITSv11GeometrySSD::fgkSSDCablesPatchPanel2RB26Angle[2] = {25.0,53.2};
-const Double_t AliITSv11GeometrySSD::fgkSSDCablesPatchPanel2RB24Angle[2] = {23.0,53.6};
-const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26ITSDistance = 975.0*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24ITSDistance = 1020.0*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = 451.3*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = 451.3*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanelHeight = 87.5*fgkmm;
-const Double_t AliITSv11GeometrySSD::fgkSSDCableMaterialBudgetHeight = 20.0*fgkmm;
-//const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = fgkSSDPConeExternalRadius;
-//const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = fgkSSDPConeExternalRadius;
+
 /////////////////////////////////////////////////////////////////////////////////
 ClassImp(AliITSv11GeometrySSD)
 /////////////////////////////////////////////////////////////////////////////////
@@ -7401,43 +7383,53 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
 }
  ////////////////////////////////////////////////////////////////////////////////
  TGeoVolume* AliITSv11GeometrySSD::SetSSDCables(){
-  /////////////////////////////////////////////////////////////
-  // Method generating SSDCables
-  /////////////////////////////////////////////////////////////
-  // SSD Layer 5 Cables
-  //////////////////////////////////////////////////////////////////////////////////////////////////
-  TGeoVolumeAssembly* ssdcablesmother = new TGeoVolumeAssembly("SSDCables");
-  Double_t ssdcablelayvertical = 0.05; // Internal variables to control overlapping with SDD cables
-  Double_t ssdcablelaylateral = 0.55;   // Internal variables to control overlapping with SDD cables
-  Double_t ssdcablesfactor = 0.5;     // Internal variables to control overlapping with SDD cables
-  //////////////////////////////////////////////////////////////////////////////////////////////////
-  Double_t ssdcableslay5rigthsideradiusmin = fgkEndCapSupportMiddleRadius[0]+fgkSSDCablesLay5TubeRadiusMin;  
-  Double_t ssdcableslay5endconedistance = (ssdcableslay5rigthsideradiusmin
-                                                                           -  fgkSSDLowerPConeRadius)
-                                                                           * TanD(fgkSSDPConeAngle);
-  Double_t ssdcableslay5startconedistance = fgkEndCapSupportCenterLay5ITSPosition
-                                                                             + fgkEndCapSupportCenterLay5Position
-                                                                             - 0.5*fgkSSDCentralSupportLength-fgkSSDCentralAL3SupportLength;
-  Double_t ssdcablelay5rightsidelength = ssdcableslay5endconedistance
-                                                                          - ssdcableslay5startconedistance; 
-  ssdcablelay5rightsidelength *= ssdcablesfactor;
-  Double_t ssdcableslay5rightsideradiusmax = ssdcableslay5rigthsideradiusmin+fgkSSDCablesLay5RightSideHeight; 
-  TGeoTube* ssdcablelay5rightubeshape = new TGeoTube(ssdcableslay5rigthsideradiusmin,
-                                                                                               ssdcableslay5rightsideradiusmax,
-                                                                                               0.5*ssdcablelay5rightsidelength); 
-  TGeoVolume* ssdcablelay5righttube = new TGeoVolume("SSDCableLay5RightSideTube",
-                                                                                                        ssdcablelay5rightubeshape,
-                                                                                                        fSSDCopper);
-  ssdcablelay5righttube->SetLineColor(9);
-  TGeoTranslation* ssdcablelay5rightrans = 
-                                         new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay5ITSPosition
-                                                                                +              fgkEndCapSupportCenterLay5Position
-                                                                                +      0.5*ssdcablelay5rightsidelength);
+   /////////////////////////////////////////////////////////////
+   // Method generating SSDCables
+   /////////////////////////////////////////////////////////////
+
+   /////////////////////////////////////////////////////////////////////////////////
+   // SSD Cables Parameters (lengths are in mm and angles in degrees)
+   /////////////////////////////////////////////////////////////////////////////////
+   
+   const Double_t kSSDCablesLay5TubeRadiusMin = 11.9*fgkmm;
+   const Double_t kSSDCablesLay6TubeRadiusMin = 11.9*fgkmm;
+   
+   // Cable thickness for rings at outer Z
+   // Average: 9/2 = 4.5 cables per quadrant
+   // Ideally 1/16 * 38(34) cables, but take factor to (1/8) to accomodate kinks and loops (there are only 2 different cable lengths); 21 mm^2 Cu each
+
+   const Double_t kSSDCablesLay5RingArea = 21.*34./8.*fgkmm*fgkmm;  // to be fixed in order to reproduce material budget
+   const Double_t kSSDCablesLay6RingArea = 21.*38./8.*fgkmm*fgkmm;  // to be fixed in order to reproduce material budget
+   
+   
+   const Double_t kSSDCablesHeight = 3.2*fgkmm;  // 3.2 mm*13 cm width = 18 cables, 185g/m each Add fudge factor of 2 to get to ~25 kg measured
+
+   const Double_t kSSDCableAngle = 22.5;
+   // MvL: remove water?
+   const Double_t kSSDCablesLay5RightSideWaterHeight = 2.5*fgkmm;  // to be fixed in order to reproduce material budget
+   const Double_t kSSDCablesPatchPanel2RB26Angle[2] = {25.0,53.2};
+   const Double_t kSSDCablesPatchPanel2RB24Angle[2] = {23.0,53.6};
+   const Double_t kSSDPatchPanel2RB26ITSDistance = 975.0*fgkmm;
+   const Double_t kSSDPatchPanel2RB24ITSDistance = 1020.0*fgkmm;
+   const Double_t kSSDPatchPanel2RB26Radius = 451.3*fgkmm;
+   const Double_t kSSDPatchPanel2RB24Radius = 451.3*fgkmm;
+   const Double_t kSSDPatchPanelHeight = 87.5*fgkmm;
+   
+   // SSD Layer 5 Cables
+   //////////////////////////////////////////////////////////////////////////////////////////////////
+   TGeoVolumeAssembly* ssdcablesmother = new TGeoVolumeAssembly("SSDCables");
+   Double_t ssdcablelayvertical = 0.05; // Internal variables to control overlapping with SDD cables
+   Double_t ssdcablelaylateral = 0.55;   // Internal variables to control overlapping with SDD cables
+   //////////////////////////////////////////////////////////////////////////////////////////////////
+  // Printf(Form("Cable ring: rad min: %g length %g thick %g", ssdcableslay5rigthsideradiusmin, ssdcablelay5rightsidelength, kSSDCablesLay5RingArea/ssdcablelay5rightsidelength));
+  
+
+  
   ////////////////////////////////////
   //  Double_t cablescapacity[20];
   //  cablescapacity[0] = ssdcablelay5rightubeshape->Capacity();
   ////////////////////////////////////
-  ssdcablesmother->AddNode(ssdcablelay5righttube,1,ssdcablelay5rightrans);
+  //ssdcablesmother->AddNode(ssdcablelay5righttube,1,ssdcablelay5rightrans);
   ////////////////////////////////////
   // TGeoPCone Volumes
   ///////////////////////////////////
@@ -7447,26 +7439,41 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
   Double_t ssdcableslay5pconzsection[6];
   Double_t ssdcableslay5pconrmin[6];
   Double_t ssdcableslay5pconrmax[6];
-  ssdcableslay5pconrmin[0] = ssdcablelay5rightubeshape->GetRmin();
-  ssdcableslay5pconrmax[0] = ssdcablelay5rightubeshape->GetRmax();
+  ssdcableslay5pconrmin[0] = fgkEndCapSupportMiddleRadius[0]+kSSDCablesLay5TubeRadiusMin;
   ssdcableslay5pconrmin[1] = fgkSSDPConeUpRadius*(1.0+ssdcablelayvertical);
-  ssdcableslay5pconrmax[1] = ssdcableslay5pconrmin[1]+fgkSSDCablesLay5RightSideHeight;
+
   ssdcableslay5pconzsection[0] = fgkEndCapSupportCenterLay5ITSPosition
-                                                          + fgkEndCapSupportCenterLay5Position
-                                                          + 2.*ssdcablelay5rightubeshape->GetDz();
+                                 + fgkEndCapSupportCenterLay5Position;
+                                //+ 2.*ssdcablelay5rightsidelength;  // removing this generates overlap with the water ring 
+                                // Keeping it generates overlap with the cones...
+  // SSDCables/SSDCableLay5RightSideWaterTube_2 ovlp=0.0939792
   ssdcableslay5pconzsection[1] = 0.5*fgkSSDCentralSupportLength
                                                           + fgkSSDCentralAL3SupportLength
                                                           + (fgkSSDPConeUpRadius-fgkSSDLowerPConeRadius)
                                                           * TanD(fgkSSDPConeAngle);      
+  Double_t dz = ssdcableslay5pconzsection[1]-ssdcableslay5pconzsection[0];
+  Double_t pconethickness = kSSDCablesLay5RingArea/TMath::Abs(dz);
+  ssdcableslay5pconrmax[0] = ssdcableslay5pconrmin[0]+pconethickness;
+  ssdcableslay5pconrmax[1] = ssdcableslay5pconrmin[1]+pconethickness;
+  //Printf(Form("pcone: r1 %g  r2 %g z1 %g z2 %g thickness %g", ssdcableslay5pconrmax[0], ssdcableslay5pconrmax[1], 
+  //         ssdcableslay5pconzsection[0],ssdcableslay5pconzsection[1],pconethickness));
+  
   for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[0]->DefineSection(i,ssdcableslay5pconzsection[i],
                                                  ssdcableslay5pconrmin[i],ssdcableslay5pconrmax[i]); 
   ssdcableslay5pcon[0] = new TGeoVolume("SSDCableLay5RightSidePCon1",
                                                           ssdcableslay5pconshape[0],fSSDCopper);
   ssdcableslay5pcon[0]->SetLineColor(9);
   ssdcablesmother->AddNode(ssdcableslay5pcon[0],1);
+
+  Double_t totvol = ssdcableslay5pcon[0]->Capacity();
+  // Printf(Form("Cables, lay5, pCone,volume: %g", ssdcableslay5pcon[0]->Capacity()));
 ////////////////////////////////////
 //  cablescapacity[1] = ssdcableslay5pconshape[0]->Capacity();
 ////////////////////////////////////
+
+  //
+  //   PCon 2 and 3 are cables going through/towards holes in supports
+  //
   ssdcableslay5pconzsection[2] = ssdcableslay5pconzsection[1];
   ssdcableslay5pconzsection[3] = 0.5*fgkSSDCentralSupportLength
                                                           + fgkSSDCentralAL3SupportLength
@@ -7475,20 +7482,21 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
   Double_t ssdcableangle = (fgkSSDPConeTrapezoidBasis-2.*(fgkSSDPConeUpMaxRadius
                                             -  fgkSSDPConeUpRadius)/TanD(fgkSSDPConeTrapezoidAngle))
                                                 /  fgkSSDPConeUpRadius*TMath::RadToDeg()*2;
-  ssdcableslay5pconshape[1] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
-                                                                                  ssdcableangle,2);   
+  ssdcableslay5pconshape[1] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
+                                                                                  ssdcableangle,2);
+  // Printf(Form("PCon2, phi %g dphi %g ",90.0-kSSDCableAngle-0.5*ssdcableangle, ssdcableangle));
   ssdcableslay5pconrmin[2] = ssdcableslay5pconrmin[1];
-  ssdcableslay5pconrmax[2] = ssdcableslay5pconrmax[1];
+  ssdcableslay5pconrmax[2] = ssdcableslay5pconrmax[1]; 
   ssdcableslay5pconrmin[3] = 0.25*(fgkSSDPConeUpMaxRadius+3.*fgkSSDPConeUpRadius
                                                   - 4.*fgkSSDLowerPConeRadius)+fgkSSDLowerPConeRadius;
   ssdcableslay5pconrmin[3]*=(1.0+ssdcablelayvertical);
-  ssdcableslay5pconrmax[3] = ssdcableslay5pconrmin[3]+fgkSSDCablesLay5RightSideHeight;
+  ssdcableslay5pconrmax[3] = ssdcableslay5pconrmin[3] + kSSDCablesHeight; 
   for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[1]->DefineSection(i,ssdcableslay5pconzsection[i+2],
                                                  ssdcableslay5pconrmin[i+2],ssdcableslay5pconrmax[i+2]); 
   ssdcableslay5pcon[1] = new TGeoVolume("SSDCableLay5RightSidePCon2",ssdcableslay5pconshape[1],fSSDCopper);
   ssdcableslay5pcon[1]->SetLineColor(9);
   ////////////////////////////////////
-  ssdcableslay5pconshape[2] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
+  ssdcableslay5pconshape[2] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
                                                                                   ssdcableangle,2);   
   ssdcableslay5pconrmin[4] = ssdcableslay5pconrmin[3];
   ssdcableslay5pconrmax[4] = ssdcableslay5pconrmax[3];
@@ -7511,6 +7519,8 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
    ssdcableslay5pconrot[i]->SetAngles(90.0*i,0.,0.);
    ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+1,ssdcableslay5pconrot[i]);
    ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+1,ssdcableslay5pconrot[i]);         
+   // Printf(Form("Pcon2, Pcon3, vol %g %g",ssdcableslay5pcon[1]->Capacity(),ssdcableslay5pcon[2]->Capacity()));
+   totvol += ssdcableslay5pcon[1]->Capacity()+ssdcableslay5pcon[2]->Capacity();
   }
   ////////////////////////////////////
   //cablescapacity[2] = 4.0*ssdcableslay5pconshape[1]->Capacity();
@@ -7518,11 +7528,6 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
   ////////////////////////////////////
   // Positioning Left SSD Cables Part
   ////////////////////////////////////
-  TGeoTranslation* ssdcablesLay5RightTubeToLeftrans = new TGeoTranslation(0.,0.,
-                                                                                                       - 0.5*ssdcablelay5rightsidelength
-                                                                                                       - fgkEndCapSupportCenterLay5Position
-                                                                                                   - fgkEndCapSupportCenterLay5ITSPosition);
-  ssdcablesmother->AddNode(ssdcablelay5righttube,2,ssdcablesLay5RightTubeToLeftrans);  
   TGeoRotation* ssdcablesLay5RightPConToLeftRot = new TGeoRotation();
   ssdcablesLay5RightPConToLeftRot->SetAngles(90.,180.,-90);
   ssdcablesmother->AddNode(ssdcableslay5pcon[0],2,ssdcablesLay5RightPConToLeftRot);  
@@ -7540,9 +7545,41 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
   /////////////////////////////////////////////////////////////
   // Water Tubes Layer 5
   /////////////////////////
+  /*  Remove ring; could be replaced with a PCone next to/on top of the cables
+
+   //
+   // MvL: Remove ring; put everything in PCone
+   //
+   // Need to keep dimensions for water ring...
+
+   Double_t ssdcablesfactor = 0.5;     // Internal variables to control overlapping with SDD cables
+
+  Double_t ssdcableslay5rigthsideradiusmin = fgkEndCapSupportMiddleRadius[0]+kSSDCablesLay5TubeRadiusMin;  
+  Double_t ssdcableslay5endconedistance = (ssdcableslay5rigthsideradiusmin
+                                                                           -  fgkSSDLowerPConeRadius)
+                                                                           * TanD(fgkSSDPConeAngle);
+  Double_t ssdcableslay5startconedistance = fgkEndCapSupportCenterLay5ITSPosition
+                                                                             + fgkEndCapSupportCenterLay5Position
+                                                                             - 0.5*fgkSSDCentralSupportLength-fgkSSDCentralAL3SupportLength;
+  Double_t ssdcablelay5rightsidelength = ssdcableslay5endconedistance
+                                                                          - ssdcableslay5startconedistance; 
+  ssdcablelay5rightsidelength *= ssdcablesfactor;
+  Double_t ssdcableslay5rightsideradiusmax = ssdcableslay5rigthsideradiusmin+kSSDCablesLay5RingArea/ssdcablelay5rightsidelength; 
+
+
+  TGeoTranslation* ssdcablelay5rightrans = 
+                                         new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay5ITSPosition
+                                                                   + fgkEndCapSupportCenterLay5Position
+                                                                   + 0.5*ssdcablelay5rightsidelength);
+
+  TGeoTranslation* ssdcablesLay5RightTubeToLeftrans = new TGeoTranslation(0.,0.,
+                                                                                                       - 0.5*ssdcablelay5rightsidelength
+                                                                                                       - fgkEndCapSupportCenterLay5Position
+                                                                                                   - fgkEndCapSupportCenterLay5ITSPosition);
+
   TGeoTube* ssdcablelay5rightubewatershape = new TGeoTube(ssdcableslay5rightsideradiusmax,
                                                                                     ssdcableslay5rightsideradiusmax
-                                                                              + fgkSSDCablesLay5RightSideWaterHeight,
+                                                                              + kSSDCablesLay5RightSideWaterHeight,
                                                                                     0.5*ssdcablelay5rightsidelength); 
   TGeoVolume* ssdcablelay5rightwatertube = new TGeoVolume("SSDCableLay5RightSideWaterTube",
                                                                                                         ssdcablelay5rightubewatershape,
@@ -7550,6 +7587,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
   ssdcablelay5rightwatertube->SetLineColor(7);
   ssdcablesmother->AddNode(ssdcablelay5rightwatertube,1,ssdcablelay5rightrans);
   ssdcablesmother->AddNode(ssdcablelay5rightwatertube,2,ssdcablesLay5RightTubeToLeftrans);
+  */
   ////////////////////////////////////
   // TGeoPCone Water Volumes Layer 
   ///////////////////////////////////
@@ -7561,10 +7599,10 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
   Double_t ssdcableslay5pconwaterrmax[6];
   ssdcableslay5pcwateronrmin[0] = ssdcableslay5pconrmax[0];
   ssdcableslay5pconwaterrmax[0] = ssdcableslay5pcwateronrmin[0]
-                                                               + fgkSSDCablesLay5RightSideWaterHeight;
+                                                               + kSSDCablesLay5RightSideWaterHeight;
   ssdcableslay5pcwateronrmin[1] = ssdcableslay5pconrmax[1];
   ssdcableslay5pconwaterrmax[1] = ssdcableslay5pcwateronrmin[1]
-                                                               + fgkSSDCablesLay5RightSideWaterHeight;
+                                                               + kSSDCablesLay5RightSideWaterHeight;
   ssdcableslay5pconwaterzsection[0] = ssdcableslay5pconzsection[0];
   ssdcableslay5pconwaterzsection[1] = ssdcableslay5pconzsection[1];
   for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[0]->DefineSection(i,ssdcableslay5pconwaterzsection[i],
@@ -7577,28 +7615,28 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
 ////////////////////////////////////
   ssdcableslay5pconwaterzsection[2] = ssdcableslay5pconzsection[2];
   ssdcableslay5pconwaterzsection[3] = ssdcableslay5pconzsection[3];
-  ssdcableslay5pconwatershape[1] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
+  ssdcableslay5pconwatershape[1] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
                                                                                                ssdcableangle,2);   
   ssdcableslay5pcwateronrmin[2] = ssdcableslay5pconrmax[1];
   ssdcableslay5pconwaterrmax[2] = ssdcableslay5pcwateronrmin[2]
-                                                               + fgkSSDCablesLay5RightSideWaterHeight;
+                                                               + kSSDCablesLay5RightSideWaterHeight;
   ssdcableslay5pcwateronrmin[3] = ssdcableslay5pconrmax[3];
   ssdcableslay5pconwaterrmax[3] = ssdcableslay5pcwateronrmin[3]
-                                                               + fgkSSDCablesLay5RightSideWaterHeight;
+                                                               + kSSDCablesLay5RightSideWaterHeight;
   for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[1]->DefineSection(i,ssdcableslay5pconwaterzsection[i+2],
                                                  ssdcableslay5pcwateronrmin[i+2],ssdcableslay5pconwaterrmax[i+2]); 
   ssdcableslay5pconwater[1] = new TGeoVolume("SSDCableLay5RightSidePConWater2",
                                                           ssdcableslay5pconwatershape[1],fSSDCoolingTubeWater);
   ssdcableslay5pconwater[1]->SetLineColor(7);
 ////////////////////////////////////
-  ssdcableslay5pconwatershape[2] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
+  ssdcableslay5pconwatershape[2] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
                                                                                                ssdcableangle,2);   
   ssdcableslay5pcwateronrmin[4] = ssdcableslay5pconrmax[3];
   ssdcableslay5pconwaterrmax[4] = ssdcableslay5pcwateronrmin[4]
-                                                               + fgkSSDCablesLay5RightSideWaterHeight;
+                                                               + kSSDCablesLay5RightSideWaterHeight;
   ssdcableslay5pcwateronrmin[5] = ssdcableslay5pconrmax[4];
   ssdcableslay5pconwaterrmax[5] = ssdcableslay5pcwateronrmin[4]
-                                                               + fgkSSDCablesLay5RightSideWaterHeight;
+                                                               + kSSDCablesLay5RightSideWaterHeight;
   ssdcableslay5pconwaterzsection[4] = ssdcableslay5pconzsection[4];
   ssdcableslay5pconwaterzsection[5] = ssdcableslay5pconzsection[5];
   for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[2]->DefineSection(i,ssdcableslay5pconwaterzsection[i+4],
@@ -7622,9 +7660,10 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
   /////////////////////////
   // SSD Layer 6 Cables
   /////////////////////////
-  Double_t ssdcableslay6rigthsideradiusmin = fgkEndCapSupportMiddleRadius[1]+fgkSSDCablesLay6TubeRadiusMin;  
-  Double_t ssdcablelay6rightsidelength = 2.*ssdcablelay5rightsidelength;
-  Double_t ssdcableslay6rightsideradiusmax = ssdcableslay6rigthsideradiusmin+fgkSSDCablesLay6RightSideHeight; 
+  Double_t ssdcableslay6rigthsideradiusmin = fgkEndCapSupportMiddleRadius[1]+kSSDCablesLay6TubeRadiusMin;  
+  Double_t ssdcablelay6rightsidelength = 2.; // cm  was 2.*ssdcablelay5rightsidelength;
+  Double_t ssdcableslay6rightsideradiusmax = ssdcableslay6rigthsideradiusmin+kSSDCablesLay6RingArea/ssdcablelay6rightsidelength;
+  // Printf(Form("Lay 6 cables, length %g, radius %g, thickness %g", ssdcablelay6rightsidelength, ssdcableslay6rigthsideradiusmin, kSSDCablesLay6RingArea/ssdcablelay6rightsidelength));
   TGeoTube* ssdcablelay6rightubeshape = new TGeoTube(ssdcableslay6rigthsideradiusmin,
                                                                                                ssdcableslay6rightsideradiusmax,
                                                                                                0.5*ssdcablelay6rightsidelength); 
@@ -7642,10 +7681,15 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
                                                                                                    - fgkEndCapSupportCenterLay6ITSPosition);
   ssdcablesmother->AddNode(ssdcablelay6righttube,1,ssdcablelay6rightrans);
   ssdcablesmother->AddNode(ssdcablelay6righttube,2,ssdcablesLay6RightTubeToLeftrans);
+  // Printf(Form("Cables; ring layer 6, volume: %g",ssdcablelay6rightubeshape->Capacity()));
+  totvol += ssdcablelay6rightubeshape->Capacity();
   ////////////////////////////////////
   //cablescapacity[8] = 2.*ssdcablelay6rightubeshape->Capacity();
   ////////////////////////////////////
-  TGeoPcon* ssdcableslay6pconshape = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
+  // MvL: PCon is part of connection to patch panels;
+  // removed since current volume is too thick; now absorbed in rings+connections
+  /*
+  TGeoPcon* ssdcableslay6pconshape = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
                                                                                   ssdcableangle,2);   
   TGeoVolume* ssdcableslay6pcon;
   Double_t ssdcableslay6pconrmin[2];
@@ -7661,6 +7705,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
   ssdcableslay6pconzsection[1] = ssdcableslay5pconwaterzsection[5];
   for(Int_t i=0; i<2;i++) ssdcableslay6pconshape->DefineSection(i,ssdcableslay6pconzsection[i],
                                                  ssdcableslay6pconrmin[i],ssdcableslay6pconrmax[i]); 
+  
   ssdcableslay6pcon = new TGeoVolume("SSDCableLay6RightSidePCon",
                                                           ssdcableslay6pconshape,fSSDCopper);
   ssdcableslay6pcon->SetLineColor(9);
@@ -7668,6 +7713,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
    ssdcablesmother->AddNode(ssdcableslay6pcon,i+1,ssdcableslay5pconrot[i]);
    ssdcablesmother->AddNode(ssdcableslay6pcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
   }
+  */
   ////////////////////////////////////
   //cablescapacity[9] = 8.*ssdcableslay6pconshape->Capacity();
   /////////////////////////
@@ -7675,7 +7721,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
   /////////////////////////
   TGeoTube* ssdcablelay6righwatertubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax,
                                                                                                                  ssdcableslay6rightsideradiusmax
-                                                                                  +                      fgkSSDCablesLay5RightSideWaterHeight,
+                                                                                  +                      kSSDCablesLay5RightSideWaterHeight,
                                                                                                                  0.5*ssdcablelay6rightsidelength); 
   TGeoVolume* ssdcablelay6rightwatertube = new TGeoVolume("SSDCableLay6RightSideWaterTube",
                                                                                                         ssdcablelay6righwatertubeshape,
@@ -7683,7 +7729,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
   ssdcablelay6rightwatertube->SetLineColor(7);
   ssdcablesmother->AddNode(ssdcablelay6rightwatertube,1,ssdcablelay6rightrans);
   ssdcablesmother->AddNode(ssdcablelay6rightwatertube,2,ssdcablesLay6RightTubeToLeftrans);
-  TGeoPcon* ssdcableslay6waterpconshape = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
+  TGeoPcon* ssdcableslay6waterpconshape = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
                                                                                   ssdcableangle,2);   
   TGeoVolume* ssdcableslay6waterpcon;
   Double_t ssdcableslay6waterpconrmin[2];
@@ -7691,7 +7737,7 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
   Double_t ssdcableslay6waterpconzsection[2];
   ssdcableslay6waterpconrmin[0] = ssdcableslay6rightsideradiusmax;
   ssdcableslay6waterpconrmax[0] = ssdcableslay6rightsideradiusmax
-                                                           + fgkSSDCablesLay5RightSideWaterHeight;
+                                                           + kSSDCablesLay5RightSideWaterHeight;
   ssdcableslay6waterpconrmin[1] = ssdcableslay6waterpconrmin[0];
   ssdcableslay6waterpconrmax[1] = ssdcableslay6waterpconrmax[0];
   ssdcableslay6waterpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
@@ -7721,20 +7767,21 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
   Double_t ssdcablepatchpanel3BB26radiusmin[2];
   Double_t ssdcablepatchpanel3BB26radiusmax[2];
   Double_t ssdcablepatchpanel3RB26zsection[2];
-  ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*fgkSSDPatchPanelHeight+2.8+0.003;//Avoid small overlap with SPDshieldring;
+  ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*kSSDPatchPanelHeight;// +2.8+0.003;//Avoid small overlap with SPDshieldring;
   ssdcablepatchpanel3BB26radiusmax[0] = ssdcablepatchpanel3BB26radiusmin[0]
-                                                                         + fgkSSDCablesLay5RightSideHeight
-                                                                         + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
-  ssdcablepatchpanel3BB26radiusmin[1] = fgkSSDPatchPanel2RB26Radius;
+                                        + kSSDCablesHeight;
+  ssdcablepatchpanel3BB26radiusmin[1] = kSSDPatchPanel2RB26Radius;
   ssdcablepatchpanel3BB26radiusmax[1] = ssdcablepatchpanel3BB26radiusmin[1]
-                                                                         + 0.*fgkSSDCablesLay5RightSideHeight
-                                                                         + 0.*fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
+                                       + kSSDCablesHeight;
   ssdcablepatchpanel3RB26zsection[0] = 0.5*fgkSSDCentralSupportLength
-                                                                                + fgkSSDCentralAL3SupportLength
+                                       + fgkSSDCentralAL3SupportLength
                                                                                 + fgkSSDPConeZLength[0];
-  ssdcablepatchpanel3RB26zsection[1] = fgkSSDPatchPanel2RB26ITSDistance;  
+  ssdcablepatchpanel3RB26zsection[1] = kSSDPatchPanel2RB26ITSDistance;  
+  // Printf(Form("RB26 cable length %g",ssdcablepatchpanel3RB26zsection[1]-ssdcablepatchpanel3RB26zsection[0]));
+  // Printf(Form("Angular range %g",ssdcableangle));
+
   TGeoPcon* ssdcablepatchpanel3RB26pconshape = 
-                                                               new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB26Angle[0]
+                                                               new TGeoPcon(90.0-kSSDCablesPatchPanel2RB26Angle[0]
                                                                                                - 0.5*ssdcableangle,ssdcableangle,2);   
   for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB26pconshape->DefineSection(i,ssdcablepatchpanel3RB26zsection[i],
                                                  ssdcablepatchpanel3BB26radiusmin[i],ssdcablepatchpanel3BB26radiusmax[i]); 
@@ -7744,12 +7791,13 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
   TGeoRotation* ssdcablepatchpanel3B26rot[4];
   for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B26rot[i] = new TGeoRotation();
   ssdcablepatchpanel3B26rot[0]->SetAngles(0.0,0.0,0.0);
-  ssdcablepatchpanel3B26rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB26Angle[0]
-                                                                 +                       fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
+  ssdcablepatchpanel3B26rot[1]->SetAngles(kSSDCablesPatchPanel2RB26Angle[0]
+                                         + kSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
   ssdcablepatchpanel3B26rot[2]->SetAngles(180.0,0.0,0.0);
-  ssdcablepatchpanel3B26rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB26Angle[0]
-                                                                 +                       fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
+  ssdcablepatchpanel3B26rot[3]->SetAngles(180.0 + kSSDCablesPatchPanel2RB26Angle[0]
+                                               + kSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
   for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB26pcon,i+1,ssdcablepatchpanel3B26rot[i]);
+  // Printf(Form("Cable to patch panels RB26 volume: %g (x4)",ssdcablepatchpanel3RB26pcon->Capacity()));
   ////////////////////////////////////
   //cablescapacity[10] = 4.*ssdcablepatchpanel3RB26pconshape->Capacity();
   ////////////////////////////////////////
@@ -7762,29 +7810,28 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
                                                                          + fgkSSDCentralAL3SupportLength
                                                                          + (4.0/5.0)*fgkSSDPConeZLength[0];
   ssdcableitsring3BB26pconzsection[1] = ssdcablepatchpanel3RB26zsection[0];
-  ssdcableitsring3BB26pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeight;
-  ssdcableitsring3BB26pconrmax[0] = ssdcableitsring3BB26pconrmin[0]
-                                                                 + fgkSSDCablesLay5RightSideHeight
-                                                                 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
+  ssdcableitsring3BB26pconrmin[0] = fgkSSDPConeUpRadius-0.5*kSSDPatchPanelHeight;
+  ssdcableitsring3BB26pconrmax[0] = ssdcableitsring3BB26pconrmin[0] + 2.5*kSSDCablesHeight; // widths of cable bunch is about half of patch panels; need factor 2.5
+
   ssdcableitsring3BB26pconrmin[1] = ssdcablepatchpanel3BB26radiusmin[0];
   ssdcableitsring3BB26pconrmax[1] = ssdcablepatchpanel3BB26radiusmax[0];
   TGeoPcon* ssdcableitsring3BB26pconshape[4];
-  ssdcableitsring3BB26pconshape[0] = new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB26Angle[0]
+  ssdcableitsring3BB26pconshape[0] = new TGeoPcon(90.0 - kSSDCablesPatchPanel2RB26Angle[0]
                                                                   -              0.5*ssdcableangle,ssdcableangle
-                                                                  +                            (fgkSSDCablesPatchPanel2RB26Angle[0]
-                                                                  -                             fgkSSDCableAngle),2);
-  ssdcableitsring3BB26pconshape[1] = new TGeoPcon(90.0+fgkSSDCablesPatchPanel2RB26Angle[1]
+                                                                  +                            (kSSDCablesPatchPanel2RB26Angle[0]
+                                                                  -                             kSSDCableAngle),2);
+  ssdcableitsring3BB26pconshape[1] = new TGeoPcon(90.0 + kSSDCablesPatchPanel2RB26Angle[1]
                                                                   -              0.5*ssdcableangle,ssdcableangle
-                                                                  +                      3.0*fgkSSDCableAngle
-                                                                  -                      fgkSSDCablesPatchPanel2RB26Angle[1],2);
-  ssdcableitsring3BB26pconshape[2] = new TGeoPcon(270-fgkSSDCablesPatchPanel2RB26Angle[0]
+                                                                  +                      3.0*kSSDCableAngle
+                                                                  -                      kSSDCablesPatchPanel2RB26Angle[1],2);
+  ssdcableitsring3BB26pconshape[2] = new TGeoPcon(270-kSSDCablesPatchPanel2RB26Angle[0]
                                                                   -              0.5*ssdcableangle,ssdcableangle
-                                                                  -                      fgkSSDCableAngle
-                                                                  +                      fgkSSDCablesPatchPanel2RB26Angle[0],2);
-  ssdcableitsring3BB26pconshape[3] = new TGeoPcon(270.0+fgkSSDCablesPatchPanel2RB26Angle[1]
+                                                                  -                      kSSDCableAngle
+                                                                  +                      kSSDCablesPatchPanel2RB26Angle[0],2);
+  ssdcableitsring3BB26pconshape[3] = new TGeoPcon(270.0+kSSDCablesPatchPanel2RB26Angle[1]
                                                                   -              0.5*ssdcableangle,ssdcableangle
-                                                                  +                      3.0*fgkSSDCableAngle
-                                                                  -                      fgkSSDCablesPatchPanel2RB26Angle[1],2);
+                                                                  +                      3.0*kSSDCableAngle
+                                                                  -                      kSSDCablesPatchPanel2RB26Angle[1],2);
   for(Int_t i=0;i<4;i++)
        for(Int_t j=0; j<2; j++) ssdcableitsring3BB26pconshape[i]->DefineSection(j,ssdcableitsring3BB26pconzsection[j],
                                                         ssdcableitsring3BB26pconrmin[j],
@@ -7801,7 +7848,9 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
   for(Int_t i=0;i<4;i++){
        ssdcableitsring3BB26pcon[i]->SetLineColor(9);
        ssdcablesmother->AddNode(ssdcableitsring3BB26pcon[i],1);
+       //Printf(Form("Cable to patch panels RB26 volume part 2: %g (%d)",ssdcableitsring3BB26pcon[i]->Capacity(),i));
 }
+
   ////////////////////////////////////
   //cablescapacity[11] = ssdcableitsring3BB26pconshape[0]->Capacity()
   //                            + ssdcableitsring3BB26pconshape[1]->Capacity() 
@@ -7815,17 +7864,16 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
   Double_t ssdcablepatchpanel3RB24zsection[2];
   ssdcablepatchpanel3BB24radiusmin[0] = ssdcablepatchpanel3BB26radiusmin[0];
   ssdcablepatchpanel3BB24radiusmax[0] = ssdcablepatchpanel3BB26radiusmax[0];
-  ssdcablepatchpanel3BB24radiusmin[1] = fgkSSDPatchPanel2RB24Radius;
+  ssdcablepatchpanel3BB24radiusmin[1] = kSSDPatchPanel2RB24Radius;
   ssdcablepatchpanel3BB24radiusmax[1] = ssdcablepatchpanel3BB24radiusmin[1]
-                                                                         + 0.*fgkSSDCablesLay5RightSideHeight
-                                                                         + 0.*fgkSSDCablesLay6RightSideHeight
-                                                                         + 0.5*fgkSSDPatchPanelHeight;
+                                        + kSSDCablesHeight;
   ssdcablepatchpanel3RB24zsection[0] = -0.5*fgkSSDCentralSupportLength
                                                                         -  fgkSSDCentralAL3SupportLength
                                                                         -  fgkSSDPConeZLength[0];
-  ssdcablepatchpanel3RB24zsection[1] = -fgkSSDPatchPanel2RB24ITSDistance;  
+  ssdcablepatchpanel3RB24zsection[1] = -kSSDPatchPanel2RB24ITSDistance;  
+  //Printf(Form("RB24 cable length %g",ssdcablepatchpanel3RB24zsection[1]-ssdcablepatchpanel3RB24zsection[0]));
   TGeoPcon* ssdcablepatchpanel3RB24pconshape = 
-                                                               new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB24Angle[1]
+                                                               new TGeoPcon(90.0-kSSDCablesPatchPanel2RB24Angle[1]
                                                                                                - 0.5*ssdcableangle,ssdcableangle,2);   
   for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB24pconshape->DefineSection(i,ssdcablepatchpanel3RB24zsection[i],
                                                  ssdcablepatchpanel3BB24radiusmin[i],ssdcablepatchpanel3BB24radiusmax[i]); 
@@ -7836,12 +7884,13 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
   TGeoRotation* ssdcablepatchpanel3B24rot[4];
   for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B24rot[i] = new TGeoRotation();
   ssdcablepatchpanel3B24rot[0]->SetAngles(-6.0,0.0,0.0);
-  ssdcablepatchpanel3B24rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB24Angle[0]
-                                                                 +                       fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
+  ssdcablepatchpanel3B24rot[1]->SetAngles(kSSDCablesPatchPanel2RB24Angle[0]
+                                         + kSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
   ssdcablepatchpanel3B24rot[2]->SetAngles(174.0,0.0,0.0);
-  ssdcablepatchpanel3B24rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB24Angle[0]
-                                                                 +                       fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
+  ssdcablepatchpanel3B24rot[3]->SetAngles(180.0+kSSDCablesPatchPanel2RB24Angle[0]
+                                         + kSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
   for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB24pcon,i+1,ssdcablepatchpanel3B24rot[i]);
+  //Printf(Form("Cable to patch panels RB24 volume: %g (x4)",ssdcablepatchpanel3RB24pcon->Capacity()));
   ////////////////////////////////////
   //cablescapacity[12] = 4.*ssdcablepatchpanel3RB24pconshape->Capacity();
   ////////////////////////////////////////
@@ -7852,25 +7901,24 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
   Double_t ssdcableitsring3BB24pconrmax[2];
   ssdcableitsring3BB24pconzsection[0] = -ssdcableitsring3BB26pconzsection[0];
   ssdcableitsring3BB24pconzsection[1] = ssdcablepatchpanel3RB24zsection[0];
-  ssdcableitsring3BB24pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeight;
-  ssdcableitsring3BB24pconrmax[0] = ssdcableitsring3BB24pconrmin[0]
-                                                                 + fgkSSDCablesLay5RightSideHeight
-                                                                 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
+  ssdcableitsring3BB24pconrmin[0] = fgkSSDPConeUpRadius-0.5*kSSDPatchPanelHeight;
+  ssdcableitsring3BB24pconrmax[0] = ssdcableitsring3BB24pconrmin[0] + 2.5*kSSDCablesHeight;  // Cable bunch width smaller; make it thicker
+
   ssdcableitsring3BB24pconrmin[1] = ssdcablepatchpanel3BB24radiusmin[0];
   ssdcableitsring3BB24pconrmax[1] = ssdcablepatchpanel3BB24radiusmax[0];
   TGeoPcon* ssdcableitsring3BB24pconshape[4];
-  ssdcableitsring3BB24pconshape[0] = new TGeoPcon(fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle
-                                                                  +                            (90.0-fgkSSDCablesPatchPanel2RB24Angle[1]
-                                                                  -                             fgkSSDCableAngle),2);
-  ssdcableitsring3BB24pconshape[1] = new TGeoPcon(90.0+fgkSSDCableAngle-0.5*ssdcableangle,
-                                                                    ssdcableangle-fgkSSDCableAngle
-                                                                  +                      fgkSSDCablesPatchPanel2RB24Angle[0],2);
-  ssdcableitsring3BB24pconshape[2] = new TGeoPcon(180.0+fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle
-                                                                  -                      fgkSSDCableAngle
-                                                                  +                      90.0-fgkSSDCablesPatchPanel2RB24Angle[1],2);
-  ssdcableitsring3BB24pconshape[3] = new TGeoPcon(270.0+fgkSSDCableAngle-0.5*ssdcableangle,
-                                                                                                 ssdcableangle-fgkSSDCableAngle
-                                                                  +                      fgkSSDCablesPatchPanel2RB24Angle[0],2);
+  ssdcableitsring3BB24pconshape[0] = new TGeoPcon(kSSDCableAngle-0.5*ssdcableangle,ssdcableangle
+                                                              + (90.0-kSSDCablesPatchPanel2RB24Angle[1]
+                                                                  - kSSDCableAngle),2);
+  ssdcableitsring3BB24pconshape[1] = new TGeoPcon(90.0+kSSDCableAngle-0.5*ssdcableangle,
+                                                                    ssdcableangle-kSSDCableAngle
+                                                                  + kSSDCablesPatchPanel2RB24Angle[0],2);
+  ssdcableitsring3BB24pconshape[2] = new TGeoPcon(180.0+kSSDCableAngle-0.5*ssdcableangle,ssdcableangle
+                                                                  - kSSDCableAngle
+                                                                  + 90.0 - kSSDCablesPatchPanel2RB24Angle[1],2);
+  ssdcableitsring3BB24pconshape[3] = new TGeoPcon(270.0+kSSDCableAngle-0.5*ssdcableangle,
+                                                                  ssdcableangle-kSSDCableAngle
+                                                                  + kSSDCablesPatchPanel2RB24Angle[0],2);
   for(Int_t i=0;i<4;i++)
        for(Int_t j=0; j<2; j++) ssdcableitsring3BB24pconshape[i]->DefineSection(j,ssdcableitsring3BB24pconzsection[j],
                                                         ssdcableitsring3BB24pconrmin[j],
@@ -7887,37 +7935,28 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
   for(Int_t i=0;i<4;i++){
        ssdcableitsring3BB24pcon[i]->SetLineColor(9);
        ssdcablesmother->AddNode(ssdcableitsring3BB24pcon[i],1);
+       // Printf(Form("Cable to patch panels RB24 (part 2) volume: %g (%d)",ssdcableitsring3BB24pcon[i]->Capacity(),i));
 }
+
   ////////////////////////////////////
   //cablescapacity[13] = ssdcableitsring3BB24pconshape[0]->Capacity()
   //                                    + ssdcableitsring3BB24pconshape[1]->Capacity()
   //                                    + ssdcableitsring3BB24pconshape[2]->Capacity()
   //                                    + ssdcableitsring3BB24pconshape[3]->Capacity();
-  ////////////////////////////////////
-  // Volumes for Material Budget 
-  ////////////////////////////////////
-  TGeoTube* ssdcablelay6materialbudgetubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax
-                                                                                          +     fgkSSDCablesLay5RightSideWaterHeight,
-                                                                                                        ssdcableslay6rightsideradiusmax
-                                                                                          +     fgkSSDCablesLay5RightSideWaterHeight
-                                                                                          +     fgkSSDCableMaterialBudgetHeight,0.5*ssdcablelay6rightsidelength); 
-  TGeoVolume* ssdcablelay6materialbudgetube = new TGeoVolume("SSDCableLay6MaterialBudgetTube",
-                                                                                                        ssdcablelay6materialbudgetubeshape,
-                                                                                                        fSSDCopper);
-  ssdcablelay6materialbudgetube->SetLineColor(9);
-  ssdcablesmother->AddNode(ssdcablelay6materialbudgetube,1,ssdcablelay6rightrans);
-  ssdcablesmother->AddNode(ssdcablelay6materialbudgetube,2,ssdcablesLay6RightTubeToLeftrans);
 
+  // MvL: Pcon are connection to patch panels (part of)
+  // Removed; do not contribute much; put into ring structure
+  /*
   TGeoPcon* ssdcablelay6materialbudgetpconshape = 
-                                       new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle,2); 
+                                       new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,ssdcableangle,2); 
   TGeoVolume* ssdcablelay6materialbudgetpcon;
   Double_t ssdcablelay6materialbudgetpconrmin[2];
   Double_t ssdcablelay6materialbudgetpconrmax[2];
   Double_t ssdcablelay6materialbudgetpconzsection[2];
   ssdcablelay6materialbudgetpconrmin[0] = ssdcableslay6rightsideradiusmax
-                                                                               + fgkSSDCablesLay5RightSideWaterHeight;
+                                                                               + kSSDCablesLay5RightSideWaterHeight;
   ssdcablelay6materialbudgetpconrmax[0] = ssdcablelay6materialbudgetpconrmin[0]
-                                                                               + fgkSSDCableMaterialBudgetHeight;
+                                                                               + kSSDCableMaterialBudgetHeight;
   ssdcablelay6materialbudgetpconrmin[1] = ssdcablelay6materialbudgetpconrmin[0];
   ssdcablelay6materialbudgetpconrmax[1] = ssdcablelay6materialbudgetpconrmax[0];
   ssdcablelay6materialbudgetpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
@@ -7935,12 +7974,14 @@ void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
    ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+1,ssdcableslay5pconrot[i]);
    ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
   }
+  */
 ////////////////////////////////////
  /* cablescapacity[14] = 2.*ssdcablelay6materialbudgetubeshape->Capacity();
   cablescapacity[15] = 2.*ssdcablelay6materialbudgetpconshape->Capacity();
   Double_t ssdcablesvolume = 0.0;
   for(Int_t i=0;i<16;i++) ssdcablesvolume+=cablescapacity[i];
   std::cout << ssdcablesvolume << std::endl;*/
+  // Printf(Form("Total volume (one side; without conn to patch panel): %g",totvol));
   return ssdcablesmother;
  }
  ////////////////////////////////////////////////////////////////////////////////
index 738a0b5..e43ba37 100644 (file)
@@ -394,23 +394,6 @@ private:
   static const Double_t fgkSSDCentralAL3SupportLength; // SSD Central Support Length
   static const Double_t fgkSSDCentralAL3SupportWidth; // SSD Central Support Width
   /////////////////////////////////////////////////////////////////////////
-  // SSD Cables e Patch Panel
-  /////////////////////////////////////////////////////////////////////////
-  static const Double_t fgkSSDCablesLay5TubeRadiusMin; // Radius Min Cable Tube Layer 5
-  static const Double_t fgkSSDCablesLay6TubeRadiusMin; // Radius Min Cable Tube Layer 6
-  static const Double_t fgkSSDCablesLay5RightSideHeight;  // Width Lay 5 Cables to be fixed in order to reproduce material budget
-  static const Double_t fgkSSDCablesLay6RightSideHeight;  // // Width Lay 5 Cables to be fixed in order to reproduce material budget
-  static const Double_t fgkSSDCableAngle; // Angle Cable   
-  static const Double_t fgkSSDCablesLay5RightSideWaterHeight;  // Width Lay 5 Water Cables to be fixed in order to reproduce material budget
-  static const Double_t fgkSSDCablesPatchPanel2RB26Angle[2]; // Angle Position Patch Panel RB26
-  static const Double_t fgkSSDCablesPatchPanel2RB24Angle[2]; // Angle Position Patch Panel RB24
-  static const Double_t fgkSSDPatchPanel2RB26ITSDistance;    // Patch Panel RB26 Position
-  static const Double_t fgkSSDPatchPanel2RB24ITSDistance;   // Patch Panel RB24 Position 
-  static const Double_t fgkSSDPatchPanel2RB26Radius; // Patch Panel Radius 
-  static const Double_t fgkSSDPatchPanel2RB24Radius; // Patch Panel Radius
-  static const Double_t fgkSSDPatchPanelHeight; // Patch Panel Height
-  static const Double_t fgkSSDCableMaterialBudgetHeight; // SSD Cable Material Budget
-  /////////////////////////////////////////////////////////////////////////
   // Private methods for private members generation
   /////////////////////////////////////////////////////////////////////////