From: masera Date: Thu, 28 Jun 2007 10:17:25 +0000 (+0000) Subject: Introduction of the new SSD geometry in simulation (AliITSv11Hybrid) and suppression... X-Git-Url: http://git.uio.no/git/?p=u%2Fmrichter%2FAliRoot.git;a=commitdiff_plain;h=bf210566c86f7817f570df1dbf5ba455a41f6524 Introduction of the new SSD geometry in simulation (AliITSv11Hybrid) and suppression of overlaps between old and new parts --- diff --git a/ITS/AliITSInitGeometry.cxx b/ITS/AliITSInitGeometry.cxx index 1ccedf7d13c..4edc0c2c759 100644 --- a/ITS/AliITSInitGeometry.cxx +++ b/ITS/AliITSInitGeometry.cxx @@ -58,7 +58,7 @@ ClassImp(AliITSInitGeometry) const Bool_t AliITSInitGeometry::fgkOldSPDbarrel = kTRUE; const Bool_t AliITSInitGeometry::fgkOldSDDbarrel = kFALSE; -const Bool_t AliITSInitGeometry::fgkOldSSDbarrel = kTRUE; +const Bool_t AliITSInitGeometry::fgkOldSSDbarrel = kFALSE; const Bool_t AliITSInitGeometry::fgkOldSDDcone = kTRUE; const Bool_t AliITSInitGeometry::fgkOldSSDcone = kTRUE; const Bool_t AliITSInitGeometry::fgkOldSPDshield = kTRUE; @@ -794,14 +794,23 @@ Bool_t AliITSInitGeometry::InitAliITSgeomV11Hybrid(AliITSgeom *geom){ pathSDDsens1 = "%sITSD_1/IT34_1/I004_%d/I302_%d/ITS3_%d"; pathSDDsens2 = "%sITSD_1/IT34_1/I005_%d/I402_%d/ITS4_%d"; } - + + char *pathSSDsens1, *pathSSDsens2; + if (SSDIsTGeoNative()) { + pathSSDsens1 = "%sITSssdLayer5_1/ITSssdLay5Ladd_%d/ITSsddSensor5_%d/ITSsddSensitivL5_1"; + pathSSDsens2 = "%sITSssdLayer6_1/ITSssdLay6Ladd_%d/ITSsddSensor6_%d/ITSsddSensitivL6_1"; + } else{ + pathSSDsens1 = "%sITSD_1/IT56_1/I565_%d/I562_%d/ITS5_%d"; + pathSSDsens2 = "%sITSD_1/IT56_1/I569_%d/I566_%d/ITS6_%d"; + } + const TString kNames[klayers] = { "%sITSD_1/IT12_1/I12B_%d/I10B_%d/I107_%d/I101_1/ITS1_1", // lay=1 "%sITSD_1/IT12_1/I12B_%d/I20B_%d/I1D7_%d/I1D1_1/ITS2_1", // lay=2 pathSDDsens1, // lay=3 pathSDDsens2, // lay=4 - "%sITSD_1/IT56_1/I565_%d/I562_%d/ITS5_%d", // lay=5 - "%sITSD_1/IT56_1/I569_%d/I566_%d/ITS6_%d"};// Lay=6 + pathSSDsens1, // lay=5 + pathSSDsens2};// Lay=6 Int_t mod,nmods=0, lay, lad, det, cpn0, cpn1, cpn2; Double_t tran[3]={0.,0.,0.}, rot[10]={9*0.0,1.0}; @@ -825,14 +834,18 @@ Bool_t AliITSInitGeometry::InitAliITSgeomV11Hybrid(AliITSgeom *geom){ geom->CreateMatrix(mod,lay,lad,det,kIdet[lay-1],tran,rot); RecodeDetector(mod,cpn0,cpn1,cpn2); // Write reusing lay,lad,det. - - if (SDDIsTGeoNative()) if (kIdet[lay-1]==kSDD) { cpn0 = lad-1; cpn1 = det-1; cpn2 = 1; } + if (SSDIsTGeoNative()) + if (kIdet[lay-1]==kSSD) { + cpn0 = lad-1; + cpn1 = det-1; + cpn2 = 1; + } path.Form(kNames[lay-1].Data(), kPathbase.Data(),cpn0,cpn1,cpn2); @@ -2156,8 +2169,13 @@ void AliITSInitGeometry::DecodeDetectorv11Hybrid(Int_t &mod,Int_t layer,Int_t cp } } break; case 5: case 6:{ - lad = cpn0; - det = cpn1; + if (SSDIsTGeoNative()) { + lad = cpn0+1; + det = cpn1+1; + } else { + lad = cpn0; + det = cpn1; + } } break; default:{ } break; diff --git a/ITS/AliITSv11GeometrySDD.cxx b/ITS/AliITSv11GeometrySDD.cxx index 405fb064cfd..0462d2cd4d6 100755 --- a/ITS/AliITSv11GeometrySDD.cxx +++ b/ITS/AliITSv11GeometrySDD.cxx @@ -42,6 +42,7 @@ #include #include #include +#include #include "AliITSgeom.h" #include "AliITSgeomSDD.h" @@ -105,8 +106,8 @@ const Double_t AliITSv11GeometrySDD::fgkBTBHolewidth = 6 *fgkmm; const Double_t AliITSv11GeometrySDD::fgkBTBHoleRefX = 10 *fgkmm; const Double_t AliITSv11GeometrySDD::fgkBTBHoleRefY = 6.5 *fgkmm; -const Double_t AliITSv11GeometrySDD::fgkLay3Rmin = 145.*fgkmm; // not min! Rmin virtual tube -const Double_t AliITSv11GeometrySDD::fgkLay3Rmax = 205.*fgkmm; // not min! Rmax virtual tube +const Double_t AliITSv11GeometrySDD::fgkLay3Rmin = 145.*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkLay3Rmax = 200.*fgkmm; const Double_t AliITSv11GeometrySDD::fgkLay3Length = (524.+0.)*fgkmm; // ladder+supporting rings (length of the virtual tube) const Double_t AliITSv11GeometrySDD::fgkLay3LadderLength = 524.*fgkmm; const Double_t AliITSv11GeometrySDD::fgkLay3DetShortRadius = 146.0*fgkmm; @@ -116,8 +117,8 @@ const Int_t AliITSv11GeometrySDD::fgkLay3Ndet = 6; const Int_t AliITSv11GeometrySDD::fgkLay3Nladd = 14; const Double_t AliITSv11GeometrySDD::fgkLay3CoolPipeSuppH = 7.5*fgkmm; -const Double_t AliITSv11GeometrySDD::fgkLay4Rmin = 220.*fgkmm; // not min! Rmin virtual tube -const Double_t AliITSv11GeometrySDD::fgkLay4Rmax = 290.*fgkmm; // not min! Rmax virtual tube +const Double_t AliITSv11GeometrySDD::fgkLay4Rmin = 235.*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkLay4Rmax = 286.*fgkmm; const Double_t AliITSv11GeometrySDD::fgkLay4Length = (671.+0.)*fgkmm; // ladder+supporting rings (length of the virtual tube) const Double_t AliITSv11GeometrySDD::fgkLay4LadderLength = 671.*fgkmm; const Double_t AliITSv11GeometrySDD::fgkLay4DetShortRadius = 235.0*fgkmm; @@ -127,6 +128,10 @@ const Int_t AliITSv11GeometrySDD::fgkLay4Ndet = 8; const Int_t AliITSv11GeometrySDD::fgkLay4Nladd = 22; const Double_t AliITSv11GeometrySDD::fgkLay4CoolPipeSuppH = 7.5*fgkmm; +const Double_t AliITSv11GeometrySDD::fgkEndLaddCardsShortRadiusLay3 = fgkLay3DetShortRadius; +const Double_t AliITSv11GeometrySDD::fgkEndLaddCardsShortRadiusLay4 = fgkLay4DetShortRadius; +const Double_t AliITSv11GeometrySDD::fgkDistEndLaddCardsLadd = 0.*fgkmm; + //hybrid const Double_t AliITSv11GeometrySDD::fgkHybridAngle = 46; // approx !!! // Origine taken at the hybrid corner : @@ -256,11 +261,11 @@ const Double_t AliITSv11GeometrySDD::fgkEndLadPipeOuterDiam = 3.*fgkmm; //--- The al body of the cooling syst.of the heat exchanger : const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmZLay3 = 112.*fgkmm; // const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmZLay4 = 125.*fgkmm; // -const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmX = 4.75*fgkmm; // the arms of the U cooling tube +const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmX = 4.75*fgkmm; // the arms of the U cooling tube const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmY = 6.8*fgkmm; const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmBoxDY = 1.03*fgkmm; // shift in Y of the arms from the axis -const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmBoxDX = 0.125*fgkmm; // shift in X of the arms from the axis -const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmZpos = 8.9*fgkmm; // +const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmBoxDX = 0.125*fgkmm;// shift in X of the arms from the axis +const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmZpos = 8.9*fgkmm; // // LV card : const Double_t AliITSv11GeometrySDD::fgkLVcardX = 26.525*fgkmm; @@ -1093,8 +1098,8 @@ void AliITSv11GeometrySDD::ShowOnePiece(TGeoVolume *moth) { // moth->AddNode(lay3Detectors, 1, 0); - TGeoVolumeAssembly *endLadder = CreateEndLadder( 4 ); - moth->AddNode(endLadder, 1, 0); +// TGeoVolumeAssembly *endLadder = CreateEndLadder( 4 ); +// moth->AddNode(endLadder, 1, 0); // TGeoVolumeAssembly *highVCard = CreateHVCard( 4 ); // moth->AddNode(highVCard, 1, 0); @@ -1102,11 +1107,57 @@ void AliITSv11GeometrySDD::ShowOnePiece(TGeoVolume *moth) { // TGeoVolumeAssembly *supportRing = CreateSupportRing( 4 ); // moth->AddNode(supportRing, 1, 0); -// TGeoVolumeAssembly *endLadderCards = CreateEndLadderCards( 4 ); + TGeoVolume *endLadderCards = CreateEndLadderCardsV( 4 ); + moth->AddNode(endLadderCards, 1, 0); + +// TGeoVolume *endLadderCards = CreateEndLadderCards( 4 ); // moth->AddNode(endLadderCards, 1, 0); // TGeoVolumeAssembly *carlosCard = CreateCarlosCard( 4 ); // moth->AddNode(carlosCard, 1, 0); + + + + /* + //================================== + //--- test of flat cable curvature + //================================== + + double angle = 90; + AliITSv11GeomCableFlat cable("test", 3, 0.3); + cable.SetNLayers(1); + cable.SetNLayers(2); + cable.SetLayer(0, 0.2, coolerMediumSDD, 2); + cable.SetLayer(1, 0.1, coolerMediumSDD, 3); + cable.SetInitialNode(endLadderCards); + + Double_t p1[3], p2[3], vX[3] = {1,0,0},vY[3] = {0,5,0}; + + p1[0] = -3; + p1[1] = 1; + p1[2] = 10; + + p2[0] = 0; + p2[1] = 1; + p2[2] = 10; + cable.AddCheckPoint(endLadderCards, 0, p1, vX); + cable.AddCheckPoint(endLadderCards, 1, p2, vX); + cable.CreateAndInsertBoxCableSegment(1,angle); + + Double_t p3[3], p4[3]; + + p3[0] = 2; + p3[1] = 3; + p3[2] = 10; + cable.AddCheckPoint(endLadderCards, 2, p3, vY); + cable.CreateAndInsertCableCylSegment(2,angle); + + p4[0] = 2; + p4[1] = 6; + p4[2] = 10; + cable.AddCheckPoint(endLadderCards, 3, p4, vY); + cable.CreateAndInsertCableSegment(3,angle); + */ } @@ -1190,23 +1241,33 @@ void AliITSv11GeometrySDD::Layer3(TGeoVolume *moth) { /////////////////////////////////////////////////// } + /* //==================================== // Then the forward rapidity pieces // (cooling, Carlos, LV, HV ...) //==================================== - Double_t fgkForwardLay3Length = 200*fgkmm; // this has to be tune !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! - Double_t fgkForwardLay3Rmin = fgkLay3Rmin-10*fgkmm; - Double_t fgkForwardLay3Rmax = fgkLay3Rmax; + Double_t fgkForwardLay3Length = fgkEndLadPipeUlengthLay3+10*fgkmm; // this has to be tune + Double_t fgkForwardLay3Rmin = fgkLay3Rmin-7*fgkmm; + Double_t fgkForwardLay3Rmax = fgkLay3Rmax-5*fgkmm; TGeoVolumeAssembly* lay3EndLadder = CreateEndLadderCards(3); TGeoTube *virtualForward3Shape = new TGeoTube("virtualForward3Shape", fgkForwardLay3Rmin, fgkForwardLay3Rmax, fgkForwardLay3Length/2.); + +// TGeoPcon *virtualForward3Shape = new TGeoPcon("virtualForward3Shape",0,360,2); +// // virtualForward3Shape->DefineSection(Int_t snum, Double_t z, Double_t rmin, Double_t rmax); +// virtualForward3Shape->DefineSection(0, Double_t z, Double_t rmin, Double_t rmax); + + TGeoVolume *virtualForward3Pos = new TGeoVolume("ITSsddForward3Pos", virtualForward3Shape, airSDD); TGeoVolume *virtualForward3Neg = new TGeoVolume("ITSsddForward3Neg", virtualForward3Shape, airSDD); +// TGeoVolume *virtualForward3Neg = new TGeoVolumeAssembly("ITSsddForward3Neg"); +// TGeoVolume *virtualForward3Pos = new TGeoVolumeAssembly("ITSsddForward3Pos"); + TGeoTranslation *virtualForward3TrPos = new TGeoTranslation("virtualForward3TrPos",0,0, fgkLay3Length/2+fgkForwardLay3Length/2); TGeoTranslation *virtualForward3TrNeg = new TGeoTranslation("virtualForward3TrNeg",0,0, @@ -1230,22 +1291,167 @@ void AliITSv11GeometrySDD::Layer3(TGeoVolume *moth) { virtualForward3Neg->AddNode(lay3EndLadder, iLadd*2, ctEndLaddNeg); } + */ + + if(GetDebug(1)) { virtualLayer3->CheckOverlaps(0.01); - virtualForward3Pos->CheckOverlaps(0.01); - virtualForward3Neg->CheckOverlaps(0.01); + //virtualForward3Pos->CheckOverlaps(0.01); + //virtualForward3Neg->CheckOverlaps(0.01); } virtualLayer3->SetVisibility(kFALSE); - virtualForward3Pos->SetVisibility(kFALSE); - virtualForward3Neg->SetVisibility(kFALSE); + //virtualForward3Pos->SetVisibility(kFALSE); + //virtualForward3Neg->SetVisibility(kFALSE); + moth->AddNode(virtualLayer3, 1, 0); - moth->AddNode(virtualForward3Pos, 1, virtualForward3TrPos); - moth->AddNode(virtualForward3Neg, 1, virtualForward3TrNeg); + //moth->AddNode(virtualForward3Pos, 1, virtualForward3TrPos); + //moth->AddNode(virtualForward3Neg, 1, virtualForward3TrNeg); } +// //________________________________________________________________________ +// void AliITSv11GeometrySDD::ForwardLayer3(TGeoVolume *moth) { +// // +// // Insert the forward pieces of layer 3 in the mother volume. +// // (cooling, Carlos, LV, HV ...) +// // + +// if (! moth) { +// printf("Error::AliITSv11GeometrySDD: Can't insert layer3, mother is null!\n"); +// return; +// }; + +// TGeoMedium *airSDD = GetMedium("SDD AIR$"); + +// if (! fSDDsensor3) CreateBasicObjects(); + +// Double_t dPhi = 360./fgkLay3Nladd; +// Double_t detectorsThick = fgkLadWaferSep + 2*fgkWaferThickness; +// Int_t iLaddMin = 0; +// Int_t iLaddMax = fgkLay3Nladd; +// if ((fAddOnlyLadder3min>=0)&&(fAddOnlyLadder3maxDefineSection(Int_t snum, Double_t z, Double_t rmin, Double_t rmax); +// // virtualForward3Shape->DefineSection(0, Double_t z, Double_t rmin, Double_t rmax); + + +// TGeoVolume *virtualForward3Pos = new TGeoVolume("ITSsddForward3Pos", +// virtualForward3Shape, airSDD); +// TGeoVolume *virtualForward3Neg = new TGeoVolume("ITSsddForward3Neg", +// virtualForward3Shape, airSDD); +// // TGeoVolume *virtualForward3Neg = new TGeoVolumeAssembly("ITSsddForward3Neg"); +// // TGeoVolume *virtualForward3Pos = new TGeoVolumeAssembly("ITSsddForward3Pos"); + +// TGeoTranslation *virtualForward3TrPos = new TGeoTranslation("virtualForward3TrPos",0,0, +// fgkLay3Length/2+fgkForwardLay3Length/2); +// TGeoTranslation *virtualForward3TrNeg = new TGeoTranslation("virtualForward3TrNeg",0,0, +// -fgkLay3Length/2-fgkForwardLay3Length/2); + +// for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) { + +// Double_t ladderPhi = -3*dPhi+iLadd*dPhi; +// Double_t minRadiusDetBox = fgkLay3DetShortRadius; +// if (iLadd%2 != 0) minRadiusDetBox = fgkLay3DetLongRadius; +// minRadiusDetBox += detectorsThick/2; + +// sprintf(rotName, "ITSsddLay3EndLadd%i",iLadd); + +// TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, minRadiusDetBox-0.1, +// -fgkForwardLay3Length/2, ladderPhi, kTRUE); +// TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, minRadiusDetBox-0.1, +// fgkForwardLay3Length/2, ladderPhi, kFALSE); + +// virtualForward3Pos->AddNode(lay3EndLadder, iLadd*2, ctEndLaddPos); +// virtualForward3Neg->AddNode(lay3EndLadder, iLadd*2, ctEndLaddNeg); +// } + +// if(GetDebug(1)) { +// virtualForward3Pos->CheckOverlaps(0.01); +// virtualForward3Neg->CheckOverlaps(0.01); +// } + +// virtualForward3Pos->SetVisibility(kFALSE); +// virtualForward3Neg->SetVisibility(kFALSE); + +// moth->AddNode(virtualForward3Pos, 1, virtualForward3TrPos); +// moth->AddNode(virtualForward3Neg, 1, virtualForward3TrNeg); +// } + + + +//________________________________________________________________________ +void AliITSv11GeometrySDD::ForwardLayer3(TGeoVolume *moth) { + // + // Insert the end-ladder of layer 3 in the mother volume. + // (cooling, Carlos, LV, HV ...) + // + + if (! moth) { + printf("Error::AliITSv11GeometrySDD: Can't insert layer3, mother is null!\n"); + return; + }; + + if (! fSDDsensor3) CreateBasicObjects(); + + Int_t iLaddMin = 0; + Int_t iLaddMax = fgkLay3Nladd; + if ((fAddOnlyLadder3min>=0)&&(fAddOnlyLadder3maxAddNode(lay3EndLadder, iLadd*2, ctEndLaddPos); + virtualForward3Neg->AddNode(lay3EndLadder, iLadd*2, ctEndLaddNeg); + } + + if(GetDebug(1)) { + virtualForward3Pos->CheckOverlaps(0.01); + virtualForward3Neg->CheckOverlaps(0.01); + } + + moth->AddNode(virtualForward3Pos, 1); + moth->AddNode(virtualForward3Neg, 1); +} + //________________________________________________________________________ void AliITSv11GeometrySDD::Layer4(TGeoVolume *moth) { // @@ -1311,14 +1517,15 @@ void AliITSv11GeometrySDD::Layer4(TGeoVolume *moth) { /////////////////////////////////////////////////// } + /* //==================================== // Then the pieces at forward rapidity // (cooling, Carlos, LV, HV ...) //==================================== - Double_t fgkForwardLay4Length = 200*fgkmm; // this has to be tuned !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! - Double_t fgkForwardLay4Rmin = fgkLay4Rmin-10*fgkmm; - Double_t fgkForwardLay4Rmax = fgkLay4Rmax; + Double_t fgkForwardLay4Length = fgkEndLadPipeUlengthLay4+10*fgkmm; // this has to be tuned + Double_t fgkForwardLay4Rmin = fgkLay4Rmin-9*fgkmm; + Double_t fgkForwardLay4Rmax = fgkLay4Rmax-5*fgkmm; TGeoVolumeAssembly* lay4EndLadder = CreateEndLadderCards(4); TGeoTube *virtualForward4Shape = new TGeoTube("virtualForward3Shape", @@ -1328,6 +1535,9 @@ void AliITSv11GeometrySDD::Layer4(TGeoVolume *moth) { virtualForward4Shape, airSDD); TGeoVolume *virtualForward4Neg = new TGeoVolume("ITSsddForward4Neg", virtualForward4Shape, airSDD); +// TGeoVolume *virtualForward4Pos = new TGeoVolumeAssembly("ITSsddForward4Pos"); +// TGeoVolume *virtualForward4Neg = new TGeoVolumeAssembly("ITSsddForward4Neg"); + TGeoTranslation *virtualForward4TrPos = new TGeoTranslation("virtualForward4TrPos",0,0, fgkLay4Length/2+fgkForwardLay4Length/2); TGeoTranslation *virtualForward4TrNeg = new TGeoTranslation("virtualForward4TrNeg",0,0, @@ -1350,16 +1560,146 @@ void AliITSv11GeometrySDD::Layer4(TGeoVolume *moth) { virtualForward4Pos->AddNode(lay4EndLadder, iLadd*2, ctEndLaddPos); virtualForward4Neg->AddNode(lay4EndLadder, iLadd*2+1, ctEndLaddNeg); } + */ if(GetDebug(1)) virtualLayer4->CheckOverlaps(0.01); virtualLayer4->SetVisibility(kFALSE); - virtualForward4Pos->SetVisibility(kFALSE); - virtualForward4Neg->SetVisibility(kFALSE); + //virtualForward4Pos->SetVisibility(kFALSE); + //virtualForward4Neg->SetVisibility(kFALSE); moth->AddNode(virtualLayer4,1,0); - moth->AddNode(virtualForward4Pos, 1, virtualForward4TrPos); - moth->AddNode(virtualForward4Neg, 1, virtualForward4TrNeg); + //moth->AddNode(virtualForward4Pos, 1, virtualForward4TrPos); + //moth->AddNode(virtualForward4Neg, 1, virtualForward4TrNeg); +} + + +// //________________________________________________________________________ +// void AliITSv11GeometrySDD::ForwardLayer4(TGeoVolume *moth) { +// // +// // Insert the layer 4 in the mother volume. This is a virtual volume +// // containing ladders of layer 4 and the supporting rings +// // (cooling, Carlos, LV, HV ...) +// // + +// if (! moth) { +// printf("Error::AliITSv11GeometrySDD: Can't insert layer4, mother is null!\n"); +// return; +// }; + +// TGeoMedium *airSDD = GetMedium("SDD AIR$"); + +// if (! fSDDsensor3) CreateBasicObjects(); + +// Double_t dPhi = 360./fgkLay4Nladd; +// Double_t detBoxThickness = fgkLadWaferSep + 2*fgkWaferThickness; + +// // placing virtual ladder and detectors volumes following ladder +// // ordering convention +// char rotName[20]; +// Int_t iLaddMin = 0; +// Int_t iLaddMax = fgkLay4Nladd; +// if ((fAddOnlyLadder4min >= 0)&&(fAddOnlyLadder4max < fgkLay4Nladd)) { +// iLaddMin = fAddOnlyLadder4min; +// iLaddMax = fAddOnlyLadder4max+1; +// } + +// //================= +// Double_t fgkForwardLay4Length = fgkEndLadPipeUlengthLay4+10*fgkmm; // this has to be tuned +// Double_t fgkForwardLay4Rmin = fgkLay4Rmin-9*fgkmm; +// Double_t fgkForwardLay4Rmax = fgkLay4Rmax-5*fgkmm; + +// TGeoVolumeAssembly* lay4EndLadder = CreateEndLadderCards(4); +// TGeoTube *virtualForward4Shape = new TGeoTube("virtualForward3Shape", +// fgkForwardLay4Rmin, fgkForwardLay4Rmax, +// fgkForwardLay4Length/2.); +// TGeoVolume *virtualForward4Pos = new TGeoVolume("ITSsddForward4Pos", +// virtualForward4Shape, airSDD); +// TGeoVolume *virtualForward4Neg = new TGeoVolume("ITSsddForward4Neg", +// virtualForward4Shape, airSDD); +// // TGeoVolume *virtualForward4Pos = new TGeoVolumeAssembly("ITSsddForward4Pos"); +// // TGeoVolume *virtualForward4Neg = new TGeoVolumeAssembly("ITSsddForward4Neg"); + +// TGeoTranslation *virtualForward4TrPos = new TGeoTranslation("virtualForward4TrPos",0,0, +// fgkLay4Length/2+fgkForwardLay4Length/2); +// TGeoTranslation *virtualForward4TrNeg = new TGeoTranslation("virtualForward4TrNeg",0,0, +// -fgkLay4Length/2-fgkForwardLay4Length/2); + +// for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) { + +// Double_t ladderPhi = -5*dPhi + iLadd*dPhi; +// Double_t minRadiusDetBox = fgkLay4DetShortRadius; +// if (iLadd%2 != 0) +// minRadiusDetBox = fgkLay4DetLongRadius; +// minRadiusDetBox += detBoxThickness/2; + +// sprintf(rotName, "ITSsddLay4EndLadd%i",iLadd); + +// TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, minRadiusDetBox-0.1, +// -fgkForwardLay4Length/2, ladderPhi, kTRUE); +// TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, minRadiusDetBox-0.1, +// fgkForwardLay4Length/2, ladderPhi, kFALSE); +// virtualForward4Pos->AddNode(lay4EndLadder, iLadd*2, ctEndLaddPos); +// virtualForward4Neg->AddNode(lay4EndLadder, iLadd*2+1, ctEndLaddNeg); +// } + +// virtualForward4Pos->SetVisibility(kFALSE); +// virtualForward4Neg->SetVisibility(kFALSE); + +// moth->AddNode(virtualForward4Pos, 1, virtualForward4TrPos); +// moth->AddNode(virtualForward4Neg, 1, virtualForward4TrNeg); +// } + + +//________________________________________________________________________ +void AliITSv11GeometrySDD::ForwardLayer4(TGeoVolume *moth) { + // + // Insert the end-ladder of layer 4 in the mother volume. + // (cooling, Carlos, LV, HV ...) + // + + if (! moth) { + printf("Error::AliITSv11GeometrySDD: Can't insert layer4, mother is null!\n"); + return; + }; + + if (! fSDDsensor3) CreateBasicObjects(); + + // placing virtual ladder and detectors volumes following ladder + // ordering convention + Int_t iLaddMin = 0; + Int_t iLaddMax = fgkLay4Nladd; + if ((fAddOnlyLadder4min >= 0)&&(fAddOnlyLadder4max < fgkLay4Nladd)) { + iLaddMin = fAddOnlyLadder4min; + iLaddMax = fAddOnlyLadder4max+1; + } + + TGeoVolume *virtualForward4Pos = new TGeoVolumeAssembly("ITSsddForward4Pos"); + TGeoVolume *virtualForward4Neg = new TGeoVolumeAssembly("ITSsddForward4Neg"); + + char rotName[30]; + Double_t dPhi = 360./fgkLay4Nladd; + TGeoVolume* lay4EndLadder = CreateEndLadderCardsV(4); + + for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) { + + Double_t ladderPhi = -5*dPhi + iLadd*dPhi; + Double_t dR = 0; + if (iLadd%2 != 0) + dR = fgkLay4DetLongRadius-fgkLay4DetShortRadius; + + sprintf(rotName, "ITSsddLay4EndLadd%i",iLadd); + + TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, dR, + fgkLay4Length/2, ladderPhi, kTRUE); + TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, dR, + -fgkLay4Length/2, ladderPhi, kFALSE); + virtualForward4Pos->AddNode(lay4EndLadder, iLadd*2, ctEndLaddPos); + virtualForward4Neg->AddNode(lay4EndLadder, iLadd*2, ctEndLaddNeg); + } + + moth->AddNode(virtualForward4Pos, 1); + moth->AddNode(virtualForward4Neg, 1); } @@ -1449,7 +1789,7 @@ TGeoVolumeAssembly *AliITSv11GeometrySDD::CreateLadder(Int_t iLay) { rotation = 90-fgkHybridAngle; digitCableA[iSegment].CreateAndInsertCableSegment(iPt, rotation); } else - digitCableA[iSegment].CreateAndInsertBoxCableSegment(iPt); + digitCableA[iSegment].CreateAndInsertCableSegment(iPt); }; @@ -1459,7 +1799,7 @@ TGeoVolumeAssembly *AliITSv11GeometrySDD::CreateLadder(Int_t iLay) { rotation = fgkHybridAngle-90; digitCableB[iSegment].CreateAndInsertCableSegment(iPt, rotation); } else - digitCableB[iSegment].CreateAndInsertBoxCableSegment(iPt); + digitCableB[iSegment].CreateAndInsertCableSegment(iPt); }; }; @@ -1996,7 +2336,7 @@ TGeoVolume* AliITSv11GeometrySDD::CreateLadderSegment(Int_t iLay, Int_t iSeg) { // Return a TGeoVolume* containing a segment of a ladder. // - TGeoMedium *phynoxSDD = GetMedium("inox/alum$"); // phynoxSDD To code ??? !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + TGeoMedium *phynoxSDD = GetMedium("inox/alum$"); // phynoxSDD To code ??? !!! TGeoMedium *coolerMediumSDD = GetMedium("WATER$"); TGeoMedium *airSDD = GetMedium("SDD AIR$"); @@ -3826,8 +4166,8 @@ TGeoVolumeAssembly* AliITSv11GeometrySDD::CreateEndLadderCards(Int_t iLay) { // and their cooling system // - TGeoMedium *alCu12SDD = GetMedium("AL$"); // ITSsddAlCu12 : to code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! - TGeoMedium *phynoxSDD = GetMedium("AL$"); // phynoxSDD To code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + TGeoMedium *alCu12SDD = GetMedium("AL$"); // ITSsddAlCu12 : to code !!!!!!!!!!!!!! + TGeoMedium *phynoxSDD = GetMedium("AL$"); // phynoxSDD To code !!!!!!!!!!!!!!!!!!! TGeoMedium *coolerMediumSDD = GetMedium("WATER$"); TGeoVolumeAssembly *endLadderCards = new TGeoVolumeAssembly("endLadderCards"); @@ -4013,50 +4353,234 @@ TGeoVolumeAssembly* AliITSv11GeometrySDD::CreateEndLadderCards(Int_t iLay) { endLadderCards->AddNode(assemblySupCarlos, iCard, carlosPos); } + return endLadderCards; +} - +//________________________________________________________________________ +TGeoVolume* AliITSv11GeometrySDD::CreateEndLadderCardsV(Int_t iLay) { +// +// return an Pcon containing the LV, HV and Carlos cards of one ladder +// and their cooling system +// + + TGeoMedium *alCu12SDD = GetMedium("AL$"); // ITSsddAlCu12 : to code !!!!!!!!!!!!!! + TGeoMedium *phynoxSDD = GetMedium("AL$"); // phynoxSDD To code !!!!!!!!!!!!!!!!!!! + TGeoMedium *coolerMediumSDD = GetMedium("WATER$"); + TGeoMedium *airSDD = GetMedium("SDD AIR$"); + + Double_t endLadPipeUlength = fgkEndLadPipeUlengthLay3; + Double_t endLadPipeArmZ = fgkEndLadPipeArmZLay3; + Int_t nCards = 3; + Double_t rREF = fgkEndLaddCardsShortRadiusLay3; + // reference radius corresponding to local y=0 + + if (iLay==4) { + endLadPipeUlength = fgkEndLadPipeUlengthLay4; + endLadPipeArmZ = fgkEndLadPipeArmZLay4; + nCards = 4; + rREF = fgkEndLaddCardsShortRadiusLay4; + } + + Double_t cardLVxShift = (fgkEndLadPipeUwidth/2-fgkEndLadPipeArmX/2 + +fgkEndLadPipeArmBoxDX); + Double_t cardLVyShift = (-fgkLVcoolPosY-fgkLVcoolY1+fgkLVcoolY3 + +fgkEndLadPipeArmY/2+fgkEndLadPipeArmBoxDY); + + Double_t rMin = rREF + cardLVyShift; + // (The LV card is defining rMin because it is the lower object) - /* - //================================== - //--- test of flat cable curvature //================================== + //--- The Pcon container + + // minimum angle of the Pcon : + Double_t tanDPhi = ((fgkEndLadPipeUwidth/2+fgkEndLadPipeArmX/2) / + (rREF-fgkEndLadPipeArmY/2) ); + Double_t dphi = 2*TMath::ATan(tanDPhi)*TMath::RadToDeg(); + Double_t phi0 = 90-dphi/2; + Double_t coolUzPos = fgkEndLadPipeOuterDiam/2 + fgkDistEndLaddCardsLadd; // it is the z coord of the axis + // of the U colling pipe in its center + Double_t zMax = endLadPipeUlength+coolUzPos; + Double_t rMax = rMin + fgkLVcardY; + rMax = TMath::Sqrt(rMax*rMax + cardLVxShift*cardLVxShift); + + TGeoPcon *containerShape = new TGeoPcon("EndLadderCcontainerShape", phi0, dphi, 6); + //DefineSection(Int_t snum, Double_t z, Double_t rmin, Double_t rmax); + containerShape->DefineSection(0, fgkDistEndLaddCardsLadd, rMin, rMax); + containerShape->DefineSection(1, endLadPipeArmZ+2*fgkEndLadPipeRadius, rMin, rMax); + containerShape->DefineSection(2, endLadPipeArmZ+2*fgkEndLadPipeRadius, rREF-1.*fgkmm, rMax); + containerShape->DefineSection(3, zMax, rREF-1.*fgkmm, rMax); + // the following is dirty but works ... + containerShape->DefineSection(4, zMax, rREF+fgkCarlosCardZ1/2, rMax); + containerShape->DefineSection(5, zMax+6.*fgkmm, rREF+fgkCarlosCardZ1/2, rMax); + + TGeoVolume *endLadderCards = new TGeoVolume("endLadderCards",containerShape,airSDD); + endLadderCards->SetVisibility(kFALSE); - double angle = 90; - AliITSv11GeomCableFlat cable("test", 3, 0.3); - cable.SetNLayers(1); - cable.SetNLayers(2); - cable.SetLayer(0, 0.2, coolerMediumSDD, 2); - cable.SetLayer(1, 0.1, coolerMediumSDD, 3); - cable.SetInitialNode(endLadderCards); + //=********************************* + //--- The rounded pipe for the end ladder card cooling - Double_t p1[3], p2[3], vX[3] = {1,0,0},vY[3] = {0,5,0}; + AliITSv11GeomCableRound endLadderPipe("endLadderPipe", fgkEndLadPipeOuterDiam/2); + endLadderPipe.SetNLayers(2); + endLadderPipe.SetLayer(0, fgkEndLadPipeInnerDiam/2, coolerMediumSDD, 4); + endLadderPipe.SetLayer(1, (fgkEndLadPipeOuterDiam-fgkEndLadPipeInnerDiam)/2, phynoxSDD, fColorPhynox); - p1[0] = -3; - p1[1] = 1; - p1[2] = 10; + Double_t coordA[3] = { fgkEndLadPipeUwidth/2, rREF, endLadPipeUlength+coolUzPos}; + Double_t vectA[3] = {0,0,1}; - p2[0] = 0; - p2[1] = 1; - p2[2] = 10; - cable.AddCheckPoint(endLadderCards, 0, p1, vX); - cable.AddCheckPoint(endLadderCards, 1, p2, vX); - cable.CreateAndInsertBoxCableSegment(1,angle); + Double_t coordB[3] = { fgkEndLadPipeUwidth/2,rREF, fgkEndLadPipeRadius+coolUzPos}; + Double_t vectB[3] = {0,0,1}; - Double_t p3[3], p4[3]; + Double_t coordC[3] = { fgkEndLadPipeUwidth/2-fgkEndLadPipeRadius, rREF, coolUzPos}; + Double_t vectC[3] = {1,0,0}; - p3[0] = 2; - p3[1] = 3; - p3[2] = 10; - cable.AddCheckPoint(endLadderCards, 2, p3, vY); - cable.CreateAndInsertCableCylSegment(2,angle); + Double_t coordD[3] = {-fgkEndLadPipeUwidth/2+fgkEndLadPipeRadius, rREF, coolUzPos}; + Double_t vectD[3] = {-1,0,0}; - p4[0] = 2; - p4[1] = 6; - p4[2] = 10; - cable.AddCheckPoint(endLadderCards, 3, p4, vY); - cable.CreateAndInsertCableSegment(3,angle); - */ + Double_t coordE[3] = {-fgkEndLadPipeUwidth/2, rREF, fgkEndLadPipeRadius+coolUzPos}; + Double_t vectE[3] = {0,0,-1}; + + Double_t coordF[3] = {-fgkEndLadPipeUwidth/2,rREF, endLadPipeUlength+coolUzPos}; + Double_t vectF[3] = {0,0,-1}; + + endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 0, coordA, vectA); + endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 1, coordB, vectB); + endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 2, coordC, vectC); + endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 3, coordD, vectD); + endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 4, coordE, vectE); + endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 5, coordF, vectF); + + endLadderPipe.SetInitialNode((TGeoVolume *) endLadderCards); //Set the root node + //endLadderPipe.CreateAndInsertCableSegment( 1); + endLadderPipe.CreateAndInsertTubeSegment( 1); + //endLadderPipe.CreateAndInsertCableSegment( 2); + endLadderPipe.CreateAndInsertTorusSegment( 2); + //endLadderPipe.CreateAndInsertCableSegment( 3); + endLadderPipe.CreateAndInsertTubeSegment( 3); + //endLadderPipe.CreateAndInsertCableSegment( 4); + endLadderPipe.CreateAndInsertTorusSegment( 4); + //endLadderPipe.CreateAndInsertCableSegment( 5); + endLadderPipe.CreateAndInsertTubeSegment( 5); + + TGeoBBox *endLadPipeArmBox = new TGeoBBox("endLadPipeArmBox",fgkEndLadPipeArmX/2, + fgkEndLadPipeArmY/2, endLadPipeArmZ/2); + TGeoTube *endLadPipeArmTube = new TGeoTube("endLadPipeArmTube", 0, + fgkEndLadPipeOuterDiam/2, endLadPipeArmZ/2); + + TGeoTranslation *endLadPipeArmBoxDY1 = new TGeoTranslation("endLadPipeArmBoxDY1", + - fgkEndLadPipeArmBoxDX, + fgkEndLadPipeArmBoxDY,0); + TGeoTranslation *endLadPipeArmBoxDY2 = new TGeoTranslation("endLadPipeArmBoxDY2", + fgkEndLadPipeArmBoxDX, + fgkEndLadPipeArmBoxDY,0); + endLadPipeArmBoxDY1->RegisterYourself(); + endLadPipeArmBoxDY2->RegisterYourself(); + + if(GetDebug(3)) { // Remove compiler warning. + endLadPipeArmBox->InspectShape(); + endLadPipeArmTube->InspectShape(); + } + + TGeoCompositeShape *endLadPipeArm1 = new TGeoCompositeShape("ITSsddEndLadPipeArm1", + "endLadPipeArmBox:endLadPipeArmBoxDY1" + "- endLadPipeArmTube"); + TGeoCompositeShape *endLadPipeArm2 = new TGeoCompositeShape("ITSsddEndLadPipeArm2", + "endLadPipeArmBox:endLadPipeArmBoxDY2" + "- endLadPipeArmTube"); + + TGeoVolume *vEndLadPipeArm1 = new TGeoVolume("ITSsddVolEndLadPipeArm1", + endLadPipeArm1, alCu12SDD); + TGeoVolume *vEndLadPipeArm2 = new TGeoVolume("ITSsddVolEndLadPipeArm2", + endLadPipeArm2, alCu12SDD); + vEndLadPipeArm1->SetLineColor(2); + vEndLadPipeArm2->SetLineColor(2); + + Double_t armZ = (coolUzPos-fgkEndLadPipeOuterDiam/2+endLadPipeArmZ/2 + +fgkEndLadPipeArmZpos); + + TGeoTranslation *trEndLadPipeArm1 = new TGeoTranslation("trEndLadPipeArm1", + -fgkEndLadPipeUwidth/2,rREF,armZ); + TGeoTranslation *trEndLadPipeArm2 = new TGeoTranslation("trEndLadPipeArm2", + fgkEndLadPipeUwidth/2,rREF,armZ); + + endLadderCards->AddNode(vEndLadPipeArm1, 1, trEndLadPipeArm1); + endLadderCards->AddNode(vEndLadPipeArm2, 1, trEndLadPipeArm2); + + //=********************************* + //--- LV cards + TGeoVolumeAssembly *cardLVassemblyR = fCardLVR; + TGeoVolumeAssembly *cardLVassemblyL = fCardLVL; + + Double_t spaceBetweenCards = 0.2*fgkmm; + + + Double_t alLVcoolZ3 = (fgkLVcardCuZ+fgkLVcardZ+2.*(fgkLVChip0SiZ+fgkLVChip0Z) + +fgkLVcoolZ1*2.); + + Double_t firstLVCardZ = fgkEndLadPipeArmZpos-fgkEndLadPipeOuterDiam/2.+alLVcoolZ3/2 + +coolUzPos+1.25*fgkmm; + // Position in z of the first LVB with respect to the start of the cooling + // rectangular arm, coming (from inside of the ladder) + // The cards are added one after the other + + for (Int_t iCard=0; iCardAddNode(cardLVassemblyR, iCard+1, trCardLVassemblyR); + endLadderCards->AddNode(cardLVassemblyL, iCard+1, trCardLVassemblyL); + } + + //=********************************* + //--- HV cards + TGeoVolumeAssembly *cardHV = fCardHV; + + Double_t coolHVdy = (fgkHVCardCoolDY + fgkHVCardCool3Y + + fgkEndLadPipeArmY/2 + fgkEndLadPipeArmBoxDY); + // shift of the HV card in local y w.r.t the local y=0 (center of cooling tube) + + Double_t coolHVCenterShift = (fgkHVCardCool3Z/2-fgkHVCardCool2Z + -(fgkHVCardCeramZ)/2); + + for (Int_t iCard=0; iCardAddNode(cardHV, iCard+1, trCardHV); + } + + //=********************************* + //--- Carlos card + + TGeoVolumeAssembly *assemblySupCarlos = fCardCarlos; +// TGeoRotation *carlosSupRot1 = new TGeoRotation("carlosSuppAngle", +// 0, -fgkCarlosSuppAngle, 0); + + Double_t spaceBetweenCarlsoCards = 0.1*fgkmm; + Double_t firstCarlosCardZ = (firstLVCardZ - alLVcoolZ3/2 + alLVcoolZ3*4 + + fgkHVCardCool3Z*4 + spaceBetweenCards*7 + 2*fgkmm); + // position in z of the first Carlos board, coming from inside of the ladder + + Double_t coolCarlosDy = (fgkCarlosSuppY3/2 + fgkEndLadPipeArmY/2 + + fgkEndLadPipeArmBoxDY); + + for (Int_t iCard=0; iCardAddNode(assemblySupCarlos, iCard, carlosPos); + } return endLadderCards; } diff --git a/ITS/AliITSv11GeometrySDD.h b/ITS/AliITSv11GeometrySDD.h index 8df9f90d84a..6066e084dc3 100755 --- a/ITS/AliITSv11GeometrySDD.h +++ b/ITS/AliITSv11GeometrySDD.h @@ -46,6 +46,8 @@ class AliITSv11GeometrySDD : public AliITSv11Geometry { // Main functions virtual void Layer3(TGeoVolume *moth); virtual void Layer4(TGeoVolume *moth); + virtual void ForwardLayer3(TGeoVolume *moth); + virtual void ForwardLayer4(TGeoVolume *moth); virtual Int_t ExportSensorGeometry(AliITSgeom *geom, Int_t iLaySDD, Int_t startMod); virtual Int_t GetCurrentLayLaddDet(Int_t &lay, Int_t &ladd, Int_t&det) const; @@ -78,6 +80,7 @@ class AliITSv11GeometrySDD : public AliITSv11Geometry { virtual TGeoVolume* CreateLadderSegment(Int_t iLay, Int_t iSeg); virtual TGeoVolumeAssembly* CreateEndLadder(Int_t iLay); virtual TGeoVolumeAssembly* CreateEndLadderCards(Int_t iLay); + virtual TGeoVolume* CreateEndLadderCardsV(Int_t iLay); virtual TGeoVolumeAssembly* CreateSupportRing(Int_t iLay); // Create some basic objects : @@ -187,6 +190,10 @@ class AliITSv11GeometrySDD : public AliITSv11Geometry { static const Double_t fgkLay4LaddTopCornerEnd; // Ends of ladder 3 static const Double_t fgkLay4ZPlusEndLength; // === + static const Double_t fgkEndLaddCardsShortRadiusLay3; // ref radius of end ladder cards + static const Double_t fgkEndLaddCardsShortRadiusLay4; // ref radius of end ladder cards + static const Double_t fgkDistEndLaddCardsLadd; // dist. between U cooling tube and ladder + static const Double_t fgkSegmentLength; // length of 1 ladder seg. static const Double_t fgkLadderWidth; // carbon fiber structure static const Double_t fgkLadderHeight; // including bottom beam diff --git a/ITS/AliITSv11GeometrySSD.cxx b/ITS/AliITSv11GeometrySSD.cxx index 5ee182aea25..092447a18a5 100644 --- a/ITS/AliITSv11GeometrySSD.cxx +++ b/ITS/AliITSv11GeometrySSD.cxx @@ -30,8 +30,14 @@ #include "TGeoCompositeShape.h" #include "TGeoTube.h" #include "TGeoBBox.h" +#include "TGeoXtru.h" #include "AliITSv11GeometrySSD.h" ///////////////////////////////////////////////////////////////////////////////// +// Names of the Sensitive Volumes of Layer 5 and Layer 6 +///////////////////////////////////////////////////////////////////////////////// +const char* AliITSv11GeometrySSD::fgSDDsensitiveVolName5 = "ITSsddSensitivL5"; +const char* AliITSv11GeometrySSD::fgSDDsensitiveVolName6 = "ITSsddSensitivL6"; +///////////////////////////////////////////////////////////////////////////////// //Parameters for SSD Geometry ///////////////////////////////////////////////////////////////////////////////// // Layer5 (lengths are in mm and angles in degrees) @@ -59,42 +65,45 @@ const Double_t AliITSv11GeometrySSD::fgkSSDChipLength = 11.100*fgkmm const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth = 3.850*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight = 0.180*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength = 1.000*fgkmm; -const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength = fgkSSDChipLength; -const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth = fgkSSDChipWidth; +const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength = fgkSSDChipLength; +const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth = fgkSSDChipWidth; const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight = 0.030*fgkmm; ///////////////////////////////////////////////////////////////////////////////// // Stiffener (lengths are in mm and angles in degrees) ///////////////////////////////////////////////////////////////////////////////// const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength = 73.000*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth = 6.500*fgkmm; +//const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 3.315; const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 0.315*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist = 2.500*fgkmm; -const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length = 1.600*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length = 1.600*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width = 0.870*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height = 0.800*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length = 4.600*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width = 3.400*fgkmm; -const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height = 1.400*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height = 0.700*fgkmm; // multiplied by 0.5 const Double_t AliITSv11GeometrySSD::fgkSSDWireLength = 30.000*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius = 0.185*fgkmm; -const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2] = {44.32*fgkmm, - 0.33*fgkmm}; -const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation = 0.44*fgkmm; -const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength = 2.16*fgkmm; -const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth = 3.60*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2] = + {44.32*fgkmm, 0.33*fgkmm}; +const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation = 0.44*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength = 2.16*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth = 3.60*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight = - 0.25*fgkSSDStiffenerHeight; + 0.25*fgkSSDStiffenerHeight; +const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight = 0.030*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight = 0.002*fgkmm; ///////////////////////////////////////////////////////////////////////////////// // Cooling Block (lengths are in mm and angles in degrees) ///////////////////////////////////////////////////////////////////////////////// const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength = 3.000*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth = 4.000*fgkmm; -const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] = - {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm}; +const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] = + {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] = - {1.000*fgkmm, 0.120*fgkmm}; + {1.000*fgkmm, 0.120*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] = - {1.900*fgkmm, 0.400*fgkmm}; + {1.900*fgkmm, 0.400*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter = 1.500*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight = @@ -103,44 +112,44 @@ const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight = // SSD Sensor (lengths are in mm and angles in degrees) ///////////////////////////////////////////////////////////////////////////////// const char* AliITSv11GeometrySSD::fgkSSDSensitiveVolName = - "SSDSensorSensitiveVol"; + "SSDSensorSensitiveVol"; const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength = 42.000*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight = 0.300*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth = 75.000*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap = fgkSSDSensorLength-39.1*fgkmm; -const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength = 1.*fgkmm; -const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth = 1.*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength = 1.*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth = 1.*fgkmm; ///////////////////////////////////////////////////////////////////////////////// // Flex (lengths are in mm and angles in degrees) ///////////////////////////////////////////////////////////////////////////////// const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength = 106.000*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4] = - {0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength - +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength), - 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength - +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)-4.000*fgkmm, - 9.500*fgkmm, 10.000*fgkmm}; + {0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength + + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength), + 0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength + + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength) + - 4.000*fgkmm, 9.500*fgkmm, 10.000*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2] = - { 9.340*fgkmm, 5.380*fgkmm}; + { 9.340*fgkmm, 5.380*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2] = - { 0.030*fgkmm, 0.020*fgkmm}; + { 0.030*fgkmm, 0.020*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle = 30.000; const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength = 1.430*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth = 3.000*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] = - {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm}; + {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm}; const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] = - {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm}; + {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm}; ///////////////////////////////////////////////////////////////////////////////// // SSD Ladder Cable (lengths are in mm and angles in degrees) ///////////////////////////////////////////////////////////////////////////////// -const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth = 23.5*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth = 23.5*fgkmm; ///////////////////////////////////////////////////////////////////////////////// // SSD Module (lengths are in mm and angles in degrees) ///////////////////////////////////////////////////////////////////////////////// const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2] = - { 1.000*fgkmm, 3.900*fgkmm}; + { 1.000*fgkmm, 3.900*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance = 45.600*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor = @@ -148,76 +157,87 @@ const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor = ///////////////////////////////////////////////////////////////////////////////// // Sensor Support (lengths are in mm and angles in degrees) ///////////////////////////////////////////////////////////////////////////////// -const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength = - 5.800*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength = + 5.800*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth = - 2.000*fgkmm; + 2.000*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] = - { 4.620*fgkmm, 5.180*fgkmm}; -const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] = - { 0.450*fgkmm, 0.450*fgkmm}; -const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition = - 0.5*(fgkSSDModuleSensorSupportDistance - + fgkSSDSensorSideSupportThickness[0]) - - fgkSSDSensorSideSupportLength; + { 4.620*fgkmm, 5.180*fgkmm}; +const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] = + { 0.450*fgkmm, 0.450*fgkmm}; +const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition + = 0.5 * (fgkSSDModuleSensorSupportDistance + + fgkSSDSensorSideSupportThickness[0]) + - fgkSSDSensorSideSupportLength; const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength = - 5.250*fgkmm; + 5.250*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth = - 1.680*fgkmm; -const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2] = - {fgkSSDSensorSideSupportHeight[0]+fgkSSDSensorSideSupportThickness[0], - fgkSSDSensorSideSupportHeight[1]+fgkSSDSensorSideSupportThickness[1]}; -const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2] = - {fgkSSDSensorSideSupportThickness[0],fgkSSDSensorSideSupportThickness[1]}; + 1.680*fgkmm; +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*fgkmm; + 19.000*fgkmm; ///////////////////////////////////////////////////////////////////////////////// // Chip Cables (lengths are in mm and angles in degrees) ///////////////////////////////////////////////////////////////////////////////// const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2] = - {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm}; + {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4] = - { 0.014*fgkmm, 0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor - - (fgkSSDSensorSideSupportHeight[1]-fgkSSDSensorSideSupportHeight[0]) - - fgkSSDCoolingBlockHoleCenter-fgkSSDStiffenerHeight - - fgkSSDChipHeight-fgkSSDSensorHeight, - fgkSSDModuleCoolingBlockToSensor - - fgkSSDCoolingBlockHoleCenter-fgkSSDStiffenerHeight - - fgkSSDChipHeight-fgkSSDSensorHeight}; + { 0.014*fgkmm, 0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor + - (fgkSSDSensorSideSupportHeight[1] + - fgkSSDSensorSideSupportHeight[0]) + - fgkSSDCoolingBlockHoleCenter + - fgkSSDStiffenerHeight + - fgkSSDChipHeight-fgkSSDSensorHeight, + fgkSSDModuleCoolingBlockToSensor + - fgkSSDCoolingBlockHoleCenter + - fgkSSDStiffenerHeight + - fgkSSDChipHeight-fgkSSDSensorHeight}; const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3] = - { 11.000*fgkmm, 0.800*fgkmm, 0.600*fgkmm}; + { 11.000*fgkmm, 0.800*fgkmm, 0.600*fgkmm}; ///////////////////////////////////////////////////////////////////////////////// // Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees) ///////////////////////////////////////////////////////////////////////////////// const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength = - 3.820*fgkmm; + 3.820*fgkmm; +//const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength = +// 3.780; const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth = - fgkSSDSensorLength-fgkSSDSensorOverlap; + fgkSSDSensorLength-fgkSSDSensorOverlap; const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2] = - { 0.86*fgkmm, 0.30*fgkmm}; + { 0.86*fgkmm, 0.30*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2] = - { 30.00, 90.00}; + { 30.00, 90.00}; const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport = - 1.78*fgkmm; + 1.78*fgkmm; ///////////////////////////////////////////////////////////////////////////////// //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::fgkCarbonFiberTriangleLength + = fgkSSDModuleSensorSupportDistance + - 2. * fgkCarbonFiberJunctionToSensorSupport; +const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle = 60.00; const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2] = - { 0.751*fgkmm, 0.482*fgkmm}; -const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength = - 1.630*fgkmm; -const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth = - 0.950*fgkmm; -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; + { 0.751*fgkmm, 0.482*fgkmm}; +const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength = + 1.630*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth = 0.950*fgkmm; +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) ///////////////////////////////////////////////////////////////////////////////// @@ -230,80 +250,84 @@ const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation = 0.5*fgkCarbonFiberSupportWidth; const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth - = fgkCarbonFiberJunctionWidth - - 2.*(fgkCarbonFiberLowerSupportWidth - + fgkCarbonFiberLowerSupportVolumeSeparation); + = fgkCarbonFiberJunctionWidth + - 2. * (fgkCarbonFiberLowerSupportWidth + + fgkCarbonFiberLowerSupportVolumeSeparation); const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2] - = {fgkCarbonFiberLowerSupportWidth - + fgkCarbonFiberLowerSupportVolumeSeparation, - fgkCarbonFiberLowerSupportWidth - + fgkCarbonFiberLowerSupportVolumeSeparation - + fgkCarbonFiberLowerSupportTransverseWidth}; + = {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)}; + {0.5 * (fgkSSDLay5LadderLength + - fgkSSDLay5SensorsNumber + * fgkCarbonFiberJunctionWidth + - fgkCarbonFiberLowerSupportWidth), + 0.5 * (fgkSSDLay5LadderLength + - fgkSSDLay5SensorsNumber + * fgkCarbonFiberJunctionWidth + + fgkCarbonFiberLowerSupportWidth)}; const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] = - {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm, - fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm}; + {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm, + fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] = - {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm, - fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm}; + {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm, + fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm}; ///////////////////////////////////////////////////////////////////////////////// // Cooling Tube Support (lengths are in mm and angles in degrees) ///////////////////////////////////////////////////////////////////////////////// -const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax = 1.45*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax = 1.45*fgkmm; const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin = fgkSSDCoolingBlockHoleRadius[0]; -const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength = 8.55*fgkmm; -const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight = 0.85*fgkmm; -const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth = 2.00*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength = 8.55*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight = 0.85*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth = 2.00*fgkmm; const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation = - fgkSSDSensorLength-2.*fgkSSDSensorOverlap; -const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber = 11.70*fgkmm; + fgkSSDSensorLength-2.*fgkSSDSensorOverlap; +const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber = + 11.70*fgkmm; ///////////////////////////////////////////////////////////////////////////////// // Cooling Tube (lengths are in mm and angles in degrees) ///////////////////////////////////////////////////////////////////////////////// -const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = - fgkCoolingTubeSupportRmin; -const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin = 0.96*fgkmm; -const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength = +const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin; +const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin = 0.96*fgkmm; +const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength = fgkCarbonFiberJunctionWidth; const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation = - fgkSSDModuleSensorSupportDistance+fgkSSDCoolingBlockLength; + 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*fgkmm, 42.2*fgkmm, 34.0*fgkmm}; + { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4] = - { 4.0*fgkmm, 8.0*fgkmm, 5.0*fgkmm, 0.2*fgkmm}; + { 4.0*fgkmm, 8.0*fgkmm, 5.0*fgkmm, 0.2*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth = - 20.0*fgkmm; + 20.0*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle = - 40.0; + 40.0; const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight = 0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]); const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis = - 2.5*fgkmm; + 2.5*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2] = - { 56.0*fgkmm, 12.0*fgkmm}; + { 56.0*fgkmm, 12.0*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2] = - { 5.0*fgkmm, 2.9*fgkmm}; + { 5.0*fgkmm, 2.9*fgkmm}; const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius = - 1.0*fgkmm; + 1.0*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge = - 6.0*fgkmm; + 6.0*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeigth = - 4.0*fgkmm; + 4.0*fgkmm; const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2] = - { 1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.}; + { 1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.}; ///////////////////////////////////////////////////////////////////////////////// ClassImp(AliITSv11GeometrySSD) ///////////////////////////////////////////////////////////////////////////////// @@ -330,21 +354,38 @@ AliITSv11GeometrySSD::AliITSv11GeometrySSD(): fSSDCoolingTubeWater(), fSSDCoolingTubePhynox(), fSSDMountingBlockMedium(), - fMotherVol(0), + fSSDAir(), + fCreateMaterials(kFALSE), + fTransformationMatrices(kFALSE), + fBasicObjects(kFALSE), + fcarbonfiberjunction(), + fcoolingtubesupport(), + fhybridmatrix(), + fssdcoolingblocksystem(), + fcoolingblocksystematrix(), + fssdstiffenerflex(), + fssdendflex(), + fendladdermountingblock(), + fSSDSensor5(), + fSSDSensor6(), + fSSDLayer5(), + fSSDLayer6(), + fMotherVol(), fColorCarbonFiber(4), fColorRyton(5), - fColorPhynox(5), + fColorPhynox(14), fColorSilicon(3), - fColorAl(7), + fColorAl(38), fColorKapton(6), fColorPolyhamide(5), fColorStiffener(9), - fColorEpoxy(30) + fColorEpoxy(30), + fColorWater(7), + fColorG10(41) { //////////////////////// // Standard constructor //////////////////////// - CreateMaterials(); } ///////////////////////////////////////////////////////////////////////////////// AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s): @@ -370,6 +411,22 @@ AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s): fSSDCoolingTubeWater(s.fSSDCoolingTubeWater), fSSDCoolingTubePhynox(s.fSSDCoolingTubePhynox), fSSDMountingBlockMedium(s.fSSDMountingBlockMedium), + fSSDAir(s.fSSDAir), + fCreateMaterials(s.fCreateMaterials), + fTransformationMatrices(s.fTransformationMatrices), + fBasicObjects(s.fBasicObjects), + fcarbonfiberjunction(s.fcarbonfiberjunction), + fcoolingtubesupport(s.fcoolingtubesupport), + fhybridmatrix(s.fhybridmatrix), + fssdcoolingblocksystem(s.fssdcoolingblocksystem), + fcoolingblocksystematrix(s.fcoolingblocksystematrix), + fssdstiffenerflex(s.fssdstiffenerflex), + fssdendflex(s.fssdendflex), + fendladdermountingblock(s.fendladdermountingblock), + fSSDSensor5(s.fSSDSensor5), + fSSDSensor6(s.fSSDSensor6), + fSSDLayer5(s.fSSDLayer5), + fSSDLayer6(s.fSSDLayer6), fMotherVol(s.fMotherVol), fColorCarbonFiber(s.fColorCarbonFiber), fColorRyton(s.fColorRyton), @@ -379,12 +436,13 @@ AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s): fColorKapton(s.fColorKapton), fColorPolyhamide(s.fColorPolyhamide), fColorStiffener(s.fColorStiffener), - fColorEpoxy(s.fColorEpoxy) + fColorEpoxy(s.fColorEpoxy), + fColorWater(s.fColorWater), + fColorG10(s.fColorG10) { //////////////////////// // Copy Constructor //////////////////////// - CreateMaterials(); } ///////////////////////////////////////////////////////////////////////////////// AliITSv11GeometrySSD& AliITSv11GeometrySSD:: @@ -401,492 +459,553 @@ operator=(const AliITSv11GeometrySSD &s){ return *this; */ } -///////////////////////////////////////////////////////////////////////////////// -// Setting the transformation Matrices -///////////////////////////////////////////////////////////////////////////////// -void AliITSv11GeometrySSD::SetSSDSensorSupportCombiTransMatrix(){ - ///////////////////////////////////////////////////////////// - // Method generating CombiTrans Matrix for SSD Sensor Support - ///////////////////////////////////////////////////////////// - //Translation Parameters SSDSensorSupportAssembly: - //////////////////////////////////////////////////////// - const Double_t kssdsensorsupporttransx[3] = {-0.5*fgkSSDSensorSideSupportWidth, - 0.5*fgkSSDSensorSideSupportWidth, - 0.5*fgkSSDSensorCenterSupportThickness[0] - - fgkSSDSensorCenterSupportPosition}; - const Double_t kssdsensorsupporttransy[3] = - {0.5*fgkSSDSensorSideSupportThickness[0], - -0.5*fgkSSDSensorSideSupportThickness[0] - -fgkSSDModuleSensorSupportDistance, - 0.5*fgkSSDSensorCenterSupportWidth - -0.5*fgkSSDModuleSensorSupportDistance}; - const Double_t kssdsensorsupporttransz[3] = {0.,0., - fgkSSDSensorCenterSupportThickness[0]}; - //////////////////////////////////////////////////////// - //Rotational Parameters SSDSensorSupportAssembly: - //////////////////////////////////////////////////////// - const Double_t kssdsensorsupportrotphi[3] = { 0., 180., 270.}; - const Double_t kssdsensorsupportrottheta[3] = { 90., 90., 90.}; - const Double_t kssdsensorsupportrotpsi[3] = {- 90.,- 90.,- 90.}; - //////////////////////////////////////////////////////////////// - //Name of CombiTrans Transformation of SSDSensorSupportAssembly: - //////////////////////////////////////////////////////////////// - char ssdsensorsupportcombitransname[40]; - char ssdsensorsupportrotname[40]; - TGeoCombiTrans *ssdsensorsupportlocalmatrix[fgkSSDSensorSupportCombiTransNumber]; - for(Int_t i=0; iSetAngles(0.0,180.0,0.0); + carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.); + carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0])); + Double_t transvector[3] = {fgkCarbonFiberTriangleLength + * CosD(fgkCarbonFiberTriangleAngle),0., + - fgkCarbonFiberTriangleLength + * SinD(fgkCarbonFiberTriangleAngle)}; + /////////////////////////////////////////// + //Setting Local Translations and Rotations: + /////////////////////////////////////////// + TGeoCombiTrans* localcarbonfibersupportmatrix[3]; + localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0, + 0.5*carbonfibersupportheight,NULL); + localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0], + 2.*symmetryplaneposition+transvector[1], + transvector[2], carbonfiberot[2]); + localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]); + ///////////////////////////////////////////////////////////// + // Carbon Fiber Support Transformations + ///////////////////////////////////////////////////////////// + const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3}; + for(Int_t i=0; iMultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]); + } + ///////////////////////////////////////////////////////////// + // Carbon Fiber Junction Transformation + ///////////////////////////////////////////////////////////// + const Int_t kcarbonfiberjunctionmatrixnumber = 2; + TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber]; + TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber]; + TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber]; + for(Int_t i=0; iSetAngles(120.*i,0.0,0.0); + localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0); + localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]); + localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]); + //////////////////////////////////////// + // Setting Carbon Fiber Junction matrix + //////////////////////////////////////// + for(Int_t i=0; iMultiplyLeft(localcarbonfiberjunctionmatrix[i][j]); + } } -} -///////////////////////////////////////////////////////////////////////////////// -void AliITSv11GeometrySSD::SetCarbonFiberJunctionCombiTransMatrix(){ - ///////////////////////////////////////////////////////////// - // Method generating CombiTrans Matrix for Carbon Fiber Junction - ///////////////////////////////////////////////////////////// - //Translation Parameters CarbonFiberJunction: - //////////////////////////////////////////////////////// - const Double_t kcarbonfiberjunctiontransx[3] = - { 0.0,fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength - * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad())}; - const Double_t kcarbonfiberjunctiontransy[3] = - { 0.0, 0.0,fgkCarbonFiberTriangleLength - * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())}; - const Double_t kcarbonfiberjunctiontransz[3] = { 0.0, 0.0, 0.0}; - //////////////////////////////////////////////////////// - //Rotational Parameters CarbonFiberJunction: - //////////////////////////////////////////////////////// - const Double_t kcarbonfiberjunctionrotphi[3] = { 0., 120., 240.}; - const Double_t kcarbonfiberjunctionrottheta[3] = { 0., 0., 0.}; - const Double_t kcarbonfiberjunctionrotpsi[3] = { 0., 0., 0.}; - /////////////////////////////////////////////////////////// - //Name of CombiTrans Transformation of CarbonFiberJunction: - /////////////////////////////////////////////////////////// - char carbonfiberjunctioncombitransname[40]; - char carbonfiberjunctionrotname[40]; - TGeoCombiTrans *carbonfiberjunctionlocalmatrix[fgkCarbonFiberJunctionCombiTransNumber]; - for(Int_t i=0; iAdd(localcarbonfiberlowersupportrans[1]); + fcarbonfiberlowersupportrans[0] = + new TGeoTranslation(*localcarbonfiberlowersupportrans[0]); + fcarbonfiberlowersupportrans[1] = + new TGeoTranslation(*localcarbonfiberlowersupportrans[1]); + ///////////////////////////////////////////////////////////// + // SSD Sensor Support Transformations + ///////////////////////////////////////////////////////////// + const Int_t kssdsensorsupportmatrixnumber = 3; + TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber]; + TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber]; + TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber]; + for(Int_t i=0; iSetAngles(0.0,90.0,0.0); + localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0); } -} -//////////////////////////////////////////////////////////////////////////////// -void AliITSv11GeometrySSD::SetCarbonFiberAssemblyCombiTransMatrix(){ - ///////////////////////////////////////////////////////////// - // Method generating CombiTrans Matrix for Carbon fiber Assembly - ///////////////////////////////////////////////////////////// - //Translation Parameters CarbonFiberAssembly: - //////////////////////////////////////////////////////// - const Double_t kcarbonfiberassemblytransx[3] = { 0.0, 0.0, 0.0}; - const Double_t kcarbonfiberassemblytransy[3] = - { 0.5*fgkCarbonFiberJunctionWidth, 0.0, - fgkCarbonFiberJunctionWidth-fgkCarbonFiberLowerSupportWidth - - fgkCarbonFiberLowerSupportVolumePosition[0] - - fgkCarbonFiberLowerSupportVolumePosition[1]}; - const Double_t kcarbonfiberassemblytransz[3] = - { 0.0, 0.0,- 0.5*fgkCarbonFiberLowerSupportHeight}; - //////////////////////////////////////////////////////// - //Rotational Parameters CarbonFiberAssembly: - //////////////////////////////////////////////////////// - const Double_t kcarbonfiberassemblyrotphi[3] = { 0., 90., 0.}; - const Double_t kcarbonfiberassemblyrottheta[3] = { 90., - -fgkCarbonFiberTriangleAngle, 0.}; - const Double_t kcarbonfiberassemblyrotpsi[3] = { 0.,- 90., 0.}; - /////////////////////////////////////////////////////////// - //Name of CombiTrans Transformation of CarbonFiberAssembly: - /////////////////////////////////////////////////////////// - char carbonfiberassemblycombitransname[30]; - char carbonfiberassemblyrotname[30]; - TGeoCombiTrans *carbonfiberassemblylocalmatrix[fgkCarbonFiberAssemblyCombiTransNumber]; - for(Int_t i=0; iSetAngles(0.0,90.0,-90.0); + localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0); + localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0); + //////////////////////////////////////// + // SSD Sensor Support matrix + //////////////////////////////////////// + for(Int_t i=0; iMultiplyLeft(localssdsensorsupportmatrix[i][j]); + } } -} -///////////////////////////////////////////////////////////////////////////////// -void AliITSv11GeometrySSD::SetCoolingTubeSupportCombiTransMatrix(){ ///////////////////////////////////////////////////////////// - // Method generating CombiTrans Matrix for Cooling Tube Support + // SSD Cooling Tube Support Transformations ///////////////////////////////////////////////////////////// - //Translation Parameters CoolingTubeSupport: - //////////////////////////////////////////////////////// + const Int_t kcoolingtubesupportmatrixnumber = 2; + TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber]; + TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber]; + TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber]; Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight /fgkCoolingTubeSupportRmax); - const Double_t kcoolingtubesupporttransx[2] = - {0.,2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi) + localcoolingtubesupportrans[0] = + new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi) + 2.*(fgkCoolingTubeSupportLength - fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi))) + fgkCarbonFiberTriangleLength - - 2.0*fgkCarbonFiberJunctionLength}; - const Double_t kcoolingtubesupporttransy[2] = { 0.0, 0.0}; - const Double_t kcoolingtubesupporttransz[2] = { 0.0, 0.0}; - //////////////////////////////////////////////////////// - //Rotational Parameters CoolingTubeSupport: - //////////////////////////////////////////////////////// - const Double_t kcoolingsubesupportrotphi[2] = { 0., 180.}; - const Double_t kcoolingsubesupportrottheta[2] = { 0., 0.}; - const Double_t kcoolingsubesupportrotpsi[2] = { 0., 0.}; - /////////////////////////////////////////////////////////// - //Name of CombiTrans Transformation of CarbonFiberJunction: - /////////////////////////////////////////////////////////// - char coolingtubesupportcombitransname[40]; - char coolingtubesupportrotname[40]; - TGeoCombiTrans *coolingtubesupportlocalmatrix[fgkCoolingTubeSupportCombiTransNumber]; - for(Int_t i=0; iSetAngles(180.0,0.0,0.0); + localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0); + for(Int_t i=0; iSetAngles(0.,90.,0.); + TGeoTranslation** localcoolingtubetrans[4]; + TVector3** localcoolingtubevect[4]; + for(Int_t i=0; i<4; i++){ + localcoolingtubevect[i] = new TVector3*[2]; + localcoolingtubetrans[i] = new TGeoTranslation*[2]; + fcoolingtubematrix[i] = new TGeoHMatrix*[2]; } -} -///////////////////////////////////////////////////////////////////////////////// -void AliITSv11GeometrySSD::SetCoolingTubeCombiTransMatrix(){ - ///////////////////////////////////////////////////////////// - // Method generating CombiTrans Matrix for Cooling Tube - ///////////////////////////////////////////////////////////// - //Translation Parameters CoolingTube: - //////////////////////////////////////////////////////// - const Double_t kcoolingtubetransx[2] = { 0., fgkCoolingTubeSeparation}; - const Double_t kcoolingtubetransy[2] = { fgkCoolingTubeLength/2.0, fgkCoolingTubeLength/2.0}; - const Double_t kcoolingtubetransz[2] = { 0.0, 0.}; - //////////////////////////////////////////////////////// - //Rotational Parameters CoolingTube: - //////////////////////////////////////////////////////// - const Double_t kcoolingtuberotphi[2] = { 0., 0.}; - const Double_t kcoolingtuberottheta[2] = { 90., 90.}; - const Double_t kcoolingtuberotpsi[2] = { 0., 0.}; - /////////////////////////////////////////////////////////// - //Name of CombiTrans Transformation of CarbonFiberJunction: - /////////////////////////////////////////////////////////// - const char* coolingtubecombitransname[fgkCoolingTubeCombiTransNumber] = - {"CoolingTubeCombiTrans0","CoolingTubeCombiTrans1"}; - const char* coolingtuberotationname[fgkCoolingTubeCombiTransNumber] = - {"CoolingTubeRotation0","CoolingTubeRotation1"}; - TGeoCombiTrans *coolingtubelocalmatrix[fgkCoolingTubeCombiTransNumber]; - for(Int_t i=0; iX(), + localcoolingtubevect[0][0]->Y()+0.5*(fgkSSDSensorLength + - 2.0*fgkSSDModuleStiffenerPosition[1] + - 2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth) + + fgkCoolingTubeSupportWidth, + localcoolingtubevect[0][0]->Z()); + localcoolingtubevect[1][0] = new TVector3(-localcoolingtubevect[0][0]->X() + + fgkCarbonFiberTriangleLength, + localcoolingtubevect[0][0]->Y(), + localcoolingtubevect[0][0]->Z()); + localcoolingtubevect[1][1] = new TVector3(-localcoolingtubevect[0][1]->X() + + fgkCarbonFiberTriangleLength, + localcoolingtubevect[0][1]->Y(), + localcoolingtubevect[0][1]->Z()); + localcoolingtubevect[2][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation + - fgkCarbonFiberTriangleLength), + - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+ + fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth + + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth + - 0.5*(fgkCarbonFiberLowerSupportWidth + + fgkSSDSensorCenterSupportLength + - fgkSSDSensorCenterSupportThickness[0]) + + fgkSSDModuleStiffenerPosition[1] + - 0.5*(fgkSSDModuleStiffenerPosition[1]-fgkSSDSensorOverlap), + - 0.5*fgkCoolingTubeSupportHeight); + localcoolingtubevect[2][1] = new TVector3(-localcoolingtubevect[2][0]->X() + + fgkCarbonFiberTriangleLength, + localcoolingtubevect[2][0]->Y(), + localcoolingtubevect[2][0]->Z()); + localcoolingtubevect[3][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation + - fgkCarbonFiberTriangleLength), + - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+ + fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth + + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth + - 0.5*(fgkCarbonFiberLowerSupportWidth + + fgkSSDSensorCenterSupportLength + - fgkSSDSensorCenterSupportThickness[0]) + + fgkSSDSensorLength + - 0.5*fgkSSDModuleStiffenerPosition[1], + - 0.5*fgkCoolingTubeSupportHeight); + localcoolingtubevect[3][1] = new TVector3(-localcoolingtubevect[3][0]->X() + + fgkCarbonFiberTriangleLength, + localcoolingtubevect[3][0]->Y(), + - 0.5*fgkCoolingTubeSupportHeight); + for(Int_t i=0; i<4; i++) + for(Int_t j=0; j<2; j++){ + localcoolingtubetrans[i][j] = + new TGeoTranslation(localcoolingtubevect[i][j]->X(), + localcoolingtubevect[i][j]->Y(), + localcoolingtubevect[i][j]->Z()); + fcoolingtubematrix[i][j] = new TGeoHMatrix((*localcoolingtubetrans[i][j]) + * (*localcoolingtuberot)); + } + ///////////////////////////////////////////////////////////// + // SSD Hybrid Components Transformations + ///////////////////////////////////////////////////////////// + const Int_t khybridmatrixnumber = 3; + TGeoTranslation* localhybridtrans[khybridmatrixnumber]; + localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength, + 0.5*fgkSSDStiffenerWidth, + 0.5*fgkSSDStiffenerHeight); + localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0], + fgkSSDModuleStiffenerPosition[1],0.0); + + localhybridtrans[2] = new TGeoTranslation( + - 0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength), + - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+ + fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth + + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth + - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength + - fgkSSDSensorCenterSupportThickness[0]), + - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight + - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight)); + fhybridmatrix = new TGeoHMatrix(); + for(Int_t i=0; iMultiplyLeft(localhybridtrans[i]); + ///////////////////////////////////////////////////////////// + // SSD Cooling Block Transformations + ///////////////////////////////////////////////////////////// + const Int_t kcoolingblockmatrixnumber = 4; + TGeoTranslation* localcoolingblocktrans[kcoolingblockmatrixnumber]; + localcoolingblocktrans[0] = new TGeoTranslation(-2.*(fgkCoolingTubeSupportRmax + - fgkCoolingTubeSupportRmin),0.0, + 0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax)); + localcoolingblocktrans[1] = new TGeoTranslation(0.5*fgkSSDStiffenerLength + - 0.5*fgkSSDModuleSensorSupportDistance-fgkSSDCoolingBlockLength, + 0.0,fgkSSDStiffenerHeight); + localcoolingblocktrans[2] = new TGeoTranslation(*localhybridtrans[1]); + localcoolingblocktrans[3] = new TGeoTranslation(*localhybridtrans[2]); + fcoolingblocksystematrix = new TGeoHMatrix(); + for(Int_t i=0; iMultiplyLeft(localcoolingblocktrans[i]); + ///////////////////////////////////////////////////////////// + // SSD Stiffener Flex Transformations + ///////////////////////////////////////////////////////////// + const Int_t klocalflexmatrixnumber = 4; + TGeoCombiTrans** localflexmatrix[fgkflexnumber]; + for(Int_t i=0; iSetTranslation(-fgkSSDFlexLength[0] + +0.5*fgkSSDStiffenerLength, + 0.5*fgkSSDStiffenerWidth, + -0.5*fgkSSDStiffenerHeight + -0.5*fgkSSDFlexHeight[0]); + localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0]) + +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation + -0.5*fgkSSDStiffenerWidth, + -0.5*fgkSSDStiffenerHeight + -0.5*fgkSSDFlexHeight[0]); + TGeoRotation* localflexrot = new TGeoRotation(); + localflexrot->SetAngles(180.,0.,0.); + localflexmatrix[1][0]->SetRotation(localflexrot); + for(Int_t i=0; iSetTranslation(*localhybridtrans[j-1]); + for(Int_t i=0; iMultiplyLeft(localflexmatrix[i][j]); } -} -///////////////////////////////////////////////////////////////////////////////// -void AliITSv11GeometrySSD::SetLadderSegmentCombiTransMatrix(){ - ///////////////////////////////////////////////////////////// - // Method generating CombiTrans Matrix for SSD Ladder Segment - ///////////////////////////////////////////////////////////// - //Translation Parameters LadderSegment: - //////////////////////////////////////////////////////// - const Double_t kladdersegmenttransx[fgkLadderSegmentCombiTransNumber] = { 0., - - 0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength), - fgkCarbonFiberTriangleLength+fgkCarbonFiberJunctionToSensorSupport, - fgkCarbonFiberJunctionLength-(fgkCoolingTubeSupportLength - - fgkCoolingTubeSupportRmax), - 0.5*(fgkCarbonFiberTriangleLength-fgkCoolingTubeSeparation)}; - const Double_t kladdersegmenttransy[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 kladdersegmenttransz[fgkLadderSegmentCombiTransNumber] = { 0., - - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight - - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight), - 0., - - 0.5*fgkCoolingTubeSupportHeight, - - 0.5*fgkCoolingTubeSupportHeight}; -////////////////////////////////////////////////// - //Rotational Parameters LadderSegment: - //////////////////////////////////////////////////////// - const Double_t kladdersegmentrotphi[fgkLadderSegmentCombiTransNumber] = - { 0., 0.,- 90., 0., 0.}; - const Double_t kladdersegmentrottheta[fgkLadderSegmentCombiTransNumber] = - { 0., 0., 0., 90., 0.}; - const Double_t kladdersegmentrotpsi[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; iSetAngles(0.0,90.0,0.0); + TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans(); + Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2]) + / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad()); + Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle + * TMath::DegToRad()*ssdflexradiusmax + - fgkSSDFlexLength[2]-TMath::Pi() + * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]; + Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle) + + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle) + + fgkSSDFlexLength[2]; + localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans, + 0.5*fgkSSDFlexWidth[0], + 2.*fgkSSDStiffenerHeight + + 0.5*fgkSSDFlexHeight[0]); + localendflexmatrix->SetRotation(localendflexrot); + for(Int_t i=0; iSetAngles(120.*j,0.,0.); + for(Int_t i=0; iSetTranslation(fgkCarbonFiberTriangleLength, + 0.0,0.0); + localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength + * CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength + * SinD(fgkCarbonFiberTriangleAngle), + 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i] + - fgkEndLadderCarbonFiberUpperJunctionLength[i])); + } + TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber]; + TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber]; + TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber]; + for(Int_t i=0; iSetAngles(0.0,90.0,0.0); + localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0, + 0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0); + localendladdercarbonfiberjunctionglobalmatrix[i] = + new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i], + *localendladdercarbonfiberjunctionglobalrot[i]); + } + for(Int_t i=0; iSetTranslation(0.0, + i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0); + fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber]; + } + for(Int_t i=0; iAdd(fendladderlowersupptrans[1]); + ///////////////////////////////////////////////////////////// + // Matrix for positioning Ladder into mother volume + ///////////////////////////////////////////////////////////// + TGeoHMatrix** ladderglobalmatrix[fgkladdernumber]; + for(Int_t i=0; iSetAngles(0.,90.,0.); + TGeoTranslation* localladdermothertrans[fgkladdernumber]; + TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber]; + for(Int_t i=0; iInverse()); } -} -///////////////////////////////////////////////////////////////////////////////// -void AliITSv11GeometrySSD::SetLadderCableCombiTransMatrix(Int_t iLayer){ ///////////////////////////////////////////////////////////// - // Method generating CombiTrans Matrix for SSD Ladder Cable + // Ladder Cables Matrices ///////////////////////////////////////////////////////////// - // 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()); + * SinD(2.*fgkSSDFlexAngle) + * CosD(2.*fgkSSDFlexAngle); ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius) - ssdladdercabletransx[0] - / TMath::Sin(2.*fgkSSDFlexAngle*TMath::DegToRad())) - * TMath::Cos(fgkSSDFlexAngle*TMath::DegToRad()); + / SinD(2.*fgkSSDFlexAngle)) + * CosD(fgkSSDFlexAngle); ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle * TMath::DegToRad()*ssdflexradiusmax - fgkSSDFlexLength[2]-TMath::Pi() * fgkSSDStiffenerHeight-fgkSSDFlexLength[0] - fgkSSDLadderCableWidth) - * TMath::Cos(2.*fgkSSDFlexAngle*TMath::DegToRad()); + * CosD(2.*fgkSSDFlexAngle); Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0] - * TMath::Tan(2.*fgkSSDFlexAngle*TMath::DegToRad()), + * TanD(2.*fgkSSDFlexAngle), ssdladdercabletransx[1] - * TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad()), + * TanD(fgkSSDFlexAngle), ssdladdercabletransx[2] - * TMath::Tan(2.*fgkSSDFlexAngle*TMath::DegToRad())}; + * TanD(2.*fgkSSDFlexAngle)}; TGeoRotation* localladdercablerot[3]; - localladdercablerot[0] = new TGeoRotation("LocalLadderCableRot0",90.,0.,0.); - localladdercablerot[1] = new TGeoRotation("LocalLadderCableRot1",90.,60.,-90.); - localladdercablerot[2] = new TGeoRotation("LocalLadderCableRot2"); + for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation(); + localladdercablerot[0]->SetAngles(90.,0.,0.); + localladdercablerot[1]->SetAngles(90.,60.,-90.); localladdercablerot[2]->SetRotation((*localladdercablerot[1]) * (*localladdercablerot[0])); //////////////////////////////////////////// @@ -904,11 +1023,27 @@ void AliITSv11GeometrySSD::SetLadderCableCombiTransMatrix(Int_t iLayer){ localladdercablecombitransmatrix[0][0] = new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength, 0.,0.,NULL); - localladdercablecombitransmatrix[0][1] = fLadderSegmentCombiTransMatrix[1]; + localladdercablecombitransmatrix[0][1] = + new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength), + - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+ + fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth + + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth + - 0.5*(fgkCarbonFiberLowerSupportWidth + + fgkSSDSensorCenterSupportLength + - fgkSSDSensorCenterSupportThickness[0]), + - (fgkSSDModuleCoolingBlockToSensor + + 0.5*fgkCoolingTubeSupportHeight + - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3] + - fgkSSDChipHeight),NULL); localladdercablecombitransmatrix[0][2] = new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0], fgkSSDModuleStiffenerPosition[1],0.,0); - localladdercablecombitransmatrix[0][3] = fSSDModuleCombiTransMatrix[6]; + localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans( + 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength + +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength), + fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1] + - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight, + new TGeoRotation("",180.,0.,0.)); localladdercablecombitransmatrix[0][4] = new TGeoCombiTrans(-ssdladdercabletransx[0] - ssdladdercabletransx[1]-ssdladdercabletransx[2] @@ -921,196 +1056,430 @@ void AliITSv11GeometrySSD::SetLadderCableCombiTransMatrix(Int_t iLayer){ /////////////////////////////////////////// // Rigth Side Ladder Cables Transformations /////////////////////////////////////////// + TGeoCombiTrans* localladdercablessdmodulematrix = + new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength + - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength), + fgkSSDStiffenerWidth, + - 0.5*fgkSSDFlexHeight[0],NULL); for(Int_t i=0; iMultiplyLeft( - localladdercablecombitransmatrix[i][klocalladdercombitransnumber-j-1]); - } - laddercablerot = new TGeoRotation(); - laddercablerot->SetMatrix(localladdercablehmatrix[i]->GetRotationMatrix()); - laddercabletrans = new TGeoTranslation(); - Double_t* laddercabletransvector = localladdercablehmatrix[i]->GetTranslation(); - laddercabletrans->SetTranslation(laddercabletransvector[0], + Int_t beamaxistrans[2][3]; + beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2; + beamaxistrans[0][1] = beamaxistrans[0][0]+1; + beamaxistrans[0][2] = beamaxistrans[0][0]-1; + beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2; + beamaxistrans[1][1] = beamaxistrans[1][0]+1; + beamaxistrans[1][2] = beamaxistrans[1][0]; + TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber]; + TGeoRotation* laddercablerot = new TGeoRotation(); + TGeoTranslation* laddercabletrans = new TGeoTranslation(); + TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans(); + Double_t* laddercabletransvector; + for(Int_t i=0; iMultiplyLeft( + localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]); + } + laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix()); + laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation(); + laddercabletrans->SetTranslation(laddercabletransvector[0], laddercabletransvector[1] - + (i==0 ? beamaxistrans[0] : 0.) + + (j==0 ? beamaxistrans[i][0] : 0.) * fgkCarbonFiberJunctionWidth, - laddercabletransvector[2]); - fLadderCableCombiTransMatrix[i] = new TGeoCombiTrans(*laddercabletrans, - *laddercablerot); - } - fLadderCableCombiTransMatrix[2] = - AddTranslationToCombiTrans(fLadderCableCombiTransMatrix[1],0., - beamaxistrans[1]*fgkCarbonFiberJunctionWidth,0.); - fLadderCableCombiTransMatrix[3] = - AddTranslationToCombiTrans(fLadderCableCombiTransMatrix[0],0., - beamaxistrans[2]*fgkCarbonFiberJunctionWidth,0.); -} -///////////////////////////////////////////////////////////////////////////////// -TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupportShape(Double_t length, - Double_t height,Double_t width,Double_t* thickness){ + laddercabletransvector[2]); + laddercablecombitrans->SetRotation(*laddercablerot); + laddercablecombitrans->SetTranslation(*laddercabletrans); + fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans); + } + fladdercablematrix[i][2] = + AddTranslationToHMatrix(fladdercablematrix[i][1],0., + beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.); + fladdercablematrix[i][3] = + AddTranslationToHMatrix(fladdercablematrix[i][0],0., + beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.); + } + for(Int_t i=0; iMultiplyLeft(ladderglobalmatrix[1][i]); + /////////////////////////////////////////// + // Setting Ladder HMatrix + /////////////////////////////////////////// + Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber, + fgkSSDLay6SensorsNumber}; + for(Int_t i=0; iSetDx(-0.5*fgkCarbonFiberTriangleLength); + fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j); + fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]); + } + } + /////////////////////////////////////////// + // Setting SSD Sensor Matrix + /////////////////////////////////////////// + TGeoCombiTrans* localssdsensorcombitrans[2]; + TGeoRotation* localssdsensorrot = new TGeoRotation(); + localssdsensorrot->SetAngles(0.,90.,0.); + TGeoTranslation* localssdsensortrans[2]; + for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation(); + localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength, + - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+ + fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth + + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth + - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength + - fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength, + 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight + - fgkSSDModuleCoolingBlockToSensor+(fgkSSDSensorSideSupportHeight[1] + - fgkSSDSensorSideSupportHeight[0])); + localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength, + - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+ + fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth + + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth + - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength + - fgkSSDSensorCenterSupportThickness[0])+0.5*fgkSSDSensorLength, + 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight + -fgkSSDModuleCoolingBlockToSensor); + for(Int_t i=0; i<2; i++) + localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i], + *localssdsensorrot); + for(Int_t i=0; iSetDx(-0.5*fgkCarbonFiberTriangleLength); + fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]); + fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]); + fendladdersegmentmatrix[1][i] = new TGeoHMatrix(); + fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength); + fendladdersegmentmatrix[1][i]->RotateZ(180.0); + fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]); + } + ///////////////////////////////////////////////////// + // Setting the CombiTransformation to pass ITS center + ///////////////////////////////////////////////////// + Double_t itscentertransz[fgklayernumber]; + itscentertransz[0] = fgkSSDLay5LadderLength + - fgkLay5CenterITSPosition; + itscentertransz[1] = fgkSSDLay6LadderLength + - fgkLay6CenterITSPosition; + Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor + + 0.5*fgkCoolingTubeSupportHeight; + TGeoRotation* itscenterrot[3]; + for(Int_t i=0; iSetAngles(90.,180.,-90.); + itscenterrot[1]->SetAngles(0.,90.,0.); + itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0])); + TGeoCombiTrans* itscentercombitrans[fgklayernumber]; + for(Int_t i=0; iSetAngles(j*layerladderangleposition[i],0.,0.); + locallayertrans[i][j]->SetTranslation(layerradius + * CosD(90.0+j*layerladderangleposition[i]), + layerradius + * SinD(90.0+j*layerladderangleposition[i]),0.); + locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j], + *locallayerrot[i][j]); + flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i])); + flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]); + flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]); + } + } ///////////////////////////////////////////////////////////// - // Method generating SSD Sensor Support Shape + // Deallocating memory ///////////////////////////////////////////////////////////// - const Int_t kvertexnumber = 4; - const Int_t kshapesnumber = 2; - Double_t shapewidth[2] = {width,width}; - TVector3** vertexposition[kshapesnumber]; - for(Int_t i = 0; iX()); - char* ssdsensorsupportshapename[kshapesnumber] = - {"SSDSensorSupportShape1","SSDSensorSupportShape2"}; - TGeoArb8* lSSDSensorSupportShape[kshapesnumber]; - for(Int_t i = 0; i< kshapesnumber; i++) lSSDSensorSupportShape[i] = - GetArbShape(vertexposition[i],shapewidth,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", - lSSDSensorSupportShape[0],fSSDSensorSupportMedium),1, - ssdsensorsupportshapetrans); - ssdsensorsupportcompvolume->AddNode(new TGeoVolume("SSDSensorSupportVolume2", - lSSDSensorSupportShape[1],fSSDSensorSupportMedium),1, - ssdsensorsupportcombitrans); - return ssdsensorsupportcompvolume; + for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){ + delete carbonfiberot[i]; + delete localcarbonfibersupportmatrix[i]; + } + for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){ + for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){ + delete localcarbonfiberjunctionmatrix[i][j]; + delete localcarbonfiberjunctionrot[i][j]; + delete localcarbonfiberjunctiontrans[i][j]; + } + delete [] localcarbonfiberjunctionmatrix[i]; + delete [] localcarbonfiberjunctionrot[i]; + delete [] localcarbonfiberjunctiontrans[i]; + } + for(Int_t i=0; iAt(i); ///////////////////////////////////////////////////////////// - // Method generating SSD Sensor Support + // Carbon Fiber Junction ///////////////////////////////////////////////////////////// - TGeoVolume* ssdsensorsupport; + fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth); + ///////////////////////////////////////////////////////////// + // Carbon Fiber Lower Support + ///////////////////////////////////////////////////////////// + TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList(); + for(Int_t i=0; iAt(i); + ///////////////////////////// + // SSD Sensor Support + ///////////////////////////// + for(Int_t i=0; iAddNode((i<2 ? ssdsensorsupport[0]: - ssdsensorsupport[1]), - i+1,fSSDSensorSupportCombiTransMatrix[i]); - return ssdsensorsupportassembly; -} -///////////////////////////////////////////////////////////////////////////////// -TGeoVolume* AliITSv11GeometrySSD::GetSSDModule(Int_t iChipCablesHeight){ - ///////////////////////////////////////////////////////////// - // Method generating SSD Sensor Module - ///////////////////////////////////////////////////////////// - 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; iAddNode(i==fgkSSDModuleCombiTransNumber-1 ? ssdmodulevolume[3] : - ssdmodulevolume[i],i!=fgkSSDModuleCombiTransNumber-1?1:2, - ssdmodulehmatrix[i]); - } - return ssdmodule; -} -///////////////////////////////////////////////////////////////////////////////// -TGeoVolume* AliITSv11GeometrySSD::GetSSDSensor(){ + fgkSSDSensorSideSupportThickness[1]}; + for(Int_t i=0; iAt(i); + ///////////////////////////////////////////////////////////// + // SSD Cooling Block System + ///////////////////////////////////////////////////////////// + fssdcoolingblocksystem = GetCoolingBlockSystem(); + ///////////////////////////////////////////////////////////// + // SSD Cooling Tube + ///////////////////////////////////////////////////////////// + TList* coolingtubelist = GetCoolingTubeList(); + for(Int_t i=0; iAt(i); + ///////////////////////////////////////////////////////////// + // SSD Flex + ///////////////////////////////////////////////////////////// + fssdstiffenerflex = GetSSDStiffenerFlex(); + fssdendflex = GetSSDEndFlex(); + /////////////////////////////////// + // End Ladder Carbon Fiber Junction + /////////////////////////////////// + for(Int_t i=0; iSetLineColor(fColorSilicon); + 0.5*fgkSSDSensorHeight, + 0.5*ssdsensitivelength); + TGeoVolume* ssdsensorsensitiveLay5 = + new TGeoVolume(fgSDDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium); + TGeoVolume* ssdsensorsensitiveLay6 = + new TGeoVolume(fgSDDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium); + ssdsensorsensitiveLay5->SetLineColor(fColorSilicon); + ssdsensorsensitiveLay6->SetLineColor(fColorSilicon); TGeoBBox* ssdsensorinsensitiveshape[2]; ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1", - 0.5*fgkSSDSensorLength, 0.5*fgkSSDSensorInsensitiveWidth, - 0.5*fgkSSDSensorHeight); + 0.5*fgkSSDSensorHeight, + 0.5*fgkSSDSensorLength); ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2", - 0.5*fgkSSDSensorInsensitiveWidth, 0.5*ssdsensitivewidth, - 0.5*fgkSSDSensorHeight); + 0.5*fgkSSDSensorHeight, + 0.5*fgkSSDSensorInsensitiveWidth); const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1", "SSDSensorInsensitive2"}; TGeoVolume* ssdsensorinsensitive[2]; @@ -1119,202 +1488,627 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDSensor(){ fSSDSensorMedium); ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber); } - TGeoVolume* ssdsensorinsensitivevol = - new TGeoVolumeAssembly("SSDSensorInsensitiveVol"); - for(Int_t i=0; i<4; i++) - ssdsensorinsensitivevol->AddNode(i%2==0 ? ssdsensorinsensitive[0]: + ///////////////////////////////////////////////////////////// + // Virtual Volume containing SSD Sensor + ///////////////////////////////////////////////////////////// + TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape", + 0.5*fgkSSDSensorWidth, + 0.5*fgkSSDSensorHeight, + 0.5*fgkSSDSensorLength); + fSSDSensor5 = new TGeoVolume("ITSsddSensor5",virtualSSDSensorShape, + fSSDAir); + fSSDSensor6 = new TGeoVolume("ITSsddSensor6",virtualSSDSensorShape, + fSSDAir); + ///////////////////////////////////////////////////////////// + for(Int_t i=0; i<4; i++){ + fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]: + ssdsensorinsensitive[1],i<2?1:2, + new TGeoTranslation( + 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.) + * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0., + 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.) + * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ()))); + fSSDSensor6->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; + new TGeoTranslation( + 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.) + * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0., + 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.) + * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ()))); + } + fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1); + fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1); } -///////////////////////////////////////////////////////////////////////////////// -TGeoVolume* AliITSv11GeometrySSD::GetSSDChipAssembly() const{ - ///////////////////////////////////////////////////////////// - // Method generating SSD Chip Assembly +/////////////////////////////////////////////////////////////////////////////// +TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){ + ///////////////////////////////////////////////////////////// + // Method generating the Carbon Fiber Support + ///////////////////////////////////////////////////////////// + const Int_t kvertexnumber = 4; + const Int_t kshapesnumber = 2; + TVector3** vertexposition[kshapesnumber]; + for(Int_t i=0; iY()); + //////////////////////////////////////////////////// + //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; jX(), + (GetReflection(vertexposition[0][j],param))->Y()); + char* carbonfibersupportshapename[kshapesnumber] = + {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"}; + char* carbonfibersupportname[kshapesnumber] = + {"CarbonFiberSupport1","CarbonFiberSupport2"}; + TGeoArb8* carbonfibersupportshape[kshapesnumber]; + TGeoVolume* carbonfibersupport[kshapesnumber]; + TList* carbonfibersupportlist = new TList(); + Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth}; + Double_t carbonfibersupportheight = + carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0] + *TMath::DegToRad()); + for(Int_t i = 0; i< kshapesnumber; i++){ + carbonfibersupportshape[i] = + GetArbShape(vertexposition[i],width,carbonfibersupportheight, + carbonfibersupportshapename[i],i==0 ? 1: -1); + carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i], + carbonfibersupportshape[i],fSSDCarbonFiberMedium); + carbonfibersupport[i]->SetLineColor(fColorCarbonFiber); + carbonfibersupportlist->Add(carbonfibersupport[i]); + } + ///////////////////////////////////////////////////////////// + // Deallocating memory + ///////////////////////////////////////////////////////////// + for(Int_t i=0; i< kshapesnumber; i++){ + for(Int_t j=0; j< kvertexnumber; j++) + delete vertexposition[i][j]; + delete [] vertexposition[i]; + } + delete [] param; ///////////////////////////////////////////////////////////// - const Int_t kssdchiprownumber = 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],fSSDChipMedium); - ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1], - fSSDChipGlueMedium); - 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; iAddNode(ssdchip,fgkSSDChipNumber*i+j+1, - new TGeoTranslation(j*ssdchipseparation[0],i*ssdchipseparation[1],0.)); - return ssdchipassembly; + return carbonfibersupportlist; } ///////////////////////////////////////////////////////////////////////////////// -TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerAssembly(){ +TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){ ///////////////////////////////////////////////////////////// - // Method generating SSD Stiffener Assembly + // Method generating SSD Carbon Fiber Junction ///////////////////////////////////////////////////////////// - const Int_t kssdstiffenernumber = 2; - Double_t ssdstiffenerseparation = fgkSSDSensorLength - - 2.*fgkSSDModuleStiffenerPosition[1] - - fgkSSDStiffenerWidth; - TGeoVolume* ssdstiffener = new TGeoVolumeAssembly("SSDStiffener"); -//////////////////////////// -// Stiffener Volumes -/////////////////////////// - const Int_t kstiffenerboxnumber = 6; - TGeoBBox* ssdstiffenerboxshapes[kstiffenerboxnumber]; - 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[kstiffenerboxnumber]; - char ssdtiffenerboxname[30]; - for(Int_t i=0; iSetLineColor(fColorStiffener); - } -//////////////////////////// -// Connector -/////////////////////////// - TGeoBBox* ssdconnectorshape = new TGeoBBox("SSDConnectorShape", - 0.5*fgkSSDConnectorLength, - 0.5*fgkSSDConnectorWidth, - 0.5*fgkSSDConnectorHeight); - TGeoVolume* ssdconnector = new TGeoVolume("SSDConnector",ssdconnectorshape, - fSSDStiffenerConnectorMedium); - ssdconnector->SetLineColor(fColorAl); - const Int_t kssdconnectornumber = 2; - TGeoTranslation* ssdconnectortrans[kssdconnectornumber]; - 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; iAddNode(ssdconnector,i+1,ssdconnectortrans[i]); -////////////////////////////////////// -// TGeoTranslation for Stiffener Boxes -////////////////////////////////////// - TGeoTranslation* ssdstiffenerboxtrans[kstiffenerboxnumber]; - 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; iAddNode(ssdstiffenerbox[i],1,ssdstiffenerboxtrans[i]); - TGeoCombiTrans* ssdstiffenercombitrans[kssdstiffenernumber]; - char ssdstiffenercombitransname[30]; - for(Int_t i=0; iX(), yvertexpoints[i] = vertex[i]->Y(); + carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints); + carbonfiberjunctionshape->DefineSection(0,-0.5*width); + carbonfiberjunctionshape->DefineSection(1,0.5*width); + TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction", + carbonfiberjunctionshape,fSSDCarbonFiberMedium); + carbonfiberjunction->SetLineColor(fColorCarbonFiber); + ///////////////////////////////////////////////////////////// + // Deallocating memory + ///////////////////////////////////////////////////////////// + for (Int_t i=0; iX(), + 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* carbonfiberlowersupportshapename[kshapesnumber] = + {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"}; + char* carbonfiberlowersupportname[kshapesnumber] = + {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"}; + TGeoArb8* carbonfiberlowersupportshape[kshapesnumber]; + TGeoVolume* carbonfiberlowersupport[kshapesnumber]; + TList* carbonfiberlowersupportlist = new TList(); + for(Int_t i = 0; i< kshapesnumber; i++){ + carbonfiberlowersupportshape[i] = + GetArbShape(vertexposition[i],width, + fgkCarbonFiberLowerSupportHeight, + carbonfiberlowersupportshapename[i]); + carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i], + carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium); + carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber); + carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]); + } + ///////////////////////////////////////////////////////////// + // Deallocating memory + ///////////////////////////////////////////////////////////// + for(Int_t i=0; i< kshapesnumber; i++){ + for(Int_t j=0; j< kvertexnumber; j++) + delete vertexposition[i][j]; + delete [] vertexposition[i]; + } + ///////////////////////////////////////////////////////////// + return carbonfiberlowersupportlist; +} +/////////////////////////////////////////////////////////////////////////////// +TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height, + Double_t width, Double_t* thickness)const{ + ///////////////////////////////////////////////////////////// + // Method generating the Sensor Support + ///////////////////////////////////////////////////////////// + const Int_t kvertexnumber = 6; + TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2); + TVector3* vertexposition[kvertexnumber]; + vertexposition[0] = new TVector3(); + vertexposition[1] = new TVector3(0.0,length); + vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y()); + vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0]); + vertexposition[4] = new TVector3(height,vertexposition[3]->Y()); + vertexposition[5] = new TVector3(vertexposition[4]->X()); + Double_t xvertexpoints[6], yvertexpoints[6]; + for(Int_t i=0; iX(), + yvertexpoints[i] = vertexposition[i]->Y(); + ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints); + ssdsensorsupportshape->DefineSection(0,-0.5*width); + ssdsensorsupportshape->DefineSection(1,0.5*width); + TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport", + ssdsensorsupportshape,fSSDSensorSupportMedium); + ///////////////////////////////////////////////////////////// + // Deallocating memory + ///////////////////////////////////////////////////////////// + for (Int_t i=0; iX(), + fgkCoolingTubeSupportRmax); + vertexposition[3] = new TVector3(-vertexposition[1]->X(), + fgkCoolingTubeSupportRmax); + vertexposition[4] = new TVector3(-vertexposition[1]->X(), + vertexposition[1]->Y()); + for(Int_t i=0; iX(); + yvertexpoints[i] = vertexposition[i]->Y(); + } + coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints, + yvertexpoints); + coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth); + coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth); + TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc", + coolingtubesupportarcshape, + fSSDTubeHolderMedium); + coolingtubesupportarc->SetLineColor(fColorG10); + ////////////////////////////////////////////////////////////////////////// + // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part + ////////////////////////////////////////////////////////////////////////// + TGeoTubeSeg* coolingtubesupportsegshape = + new TGeoTubeSeg(fgkCoolingTubeSupportRmin, + fgkCoolingTubeSupportRmax, + 0.5*fgkCoolingTubeSupportWidth, + phi,360-phi); + TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg", + coolingtubesupportsegshape, + fSSDTubeHolderMedium); + coolingtubesupportseg->SetLineColor(fColorG10); + ////////////////////////////////////////////////////////////////////////// + // TGeoBBox Volume definition for Cooling Tube Support Box Part + ////////////////////////////////////////////////////////////////////////// + Double_t* boxorigin = new Double_t[3]; + Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax; + boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.; + TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength, + 0.5*fgkCoolingTubeSupportHeight, + 0.5*fgkCoolingTubeSupportWidth,boxorigin); + TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox", + coolingtubesupportboxshape,fSSDTubeHolderMedium); + coolingtubesupportbox->SetLineColor(fColorG10); + ////////////////////////////////////////////////////////////////////////// + // Cooling Tube for Cooling Tube Support + ////////////////////////////////////////////////////////////////////////// + TGeoXtru* coolingtubearcshape[2]; + coolingtubearcshape[0] = new TGeoXtru(2); + Double_t* xvert = new Double_t[nedges+2]; + Double_t* yvert = new Double_t[nedges+2]; + Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin; + //////////////////////////////////////// + // Positioning the vertices for TGeoXTru + //////////////////////////////////////// + xvert[0] = 0., yvert[0] = 0.; + xvert[1] = vertexposition[0]->X()*ratio, yvert[1] = vertexposition[0]->Y()*ratio; + for(Int_t i=0; i< nedges; i++) + xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio, + yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio; + //////////////////////////////////////// + // Defining TGeoXTru PolyGone + //////////////////////////////////////// + coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert); + coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth); + coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth); + coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin, + fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth); + TGeoVolume* coolingtubearc[2]; + coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart", + coolingtubearcshape[0],fSSDCoolingTubeWater); + coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart", + coolingtubearcshape[1],fSSDCoolingTubePhynox); + coolingtubearc[0]->SetLineColor(fColorWater); + coolingtubearc[1]->SetLineColor(fColorPhynox); + //////////////////////////////////////////// + // Defining TGeoTubeSeg Part of Cooling Tube + //////////////////////////////////////////// + TGeoTubeSeg* coolingtubesegshape[2]; + coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax, + 0.5*fgkCoolingTubeSupportWidth,phi,360-phi); + coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin, + 0.5*fgkCoolingTubeSupportWidth,phi,360-phi); + TGeoVolume* coolingtubeseg[2]; + coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart", + coolingtubesegshape[0],fSSDCoolingTubePhynox); + coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart", + coolingtubesegshape[1],fSSDCoolingTubeWater); + coolingtubeseg[0]->SetLineColor(fColorPhynox); + coolingtubeseg[1]->SetLineColor(fColorWater); + ///////////////////////////////////////////////////////////// + // Virtual Volume containing Cooling Tube Support + ///////////////////////////////////////////////////////////// + TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2); + const Int_t kvirtualvertexnumber = 8; + TVector3* virtualvertex[kvirtualvertexnumber]; + //////////////////////////////////////// + // Positioning the vertices for TGeoXTru + //////////////////////////////////////// + virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax); + virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y()); + virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y()); + virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight); + virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y()); + virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y()); + virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y()); + virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y()); + Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber]; + for(Int_t i=0; i< kvirtualvertexnumber; i++) + xmothervertex[i] = virtualvertex[i]->X(), + ymothervertex[i] = virtualvertex[i]->Y(); + //////////////////////////////////////// + // Defining TGeoXTru PolyGone + //////////////////////////////////////// + virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex, + ymothervertex); + virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth); + virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth); + TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport", + virtualCoolingTubeSupportShape,fSSDAir); + //////////////////////////////////////// + // Positioning Volumes in Virtual Volume + //////////////////////////////////////// + TGeoRotation* coolingtubesupportrot = new TGeoRotation(); + coolingtubesupportrot->SetAngles(-90.0,0.0,0.0); + virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot); + virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1); + virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1); + virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot); + virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot); + virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1); + virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1); + ///////////////////////////////////////////////////////////// + // Deallocating memory + ///////////////////////////////////////////////////////////// + delete [] vertexposition; + delete xvertexpoints; + delete yvertexpoints; + delete xvert; + delete yvert; + for(Int_t i=0; i< kvirtualvertexnumber; i++) + delete virtualvertex[i]; + ///////////////////////////////////////////////////////////// + return virtualcoolingtubesupport; +} +///////////////////////////////////////////////////////////////////////////////// +TList* AliITSv11GeometrySSD::GetSSDHybridParts(){ + ///////////////////////////////////////////////////////////// + // Method generating List containing SSD Hybrid Components + ///////////////////////////////////////////////////////////// + TList* ssdhybridlist = new TList(); + const Int_t kssdstiffenernumber = 2; + Double_t ssdstiffenerseparation = fgkSSDSensorLength + - 2.*fgkSSDModuleStiffenerPosition[1] + - fgkSSDStiffenerWidth; + Double_t ssdchipcablesradius[kssdstiffenernumber]; + for(Int_t i=0; iDefinePolygon(kmothervertexnumber,xmothervertex[i], + ymothervertex[i]); + ssdhybridmothershape[i]->DefineSection(0,-0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight + -fgkSSDChipCablesHeight[i+2]); + ssdhybridmothershape[i]->DefineSection(1, 0.5*fgkSSDStiffenerHeight); + ssdhybridmother[i] = new TGeoVolume(ssdhybridmothername[i],ssdhybridmothershape[i], + fSSDAir); + } + ///////////////////////////////////////////////////////////// + // SSD Stiffener + ///////////////////////////////////////////////////////////// + TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape", + 0.5*fgkSSDStiffenerLength, + 0.5*fgkSSDStiffenerWidth, + 0.5*fgkSSDStiffenerHeight); + TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape, + fSSDStiffenerMedium); + ssdstiffener->SetLineColor(fColorStiffener); + TGeoTranslation* ssdstiffenertrans[kssdstiffenernumber]; + for(Int_t i=0; iSetLineColor(fColorAl); + for(Int_t i=0; iAddNode(ssdstiffener,j+1,ssdstiffenertrans[j]); + for(Int_t k=1; kAddNode(capacitor0603,knapacitor0603number*j+k, + new TGeoTranslation((k-3.)/6*fgkSSDStiffenerLength, + j*ssdstiffenerseparation + + 0.5*((j==0? 1:-1)*fgkSSDStiffenerWidth + + (j==0? -1:+1)*fgkSSDCapacitor0603Width), + - 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height))); + } + } + ssdhybridmother[i]->AddNode((TGeoVolume*)ssdchipsystemlist->At(i),i+1,ssdchipsystemtrans); + ssdhybridlist->Add(ssdhybridmother[i]); + } +///////////////////////////////////////////////////////////// +// Mother Volume Containing Capacitor Part +///////////////////////////////////////////////////////////// + const Int_t kcapacitormothernumber = 8; + Double_t xcapacitorvertex[kcapacitormothernumber]; + Double_t ycapacitorvertex[kcapacitormothernumber]; + /////////////////////// + // Setting the vertices + /////////////////////// + xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX(); + xcapacitorvertex[1] = xcapacitorvertex[0]; + xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth; + xcapacitorvertex[3] = xcapacitorvertex[2]; + xcapacitorvertex[4] = xcapacitorvertex[0]; + xcapacitorvertex[5] = xcapacitorvertex[0]; + xcapacitorvertex[6] = -xcapacitorvertex[0]; + xcapacitorvertex[7] = xcapacitorvertex[6]; + ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth; + ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength; + ycapacitorvertex[2] = ycapacitorvertex[1]; + ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength; + ycapacitorvertex[4] = ycapacitorvertex[3]; + ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth; + ycapacitorvertex[6] = ycapacitorvertex[5]; + ycapacitorvertex[7] = ycapacitorvertex[0]; + TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2); + ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex, + ycapacitorvertex); + ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight); + ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height); + TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape, + fSSDAir); //////////////////////////// -// Capacitor 1812-330 nF +// Connector /////////////////////////// + const Int_t kssdconnectornumber = 2; + TGeoBBox* ssdconnectorshape[kssdconnectornumber]; + Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)}; + Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight) + + fgkSSDConnectorAlHeight}; + const char* ssdconnectorname[kssdconnectornumber] = {"SSDConnectorAl","SSDConnectorNi"}; + TGeoVolume* ssdconnector[kssdconnectornumber]; + for(Int_t i=0; iSetLineColor(i==0 ? fColorAl : fColorPhynox); + } + TGeoTranslation* ssdconnectortrans[2*kssdconnectornumber]; + ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX() + + fgkSSDConnectorPosition[0] + - fgkSSDConnectorSeparation + - 1.5*fgkSSDConnectorLength, + ssdstiffenerseparation+ssdstiffenershape->GetDY() + - fgkSSDConnectorPosition[1] + - ssdconnectorshape[0]->GetDY(),0.0); + ssdconnectortrans[1] = new TGeoTranslation( + - ssdstiffenershape->GetDX() + + fgkSSDConnectorPosition[0] + - 0.5*fgkSSDConnectorLength, + ssdstiffenerseparation+ssdstiffenershape->GetDY() + - fgkSSDConnectorPosition[1] + - ssdconnectorshape[0]->GetDY(),0.0); + ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX() + - fgkSSDConnectorPosition[0] + + fgkSSDConnectorSeparation + + 1.5*fgkSSDConnectorLength, + -(ssdstiffenershape->GetDY() + - fgkSSDConnectorPosition[1] + - ssdconnectorshape[0]->GetDY()),0.0); + ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX() + - fgkSSDConnectorPosition[0] + + 0.5*fgkSSDConnectorLength, + -(ssdstiffenershape->GetDY() + - fgkSSDConnectorPosition[1] + - ssdconnectorshape[0]->GetDY()),0.0); + for(Int_t i=0; i<2*kssdconnectornumber; i++) + for(Int_t j=0; jAddNode(ssdconnector[j],i+1,ssdconnectortrans[i]); +//////////////////////////// +// Capacitor 1812-330 nF +/////////////////////////// + Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)}; TGeoBBox* capacitor1812shape = new TGeoBBox("Capacitor1812Shape", 0.5*fgkSSDCapacitor1812Length, 0.5*fgkSSDCapacitor1812Width, - 0.5*fgkSSDCapacitor1812Height); + 0.5*fgkSSDCapacitor1812Height, + ssdcapacitor1812origin); TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape, fSSDStiffener1812CapacitorMedium); capacitor1812->SetLineColor(fColorAl); - TGeoTranslation* capacitor1812trans = new TGeoTranslation("Capacitor1812Trans", - 0., - 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation - - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1], - ssdstiffenerboxshapes[0]->GetDZ()+fgkSSDConnectorHeight - + 0.5*fgkSSDCapacitor1812Height); + TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0, + 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation + - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.0); + ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans); //////////////////////////// //Hybrid Wire //////////////////////////// @@ -1337,481 +2131,173 @@ TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerAssembly(){ + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation, 0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth, - ssdstiffenerboxshapes[0]->GetDZ()+fgkSSDConnectorHeight - + fgkSSDWireRadius, + ssdstiffenershape->GetDZ() + + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight, 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.)); + 0.0, + - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius, + 0.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; iAddNode(ssdstiffener,i+1,ssdstiffenercombitrans[i]); - for(Int_t j=1; jAddNode(capacitor0603,knapacitor0603number*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){ + ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix); + ssdhybridlist->Add(ssdhybridcapacitormother); ///////////////////////////////////////////////////////////// - // Method generating SSD Chip Cables + // Deallocating memory ///////////////////////////////////////////////////////////// - const Int_t kssdchipcableslaynumber = 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*kssdchipcableslaynumber] = - {"SSDChipCablesBoxLay0Shape0","SSDChipCablesBoxLay0Shape1", - "SSDChipCablesBoxLay1Shape0","SSDChipCablesBoxLay1Shape1"}; - char* ssdchipcablestubesegshapename[2*kssdchipcableslaynumber] = - {"SSDChipCablesTubeSegLay0Shape0","SSDChipCablesTubeSegLay0Shape1", - "SSDChipCablesTubeSegLay1Shape0","SSDChipCablesTubeSegLay1Shape1"}; - TGeoBBox** ssdchipcablesboxshape[kssdchipcableslaynumber]; - TGeoTubeSeg** ssdchipcablestubesegshape[kssdchipcableslaynumber]; - for(Int_t i=0; iSetLineColor(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]); + delete hybridwirecombitrans[0]; + delete hybridwirecombitrans[1]; + delete ssdchipsystemlist; + return ssdhybridlist; + ///////////////////////////////////////////////////////////// +} +/////////////////////////////////////////////////////////////////////////////// +TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){ + ///////////////////////////////////////////////////////////// + // SSD Cooling Block System + ///////////////////////////////////////////////////////////// + // SSD Cooling Block and Cooling Tube Transformations + ///////////////////////////////////////////////////////////// + TGeoRotation* localcoolingblockrot = new TGeoRotation(); + localcoolingblockrot->SetAngles(0.,90.,0.); + TGeoCombiTrans* localcoolingblockmatrix = + new TGeoCombiTrans(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot); + TGeoTranslation* localcoolingblocktrans; + TVector3* coolingblocktransvector; + coolingblocktransvector = new TVector3(fgkSSDModuleSensorSupportDistance + + fgkSSDCoolingBlockLength, + fgkSSDSensorLength + - 2.*fgkSSDModuleStiffenerPosition[1] + - fgkSSDCoolingBlockWidth); + const Int_t kcoolingblocktransnumber = 2; + const Int_t kcoolingblocknumber = 4; + TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber]; + TGeoHMatrix* coolingtubematrix[kcoolingblocknumber]; + TGeoRotation* localcoolingtuberot = new TGeoRotation(); + localcoolingtuberot->SetAngles(0.0,90.0,0.0); + TGeoTranslation* localcoolingtubetrans = new TGeoTranslation(); + localcoolingtubetrans->SetTranslation(0.5*fgkSSDCoolingBlockLength, + 0.5*fgkSSDCoolingBlockWidth, + fgkSSDCoolingBlockHoleCenter); + TGeoCombiTrans* localcoolingtubematrix = new TGeoCombiTrans(*localcoolingtubetrans, + *localcoolingtuberot); + Double_t coolingtubedistance = fgkCoolingTubeSupportRmax-fgkCoolingTubeSupportRmin; + for(Int_t i=0; iX()+2*coolingtubedistance, + j*coolingblocktransvector->Y(), + - 0.5*(fgkSSDCoolingBlockHoleCenter + + fgkCoolingTubeRmax)); + coolingblockmatrix[2*i+j] = new TGeoHMatrix((*localcoolingblocktrans) + *(*localcoolingblockmatrix)); + coolingtubematrix[2*i+j] = new TGeoHMatrix((*localcoolingblocktrans) + *(*localcoolingtubematrix)); + } } - ////////////////// - //Trapezoid Shapes - ////////////////// - const Int_t kssdchipcablesvertexnumber = 2; - const Int_t kssdchipcablestrapezoidnumber = 2; - TVector3** ssdchipcablestrapezoidvertex[kssdchipcablesvertexnumber]; - for(Int_t i = 0; i< kssdchipcablestrapezoidnumber; i++) - ssdchipcablestrapezoidvertex[i] = new TVector3*[kssdchipcablesvertexnumber]; - //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[kssdchipcablestrapezoidnumber] = - {"SSDChipCablesTrapezoidBoxShape1","SSDChipCablesTrapezoidBoxShape2"}; - char* ssdchipcablestrapezoidshapename[kssdchipcablestrapezoidnumber] = - {"SSDChipCablesTrapezoidShape1","SSDChipCablesTrapezoidShape2"}; - char* ssdchipcablestrapezoidboxname[kssdchipcablestrapezoidnumber] = - {"SSDChipCablesTrapezoidBox1","SSDChipCablesTrapezoidBox2"}; - char* ssdhipcablestrapezoidname[kssdchipcablestrapezoidnumber] = - {"SSDChipCablesTrapezoid1","SSDChipCablesTrapezoid2"}; - char* ssdchipcablestrapezoidassemblyname[kssdchipcablestrapezoidnumber] = - {"SSDChipCablesTrapezoidAssembly1","SSDChipCablesTrapezoidAssembly2"}; - //Setting the Shapes - TGeoBBox* ssdchipcablestrapezoidboxshape[kssdchipcablestrapezoidnumber]; - TGeoArb8* ssdchipcablestrapezoidshape[kssdchipcablestrapezoidnumber]; - //Setting the Volumes - TGeoVolume* ssdchipcablestrapezoidbox[kssdchipcablestrapezoidnumber]; - TGeoVolume* ssdchipcablestrapezoid[kssdchipcablestrapezoidnumber]; - TGeoVolume* ssdchipcablestrapezoidassembly[kssdchipcablestrapezoidnumber]; - Double_t ssdchipcablestrapezoidwidth[kssdchipcablesvertexnumber] = - {fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2],fgkSSDChipCablesWidth[1]}; - for(Int_t i=0; iSetLineColor(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.)); + ///////////////////////////////////////////////////////////// + // Virtual Volume containing CoolingBlock System + ///////////////////////////////////////////////////////////// + TGeoXtru* coolingsystemothershape = new TGeoXtru(2); + const Int_t kmothervertexnumber = 16; + Double_t xmothervertex[kmothervertexnumber]; + Double_t ymothervertex[kmothervertexnumber]; + /////////////////////// + // Setting the vertices + ///////////////////////fgkCoolingTubeSupportRmax + xmothervertex[0] = 0.0,ymothervertex[0] = 0.0; + xmothervertex[1] = xmothervertex[0], ymothervertex[1] = coolingblocktransvector->Y() + + fgkSSDCoolingBlockWidth; + xmothervertex[2] = coolingblocktransvector->X() + + fgkSSDCoolingBlockLength + + 4*coolingtubedistance; + ymothervertex[2] = ymothervertex[1]; + xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0]; + xmothervertex[4] = xmothervertex[3]-2.*coolingtubedistance-fgkSSDCoolingBlockLength; + ymothervertex[4] = ymothervertex[0]; + xmothervertex[5] = xmothervertex[4], ymothervertex[5] = fgkSSDCoolingBlockWidth; + xmothervertex[6] = xmothervertex[3]-coolingtubedistance; + ymothervertex[6] = ymothervertex[5]; + xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2] + - fgkSSDCoolingBlockWidth; + xmothervertex[8] = xmothervertex[5], ymothervertex[8] = ymothervertex[7]; + xmothervertex[9] = xmothervertex[8], ymothervertex[9] = ymothervertex[2] + - coolingtubedistance; + xmothervertex[10] = fgkSSDCoolingBlockLength+2.*coolingtubedistance; + ymothervertex[10] = ymothervertex[9]; + xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[8]; + xmothervertex[12] = coolingtubedistance, ymothervertex[12] = ymothervertex[11]; + xmothervertex[13] = xmothervertex[12], ymothervertex[13] = fgkSSDCoolingBlockWidth; + xmothervertex[14] = 2.*coolingtubedistance+fgkSSDCoolingBlockLength; + ymothervertex[14] = ymothervertex[13]; + xmothervertex[15] = xmothervertex[14], ymothervertex[15] = ymothervertex[0]; + ////////////////////////////////////////////////////////// + coolingsystemothershape->DefinePolygon(kmothervertexnumber, + xmothervertex,ymothervertex); + coolingsystemothershape->DefineSection(0,-0.5*(fgkSSDCoolingBlockHoleCenter + + fgkCoolingTubeRmax)); + coolingsystemothershape->DefineSection(1, 0.5*(fgkSSDCoolingBlockHoleCenter + + fgkCoolingTubeRmax)); + TGeoVolume* coolingsystemother = new TGeoVolume("CoolingBlockSystem", + coolingsystemothershape,fSSDAir); + ///////////////////////////////////////////////////////////// + // SSD Cooling Tube Part + ///////////////////////////////////////////////////////////// + TGeoTube* coolingtubeshape[fgkcoolingtubenumber]; + coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax, + 0.5*fgkSSDCoolingBlockWidth); + coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin, + 0.5*fgkSSDCoolingBlockWidth); + TGeoVolume* coolingtube[fgkcoolingtubenumber]; + coolingtube[0] = new TGeoVolume("OuterCoolingTube",coolingtubeshape[0], + fSSDCoolingTubePhynox); + coolingtube[1] = new TGeoVolume("InnerCoolingTube",coolingtubeshape[1], + fSSDCoolingTubeWater); + coolingtube[0]->SetLineColor(fColorPhynox); + coolingtube[1]->SetLineColor(fColorWater); + TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30); + ///////////////////////////////////////////////////////////// + // Adding Cooling block to mother volume + ///////////////////////////////////////////////////////////// + for(Int_t i=0; iAddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]); + coolingsystemother->AddNode(coolingtube[0],i+1,coolingtubematrix[i]); + coolingsystemother->AddNode(coolingtube[1],i+1,coolingtubematrix[i]); } - ///////////////////////////// - //Box and Tube Seg CombiTrans - ///////////////////////////// - TGeoTranslation* ssdchipcablesboxtrans[2*kssdchipcableslaynumber]; - 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*(kssdchipcableslaynumber+1)]; -// 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[kssdchipcableslaynumber]; - 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*kssdchipcableslaynumber] = - {"SSDChipCablesLay1Box1","SSDChipCablesLay1Box2", - "SSDChipCablesLay2Box1","SSDChipCablesLay2Box2"}; - char* ssdchiprightcablestubesegname[2*kssdchipcableslaynumber] = - {"SSDChipRightCablesLay1TubeSeg1","SSDChipRightCablesLay1TubeSeg2", - "SSDChipRightCablesLay2TubeSeg1","SSDChipRightCablesLay2TubeSeg2"}; - char* ssdchipLeftcablestubesegname[2*kssdchipcableslaynumber] = - {"SSDChipLeftCablesLay1TubeSeg1","SSDChipLeftCablesLay1TubeSeg2", - "SSDChipLeftCablesLay2TubeSeg1","SSDChipLeftCablesLay2TubeSeg2"}; - char* ssdchipcableslayassemblyname[kssdchipcableslaynumber] = - {"SSDChipCablesLay1","SSDChipCablesLay2"}; - TGeoVolume** ssdchipcablesbox[kssdchipcableslaynumber]; - TGeoVolume** ssdchipcablestubeseg[kssdchipcableslaynumber]; - TGeoVolume* ssdchipcableslayassembly[kssdchipcableslaynumber]; - for(Int_t i=0; iSetLineColor(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[kssdchipcableslaynumber]; - 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; iAddNode(ssdchipcableslayassembly[i],1, - ssdchipcablescombitrans[i]); - ssdchipcablesassembly->AddNode(ssdunderchipcablesbox[i],1,ssdunderchipcablesboxtrans[i]); - } - return ssdchipcablesassembly; -} -///////////////////////////////////////////////////////////////////////////////// -TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCablesAssembly(Double_t SSDChipCablesHeigth){ - ///////////////////////////////////////////////////////////// - // Method generating SSD Chip Cables Assembly - ///////////////////////////////////////////////////////////// - const Int_t kchipcablesnumber = 2; - Double_t chipcablestransvector = fgkSSDSensorLength - - 2.*fgkSSDModuleStiffenerPosition[1] - - 2.*(fgkSSDStiffenerWidth - - fgkSSDStiffenerToChipDist-fgkSSDChipWidth); - char* ssdchipcablesname[kchipcablesnumber] = {"Right","Left"}; - TGeoVolume* ssdchipcables[kchipcablesnumber]; - TGeoVolume* ssdchipcablesassembly = - new TGeoVolumeAssembly("SSDChipCablesAssembly"); - for(Int_t i=0; iAddNode(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; + ///////////////////////////////////////////////////////////// + // Deallocating memory + ///////////////////////////////////////////////////////////// + delete coolingblocktransvector; + delete localcoolingblocktrans; + delete localcoolingblockrot; + delete localcoolingblockmatrix; + delete localcoolingtubetrans; + delete localcoolingtuberot; + ///////////////////////////////////////////////////////////// + // Checking overlaps + ///////////////////////////////////////////////////////////// + //coolingsystemother->CheckOverlaps(0.01); + ///////////////////////////////////////////////////////////// + return coolingsystemother; } ///////////////////////////////////////////////////////////////////////////////// -TGeoVolume* AliITSv11GeometrySSD::GetSSDFlex(Double_t ssdflexradius, Double_t SSDFlexHeigth){ +TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{ ///////////////////////////////////////////////////////////// - // Method generating SSD Flex + // SSD Flex ///////////////////////////////////////////////////////////// - const Int_t kssdflexvolumenumber = 3; - TGeoVolume* ssdflexvolume[kssdflexvolumenumber]; - //////////////////////// - // Setting Display Color - //////////////////////// - Int_t ssdflexcolor; - ssdflexcolor = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fColorAl: fColorPolyhamide); - TGeoMedium* ssdflexmed = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fSSDAlTraceFlexMedium : - fSSDKaptonFlexMedium); - //////////////////////// - // SSDFlexTrapezoidShape - //////////////////////// - const Int_t kssdflexvertexnumber = 2; - Double_t ssdflexwidth[kssdflexvertexnumber] = {fgkSSDFlexWidth[1], - fgkSSDFlexWidth[0]}; - TVector3* ssdflexvertex[kssdflexvertexnumber]; - 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 kssdflextubesegnumber = 2; - TGeoTubeSeg* ssdflextubesegshape[kssdflextubesegnumber]; - 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[kssdflextubesegnumber]; - for(Int_t i = 0; iSetLineColor(ssdflexcolor); - ssdflexvolume[1]->AddNode(ssdflextubeseg[i],1,ssdflextubesegcombitrans[i]); - } - /////////// - //Box Shape - /////////// - const Int_t kssdflexboxnumber = 7; + const Int_t kssdflexlayernumber = 2; + TGeoXtru* ssdflexshape[kssdflexlayernumber]; + for(Int_t i=0; iX()+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[kssdflexboxnumber+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; iAddNode(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; iAddNode(ssdflexvolume[i],1); - return ssdflex; + /////////////////////// + // Setting the vertices + /////////////////////// + xmothervertex[0] = 0.0; + xmothervertex[1] = xmothervertex[0]; + xmothervertex[2] = fgkSSDFlexLength[0]-fgkSSDFlexLength[1]; + xmothervertex[3] = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1] + + ssdflexboxlength[4]; + xmothervertex[4] = xmothervertex[3]; + xmothervertex[5] = xmothervertex[4]-ssdflexboxlength[4]; + xmothervertex[6] = xmothervertex[5]; + xmothervertex[7] = xmothervertex[6]-fgkSSDFlexHoleLength; + xmothervertex[8] = xmothervertex[7]; + xmothervertex[9] = xmothervertex[8]-ssdflexboxlength[2]; + xmothervertex[10] = xmothervertex[9]; + xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3]; + xmothervertex[12] = xmothervertex[11]; + xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2]; + xmothervertex[14] = xmothervertex[13]; + xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength; + xmothervertex[16] = xmothervertex[15]; + ymothervertex[0] = 0.0; + ymothervertex[1] = fgkSSDFlexWidth[1]; + ymothervertex[2] = fgkSSDFlexWidth[0]; + ymothervertex[3] = ymothervertex[2]; + ymothervertex[4] = ymothervertex[0]; + ymothervertex[5] = ymothervertex[4]; + ymothervertex[6] = ssdflexboxwidth[2]; + ymothervertex[7] = ymothervertex[6]; + ymothervertex[8] = ymothervertex[0]; + ymothervertex[9] = ymothervertex[8]; + ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3]; + ymothervertex[11] = ymothervertex[10]; + ymothervertex[12] = ymothervertex[0]; + ymothervertex[13] = ymothervertex[12]; + ymothervertex[14] = ymothervertex[7]; + ymothervertex[15] = ymothervertex[14]; + ymothervertex[16] = ymothervertex[0]; + ///////////////////////////////////////////////////////////// + // First Mother Volume containing SSDFlex + ///////////////////////////////////////////////////////////// + TGeoXtru* ssdflexmothershape = new TGeoXtru(2); + ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex, + ymothervertex); + ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]); + ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]); + TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape, + fSSDAir); + ///////////////////////////////////////////////////////////// + // SSDFlex Layer Shapes + ///////////////////////////////////////////////////////////// + for(Int_t i=0; iDefinePolygon(kmothervertexnumber,xmothervertex, + ymothervertex); + ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]); + ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]); + } + ///////////////////////////////////// + // Setting Layers into Mother Volume + ///////////////////////////////////// + Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide}; + TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium, + fSSDKaptonFlexMedium}; + const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1", + "AlFlexLay2","KaptonFlexLay2"}; + TGeoVolume* ssdflex[2*kssdflexlayernumber]; + TGeoTranslation* ssdflextrans[2*kssdflexlayernumber]; + for(Int_t i=0; i<2*kssdflexlayernumber; i++){ + ssdflex[i] = new TGeoVolume(ssdflexname[i], + i%2==0 ? ssdflexshape[0] : ssdflexshape[1], + i%2==0 ? ssdflexmed[0] : ssdflexmed[1]); + ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]); + ssdflextrans[i] = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0] + + fgkSSDFlexHeight[1])); + ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]); + } + //ssdflexmother->CheckOverlaps(0.01); + return ssdflexmother; } ///////////////////////////////////////////////////////////////////////////////// -TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(Double_t SSDEndFlexLength, - Double_t SSDFlexHeigth){ +TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){ ///////////////////////////////////////////////////////////// // Method generating SSD End Flex ///////////////////////////////////////// - // Setting Display Color, Media and Index - ///////////////////////////////////////// - Int_t ssdflexcolor; - ssdflexcolor = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fColorAl: fColorPolyhamide); - TGeoMedium* ssdflexmed = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fSSDAlTraceFlexMedium : - fSSDKaptonFlexMedium); - //////////////////////// - const Int_t kssdendflexboxnumber = 5; - TGeoBBox* ssdendflexbboxshape[kssdendflexboxnumber]; - 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[kssdendflexboxnumber]; - char ssdendflexbboxname[30]; - for(Int_t i=0; iSetLineColor(ssdflexcolor); - } - TGeoVolume* ssdendflex = new TGeoVolumeAssembly("SSDEndFlex"); - Double_t partialsumlength = 0.; - for(Int_t i=0; iAddNode(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(){ - ///////////////////////////////////////////////////////////// - // Method generating SSD Flex Assembly - ///////////////////////////////////////////////////////////// - TGeoVolume* ssdflexassembly = new TGeoVolumeAssembly("SSDFlexAssembly"); - const Int_t kssdflexlayernumber = 4; - Double_t ssdflexheight[kssdflexlayernumber]; - Double_t ssdflexradius[kssdflexlayernumber]; - TGeoTranslation* ssdflextrans[kssdflexlayernumber]; - for(Int_t i=0; iAddNode(GetSSDFlex(ssdflexradius[i],ssdflexheight[i]),i+1, - ssdflextrans[i]); - } - return ssdflexassembly; -} -///////////////////////////////////////////////////////////////////////////////// -TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlockAssembly(){ - ///////////////////////////////////////////////////////////// - // Method generating SSD Cooling Block Assembly - ///////////////////////////////////////////////////////////// - const Int_t kssdcoolingblocktransnumber = 2; - Double_t ssdcoolingblocktransvector[kssdcoolingblocktransnumber] = - {fgkSSDModuleSensorSupportDistance+fgkSSDCoolingBlockLength, - fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1] - - fgkSSDCoolingBlockWidth}; - TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(); - TGeoVolume* ssdcoolingblockassembly = - new TGeoVolumeAssembly("SSDCoolingBlockAssembly"); - for(Int_t i=0; iAddNode(ssdcoolingblock, - kssdcoolingblocktransnumber*i+j+1, - new TGeoTranslation(i*ssdcoolingblocktransvector[0], - j*ssdcoolingblocktransvector[1],0.)); - return ssdcoolingblockassembly; -} -///////////////////////////////////////////////////////////////////////////////// -TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(){ + Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2]) + / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad()); + Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle + * TMath::DegToRad()*ssdflexradiusmax + - fgkSSDFlexLength[2]-TMath::Pi() + * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]; + const Int_t knedges = 20; + const Int_t karcnumber = 2; + TVector3* vertexposition[karcnumber*(knedges+1)]; + Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges}; + Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0}; + Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight}; + Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(), + - 90.0*TMath::DegToRad()}; + TVector3* referencetrans[karcnumber]; + referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle) + + radius[0]*SinD(2.*fgkSSDFlexAngle), + radius[0]); + referencetrans[1] = new TVector3(referencetrans[0]->X() + + fgkSSDFlexLength[2], + - fgkSSDStiffenerHeight); +for(Int_t i=0; iSetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle) + + radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0); + for(Int_t i=1; iSetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1]) + * CosD(fgkSSDFlexAngle), + (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1]) + * SinD(fgkSSDFlexAngle),0.0); + *transvector[i] = *transvector[i-1]+*deltatransvector; + } + Double_t ratioradius[karcnumber][kendflexlayernumber+1]; + ratioradius[0][0] = 1., ratioradius[1][0] = 1.; + for(Int_t i=0; iX(),transvector[i]->Y()); + vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y()); + for(Int_t j=0; jX()*ratioradius[0][i+1], + vertexposition[j]->Y()*ratioradius[0][i+1]); + vertex[i][j+2]->RotateZ(referenceangle[0]); + *vertex[i][j+2] += *referencetrans[0]; + vertex[i][4*(knedges+1)-j+1] = + new TVector3(vertexposition[j]->X()*ratioradius[0][i], + vertexposition[j]->Y()*ratioradius[0][i]); + vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]); + *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0]; + } + else{ + + vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1], + vertexposition[j]->Y()*ratioradius[1][i+1]); + vertex[i][j+2]->RotateZ(referenceangle[1]); + *vertex[i][j+2] += *referencetrans[1]; + vertex[i][4*(knedges+1)-j+1] = + new TVector3(vertexposition[j]->X()*ratioradius[1][i], + vertexposition[j]->Y()*ratioradius[1][i]); + vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]); + *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1]; + } + } + } ///////////////////////////////////////////////////////////// - // Method generating SSD Cooling Block + // First Mother Volume containing SSDEndFlex + ///////////////////////////////////////////////////////////// + TGeoXtru* ssdendflexmothershape = new TGeoXtru(2); + Double_t xmothervertex[kendflexvertexnumber]; + Double_t ymothervertex[kendflexvertexnumber]; + xmothervertex[0] = vertex[0][0]->X(); + ymothervertex[0] = vertex[0][0]->Y(); + for(Int_t i=1; iX(); + ymothervertex[i] = vertex[3][i]->Y(); + } + else{ + xmothervertex[i] = vertex[0][i]->X(); + ymothervertex[i] = vertex[0][i]->Y(); + } + } + ssdendflexmothershape->DefinePolygon(kendflexvertexnumber, + xmothervertex,ymothervertex); + ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]); + ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]); + TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother", + ssdendflexmothershape,fSSDAir); + ////////////////////////////////////// + // End Flex TGeoXtru Layer Definition + ////////////////////////////////////// + TGeoXtru* ssdendflexshape[kendflexlayernumber]; + TGeoVolume* ssdendflex[kendflexlayernumber]; + for(Int_t i=0; iX(); + yvertex[i][j] = vertex[i][j]->Y(); + } + ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]); + ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]); + ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]); + ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i], + i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]); + ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]); + ssdendflexmother->AddNode(ssdendflex[i],1); + } ///////////////////////////////////////////////////////////// - // Center Cooling Block Hole - //////////////////////////// - Double_t coolingblockholeangle = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0] - /fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg(); - Double_t coolingblockholewidth = fgkSSDCoolingBlockWidth; - 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()); - GetTriangleShape(coolingblockholevertex, - coolingblockholewidth,"CoolingBlockTriangleHoleShape"); - TGeoRotation* coolingblockholerot = - new TGeoRotation("CoolingBlockHoleRot",90,0.,0.); - coolingblockholerot->RegisterYourself(); - new TGeoCompositeShape("CoolingTubeHoleShape", - "CoolingBlockTriangleHoleShape:CoolingBlockHoleRot+" - "CoolingBlockHoleShape"); - /////////////////////////// - // Cooling Block Trapezoids - /////////////////////////// - const Int_t kvertexnumber = 4; - const Int_t ktrapezoidnumber = 2; - TVector3** coolingblocktrapezoidvertex[ktrapezoidnumber]; - for(Int_t i = 0; iX() - - 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[ktrapezoidnumber] = - {"CoolingBlockTrapezoidShape0","CoolingBlockTrapezoidShape1"}; - TGeoArb8* coolingblocktrapezoidshape[ktrapezoidnumber]; - for(Int_t i = 0; i< ktrapezoidnumber; 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(); - new TGeoCompositeShape("CoolingBlockTrapezoidCompositeShape", - "CoolingBlockTrapezoidShape0+CoolingBlockTrapezoidShape1:CoolingBlockTrapezoidTrans+" - "CoolingBlockTrapezoidShape1:CoolingBlockTrapezoidCombiTrans"); - ///////////////////////////// - // Cooling Block Boxes Shapes - ///////////////////////////// - const Int_t kboxnumber = 3; - TGeoBBox* coolingblockboxshape[kboxnumber]; - 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[kboxnumber-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; iRegisterYourself(); - 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* ssdoolingblockshape = - new TGeoCompositeShape("SSDCoolingBlockShape", - "CoolingBlockBoxCompositeShape:CoolingBlockBoxCompositeShapeTrans+" - "CoolingBlockTrapezoidCompositeShape:CoolingBlockTrapezoidCompositeShapeTrans-" - "CoolingTubeHoleShape:CoolingTubeHoleShapeCombiTrans"); - TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock", - ssdoolingblockshape,fSSDAlCoolBlockMedium); - return ssdcoolingblock; -} -///////////////////////////////////////////////////////////////////////////////// -TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){ + // Deallocating memory ///////////////////////////////////////////////////////////// - // Method generating SSD Carbon Fiber Junction + for(Int_t i=0; iSetVertex(i, - vertex[(i < kvertexnumber ? i: i-kvertexnumber)]->X(), - vertex[(i < kvertexnumber ? i : i-kvertexnumber)]->Y()); - TGeoRotation* carbonfiberjunctionrot = - new TGeoRotation("CarbonFiberJunctionRot", - 180., - 180., - 180-2.*fgkCarbonFiberJunctionAngle[0]); - TGeoVolume* carbonfiberjunctionpiece = - new TGeoVolume("CarbonFiberJunctionPiece", - carbonfiberjunctionshapepiece,fSSDCarbonFiberMedium); - TGeoVolume* carbonfiberjunction = - new TGeoVolumeAssembly("CarbonFiberJunction"); - carbonfiberjunctionpiece->SetLineColor(fColorCarbonFiber); - carbonfiberjunction->AddNode(carbonfiberjunctionpiece,1); - carbonfiberjunction->AddNode(carbonfiberjunctionpiece,2,carbonfiberjunctionrot); - return carbonfiberjunction; -} -///////////////////////////////////////////////////////////////////////////////// -TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunctionAssembly(){ - ///////////////////////////////////////////////////////////// - // Method generating SSD Carbon Fiber Junction Assembly - ///////////////////////////////////////////////////////////// - SetCarbonFiberJunctionCombiTransMatrix(); - TGeoVolume* carbonfiberjunctionassembly = - new TGeoVolumeAssembly("CarbonFiberJunctionAssembly"); - TGeoVolume* carbonfiberjunction = - GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth); - for(Int_t i=0; iAddNode(carbonfiberjunction,i+1, - fCarbonFiberJunctionCombiTransMatrix[i]); - return carbonfiberjunctionassembly; + //ssdendflexmother->CheckOverlaps(0.01); + return ssdendflexmother; } -///////////////////////////////////////////////////////////////////////////////// -TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){ - ///////////////////////////////////////////////////////////// - // Method returning a List containing pointers to Ladder Cable Volumes +//////////////////////////////////////////////////////////////////////////////// +TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){ ///////////////////////////////////////////////////////////// - const Int_t kladdercablesegmentnumber = 2; - ///////////////////////////////////////// - // LadderSegmentBBox Volume - ///////////////////////////////////////// - TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber]; - const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] = - {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"}; - for(Int_t i=0; iSetLineColor(i==0 ? fColorAl : - fColorPolyhamide); - } - TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber]; - 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; iAddNode(laddercablesegmentbbox[i],1, - laddercablesegmentbboxtrans[i]); -///////////////////////////////////////// -// LadderSegmentArb8 Volume -///////////////////////////////////////// - const Int_t kvertexnumber = 4; - TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber]; - for(Int_t i = 0; iX(), - laddercablesegmentvertexposition[i][2]->Y()); - } - Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]}, - {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}}; - char* laddercablesegmentarbshapename[kladdercablesegmentnumber] = - {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"}; - TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber]; - for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] = - GetArbShape(laddercablesegmentvertexposition[i], - laddercablesegmentwidth[i], - fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0], - laddercablesegmentarbshapename[i]); - const char* laddercablesegmentarbname[kladdercablesegmentnumber] = - {"LadderCableSegmentArb1","LadderCableSegmentArb2"}; - TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber]; - for(Int_t i=0; iSetLineColor(i==0 ? fColorAl : - fColorPolyhamide); -} - TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber]; - 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; iAddNode(laddercablesegmentarb[i],1, - laddercablesegmentarbcombitrans); -///////////////////////////////////////// -// End Ladder Cable Volume -///////////////////////////////////////// - TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber]; - const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] = - {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"}; - for(Int_t i=0; iSetLineColor(i==0 ? fColorAl : - fColorPolyhamide); - } - TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber]; - 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; iAddNode(ladderendcablesegmentbbox[i],1, - ladderendcablesegmentbboxtrans[i]); -///////////////////////////////////////// - TList* laddercablesegmentlist = new TList(); - laddercablesegmentlist->Add(laddercablesegmentbboxassembly); - laddercablesegmentlist->Add(laddercablesegmentarbassembly); - laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly); - return laddercablesegmentlist; + // Method generating the Mounting Block + ///////////////////////////////////////////////////////////// + // Mounting Block Boxes Shapes + /////////////////////////////////////// + const Int_t kmountingblockboxnumber = 3; + TGeoBBox* mountingblockboxshape[kmountingblockboxnumber]; + 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[kmountingblockboxnumber+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; iRegisterYourself(); + /////////////////////////////////////// + // Mounting Block Trapezoid Hole Shapes + /////////////////////////////////////// + const Int_t kholetrapezoidvertexnumber = 4; + TVector3* holetrapezoidvertex[kholetrapezoidvertexnumber]; + 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}; + 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 kmountingblocktubenumber = 2; + TGeoTube* mountingblocktubeshape[kmountingblocktubenumber]; + 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*kmountingblocktubenumber]; + 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*kmountingblocktubenumber; i++) + mountingblocktubetrans[i]->RegisterYourself(); + new TGeoCompositeShape("MountingBlockMainShape", + "MountingBlockBoxShape0:MountingBlockBoxTrans0+" + "MountingBlockBoxShape1:MountingBlockBoxTrans1+" + "MountingBlockBoxShape2:MountingBlockBoxTrans2+" + "MountingBlockBoxShape1:MountingBlockBoxTrans3+" + "MountingBlockBoxShape0:MountingBlockBoxTrans4"); + //////////////////////////////////////////// + // Mounting Block Screw Composite Hole Shapes + //////////////////////////////////////////// + const Int_t kmountingblockholetubesegnumber = 4; + new TGeoTubeSeg("MountingBlockHoleTubeSegShape", + 0.0, + fgkSSDMountingBlockScrewHoleRadius[0], + 0.5*fgkSSDMountingBlockScrewHoleHeigth,-90.,180.); + TGeoCombiTrans* mountingblockholetubesegcombitrans[kmountingblockholetubesegnumber]; + char* mountingblockholetubesegcombitransname[kmountingblockholetubesegnumber] = + { "MountingBlockHoleTubeSegCombiTrans0", + "MountingBlockHoleTubeSegCombiTrans1", + "MountingBlockHoleTubeSegCombiTrans2", + "MountingBlockHoleTubeSegCombiTrans3"}; + for(Int_t i=0; iRegisterYourself(); } -///////////////////////////////////////////////////////////////////////////////// -TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){ - ///////////////////////////////////////////////////////////// - // Method generating Ladder Cable Volumes Assemblies - ///////////////////////////////////////////////////////////// - TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength); - TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable"); - for(Int_t i=0; iAddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans); - if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans); + 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"); + new TGeoTubeSeg("MountingBlockLowerHoleTubeSegShape", + 0.0, + fgkSSDMountingBlockScrewHoleRadius[1], + 0.5*(fgkSSDMountingBlockHoleTubeWidth[0] + - fgkSSDMountingBlockScrewHoleHeigth + - fgkSSDMountingBlockHeight[3]),0.,90.); + TGeoCombiTrans* mountingblocklowerholetubesegcombitrans[kmountingblockholetubesegnumber]; + char* mountingblocklowerholetubesegcombitransname[kmountingblockholetubesegnumber] = + { "MountingBlockLowerHoleTubeSegCombiTrans0", + "MountingBlockLowerHoleTubeSegCombiTrans1", + "MountingBlockLowerHoleTubeSegCombiTrans2", + "MountingBlockLowerHoleTubeSegCombiTrans3"}; + for(Int_t i=0; iRegisterYourself(); } - 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){ - ///////////////////////////////////////////////////////////// - // Method generating Ladder Cable Volumes Assembly - ///////////////////////////////////////////////////////////// - TGeoVolume* laddercableassembly = new TGeoVolumeAssembly("LadderCableAssembly"); - char laddercabletransname[30]; - for(Int_t i=0; iAddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1, - new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0.,0.)); + 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[kmountingblockholetubesegnumber]; + char* mountingBlockLowerHoleBoxCombiTransName[kmountingblockholetubesegnumber] = + { "MountingBlockLowerHoleBoxCombiTrans0", + "MountingBlockLowerHoleBoxCombiTrans1", + "MountingBlockLowerHoleBoxCombiTrans2", + "MountingBlockLowerHoleBoxCombiTrans3"}; + for(Int_t i=0; iRegisterYourself(); } - return laddercableassembly; -} -///////////////////////////////////////////////////////////////////////////////// -TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){ - ///////////////////////////////////////////////////////////// - // Method generating Ladder Cable List Assemblies - ///////////////////////////////////////////////////////////// - const Int_t kladdercableassemblynumber = 2; - TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength); - TGeoVolume* ladderCable[kladdercableassemblynumber]; - char laddercableassemblyname[30]; - TList* laddercableassemblylist = new TList(); - for(Int_t i=0; iAddNode(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; + 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(); + 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,fSSDMountingBlockMedium); + return ssdmountingblock; } -///////////////////////////////////////////////////////////////////////////////// -TList* AliITSv11GeometrySSD::GetEndLadderCarbonFiberJunctionAssembly(){ +/////////////////////////////////////////////////////////////////////////////// +TList* AliITSv11GeometrySSD::GetCoolingTubeList()const{ ///////////////////////////////////////////////////////////// - // Method generating the End Ladder Carbon Fiber Junction Assembly + // Method generating the Cooling Tube ///////////////////////////////////////////////////////////// - const Int_t kendlabbercarbonfiberjunctionumber = 2; - TGeoVolume* endladdercarbonfiberjunctionassembly[kendlabbercarbonfiberjunctionumber]; - endladdercarbonfiberjunctionassembly[0] = - new TGeoVolumeAssembly("EndLadderCarbonFiberJunctionAssembly1"); - endladdercarbonfiberjunctionassembly[1] = - new TGeoVolumeAssembly("EndLadderCarbonFiberJunctionAssembly2"); - TGeoVolume** endladdercarbonfiberjunction[kendlabbercarbonfiberjunctionumber]; - for(Int_t i=0; iGetDz()); + coolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax, + 0.5*(fgkSSDModuleStiffenerPosition[1] + - fgkSSDSensorOverlap)); + coolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin, + coolingtubeshape[1][0]->GetDz()); + coolingtubeshape[2][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax, + 0.5*fgkSSDModuleStiffenerPosition[1]); + coolingtubeshape[2][1] = new TGeoTube(0.0,fgkCoolingTubeRmin, + coolingtubeshape[2][0]->GetDz()); + TGeoVolume** coolingtube[fgkcoolingtubenumber]; + for(Int_t i=0; iSetLineColor(fColorPhynox); + coolingtube[i][1]->SetLineColor(fColorWater); + } + ///////////////////////////////////////////////////////////// + // Virtual Volume containing Cooling Tubes + ///////////////////////////////////////////////////////////// + TGeoTube* virtualcoolingtubeshape[fgkcoolingtubenumber]; + for(Int_t i=0; iGetRmin(), + coolingtubeshape[i][0]->GetRmax(), + coolingtubeshape[i][0]->GetDz()); + TGeoVolume* virtualcoolingtube[fgkcoolingtubenumber]; + virtualcoolingtube[0] = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape[0], + fSSDAir); + virtualcoolingtube[1] = new TGeoVolume("CoolingTube2",virtualcoolingtubeshape[1], + fSSDAir); + virtualcoolingtube[2] = new TGeoVolume("CoolingTube3",virtualcoolingtubeshape[2], + fSSDAir); + TList* coolingtubelist = new TList(); + for(Int_t i=0; iAddNode(coolingtube[i][0],1); + virtualcoolingtube[i]->AddNode(coolingtube[i][1],1); + coolingtubelist->Add(virtualcoolingtube[i]); } - TList* endladdercarbonfiberjunctionlist = new TList(); - for(Int_t i=0; iAddNode(j==2 ? - endladdercarbonfiberjunction[i][1] : - endladdercarbonfiberjunction[i][0], - j+1,fEndLadderCarbonFiberJunctionCombiTransMatrix[j]); - endladdercarbonfiberjunctionlist->Add(endladdercarbonfiberjunctionassembly[i]); - } - return endladdercarbonfiberjunctionlist; + return coolingtubelist; } -//////////////////////////////////////////////////////////////////////////////// -TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberSupport(){ +/////////////////////////////////////////////////////////////////////////////// +TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){ ///////////////////////////////////////////////////////////// - // Method generating the Carbon Fiber Support - ///////////////////////////////////////////////////////////// - const Int_t kvertexnumber = 4; - const Int_t kshapesnumber = 2; - TVector3** vertexposition[kshapesnumber]; - for(Int_t i=0; iY()); - //////////////////////////////////////////////////// - //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; jX(), - (GetReflection(vertexposition[0][j],param))->Y()); - char* carbonfibersupportshapename[kshapesnumber] = - {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"}; - TGeoArb8* carbonfibersupportshape[kshapesnumber]; - Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth}; - Double_t carbonfibersupportheight = - carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0] - *TMath::DegToRad()); - for(Int_t i = 0; i< kshapesnumber; 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,fSSDCarbonFiberMedium); - 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){ + // Method generating SSD Cooling Block ///////////////////////////////////////////////////////////// - // Method generating the Carbon Fiber Lower Support - ///////////////////////////////////////////////////////////// - const Int_t kvertexnumber = 4; - const Int_t kshapesnumber = 2; - Double_t width[2] = {fgkCarbonFiberLowerSupportWidth, - fgkCarbonFiberLowerSupportWidth}; - TVector3** vertexposition[kshapesnumber]; - for(Int_t i = 0; iX(), - 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[kshapesnumber] = - {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"}; - TGeoArb8* carbonfiberlowersupportshape[kshapesnumber]; - for(Int_t i = 0; i< kshapesnumber; i++) carbonfiberlowersupportshape[i] = - GetArbShape(vertexposition[i],width, - fgkCarbonFiberLowerSupportHeight, - carbonfiberlowersupportname[i]); + const Int_t kvertexnumber = 8; + /////////////////////////////////////// + // Vertex Positioning for TGeoXTru + /////////////////////////////////////// + TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1]; + vertexposition[0] = new TVector3(0.0,0.0); + vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1]); + vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1], + vertexposition[1]->Y()); + vertexposition[3] = new TVector3(vertexposition[2]->X(), + vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2]); + vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y()); + vertexposition[5] = new TVector3(vertexposition[4]->X(), + + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1]); + vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(), + vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength + - fgkSSDCoolingBlockHoleLength[0] + - 4.*fgkSSDCoolingBlockHoleRadius[1]), + fgkSSDCoolingBlockHeight[0] + - fgkSSDCoolingBlockHoleRadius[1], + fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0]); + vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength + - fgkSSDCoolingBlockHoleLength[0]), + vertexposition[6]->Y()); + Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0] + / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg(); + Double_t phi = 180.-alpha; + Double_t psi = 180.+2.*alpha; + Double_t deltapsi = psi/nedges; + Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi); + TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength, + fgkSSDCoolingBlockHoleCenter); + for(Int_t i=0; iX(); + yvertexpoints[i] = vertexposition[i]->Y(); + } + ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints, + yvertexpoints); + ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth); + ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth); + TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock", + ssdcoolingblockshape, + fSSDAlCoolBlockMedium); + ssdcoolingblock->SetLineColor(fColorAl); + ///////////////////////////////////////////////////////////// + // Deallocating memory + ///////////////////////////////////////////////////////////// + delete [] vertexposition; + delete xvertexpoints; + delete yvertexpoints; + ///////////////////////////////////////////////////////////// + return ssdcoolingblock; +} +///////////////////////////////////////////////////////////////////////////////// +TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth, Int_t nedges){ /////////////////////////////////////////////////////// - TGeoTranslation* carbonfiberlowersupporttrans[kshapesnumber]; - 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< kshapesnumber; i++) - carbonfiberlowersupporttrans[i]->RegisterYourself(); + const Int_t kssdchipcablesnumber = 2; + const Int_t kssdchipcableslaynumber = 2; + const Int_t kvertexnumber = 4*(nedges+1)+4; + Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide}; + Double_t ssdchipcablesradius[kssdchipcableslaynumber]; + ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeigth + - fgkSSDChipCablesHeight[0] + - fgkSSDChipCablesHeight[1]); + ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0]; + Double_t ssdchipcablespiecelength[kssdchipcablesnumber]; + ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0] + - 2.*TMath::Pi()*ssdchipcablesradius[0] + - ssdchipcablesradius[0] + - fgkSSDChipCablesWidth[1] + - fgkSSDChipCablesWidth[2]); + ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0] + - 0.5*(fgkSSDModuleStiffenerPosition[1] + + fgkSSDChipCablesHeight[1] + + fgkSSDSensorHeight); /////////////////////////////////////////////////////// - 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,fSSDCarbonFiberMedium); - carbonfiberlowersupport->SetLineColor(fColorCarbonFiber); - return carbonfiberlowersupport; -} -//////////////////////////////////////////////////////////////////////////////// -TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberAssemblySupport(){ + // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2 + /////////////////////////////////////////////////////// + TVector3** vertexposition[kssdchipcableslaynumber]; + for(Int_t i=0; iSetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]); + transvector[1]->SetY(ssdchipcablesradius[0] + + fgkSSDChipCablesHeight[0] + + fgkSSDChipCablesHeight[1]); + for(Int_t i=0; iX(), + vertexposition[i][2*(nedges+1)+2]->Y() + - fgkSSDChipCablesHeight[i]); + for(Int_t j=0; jSetX(ssdchipcablesradius[0]*CosD(angle)); + vertex->SetY(ssdchipcablesradius[0]*SinD(angle)); + vertexposition[0][(nedges+1)*i+j+2] = + new TVector3(*vertex+*transvector[i]); + vertexposition[1][(nedges+1)*i+j+2] = + new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(), + vertex->Y()*ratio[2*i]+transvector[i]->Y()); + vertexposition[0][(4-i)*(nedges+1)+4-j-1] = + new TVector3(*vertexposition[1][(nedges+1)*i+j+2]); + vertexposition[1][(4-i)*(nedges+1)+4-j-1] = + new TVector3(vertex->X()*ratio[2*i+1] + + transvector[i]->X(), + vertex->Y()*ratio[2*i+1] + + transvector[i]->Y()); + } + } + for(Int_t i=0; iX(); + yvertexpoints[i][j] = vertexposition[i][j]->Y(); + } + ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2); + ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber, + xvertexpoints[i],yvertexpoints[i]); + ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]); + ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]); + ssdchipcable[kssdchipcablesnumber*k+i] = + new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i], + ssdchipcableshape[kssdchipcablesnumber*k+i], + (kssdchipcablesnumber*k+i)%2==0? + fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium); + ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]); + } + for(Int_t i=0; iAddNode(carbonfiberassemblyvolumes[i],1, - fCarbonFiberAssemblyCombiTransMatrix[i]); - return carbonfiberassemblysupport; + // Mother Volume definition + ///////////////////////////////////////////////////////////// + Double_t ssdchipseparation = fgkSSDSensorLength + - 2.*fgkSSDModuleStiffenerPosition[1] + - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist + - 0.5*fgkSSDChipWidth)-fgkSSDChipWidth; + Double_t boxorigin[3] = {-0.5*ssdchipseparation,0.,0.5*SSDChipCablesHeigth}; + Double_t dx = ssdchipseparation+2.*(fgkSSDChipWidth+ssdchipcablesradius[0] + +fgkSSDChipCablesWidth[1] + +fgkSSDChipCablesWidth[2]); + Double_t dy = fgkSSDChipCablesLength[1]; + Double_t dz = SSDChipCablesHeigth; + TGeoBBox* ssdchipcablesmotherbox = new TGeoBBox(0.5*dx,0.5*dy,0.5*dz,boxorigin); + TGeoVolume* ssdchipcablesmother = new TGeoVolume("SSDChipCablesMother", + ssdchipcablesmotherbox,fSSDAir); + ///////////////////////////////////////////////////////////// + // Rotation and Translation Definition for positioning + ///////////////////////////////////////////////////////////// + TGeoRotation* ssdchipcablesrot[5]; + ssdchipcablesrot[0] = new TGeoRotation("",90.,180.,-90); + ssdchipcablesrot[1] = new TGeoRotation("",0.0,90.0,0.0); + ssdchipcablesrot[2] = new TGeoRotation((*ssdchipcablesrot[1])*(*ssdchipcablesrot[0])); + ssdchipcablesrot[3] = new TGeoRotation("",180.,0.0,0.0); + ssdchipcablesrot[4] = new TGeoRotation((*ssdchipcablesrot[3])*(*ssdchipcablesrot[2])); + TGeoCombiTrans* ssdchipcablescombitrans = new TGeoCombiTrans(-ssdchipseparation, + 0.,0.,ssdchipcablesrot[2]); + ssdchipcablesmother->AddNode(ssdchipcable[0],1,ssdchipcablesrot[4]); + ssdchipcablesmother->AddNode(ssdchipcable[1],1,ssdchipcablesrot[4]); + ssdchipcablesmother->AddNode(ssdchipcable[2],1,ssdchipcablescombitrans); + ssdchipcablesmother->AddNode(ssdchipcable[3],1,ssdchipcablescombitrans); + ///////////////////////////////////////////////////////////// + // Deallocating memory + ///////////////////////////////////////////////////////////// + for(Int_t i=0; iDefinePolygon(kmothervertexnumber, + xmothervertex[i],ymothervertex[i]); + chipsystemothershape[i]->DefineSection(0,-fgkSSDChipCablesHeight[i+2] + -0.5*fgkSSDChipHeight); + chipsystemothershape[i]->DefineSection(1,0.5*fgkSSDChipHeight); + chipsystemother[i] = new TGeoVolume(chipsytemothername[i], + chipsystemothershape[i],fSSDAir); + } ///////////////////////////////////////////////////////////// - // Method generating the Cooling Tube Support - ///////////////////////////////////////////////////////////// - const Int_t kvertexnumber = 3; - Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight - / fgkCoolingTubeSupportRmax)*TMath::RadToDeg(); - new TGeoTubeSeg("CoolingTubeSegShape",0.0, - fgkCoolingTubeSupportRmax, - 0.5*fgkCoolingTubeSupportWidth,phi, - 360-phi); - new TGeoTube("CoolingTubeHoleShape",0.0, - fgkCoolingTubeSupportRmin, - 0.5*fgkCoolingTubeSupportWidth); - TVector3* vertexposition[kvertexnumber]; - /////////////////////////// - //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()); - 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.; - 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,fSSDTubeHolderMedium); - return coolingtubesupport; + // SSD Chip Cables + ///////////////////////////////////////////////////////////// + TGeoVolume* ssdchipcables[kchipsystemnumber]; + TGeoRotation** ssdchipcablesrot[kchipsystemnumber]; + TGeoTranslation** ssdchipcablestrans[kchipsystemnumber]; + TGeoCombiTrans** ssdchipcablescombitrans[kchipsystemnumber]; + ////////////////// + for(Int_t i=0; iSetAngles(-90.0,0.0,0.0); + ssdchipcablestrans[i][j]->SetTranslation(j*(fgkSSDChipLength + + fgkSSDChipSeparationLength), + 0.5*fgkSSDChipWidth, + - 0.5*fgkSSDChipHeight + - fgkSSDChipCablesHeight[i+2]); + ssdchipcablescombitrans[i][j]->SetRotation(*ssdchipcablesrot[i][j]); + ssdchipcablescombitrans[i][j]->SetTranslation(*ssdchipcablestrans[i][j]); + chipsystemother[i]->AddNode(ssdchipcables[i],j+1,ssdchipcablescombitrans[i][j]); + + } + chipsystemother[i]->AddNode(ssdchipassembly,i+1); + ssdchipsystemlist->Add(chipsystemother[i]); + } + ///////////////////////////////////////////////////////////// + // Deallocating memory + ///////////////////////////////////////////////////////////// + for(Int_t i=0; iAddNode(coolingtubesupport,i+1, - fCoolingTubeSupportCombiTransMatrix[i]); - return coolingtubesupportassembly; + // SSD Chip Assembly Generation + ///////////////////////////////////////////////////////////// + const Int_t kssdchiprownumber = 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],fSSDChipMedium); + ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1], + fSSDChipGlueMedium); + 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()); + ///////////////////////////////////////////////////////////// + // Virtual Volume containing SSDChip + ///////////////////////////////////////////////////////////// + TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength, + 0.5*fgkSSDChipWidth, + 0.5*fgkSSDChipHeight); + TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir); + ///////////////////////////////////////////////////////////// + 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)}; + ///////////////////////////////////////////////////////////// + // Virtual Volume containing SSDChipAssembly + ///////////////////////////////////////////////////////////// + TGeoXtru* ssdchipmothershape = new TGeoXtru(2); + const Int_t kssdmothervertexnumber = 2*fgkSSDChipNumber; + Double_t xmothervertex[kssdmothervertexnumber]; + Double_t ymothervertex[kssdmothervertexnumber]; + /////////////////////// + // Setting the vertices + /////////////////////// + xmothervertex[0] = -0.5*fgkSSDChipLength,ymothervertex[0] = -0.5*fgkSSDChipWidth; + xmothervertex[1] = xmothervertex[0], ymothervertex[1] = ssdchipseparation[1] + - ymothervertex[0]; + xmothervertex[2] = (fgkSSDChipNumber-1)*ssdchipseparation[0]-xmothervertex[0]; + ymothervertex[2] = ymothervertex[1]; + xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0]; + xmothervertex[4] = ssdchipseparation[0]+xmothervertex[0]; + ymothervertex[4] = ymothervertex[0]; + xmothervertex[5] = xmothervertex[4], ymothervertex[5] = -ymothervertex[4]; + xmothervertex[6] = (fgkSSDChipNumber-1)*ssdchipseparation[0] + + (0.5*fgkSSDChipLength-fgkSSDChipWidth); + ymothervertex[6] = ymothervertex[5]; + xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2] + - fgkSSDChipWidth; + xmothervertex[8] = -0.5*fgkSSDChipLength+fgkSSDChipWidth; + ymothervertex[8] = ymothervertex[7]; + xmothervertex[9] = -0.5*fgkSSDChipLength+fgkSSDChipWidth; + ymothervertex[9] = ymothervertex[6]; + xmothervertex[10] = -xmothervertex[0], ymothervertex[10] = ymothervertex[9]; + xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[0]; + ////////////////////////////////////////////////////////// + ssdchipmothershape->DefinePolygon(kssdmothervertexnumber, + xmothervertex,ymothervertex); + ssdchipmothershape->DefineSection(0,-0.5*fgkSSDChipHeight); + ssdchipmothershape->DefineSection(1, 0.5*fgkSSDChipHeight); + TGeoVolume* ssdchipmother = new TGeoVolume("SSDChipContainer", + ssdchipmothershape,fSSDAir); + ///////////////////////////////////////////////////////////// + for(Int_t i=0; iAddNode(ssdchip,fgkSSDChipNumber*i+j+1, + new TGeoTranslation(j*ssdchipseparation[0],i*ssdchipseparation[1],0.)); + return ssdchipmother; } -//////////////////////////////////////////////////////////////////////////////// -TGeoVolume* AliITSv11GeometrySSD::GetCoolingTube() const{ +///////////////////////////////////////////////////////////////////////////////// +TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){ ///////////////////////////////////////////////////////////// - // Method generating the Cooling Tube - ///////////////////////////////////////////////////////////// - TGeoVolume* coolingtubeassembly = new TGeoVolumeAssembly("CoolingTubeAssembly"); - TGeoTube *coolingtubeshape = new TGeoTube("CoolingTubeShape", fgkCoolingTubeRmin, - fgkCoolingTubeRmax, fgkCoolingTubeLength/2.0); - TGeoVolume* coolingtube = new TGeoVolume("CoolingTube", - coolingtubeshape,fSSDCoolingTubePhynox); - TGeoTube *coolingtubeinteriorshape = new TGeoTube("CoolingTubeInteriorShape", - 0, fgkCoolingTubeRmin, - fgkCoolingTubeLength/2.0); - TGeoVolume *coolingtubeinterior = new TGeoVolume("CoolingTubeInterior", - coolingtubeinteriorshape,fSSDCoolingTubeWater); - coolingtubeassembly->AddNode(coolingtube,1); - coolingtubeassembly->AddNode(coolingtubeinterior,2); - return coolingtubeassembly; -} -//////////////////////////////////////////////////////////////////////////////// -TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeAssembly(){ + // Method returning a List containing pointers to Ladder Cable Volumes ///////////////////////////////////////////////////////////// - // Method generating the Cooling Tube Assembly - ///////////////////////////////////////////////////////////// - TGeoVolume* coolingtubeassembly = new TGeoVolumeAssembly("CoolingTubeAssembly"); - TGeoVolume* coolingtube = GetCoolingTube(); - SetCoolingTubeCombiTransMatrix(); - for(Int_t i=0; iAddNode(coolingtube,i+1,fCoolingTubeTransMatrix[i]); - return coolingtubeassembly; + const Int_t kladdercablesegmentnumber = 2; + ///////////////////////////////////////// + // LadderSegmentBBox Volume + ///////////////////////////////////////// + TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber]; + const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] = + {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"}; + for(Int_t i=0; iSetLineColor(i==0 ? fColorAl : + fColorPolyhamide); + } + TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber]; + 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; iAddNode(laddercablesegmentbbox[i],1, + laddercablesegmentbboxtrans[i]); +///////////////////////////////////////// +// LadderSegmentArb8 Volume +///////////////////////////////////////// + const Int_t kvertexnumber = 4; + TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber]; + for(Int_t i = 0; iX(), + laddercablesegmentvertexposition[i][2]->Y()); + } + Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]}, + {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}}; + char* laddercablesegmentarbshapename[kladdercablesegmentnumber] = + {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"}; + TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber]; + for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] = + GetArbShape(laddercablesegmentvertexposition[i], + laddercablesegmentwidth[i], + fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0], + laddercablesegmentarbshapename[i]); + const char* laddercablesegmentarbname[kladdercablesegmentnumber] = + {"LadderCableSegmentArb1","LadderCableSegmentArb2"}; + TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber]; + for(Int_t i=0; iSetLineColor(i==0 ? fColorAl : + fColorPolyhamide); } -//////////////////////////////////////////////////////////////////////////////// -TGeoVolume* AliITSv11GeometrySSD::GetLadderSegment(Int_t iChipCablesHeight){ - ///////////////////////////////////////////////////////////// - // Method generating the basic Ladder Segment element which will be replicated - ///////////////////////////////////////////////////////////// - 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; iAddNode(laddersegmentvolumes[i],1, - fLadderSegmentCombiTransMatrix[i]); - return laddersegment; - } -//////////////////////////////////////////////////////////////////////////////// -TList* AliITSv11GeometrySSD::GetEndLadderSegment(){ + TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber]; + 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; iAddNode(laddercablesegmentarb[i],1, + laddercablesegmentarbcombitrans); +///////////////////////////////////////// +// End Ladder Cable Volume +///////////////////////////////////////// + TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber]; + const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] = + {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"}; + for(Int_t i=0; iSetLineColor(i==0 ? fColorAl : + fColorPolyhamide); + } + TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber]; + 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; iAddNode(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){ ///////////////////////////////////////////////////////////// - // Method generating the Terminal Ladder Segment - ///////////////////////////////////////////////////////////// - const Int_t kendladdersegmentnumber = 2; - TList* endladdercarbonfiberjunctionlist = GetEndLadderCarbonFiberJunctionAssembly(); - TGeoVolume* endladdersegment[kendladdersegmentnumber]; - endladdersegment[0] = new TGeoVolumeAssembly("EndLadderSegment1"); - endladdersegment[1] = new TGeoVolumeAssembly("EndLadderSegment2"); - TGeoVolume** laddersegmentvolumes[kendladdersegmentnumber]; - const Int_t kladdersegmentvolumenumber = 4; - for(Int_t i=0; iAt(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; iAddNode(laddersegmentvolumes[i][j],1, - fEndLadderSegmentCombiTransMatrix[j]); - endladdersegmentlist->Add(endladdersegment[i]); - } - return endladdersegmentlist; -} -//////////////////////////////////////////////////////////////////////////////// -TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){ + // Method generating Ladder Cable Volumes Assemblies ///////////////////////////////////////////////////////////// - // Method generating the Mounting Block - ///////////////////////////////////////////////////////////// - // Mounting Block Boxes Shapes - /////////////////////////////////////// - const Int_t kmountingblockboxnumber = 3; - TGeoBBox* mountingblockboxshape[kmountingblockboxnumber]; - 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[kmountingblockboxnumber+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; iRegisterYourself(); - /////////////////////////////////////// - // Mounting Block Trapezoid Hole Shapes - /////////////////////////////////////// - const Int_t kholetrapezoidvertexnumber = 4; - TVector3* holetrapezoidvertex[kholetrapezoidvertexnumber]; - 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}; - 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 kmountingblocktubenumber = 2; - TGeoTube* mountingblocktubeshape[kmountingblocktubenumber]; - 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*kmountingblocktubenumber]; - 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*kmountingblocktubenumber; i++) - mountingblocktubetrans[i]->RegisterYourself(); - new TGeoCompositeShape("MountingBlockMainShape", - "MountingBlockBoxShape0:MountingBlockBoxTrans0+" - "MountingBlockBoxShape1:MountingBlockBoxTrans1+" - "MountingBlockBoxShape2:MountingBlockBoxTrans2+" - "MountingBlockBoxShape1:MountingBlockBoxTrans3+" - "MountingBlockBoxShape0:MountingBlockBoxTrans4"); - //////////////////////////////////////////// - // Mounting Block Screw Composite Hole Shapes - //////////////////////////////////////////// - const Int_t kmountingblockholetubesegnumber = 4; - new TGeoTubeSeg("MountingBlockHoleTubeSegShape", - 0.0, - fgkSSDMountingBlockScrewHoleRadius[0], - 0.5*fgkSSDMountingBlockScrewHoleHeigth,-90.,180.); - TGeoCombiTrans* mountingblockholetubesegcombitrans[kmountingblockholetubesegnumber]; - char* mountingblockholetubesegcombitransname[kmountingblockholetubesegnumber] = - { "MountingBlockHoleTubeSegCombiTrans0", - "MountingBlockHoleTubeSegCombiTrans1", - "MountingBlockHoleTubeSegCombiTrans2", - "MountingBlockHoleTubeSegCombiTrans3"}; - for(Int_t i=0; iRegisterYourself(); + TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength); + TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable"); + for(Int_t i=0; iAddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans); + if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans); } - 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"); - new TGeoTubeSeg("MountingBlockLowerHoleTubeSegShape", - 0.0, - fgkSSDMountingBlockScrewHoleRadius[1], - 0.5*(fgkSSDMountingBlockHoleTubeWidth[0] - - fgkSSDMountingBlockScrewHoleHeigth - - fgkSSDMountingBlockHeight[3]),0.,90.); - TGeoCombiTrans* mountingblocklowerholetubesegcombitrans[kmountingblockholetubesegnumber]; - char* mountingblocklowerholetubesegcombitransname[kmountingblockholetubesegnumber] = - { "MountingBlockLowerHoleTubeSegCombiTrans0", - "MountingBlockLowerHoleTubeSegCombiTrans1", - "MountingBlockLowerHoleTubeSegCombiTrans2", - "MountingBlockLowerHoleTubeSegCombiTrans3"}; - for(Int_t i=0; iRegisterYourself(); + 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){ + ///////////////////////////////////////////////////////////// + // Method generating Ladder Cable Volumes Assembly + ///////////////////////////////////////////////////////////// + TGeoVolume* laddercableassembly = new TGeoVolumeAssembly("LadderCableAssembly"); + char laddercabletransname[30]; + for(Int_t i=0; iAddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1, + new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0.,0.)); } - 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[kmountingblockholetubesegnumber]; - char* mountingBlockLowerHoleBoxCombiTransName[kmountingblockholetubesegnumber] = - { "MountingBlockLowerHoleBoxCombiTrans0", - "MountingBlockLowerHoleBoxCombiTrans1", - "MountingBlockLowerHoleBoxCombiTrans2", - "MountingBlockLowerHoleBoxCombiTrans3"}; - for(Int_t i=0; iRegisterYourself(); + return laddercableassembly; +} +///////////////////////////////////////////////////////////////////////////////// +TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){ + ///////////////////////////////////////////////////////////// + // Method generating Ladder Cable List Assemblies + ///////////////////////////////////////////////////////////// + const Int_t kladdercableassemblynumber = 2; + TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength); + TGeoVolume* ladderCable[kladdercableassemblynumber]; + char laddercableassemblyname[30]; + TList* laddercableassemblylist = new TList(); + for(Int_t i=0; iAddNode(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; +} +/////////////////////////////////////////////////////////////////////////////// +void AliITSv11GeometrySSD::SetLadderSegment(){ + ///////////////////////////////////////////////////////////// + // Method Generating Ladder Segment Array + ///////////////////////////////////////////////////////////// + fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1"); + fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2"); + if(!fCreateMaterials) CreateMaterials(); + if(!fTransformationMatrices) CreateTransformationMatrices(); + if(!fBasicObjects) CreateBasicObjects(); + for(Int_t i=0; iAddNode(fcarbonfibersupport[0],j+1, + fcarbonfibersupportmatrix[j]); + fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1, + fcarbonfibersupportmatrix[j]); } - 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(); - 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,fSSDMountingBlockMedium); - return ssdmountingblock; + // Placing Carbon Fiber Junction + for(Int_t j=0; jAddNode(fcarbonfiberjunction,j+1, + fcarbonfiberjunctionmatrix[j]); + // Placing Carbon Fiber Lower Support + for(Int_t j=0; jAddNode(fcarbonfiberlowersupport[j],j+1, + fcarbonfiberlowersupportrans[j]); + // Placing SSD Sensor Support + for(Int_t j=0; jAddNode(j<2 ? fssdsensorsupport[0][i] : + fssdsensorsupport[1][i], + j+1,fssdsensorsupportmatrix[j]); + // Placing SSD Cooling Tube Support + for(Int_t j=0; jAddNode(fcoolingtubesupport,j+1, + fcoolingtubesupportmatrix[j]); + // Placing SSD Cooling Tube + for(Int_t j=0; j<2; j++) + for(Int_t k=0; k<2; k++){ + fladdersegment[i]->AddNode(fcoolingtube[0],2*j+k+1,fcoolingtubematrix[j][k]); + fladdersegment[i]->AddNode(fcoolingtube[j+1],k+1,fcoolingtubematrix[2+j][k]); + } + // Placing SSD Hybrid + switch(i){ + case 0: + fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix); + fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix); + break; + case 1: + fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix); + fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix); + break; + } + // Placing Cooling Block System + fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix); + // Placing SSD Flex + for(Int_t j=0; jAddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]); + fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]); + } + } } -//////////////////////////////////////////////////////////////////////////////// -TGeoVolume* AliITSv11GeometrySSD::GetLadder(Int_t iLayer){ +/////////////////////////////////////////////////////////////////////////////// +void AliITSv11GeometrySSD::SetEndLadderSegment(){ + ///////////////////////////////////////////////////////////// + // Method Generating End Ladder + ///////////////////////////////////////////////////////////// + // End Ladder Carbon Fiber Junction + ///////////////////////////////////////////////////////////// + fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1"); + fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2"); + if(!fCreateMaterials) CreateMaterials(); + if(!fTransformationMatrices) CreateTransformationMatrices(); + if(!fBasicObjects) CreateBasicObjects(); + for(Int_t i=0; iAddNode(j==2 ? + fendladdercarbonfiberjunction[i][1] : + fendladdercarbonfiberjunction[i][0], + j+1,fendladdercarbonfiberjunctionmatrix[i][j]); + } + ///////////////////////////////////////////////////////////// + // End Ladder Carbon Fiber Support + ///////////////////////////////////////////////////////////// + for(Int_t i=0; iAddNode(fcarbonfibersupport[0],j+1, + fendladdercarbonfibermatrix[i][j]); + fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1, + fendladdercarbonfibermatrix[i][j]); + } + ///////////////////////////////////////////////////////////// + // End Ladder Mounting Block + ///////////////////////////////////////////////////////////// + // for(Int_t i=0; iAddNode(fendladdermountingblock,1, + // fendladdermountingblocktrans[i]); + ///////////////////////////////////////////////////////////// + // End Ladder Lower Supports ///////////////////////////////////////////////////////////// - // Method generating the Layer5 or Layer6 Ladder + fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1, + fendladderlowersupptrans[0]); + fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2, + fendladderlowersupptrans[1]); + fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3, + fendladderlowersupptrans[2]); + //fendladdersegment[0]->CheckOverlaps(0.01); + //fendladdersegment[1]->CheckOverlaps(0.01); +} +/////////////////////////////////////////////////////////////////////////////// +void AliITSv11GeometrySSD::SetLadder(){ + ///////////////////////////////////////////////////////////// + // Method Generating Ladder of Layer 5 and 6 ///////////////////////////////////////////////////////////// - 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; iAddNode(i%2==0 ? - laddersegment[iLayer==5 ? 0 : 1] : - laddersegment[iLayer==5 ? 1 : 0], - ssdlaysensorsnumber-i-1,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.))); + Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber, + fgkSSDLay6SensorsNumber}; + ///////////////////////////////////////////////////////////////////////////// + /// Generating Ladder Mother Volume Containing Ladder + ///////////////////////////////////////////////////////////////////////////// + TGeoXtru* laddershape[fgkladdernumber]; + for(Int_t i=0; iDefinePolygon(kmothervertexnumber,xmothervertex[i], + ymothervertex[i]); + laddershape[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]); + laddershape[i]->DefineSection(1,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth + +fgkEndLadderCarbonFiberLowerJunctionLength[0]); + fladder[i] = new TGeoVolume(laddername[i],laddershape[i],fSSDAir); + } +/////////////////////////////////////////////////////////////////////////// + if(!fCreateMaterials) CreateMaterials(); + if(!fTransformationMatrices) CreateTransformationMatrices(); + if(!fBasicObjects) CreateBasicObjects(); + SetLadderSegment(); + SetEndLadderSegment(); + for(Int_t i=0; iAddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] : + fladdersegment[i==0 ? 1 : 0], + ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]); + ////////////////////////// + /// Placing SSD Sensor + ////////////////////////// + fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1, + fssdsensormatrix[i][j]); + } + /////////////////////////////// + /// Placing End Ladder Segment + /////////////////////////////// + fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]); + fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]); + } ///////////////////////////////////////////////////////////////////////////// /// 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 = - fLadderSegmentCombiTransMatrix[1]->GetTranslation(); + Int_t sidecablenumber[2][2]; + sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1; + sidecablenumber[0][1] = sidecablenumber[0][0]-2; + sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1; + sidecablenumber[1][1] = sidecablenumber[1][0]-1; + Double_t carbonfibertomoduleposition[3]; + carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength); + carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+ + fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth + + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth + - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength + - fgkSSDSensorCenterSupportThickness[0]); + carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor + + 0.5*fgkCoolingTubeSupportHeight + - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight); + const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned Double_t ssdendladdercablelength[4]; ssdendladdercablelength[0] = carbonfibertomoduleposition[1] + fgkSSDSensorLength - fgkSSDModuleStiffenerPosition[1] - fgkSSDStiffenerWidth - fgkSSDFlexWidth[0] - + fgkEndLadderCarbonFiberLowerJunctionLength[1]; + + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection; ssdendladdercablelength[1] = carbonfibertomoduleposition[1] + fgkSSDModuleStiffenerPosition[1] + fgkSSDStiffenerWidth - + fgkEndLadderCarbonFiberLowerJunctionLength[1]; + + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection; ssdendladdercablelength[2] = ssdendladdercablelength[1] - fgkEndLadderCarbonFiberLowerJunctionLength[1] - + fgkEndLadderCarbonFiberLowerJunctionLength[0]; + + fgkEndLadderCarbonFiberLowerJunctionLength[0] + - kendladdercablecorrection; ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength + carbonfibertomoduleposition[1] - fgkSSDModuleStiffenerPosition[1] - fgkSSDStiffenerWidth) - + fgkEndLadderCarbonFiberLowerJunctionLength[1]; + + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection; TList* laddercableassemblylist[4]; const Int_t kendladdercablesnumber = 4; - for(Int_t i=0; iAddNode((TGeoVolume*)laddercableassemblylist[i]->At(i%2==0?0:1), - i<2?1:2,fLadderCableCombiTransMatrix[i]); - } - return ladder; -} + for(Int_t i=0; iAddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1), + j<2?1:2,fladdercablematrix[i][j]); + } + //fladder[0]->CheckOverlaps(0.01); + //fladder[1]->CheckOverlaps(0.01); +} +//////////////////////////////////////////////////////////////////////////////// +void AliITSv11GeometrySSD::SetLayer(){ //////////////////////////////////////////////////////////////////////////////// -TGeoVolume* AliITSv11GeometrySSD::GetLayer(Int_t iLayer){ + // Creating Ladder of Layer 5 and Layer 6 + ///////////////////////////////////////////////////////////// + if(!fCreateMaterials) CreateMaterials(); + if(!fTransformationMatrices) CreateTransformationMatrices(); + if(!fBasicObjects) CreateBasicObjects(); + SetLadder(); // Generating the ladder of Layer5 and Layer6 + const Int_t kssdlayladdernumber[fgklayernumber] = + {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber}; + ///////////////////////////////////////////////////////////// + // Generating mother volumes for Layer5 and Layer6 + ///////////////////////////////////////////////////////////// + TGeoXtru* ssdladdermothershape = (TGeoXtru*)fladder[0]->GetShape(); + TGeoTube* ssdlayershape[fgklayernumber]; + ssdlayershape[0] = new TGeoTube(fgkSSDLay5RadiusMin,fgkSSDLay5RadiusMax + - ssdladdermothershape->GetY(0) + + TMath::Sqrt(TMath::Power(ssdladdermothershape->GetY(4),2.) + + TMath::Power(ssdladdermothershape->GetX(4),2.)), + 0.5*fgkSSDLay5LadderLength); + ssdlayershape[1] = new TGeoTube(fgkSSDLay6RadiusMin,fgkSSDLay6RadiusMax + - ssdladdermothershape->GetY(0) + + TMath::Sqrt(TMath::Power(ssdladdermothershape->GetY(4),2.) + + TMath::Power(ssdladdermothershape->GetX(4),2.)), + 0.5*fgkSSDLay6LadderLength); + fSSDLayer5 = new TGeoVolume("ITSssdLayer5",ssdlayershape[0],fSSDAir); + fSSDLayer6 = new TGeoVolume("ITSssdLayer6",ssdlayershape[1],fSSDAir); + ///////////////////////////////////////////////////////////// + Int_t *ladderindex[fgklayernumber]; + Int_t index[fgklayernumber] = {8,9}; + for(Int_t i=0; i=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ? + j+index[i] : j+index[i]-kssdlayladdernumber[i]; + i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) : + fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]); + } ///////////////////////////////////////////////////////////// - // Method generating the Layer5 or Layer6 - ///////////////////////////////////////////////////////////// - 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 - ///////////////////////////////////////////////////// - TGeoCombiTrans* lay5laddercombitrans[fgkSSDLay5LadderNumber]; - TGeoCombiTrans* lay6laddercombitrans[fgkSSDLay6LadderNumber]; - TGeoHMatrix* lay5ladderhmatrix[fgkSSDLay5LadderNumber]; - TGeoHMatrix* lay6ladderhmatrix[fgkSSDLay6LadderNumber]; - if(iLayer==5){ - Double_t lay5ladderangleposition = 360./fgkSSDLay5LadderNumber; - char lay5laddercombitransname[30], lay5ladderrotname[30]; - for(Int_t i=0; iAddNode(ladder,i,lay5ladderhmatrix[i]); - } - } - else{ - Double_t lay6ladderangleposition = 360./fgkSSDLay6LadderNumber; - char lay6laddercombitransname[30], lay6ladderrotname[30]; - for(Int_t i=0; iAddNode(ladder,i,lay6ladderhmatrix[i]); - } - } - return layer; + // Deallocating memory + ///////////////////////////////////////////////////////////// + for(Int_t i=0; iAddNode(GetLayer(5),1,0); + if(!fSSDLayer5) SetLayer(); + fMotherVol = moth; + TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength + + fgkLay5CenterITSPosition); + moth->AddNode(fSSDLayer5,1,centerITSlayer5trans); } //////////////////////////////////////////////////////////////////////////////// void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ @@ -3278,35 +3840,13 @@ void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){ printf("Error::AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n"); return; }; - fMotherVol = moth; - moth->AddNode(GetLayer(6),1,0); + if(!fSSDLayer6) SetLayer(); + fMotherVol = moth; + TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength + + fgkLay6CenterITSPosition); + moth->AddNode(fSSDLayer6,1,centerITSlayer6trans); } -//////////////////////////////////////////////////////////////////////////////// -TGeoArb8* AliITSv11GeometrySSD::GetTrapezoidShape(TVector3* vertexpos[], - Double_t* width, Double_t height, char* shapename) const{ - ///////////////////////////////////////////////////////////// - // Method generating a trapezoid shape - ///////////////////////////////////////////////////////////// - const Int_t kvertexnumber = 4; - const Int_t ktransvectnumber = 2; - TVector3* vertex[kvertexnumber]; - TVector3* transvector[2]; - for(Int_t i=0; iSetVertex(i,vertex[(iX(), - vertex[(iY()); - return trapezoidshape; -} -//////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width, Double_t height, char* shapename, Int_t isign) const{ ///////////////////////////////////////////////////////////// @@ -3332,26 +3872,62 @@ TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* wid TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height); for(Int_t i = 0; iSetVertex(i,vertex[i]->X(),vertex[i]->Y()); + ///////////////////////////////////////////////////////////// + // Deallocating memory + ///////////////////////////////////////////////////////////// + for(Int_t i=0; i< kvertexnumber; i++) delete vertex[i]; + for(Int_t i=0; i< ktransvectnumber; i++) delete transvector[i]; + ///////////////////////////////////////////////////////////// return arbshape; } -//////////////////////////////////////////////////////////////////////////////// -TGeoArb8* AliITSv11GeometrySSD::GetTriangleShape(TVector3* vertexpos[], - Double_t height, char* shapename) const{ +/////////////////////////////////////////////////////////////////////////////// +TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin, + Double_t rmax, Int_t nedges, Double_t height){ + ///////////////////////////////////////////////////////////// + // Method generating Arc shape + ///////////////////////////////////////////////////////////// + const Int_t kvertexnumber = 2*nedges+2; + TGeoXtru* arcshape = new TGeoXtru(2); + TVector3** vertexposition[2]; + for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1]; + Double_t angle = 0.; + for(Int_t i=0; iX(), + yvertexpoints[i] = vertexposition[0][i]->Y(); + } + else if(i>=1&&iX(); + yvertexpoints[i] = vertexposition[1][i-1]->Y(); + } + else + { + xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X(); + yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y(); + } + } + arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints); + arcshape->DefineSection(0,-0.5*height); + arcshape->DefineSection(1,0.5*height); ///////////////////////////////////////////////////////////// - // Method generating a triangle shape + // Deallocating memory ///////////////////////////////////////////////////////////// - const Int_t kvertexnumber = 4; - TVector3* vertex[kvertexnumber]; -////////////////////////////////////// - //Setting the vertices for TGeoArb8 - //////////////////////////////////// - for(Int_t i = 0; iSetVertex(i,vertex[(i < kvertexnumber ? i: i-kvertexnumber)]->X(), - vertex[(i < kvertexnumber ? i : i-kvertexnumber)]->Y()); - return triangleshape; + for(Int_t i=0; i<2; i++){ + for(Int_t j=0; jMag2(); TVector3* reflectedvector = new TVector3(*vector-2*d*(*n)); + ///////////////////////////////////////////////////////////// + // Deallocating memory + ///////////////////////////////////////////////////////////// + delete n; + ///////////////////////////////////////////////////////////// return reflectedvector; } //////////////////////////////////////////////////////////////////////////////// -TGeoCombiTrans* AliITSv11GeometrySSD::AddTranslationToCombiTrans(TGeoCombiTrans* ct, +TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(TGeoHMatrix* ct, Double_t dx, Double_t dy, Double_t dz) const{ ///////////////////////////////////////////////////////////// // Add a dx,dy,dz translation to the initial TGeoCombiTrans ///////////////////////////////////////////////////////////// - TGeoCombiTrans* combiTrans = new TGeoCombiTrans(*ct); - const Double_t *vect = combiTrans->GetTranslation(); + TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct); + const Double_t *vect = hmatrix->GetTranslation(); Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz}; - combiTrans->SetTranslation(newvect); - return combiTrans; + hmatrix->SetTranslation(newvect); + TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix); + delete hmatrix; + return matrix; } //////////////////////////////////////////////////////////////////////////////// TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) { @@ -3391,125 +3974,6 @@ TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* 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); - fSSDSensorMedium = Silicon; - /////////////////////////////////// - // Silicon Mixture for Sensor - /////////////////////////////////// - Int_t SiMixtureNumber = 1; - TGeoMaterial* SiMixtureMaterial = new TGeoMaterial("SiMixtureMaterial"); - TGeoMedium* SiliconMixture = new TGeoMedium("SiliconMixture",SiMixtureNumber,SiMixtureMaterial); - fSSDChipMedium = SiliconMixture; - /////////////////////////////////// - // Stiffener Components Materials - /////////////////////////////////// - Int_t K1100Number = 2; - TGeoMaterial* K1100Material = new TGeoMaterial("K1100Material"); - TGeoMedium* K1100 = new TGeoMedium("K1100",K1100Number,K1100Material); - fSSDStiffenerMedium = K1100; - /////////////////////////// - // Stiffener Connectors - /////////////////////////// - Int_t SnMaterialNumber = 3; - TGeoMaterial* SnMaterial = new TGeoMaterial("SnMaterial"); - TGeoMedium* SnMedium = new TGeoMedium("SnMedium",SnMaterialNumber, - SnMaterial); - fSSDStiffenerConnectorMedium = SnMedium; - //////////////////////////////// - // Stiffener 0603-1812 Capacitor - //////////////////////////////// - Int_t Al2O3Number = 4; - TGeoMaterial* Al2O3Material = new TGeoMaterial("Al2O3Material"); - TGeoMedium* Al2O3Medium = new TGeoMedium("Al2O3Medium", - Al2O3Number, - Al2O3Material); - fSSDStiffener0603CapacitorMedium = Al2O3Medium; - fSSDStiffener1812CapacitorMedium = Al2O3Medium; - /////////////////////////// - // Stiffener Hybrid Wire - /////////////////////////// - Int_t CuHybridWireNumber = 5; - TGeoMaterial* CuHybridWireMaterial = new TGeoMaterial("CuHybridWireMaterial"); - TGeoMedium* CuHybridWireMedium = new TGeoMedium("CuHybridWireMedium", - CuHybridWireNumber, - CuHybridWireMaterial); - fSSDStiffenerHybridWireMedium = CuHybridWireMedium; - /////////////////////////// - // Al for Cooling Block - /////////////////////////// - Int_t AlCoolBlockNumber = 6; - TGeoMaterial* AlCoolBlockMaterial = new TGeoMaterial("AlCoolBlockMaterial"); - TGeoMedium* AlCoolBlockMedium = new TGeoMedium("AlCoolBlockMedium", - AlCoolBlockNumber, - AlCoolBlockMaterial); - fSSDAlCoolBlockMedium = 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); - fSSDKaptonChipCableMedium = KaptonMedium; - fSSDAlTraceChipCableMedium = AlTraceMedium; - fSSDKaptonFlexMedium = KaptonMedium; - fSSDAlTraceFlexMedium = AlTraceMedium; - fSSDKaptonLadderCableMedium = KaptonMedium; - fSSDAlTraceLadderCableMedium = 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); - fSSDCarbonFiberMedium = M55JMedium; - fSSDMountingBlockMedium = M55JMedium; - ///////////////////////////////////////////////////////////////// - // G10 for Detector Leg, TubeHolder - ////////////////////////////////////////////////////////////////// - Int_t G10Number = 10; - TGeoMaterial* G10Material = new TGeoMaterial("G10Material"); - TGeoMedium* G10Medium = new TGeoMedium("G10Medium",G10Number, - G10Material); - fSSDTubeHolderMedium = G10Medium; - fSSDSensorSupportMedium = G10Medium; - ///////////////////////////////////////////////////////////////// - // Water and Phynox for Cooling Tube - ////////////////////////////////////////////////////////////////// - Int_t WaterNumber = 11; - TGeoMaterial* WaterMaterial = new TGeoMaterial("WaterMaterial"); - TGeoMedium* WaterMedium = new TGeoMedium("WaterMedium",WaterNumber, - WaterMaterial); - fSSDCoolingTubeWater = WaterMedium; - Int_t PhynoxNumber = 12; - TGeoMaterial* PhynoxMaterial = new TGeoMaterial("PhynoxMaterial"); - TGeoMedium* PhynoxMedium = new TGeoMedium("PhynoxMedium",PhynoxNumber, - PhynoxMaterial); - fSSDCoolingTubePhynox = PhynoxMedium; -} -*/ void AliITSv11GeometrySSD::CreateMaterials(){ /////////////////////////////////// // This part has to be modified @@ -3517,7 +3981,7 @@ void AliITSv11GeometrySSD::CreateMaterials(){ /////////////////////////////////// // Silicon for Sensor /////////////////////////////////// - fSSDSensorMedium = GetMedium("Si"); + fSSDSensorMedium = GetMedium("SI$"); /////////////////////////////////// // Silicon Mixture for Sensor /////////////////////////////////// @@ -3526,33 +3990,33 @@ void AliITSv11GeometrySSD::CreateMaterials(){ /////////////////////////////////// // Stiffener Components Materials /////////////////////////////////// - fSSDStiffenerMedium = GetMedium("ITSsddCarbonM55J"); + fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$"); /////////////////////////// // Stiffener Connectors /////////////////////////// - fSSDStiffenerConnectorMedium = GetMedium("COPPER"); + fSSDStiffenerConnectorMedium = GetMedium("COPPER$"); //////////////////////////////// // Stiffener 0603-1812 Capacitor //////////////////////////////// - fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3"); - fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3"); + fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$"); + fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$"); /////////////////////////// // Stiffener Hybrid Wire /////////////////////////// - fSSDStiffenerHybridWireMedium = GetMedium("COPPER"); + fSSDStiffenerHybridWireMedium = GetMedium("COPPER$"); /////////////////////////// // Al for Cooling Block /////////////////////////// - fSSDAlCoolBlockMedium = GetMedium("ITSal"); + fSSDAlCoolBlockMedium = GetMedium("AL$"); ////////////////////////////////////////////////////// // Kapton and Al for Chip Cable Flex and Ladder Cables ////////////////////////////////////////////////////// - fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)"); - fSSDAlTraceChipCableMedium = GetMedium("ITSal"); - fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)"); - fSSDAlTraceFlexMedium = GetMedium("ITSal"); - fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)"); - fSSDAlTraceLadderCableMedium = GetMedium("ITSal"); + fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$"); + fSSDAlTraceChipCableMedium = GetMedium("AL$"); + fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$"); + fSSDAlTraceFlexMedium = GetMedium("AL$"); + fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$"); + fSSDAlTraceLadderCableMedium = GetMedium("AL$"); ///////////////////////////////////////////////////////////////// // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction ////////////////////////////////////////////////////////////////// @@ -3567,8 +4031,10 @@ void AliITSv11GeometrySSD::CreateMaterials(){ ///////////////////////////////////////////////////////////////// // Water and Phynox for Cooling Tube ////////////////////////////////////////////////////////////////// - fSSDCoolingTubeWater = GetMedium("WATER"); + fSSDCoolingTubeWater = GetMedium("WATER$"); fSSDCoolingTubePhynox = GetMedium("INOX$"); + ///////////////////////////////////////////////////////////////////// + fSSDAir = GetMedium("SDD AIR$"); + fCreateMaterials = kTRUE; } ///////////////////////////////////////////////////////////////////// - diff --git a/ITS/AliITSv11GeometrySSD.h b/ITS/AliITSv11GeometrySSD.h index e184fc1555f..babbb2b9e3b 100644 --- a/ITS/AliITSv11GeometrySSD.h +++ b/ITS/AliITSv11GeometrySSD.h @@ -14,6 +14,9 @@ class TGeoArb8; class TList; class TGeoTube; class TGeoHMatrix; +class TGeoTranslation; +class TGeoXtru; +class TGeoVolumeAssembly; #include "AliITSv11Geometry.h" class AliITSv11GeometrySSD: public AliITSv11Geometry { public: @@ -24,144 +27,28 @@ public: ///////////////////////////////////////////////////////////////////////// // Public methods ///////////////////////////////////////////////////////////////////////// - const char* GetSensitiveVolumeName() const {return fgkSSDSensitiveVolName;}; - // Method returning the name of the sensitive part of detector - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetSSDSensorSupportShape(Double_t length,Double_t height, - Double_t width,Double_t* thickness); - // Method returning the name of the sensitive part of detector - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetSSDSensorSupport(Int_t VolumeKind,Int_t n); - // Method returning the SSD Sensor Support - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetSSDSensorSupportAssembly(Int_t n); - // Method returning the SSD Sensor Support Assembly - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetSSDSensor(); - // Method returning the SSD Sensor - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetSSDChipAssembly() const; - // Method returning the SSD Chip Assembly - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetSSDChipCables(Double_t ssdchipcablesheigth,char* side); - // Method returning the SSD Chip Cables - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetSSDChipCablesAssembly(Double_t ssdchipcablesheigth); - // Method returning the SSD Chip Cables Assembly - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetSSDStiffenerAssembly(); - // Method returning the SSD Stiffener Assembly - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetSSDFlex(Double_t ssdflexradius, Double_t ssdflexheigth); - // Method returning the SSD Flex - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetSSDEndFlex(Double_t ssdendflexlength,Double_t ssdflexheigth); - // Method returning the SSD End Flex - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetSSDFlexAssembly(); - // Method returning the SSD Flex Assembly - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetSSDCoolingBlock(); - // Method returning the SSD Cooling Block - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetSSDCoolingBlockAssembly(); - // Method returning the SSD Cooling Block Assembly - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetSSDModule(Int_t ichipcablesheight); - // Method returning the SSD Module - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetCarbonFiberJunction(Double_t width); - // Method returning the Carbon Fiber Junction - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetCarbonFiberJunctionAssembly(); - // Method returning the Carbon Fiber Junction Assembly - ///////////////////////////////////////////////////////////////////////// - TList* GetLadderCableSegment(Double_t ssdendladdercablelength); - // Method returning a List containing pointers to Ladder Cable Volumes - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetLadderCable(Int_t n,Double_t ssdendladdercablelength); - // Method generating Ladder Cable Volumes Assemblies - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetLadderCableAssembly(Int_t n,Double_t ssdendladdercablelength); - // Method generating Ladder Cable Volumes Assembly - ///////////////////////////////////////////////////////////////////////// - TList* GetLadderCableAssemblyList(Int_t n,Double_t ssdendladdercablelength); - // Method generating Ladder Cable List Assemblies - ///////////////////////////////////////////////////////////////////////// - TList* GetEndLadderCarbonFiberJunctionAssembly(); - // Method generating the End Ladder Carbon Fiber Junction Assembly - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetCarbonFiberSupport(); - // Method generating the Carbon Fiber Support - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetCarbonFiberLowerSupport(Int_t i=0,Bool_t endladder = false); - // Method generating the Carbon Fiber Lower Support - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetCarbonFiberAssemblySupport(); - // Method generating the Carbon Fiber Assembly Support - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetCoolingTubeSupport(); - // Method generating the Cooling Tube Support - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetCoolingTubeSupportAssembly(); - // Method generating the Cooling Tube Support Assembly - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetCoolingTube() const; - // Method generating the Cooling Tube - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetCoolingTubeAssembly(); - // Method generating the Cooling Tube Assembly - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetLadderSegment(Int_t iChipCablesHeight); - // Method generating the basic Ladder Segment element which will be replicated - ///////////////////////////////////////////////////////////////////////// - TList* GetEndLadderSegment(); - // Method generating the Terminal Ladder Segment - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetSSDMountingBlock(); - // Method generating the Terminal Ladder Mounting Block - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetLadder(Int_t iLayer); - // Method generating the Layer5 or Layer6 Ladder - ///////////////////////////////////////////////////////////////////////// - TGeoVolume* GetLayer(Int_t iLayer); - // Method generating the Layer5 or Layer6 - ///////////////////////////////////////////////////////////////////////// - void Layer5(TGeoVolume* mothervolume); - // Method placing the Layer5 within mother volume - ///////////////////////////////////////////////////////////////////////// - void Layer6(TGeoVolume* mothervolume); - // Method placing the Layer6 within mother volume - ///////////////////////////////////////////////////////////////////////// - //Auxiliary methods for shapes building - ///////////////////////////////////////////////////////////////////////// - TVector3* GetReflection(TVector3* vector,Double_t* param) const; - // Given an axis specified by param, it gives the reflection of the point - // respect to the axis - ///////////////////////////////////////////////////////////////////////// - TGeoArb8* GetArbShape(TVector3* vertexpos[],Double_t* width, - Double_t height,char* shapename,Int_t isign = 1) const; - // Method generating an arb shape - ///////////////////////////////////////////////////////////////////////// - TGeoArb8* GetTriangleShape(TVector3* vertexpos[],Double_t height, char* shapename) const; - // Method generating a triangle shape - ///////////////////////////////////////////////////////////////////////// - TGeoArb8* GetTrapezoidShape(TVector3* vertexpos[],Double_t* width, - Double_t height,char* shapename) const; - // Method generating a trapezoid shape - ///////////////////////////////////////////////////////////////////////// - TGeoCombiTrans* AddTranslationToCombiTrans(TGeoCombiTrans* ct,Double_t dx, - Double_t dy,Double_t dz) const; - // add (dx,dy,dz) translation to a initial TGeoCombiTrans - ///////////////////////////////////////////////////////////////////////// - //Auxiliary methods for material building - ///////////////////////////////////////////////////////////////////////// TGeoMedium* GetMedium(const char* mediumName); // It returns the Medium - ///////////////////////////////////////////////////////////////////////// - void CreateMaterials(); - // it creates the matherials + const char* GetSenstiveVolumeName5() const {return fgSDDsensitiveVolName5;}; + // it returns the Sensitive Volume of Layer 5 + const char* GetSenstiveVolumeName6() const {return fgSDDsensitiveVolName6;}; + // it returns the Sensitive Volume of Layer 6 + TGeoVolumeAssembly* GetLadderSegment(Int_t i){return fladdersegment[i];}; // Get Ladder Segment + TGeoVolumeAssembly* GetEndLadderSegment(Int_t i){return fendladdersegment[i];}; // Get End Ladder Segment + TGeoVolume* GetLadder(Int_t i) {return fladder[i];}; // Get Ladder + TGeoVolume* GetLayer(Int_t i)const {return i==5? fSSDLayer5 : fSSDLayer6;}; // Get Layer + void SetLadderSegment(); // Set Ladder Elementary Segment + void SetEndLadderSegment(); // Set End Ladder Segment + void SetLadder(); // Set Ladder + void SetLayer(); // Set Layer + void Layer5(TGeoVolume* moth); // Setting Layer 5 into mother volume + void Layer6(TGeoVolume* moth); // Setting Layer 6 into mother volume private: + ///////////////////////////////////////////////////////////////////////////////// + // Names of the Sensitive Volumes of Layer 5 and Layer 6 + ///////////////////////////////////////////////////////////////////////////////// + static const char* fgSDDsensitiveVolName5; // sens. vol. name for lay. 5 + static const char* fgSDDsensitiveVolName6; // sens. vol. name for lay. 6 ///////////////////////////////////////////////////////////////////////// // Layer5 (lengths are in mm and angles in degrees) ///////////////////////////////////////////////////////////////////////// @@ -193,8 +80,6 @@ private: static const Double_t fgkSSDChipGlueLength; // SSD Module Chip Glue Layer Length static const Double_t fgkSSDChipGlueWidth; // SSD Module Chip Glue Layer Width static const Double_t fgkSSDChipGlueHeight; // SSD Module Chip Glue Layer Height - TGeoMedium* fSSDChipMedium; // SSD Module Chip Medium - TGeoMedium* fSSDChipGlueMedium; // SSD Module Chip Glue Layer Medium ///////////////////////////////////////////////////////////////////////// // Stiffener Components ///////////////////////////////////////////////////////////////////////// @@ -216,11 +101,8 @@ private: static const Double_t fgkSSDConnectorLength; // SSD Stiffener Connector Length static const Double_t fgkSSDConnectorWidth; // SSD Stiffener Connector Width static const Double_t fgkSSDConnectorHeight; // SSD Stiffener Connector Height - TGeoMedium* fSSDStiffenerMedium; // SSDStiffener Medium - TGeoMedium* fSSDStiffenerConnectorMedium; // SSD Stiffener Connector Medium - TGeoMedium* fSSDStiffener0603CapacitorMedium; // SSD Stiffener Capacitor 0603 Medium - TGeoMedium* fSSDStiffener1812CapacitorMedium; // SSD Stiffener Capacitor 1812 Medium - TGeoMedium* fSSDStiffenerHybridWireMedium; // SSD Stiffener Wire Medium + static const Double_t fgkSSDConnectorAlHeight; // SSD Stiffener Connector Al Height + static const Double_t fgkSSDConnectorNiHeight; // SSD Stiffener Connector Ni Height ///////////////////////////////////////////////////////////////////////// // Flex ///////////////////////////////////////////////////////////////////////// @@ -233,14 +115,10 @@ private: static const Double_t fgkSSDFlexHoleWidth; // SSD Flex Hole Width static const Double_t fgkSSDEndFlexCompLength[6];// SSD End-Flex Components Length static const Double_t fgkSSDEndFlexCompWidth[3]; // SSD End-Flex Components Width - TGeoMedium* fSSDKaptonFlexMedium; // SSD Flex Kapton Layer Medium - TGeoMedium* fSSDAlTraceFlexMedium; // SSD Flex Al Layer Medium ///////////////////////////////////////////////////////////////////////////////// // SSD Ladder Cable ///////////////////////////////////////////////////////////////////////////////// static const Double_t fgkSSDLadderCableWidth; // SSD Ladder Cable Width - TGeoMedium* fSSDAlTraceLadderCableMedium; // SSD Ladder Cable Al Layer Medium - TGeoMedium* fSSDKaptonLadderCableMedium; // SSD Ladder Cable Kapton Layer Medium ///////////////////////////////////////////////////////////////////////// // SSD Module Components ///////////////////////////////////////////////////////////////////////// @@ -250,20 +128,12 @@ private: // respect to Sensor Edge static const Double_t fgkSSDModuleCoolingBlockToSensor; // SSD Cooling Block Position // respect to sensor - static const Int_t fgkSSDModuleCombiTransNumber = 7; // Number of TGeoCombiTrans - // for positioning volumes in SSD Module - void SetSSDModuleCombiTransMatrix(Double_t); // Method for generating TGeoCombiTrans for - // for volume positioning in SSD Module - TGeoCombiTrans *fSSDModuleCombiTransMatrix[fgkSSDModuleCombiTransNumber]; // TGeoCombiTrans roto-trans - // transformations for volume positioning ///////////////////////////////////////////////////////////////////////// // Chip Cables ///////////////////////////////////////////////////////////////////////// static const Double_t fgkSSDChipCablesLength[2]; // SSD Chip Cables Components Length static const Double_t fgkSSDChipCablesHeight[4]; // SSD Chip Cables Components Height static const Double_t fgkSSDChipCablesWidth[3]; // SSD Chip Cables Components Width - TGeoMedium* fSSDKaptonChipCableMedium; // SSD Chip Cables Kapton Layer Medium - TGeoMedium* fSSDAlTraceChipCableMedium; // SSD Chip Cables Al Layer Medium ///////////////////////////////////////////////////////////////////////// // Cooling Block ///////////////////////////////////////////////////////////////////////// @@ -274,7 +144,6 @@ private: static const Double_t fgkSSDCoolingBlockHoleLength[2];// SSD Cooling Block Hole Length static const Double_t fgkSSDCoolingBlockHoleCenter; // SSD Cooling Block Hole Ceneter Position static const Double_t fgkSSDCoolingBlockHoleHeight; // SSD Cooling Block Hole Height - TGeoMedium* fSSDAlCoolBlockMedium; // SSD Cooling Block Al Medium ///////////////////////////////////////////////////////////////////////// // SSD Sensor ///////////////////////////////////////////////////////////////////////// @@ -285,7 +154,6 @@ private: static const Double_t fgkSSDSensorOverlap; // SSD Sensor Beam Axis Overlap static const Double_t fgkSSDSensorInsensitiveLength; // SSD Insensitive Part Length static const Double_t fgkSSDSensorInsensitiveWidth; // SSD Insensitive Part Width - TGeoMedium* fSSDSensorMedium; // SSD Sensor Medium ///////////////////////////////////////////////////////////////////////// // SSD Sensor Support ///////////////////////////////////////////////////////////////////////// @@ -301,11 +169,6 @@ private: static const Double_t fgkSSDSensorCenterSupportPosition; // SSD Center Sensor Support Position static const Int_t fgkSSDSensorSupportCombiTransNumber = 3; // Number of TGeoCombiTrans // for positioning volumes in Sensor Support Assembly - void SetSSDSensorSupportCombiTransMatrix(); // Method for generating TGeoCombiTrans for - // volume positioning in Sensor Support Assembly - TGeoCombiTrans *fSSDSensorSupportCombiTransMatrix[fgkSSDSensorSupportCombiTransNumber]; // TGeoCombiTrans roto-trans - // transformations for volume positioning in Sensor Support Assembly - TGeoMedium* fSSDSensorSupportMedium; // SSD Sensor Support Medium ///////////////////////////////////////////////////////////////////////// //Parameters for Carbon Fiber ///////////////////////////////////////////////////////////////////////// @@ -318,11 +181,6 @@ private: static const Double_t fgkCarbonFiberSupportYAxisLength; // Carbon Fiber Support Y Axis Lenght static const Int_t fgkCarbonFiberAssemblyCombiTransNumber = 3; // Number of TGeoCombiTrans // for positioning volumes in Carbon Fiber Assembly - void SetCarbonFiberAssemblyCombiTransMatrix(); // Method for generating TGeoCombiTrans for - // volume positioning in Carbon Fiber Assembly - TGeoCombiTrans *fCarbonFiberAssemblyCombiTransMatrix[fgkCarbonFiberAssemblyCombiTransNumber]; // TGeoCombiTrans roto-trans - // transformations for volume positioning in Carbon Fiber Assembly - TGeoMedium* fSSDCarbonFiberMedium; // SSD Carbon Fiber Medium ////////////////////////////////////////////////////////////////////////////// // Carbon Fiber Junction Parameters ////////////////////////////////////////////////////////////////////////////// @@ -331,12 +189,6 @@ private: static const Double_t fgkCarbonFiberJunctionEdge[2]; // Carbon Fiber Junction Edge Length static const Double_t fgkCarbonFiberJunctionAngle[2]; // Carbon Fiber Junction Angle static const Double_t fgkCarbonFiberJunctionToSensorSupport; // Carbon Fiber Junction position respect to sensor - static const Int_t fgkCarbonFiberJunctionCombiTransNumber = 3; // Number of TGeoCombiTrans - // for positioning volumes in Carbon Fiber Junction Assembly - void SetCarbonFiberJunctionCombiTransMatrix(); // Method for generating TGeoCombiTrans for - // volume positioning in Carbon Fiber Junction Assembly - TGeoCombiTrans *fCarbonFiberJunctionCombiTransMatrix[fgkCarbonFiberJunctionCombiTransNumber];// TGeoCombiTrans roto-trans - // transformations for volume positioning in Carbon Fiber Junction Assembly ///////////////////////////////////////////////////////////////////////// //Parameters for Carbon Fiber Lower Support (lengths are in mm) ///////////////////////////////////////////////////////////////////////// @@ -352,13 +204,6 @@ private: static const Double_t fgkEndLadderCarbonFiberLowerJunctionLength[2]; // End Ladder Carbon Fiber Lower Up Support length static const Double_t fgkEndLadderCarbonFiberUpperJunctionLength[2]; // End Ladder Carbon Fiber Lower Down Support length static const Double_t fgkEndLadderMountingBlockPosition[2]; // End Ladder Mounting Block Position - static const Int_t fgkEndLadderCarbonFiberJunctionCombiTransNumber = 3;// Number of TGeoCombiTrans - // for positioning volumes in End LadderCarbon Fiber Junction Assembly - void SetEndLadderCarbonFiberJunctionCombiTransMatrix(Int_t); // Method for generating TGeoCombiTrans for - // volume positioning in End Ladder Carbon Fiber Junction Assembly - TGeoCombiTrans *fEndLadderCarbonFiberJunctionCombiTransMatrix[fgkEndLadderCarbonFiberJunctionCombiTransNumber]; // TGeoCombiTrans roto-trans - // transformations for volume positioning in End Ladder - // Carbon Fiber Junction Assembly ///////////////////////////////////////////////////////////////////////// // Cooling Tube Support (lengths are in mm and angles in degrees) ///////////////////////////////////////////////////////////////////////// @@ -369,14 +214,6 @@ private: static const Double_t fgkCoolingTubeSupportWidth; // Cooling Tube Support Width static const Double_t fgkCoolingTubeSupportSeparation; // Cooling Tube Support Separation static const Double_t fgkCoolingTubeSupportToCarbonFiber; // Cooling Tube Support position respect to Carbon Fiber - static const Int_t fgkCoolingTubeSupportCombiTransNumber = 2; // Number of TGeoCombiTrans - // for positioning volumes in Cooling Tube Support Assembly - void SetCoolingTubeSupportCombiTransMatrix(); // Method for generating TGeoCombiTrans for - // volume positioning in Cooling Tube Support Assembly - TGeoCombiTrans *fCoolingTubeSupportCombiTransMatrix[fgkCoolingTubeSupportCombiTransNumber]; // TGeoCombiTrans roto-trans - // transformations for volume positioning in - // Cooling Tube Support Assembly - TGeoMedium* fSSDTubeHolderMedium; // Cooling Tube Support Medium ///////////////////////////////////////////////////////////////////////////////// // Cooling Tube (lengths are in mm and angles in degrees) ///////////////////////////////////////////////////////////////////////////////// @@ -384,14 +221,6 @@ private: static const Double_t fgkCoolingTubeRmin; // Cooling Tube Min Radius static const Double_t fgkCoolingTubeLength; // Cooling Tube Length static const Double_t fgkCoolingTubeSeparation; // Cooling Tube Separation - static const Int_t fgkCoolingTubeCombiTransNumber = 2; // Number of TGeoCombiTrans - // for positioning volumes in Cooling Tube Assembly - void SetCoolingTubeCombiTransMatrix(); // Method for generating TGeoCombiTrans for - // volume positioning in Cooling Tube Assembly - TGeoCombiTrans *fCoolingTubeTransMatrix[fgkCoolingTubeCombiTransNumber];// TGeoCombiTrans roto-trans - // transformations for volume positioning Cooling Tube Assembly - TGeoMedium* fSSDCoolingTubeWater; // Medium for Inner Part of Cooling Tube - TGeoMedium* fSSDCoolingTubePhynox; // Medium for Cooling Tube ///////////////////////////////////////////////////////////////////////// // SSD Mounting Block Parameters (lengths are in mm and angles in degrees) ///////////////////////////////////////////////////////////////////////// @@ -407,36 +236,205 @@ private: static const Double_t fgkSSDMountingBlockScrewHoleEdge; // SSD Mounting Block Screw Hole Edge static const Double_t fgkSSDMountingBlockScrewHoleHeigth; // SSD Mounting Block Screw Hole Height static const Double_t fgkSSDMountingBlockScrewHoleRadius[2]; // SSD Mounting Block Screw Hole Radii - TGeoMedium* fSSDMountingBlockMedium; // Medium for SSD Mounting Block ///////////////////////////////////////////////////////////////////////// - // LadderSegment + // Private methods for private members generation + ///////////////////////////////////////////////////////////////////////// + void CreateMaterials(); // Method setting the materials + void CreateTransformationMatrices(); // Method setting the transformation matrices + void CreateBasicObjects(); // Method creating the basic objects of ssd geometry + void SetSSDSensor(); // Method setting the SSD Layer 5 and 6 sensors + TList* GetCarbonFiberSupportList(); // Method generating CarbonFiberSupport + TGeoVolume* GetCarbonFiberJunction(Double_t width); // Method generating + // CarbonFiberJunction + TList* GetCarbonFiberLowerSupportList(); + // Method generating CarbonFiberLowerSupport + TGeoVolume* GetSSDSensorSupport(Double_t length, Double_t height, + Double_t width, Double_t* thickness) const; // + // Method generating SSDSensorSupport + TGeoVolume* GetCoolingTubeSupport(Int_t nedges); // Method generating CoolingTubeSupport + TList* GetSSDHybridParts(); // Method setting Hybrid Components + TGeoVolume* GetCoolingBlockSystem(); // Method generating Cooling Block System + TGeoVolume* GetSSDStiffenerFlex()const; // Method generating StiffenerFlex + TGeoVolume* GetSSDEndFlex(); // Method generating EndFlex + TGeoVolume* GetSSDMountingBlock(); // Method generating Mounting Block + TList* GetCoolingTubeList()const; // Method generating list of Tubes + TGeoVolume* GetSSDCoolingBlock(Int_t nedges); + // Method generating StiffenerFlex + TGeoVolume* GetSSDChipCables(Double_t SSDChipCablesHeigth, Int_t nedges); + // Method setting ChipCables + TList* GetSSDChipSystem(); // Method setting Chip System + TGeoVolume* GetSSDChips() const; // Method generating Chips + TList* GetLadderCableSegment(Double_t ssdendladdercablelength); + // Method generating LadderCableSegment + TGeoVolume* GetLadderCable(Int_t n, Double_t ssdendladdercablelength); + // Method generating Ladder Cable + TGeoVolume* GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength); + // Method generating Ladder Cable Assembly + TList* GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength); + // Method generating Ladder Cable List + TGeoXtru* GetArcShape(Double_t phi, Double_t rmin, + Double_t rmax, Int_t nedges, Double_t height); + //Auxiliary Method for Arc Shape + TGeoArb8* GetArbShape(TVector3* vertexpos[],Double_t* width, + Double_t height,char* shapename,Int_t isign = 1) const; + // Method generating an Arb shape + TVector3* GetReflection(TVector3* vector,Double_t* param) const; + // Given an axis specified by param, + // it gives the reflection of the point respect to the axis + TGeoHMatrix* AddTranslationToHMatrix(TGeoHMatrix* ct,Double_t dx,Double_t dy, + Double_t dz) const; + // add (dx,dy,dz) translation to a initial TGeoCombiTrans ///////////////////////////////////////////////////////////////////////// - static const Int_t fgkLadderSegmentCombiTransNumber = 5; // Number of TGeoCombiTrans - // for positioning volumes in Ladder Segment - void SetLadderSegmentCombiTransMatrix(); // Method for generating TGeoCombiTrans for - // volume positioning in Ladder Segment - TGeoCombiTrans *fLadderSegmentCombiTransMatrix[fgkLadderSegmentCombiTransNumber]; // TGeoCombiTrans roto-trans - // transformations for volume positioning in - // in Ladder Segment + // Private members ///////////////////////////////////////////////////////////////////////// - // End LadderSegment + // Materials ///////////////////////////////////////////////////////////////////////// - static const Int_t fgkEndLadderSegmentCombiTransNumber = 4; // Number of TGeoCombiTrans - // for positioning volumes in End Ladder Segment - void SetEndLadderSegmentCombiTransMatrix(Int_t); // Method for generating TGeoCombiTrans for - // volume positioning in End Ladder Segment - TGeoCombiTrans *fEndLadderSegmentCombiTransMatrix[fgkEndLadderSegmentCombiTransNumber]; // TGeoCombiTrans roto-trans - // transformations for volume positioning in - // in End Ladder Segment + TGeoMedium* fSSDChipMedium; // SSD Module Chip Medium + TGeoMedium* fSSDChipGlueMedium; // SSD Module Chip Glue Layer Medium + TGeoMedium* fSSDStiffenerMedium; // SSDStiffener Medium + TGeoMedium* fSSDStiffenerConnectorMedium; // SSD Stiffener Connector Medium + TGeoMedium* fSSDStiffener0603CapacitorMedium; // SSD Stiffener Capacitor 0603 Medium + TGeoMedium* fSSDStiffener1812CapacitorMedium; // SSD Stiffener Capacitor 1812 Medium + TGeoMedium* fSSDStiffenerHybridWireMedium; // SSD Stiffener Wire Medium + TGeoMedium* fSSDKaptonFlexMedium; // SSD Flex Kapton Layer Medium + TGeoMedium* fSSDAlTraceFlexMedium; // SSD Flex Al Layer Medium + TGeoMedium* fSSDAlTraceLadderCableMedium; // SSD Ladder Cable Al Layer Medium + TGeoMedium* fSSDKaptonLadderCableMedium; // SSD Ladder Cable Kapton Layer Medium + TGeoMedium* fSSDKaptonChipCableMedium; // SSD Chip Cables Kapton Layer Medium + TGeoMedium* fSSDAlTraceChipCableMedium; // SSD Chip Cables Al Layer Medium + TGeoMedium* fSSDAlCoolBlockMedium; // SSD Cooling Block Al Medium + TGeoMedium* fSSDSensorMedium; // SSD Sensor Medium + TGeoMedium* fSSDSensorSupportMedium; // SSD Sensor Support Medium + TGeoMedium* fSSDCarbonFiberMedium; // SSD Carbon Fiber Medium + TGeoMedium* fSSDTubeHolderMedium; // Cooling Tube Support Medium + TGeoMedium* fSSDCoolingTubeWater; // Medium for Inner Part of Cooling Tube + TGeoMedium* fSSDCoolingTubePhynox; // Medium for Cooling Tube + TGeoMedium* fSSDMountingBlockMedium; // Medium for SSD Mounting Block + TGeoMedium* fSSDAir; // SSD Air + ///////////////////////////////////////////////////////////////////////// + Bool_t fCreateMaterials; // Bool variable which verifies if materials have been created + Bool_t fTransformationMatrices; // Bool variable which verifies if matrices have been allocated + Bool_t fBasicObjects; // Bool variable which verifies if basic objects have been allocated + ///////////////////////////////////////////////////////////////////////// + // Carbon Fiber Support Matrices and Objects + //////////////////////////////////////////// + static const Int_t fgkcarbonfibersupportnumber = 2; // Support Number + TGeoVolume* fcarbonfibersupport[fgkcarbonfibersupportnumber]; // Support + TGeoHMatrix* fcarbonfibersupportmatrix[fgkcarbonfibersupportnumber]; // Support Matrix + ///////////////////////// + // Carbon Fiber Junction + //////////////////////// + static const Int_t fgkcarbonfiberjunctionumber = 3; // Carbon Fiber Number + TGeoVolume* fcarbonfiberjunction; // Carbon Fiber + TGeoHMatrix* fcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber]; // Carbon Fiber Matrix + ///////////////////////////// + // Carbon Fiber Lower Support + ///////////////////////////// + static const Int_t fgkcarbonfiberlowersupportnumber = 2; // Carbon Fiber Lower Support Number + TGeoVolume* fcarbonfiberlowersupport[fgkcarbonfiberlowersupportnumber]; // Carbon Fiber Lower Support + TGeoTranslation* fcarbonfiberlowersupportrans[fgkcarbonfiberlowersupportnumber];// Carbon Fiber Lower Support Translation + ///////////////////////////// + // SSD Sensor Support + ///////////////////////////// + static const Int_t fgkvolumekind = 2; // volumekind = 0 : side ssd support + // volumekind = 1 : central ssd support + static const Int_t fgkssdsensorsupportnumber = 3; // SSD Sensor Support Number + TGeoVolume** fssdsensorsupport[fgkvolumekind]; // SSD Sensor + TGeoHMatrix* fssdsensorsupportmatrix[fgkssdsensorsupportnumber]; // SSD Sensor Matrix + ///////////////////////////////////////////////////////////// + // SSD Cooling Tube Support + ///////////////////////////////////////////////////////////// + static const Int_t fgkcoolingtubesupportnumber = 2; // Cooling Tube Support Number + TGeoVolume* fcoolingtubesupport; // Cooling Tube Support + TGeoHMatrix* fcoolingtubesupportmatrix[fgkcoolingtubesupportnumber]; // Cooling Tube Support Matrix + ///////////////////////////////////////////////////////////// + // SSD Hybrid + ///////////////////////////////////////////////////////////// + static const Int_t fgkhybridcompnumber = 3; // Hybrid number + TGeoVolume* fssdhybridcomponent[fgkhybridcompnumber]; // Hybrid Components + TGeoHMatrix* fhybridmatrix; // Hybrid Matrix + ///////////////////////////////////////////////////////////// + // SSD Cooling Block System + ///////////////////////////////////////////////////////////// + static const Int_t fgkcoolingblocknumber = 4; // Cooling Block Number + TGeoVolume* fssdcoolingblocksystem; // Cooling Block + TGeoHMatrix* fcoolingblocksystematrix; // Cooling Block Matrix + TGeoHMatrix* fcoolingblockmatrix[fgkcoolingblocknumber]; // Cooling System Matrix + ///////////////////////////////////////////////////////////// + // SSD Flex + ///////////////////////////////////////////////////////////// + static const Int_t fgkflexnumber = 2; // Flex Number + TGeoVolume* fssdstiffenerflex; // Stiffener Flex + TGeoVolume* fssdendflex; // End flex + TGeoHMatrix* fstiffenerflexmatrix[fgkflexnumber]; // Stiffener Flex Matrix + TGeoHMatrix* fendflexmatrix[fgkflexnumber]; // End Flex Matrix + ///////////////////////////////////////// + // Cooling Tube + ///////////////////////////////////////// + static const Int_t fgkcoolingtubenumber = 3; // Coling Tube Number + TGeoHMatrix** fcoolingtubematrix[fgkcoolingtubenumber+1]; // Cooling Tube Matrix + TGeoVolume* fcoolingtube[fgkcoolingtubenumber]; // Cooling Tube + ///////////////////////////////////////// + // End Ladder Components + ///////////////////////////////////////// + TGeoVolumeAssembly* fendladdersegment[2]; // End Ladder Segment + TGeoHMatrix** fendladdersegmentmatrix[2]; // End Ladder Matrix + /////////////////////////////////// + // End Ladder Carbon Fiber Junction + /////////////////////////////////// + static const Int_t fgkendlabbercarbonfiberjunctionumber = 2; // End Ladder Carbon fiber Junction Number + TGeoVolume** fendladdercarbonfiberjunction[fgkendlabbercarbonfiberjunctionumber]; // End Ladder Carbon fiber Junction Volumes + static const Int_t fgkendladdercabonfiberjunctionmatrixnumber = 3; // End Ladder Carbon fiber Junction Matrix Number + TGeoHMatrix** fendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber]; // End Ladder Carbon fiber Junction Matrix + /////////////////////////////////// + // End Ladder Carbon Fiber Support + /////////////////////////////////// + static const Int_t fgkendladdercarbonfibermatrixnumber = 2; // End Ladder Carbon fiber Matrix Number + TGeoHMatrix** fendladdercarbonfibermatrix[fgkendladdercarbonfibermatrixnumber]; // End Ladder Carbon fiber Matrix + /////////////////////////////////// + // End Ladder SSD Mounting Block + /////////////////////////////////// + static const Int_t fgkendladdermountingblocknumber = 2; // Mounting Block Number + TGeoVolume* fendladdermountingblock; // Mounting Block + TGeoTranslation* fendladdermountingblocktrans[fgkendladdermountingblocknumber]; // Mounting Block Translation + /////////////////////////////////// + // End Ladder Lower Support + /////////////////////////////////// + static const Int_t fgkendladderlowersuppnumber = 2; // End Ladder Lower Support Number + TGeoTranslation* fendladderlowersupptrans[fgkendladderlowersuppnumber+1]; // End Ladder Lower Support Translations ///////////////////////////////////////////////////////////////////////// // LadderCables ///////////////////////////////////////////////////////////////////////// - static const Int_t fgkLadderCableCombiTransNumber = 4; // Number of TGeoCombiTrans - // for positioning Ladder Cable volumes - void SetLadderCableCombiTransMatrix(Int_t iLayer); // Method for generating TGeoCombiTrans - // for positioning Ladder Cables volumes - TGeoCombiTrans *fLadderCableCombiTransMatrix[fgkLadderCableCombiTransNumber]; // TGeoCombiTrans for positioning - // Ladder Cables volumes + static const Int_t fgkladdercablematrixnumber = 4; // Number of TGeoCombiTrans + // for positioning Ladder Cable volumes + static const Int_t fgkladdercablesnumber = 2; // Number of Ladder Cables Layers + TGeoHMatrix **fladdercablematrix[fgkladdercablesnumber]; // TGeoCombiTrans for positioning + // Ladder Cables volumes + /////////////////////////////////// + // Ladder Segment + /////////////////////////////////// + static const Int_t fgkladdersegmentnumber = 2; // Ladder Segment Kinds Number + TGeoVolumeAssembly* fladdersegment[fgkladdersegmentnumber]; // Ladder Segment + /////////////////////////////////// + // Ladder + /////////////////////////////////// + static const Int_t fgkladdernumber = 2; // Ladder Number + TGeoVolume* fladder[fgkladdernumber]; //fladder[0]: ladder of Layer 5 + //fladder[1]: ladder of Layer 6 + TGeoHMatrix** fladdermatrix[fgkladdernumber]; // Ladder Matrix + /////////////////////////////////// + // SSD Sensor + /////////////////////////////////// + TGeoVolume* fSSDSensor5; // Layer 5 SSD Sensor + TGeoVolume* fSSDSensor6; // Layer 6 SSD Sensor + TGeoHMatrix** fssdsensormatrix[fgkladdernumber]; // SSD Sensor Matrix + /////////////////////////////////// + // SSD Layer + /////////////////////////////////// + static const Int_t fgklayernumber = 2; // Layer Number + TGeoVolume* fSSDLayer5; // SSD Layer 5 + TGeoVolume* fSSDLayer6; // SSD Layer 6 + TGeoHMatrix** flayermatrix[fgklayernumber]; // Layer Transformations ///////////////////////////////////////////////////////////////////////// // Mother Volume ///////////////////////////////////////////////////////////////////////// @@ -454,6 +452,8 @@ private: Int_t fColorPolyhamide; // === Int_t fColorStiffener; // === Int_t fColorEpoxy; // === + Int_t fColorWater; // === + Int_t fColorG10; // === ClassDef(AliITSv11GeometrySSD, 2) // ITS v11 SSD geometry }; #endif diff --git a/ITS/AliITSv11Hybrid.cxx b/ITS/AliITSv11Hybrid.cxx index 4f7b3a575dd..ef59b129afd 100644 --- a/ITS/AliITSv11Hybrid.cxx +++ b/ITS/AliITSv11Hybrid.cxx @@ -16,6 +16,9 @@ // $Id$ // $Log$ +// Revision 1.4 2007/05/09 20:40:41 masera +// Bug fix (V11Hybrid geometry) +// // Revision 1.3 2007/05/08 16:57:42 masera // Updates concerning the geometry: versioning system, new V11hybrid version, bug fixes (B.Nilsend and L. Gaudichet // @@ -69,6 +72,7 @@ #include "AliTrackReference.h" #include "AliITSInitGeometry.h" #include "AliITSv11GeometrySDD.h" +#include "AliITSv11GeometrySSD.h" #define GEANTGEOMETRY kTRUE @@ -91,7 +95,8 @@ AliITSv11Hybrid::AliITSv11Hybrid(): fFluid(0), fIDMother(0), fInitGeom((AliITSVersion_t)fMajorVersion,fMinorVersion), - fSDDgeom(0) + fSDDgeom(0), + fSSDgeom(0) { // Standard default constructor // Inputs: @@ -122,7 +127,8 @@ AliITSv11Hybrid::AliITSv11Hybrid(const char *name, const char *title) fFluid(0), fIDMother(0), fInitGeom((AliITSVersion_t)fMajorVersion,fMinorVersion), - fSDDgeom(0) { + fSDDgeom(0), + fSSDgeom(0) { // Standard constructor for the v11Hybrid geometry. // Inputs: // const char * name Ignored, set to "ITS" @@ -132,13 +138,16 @@ AliITSv11Hybrid::AliITSv11Hybrid(const char *name, const char *title) // Return: // none. Int_t i; + + fSDDgeom = new AliITSv11GeometrySDD(0); + fSSDgeom = new AliITSv11GeometrySSD(); fIdN = 6; fIdName = new TString[fIdN]; fIdName[0] = name; // removes warning message fIdName[0] = "ITS1"; fIdName[1] = "ITS2"; - + if (AliITSInitGeometry::SDDIsTGeoNative()) { fIdName[2] = fSDDgeom->GetSenstiveVolumeName3(); fIdName[3] = fSDDgeom->GetSenstiveVolumeName4(); @@ -146,9 +155,15 @@ AliITSv11Hybrid::AliITSv11Hybrid(const char *name, const char *title) fIdName[2] = "ITS3"; fIdName[3] = "ITS4"; } + + if (AliITSInitGeometry::SSDIsTGeoNative()) { + fIdName[4] = fSSDgeom->GetSenstiveVolumeName5(); + fIdName[5] = fSSDgeom->GetSenstiveVolumeName6(); + } else { + fIdName[4] = "ITS5"; + fIdName[5] = "ITS6"; + } - fIdName[4] = "ITS5"; - fIdName[5] = "ITS6"; fIdSens = new Int_t[fIdN]; for(i=0;iGetTranslation(), rotMatrix[9]; memcpy(&rotMatrix[0], globMatrix->GetRotationMatrix(), 9*sizeof(Double_t)); - Double_t al = TMath::ATan2(rotMatrix[1],rotMatrix[0]) + dAlpha; + Double_t al = TMath::ATan2(rotMatrix[1],rotMatrix[0]); if (yRot180) { - al = TMath::ATan2(rotMatrix[1],-rotMatrix[0]) + dAlpha; + al = TMath::ATan2(rotMatrix[1],-rotMatrix[0]); } TGeoHMatrix *matLtoT = new TGeoHMatrix; - matLtoT->SetDx( dxSign*(gtrans[0]*TMath::Cos(al)+gtrans[1]*TMath::Sin(al)) ); // translation + matLtoT->SetDx( gtrans[0]*TMath::Cos(al)+gtrans[1]*TMath::Sin(al) ); // translation matLtoT->SetDy( yShift ); matLtoT->SetDz(-gtrans[2]); rotMatrix[0]= 0; rotMatrix[1]= 1; rotMatrix[2]= 0; // + rotation @@ -225,6 +242,68 @@ void AliITSv11Hybrid::SetT2Lmatrix(const char *name, Double_t dAlpha, delete matLtoT; alignableEntry->SetMatrix(matTtoL); } + + + + + +/* +//______________________________________________________________________ +void AliITSv11Hybrid::SetT2Lmatrix(const char *name, Double_t dAlpha, + Double_t dxSign, Double_t yShift, Bool_t yFlip, Bool_t yRot180) + const { + + // + // Creates the TGeo Local to Tracking transformation matrix + // and sends it to the corresponding TGeoPNEntry + // + // This function is used in AddAlignableVolumes() + + TGeoPNEntry *alignableEntry = gGeoManager->GetAlignableEntry(name); + const char *path = alignableEntry->GetTitle(); + + if (!gGeoManager->cd(path)) + AliFatal(Form("Volume path %s not valid!",path)); + TGeoHMatrix* globMatrix = gGeoManager->GetCurrentMatrix(); + + Double_t *gtransL1 = globMatrix->GetTranslation(), rotMatrixL1[9]; + memcpy(&rotMatrixL1[0], globMatrix->GetRotationMatrix(), 9*sizeof(Double_t)); + + // L1 is the real local reference system. We will define L2, which is a + // more practical "local" reference system. L2 has his z axis parallel + // to the global z axis and y is the axis perpendicular to the sensor plane. + Double_t rotMatrixL2[9]; + + + + // We know the transformation from L2 to Tracking + Double_t al = TMath::ATan2(rotMatrixL2[1],rotMatrixL2[0]) + dAlpha; + Double_t transL2toT[3] = { gtransL1[0]*TMath::Cos(al)+gtransL1[1]*TMath::Sin(al), + yShift, + -gtrans[2]}; + + TGeoHMatrix *matLtoT = new TGeoHMatrix; + matLtoT->SetDx( dxSign*(gtrans[0]*TMath::Cos(al)+gtrans[1]*TMath::Sin(al)) ); // translation + matLtoT->SetDy( yShift ); + matLtoT->SetDz(-gtrans[2]); + rotMatrix[0]= 0; rotMatrix[1]= 1; rotMatrix[2]= 0; // + rotation + rotMatrix[3]= 1; rotMatrix[4]= 0; rotMatrix[5]= 0; + rotMatrix[6]= 0; rotMatrix[7]= 0; rotMatrix[8]=-1; + if (yFlip) rotMatrix[3] = -1; // flipping in y (for SPD1) + + + TGeoRotation rot; + rot.SetMatrix(rotMatrix); + matLtoT->MultiplyLeft(&rot); + TGeoHMatrix *matTtoL = new TGeoHMatrix(matLtoT->Inverse()); + delete matLtoT; + alignableEntry->SetMatrix(matTtoL); +} +*/ + + + + //______________________________________________________________________ void AliITSv11Hybrid::AddAlignableVolumes() const { @@ -307,7 +386,7 @@ void AliITSv11Hybrid::AddAlignableVolumes() const AliFatal("Unable to set alignable entry!!"); //printf("%s == %s\n",strEntryName3.Data(),module.Data()); - SetT2Lmatrix(strEntryName3.Data(), 0, 1, -fChip1*0.0001/2., kTRUE); + SetT2Lmatrix(strEntryName3.Data(), -fChip1*0.0001/2., kTRUE); } } } @@ -359,14 +438,13 @@ void AliITSv11Hybrid::AddAlignableVolumes() const AliFatal("Unable to set alignable entry!!"); //printf("%s == %s\n",strEntryName3.Data(),module.Data()); - SetT2Lmatrix(strEntryName3.Data(), TMath::Pi(), -1, -fChip2*0.0001/2., kFALSE); + SetT2Lmatrix(strEntryName3.Data(), -fChip2*0.0001/2., kFALSE); } } } } //===== SDD layers ===== - if (AliITSInitGeometry::SDDIsTGeoNative()) { // new SDD geometry TString str0 = "/ALIC_1/ITSV_1/ITSsddLayer3_1/ITSsddLadd_"; // SDD layer1 @@ -400,7 +478,7 @@ void AliITSv11Hybrid::AddAlignableVolumes() const if(!gGeoManager->SetAlignableEntry(strEntryName2.Data(),wafer.Data())) AliFatal("Unable to set alignable entry!!"); - SetT2Lmatrix(strEntryName2.Data(), TMath::Pi(), -1, 0, kFALSE, c2>=3); + SetT2Lmatrix(strEntryName2.Data(), 0, kFALSE, c2>=3); } } @@ -433,11 +511,11 @@ void AliITSv11Hybrid::AddAlignableVolumes() const if(!gGeoManager->SetAlignableEntry(strEntryName2.Data(),wafer.Data())) AliFatal("Unable to set alignable entry!!"); - SetT2Lmatrix(strEntryName2.Data(), TMath::Pi(), -1, 0, kFALSE, c2>=4); + SetT2Lmatrix(strEntryName2.Data(), 0, kFALSE, c2>=4); } } - } else { // else old geometry + } else { // else old SDD geometry TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT34_1/I004_"; TString str1 = "/I302_"; @@ -469,7 +547,7 @@ void AliITSv11Hybrid::AddAlignableVolumes() const AliFatal("Unable to set alignable entry!!"); //printf("%s == %s\n",strEntryName2.Data(),wafer.Data()); - SetT2Lmatrix(strEntryName2.Data(), TMath::Pi(), -1, 0, kFALSE); + SetT2Lmatrix(strEntryName2.Data(), 0, kFALSE); } } @@ -500,23 +578,90 @@ void AliITSv11Hybrid::AddAlignableVolumes() const AliFatal("Unable to set alignable entry!!"); //printf("%s == %s\n",strEntryName2.Data(),wafer.Data()); - SetT2Lmatrix(strEntryName2.Data(), TMath::Pi(), -1, 0, kFALSE); + SetT2Lmatrix(strEntryName2.Data(), 0, kFALSE); } } - } // end SDD - //===== SSD layer1 ===== - { + if (AliITSInitGeometry::SSDIsTGeoNative()) { // new SSD geometry + + TString str0 = "/ALIC_1/ITSV_1/ITSssdLayer5_1/ITSssdLay5Ladd_"; // SSD layer1 + TString str1 = "/ITSsddSensor5_"; + TString str2 = ""; + TString ladder; + TString wafer; + + for(Int_t c1 = 0; c1<34; c1++) { + + ladder = str0; + ladder += c1; // the set of wafers from one ladder + strEntryName1 = strSSD; + strEntryName1 += 4; + strEntryName1 += strLadder; + strEntryName1 += c1; + //printf("%s == %s\n",strEntryName1.Data(),ladder.Data()); + if(!gGeoManager->SetAlignableEntry(strEntryName1.Data(),ladder.Data())) + AliFatal("Unable to set alignable entry!!"); + + for(Int_t c2 =0; c2<22; c2++) { + + wafer = ladder; + wafer += str1; + wafer += c2; + //wafer += str2; // one wafer + strEntryName2 = strEntryName1; + strEntryName2 += strSensor; + strEntryName2 += c2; + //printf("%s == %s\n",strEntryName2.Data(),wafer.Data()); + if(!gGeoManager->SetAlignableEntry(strEntryName2.Data(),wafer.Data())) + AliFatal("Unable to set alignable entry!!"); + + SetT2Lmatrix(strEntryName2.Data(), 0, kFALSE, kFALSE); + } + } + + str0 = "/ALIC_1/ITSV_1/ITSssdLayer6_1/ITSssdLay6Ladd_"; // SSD layer2 + str1 = "/ITSsddSensor6_"; + str2 = ""; + + for(Int_t c1 = 0; c1<38; c1++) { + + ladder = str0; + ladder += c1; // the set of wafers from one ladder + strEntryName1 = strSSD; + strEntryName1 += 5; + strEntryName1 += strLadder; + strEntryName1 += c1; + //printf("%s == %s\n",strEntryName1.Data(),ladder.Data()); + if(!gGeoManager->SetAlignableEntry(strEntryName1.Data(),ladder.Data())) + AliFatal("Unable to set alignable entry!!"); + + for(Int_t c2 =0; c2<25; c2++) { + + wafer = ladder; + wafer += str1; + wafer += c2; + //wafer += str2; // one wafer + strEntryName2 = strEntryName1; + strEntryName2 += strSensor; + strEntryName2 += c2; + //printf("%s == %s\n",strEntryName2.Data(),wafer.Data()); + if(!gGeoManager->SetAlignableEntry(strEntryName2.Data(),wafer.Data())) + AliFatal("Unable to set alignable entry!!"); + + SetT2Lmatrix(strEntryName2.Data(), 0, kFALSE, kFALSE); + } + } + + } else { // else old SSD geometry TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT56_1/I565_"; TString str1 = "/I562_"; - TString ladder; TString wafer; for(Int_t c1 = 1; c1<=34; c1++){ - + ladder = str0; ladder += c1; // the set of wafers from one ladder strEntryName1 = strSSD; @@ -526,9 +671,9 @@ void AliITSv11Hybrid::AddAlignableVolumes() const if(!gGeoManager->SetAlignableEntry(strEntryName1.Data(),ladder.Data())) AliFatal("Unable to set alignable entry!!"); //printf("%s == %s\n",strEntryName1.Data(),ladder.Data()); - + for(Int_t c2 = 1; c2<=22; c2++){ - + wafer = ladder; wafer += str1; wafer += c2; // one wafer @@ -538,22 +683,17 @@ void AliITSv11Hybrid::AddAlignableVolumes() const if(!gGeoManager->SetAlignableEntry(strEntryName2.Data(),wafer.Data())) AliFatal("Unable to set alignable entry!!"); //printf("%s == %s\n",strEntryName2.Data(),wafer.Data()); - - SetT2Lmatrix(strEntryName2.Data(), TMath::Pi(), -1, 0, kFALSE); + + SetT2Lmatrix(strEntryName2.Data(), 0, kFALSE); } } - } - - //===== SSD layer2 ===== - { - TString str0 = "ALIC_1/ITSV_1/ITSD_1/IT56_1/I569_"; - TString str1 = "/I566_"; - - TString ladder; - TString wafer; - + + //===== SSD layer2 ===== + str0 = "ALIC_1/ITSV_1/ITSD_1/IT56_1/I569_"; + str1 = "/I566_"; + for(Int_t c1 = 1; c1<=38; c1++){ - + ladder = str0; ladder += c1; // the set of wafers from one ladder strEntryName1 = strSSD; @@ -563,9 +703,9 @@ void AliITSv11Hybrid::AddAlignableVolumes() const if(!gGeoManager->SetAlignableEntry(strEntryName1.Data(),ladder.Data())) AliFatal("Unable to set alignable entry!!"); //printf("%s == %s\n",strEntryName1.Data(),ladder.Data()); - + for(Int_t c2 = 1; c2<=25; c2++){ - + wafer = ladder; wafer += str1; wafer += c2; // one wafer @@ -575,12 +715,13 @@ void AliITSv11Hybrid::AddAlignableVolumes() const if(!gGeoManager->SetAlignableEntry(strEntryName2.Data(),wafer.Data())) AliFatal("Unable to set alignable entry!!"); //printf("%s == %s\n",strEntryName2.Data(),wafer.Data()); - - SetT2Lmatrix(strEntryName2.Data(), TMath::Pi(), -1, 0, kFALSE); + + SetT2Lmatrix(strEntryName2.Data(), 0, kFALSE); } } - } + } // end SSD geometry } + //______________________________________________________________________ void AliITSv11Hybrid::BuildGeometry(){ // Geometry builder for the ITS version 10. Event Display geometry. @@ -651,6 +792,10 @@ void AliITSv11Hybrid::CreateGeometry() { CreateOldGeometry(); TGeoVolume *vITS = geoManager->GetVolume("ITSV"); + TGeoVolume *vIS02 = geoManager->GetVolume("IS02"); + + + const Char_t *cvsDate="$Date$"; const Char_t *cvsRevision="$Revision$"; const Int_t length=100; @@ -662,6 +807,12 @@ void AliITSv11Hybrid::CreateGeometry() { if (AliITSInitGeometry::SDDIsTGeoNative()) { fSDDgeom->Layer3(vITS); fSDDgeom->Layer4(vITS); + fSDDgeom->ForwardLayer3(vIS02); + fSDDgeom->ForwardLayer4(vIS02); + } + if (AliITSInitGeometry::SSDIsTGeoNative()) { + fSSDgeom->Layer5(vITS); + fSSDgeom->Layer6(vITS); } } @@ -2462,42 +2613,73 @@ void AliITSv11Hybrid::CreateOldGeometry(){ dits[0] = 0; dits[1] = 360; dits[2] = 12; + // dits[3] = -59.7; dits[4] = 27; dits[5] = 28.6; + dits[6] = -42.7; dits[7] = 10; dits[8] = 28.6; - dits[9] = -34.65; + + // dits[9] = -34.65; + dits[9] = -33.55; dits[10] = 10; dits[11] = 28.6; - dits[12] = -34.65; + + // dits[12] = -34.65; + dits[12] = -33.55; dits[13] = 10; dits[14] = 23.495; - dits[15] = -23.7; + + //dits[15] = -23.7; + dits[15] = -26.2; dits[16] = 10; dits[17] = 23.495; - dits[18] = -23.7; + + //dits[18] = -23.7; + dits[18] = -26.2; dits[19] = 10; dits[20] = 14.595; - dits[21] = 23.7; + + //dits[21] = 23.7; + dits[21] = 26.2; dits[22] = 10; dits[23] = 14.595; - dits[24] = 23.7; + + //dits[24] = 23.7; + dits[24] = 26.2; dits[25] = 10; dits[26] = 23.495; - dits[27] = 34.65; + +// dits[27] = 34.65; + dits[27] = 33.55; dits[28] = 10; dits[29] = 23.495; - dits[30] = 34.65; + +// dits[30] = 34.65; + dits[30] = 33.55; dits[31] = 10; dits[32] = 28.6; + dits[33] = 42.7; dits[34] = 10; dits[35] = 28.6; + dits[36] = 59.7; dits[37] = 27.2637; - dits[38] = 28.6; + dits[38] = 28.6; + + if (! AliITSInitGeometry::SDDIsTGeoNative()) { + dits[9] = -34.65; + dits[12] = -34.65; + dits[15] = -23.7; + dits[18] = -23.7; + dits[21] = 23.7; + dits[24] = 23.7; + dits[27] = 34.65; + dits[30] = 34.65; + } gMC->Gsvolu("IS02", "PCON", idtmed[204], dits, 39); dits[0] = 0; @@ -2603,7 +2785,10 @@ void AliITSv11Hybrid::CreateOldGeometry(){ dits[2] = 7.74; gMC->Gsvolu("I202", "BOX ", idtmed[272], dits, 3); - dits[0] = 1; + if (AliITSInitGeometry::SDDIsTGeoNative()) + dits[0] = 0.9; + else + dits[0] = 1; dits[1] = 1; dits[2] = 9.14; gMC->Gsvolu("I203", "BOX ", idtmed[272], dits, 3); @@ -2631,42 +2816,65 @@ void AliITSv11Hybrid::CreateOldGeometry(){ dits[0] = 0; dits[1] = 360; dits[2] = 12; + dits[3] = -zmax; - dits[4] = 46; - dits[5] = 49.25; + dits[4] = 46; + dits[5] = 49.25; + dits[6] = -61.2; dits[7] = 28.7; - dits[8] = 49.25; + dits[8] = 49.25; + dits[9] = -57.5; dits[10] = 28.7; - dits[11] = 49.25; + dits[11] = 49.25; + dits[12] = -57.5; dits[13] = 28.7; dits[14] = 43.5; - dits[15] = -49.2; + + //dits[15] = -49.2; + dits[15] = -53.4-0.75; dits[16] = 28.7; dits[17] = 43.5; - dits[18] = -49.2; + + //dits[18] = -49.2; + dits[18] = -53.4-0.75; dits[19] = 28.7; dits[20] = 36.85; - dits[21] = 50.6; + + //dits[21] = 50.6; + dits[21] = 53.4+0.75; dits[22] = 28.7; dits[23] = 36.85; - dits[24] = 50.6; + + dits[24] = 53.4+0.75; + //dits[24] = 50.6; dits[25] = 28.7; dits[26] = 43.5; + dits[27] = 57.5; dits[28] = 28.7; dits[29] = 43.5; + dits[30] = 57.5; dits[31] = 28.7; - dits[32] = 49.25; + dits[32] = 49.25; + dits[33] = 61.2; dits[34] = 28.7; dits[35] = 49.25; dits[36] = zmax; dits[37] = 46; - dits[38] = 49.25; + dits[38] = 49.25; + + if (! AliITSInitGeometry::SSDIsTGeoNative()) { + dits[15] = -49.2; + dits[18] = -49.2; + dits[21] = 50.6; + dits[24] = 50.6; + } + gMC->Gsvolu("IS01", "PCON", idtmed[204], dits, 39); // SSD cone mother volume dits[0] = 0; @@ -3878,10 +4086,16 @@ void AliITSv11Hybrid::CreateOldGeometry(){ gMC->Gspos("I212",2,"IS01",0.0,0.0,0.0,idrotm[701],"MANY"); gMC->Gspos("I212",1,"IS01",0.0,0.0,0.0,0,"MANY"); gMC->Gspos("I211",1,"IS01",0.0,0.0,-56.5,0,"ONLY"); + gMC->Gspos("I217",1,"IS01",0.0,0.0,-44.4,0,"ONLY"); // this will change after PPR to be symmetric - gMC->Gspos("I219",1,"IS01",0.0,0.0,-50.25,0,"ONLY"); // this will change after PPR to be symmetric + // Unfortunately the following piece is not compatible with new SSD + if (! AliITSInitGeometry::SSDIsTGeoNative()) + gMC->Gspos("I219",1,"IS01",0.0,0.0,-50.25,0,"ONLY"); // this will change after PPR to be symmetric gMC->Gspos("I211",2,"IS01",0.0,0.0,56.5,idrotm[701],"ONLY"); - gMC->Gspos("I219",2,"IS01",0.0,0.0,51.65,idrotm[701],"ONLY"); // this will change after PPR to be symmetric + + // Unfortunately the following piece is not compatible with new SSD + if (! AliITSInitGeometry::SSDIsTGeoNative()) + gMC->Gspos("I219",2,"IS01",0.0,0.0,51.65,idrotm[701],"ONLY"); // this will change after PPR to be symmetric gMC->Gspos("I217",2,"IS01",0.0,0.0,45.8,idrotm[701],"ONLY"); // this will change after PPR to be symmetric gMC->Gspos("I214",2,"IS01",0.0,0.0,67.25,idrotm[701],"ONLY"); gMC->Gspos("I213",2,"IS01",0.0,0.0,62.25,idrotm[701],"ONLY"); @@ -3899,18 +4113,23 @@ void AliITSv11Hybrid::CreateOldGeometry(){ gMC->Gspos("I215",13,"IS01",0.0,0.0,0.0,idrotm[711],"MANY"); gMC->Gspos("I215",15,"IS01",0.0,0.0,0.0,idrotm[712],"MANY"); gMC->Gspos("I215",17,"IS01",0.0,0.0,0.0,idrotm[713],"MANY"); - gMC->Gspos("I216",9,"IS01",0.0,0.0,45.5,idrotm[714],"ONLY"); - gMC->Gspos("I216",11,"IS01",0.0,0.0,45.5,idrotm[715],"ONLY"); - gMC->Gspos("I216",12,"IS01",0.0,0.0,45.5,idrotm[716],"ONLY"); - gMC->Gspos("I216",3,"IS01",0.0,0.0,45.5,idrotm[717],"ONLY"); - gMC->Gspos("I216",5,"IS01",0.0,0.0,45.5,idrotm[718],"ONLY"); - gMC->Gspos("I216",7,"IS01",0.0,0.0,45.5,idrotm[719],"ONLY"); - gMC->Gspos("I216",10,"IS01",0.0,0.0,-44,idrotm[720],"ONLY"); - gMC->Gspos("I216",1,"IS01",0.0,0.0,-44,idrotm[721],"ONLY"); - gMC->Gspos("I216",2,"IS01",0.0,0.0,-44,idrotm[722],"ONLY"); - gMC->Gspos("I216",4,"IS01",0.0,0.0,-44,idrotm[723],"ONLY"); - gMC->Gspos("I216",6,"IS01",0.0,0.0,-44,idrotm[724],"ONLY"); - gMC->Gspos("I216",8,"IS01",0.0,0.0,-44,idrotm[725],"ONLY"); + + // Unfortunately the following piece is not compatible with new SSD + if (! AliITSInitGeometry::SSDIsTGeoNative()) { + gMC->Gspos("I216",9,"IS01",0.0,0.0,45.5,idrotm[714],"ONLY"); + gMC->Gspos("I216",11,"IS01",0.0,0.0,45.5,idrotm[715],"ONLY"); + gMC->Gspos("I216",12,"IS01",0.0,0.0,45.5,idrotm[716],"ONLY"); + gMC->Gspos("I216",3,"IS01",0.0,0.0,45.5,idrotm[717],"ONLY"); + gMC->Gspos("I216",5,"IS01",0.0,0.0,45.5,idrotm[718],"ONLY"); + gMC->Gspos("I216",7,"IS01",0.0,0.0,45.5,idrotm[719],"ONLY"); + gMC->Gspos("I216",10,"IS01",0.0,0.0,-44,idrotm[720],"ONLY"); + gMC->Gspos("I216",1,"IS01",0.0,0.0,-44,idrotm[721],"ONLY"); + gMC->Gspos("I216",2,"IS01",0.0,0.0,-44,idrotm[722],"ONLY"); + gMC->Gspos("I216",4,"IS01",0.0,0.0,-44,idrotm[723],"ONLY"); + gMC->Gspos("I216",6,"IS01",0.0,0.0,-44,idrotm[724],"ONLY"); + gMC->Gspos("I216",8,"IS01",0.0,0.0,-44,idrotm[725],"ONLY"); + } + gMC->Gspos("I215",1,"IS01",0.0,0.0,0.0,idrotm[726],"MANY"); gMC->Gspos("I215",2,"IS01",0.0,0.0,0.0,idrotm[727],"MANY"); gMC->Gspos("I215",4,"IS01",0.0,0.0,0.0,idrotm[728],"MANY"); @@ -3929,15 +4148,15 @@ void AliITSv11Hybrid::CreateOldGeometry(){ // into ITS mother volume ITSD if (! AliITSInitGeometry::SPDIsTGeoNative()) - gMC->Gspos("IT12",1,"ITSD",0.0,0.0,0.0,0,"MANY"); // SPD mother volume + gMC->Gspos("IT12",1,"ITSD",0.0,0.0,0.0,0,"ONLY"); // SPD mother volume if (! AliITSInitGeometry::SDDIsTGeoNative()) gMC->Gspos("IT34",1,"ITSD",0.0,0.0,0.0,0,"MANY"); // SDD mother volume if (! AliITSInitGeometry::SSDIsTGeoNative()) gMC->Gspos("IT56",1,"ITSD",0.0,0.0,0.0,0,"MANY"); // SSD mother volume if (! AliITSInitGeometry::SDDconeIsTGeoNative()) - gMC->Gspos("IS02",1,"ITSD",0.0,0.0,0.0,0,"MANY"); // SDD cones/supports + gMC->Gspos("IS02",1,"ITSD",0.0,0.0,0.0,0,"ONLY"); // SDD cones/supports if (! AliITSInitGeometry::SSDconeIsTGeoNative()) - gMC->Gspos("IS01",1,"ITSD",0.0,0.0,0.0,0,"MANY"); // SSD cones/supports + gMC->Gspos("IS01",1,"ITSD",0.0,0.0,0.0,0,"ONLY"); // SSD cones/supports // **************************** SERVICES ********************************* @@ -4530,10 +4749,7 @@ void AliITSv11Hybrid::CreateOldGeometry(){ } while (strcmp(sddName, toTransform->GetName()) == 0); } - - } - } //______________________________________________________________________ void AliITSv11Hybrid::CreateMaterials(){ @@ -5171,6 +5387,7 @@ void AliITSv11Hybrid::InitAliITSgeom(){ } // end for lay return; } + //______________________________________________________________________ void AliITSv11Hybrid::Init(){ // Initialise the ITS after it has been created. @@ -5183,22 +5400,13 @@ void AliITSv11Hybrid::Init(){ AliDebug(1,Form("Init: Major version %d Minor version %d",fMajorVersion, fMinorVersion)); - // - /* obsolete initialization of AliITSgeom from external "det" file - if(fRead[0]=='\0') strncpy(fRead,fEuclidGeomDet,60); - if(fWrite[0]=='\0') strncpy(fWrite,fEuclidGeomDet,60); - AliITSgeom* geom = new AliITSgeom(); - SetITSgeom(geom); - if(fGeomDetIn) GetITSgeom()->ReadNewFile(fRead); - else this->InitAliITSgeom(); - */ UpdateInternalGeometry(); AliITS::Init(); if(fGeomDetOut) GetITSgeom()->WriteNewFile(fWrite); - // fIDMother = gMC->VolId("ITSV"); // ITS Mother Volume ID. } + //______________________________________________________________________ void AliITSv11Hybrid::SetDefaults(){ // sets the default segmentation, response, digit and raw cluster classes @@ -5353,6 +5561,7 @@ void AliITSv11Hybrid::DrawModule() const{ gMC->Gdhead(1111, "Inner Tracking System Version 1"); gMC->Gdman(17, 6, "MAN"); } + //______________________________________________________________________ void AliITSv11Hybrid::StepManager(){ // Called for every step in the ITS, then calles the AliITShit class @@ -5372,15 +5581,14 @@ void AliITSv11Hybrid::StepManager(){ if(!(this->IsActive())) return; if(!(gMC->TrackCharge())) return; - Int_t copy, id, lay; - Bool_t sensvol = kFALSE; - id = gMC->CurrentVolID(copy); - for(lay=0; layCurrentVolID(copy); + + Bool_t notSens; + while ((notSens = id != fIdSens[lay]) && (layIsTrackExiting())) { + if(gMC->IsTrackExiting()) { copy = fTrackReferences->GetEntriesFast(); TClonesArray &lTR = *fTrackReferences; // Fill TrackReference structure with this new TrackReference. @@ -5390,12 +5598,11 @@ void AliITSv11Hybrid::StepManager(){ static TLorentzVector position, momentum; // Saves on calls to construtors static AliITShit hit;// Saves on calls to constructors - Int_t cpn0, cpn1, cpn2, status, mod; - //TClonesArray &lhits = *(GetDetTypeSim()->GetHits()); + TClonesArray &lhits = *(Hits()); + Int_t cpn0, cpn1, mod, status = 0; // // Track status - status = 0; if(gMC->IsTrackInside()) status += 1; if(gMC->IsTrackEntering()) status += 2; if(gMC->IsTrackExiting()) status += 4; @@ -5403,15 +5610,16 @@ void AliITSv11Hybrid::StepManager(){ if(gMC->IsTrackDisappeared()) status += 16; if(gMC->IsTrackStop()) status += 32; if(gMC->IsTrackAlive()) status += 64; + // switch (lay) { case 0:case 1: // SPD - gMC->CurrentVolOffID(2,cpn2); + gMC->CurrentVolOffID(2,copy); gMC->CurrentVolOffID(3,cpn1); gMC->CurrentVolOffID(4,cpn0); break; case 2:case 3: // SDD - cpn2 = 1; + copy = 1; if (AliITSInitGeometry::SDDIsTGeoNative()) { gMC->CurrentVolOffID(2,cpn1); gMC->CurrentVolOffID(3,cpn0); @@ -5421,15 +5629,20 @@ void AliITSv11Hybrid::StepManager(){ }; break; case 4:case 5: // SSD - cpn2 = 1; + copy = 1; + if (AliITSInitGeometry::SSDIsTGeoNative()) { + gMC->CurrentVolOffID(1,cpn1); + gMC->CurrentVolOffID(2,cpn0); + } else { gMC->CurrentVolOffID(1,cpn1); gMC->CurrentVolOffID(2,cpn0); + }; break; default: - Error("StepManager","Unknown volume lay=%d",lay+1); + AliError(Form("Invalid value: lay= %d . Not an ITS sensitive volume",lay)); return; // not an ITS sensitive volume. } // - fInitGeom.DecodeDetector(mod,lay+1,cpn0,cpn1,cpn2); + fInitGeom.DecodeDetector(mod,lay+1,cpn0,cpn1,copy); // // Fill hit structure. diff --git a/ITS/AliITSv11Hybrid.h b/ITS/AliITSv11Hybrid.h index 574ffb0174e..8600f327df3 100644 --- a/ITS/AliITSv11Hybrid.h +++ b/ITS/AliITSv11Hybrid.h @@ -6,6 +6,9 @@ // $Id$ // $Log$ +// Revision 1.3 2007/05/08 16:57:42 masera +// Updates concerning the geometry: versioning system, new V11hybrid version, bug fixes (B.Nilsend and L. Gaudichet +// //======================================================================== // @@ -22,6 +25,7 @@ #include "AliITSInitGeometry.h" class AliITSv11GeometrySDD; +class AliITSv11GeometrySSD; class AliITSv11Hybrid : public AliITS { @@ -110,8 +114,8 @@ class AliITSv11Hybrid : public AliITS { protected: void CreateOldGeometry(); - void SetT2Lmatrix(const char *name, Double_t dAlpha, Double_t dxSign, - Double_t yShift, Bool_t yFlip, Bool_t yRot180=kFALSE) const; // Set T2L matrix in TGeoPNEntries + void SetT2Lmatrix(const char *name, Double_t yShift, + Bool_t yFlip, Bool_t yRot180=kFALSE) const; // Set T2L matrix in TGeoPNEntries private: AliITSv11Hybrid(const AliITSv11Hybrid &source); // copy constructor @@ -137,8 +141,9 @@ class AliITSv11Hybrid : public AliITS { AliITSInitGeometry fInitGeom; //! Get access to decoding and AliITSgeom init functins AliITSv11GeometrySDD *fSDDgeom; //! SDD Geometry + AliITSv11GeometrySSD *fSSDgeom; //! SSD Geometry - ClassDef(AliITSv11Hybrid,2) + ClassDef(AliITSv11Hybrid,3) }; #endif