bug fixes on V11 geometries and some improvements: namely the possibility of defining...
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 23 Nov 2004 11:47:09 +0000 (11:47 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 23 Nov 2004 11:47:09 +0000 (11:47 +0000)
ITS/AliITSv11.cxx
ITS/AliITSv11.h
ITS/AliITSv11GeomCable.cxx
ITS/AliITSv11GeomCableFlat.cxx
ITS/AliITSv11GeomCableRound.cxx
ITS/AliITSv11GeomCableRound.h
ITS/AliITSv11GeometrySDD.cxx
ITS/AliITSv11GeometrySDD.h

index 774c4a1..b8f27f8 100644 (file)
 
 ClassImp(AliITSv11)
  
-//______________________________________________________________________
-  AliITSv11::AliITSv11() :
-    AliITS("ITS","ITS geometry v11"),
-    fGeomDetOut(kFALSE),
-    fGeomDetIn(kFALSE),
-    fMajorVersion(11),
-    fMinorVersion(0) {
+
+
+AliITSv11::AliITSv11() : AliITS()
+{
   //    Standard default constructor for the ITS version 11.
-  // Inputs:
-  //   none.
-  // Outputs:
-  //   none.
-  // Return:
-  //   none.
-  
+  fGeomDetOut=kFALSE;
+  fGeomDetIn=kFALSE;
+  fMajorVersion=11;
+  fMinorVersion=0;
   Int_t i;
   for(i=0;i<60;i++) fRead[i] = '\0';
   for(i=0;i<60;i++) fWrite[i] = '\0';
@@ -91,6 +85,39 @@ ClassImp(AliITSv11)
   for(Int_t i=0; i<fIdN; i++) fIdSens[i] = 0;
 }
 
+
+//______________________________________________________________________
+AliITSv11::AliITSv11(const char *name, const char *title)
+  : AliITS("ITS", title)
+{
+  //    Standard constructor for the ITS version 11.
+
+  fGeomDetOut = kFALSE;
+  fGeomDetIn = kFALSE;
+  fMajorVersion = 11;
+  fMinorVersion = 0;
+  printf("%s\n constructor",name);
+
+  Int_t i;
+  for(i=0;i<60;i++) fRead[i] = '\0';
+  for(i=0;i<60;i++) fWrite[i] = '\0';
+  for(i=0;i<60;i++) fEuclidGeomDet[i] = '\0';
+  strncpy(fRead,"$ALICE_ROOT/ITS/ITSgeometry_vPPRasymmFMD.det",60);
+  SetEUCLID(kFALSE);
+
+//   fSPDgeom = new AliITSv11GeometrySPD();
+  fSDDgeom = new AliITSv11GeometrySDD();
+//   fSupgeom = new AliITSv11GeometrySupport();
+
+  fIdN = 1;         
+  fIdName    = new TString[fIdN];
+  fIdName[0] = fSDDgeom->GetSenstiveVolumeMame();
+  fIdSens    = new Int_t[fIdN];
+  for(Int_t i=0; i<fIdN; i++) fIdSens[i] = 0;
+}
+
+
+
 //______________________________________________________________________
 AliITSv11::AliITSv11(Int_t debugITS,Int_t debugSPD,Int_t debugSDD,
                   Int_t debugSSD,Int_t debugSUP) :
@@ -129,7 +156,7 @@ AliITSv11::AliITSv11(Int_t debugITS,Int_t debugSPD,Int_t debugSDD,
   fIdSens    = new Int_t[fIdN];
   for(Int_t i=0; i<fIdN; i++) fIdSens[i] = 0;
 
-  debugITS = (debugSPD && debugSSD && debugSUP); //remove temp. warnings
+  debugITS = (debugSPD && debugSSD && debugSUP && debugSDD); //remove temp. warnings
 }
 
 
@@ -197,8 +224,12 @@ void AliITSv11::CreateGeometry(){
   vALIC->AddNode(vITS,1,0);
 
 //   fSPDgeom->CenteralSPD(vITS);
+
+//   fSDDgeom->AddOnlyLay3Ladder(0,1);
+//   fSDDgeom->AddOnlyLay4Ladder(0,1);
   fSDDgeom->Layer3(vITS);
   fSDDgeom->Layer4(vITS);
+
 //     fSupgeom->SPDCone(vITS);
 //     fSupgeom->SPDThermalSheald(vITS);
 //     fSupgeom->SDDCone(vITS);
@@ -703,13 +734,20 @@ void AliITSv11::InitAliITSgeom(){
   // Fill fITSgeom with the 3 sub-detector geometries
   //
 
-  const Int_t knlayers = 2;             // only SDD for the moment
+  const Int_t knlayers = 6;
   Int_t nlad[knlayers],ndet[knlayers];
-  nlad[0]=14; nlad[1]=22;
-  ndet[0]=6;  ndet[1]=8;
-  Int_t mod = nlad[0]*ndet[0]+nlad[1]*ndet[1];
+  nlad[0]= 0; ndet[0]=0;
+  nlad[1]= 0; ndet[1]=0;
+  nlad[2]= fSDDgeom->GetLay3NLadders(); ndet[2]=6;
+  nlad[3]= fSDDgeom->GetLay4NLadders(); ndet[3]=8;
+  nlad[4]= 0; ndet[4]=0;
+  nlad[5]= 0; ndet[5]=0;
+  Int_t nSPD = nlad[0]*ndet[0]+nlad[1]*ndet[1];
+  Int_t nSDD = nlad[2]*ndet[2]+nlad[3]*ndet[3];
+  Int_t nSSD = nlad[4]*ndet[4]+nlad[5]*ndet[5];
+  Int_t nModTot = nSPD + nSDD + nSSD;
   if (fITSgeom) delete fITSgeom;
-  fITSgeom = new AliITSgeom(0,knlayers,nlad,ndet,mod);
+  fITSgeom = new AliITSgeom(0,knlayers,nlad,ndet,nModTot);
 
 
   //***************************************************
@@ -728,7 +766,7 @@ void AliITSv11::InitAliITSgeom(){
                         new AliITSgeomSSD75and275(3,(Float_t *)kDxyzSSD));
 
   //*****************************************
-  fSDDgeom->ExportSensorGeometry(fITSgeom, +1, 0);  //SDD
+  fSDDgeom->ExportSensorGeometry(fITSgeom, +3, 0);  //SDD
 
   return;
 }
@@ -741,7 +779,6 @@ void AliITSv11::Init(){
   //
 
     Int_t i;
-
     for(i=0;i<20;i++) printf("*");
     printf( " ITSv%i.%i_Init ", fMajorVersion,fMinorVersion );
     for(i=0;i<20;i++) printf("*"); printf("\n");
@@ -757,7 +794,6 @@ void AliITSv11::Init(){
 
     // Initialize AliITS
     AliITS::Init();
-
     for(i=0;i<40+16;i++) printf("*"); printf("\n");
 }
 
@@ -809,18 +845,18 @@ void AliITSv11::SetDefaults(){
   
   //================================================ SDD
   iDetType=DetType(kSDD);
-  s1 = (AliITSgeomSDD*) fITSgeom->GetShape(kSDD);// Get shape info. Do it this way for now.
+  s1 = (AliITSgeomSDD*) fITSgeom->GetShape(kSDD);
   if (s1) {
-    AliITSresponseSDD *resp1=new AliITSresponseSDD("simulated");
-    SetResponseModel(kSDD,resp1);
-    AliITSsegmentationSDD *seg1=new AliITSsegmentationSDD(fITSgeom,resp1);
-    seg1->SetDetSize(s1->GetDx()*kconv, // base this on AliITSgeomSDD
-                    s1->GetDz()*2.*kconv, // for now.
-                    s1->GetDy()*2.*kconv); // x,z,y full width in microns.
-    seg1->SetNPads(256,256);// Use AliITSgeomSDD for now
-    SetSegmentationModel(kSDD,seg1);
-    const char *kData1=(iDetType->GetResponseModel())->DataType();
-    const char *kopt=iDetType->GetResponseModel()->ZeroSuppOption();
+    AliITSresponseSDD     *resp1 = new AliITSresponseSDD("simulated");
+    AliITSsegmentationSDD  *seg1 = new AliITSsegmentationSDD(fITSgeom,resp1);
+    seg1->SetDetSize(s1->GetDx()*kconv,
+                    s1->GetDz()*4*kconv,  // z in 2th and y in 3th position in
+                    s1->GetDy()*4*kconv); // AliITSsegmentation::SetDetSize()...
+    seg1->SetNPads(256, 256);
+    SetResponseModel(kSDD, resp1);
+    SetSegmentationModel(kSDD, seg1);
+    const char *kData1 = (iDetType->GetResponseModel())->DataType();
+    const char *kopt   = iDetType->GetResponseModel()->ZeroSuppOption();
     if((!strstr(kopt,"2D")) && (!strstr(kopt,"1D")) || strstr(kData1,"real") ){
       iDetType->ClassNames("AliITSdigit","AliITSRawClusterSDD");
     } else iDetType->ClassNames("AliITSdigitSDD","AliITSRawClusterSDD");
@@ -856,8 +892,6 @@ void AliITSv11::SetDefaults(){
 };
 
 
-
-
 //______________________________________________________________________
 void AliITSv11::DrawModule() const{
 
index 1c2ff14..e67b8fa 100644 (file)
@@ -13,6 +13,7 @@ class AliITSv11 : public AliITS {
 
  public:
     AliITSv11();
+    AliITSv11(const char *name, const char *title);
     AliITSv11(Int_t debugITS, Int_t debugSPD = 0, Int_t debugSDD = 0,
             Int_t debugSSD = 0, Int_t debugSUP = 0);
     AliITSv11(const AliITSv11 &source);            // copy constructor
@@ -82,7 +83,7 @@ class AliITSv11 : public AliITS {
 
 
     //AliITSv11GeometrySPD *fSPDgeom;      //SPD Geometry
-    AliITSv11GeometrySDD *fSDDgeom;      //SDD Geometry
+    AliITSv11GeometrySDD *fSDDgeom;      //! SDD Geometry
     //AliITSv11GeometrySupport /fSupgeom;  //Support Geometry
 
     ClassDef(AliITSv11,1)  // ITS version 11 
index 4fe811d..9c5726c 100644 (file)
@@ -54,12 +54,14 @@ AliITSv11GeomCable::AliITSv11GeomCable(const AliITSv11GeomCable &s) :
   fVolumeArray(s.fVolumeArray),fInitialNode(s.fInitialNode)
 {
   //     Copy Constructor 
+  printf("Copy Constructor of AliITSv11GeomCable ???\n");  
 }
 
 //________________________________________________________________________
 AliITSv11GeomCable& AliITSv11GeomCable::operator=(const AliITSv11GeomCable &s) {
   //     Assignment operator
   // Not fully inplemented yet !!!
+  printf("Assignment operator of AliITSv11GeomCable not fully inplemented yet !!!\n");  
 
   if(&s == this) return *this;
   SetName(s.GetName());
@@ -114,11 +116,7 @@ const {
   // Get the check point #iCheckPt
   //
   TVectorD *coordVector =(TVectorD *)fPointArray.UncheckedAt(iCheckPt);
-#if ROOT_VERSION_CODE < ROOT_VERSION(4,0,0)
-  CopyFrom(coord, coordVector->GetElements());
-#else
   CopyFrom(coord, coordVector->GetMatrixArray());
-#endif
   return kTRUE;
 };
 
@@ -130,11 +128,7 @@ const {
   //
 
   TVectorD *coordVector =(TVectorD *)fPointArray.UncheckedAt(iCheckPt);
-#if ROOT_VERSION_CODE < ROOT_VERSION(4,0,0)
-  CopyFrom(coord, coordVector->GetElements());
-#else
   CopyFrom(coord, coordVector->GetMatrixArray());
-#endif
   return kTRUE;
 };
 
index ee85a95..725dfc3 100644 (file)
@@ -109,11 +109,7 @@ Int_t AliITSv11GeomCableFlat::GetPoint( Int_t iCheckPt, Double_t *coord)
   // Get the correct point #iCheckPt
   TVectorD *coordVector =(TVectorD *)fPointArray.At(2*iCheckPt);
   if (coordVector) {
-#if ROOT_VERSION_CODE < ROOT_VERSION(4,0,0)
-    CopyFrom(coord, coordVector->GetElements());
-#else
     CopyFrom(coord, coordVector->GetMatrixArray());
-#endif
     return kTRUE;
   } else {
     return kFALSE;
@@ -128,11 +124,7 @@ Int_t AliITSv11GeomCableFlat::GetVect( Int_t iCheckPt, Double_t *coord)
 
   TVectorD *coordVector =(TVectorD *)fPointArray.At(2*iCheckPt+1);
   if (coordVector) {
-#if ROOT_VERSION_CODE < ROOT_VERSION(4,0,0)
-    CopyFrom(coord, coordVector->GetElements());
-#else
     CopyFrom(coord, coordVector->GetMatrixArray());
-#endif
     return kTRUE;
   } else {
     return kFALSE;
index 73e681d..ccf518d 100644 (file)
@@ -24,6 +24,7 @@
 #include <TGeoManager.h>
 #include <TGeoVolume.h>
 #include <TGeoTube.h>
+#include <TGeoTorus.h>
 #include <TGeoMatrix.h>
 
 #include "AliITSv11GeomCableRound.h"
 // Ludovic Gaudichet                                   gaudichet@to.infn.it
 //*************************************************************************
 
+/*
+// ************************************************************************
+// Here is a example on how to use this class
+// ************************************************************************
+
+  // Getting some media 
+  TGeoMedium *air   = gGeoManager->GetMedium("ITSair");
+  TGeoMedium *water = gGeoManager->GetMedium("WATER");
+  TGeoMedium *alu   = gGeoManager->GetMedium("ITSal"); 
+
+  // Creating a small box inside a bigger one (containers)
+  TGeoBBox *box1      = new TGeoBBox("box1", 6,10,10);
+  TGeoBBox *bigBox    = new TGeoBBox("bigBox", 20,10,10);
+  TGeoVolume *vbox1   = new TGeoVolume("vbox1", box1, air);
+  TGeoVolume *vBigBox = new TGeoVolume("vBigBox", bigBox, air);
+  vbox1->SetVisibility(kFALSE);
+  vBigBox->SetVisibility(kFALSE);
+
+  TGeoTranslation *tr1 = new TGeoTranslation("negTr",-14,0,0);
+  vBigBox->AddNode(vbox1, 1, tr1);
+  moth->AddNode(vBigBox, 1, 0);
+
+  // **************************************************
+  // Inserting a round cable (or here a water pipe...)
+  // **************************************************
+
+  Int_t waterColor = 7;
+  Int_t aluColor = 5;
+  AliITSv11GeomCableRound roundCable("waterPipe", 0.9); //radius of 0.9cm
+  roundCable.SetNLayers(2); 
+  roundCable.SetLayer(0, 0.7, water, waterColor); // radius of 0.7cm
+  roundCable.SetLayer(1, 0.2, alu, aluColor);     // thickness of 0.2cm
+
+  // ****** Set check points and their containers ******
+  // The 2 first points are in the small box (vbox1)
+  // The second point is at the boundary 
+
+  Double_t coord0[3] = {0,-2,-2};
+  Double_t coord1[3] = {6,2,1};
+  Double_t vect0[3]  = {1,1,0};
+  Double_t vect1[3]  = {1,0,0};
+  // coordinates have to be given in the specified container
+  // reference system (here it's going to be vbox1).
+  // vect1 and vect2 are vectors perpendicular to the segment ends
+  // (These vectors don't need to be normalized)
+  roundCable.AddCheckPoint( vbox1, 0, coord0, vect0);
+  roundCable.AddCheckPoint( vbox1, 1, coord1, vect1);
+
+  // Then, let's cross the boundary ! You just need
+  // to put the next point in the other volume, vBigBox.
+  // At the moment of creating the second segment, it will
+  // be inserted in this volume. That is why the point 1 had to
+  // be at the boundary, because otherwise the second segment
+  // between de points 1 and 2 would have been inserted in the
+  // vBigBox but in the same time would have cross its
+  // boundary ...
+  Double_t coord2[3] = {-2,6,4}; // coord. syst. of vBigBox !
+  Double_t vect2[3]= {1,1,0.5};
+  roundCable.AddCheckPoint( vBigBox, 2, coord2, vect2);
+
+  Double_t coord3[3] = {4,6,4};
+  Double_t vect3[3]= {-1,0,0};
+  roundCable.AddCheckPoint( vBigBox, 3, coord3, vect3);
+
+  Double_t coord4[3] = {4,0,-4};
+  Double_t vect4[3]= {1,0,0};
+  roundCable.AddCheckPoint( vBigBox, 4, coord4, vect4);
+
+  Double_t coord5[3] = {4,-6,4};
+  Double_t vect5[3]= {1,0,0};
+  roundCable.AddCheckPoint( vBigBox, 5, coord5, vect5);
+
+  Double_t coord6[3] = {7,-6,4};
+  Double_t vect6[3]= {1,0,0};
+  roundCable.AddCheckPoint( vBigBox, 6, coord6, vect6);
+
+  Double_t r = 7;
+  Double_t angle = 70*TMath::DegToRad(); 
+  Double_t coord7[3] = {coord6[0] +r*sin(angle), coord6[1],
+                       coord6[2] -r*(1-cos(angle)) };
+  Double_t vect7[3]= {r*cos(angle),0,-r*sin(angle)};
+  roundCable.AddCheckPoint( vBigBox, 7, coord7, vect7);
+
+  Double_t coord8[3] = { coord7[0]+vect7[0], coord7[1]+vect7[1],-10};
+  Double_t vect8[3]= {0,0,1};
+  roundCable.AddCheckPoint( vBigBox, 8, coord8, vect8);
+
+  // ****** Creating the corresponding volume ******
+  // Since the container volumes of the check points have
+  // been recorded, this can be done at any moments, providing
+  // that the container volumes are found in the sub-nodes
+  // of the initial node (the top volume of the TGeoManager or
+  // the volume set in SetInitialNode(TGeoVolume*) function)
+
+  roundCable.SetInitialNode(vBigBox); //Set the root node
+  roundCable.CreateAndInsertCableSegment( 1);
+  // This command means : create the segment between point 0
+  // and point 1. The segment is automatically inserted in the
+  // container volume of point 1.
+
+  roundCable.CreateAndInsertCableSegment( 2);
+  roundCable.CreateAndInsertCableSegment( 3);
+
+  // The following segment is going to be a torus segment.
+  // The radius and position of the torus is defined by the
+  // orthogonal vector of point 4 (the orientation of this vector
+  // and the position of the 2 check points are enough to define
+  // completely the torus)
+  roundCable.CreateAndInsertTorusSegment( 4, 180);
+  // The second argument is an additionnal rotation of the
+  // segment around the axis defined by the 2 check points.
+
+  roundCable.CreateAndInsertTorusSegment( 5);
+  roundCable.CreateAndInsertCableSegment( 6);
+  roundCable.CreateAndInsertTorusSegment( 7,180);
+  roundCable.CreateAndInsertCableSegment( 8);
+
+*/
+
+
+
 ClassImp(AliITSv11GeomCableRound)
 
 //________________________________________________________________________
@@ -90,11 +212,7 @@ Int_t AliITSv11GeomCableRound::GetPoint( Int_t iCheckPt, Double_t *coord)
   const {
   // Get check point #iCheckPt
   TVectorD *coordVector =(TVectorD *)fPointArray.UncheckedAt(2*iCheckPt);
-#if ROOT_VERSION_CODE < ROOT_VERSION(4,0,0)
-  CopyFrom(coord, coordVector->GetElements());
-#else
   CopyFrom(coord, coordVector->GetMatrixArray());
-#endif
   return kTRUE;
 };
 
@@ -106,11 +224,7 @@ Int_t AliITSv11GeomCableRound::GetVect( Int_t iCheckPt, Double_t *coord)
   //
 
   TVectorD *coordVector =(TVectorD *)fPointArray.UncheckedAt(2*iCheckPt+1);
-#if ROOT_VERSION_CODE < ROOT_VERSION(4,0,0)
-  CopyFrom(coord, coordVector->GetElements());
-#else
   CopyFrom(coord, coordVector->GetMatrixArray());
-#endif
   return kTRUE;
 };
 //________________________________________________________________________
@@ -148,23 +262,18 @@ void AliITSv11GeomCableRound::PrintCheckPoints() const {
     TVectorD *coordVector = (TVectorD *)fPointArray.UncheckedAt(i*2);
     //TVectorD *vectVector = (TVectorD *)fPointArray.UncheckedAt(i*2+1);
     Double_t coord[3];
-#if ROOT_VERSION_CODE < ROOT_VERSION(4,0,0)
-    CopyFrom(coord, coordVector->GetElements());
-#else
     CopyFrom(coord, coordVector->GetMatrixArray());
-#endif
 
     printf("   ( %.2f, %.2f, %.2f )\n", coord[0], coord[1], coord[2]);
   };
 
 };
 
+
 //________________________________________________________________________
 Int_t AliITSv11GeomCableRound::CreateAndInsertCableSegment(Int_t p2)
 {
 //    Creates a cable segment between points p1 and p2.
-//    Rotation is the eventual rotation of the flat cable
-//    along its length axis
 //
 // The segment volume is created inside the volume containing point2
 // Therefore this segment should be defined in this volume only.
@@ -305,12 +414,178 @@ Int_t AliITSv11GeomCableRound::CreateAndInsertCableSegment(Int_t p2)
   return kTRUE;
 };
 
+
+//________________________________________________________________________
+Int_t AliITSv11GeomCableRound::CreateAndInsertTorusSegment(Int_t p2, Double_t rotation)
+{
+  // Create a torus cable segment between points p1 and p2.
+  // The radius and position of the torus is defined by the
+  // perpendicular vector of point p2 (the orientation of this vector
+  // and the position of the 2 check points are enough to completely
+  // define the torus)
+
+  TGeoNode *mainNode;
+  if (fInitialNode==0) {
+    TObjArray *nodes = gGeoManager->GetListOfNodes();
+    if (nodes->GetEntriesFast()==0) return kFALSE;
+    mainNode = (TGeoNode *) nodes->UncheckedAt(0);
+  } else {
+    mainNode = fInitialNode;
+  };
+
+  Int_t p1 = p2 - 1;
+  TGeoVolume *p1Vol = GetVolume(p1);
+  TGeoVolume *p2Vol = GetVolume(p2);
+
+  ResetCheckDaughter();
+  fCurrentVol = p1Vol;
+  if (! CheckDaughter(mainNode)) {
+    printf("Error::volume containing point is not visible in node tree!\n");
+    return kFALSE;
+  };
+
+  Double_t coord1[3], coord2[3], vect1[3], vect2[3];
+  //=================================================
+  // Get p1 position in the systeme of p2
+  if (p1Vol!=p2Vol) {
+
+    Int_t p1nodeInd[fgkCableMaxNodeLevel]; 
+    for (Int_t i=0; i<fgkCableMaxNodeLevel; i++) p1nodeInd[i]=fNodeInd[i];
+    Int_t p1volLevel = 0;
+    while (p1nodeInd[p1volLevel]!=-1) p1volLevel++;
+    p1volLevel--;
+
+    ResetCheckDaughter();
+    fCurrentVol = p2Vol;
+    if (! CheckDaughter(mainNode)) {
+      printf("Error::volume containing point is not visible in node tree!\n");
+      return kFALSE;
+    };
+    Int_t p2nodeInd[fgkCableMaxNodeLevel];
+    for (Int_t i=0; i<fgkCableMaxNodeLevel; i++) p2nodeInd[i]=fNodeInd[i];
+    Int_t commonMotherLevel = 0;
+    while (p1nodeInd[commonMotherLevel]==fNodeInd[commonMotherLevel])
+      commonMotherLevel++;
+    commonMotherLevel--;
+    Int_t p2volLevel = 0;
+    while (fNodeInd[p2volLevel]!=-1) p2volLevel++;
+    p2volLevel--;
+
+    // Get coord and vect of p1 in the common mother reference system
+    GetCheckPoint(p1, 0, p1volLevel-commonMotherLevel, coord1);
+    GetCheckVect( p1, 0, p1volLevel-commonMotherLevel, vect1);
+    // Translate them in the reference system of the volume containing p2    
+    TGeoNode *pathNode[fgkCableMaxNodeLevel];
+    pathNode[0] = mainNode;
+    for (Int_t i=0; i<=p2volLevel; i++) {
+      pathNode[i+1] = pathNode[i]->GetDaughter(p2nodeInd[i]);
+    };
+    Double_t globalCoord1[3] = {coord1[0], coord1[1], coord1[2]}; 
+    Double_t globalVect1[3]  = {vect1[0], vect1[1], vect1[2]};
+
+    for (Int_t i = commonMotherLevel+1; i<=p2volLevel; i++) {
+      pathNode[i+1]->GetMatrix()->MasterToLocal(globalCoord1, coord1);
+      pathNode[i+1]->GetMatrix()->MasterToLocalVect(globalVect1, vect1);
+      CopyFrom(globalCoord1, coord1);
+      CopyFrom(globalVect1, vect1);
+    };
+  } else {
+    GetCheckPoint(p1, 0, 0, coord1);
+    GetCheckVect(p1, 0, 0, vect1);
+  };
+  
+  //=================================================
+  // Get p2 position in the systeme of p2
+  GetCheckPoint(p2, 0, 0, coord2);
+  GetCheckVect(p2, 0, 0, vect2);
+
+  Double_t cx = (coord1[0]+coord2[0])/2;
+  Double_t cy = (coord1[1]+coord2[1])/2;
+  Double_t cz = (coord1[2]+coord2[2])/2;
+  Double_t dx = coord2[0]-coord1[0];
+  Double_t dy = coord2[1]-coord1[1];
+  Double_t dz = coord2[2]-coord1[2];
+  Double_t length = TMath::Sqrt(dx*dx+dy*dy+dz*dz);
+
+  //=================================================
+  // Positionning of the segment between the 2 points
+  if ((dy<1e-31)&&(dy>0)) dy = 1e-31;
+  if ((dz<1e-31)&&(dz>0)) dz = 1e-31;
+  if ((dy>-1e-31)&&(dy<0)) dy = -1e-31;
+  if ((dz>-1e-31)&&(dz<0)) dz = -1e-31;
+
+  Double_t angleRot1 = -TMath::ATan2(dx,dy);
+  Double_t planDiagL = TMath::Sqrt(dy*dy+dx*dx);
+  Double_t angleRotDiag = -TMath::ATan2(planDiagL,dz);
+
+  TGeoRotation rotTorusTemp("",angleRot1*TMath::RadToDeg(),
+                           angleRotDiag*TMath::RadToDeg(),0);
+  TGeoRotation rotTorusToZ("",0,90,0);
+  rotTorusTemp.MultiplyBy(&rotTorusToZ, kTRUE);
+  Double_t localVect2[3];
+  rotTorusTemp.MasterToLocalVect(vect2, localVect2);
+  if (localVect2[1]<0) {
+    localVect2[0] = -localVect2[0];
+    localVect2[1] = -localVect2[1];
+    localVect2[2] = -localVect2[2];
+  };
+  Double_t normVect2 = TMath::Sqrt(localVect2[0]*localVect2[0]+
+                                  localVect2[1]*localVect2[1]+
+                                  localVect2[2]*localVect2[2]);
+  Double_t axisX[3] = {1,0,0};
+  Double_t cosangleTorusSeg = (localVect2[0]*axisX[0]+
+                              localVect2[1]*axisX[1]+
+                              localVect2[2]*axisX[2])/normVect2;
+  Double_t angleTorusSeg = TMath::ACos(cosangleTorusSeg)*TMath::RadToDeg();
+  TGeoRotation rotTorus("",angleRot1*TMath::RadToDeg(),
+                       angleRotDiag*TMath::RadToDeg(),
+                       180-angleTorusSeg+rotation);
+  rotTorus.MultiplyBy(&rotTorusToZ, kTRUE);
+  rotTorus.MasterToLocalVect(vect2, localVect2);
+  if (localVect2[1]<0) {
+    localVect2[0] = -localVect2[0];
+    localVect2[1] = -localVect2[1];
+    localVect2[2] = -localVect2[2];
+  };
+  normVect2 = TMath::Sqrt(localVect2[0]*localVect2[0]+
+                         localVect2[1]*localVect2[1]+
+                         localVect2[2]*localVect2[2]);
+  Double_t axisY[3] = {0,1,0};
+  Double_t cosPhi = (localVect2[0]*axisY[0]+localVect2[1]*axisY[1]+
+                    localVect2[2]*axisY[2])/normVect2;
+  Double_t torusPhi1 = TMath::ACos(cosPhi);
+  Double_t torusR = (length/2)/TMath::Sin(torusPhi1);
+  torusPhi1 = torusPhi1*TMath::RadToDeg();
+  Double_t perpLength = TMath::Sqrt(torusR*torusR-length*length/4);
+  Double_t localTransT[3] = {-perpLength,0,0};
+  Double_t globalTransT[3];
+  rotTorus.LocalToMasterVect(localTransT, globalTransT);
+  TGeoTranslation transTorus("",cx+globalTransT[0],cy+globalTransT[1],
+                            cz+globalTransT[2]);
+
+  TGeoCombiTrans  *combiTorus = new TGeoCombiTrans(transTorus, rotTorus);
+
+  //=================================================
+  // Create the segment and add it to the mother volume
+  TGeoVolume *vCableSegT = CreateTorus(torusPhi1, torusR);
+  p2Vol->AddNode(vCableSegT, p2, combiTorus);
+
+  if (fDebug) {
+    printf("---\n  Cable segment points : ");
+    printf("%f, %f, %f\n",coord1[0], coord1[1], coord1[2]);
+    printf("%f, %f, %f\n",coord2[0], coord2[1], coord2[2]);
+  };
+
+  return kTRUE;
+};
+
 //________________________________________________________________________
 TGeoVolume *AliITSv11GeomCableRound::CreateSegment( Double_t *coord1,
                                                      Double_t *coord2,
                                                      Double_t *localVect1,
                                                      Double_t *localVect2 )
 {
+  // Create one cylindrical segment and its layers
 
   //=================================================
   // Calculate segment "deformation"
@@ -332,7 +607,7 @@ TGeoVolume *AliITSv11GeomCableRound::CreateSegment( Double_t *coord1,
   };
   //=================================================
   // Create the segment
-  TGeoCtub *cableSeg = new TGeoCtub(0., fRadius, length/2, fPhiMin, fPhiMax,
+  TGeoCtub *cableSeg = new TGeoCtub(0, fRadius, length/2, fPhiMin, fPhiMax,
                                    localVect1[0],localVect1[1],localVect1[2],
                                    localVect2[0],localVect2[1],localVect2[2]);
 
@@ -361,6 +636,42 @@ TGeoVolume *AliITSv11GeomCableRound::CreateSegment( Double_t *coord1,
 
 
 //________________________________________________________________________
+TGeoVolume *AliITSv11GeomCableRound::CreateTorus( Double_t &phi,
+                                                 Double_t &r)
+{
+  // Create one torus segment and its layers
+
+  Double_t torusR = r;
+  Double_t torusPhi1 = phi;
+  Double_t torusDPhi = -2*torusPhi1;
+
+  //=================================================
+  // Create the segment
+  TGeoTorus *cableSeg = new TGeoTorus(torusR, 0,fRadius,torusPhi1,torusDPhi);
+  TGeoMedium *airSDD = gGeoManager->GetMedium("ITSair");
+  TGeoVolume *vCableSeg = new TGeoVolume(GetName(), cableSeg, airSDD);
+
+  // add all cable layers
+  Double_t layThickness[100+1];                        // 100 layers max !!!
+  layThickness[0] = 0;
+  for (Int_t iLay=0; iLay<fNlayer; iLay++) {
+    
+    layThickness[iLay+1] = fLayThickness[iLay]+layThickness[iLay];
+    TGeoTorus *lay = new TGeoTorus(torusR, layThickness[iLay],
+                                  layThickness[iLay+1],
+                                  torusPhi1,torusDPhi);
+
+    TGeoVolume *vLay = new TGeoVolume("vCableSegLay",lay,fLayMedia[iLay]);
+    vLay->SetLineColor(fLayColor[iLay]);
+    vCableSeg->AddNode(vLay, iLay+1, 0);
+  };
+
+  vCableSeg->SetVisibility(kFALSE);
+  return vCableSeg;
+};
+
+
+//________________________________________________________________________
 void AliITSv11GeomCableRound::SetNLayers(Int_t nLayers) {
   // Set the total number of layers
   if((nLayers>0) &&(nLayers<=fgkCableMaxLayer)) {
index e5fe851..5bcaa34 100644 (file)
@@ -30,6 +30,7 @@ class AliITSv11GeomCableRound : public AliITSv11GeomCable {
   void          AddCheckPoint( TGeoVolume *vol, Int_t iCheckPt,
                               Double_t *coord, Double_t *orthVect);
   Int_t         CreateAndInsertCableSegment(Int_t p2);
+  Int_t         CreateAndInsertTorusSegment(Int_t p2, Double_t rotation=0);
   void          PrintCheckPoints() const;
 
   void          SetNLayers(Int_t nLayers);
@@ -41,10 +42,10 @@ class AliITSv11GeomCableRound : public AliITSv11GeomCable {
  protected:
   TGeoVolume*   CreateSegment( Double_t *coord1,Double_t *coord2,
                               Double_t *localVect1, Double_t *localVect2 );
+  TGeoVolume*   CreateTorus(  Double_t &phi, Double_t &r );
 
   Double_t   fRadius;                         // total radius
   Int_t      fNlayer;                         // number of layers
-
   Double_t   fPhiMin;                         // minimum phi
   Double_t   fPhiMax;                         // maximum phi
   Double_t   fLayThickness[fgkCableMaxLayer]; // layer thicknesses
index 0c30dcb..7dfd50b 100755 (executable)
@@ -52,17 +52,17 @@ const Double_t AliITSv11GeometrySDD::fgkLadderSegBoxDH    =  3.*fgkmm;
 
 const Double_t AliITSv11GeometrySDD::fgkLadderBeamRadius  =  0.6*fgkmm;
 const Double_t AliITSv11GeometrySDD::fgkLadderLa          =  3.*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLadderHa          =  0.6*fgkmm;     //total ???
+const Double_t AliITSv11GeometrySDD::fgkLadderHa          =  0.721979*fgkmm;
 const Double_t AliITSv11GeometrySDD::fgkLadderLb          =  3.7*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkLadderHb          =  0.6*fgkmm;     //total ???
+const Double_t AliITSv11GeometrySDD::fgkLadderHb          =  0.890428*fgkmm;
 const Double_t AliITSv11GeometrySDD::fgkLadderl           =  0.25*fgkmm;
 
 const Double_t AliITSv11GeometrySDD::fgkBottomBeamAngle   = 56.5;
 const Double_t AliITSv11GeometrySDD::fgkBeamSidePhi       = 65;
 
 const Double_t AliITSv11GeometrySDD::fgkLadWaferSep       = 2*fgkmm;
-const Double_t AliITSv11GeometrySDD::fgkPinSuppWidth      = 2.5*fgkmm;       // ???
-const Double_t AliITSv11GeometrySDD::fgkPinSuppHeight     = 2.*fgkmm;        // ???
+const Double_t AliITSv11GeometrySDD::fgkPinSuppWidth      = 2.5*fgkmm;
+const Double_t AliITSv11GeometrySDD::fgkPinSuppHeight     = 2.*fgkmm;
 const Double_t AliITSv11GeometrySDD::fgkPinSuppRmax       = 2.5/2.*fgkmm;
 const Double_t AliITSv11GeometrySDD::fgkPinR              = 1.5/2.*fgkmm;
 const Double_t AliITSv11GeometrySDD::fgkPinSuppLength     = 5.*fgkmm;
@@ -230,15 +230,13 @@ ClassImp(AliITSv11GeometrySDD)
   //
   // Standard constructor
   //
-
-  fDigitCableLay3A = new AliITSv11GeomCableFlat[fgkLay3Ndet];
-  fDigitCableLay3B = new AliITSv11GeomCableFlat[fgkLay3Ndet];
-  fDigitCableLay4A = new AliITSv11GeomCableFlat[fgkLay4Ndet];
-  fDigitCableLay4B = new AliITSv11GeomCableFlat[fgkLay4Ndet];
+  fDigitCableLay3A = 0;
+  fDigitCableLay3B = 0;
+  fDigitCableLay4A = 0;
+  fDigitCableLay4B = 0;
   SetParameters();
 };
 
-
 //________________________________________________________________________
 AliITSv11GeometrySDD::AliITSv11GeometrySDD(Int_t debug) :
   AliITSv11Geometry(debug),fMotherVol(0),fAddHybrids(kTRUE),fAddSensors(kTRUE),
@@ -250,11 +248,10 @@ AliITSv11GeometrySDD::AliITSv11GeometrySDD(Int_t debug) :
   //
   // Constructor setting debugging level
   //
-
-  fDigitCableLay3A = new AliITSv11GeomCableFlat[fgkLay3Ndet];
-  fDigitCableLay3B = new AliITSv11GeomCableFlat[fgkLay3Ndet];
-  fDigitCableLay4A = new AliITSv11GeomCableFlat[fgkLay4Ndet];
-  fDigitCableLay4B = new AliITSv11GeomCableFlat[fgkLay4Ndet];
+  fDigitCableLay3A = 0;
+  fDigitCableLay3B = 0;
+  fDigitCableLay4A = 0;
+  fDigitCableLay4B = 0;
   SetParameters();
 };
 
@@ -268,10 +265,10 @@ AliITSv11GeometrySDD::AliITSv11GeometrySDD(const AliITSv11GeometrySDD &s) :
  fAddOnlyLadder4min(s.fAddOnlyLadder4min), fAddOnlyLadder4max(s.fAddOnlyLadder4max)
 {
   //     Copy Constructor 
-  fDigitCableLay3A = new AliITSv11GeomCableFlat[fgkLay3Ndet];
-  fDigitCableLay3B = new AliITSv11GeomCableFlat[fgkLay3Ndet];
-  fDigitCableLay4A = new AliITSv11GeomCableFlat[fgkLay4Ndet];
-  fDigitCableLay4B = new AliITSv11GeomCableFlat[fgkLay4Ndet];
+  fDigitCableLay3A = 0;
+  fDigitCableLay3B = 0;
+  fDigitCableLay4A = 0;
+  fDigitCableLay4B = 0;
   SetParameters();
 }
 
@@ -311,22 +308,22 @@ void AliITSv11GeometrySDD::SetParameters() {
   // Define display colors and the non constant geometry parameters
   //
 
-  fColorCarbonFiber = 4;
-  fColorRyton = 5;
-  fColorPhynox = 7;
-  fColorSilicon = 3;
-  fColorAl = 7;
-  fColorPolyhamide = 5;
-  fColorGlass = 2;
-  fColorSMD = 12;
-  fColorSMDweld = 17;
-
-  fPinSupport = 0;
+  fColorCarbonFiber =  4;
+  fColorRyton       =  5;
+  fColorPhynox      =  7;
+  fColorSilicon     =  3;
+  fColorAl          =  7;
+  fColorPolyhamide  =  5;
+  fColorGlass       =  2;
+  fColorSMD         = 12;
+  fColorSMDweld     = 17;
+
+  fPinSupport       = 0;
   fCoolPipeSupportL = 0;
   fCoolPipeSupportR = 0;
-  fSDDsensor = 0;
-  fBaseThermalBridge = 0;
-  fHybrid = 0;
+  fSDDsensor        = 0;
+  fBaseThermalBridge= 0;
+  fHybrid           = 0;
 
   Double_t detLadderDist = 8*fgkmm; 
 
@@ -364,7 +361,6 @@ void AliITSv11GeometrySDD::SetParameters() {
   fLay4sensorZPos[7] = ( -35.6-74.8-72.4-76.  )*fgkmm;
 };
 
-
 //________________________________________________________________________
 TGeoMedium* AliITSv11GeometrySDD::GetMedium(const char* mediumName) {
   //
@@ -375,17 +371,43 @@ TGeoMedium* AliITSv11GeometrySDD::GetMedium(const char* mediumName) {
   TGeoMedium* medium =  gGeoManager->GetMedium(mediumName);
   if (! medium)
     printf("Error(AliITSv11GeometrySDD)::medium %s not found !\n", mediumName);
-
   return medium;
 };
 
 //________________________________________________________________________
+Int_t AliITSv11GeometrySDD::GetLay3NLadders() const{
+  // Get the actual number of ladder in layer 3
+  if ( (fAddOnlyLadder3min<0) ||
+       (fAddOnlyLadder3min >= fgkLay3Nladd) ||
+       (fAddOnlyLadder3max<0) ||
+       (fAddOnlyLadder3max >= fgkLay3Nladd) )
+    return fgkLay3Nladd;
+  else return (fAddOnlyLadder3max-fAddOnlyLadder3min+1);
+}
+
+//________________________________________________________________________
+Int_t AliITSv11GeometrySDD::GetLay4NLadders() const{
+  // Get the actual number of ladder in layer 4
+  if ( (fAddOnlyLadder4min<0) ||
+       (fAddOnlyLadder4min >= fgkLay4Nladd) ||
+       (fAddOnlyLadder4max<0) ||
+       (fAddOnlyLadder4max >= fgkLay4Nladd) )
+    return fgkLay4Nladd;
+  else return (fAddOnlyLadder4max-fAddOnlyLadder4min+1);
+}
+
+//________________________________________________________________________
 void AliITSv11GeometrySDD::CreateBasicObjects() {
   //
   // Create basics objets which will be assembled together
   // in Layer3 and Layer4 functions
   //
 
+  fDigitCableLay3A = new AliITSv11GeomCableFlat[fgkLay3Ndet];
+  fDigitCableLay3B = new AliITSv11GeomCableFlat[fgkLay3Ndet];
+  fDigitCableLay4A = new AliITSv11GeomCableFlat[fgkLay4Ndet];
+  fDigitCableLay4B = new AliITSv11GeomCableFlat[fgkLay4Ndet];
+
   fPinSupport = CreatePinSupport();
   fCoolPipeSupportL = CreateCoolPipeSupportL();
   fCoolPipeSupportR = CreateCoolPipeSupportR();
@@ -645,90 +667,18 @@ void AliITSv11GeometrySDD::AddTranslationToCombiTrans(TGeoCombiTrans* ct,
 void AliITSv11GeometrySDD::ShowOnePiece(TGeoVolume *moth) {
 // for code developpment and debugging purposes
 
- if (! fSDDsensor) CreateBasicObjects();
-
-//     Moth->AddNode(fBaseThermalBridge, 1, 0);
-     moth->AddNode(fHybrid,100,0);
-//     moth->AddNode(fSDDsensor, 1, 0);
-
-//   TGeoVolume* seg = CreateLadderSegment( 4, 0); //lay 4
-//   moth->AddNode(seg, 1, 0);
-
+   if (! fSDDsensor) CreateBasicObjects();
 
+//   moth->AddNode(fPinSupport, 1, 0);
+//   moth->AddNode(fCoolPipeSupportL, 1, 0);
+//   moth->AddNode(fBaseThermalBridge, 1, 0);
+//   moth->AddNode(fHybrid,100,0);
+   moth->AddNode(fSDDsensor, 1, 0);
 
 
-//  TGeoBBox *box1 = new TGeoBBox("box1", 5,5,5);
-//  TGeoMedium *air = GetMedium("ITSair");
-//  TGeoVolume *vbox1 = new TGeoVolume("vbox1", box1, air);
-//  TGeoBBox *box2 = new TGeoBBox("box2", 6,6,6);
-//  TGeoVolume *vbox2 = new TGeoVolume("vbox2", box2, air);
-//  TGeoBBox *box3 = new TGeoBBox("box3", 7,7,7);
-//  TGeoVolume *vbox3 = new TGeoVolume("vbox3", box3, air);
-
-//  vbox1->AddNode(fHybrid,100,0);
-//  vbox2->AddNode(vbox1,1,0);
-//  vbox3->AddNode(vbox2,1,0);
-//  moth->AddNode(vbox3,1,0);
-
-
-
-//   //testing cable
-//   TGeoBBox *box1 = new TGeoBBox("box1", 10,10,10);
-//   TGeoBBox *box2 = new TGeoBBox("box2", 10,10,10);
-//   TGeoBBox *box3 = new TGeoBBox("box3", 20,10,10);
-//   TGeoMedium *air = GetMedium("ITSsddAir");
-//   TGeoVolume *vbox1 = new TGeoVolume("vbox1", box1, air);
-//   TGeoVolume *vbox2 = new TGeoVolume("vbox2", box2, air);
-//   TGeoVolume *vbox3 = new TGeoVolume("vbox3", box3, air);
-
-//   TGeoTranslation *tr1 = new TGeoTranslation("merdeneg",-10,0,0);
-//   TGeoTranslation *tr2 = new TGeoTranslation("merdepos",10,0,0);
-
-//   AliITSv11GeomCableRound napCable(0.9);
-//   //AliITSv11GeomCableFlat napCable(2,0.9);
-//   napCable.SetNLayers(3);
-//   napCable.SetLayer(0, 0.2, air);
-//   napCable.SetLayer(1, 0.2, air);
-//   napCable.SetLayer(2, 0.5, air);
-
-//   napCable.SetInitialNode(vbox3);
-
-//   Double_t coord1[3] = {0,-2,-2};
-//   Double_t vect1[3]= {1,1,0};
-//   napCable.AddCheckPoint( vbox1, 0, coord1, vect1);
-//   Double_t coord2[3] = {10,0,0};
-//   Double_t vect2[3]= {1,0,0};
-//   napCable.AddCheckPoint( vbox1, 1, coord2, vect2);
-
-//   //Double_t coord3[3] = {7,7,7};
-//   Double_t coord3[3] = {7,-7,-7};
-//   Double_t vect3[3]= {1,0,0};
-//   napCable.AddCheckPoint( vbox3, 2, coord3, vect3);
-
-//   Double_t coord4[3] = {19,7,7};
-//   Double_t vect4[3]= {-1,0,2};
-//   napCable.AddCheckPoint( vbox3, 3, coord4, vect4);
-
-//   Double_t coord5[3] = {1,7,7};
-//   Double_t vect5[3]= {1,0,0};
-//   napCable.AddCheckPoint( vbox3, 4, coord5, vect5);
+//   TGeoVolume* seg = CreateLadderSegment( 3, 0);
+//   moth->AddNode(seg, 1, 0);
 
-//   TGeoRotation *rot = new TGeoRotation("",0,0,0);
-//   TGeoCombiTrans *combi = new TGeoCombiTrans(*tr1,*rot );
-//   //vbox3->AddNode(vbox1,1,tr1);
-//   vbox3->AddNode(vbox1,1,combi);
-//   moth->AddNode(vbox3,1,0);
-
-// //   napCable.CreateAndInsertCableSegment( 1, 135);
-// //   napCable.CreateAndInsertCableSegment( 2, 0);
-// //   napCable.CreateAndInsertCableSegment( 3, 0);
-// //   napCable.CreateAndInsertCableSegment( 4, 0);
-//   napCable.CreateAndInsertCableSegment( 1);
-//   napCable.CreateAndInsertCableSegment( 2);
-//   napCable.CreateAndInsertCableSegment( 3);
-//   napCable.CreateAndInsertCableSegment( 4);
-//   napCable.PrintCheckPoints();
 };
 
 
@@ -951,6 +901,7 @@ TGeoVolume *AliITSv11GeometrySDD::CreateLadder(Int_t iLay) {
   
   // HV cable
   //=======================================================================
+  if (fAddHVcables) {
   TGeoMedium *polyhamideSDD = GetMedium("ITSsddKAPTON_POLYCH2");
   TGeoMedium *alSDD         = GetMedium("ITSal");
 
@@ -970,9 +921,9 @@ TGeoVolume *AliITSv11GeometrySDD::CreateLadder(Int_t iLay) {
   Double_t x1[3], x2[3], x3[3],
           vY[3] = {0,1,0}, vZ[3] = {0,0,1}, vYZ[3]={0,1,1};
 
-  x1[0] = fgkTransitHVtailXpos;
-  x2[0] = fgkTransitHVtailXpos;
-  x3[0] = fgkTransitHVtailXpos;
+  x1[0] = -fgkTransitHVtailXpos;
+  x2[0] = -fgkTransitHVtailXpos;
+  x3[0] = -fgkTransitHVtailXpos;
   for (Int_t iSegment  = nDetectors/2-1; iSegment >= 0; iSegment-- ) {
     Double_t cableSeparation = TMath::Abs(iSegment - (nDetectors/2-1))
                                *fgkLongHVcableSeparation;
@@ -992,6 +943,10 @@ TGeoVolume *AliITSv11GeometrySDD::CreateLadder(Int_t iLay) {
   };
 
   vYZ[2] = -1;
+  x1[0] = fgkTransitHVtailXpos;
+  x2[0] = fgkTransitHVtailXpos;
+  x3[0] = fgkTransitHVtailXpos;
+
   for (Int_t iSegment = nDetectors/2; iSegment < nDetectors; iSegment++ ) { 
     Double_t cableSeparation = TMath::Abs(iSegment - (nDetectors/2-1))
                                *fgkLongHVcableSeparation;
@@ -1009,10 +964,11 @@ TGeoVolume *AliITSv11GeometrySDD::CreateLadder(Int_t iLay) {
     cableHV[iSegment].CreateAndInsertCableSegment(1,0);
     cableHV[iSegment].CreateAndInsertCableSegment(2,0);
   };
+  };
 
   //**********************************
   if(GetDebug(1)) virtualLadder->CheckOverlaps(0.01);
-  //virtualLadder->SetVisibility(kFALSE);
+  virtualLadder->SetVisibility(kFALSE);
   return virtualLadder;
 };
 
@@ -1606,14 +1562,14 @@ TGeoVolume* AliITSv11GeometrySDD::CreateLadderSegment(Int_t iLay, Int_t iSeg) {
   TGeoRotation rotCPS2("", -halfTheta*TMath::RadToDeg(), -90,  90);
   TGeoRotation rotCPS1("",  halfTheta*TMath::RadToDeg(), -90, -90);
   TGeoCombiTrans *transCPS1 = new TGeoCombiTrans(coolPipeSuppL,
-                                 -fgkLadderHeight/2.-TMath::Abs(tDY)
+                                 -fgkLadderHeight/2. - tDY
                                  +coolPipeSuppH+fgkLadderBeamRadius,
                                  -segmentLength/2., &rotCPS1);
   TGeoCombiTrans *transCPS3 = new TGeoCombiTrans(*transCPS1);
   AddTranslationToCombiTrans(transCPS3, 0, 0, segmentLength);
   
   TGeoCombiTrans *transCPS2 = new TGeoCombiTrans(-coolPipeSuppL,
-                                 -fgkLadderHeight/2.-tDY
+                                 -fgkLadderHeight/2.- tDY
                                  +coolPipeSuppH+fgkLadderBeamRadius,
                                  segmentLength/2., &rotCPS2);
   TGeoCombiTrans *transCPS4 = new TGeoCombiTrans(*transCPS2);
@@ -1749,7 +1705,7 @@ TGeoVolume* AliITSv11GeometrySDD::CreateLadderSegment(Int_t iLay, Int_t iSeg) {
 
   //**********************************
   if(GetDebug(1)) virtualSeg->CheckOverlaps(0.01);
-  //virtualSeg->SetVisibility(kFALSE);
+  virtualSeg->SetVisibility(kFALSE);
   return virtualSeg;
 };
 
@@ -2209,21 +2165,21 @@ TGeoVolume* AliITSv11GeometrySDD::CreateEndLadder(Int_t iLay) {
   //**********************************
   //the cooling pipe supports
   Double_t triangleCPaxeDist = fgkCoolPipeSuppAxeDist-fgkCoolPipeSuppWidthExt-
-    fgkCoolPipeSuppWidthIn+fgkLadderBeamRadius;
+                               fgkCoolPipeSuppWidthIn+fgkLadderBeamRadius;
 
   Double_t coolPipeSuppL = TMath::Tan(halfTheta)*
-    (triangleHeight+triangleCPaxeDist/
-     TMath::Sin(halfTheta) - coolPipeSuppH);
+                           (triangleHeight+triangleCPaxeDist/
+                           TMath::Sin(halfTheta)-coolPipeSuppH);
   
   if (fAddCoolingSyst) {
   TGeoRotation rotCPS2("",-halfTheta*TMath::RadToDeg(),-90, 90);
   TGeoRotation rotCPS1("", halfTheta*TMath::RadToDeg(),-90,-90);
   TGeoCombiTrans *transCPS1 = new TGeoCombiTrans(coolPipeSuppL,
-                                 -fgkLadderHeight/2.-TMath::Abs(tDY)+
+                                 -fgkLadderHeight/2.+ tDY +
                                  coolPipeSuppH+fgkLadderBeamRadius,
                                  -length/2., &rotCPS1);
   TGeoCombiTrans *transCPS4 = new TGeoCombiTrans(-coolPipeSuppL,
-                                 -fgkLadderHeight/2.-TMath::Abs(tDY)+
+                                 -fgkLadderHeight/2.+ tDY +
                                  coolPipeSuppH+fgkLadderBeamRadius,
                                  -length/2., &rotCPS2);
 
@@ -2233,7 +2189,7 @@ TGeoVolume* AliITSv11GeometrySDD::CreateEndLadder(Int_t iLay) {
 
   //**********************************
   if(GetDebug(1)) virtualEnd->CheckOverlaps(0.01);
-  //virtualEnd->SetVisibility(kFALSE);
+  virtualEnd->SetVisibility(kFALSE);
   return virtualEnd;
 };
 
@@ -2530,7 +2486,7 @@ TGeoVolume *AliITSv11GeometrySDD::CreateDetectors(Int_t iLay) {
     ladderLength = fgkLay4LadderLength;
     sensorZPos   = fLay4sensorZPos;
   } else {
-    printf("AliITSv11GeometrySDD::CreateLay3Detectors: Error : Wrong layer");
+    printf("AliITSv11GeometrySDD::CreateDetectors: Error : Wrong layer");
   };
 
   char name[30];
@@ -2548,17 +2504,23 @@ TGeoVolume *AliITSv11GeometrySDD::CreateDetectors(Int_t iLay) {
         if (iLay==3) if (i%2!=0) localY = -localY;
        if (iLay==4) if (i%2==0) localY = -localY;
         sprintf(name, "ITSsddLay%iSensorPos%i",iLay, i);
-       Double_t rotationY = 180;
-       if (i >= nDetectors/2) rotationY = 0;
-       TGeoRotation rotSensor("",0, rotationY, 0);
-       TGeoCombiTrans *sensorPos = new TGeoCombiTrans(0,localY,
-                                                      localZ,&rotSensor);
-       sensorPos->SetName(name);
-        virtualDet->AddNode(fSDDsensor, i, sensorPos);
+
+       if (i >= nDetectors/2) {
+         TGeoTranslation *sensorPos = new TGeoTranslation(0,localY,localZ);
+         sensorPos->SetName(name);
+         virtualDet->AddNode(fSDDsensor, i, sensorPos);
+       }
+       else {
+         TGeoRotation rotSensor("",0, 180, 180);
+         TGeoCombiTrans *sensorPos = new TGeoCombiTrans(0,localY,
+                                                localZ,&rotSensor);
+         sensorPos->SetName(name);
+         virtualDet->AddNode(fSDDsensor, i, sensorPos);
+       };
     }
 
     if(GetDebug(1)) virtualDet->CheckOverlaps(0.01);
-    //virtualDet->SetVisibility(kFALSE);
+    virtualDet->SetVisibility(kFALSE);
     return virtualDet;
 };
 
@@ -2580,9 +2542,8 @@ Int_t AliITSv11GeometrySDD::ExportSensorGeometry(AliITSgeom *geom, Int_t iLaySDD
     return kFALSE;
   };
 
-  Int_t firstSDDmod = startMod;
-  const Float_t kDxyz[3] = {fgkWaferWidthSens, fgkWaferThickSens, fgkWaferLengthSens};
-
+  const Float_t kDxyz[3] = {fgkWaferWidthSens/2., fgkWaferThickSens/2.,
+                           fgkWaferLengthSens/2.};
   if(!(geom->IsShapeDefined(kSDD)))
     geom->ReSetShape(kSDD, new AliITSgeomSDD256(3, kDxyz));
 
@@ -2591,12 +2552,13 @@ Int_t AliITSv11GeometrySDD::ExportSensorGeometry(AliITSgeom *geom, Int_t iLaySDD
   char sensorName[30];
   char senstivName[30];
   const Int_t kNLay = 2;
-  const Int_t kNLadd[2] = {fgkLay3Nladd, fgkLay4Nladd};
-  const Int_t kNDet[2]  = {fgkLay3Ndet,  fgkLay4Ndet};
+  const Int_t kNLadd[kNLay] = {fgkLay3Nladd, fgkLay4Nladd};
+  const Int_t kNDet[kNLay]  = {fgkLay3Ndet,  fgkLay4Ndet};
 
   if (GetDebug(1))
     printf("AliITSv11GeometrySDD::SetSensorGeometry(), nodes found :\n");
 
+  Int_t firstSDDmod = startMod;
   for (Int_t iLay=0; iLay<kNLay; iLay++) {
     /////////////////////////////////////////
     sprintf(layerName, "ITSsddLayer%i_1",iLay+3);
@@ -2638,17 +2600,27 @@ Int_t AliITSv11GeometrySDD::ExportSensorGeometry(AliITSgeom *geom, Int_t iLaySDD
                TGeoHMatrix sensMatrix(wafMatrix);
                sensMatrix.Multiply(sensitivNode->GetMatrix());
 
+               // Sticking to the convention for local wafer coordinate
+               // in AliITSgeom :
+               if (iDet >= kNDet[iLay]/2) {
+                 //              TGeoRotation rotY("",0,180,0);
+                 TGeoRotation rotY("",-180,-180,0);
+                 sensMatrix.Multiply(&rotY);
+               };
+               // Creating the matrix in AliITSgeom for
+               // this sensitive volume :
                Double_t *trans = sensMatrix.GetTranslation();
                Double_t *r     = sensMatrix.GetRotationMatrix();
                Double_t rot[10] = {r[0],r[1],r[2],
                                    r[3],r[4],r[5],
-                                   r[6],r[7],r[8], 0.0};
-               //rot[9]=0.0 => not a unity matrix
+                                   r[6],r[7],r[8], 1.0};
+               //rot[9]!=0.0 => not a unity matrix
                geom->CreatMatrix(startMod,iLay+iLaySDD,iLadd+1,iDet+1,
                                  kSDD,trans,rot);
                // iLadd+1, iDet+1 because ladd. and det. start at +1
                // elsewhere
                startMod++;
+
              } else
                printf("Error (ExportSensorGeometry) %s not found !\n",
                       senstivName);
@@ -2672,6 +2644,7 @@ Int_t AliITSv11GeometrySDD::ExportSensorGeometry(AliITSgeom *geom, Int_t iLaySDD
 };
 
 
+//________________________________________________________________________
 Int_t AliITSv11GeometrySDD::
 GetCurrentLayLaddDet(Int_t &lay, Int_t &ladd, Int_t&det) const {
   //
@@ -2693,8 +2666,8 @@ GetCurrentLayLaddDet(Int_t &lay, Int_t &ladd, Int_t&det) const {
 
  // Get the layer index :
   if (node->GetNdaughters()==fgkLay3Ndet)
-    lay = 1;
-  else lay = 2;
+    lay = 3;            // this has to be equal to the iLaySDD argument given to ExportSensorGeometry() !!!
+  else lay = 4;
 
   return kTRUE;
 };
index b2268ab..4458748 100755 (executable)
@@ -55,6 +55,8 @@ class AliITSv11GeometrySDD : public AliITSv11Geometry {
   virtual void  SetParameters();
   TGeoVolume*   GetMotherVolume() const { return fMotherVol;};
   const char*   GetSenstiveVolumeMame() const {return fgSDDsensitiveVolName;};
+  Int_t         GetLay3NLadders() const;
+  Int_t         GetLay4NLadders() const;
 
   private: