const Double_t kInnerRadiusRing = 37.3*fgkcm;
const Double_t kOuterRadiusRing = 42.0*fgkcm;
const Double_t kOuterRadiusWing = 49.25*fgkcm;
- const Double_t kWideWing = 6.0*fgkcm;
- const Double_t kThetaWing = 45.0;
+ const Double_t kWideWing = 6.0*fgkcm;
+ const Double_t kThetaWing = 45.0;
// Common data
const Double_t kTheta = 36.0*TMath::DegToRad();
const Double_t kThicknessOmega = 0.3*fgkmm;
// Create the Omega insert
TGeoXtru *centralomegashape = new TGeoXtru(2);
- CreateSPDOmegaShape(xair,yair,kTheta,kThicknessOmega,xomega,yomega);
+ CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
centralomegashape->DefinePolygon(48,xomega,yomega);
centralomegashape->DefineSection(0,-kHalfLengthCentral);
// Create the Omega insert
TGeoXtru *endcapomegashape = new TGeoXtru(2);
- CreateSPDOmegaShape(xair,yair,kTheta,kThicknessOmega,xomega,yomega);
+ CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
endcapomegashape->DefinePolygon(48,xomega,yomega);
endcapomegashape->DefineSection(0,-kHalfLengthEndCap);
-kHalfLengthRing));
for (Int_t i=0; i<4; i++) {
- Double_t thetaW = kThetaWing*(2*i+1);
+ Double_t thetaW = kThetaWing*(2*i+1) - angleWideWing/2.;
vM->AddNode(wing,2*i+1,new TGeoCombiTrans(0, 0,
kHalfLengthCentral+2*kHalfLengthEndCap+2*kHalfLengthCone
+kHalfLengthRing, new TGeoRotation("",thetaW,0,0) ));
//______________________________________________________________________
void AliITSv11GeometrySupport::CreateSPDOmegaShape(
- Double_t *xin, Double_t *yin, Double_t t,
- Double_t d, Double_t *x, Double_t *y)
+ Double_t *xin, Double_t *yin, Double_t d,
+ Double_t *x, Double_t *y)
{
//
// Creates the proper sequence of X and Y coordinates to determine
//
// Created: 17 Nov 2007 Mario Sitta
// Updated: 11 Dec 2007 Mario Sitta
+// Updated: 20 Feb 2009 Mario Sitta New algorithm (the old one
+// gives erroneous vertexes)
//
- Double_t xlocal[6],ylocal[6];
-
- // First determine various parameters
- Double_t ina = TMath::Sqrt( (xin[23]-xin[0])*(xin[23]-xin[0]) +
- (yin[23]-yin[0])*(yin[23]-yin[0]) );
- Double_t inb = TMath::Sqrt( (xin[ 1]-xin[0])*(xin[ 1]-xin[0]) +
- (yin[ 1]-yin[0])*(yin[ 1]-yin[0]) );
- Double_t inr = yin[0];
- Double_t oua = TMath::Sqrt( (xin[12]-xin[11])*(xin[12]-xin[11]) +
- (yin[12]-yin[11])*(yin[12]-yin[11]) );
- Double_t oub = TMath::Sqrt( (xin[10]-xin[11])*(xin[10]-xin[11]) +
- (yin[10]-yin[11])*(yin[10]-yin[11]) );
- Double_t our = yin[11];
-
- //Create the first inner pseudo-quadrant
- FillSPDXtruShape(ina,inb,inr,t,xlocal,ylocal);
- x[ 1] = xlocal[0];
- y[ 1] = ylocal[0];
-
- x[ 2] = xlocal[1];
- y[ 2] = ylocal[1];
-
- x[ 5] = xlocal[2];
- y[ 5] = ylocal[2];
-
- x[ 6] = xlocal[3];
- y[ 6] = ylocal[3];
-
- x[ 9] = xlocal[4];
- y[ 9] = ylocal[4];
-
- x[10] = xlocal[5];
- y[10] = ylocal[5];
-
- //Create the first outer pseudo-quadrant
- FillSPDXtruShape(oua,oub,our,t,xlocal,ylocal);
- x[23] = xlocal[0];
- y[23] = ylocal[0];
-
- x[20] = xlocal[1];
- y[20] = ylocal[1];
-
- x[19] = xlocal[2];
- y[19] = ylocal[2];
-
- x[16] = xlocal[3];
- y[16] = ylocal[3];
-
- x[15] = xlocal[4];
- y[15] = ylocal[4];
-
- x[11] = xlocal[5];
- y[11] = ylocal[5];
- //Create the second inner pseudo-quadrant
- FillSPDXtruShape(ina+2*d,inb-2*d,inr+d,t,xlocal,ylocal);
- x[22] = xlocal[0];
- y[22] = ylocal[0];
+ // This vector contains the index of those points which coincide
+ // with the corresponding points in the air shape
+ Int_t indexAir2Omega[12] = {1, 2, 5, 6, 9, 10, 11, 15, 16, 19, 20, 23};
- x[21] = xlocal[1];
- y[21] = ylocal[1];
+ // First fill those vertexes corresponding to
+ // the edges aligned to the air shape edges
+ for (Int_t j=0; j<12; j++) {
+ x[*(indexAir2Omega+j)] = xin[j];
+ y[*(indexAir2Omega+j)] = yin[j];
+ }
- x[18] = xlocal[2];
- y[18] = ylocal[2];
+ // Now get the coordinates of the first inner point
+ PointFromParallelLines(x[23],y[23],x[1],y[1],d,x[0],y[0]);
- x[17] = xlocal[3];
- y[17] = ylocal[3];
+ // Knowing this, the second internal point can be determined
+ InsidePoint(x[0],y[0],x[1],y[1],x[2],y[2],d,x[22],y[22]);
- x[14] = xlocal[4];
- y[14] = ylocal[4];
+ // The third point is now computable
+ ReflectPoint(x[1],y[1],x[2],y[2],x[22],y[22],x[21],y[21]);
- x[13] = xlocal[5];
- y[13] = ylocal[5];
+ // Repeat this logic
+ InsidePoint(x[21],y[21],x[20],y[20],x[19],y[19],-d,x[3],y[3]);
- //Create the second outer pseudo-quadrant
- FillSPDXtruShape(oua-2*d,oub+2*d,our-d,t,xlocal,ylocal);
- x[ 0] = xlocal[0];
- y[ 0] = ylocal[0];
+ ReflectPoint(x[20],y[20],x[19],y[19],x[3],y[3],x[4],y[4]);
- x[ 3] = xlocal[1];
- y[ 3] = ylocal[1];
+ InsidePoint(x[4],y[4],x[5],y[5],x[6],y[6],d,x[18],y[18]);
- x[ 4] = xlocal[2];
- y[ 4] = ylocal[2];
+ ReflectPoint(x[5],y[5],x[6],y[6],x[18],y[18],x[17],y[17]);
- x[ 7] = xlocal[3];
- y[ 7] = ylocal[3];
+ InsidePoint(x[17],y[17],x[16],y[16],x[15],y[15],-d,x[7],y[7]);
- x[ 8] = xlocal[4];
- y[ 8] = ylocal[4];
+ ReflectPoint(x[16],y[16],x[15],y[15],x[7],y[7],x[8],y[8]);
- x[12] = xlocal[5];
- y[12] = ylocal[5];
+ InsidePoint(x[8],y[8],x[9],y[9],x[10],y[10],d,x[14],y[14]);
// These need to be fixed explicitly
- y[10] = yin[5];
- y[11] = yin[6];
x[12] = x[11];
y[12] = y[11] + d;
x[13] = x[10] + d;
y[13] = y[12];
- // Finally reflex on the negative side
+ // Finally reflect on the negative side
for (Int_t i=0; i<24; i++) {
x[24+i] = -x[23-i];
y[24+i] = y[23-i];
return;
}
+//______________________________________________________________________
+void AliITSv11GeometrySupport::PointFromParallelLines(Double_t x1, Double_t y1,
+ Double_t x2, Double_t y2, Double_t d,
+ Double_t &x, Double_t &y)
+{
+//
+// Determines the X and Y of the first internal point of the Omega shape
+// (i.e. the coordinates of a point given two parallel lines passing by
+// two points and placed at a known distance)
+//
+// Input:
+// x1, y1 : first point
+// x2, y2 : second point
+// d : distance between the two lines
+//
+// Output:
+// x, y : coordinate of the point
+//
+// Created: 22 Feb 2009 Mario Sitta
+//
+//Begin_Html
+/*
+<img src="ITS/doc/PointFromParallelLines.gif">
+*/
+//End_Html
+
+ // The slope of the paralles lines at a distance d
+ Double_t m;
+
+ // The parameters of the solving equation
+ // a x^2 - 2 b x + c = 0
+ Double_t a = (x1 - x2)*(x1 - x2) - d*d;
+ Double_t b = (x1 - x2)*(y1 - y2);
+ Double_t c = (y1 - y2)*(y1 - y2) - d*d;
+
+ // (Delta4 is Delta/4 because we use the reduced formula)
+ Double_t Delta4 = b*b - a*c;
+
+ // Compute the slope of the two parallel lines
+ // (one of the two possible slopes, the one with the smaller
+ // absolute value is needed)
+ if (Delta4 < 0) { // Should never happen with our data, but just to be sure
+ x = -1; // x is expected positive, so this flags an error
+ return;
+ } else
+ m = (b + TMath::Sqrt(Delta4))/a; // b is negative with our data
+
+ // Finally compute the coordinates of the point
+ x = x2 + (y1 - y2 - d)/m;
+ y = y1 - d;
+
+ // Done
+ return;
+}
+
+//______________________________________________________________________
+void AliITSv11GeometrySupport::ReflectPoint(Double_t x1, Double_t y1,
+ Double_t x2, Double_t y2,
+ Double_t x3, Double_t y3,
+ Double_t &x, Double_t &y)
+{
+//
+// Given two points (x1,y1) and (x2,y2), determines the point (x,y)
+// lying on the line parallel to the line passing by these points,
+// at a distance d and passing by the point (x3,y3), which is symmetric to
+// the third point with respect to the axis of the segment delimited by
+// the two first points.
+//
+// Input:
+// x1, y1 : first point
+// x2, y2 : second point
+// x3, y3 : third point
+// d : distance between the two lines
+//
+// Output:
+// x, y : coordinate of the reflected point
+//
+// Created: 22 Feb 2009 Mario Sitta
+//
+//Begin_Html
+/*
+<img src="ITS/doc/ReflectPoint.gif">
+*/
+//End_Html
+
+ // The slope of the line passing by the first two points
+ Double_t k = (y2 - y1)/(x2 - x1);
+
+ // The middle point of the segment 1-2
+ Double_t xK = (x1 + x2)/2.;
+ Double_t yK = (y1 + y2)/2.;
+
+ // The intercept between the axis of the segment 1-2 and the line
+ // passing by 3 and parallel to the line passing by 1-2
+ Double_t xH = (k*k*x3 + k*(yK - y3) + xK)/(k*k + 1);
+ Double_t yH = k*(xH - x3) + y3;
+
+ // The point symmetric to 3 with respect to H
+ x = 2*xH - x3;
+ y = 2*yH - y3;
+
+ // Done
+ return;
+}
+
//______________________________________________________________________
void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,TGeoManager *mgr)
{
//
// Created: ??? Bjorn S. Nilsen
// Updated: 18 Feb 2008 Mario Sitta
+// Updated: 25 Jul 2008 Mario Sitta SDDCarbonFiberCone simpler
//
// Technical data are taken from: "Supporto Generale Settore SDD"
// (technical drawings ALR-0816/1-B), "Supporto Globale Settore SDD"
const Double_t kConeROutMax = (560.0/2)*fgkmm;
const Double_t kConeRCurv = 10.0*fgkmm; // Radius of curvature
const Double_t kConeRinMin = (210.0/2)*fgkmm;
- const Double_t kConeRinMax = (216.0/2)*fgkmm;
+// const Double_t kConeRinMax = (216.0/2)*fgkmm;
const Double_t kConeRinCylinder = (231.0/2)*fgkmm;
const Double_t kConeZCylinder = 192.0*fgkmm;
const Double_t kConeZOuterMilled = 23.0*fgkmm;
dza = kConeThickness/kSinConeTheta-(kConeROutMax-kConeROutMin)/kTanConeTheta;
- TGeoPcon *coneshape = new TGeoPcon(0.0, 360.0, 12);
+ TGeoPcon *coneshape = new TGeoPcon(0.0, 360.0, 10);
coneshape->Z(0) = 0.0;
coneshape->Rmin(0) = kConeROutMin;
coneshape->Rmax(3) = RmaxFrom2Points(coneshape,4,2,coneshape->GetZ(3));
+ coneshape->Z(6) = kConeZCylinder - kConeDZin;
+
+ RadiusOfCurvature(kConeRCurv,90.0,coneshape->GetZ(6),0.0,
+ 90.0-kConeTheta,z,rmin);
+ coneshape->Z(5) = z;
+ coneshape->Rmin(5) = RminFromZpCone(coneshape,3,kConeTheta,z);
+ coneshape->Rmax(5) = RmaxFromZpCone(coneshape,4,kConeTheta,z);
+
+ RadiusOfCurvature(kConeRCurv,90.-kConeTheta,
+ 0.0,coneshape->Rmin(5),90.0,z,rmin);
+ coneshape->Rmin(6) = rmin;
+ coneshape->Rmax(6) = RmaxFromZpCone(coneshape,4,kConeTheta,
+ coneshape->GetZ(6));
+
+ coneshape->Z(7) = coneshape->GetZ(6);
coneshape->Rmin(7) = kConeRinMin;
+ coneshape->Rmax(7) = coneshape->GetRmax(6);
coneshape->Rmin(8) = kConeRinMin;
- RadiusOfCurvature(kConeRCurv,90.0,0.0,kConeRinMax,90.0-kConeTheta,z,rmax);
+ RadiusOfCurvature(kConeRCurv,90.0,kConeZCylinder,kConeRinCylinder,
+ 90.0-kConeTheta,z,rmax);
+ coneshape->Z(8) = z;
coneshape->Rmax(8) = rmax;
- coneshape->Z(8) = ZFromRmaxpCone(coneshape,4,kConeTheta,
- coneshape->GetRmax(8));
coneshape->Z(9) = kConeZCylinder;
coneshape->Rmin(9) = kConeRinMin;
+ coneshape->Rmax(9) = kConeRinCylinder;
- coneshape->Z(10) = coneshape->GetZ(9);
- coneshape->Rmin(10) = kConeRinCylinder;
-
- coneshape->Rmin(11) = kConeRinCylinder;
- coneshape->Rmax(11) = coneshape->GetRmin(11);
-
- rmin = coneshape->GetRmin(8);
- RadiusOfCurvature(kConeRCurv,90.0-kConeTheta,
- coneshape->GetZ(8),coneshape->GetRmax(8),90.0,z,rmax);
- rmax = kConeRinMax;
- coneshape->Z(11) = z + (coneshape->GetZ(8)-z)*
- (coneshape->GetRmax(11)-rmax)/(coneshape->GetRmax(8)-rmax);
-
- coneshape->Rmax(9) = RmaxFrom2Points(coneshape,11,8,coneshape->GetZ(9));
-
- coneshape->Rmax(10) = coneshape->GetRmax(9);
-
- coneshape->Z(6) = z - kConeDZin;
- coneshape->Z(7) = coneshape->GetZ(6);
-
- coneshape->Rmax(6) = RmaxFromZpCone(coneshape,4,kConeTheta,
- coneshape->GetZ(6));
-
- coneshape->Rmax(7) = coneshape->GetRmax(6);
-
- RadiusOfCurvature(kConeRCurv,90.,
- coneshape->GetZ(6),0.0,90.0-kConeTheta,z,rmin);
- coneshape->Z(5) = z;
- coneshape->Rmin(5) = RminFromZpCone(coneshape,3,kConeTheta,z);
- coneshape->Rmax(5) = RmaxFromZpCone(coneshape,4,kConeTheta,z);
-
- RadiusOfCurvature(kConeRCurv,90.-kConeTheta,
- 0.0,coneshape->Rmin(5),90.0,z,rmin);
- coneshape->Rmin(6) = rmin;
// SDD Cone Insert: another Pcon
Double_t x0, y0, x1, y1, x2, y2;
conefoamshape->Rmin(3) = conefoamshape->GetRmax(3);
// SDD Cone Holes: Pcon's
+ // A single hole volume gives an overlap with coneinsert, so
+ // three contiguous volumes are created: one to be put in the cone foam
+ // and two in the cone carbon fiber envelope
TGeoPcon *hole1shape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
hole1shape->Rmin(0) = kHole1RMax;
hole1shape->Rmax(0) = hole1shape->GetRmin(0);
- hole1shape->Z(0) = ZFromRminpCone(coneshape,3,kConeTheta,
+ hole1shape->Z(0) = ZFromRminpCone(conefoamshape,0,kConeTheta,
hole1shape->GetRmin(0));
hole1shape->Rmax(1) = hole1shape->GetRmax(0);
- hole1shape->Z(1) = ZFromRmaxpCone(coneshape,4,kConeTheta,
+ hole1shape->Z(1) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
hole1shape->GetRmax(1));
- hole1shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
+ hole1shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta,
hole1shape->GetZ(1));
hole1shape->Rmin(2) = kHole1RMin;
- hole1shape->Z(2) = ZFromRminpCone(coneshape,3,kConeTheta,
+ hole1shape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta,
hole1shape->GetRmin(2));
- hole1shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
+ hole1shape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
hole1shape->GetZ(2));
hole1shape->Rmin(3) = hole1shape->GetRmin(2);
hole1shape->Rmax(3) = hole1shape->GetRmin(3);
- hole1shape->Z(3) = ZFromRmaxpCone(coneshape,4,kConeTheta,
+ hole1shape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
hole1shape->GetRmax(3));
+ TGeoPcon *hole11shape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
+
+ hole11shape->Rmin(0) = kHole1RMax;
+ hole11shape->Rmax(0) = hole11shape->GetRmin(0);
+ hole11shape->Z(0) = ZFromRminpCone(coneshape,3,kConeTheta,
+ hole11shape->GetRmin(0));
+
+ hole11shape->Rmax(1) = hole11shape->GetRmax(0);
+ hole11shape->Z(1) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
+ hole11shape->GetRmax(1));
+ hole11shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
+ hole11shape->GetZ(1));
+
+ hole11shape->Rmin(2) = kHole1RMin;
+ hole11shape->Z(2) = ZFromRminpCone(coneshape,3,kConeTheta,
+ hole11shape->GetRmin(2));
+ hole11shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
+ hole11shape->GetZ(2));
+
+ hole11shape->Rmin(3) = hole11shape->GetRmin(2);
+ hole11shape->Rmax(3) = hole11shape->GetRmin(3);
+ hole11shape->Z(3) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
+ hole11shape->GetRmax(3));
+
+ TGeoPcon *hole12shape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
+
+ hole12shape->Rmin(0) = kHole1RMax;
+ hole12shape->Rmax(0) = hole12shape->GetRmin(0);
+ hole12shape->Z(0) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
+ hole12shape->GetRmin(0));
+
+ hole12shape->Rmax(1) = hole12shape->GetRmax(0);
+ hole12shape->Z(1) = ZFromRmaxpCone(coneshape,4,kConeTheta,
+ hole12shape->GetRmax(1));
+ hole12shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
+ hole12shape->GetZ(1));
+
+ hole12shape->Rmin(2) = kHole1RMin;
+ hole12shape->Z(2) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
+ hole12shape->GetRmin(2));
+ hole12shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
+ hole12shape->GetZ(2));
+
+ hole12shape->Rmin(3) = hole12shape->GetRmin(2);
+ hole12shape->Rmax(3) = hole12shape->GetRmin(3);
+ hole12shape->Z(3) = ZFromRmaxpCone(coneshape,4,kConeTheta,
+ hole12shape->GetRmax(3));
+
+ //
TGeoPcon *hole2shape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
hole2shape->Rmin(0) = kHole2RMax;
hole2shape->Rmax(0) = hole2shape->GetRmin(0);
- hole2shape->Z(0) = ZFromRminpCone(coneshape,3,kConeTheta,
+ hole2shape->Z(0) = ZFromRminpCone(conefoamshape,0,kConeTheta,
hole2shape->GetRmin(0));
hole2shape->Rmax(1) = hole2shape->GetRmax(0);
- hole2shape->Z(1) = ZFromRmaxpCone(coneshape,4,kConeTheta,
+ hole2shape->Z(1) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
hole2shape->GetRmax(1));
- hole2shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
+ hole2shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta,
hole2shape->GetZ(1));
hole2shape->Rmin(2) = kHole2RMin;
- hole2shape->Z(2) = ZFromRminpCone(coneshape,3,kConeTheta,
+ hole2shape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta,
hole2shape->GetRmin(2));
- hole2shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
+ hole2shape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
hole2shape->GetZ(2));
hole2shape->Rmin(3) = hole2shape->GetRmin(2);
hole2shape->Rmax(3) = hole2shape->GetRmin(3);
- hole2shape->Z(3) = ZFromRmaxpCone(coneshape,4,kConeTheta,
+ hole2shape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
hole2shape->GetRmax(3));
+ TGeoPcon *hole21shape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
+
+ hole21shape->Rmin(0) = kHole2RMax;
+ hole21shape->Rmax(0) = hole21shape->GetRmin(0);
+ hole21shape->Z(0) = ZFromRminpCone(coneshape,3,kConeTheta,
+ hole21shape->GetRmin(0));
+
+ hole21shape->Rmax(1) = hole21shape->GetRmax(0);
+ hole21shape->Z(1) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
+ hole21shape->GetRmax(1));
+ hole21shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
+ hole21shape->GetZ(1));
+
+ hole21shape->Rmin(2) = kHole2RMin;
+ hole21shape->Z(2) = ZFromRminpCone(coneshape,3,kConeTheta,
+ hole21shape->GetRmin(2));
+ hole21shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
+ hole21shape->GetZ(2));
+
+ hole21shape->Rmin(3) = hole21shape->GetRmin(2);
+ hole21shape->Rmax(3) = hole21shape->GetRmin(3);
+ hole21shape->Z(3) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
+ hole21shape->GetRmax(3));
+
+ TGeoPcon *hole22shape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
+
+ hole22shape->Rmin(0) = kHole2RMax;
+ hole22shape->Rmax(0) = hole22shape->GetRmin(0);
+ hole22shape->Z(0) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
+ hole22shape->GetRmin(0));
+
+ hole22shape->Rmax(1) = hole22shape->GetRmax(0);
+ hole22shape->Z(1) = ZFromRmaxpCone(coneshape,4,kConeTheta,
+ hole22shape->GetRmax(1));
+ hole22shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
+ hole22shape->GetZ(1));
+
+ hole22shape->Rmin(2) = kHole2RMin;
+ hole22shape->Z(2) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
+ hole22shape->GetRmin(2));
+ hole22shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
+ hole22shape->GetZ(2));
+
+ hole22shape->Rmin(3) = hole22shape->GetRmin(2);
+ hole22shape->Rmax(3) = hole22shape->GetRmin(3);
+ hole22shape->Z(3) = ZFromRmaxpCone(coneshape,4,kConeTheta,
+ hole22shape->GetRmax(3));
+
+ //
Double_t holePhi;
holePhi = (kHole3Width/kHole3RMin)*TMath::RadToDeg();
hole3shape->Rmin(0) = kHole3RMin + kHole3DeltaR;
hole3shape->Rmax(0) = hole3shape->GetRmin(0);
- hole3shape->Z(0) = ZFromRminpCone(coneshape,3,kConeTheta,
+ hole3shape->Z(0) = ZFromRminpCone(conefoamshape,0,kConeTheta,
hole3shape->GetRmin(0));
hole3shape->Rmax(1) = hole3shape->GetRmax(0);
- hole3shape->Z(1) = ZFromRmaxpCone(coneshape,4,kConeTheta,
+ hole3shape->Z(1) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
hole3shape->GetRmax(1));
- hole3shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
+ hole3shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta,
hole3shape->GetZ(1));
hole3shape->Rmin(2) = kHole3RMin;
- hole3shape->Z(2) = ZFromRminpCone(coneshape,3,kConeTheta,
+ hole3shape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta,
hole3shape->GetRmin(2));
- hole3shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
+ hole3shape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
hole3shape->GetZ(2));
hole3shape->Rmin(3) = hole3shape->GetRmin(2);
hole3shape->Rmax(3) = hole3shape->GetRmin(3);
- hole3shape->Z(3) = ZFromRmaxpCone(coneshape,4,kConeTheta,
+ hole3shape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
hole3shape->GetRmax(3));
+ TGeoPcon *hole31shape = new TGeoPcon(-holePhi/2., holePhi, 4);
+
+ hole31shape->Rmin(0) = kHole3RMin + kHole3DeltaR;
+ hole31shape->Rmax(0) = hole31shape->GetRmin(0);
+ hole31shape->Z(0) = ZFromRminpCone(coneshape,3,kConeTheta,
+ hole31shape->GetRmin(0));
+
+ hole31shape->Rmax(1) = hole31shape->GetRmax(0);
+ hole31shape->Z(1) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
+ hole31shape->GetRmax(1));
+ hole31shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
+ hole31shape->GetZ(1));
+
+ hole31shape->Rmin(2) = kHole3RMin;
+ hole31shape->Z(2) = ZFromRminpCone(coneshape,3,kConeTheta,
+ hole31shape->GetRmin(2));
+ hole31shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
+ hole31shape->GetZ(2));
+
+ hole31shape->Rmin(3) = hole31shape->GetRmin(2);
+ hole31shape->Rmax(3) = hole31shape->GetRmin(3);
+ hole31shape->Z(3) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
+ hole31shape->GetRmax(3));
+
+ TGeoPcon *hole32shape = new TGeoPcon(-holePhi/2., holePhi, 4);
+
+ hole32shape->Rmin(0) = kHole3RMin + kHole3DeltaR;
+ hole32shape->Rmax(0) = hole32shape->GetRmin(0);
+ hole32shape->Z(0) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
+ hole32shape->GetRmin(0));
+
+ hole32shape->Rmax(1) = hole32shape->GetRmax(0);
+ hole32shape->Z(1) = ZFromRmaxpCone(coneshape,4,kConeTheta,
+ hole32shape->GetRmax(1));
+ hole32shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
+ hole32shape->GetZ(1));
+
+ hole32shape->Rmin(2) = kHole3RMin;
+ hole32shape->Z(2) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
+ hole32shape->GetRmin(2));
+ hole32shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
+ hole32shape->GetZ(2));
+
+ hole32shape->Rmin(3) = hole32shape->GetRmin(2);
+ hole32shape->Rmax(3) = hole32shape->GetRmin(3);
+ hole32shape->Z(3) = ZFromRmaxpCone(coneshape,4,kConeTheta,
+ hole32shape->GetRmax(3));
+
+ //
holePhi = (kHole4Width/kHole4RMin)*TMath::RadToDeg();
TGeoPcon *hole4shape = new TGeoPcon(-holePhi/2., holePhi, 4);
conefoamshape->InspectShape();
hole1shape->InspectShape();
hole2shape->InspectShape();
+ hole3shape->InspectShape();
+ hole4shape->InspectShape();
}
hole1->SetFillColor(hole1->GetLineColor());
hole1->SetFillStyle(4090); // 90% transparent
+ TGeoVolume *hole11 = new TGeoVolume("SDDCableHole11",
+ hole11shape,medSDDair);
+ hole11->SetVisibility(kTRUE);
+ hole11->SetLineColor(5); // Yellow
+ hole11->SetLineWidth(1);
+ hole11->SetFillColor(hole11->GetLineColor());
+ hole11->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *hole12 = new TGeoVolume("SDDCableHole12",
+ hole12shape,medSDDair);
+ hole12->SetVisibility(kTRUE);
+ hole12->SetLineColor(5); // Yellow
+ hole12->SetLineWidth(1);
+ hole12->SetFillColor(hole12->GetLineColor());
+ hole12->SetFillStyle(4090); // 90% transparent
+
TGeoVolume *hole2 = new TGeoVolume("SDDCableHole2",
hole2shape,medSDDair);
hole2->SetVisibility(kTRUE);
hole2->SetFillColor(hole2->GetLineColor());
hole2->SetFillStyle(4090); // 90% transparent
+ TGeoVolume *hole21 = new TGeoVolume("SDDCableHole21",
+ hole21shape,medSDDair);
+ hole21->SetVisibility(kTRUE);
+ hole21->SetLineColor(5); // Yellow
+ hole21->SetLineWidth(1);
+ hole21->SetFillColor(hole21->GetLineColor());
+ hole21->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *hole22 = new TGeoVolume("SDDCableHole22",
+ hole22shape,medSDDair);
+ hole22->SetVisibility(kTRUE);
+ hole22->SetLineColor(5); // Yellow
+ hole22->SetLineWidth(1);
+ hole22->SetFillColor(hole22->GetLineColor());
+ hole22->SetFillStyle(4090); // 90% transparent
+
TGeoVolume *hole3 = new TGeoVolume("SDDCableHole3",
hole3shape,medSDDair);
hole3->SetVisibility(kTRUE);
hole3->SetFillColor(hole3->GetLineColor());
hole3->SetFillStyle(4090); // 90% transparent
+ TGeoVolume *hole31 = new TGeoVolume("SDDCableHole31",
+ hole31shape,medSDDair);
+ hole31->SetVisibility(kTRUE);
+ hole31->SetLineColor(5); // Yellow
+ hole31->SetLineWidth(1);
+ hole31->SetFillColor(hole31->GetLineColor());
+ hole31->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *hole32 = new TGeoVolume("SDDCableHole32",
+ hole32shape,medSDDair);
+ hole32->SetVisibility(kTRUE);
+ hole32->SetLineColor(5); // Yellow
+ hole32->SetLineWidth(1);
+ hole32->SetFillColor(hole32->GetLineColor());
+ hole32->SetFillStyle(4090); // 90% transparent
+
TGeoVolume *hole4 = new TGeoVolume("SDDCableHole4",
hole4shape,medSDDair);
hole4->SetVisibility(kTRUE);
// Mount up a cone
cfconeinsert->AddNode(cfconefoam,1,0);
- cfcone->AddNode(cfconeinsert,1,0);
-
for (Int_t i=0; i<12; i++) {
Double_t phiH = i*30.0;
- cfcone->AddNode(hole1, i+1, new TGeoRotation("", 0, 0, phiH));
+ cfconefoam->AddNode(hole1 , i+1, new TGeoRotation("", 0, 0, phiH));
+ cfcone->AddNode(hole11, i+1, new TGeoRotation("", 0, 0, phiH));
+ cfcone->AddNode(hole12, i+1, new TGeoRotation("", 0, 0, phiH));
}
for (Int_t i=0; i<6; i++) {
Double_t phiH = i*60.0;
- cfcone->AddNode(hole2, i+1, new TGeoRotation("", 0, 0, phiH));
+ cfconefoam->AddNode(hole2 , i+1, new TGeoRotation("", 0, 0, phiH));
+ cfcone->AddNode(hole21, i+1, new TGeoRotation("", 0, 0, phiH));
+ cfcone->AddNode(hole22, i+1, new TGeoRotation("", 0, 0, phiH));
}
for (Int_t i=0; i<kNHole3; i++) {
Double_t phiH0 = 360./(Double_t)kNHole3;
Double_t phiH = i*phiH0 + 0.5*phiH0;
- cfcone->AddNode(hole3, i+1, new TGeoRotation("", phiH, 0, 0));
+ cfconefoam->AddNode(hole3 , i+1, new TGeoRotation("", phiH, 0, 0));
+ cfcone->AddNode(hole31, i+1, new TGeoRotation("", phiH, 0, 0));
+ cfcone->AddNode(hole32, i+1, new TGeoRotation("", phiH, 0, 0));
}
+
+ cfcone->AddNode(cfconeinsert,1,0);
+
/*
for (Int_t i=0; i<kNHole4; i++) {
Double_t phiH0 = 360./(Double_t)kNHole4;
(kCylinderHalfLength-kFoamHalfLength)/2.;
const Double_t kFlangeInnerRadius = ( 563.0/2) *fgkmm;
// Dimensions of the Cone
- const Double_t kConeROuterMin = ( 945.0/2) *fgkmm;
- const Double_t kConeROuterMax = ( 985.0/2) *fgkmm;
+ const Double_t kConeROuterMin = ( 957.0/2) *fgkmm;
+ const Double_t kConeROuterMax = ( 997.0/2) *fgkmm;
const Double_t kConeRInnerMin = ( 564.0/2) *fgkmm;
const Double_t kConeRCurv1 = 10.0 *fgkmm;
const Double_t kConeRCurv2 = 25.0 *fgkmm;
const Double_t kConeCent1RCurv2 = ( 578.0/2) *fgkmm;
- const Double_t kConeCent2RCurv2 = ( 593.0/2) *fgkmm;
+ const Double_t kConeCent2RCurv2 = ( 592.0/2) *fgkmm;
// const Double_t kConeZOuterRing = 47.0 *fgkmm;
// const Double_t kConeZOuterRingInside = 30.25*fgkmm;
// const Double_t kConeZInnerRing = 161.5 *fgkmm;
const Double_t kConeZLength = 168.0 *fgkmm;
const Double_t kConeZPosition = kConeZLength + kCylinderHalfLength;
const Double_t kConeThickness = 13.0 *fgkmm; // Cone thickness
- const Double_t kConeTheta = 39.0 *fgkDegree; // Cone angle
+ const Double_t kConeTheta = 39.1 *fgkDegree; // Cone angle
const Double_t kSinConeTheta =
TMath::Sin(kConeTheta*TMath::DegToRad());
const Double_t kCosConeTheta =
const Double_t kWingHalfThick = ( 10.0/2) *fgkmm;
const Double_t kThetaWing = 45.0 *fgkDegree;
// Dimensions of the SSD-SDD Mounting Brackets
- const Double_t kBracketRmin = ( 540.0/2) *fgkmm;// See SDD ROutMin
+ const Double_t kBracketRmin = ( 541.0/2) *fgkmm;// See SDD ROutMin
const Double_t kBracketRmax = ( 585.0/2) *fgkmm;
const Double_t kBracketHalfLength = ( 4.0/2) *fgkmm;
const Double_t kBracketPhi = (70.*fgkmm/kBracketRmax)*fgkRadian;
conefoam2shape->GetZ(1));
// SSD Cone Holes: Pcon's
+ // A single hole volume gives an overlap with coneinsert, so
+ // three contiguous volumes are created: one to be put in coneinsert
+ // and two in the cone carbon fiber envelope
Double_t holePhi;
holePhi = (kCoolingHoleWidth/kCoolingHoleRmin)*TMath::RadToDeg();
coolingholeshape->Rmin(0) = kCoolingHoleRmin + kCoolingHoleHight;
coolingholeshape->Rmax(0) = coolingholeshape->GetRmin(0);
- coolingholeshape->Z(0) = ZFromRminpCone(coneshape,3,90.-kConeTheta,
+ coolingholeshape->Z(0) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
coolingholeshape->GetRmin(0));
coolingholeshape->Rmax(1) = coolingholeshape->GetRmax(0);
- coolingholeshape->Z(1) = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
+ coolingholeshape->Z(1) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
coolingholeshape->GetRmax(1));
- coolingholeshape->Rmin(1) = RminFromZpCone(coneshape,3,90.-kConeTheta,
+ coolingholeshape->Rmin(1) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
coolingholeshape->GetZ(1));
coolingholeshape->Rmin(2) = kCoolingHoleRmin;
- coolingholeshape->Z(2) = ZFromRminpCone(coneshape,3,90.-kConeTheta,
+ coolingholeshape->Z(2) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
coolingholeshape->GetRmin(2));
- coolingholeshape->Rmax(2) = RmaxFromZpCone(coneshape,7,90.-kConeTheta,
+ coolingholeshape->Rmax(2) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
coolingholeshape->GetZ(2));
coolingholeshape->Rmin(3) = coolingholeshape->GetRmin(2);
coolingholeshape->Rmax(3) = coolingholeshape->GetRmin(3);
- coolingholeshape->Z(3) = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
+ coolingholeshape->Z(3) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
coolingholeshape->GetRmax(3));
- // This is really weird: a single mountinghole volume gives an overlap
- // with coneinsert (why doesn't coolinghole ?), so three contiguous
- // volumes are created: one to be put in coneinsert and two in the cone
- // carbon fiber envelope
+ TGeoPcon *coolinghole2shape = new TGeoPcon(-holePhi/2., holePhi, 4);
+
+ coolinghole2shape->Rmin(0) = kCoolingHoleRmin + kCoolingHoleHight;
+ coolinghole2shape->Rmax(0) = coolinghole2shape->GetRmin(0);
+ coolinghole2shape->Z(0) = ZFromRminpCone(coneshape,3,90.-kConeTheta,
+ coolinghole2shape->GetRmin(0));
+
+ coolinghole2shape->Rmax(1) = coolinghole2shape->GetRmax(0);
+ coolinghole2shape->Z(1) = coolingholeshape->GetZ(0);
+ coolinghole2shape->Rmin(1) = RminFromZpCone(coneshape,3,90.-kConeTheta,
+ coolinghole2shape->GetZ(1));
+
+ coolinghole2shape->Rmin(2) = kCoolingHoleRmin;
+ coolinghole2shape->Z(2) = ZFromRminpCone(coneshape,3,90.-kConeTheta,
+ coolinghole2shape->GetRmin(2));
+ coolinghole2shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
+ coolinghole2shape->GetZ(2));
+
+ coolinghole2shape->Rmin(3) = coolinghole2shape->GetRmin(2);
+ coolinghole2shape->Rmax(3) = coolinghole2shape->GetRmin(3);
+ coolinghole2shape->Z(3) = coolingholeshape->GetZ(2);
+
+ TGeoPcon *coolinghole3shape = new TGeoPcon(-holePhi/2., holePhi, 4);
+
+ coolinghole3shape->Rmin(0) = kCoolingHoleRmin + kCoolingHoleHight;
+ coolinghole3shape->Rmax(0) = coolinghole3shape->GetRmin(0);
+ coolinghole3shape->Z(0) = coolingholeshape->GetZ(1);
+
+ coolinghole3shape->Rmax(1) = coolinghole3shape->GetRmax(0);
+ coolinghole3shape->Z(1) = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
+ coolinghole3shape->GetRmax(1));
+ coolinghole3shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
+ coolinghole3shape->GetZ(1));
+
+ coolinghole3shape->Rmin(2) = kCoolingHoleRmin;
+ coolinghole3shape->Z(2) = coolingholeshape->GetZ(3);
+ coolinghole3shape->Rmax(2) = RmaxFromZpCone(coneshape,7,90.-kConeTheta,
+ coolinghole3shape->GetZ(2));
+
+ coolinghole3shape->Rmin(3) = coolinghole3shape->GetRmin(2);
+ coolinghole3shape->Rmax(3) = coolinghole3shape->GetRmin(3);
+ coolinghole3shape->Z(3) = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
+ coolinghole3shape->GetRmax(3));
+
+ //
holePhi = (kMountingHoleWidth/kMountingHoleRmin)*TMath::RadToDeg();
TGeoPcon *mountingholeshape = new TGeoPcon(-holePhi/2., holePhi, 4);
coolinghole->SetFillColor(coolinghole->GetLineColor());
coolinghole->SetFillStyle(4090); // 90% transparent
+ TGeoVolume *coolinghole2 = new TGeoVolume("SSDCoolingHole2",
+ coolinghole2shape,medSSDair);
+ coolinghole2->SetVisibility(kTRUE);
+ coolinghole2->SetLineColor(5); // Yellow
+ coolinghole2->SetLineWidth(1);
+ coolinghole2->SetFillColor(coolinghole2->GetLineColor());
+ coolinghole2->SetFillStyle(4090); // 90% transparent
+
+ TGeoVolume *coolinghole3 = new TGeoVolume("SSDCoolingHole3",
+ coolinghole3shape,medSSDair);
+ coolinghole3->SetVisibility(kTRUE);
+ coolinghole3->SetLineColor(5); // Yellow
+ coolinghole3->SetLineWidth(1);
+ coolinghole3->SetFillColor(coolinghole3->GetLineColor());
+ coolinghole3->SetFillStyle(4090); // 90% transparent
+
TGeoVolume *mountinghole = new TGeoVolume("SSDMountingHole",
mountingholeshape,medSSDair);
mountinghole->SetVisibility(kTRUE);
cfconefoam2->AddNode(mountinghole,i+1, new TGeoRotation("", phiH, 0, 0));
}
+ for (Int_t i=0; i<(Int_t)(360./kCoolingHolePhi); i++) {
+ Double_t phiH = i*kCoolingHolePhi + 0.5*kCoolingHolePhi;
+ cfconeinsert->AddNodeOverlap(coolinghole,i+1, new TGeoRotation("", phiH, 0, 0));
+ }
+
cfconeinsert->AddNode(cfconefoam1,1,0);
cfconeinsert->AddNode(cfconefoam2,1,0);
for (Int_t i=0; i<(Int_t)(360./kCoolingHolePhi); i++) {
Double_t phiH = i*kCoolingHolePhi + 0.5*kCoolingHolePhi;
- cfcone->AddNode(coolinghole,i+1, new TGeoRotation("", phiH, 0, 0));
+ cfcone->AddNode(coolinghole2,i+1, new TGeoRotation("", phiH, 0, 0));
+ cfcone->AddNode(coolinghole3,i+1, new TGeoRotation("", phiH, 0, 0));
cfcone->AddNodeOverlap(cablehole,i+1, new TGeoRotation("", phiH, 0, 0));
}
vC->AddNode(cfcone,1,new TGeoTranslation(0,0,-kConeZPosition));
for (Int_t i=0; i<4; i++) {
- Double_t thetaW = kThetaWing + 90.*i;
- vC->AddNode(wing, i+1, new TGeoCombiTrans(0, 0, -kConeZPosition,
+ Double_t thetaW = kThetaWing + 90.*i + angleWideWing/2.;
+ vC->AddNode(wing, i+1, new TGeoCombiTrans(0, 0, -kConeZPosition+kWingHalfThick,
new TGeoRotation("",thetaW,180,0)));
}
Double_t zBracket = kConeZPosition - coneshape->GetZ(9) +
- bracketshape->GetDz();
+ 2*bracketshape->GetDz();
for (Int_t i=0; i<3; i++) {
Double_t thetaB = 60 + 120.*i;
vC->AddNode(bracket, i+1, new TGeoCombiTrans(0, 0, -zBracket,
} // end for i
if(GetDebug(1)) for(i=0;i<kct24Ntrays;i++) Info("ServicesCableSupport",
"tha[%d]=%f",i,tha[i]);
- Char_t *airName[kct24Ntrays]={"FMD0","SDD0","SSD0","SSD1","SPD0","SPD1",
+ const Char_t *airName[kct24Ntrays]={"FMD0","SDD0","SSD0","SSD1","SPD0","SPD1",
"TV00","SDD1","SDD2","SPD2","SPD3","ALG0",
"SPD4","SPD5","SSD2","SSD3","SPD6","SPD7",
"TV01","SDD3","SDD4","SPD8","SPD9","ALG1",
"TV02","SDD6","SDD7","SPDC","SPDD","ALG2",
"SPDE","SPDF","SSD6","SSD7","SPDG","SPDH",
"TV03","SDD8","SDD9","SPDI","SPDJ","ALG3"};
- Char_t *trayName[kct24Ntrays]={"FMD0","SSD0","SSD1","SSD2","SSD3","SPD0",
+ const Char_t *trayName[kct24Ntrays]={"FMD0","SSD0","SSD1","SSD2","SSD3","SPD0",
"TV00","SDD0","SDD1","SDD2","SPD1","ALG0",
"SPD2","SSD4","SSD5","SSD6","SSD7","SPD3",
"TV01","SDD3","SDD4","SDD5","SPD4","ALG1",
thb[i+ kft24NPatchPannels/2] = 180.0 + thb[i];
thb[i+3*kft24NPatchPannels/4] = 270.0 + thb[i];
} // end for i
- Char_t *pachName[kft24NPatchPannels]={"FMD0","SSD0","SPD0","SDD0","SPD1",
+ const Char_t *pachName[kft24NPatchPannels]={"FMD0","SSD0","SPD0","SDD0","SPD1",
"SPD2","SSD1","SPD3","SDD1","SPD4",
"FMD1","SSD2","SPD5","SDD2","SPD6",
"SPD7","SSD3","SPD8","SDD3","SPD9"};
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff