Minor fixes to revertexer and reconstructor.
authorcholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 11 Nov 2008 15:45:31 +0000 (15:45 +0000)
committercholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 11 Nov 2008 15:45:31 +0000 (15:45 +0000)
Final fixes to the geometry.   This is it.  No more to be done,
unless the ITS figures out something more.  I'll close the
corresponding task.

13 files changed:
FMD/AliFMD1.cxx
FMD/AliFMD1.h
FMD/AliFMD2.cxx
FMD/AliFMD3.cxx
FMD/AliFMDESDRevertexer.h
FMD/AliFMDGeometryBuilder.cxx
FMD/AliFMDGeometryBuilder.h
FMD/AliFMDReconstructor.cxx
FMD/AliFMDRing.cxx
FMD/AliFMDRing.h
FMD/Config.C
FMD/scripts/ShowCoordinates.C
FMD/scripts/ShowFMDITS.C

index 1cd9bdf..2eba4bb 100644 (file)
@@ -29,6 +29,7 @@
 // FMD1 currently has no support defined. 
 //
 #include "AliFMD1.h"           // ALIFMD1_H 
+#include <AliLog.h>
 // #include "AliFMDRing.h"             // ALIFMDRING_H 
 
 
@@ -42,10 +43,22 @@ ClassImp(AliFMD1)
 AliFMD1::AliFMD1(AliFMDRing* inner) 
   : AliFMDDetector(1, inner, 0)
 {
-  // Subtracting 0.25 cm puts the middle plane of the detector at 320 cm
-  SetInnerZ(320. - 0.25);
+  // Subtracting 0.25 cm puts the middle plane of the detector at 320
+  // cm
+  Double_t off = 0; // -0.25
+  if (off != 0) 
+    AliWarning(Form("FMD1 is off by %fcm", off));
+  SetInnerZ(320. + off);
 }
 
+//____________________________________________________________________
+void
+AliFMD1::Init() 
+{
+  // Initialize 
+  AliFMDDetector::Init();
+  SetInnerHoneyHighR(22.3716);
+}
 
 //____________________________________________________________________
 //
index a272e42..5645bb9 100644 (file)
@@ -32,7 +32,7 @@ public:
   /** Destructor */
   virtual ~AliFMD1() {}
   /** Initialize */
-  virtual void Init() { AliFMDDetector::Init(); }
+  virtual void Init();
   ClassDef(AliFMD1,1)
 };
 
index 3bdaaaf..ba0a6de 100644 (file)
@@ -45,7 +45,7 @@ AliFMD2::AliFMD2(AliFMDRing* inner, AliFMDRing* outer)
   // Constructor 
   // SetInnerZ(83.4);
   // SetOuterZ(75.2);
-  Double_t off = 0; // 2.35
+  Double_t off = 0.414256-0.1963; // 2.35
   if (off != 0) 
     AliWarning(Form("Z position of FMD2 rings may be wrong by %fcm!", off));
   SetInnerZ(83.4+off);
index 32cf2fc..e61674c 100644 (file)
@@ -46,7 +46,8 @@ ClassImp(AliFMD3)
 //____________________________________________________________________
 AliFMD3::AliFMD3(AliFMDRing* inner, AliFMDRing* outer) 
   : AliFMDDetector(3, inner, outer),
-    fNoseZ(16.54667),    // From drawing
+    // fNoseZ(16.54667)
+    fNoseZ(18.13 - inner->GetModuleDepth()-inner->GetModuleSpacing()/2),    // From drawing
     fFlangeDepth(0),
     fFlangeHighR(49.25), // From drawing 
     fFlangeLength(0),
@@ -65,7 +66,7 @@ AliFMD3::AliFMD3(AliFMDRing* inner, AliFMDRing* outer)
     fFiducialHoles(4)
 {
   // Constructor. 
-  Double_t off = -0.25;
+  Double_t off = -0.39615-0.10185; // -0.25;
   if (off != 0) 
     AliWarning(Form("Z position of FMD3 rings may be off by %fcm!", off));
 
@@ -111,8 +112,8 @@ AliFMD3::Init()
   fConeInnerAngle  = TMath::ATan2(v4.Z()-v1.Z(), v4.X()-v1.X());
   fConeOuterAngle  = TMath::ATan2(v3.Y()-v2.Y(), v3.X()-v2.X());
   
-  Double_t    hz1  = -fHoleOffset+fInnerZ+fNoseZ;
 #if 0
+  Double_t    hz1  = -fHoleOffset+fInnerZ+fNoseZ;
   fHoleLength      = TMath::Sqrt(TMath::Power(v4.Z()-ConeR(hz1),2) + 
                                 TMath::Power(v4.X()-fHoleOffset,2));  
 #endif
index af12ba3..c4d5952 100644 (file)
@@ -129,9 +129,9 @@ AliFMDESDRevertexer::Revertex(AliESDFMD* fmdEsd, Double_t vz) const
          continue;
        }
        
-       Double_t corr = TMath::Abs(TMath::Cos(theta));
+       Double_t corr = 1; 
        if (fmdEsd->IsAngleCorrected()) 
-         corr /= TMath::Abs(TMath::Cos(oldTheta));
+         corr = TMath::Abs(TMath::Cos(theta) / TMath::Cos(oldTheta));
        for (UShort_t sec = 0; sec < nsec; sec++) { 
          Double_t mult = fmdEsd->Multiplicity(det, rng, sec, str);
          fmdEsd->SetMultiplicity(det, rng, sec, str, corr * mult);
index 7ca71e2..e383291 100644 (file)
@@ -149,6 +149,27 @@ AliFMDGeometryBuilder::AliFMDGeometryBuilder(Bool_t detailed)
   fActiveId.Set(2);
 }
 
+//____________________________________________________________________
+TGeoShape*
+AliFMDGeometryBuilder::MakeXTRU(const TObjArray& verticies, 
+                               Double_t thick) const
+{
+  TArrayD xs(6);
+  TArrayD ys(6);
+  for (Int_t i = 0; i < 3; i++) { 
+    TVector2* v = static_cast<TVector2*>(verticies.At(i+1));
+    xs[i]     =  v->Y();
+    ys[i]     = -v->X();
+    xs[6-1-i] =  v->Y();
+    ys[6-1-i] =  v->X();
+  }
+  TGeoXtru* shape = new TGeoXtru(2);
+  shape->DefinePolygon(xs.fN, xs.fArray, ys.fArray);
+  shape->DefineSection(0, -thick/2);
+  shape->DefineSection(1, +thick/2);
+  
+  return shape;
+}
 
 //____________________________________________________________________
 TGeoVolume*
@@ -173,52 +194,25 @@ AliFMDGeometryBuilder::RingGeometry(AliFMDRing* r)
   Char_t        id       = r->GetId();
   Char_t        rng      = toupper(id);
   const Char_t* lName    = (rng == 'I' ? "inner" : "outer");
-  Double_t      siThick  = r->GetSiThickness();
-  const Int_t   knv      = r->GetNVerticies();
-  TVector2*     a        = r->GetVertex(5);
-  TVector2*     b        = r->GetVertex(3);
-  TVector2*     c        = r->GetVertex(4);
-  Double_t      theta    = r->GetTheta();
-  Double_t      off      = (TMath::Tan(TMath::Pi() * theta / 180) 
-                           * r->GetBondingWidth());
-  Double_t      rmax     = b->Mod();
-  Double_t      rmin     = r->GetLowR();
-  Double_t      pcbThick = r->GetPrintboardThickness();
-  Double_t      cuThick  = r->GetCopperThickness();
-  Double_t      chipThick= r->GetChipThickness();
-  Double_t      modSpace = r->GetModuleSpacing();
-  Double_t      legr     = r->GetLegRadius();
-  Double_t      legl     = r->GetLegLength();
-  Double_t      legoff   = r->GetLegOffset();
-  Int_t         ns       = r->GetNStrips();
-  Double_t      stripoff = a->Mod();
-  Double_t      dstrip   = (rmax - stripoff) / ns;
-  Double_t      space    = r->GetSpacing();
-  TArrayD       xs(knv);
-  TArrayD       ys(knv);
-  for (Int_t i = 0; i < knv; i++) {
-    // Reverse the order 
-    TVector2* vv = r->GetVertex(knv - 1 - i);
-    if (!vv) {
-      AliError(Form("Failed to get vertex # %d", knv - 1 - i));
-      continue;
-    }
-    xs[i] = vv->X();
-    ys[i] = vv->Y();
-  }
+  Double_t siThick  = r->GetSiThickness();
+  Double_t pcbThick = r->GetPrintboardThickness();
+  Double_t cuThick  = r->GetCopperThickness();
+  Double_t chipThick= r->GetChipThickness();
+  Double_t modSpace = r->GetModuleSpacing();
+  Double_t theta    = r->GetTheta();
   
-  // Shape of actual sensor 
-  TGeoXtru* sensorShape = new TGeoXtru(2);
-  sensorShape->DefinePolygon(knv, xs.fArray, ys.fArray);
-  sensorShape->DefineSection(0, - siThick/2);
-  sensorShape->DefineSection(1, siThick/2);
-  sensorShape->SetName(Form(fgkSensorName, id));
-  sensorShape->SetTitle(Form("FMD %s Sensor", lName));
+  //------------------------------------------------------------------
+  // Sensor
+  // Physical sensor
+  TGeoShape* sensorShape = MakeXTRU(r->GetSensorVerticies(), siThick);
+  sensorShape->SetName(Form("FMD%c_physical_sensor", id));
+  sensorShape->SetTitle(Form("FMD %s physical sensor", lName));
   TGeoVolume* sensorVolume = new TGeoVolume(Form(fgkSensorName, id), 
                                            sensorShape, fSi);
   sensorVolume->SetTitle(Form("FMD %s Sensor", lName));
   sensorVolume->VisibleDaughters(kFALSE);
   Int_t sid = sensorVolume->GetNumber();
+
   fSectorOff   = -1;
   fModuleOff   = 1;
   fRingOff     = 2;
@@ -230,15 +224,24 @@ AliFMDGeometryBuilder::RingGeometry(AliFMDRing* r)
     fDetectorOff = 6;
     // Virtual volume shape to divide - This volume is only defined if
     // the geometry is set to be detailed. 
-    TGeoTubeSeg* activeShape = new TGeoTubeSeg(rmin, rmax, siThick/2, 
-                                              - theta, theta);
+    TGeoTubeSeg* activeShape = new TGeoTubeSeg(r->GetLowR(),
+                                              r->GetHighR(), 
+                                              siThick / 2, 
+                                              - theta, 
+                                              + theta);
     activeShape->SetName(Form(fgkActiveName, id));
     activeShape->SetTitle(Form("FMD %s active area", lName));
     TGeoVolume* activeVolume = new TGeoVolume(Form(fgkActiveName, id),
                                              activeShape,fSi);
     activeVolume->SetTitle(Form("FMD %s active area", lName));
     TGeoVolume* sectorVolume = activeVolume->Divide(Form(fgkSectorName,id), 
-                                                     2, 2, -theta,0,0,"N");
+                                                     2, 2, -theta,
+                                                   0,0,"N");
+
+    Int_t    ns       = r->GetNStrips();
+    Double_t stripoff = r->GetLowR(); // 0; // a->Mod();
+    Double_t dstrip   = (r->GetHighR() - stripoff) / ns;
+
     sectorVolume->SetTitle(Form("FMD %s sector", lName));
     TGeoVolume* stripVolume  = sectorVolume->Divide(Form(fgkStripName, id), 
                                                    1, ns, stripoff, dstrip, 
@@ -253,101 +256,99 @@ AliFMDGeometryBuilder::RingGeometry(AliFMDRing* r)
   case 'O': fActiveId[1] = sid; break;
   }
 
-  // Shape of Printed circuit Board 
-  for (Int_t i = 0;       i < knv / 2; i++) ys[i] -= off;
-  for (Int_t i = knv / 2; i < knv;     i++) ys[i] += off;
-  TGeoXtru* pcbShape         = new TGeoXtru(2);
-  pcbShape->DefinePolygon(knv, xs.fArray, ys.fArray);
-  pcbShape->DefineSection(0, - pcbThick/2);
-  pcbShape->DefineSection(1, pcbThick/2);
-  pcbShape->SetName(Form(fgkPCBName, id));
+  //------------------------------------------------------------------
+  // Hybrid
+  // PCB layer of hybrid 
+  TGeoShape* pcbShape = MakeXTRU(r->GetHybridVerticies(), pcbThick);
+  pcbShape->SetName(Form("FMD%c_hybrid_pcb", id));
   pcbShape->SetTitle(Form("FMD %s hybrid PCB", lName));
-  TGeoVolume* pcbVolume      = new TGeoVolume(Form(fgkPCBName, id), 
-                                             pcbShape, fPCB);
+  TGeoVolume* pcbVolume = new TGeoVolume(Form(fgkPCBName, id), pcbShape, fPCB);
   pcbVolume->SetTitle(Form("FMD %s hybrid PCB", lName));
 
   // Copper layer
-  TGeoXtru* cuShape       = new TGeoXtru(2);
-  cuShape->DefinePolygon(6, xs.fArray, ys.fArray);
-  cuShape->DefineSection(0, - cuThick/2);
-  cuShape->DefineSection(1, cuThick/2);
+  TGeoShape* cuShape = MakeXTRU(r->GetHybridVerticies(), cuThick);
+  cuShape->SetName(Form("FMD%c_hybrid_copper", id));
   cuShape->SetTitle(Form("FMD %s hybrid copper", lName));
   TGeoVolume* cuVolume    = new TGeoVolume(Form(fgkCuName,id),cuShape,fCopper);
   cuVolume->SetTitle(Form("FMD %s hybrid copper", lName));
 
   // Chip layer
-  TGeoXtru*   chipShape   = new TGeoXtru(2);
-  chipShape->DefinePolygon(6, xs.fArray, ys.fArray);
-  chipShape->DefineSection(0, - chipThick/2);
-  chipShape->DefineSection(1, chipThick/2);
+  TGeoShape* chipShape = MakeXTRU(r->GetHybridVerticies(), chipThick);
+  chipShape->SetName(Form("FMD%c_hybrid_chip", id));
   chipShape->SetTitle(Form("FMD %s hybrid chip", lName));
-  TGeoVolume* chipVolume = new TGeoVolume(Form(fgkChipName,id),
-                                         chipShape,fChip);
+  TGeoVolume* chipVolume = new TGeoVolume(Form(fgkChipName,id),chipShape,fChip);
   chipVolume->SetTitle(Form("FMD %s hybrid chip", lName));
 
+  //------------------------------------------------------------------
+  // Legs
+  Double_t      legr     = r->GetLegRadius();
+  Double_t      legl     = r->GetLegLength();
+  Double_t      lege     = .05;
+
   // Short leg shape 
-  TGeoTube*   shortLegShape  = new TGeoTube(0, legr, legl / 2);
+  TGeoTube*   shortLegShape  = new TGeoTube(0, legr, (legl-lege) / 2);
   shortLegShape->SetName(Form(fgkShortLegName, id));
   shortLegShape->SetTitle(Form("FMD %s short support foot", lName));
   TGeoVolume* shortLegVolume = new TGeoVolume(Form(fgkShortLegName, id), 
                                              shortLegShape, fCopper);
   shortLegVolume->SetTitle(Form("FMD %s short support foot", lName));
   // Long leg shape
-  TGeoTube*   longLegShape   = new TGeoTube(0, legr, (legl + modSpace) / 2);
+  TGeoTube*   longLegShape   = new TGeoTube(0, legr, 
+                                           (legl - lege + modSpace) / 2);
   longLegShape->SetName(Form(fgkLongLegName, id));
   longLegShape->SetTitle(Form("FMD %s long support foot", lName));
   TGeoVolume* longLegVolume  = new TGeoVolume(Form(fgkLongLegName, id), 
                                              longLegShape, fCopper);
   longLegVolume->SetTitle(Form("FMD %s long support foot", lName));
   
-  
+
+
+  //------------------------------------------------------------------
+  // Placement of module volumes in assemblies 
+  TArrayD xfs(3);
+  TArrayD yfs(3);
+  for (Int_t i = 0; i < 3; i++) { 
+    TVector2* vv = r->GetFootPosition(i);
+    // TVector2  uu = vv->Rotate(TMath::Pi()/2);
+    xfs[i]       = vv->Y();
+    yfs[i]       = vv->X();
+  }
+
   // Back container volume 
   TGeoVolume* backVolume     = new TGeoVolumeAssembly(Form(fgkBackVName, id));
   backVolume->SetTitle(Form("FMD %s back module", lName));
-  Double_t x = 0;
-  Double_t y = 0;
-  Double_t z = siThick / 2;
-  backVolume->AddNode(sensorVolume, 0, new TGeoTranslation(x, y, z));
-  z          += siThick / 2 + space + pcbThick / 2;
-  backVolume->AddNode(pcbVolume, 0, new TGeoTranslation(x,y,z));
-  z          += (pcbThick + cuThick) / 2;
-  backVolume->AddNode(cuVolume, 0, new TGeoTranslation(0, 0, z));
-  z          += (cuThick + chipThick) / 2;
-  backVolume->AddNode(chipVolume, 0, new TGeoTranslation(0, 0, z));
-  x          =  a->X() + legoff + legr;
-  y          =  0;
-  z          += pcbThick / 2 + legl / 2;
-  backVolume->AddNode(shortLegVolume, 0, new TGeoTranslation(x,y,z));
-  x          =  c->X();
-  y          =  c->Y() - legoff - legr - off;
-  backVolume->AddNode(shortLegVolume, 1, new TGeoTranslation(x,y,z));
-  y          =  -y;
-  backVolume->AddNode(shortLegVolume, 2, new TGeoTranslation(x,y,z));
-
-  // Front container volume 
   TGeoVolume* frontVolume    = new TGeoVolumeAssembly(Form(fgkFrontVName, id));
   frontVolume->SetTitle(Form("FMD %s front module", lName));
-  x         =  0;
-  y         =  0;
-  z         = siThick / 2;
-  frontVolume->AddNode(sensorVolume, 0, new TGeoTranslation(x, y, z));
-  z          += siThick / 2 + space + pcbThick / 2;
-  frontVolume->AddNode(pcbVolume, 0, new TGeoTranslation(x,y,z));
-  z          += (pcbThick + cuThick) / 2;
-  frontVolume->AddNode(cuVolume, 0, new TGeoTranslation(0, 0, z));
-  z          += (cuThick + chipThick) / 2;
-  frontVolume->AddNode(chipVolume, 0, new TGeoTranslation(0, 0, z));
-  x         =  a->X() + legoff + legr;
-  y         =  0;
-  z         += pcbThick / 2 + (legl + modSpace)/ 2;
-  frontVolume->AddNode(longLegVolume, 0, new TGeoTranslation(x,y,z));
-  x         =  c->X();
-  y         =  c->Y() - legoff - legr - off;
-  frontVolume->AddNode(longLegVolume, 1, new TGeoTranslation(x,y,z));
-  y         =  -y;
-  frontVolume->AddNode(longLegVolume, 2, new TGeoTranslation(x,y,z));
 
+  Double_t space    = r->GetSpacing();
+  Double_t x        = 0;
+  Double_t y        = 0;
+  Double_t zb       = siThick / 2;
+  Double_t zf       = siThick / 2;
+  backVolume->AddNode(sensorVolume, 0, new TGeoTranslation(x, y, zb));
+  frontVolume->AddNode(sensorVolume, 0, new TGeoTranslation(x, y, zf));
+  zb         += siThick / 2 + space + pcbThick / 2;
+  zf         += siThick / 2 + space + pcbThick / 2;
+  backVolume->AddNode(pcbVolume, 0, new TGeoTranslation(x, y, zb));
+  frontVolume->AddNode(pcbVolume, 0, new TGeoTranslation(x, y, zf));
+  zb         += (pcbThick + cuThick) / 2;
+  zf         += (pcbThick + cuThick) / 2;
+  backVolume->AddNode(cuVolume, 0, new TGeoTranslation(0, 0, zf));
+  frontVolume->AddNode(cuVolume, 0, new TGeoTranslation(0, 0, zb));
+  zb         += (cuThick + chipThick) / 2;
+  zf         += (cuThick + chipThick) / 2;
+  backVolume->AddNode(chipVolume, 0, new TGeoTranslation(0, 0, zb));
+  frontVolume->AddNode(chipVolume, 0, new TGeoTranslation(0, 0, zf));
+  zb         += pcbThick / 2 + (legl)/ 2  - lege;
+  zf         += pcbThick / 2 + (legl + modSpace)/ 2 - lege;
+  for (Int_t i = 0; i < 3; i++) { 
+    x          =  xfs[i]; // a->X() + legoff + legr;
+    y          =  yfs[i]; // 0;
+    backVolume->AddNode(shortLegVolume, i, new TGeoTranslation(x,y,zb));
+    frontVolume->AddNode(longLegVolume, i, new TGeoTranslation(x,y,zf));
+  }
 
+  //------------------------------------------------------------------
   // FMDD 
   Double_t ddlr = r->GetFMDDLowR();
   Double_t ddhr = r->GetFMDDHighR();
@@ -415,6 +416,7 @@ AliFMDGeometryBuilder::RingGeometry(AliFMDRing* r)
   fmddCuVolume->SetTitle(Form("FMD %s digitiser copper", lName));
   fmddChipVolume->SetTitle(Form("FMD %s digitiser chip", lName));
 
+  //------------------------------------------------------------------
   // Half ring mother volumes. 
   TGeoVolume* ringTopVolume = new TGeoVolumeAssembly(Form(fgkRingTopName,id));
   TGeoVolume* ringBotVolume = new TGeoVolumeAssembly(Form(fgkRingBotName,id));
@@ -422,6 +424,7 @@ AliFMDGeometryBuilder::RingGeometry(AliFMDRing* r)
   ringTopVolume->SetTitle(Form("FMD %s top half-ring", lName));
   ringBotVolume->SetTitle(Form("FMD %s bottom half-ring", lName));
   
+  //------------------------------------------------------------------
   // Adding modules to half-rings
   Int_t    nmod =  r->GetNModules();
   AliFMDDebug(10, ("making %d modules in ring %c", nmod, id));
@@ -430,28 +433,17 @@ AliFMDGeometryBuilder::RingGeometry(AliFMDRing* r)
     Bool_t      front =  (i % 2 == (rng == 'I' ? 1 : 0));
     TGeoVolume* vol   =  (front ? frontVolume : backVolume);
     // vol->AddNode(sensorVolume, i, new TGeoTranslation(0,0,siThick/2));
-    Double_t    z1    =  (front ? 0 : modSpace);
+    Double_t    z1    =  (front ? -1 : 1) * modSpace / 2;
+    // Double_t z1    =  (front ? 0 : modSpace);
     Double_t    th    =  (2 * i + 1) * theta;
     TGeoMatrix* mat1  =  new TGeoCombiTrans(0,0,z1,0); 
     mat1->RotateZ(th);
     mat1->SetName(Form("FMD%c_module_%02d", id, i));
     mat1->SetTitle(Form("FMD %s module %2d matrix", lName, i));
     halfRing->AddNode(vol, i, mat1);
-#if 0
-    Double_t    z2    =  z1 + siThick / 2 + space;
-    Double_t    th    =  (2 * i + 1) * theta;
-    AliFMDDebug(20, ("Placing copy %d of %s and %s in %s at z=%f and %f, "
-                     "and theta=%f", i, sensorVolume->GetName(), 
-                     vol->GetName(), halfRing->GetName(), z1, z2, th));
-    TGeoMatrix* mat1  =  new TGeoCombiTrans(0,0,z1,0); 
-    mat1->RotateZ(th);
-    halfRing->AddNode(sensorVolume, i, mat1);
-    TGeoMatrix* mat2  =  new TGeoCombiTrans(0,0,z2,0); 
-    mat2->RotateZ(th);
-    halfRing->AddNode(vol, i, mat2);
-#endif
   }
 
+  //------------------------------------------------------------------
   // Add the FMDD 
   Double_t zi = r->GetFullDepth() - ddt;
   Int_t    n  = 2;
@@ -461,7 +453,7 @@ AliFMDGeometryBuilder::RingGeometry(AliFMDRing* r)
     TGeoRotation* rot    = new TGeoRotation(Form("FMDD%c rotation %d", id, i));
     rot->RotateZ(phi);
     rot->SetTitle(Form("FMD %s digitiser rotation %2d", lName, i));
-    z         =  zi + ddpt / 2;
+    Double_t z =  zi + ddpt / 2;
     halfRing->AddNode(fmddPcbVolume, i, new TGeoCombiTrans(0,0,z,rot));
     z          += (ddpt + ddct) / 2;
     halfRing->AddNode(fmddCuVolume, i, new TGeoCombiTrans(0,0,z,rot));
@@ -473,6 +465,7 @@ AliFMDGeometryBuilder::RingGeometry(AliFMDRing* r)
   return 0;
 }
 
+
 //____________________________________________________________________
 TGeoShape*
 AliFMDGeometryBuilder::HoneycombShape(Int_t id, Char_t ring,
@@ -615,7 +608,7 @@ AliFMDGeometryBuilder::DetectorGeometry(AliFMDDetector* d,
 
     // Place ring in mother volume
     // TGeoMatrix*matrix=new TGeoTranslation(Form("FMD%d%c trans",id,c),0,0,0);
-    AliFMDDebug(1, ("Placing volumes %s and %s in %s and %s at z=%f", 
+    AliFMDDebug(2, ("Placing volumes %s and %s in %s and %s at z=%f", 
                     tvol->GetName(), bvol->GetName(), 
                     topMother->GetName(), botMother->GetName(), z));
     topMother->AddNode(tvol, Int_t(c), new TGeoTranslation(0,0,z));
@@ -626,16 +619,9 @@ AliFMDGeometryBuilder::DetectorGeometry(AliFMDDetector* d,
     TGeoVolume*  hcVol = new TGeoVolume(Form(fgkHCName,id,c),hcSha,fAl);
     hcVol->SetTitle(Form("FMD%d%c honeycomb shell", id, c));
     
-    z += (r->GetSiThickness() + 
-         r->GetSpacing() + 
-         r->GetPrintboardThickness() + 
-         r->GetCopperThickness() + 
-         r->GetChipThickness() + 
-         r->GetModuleSpacing() +
-         r->GetLegLength() + 
-         r->GetHoneycombThickness() + 
-         r->GetFMDDPrintboardThickness() - 
-         hcThick / 2); 
+    z += (r->GetModuleDepth() 
+         + r->GetModuleSpacing() / 2
+         + r->GetHoneycombThickness() / 2);
 
     AliFMDDebug(15, ("Placing a copy of %s in %s and %s at z=%f", 
                      hcVol->GetName(), topMother->GetName(), 
@@ -667,14 +653,6 @@ AliFMDGeometryBuilder::FMD1Geometry(AliFMD1* fmd1,
   if (!fmd1 || !innerTop || !innerBot) return 0;
   AliFMDRing* r             = fmd1->GetInner();
   Double_t    z             = fmd1->GetInnerZ();  
-  Double_t    disce         = 2;
-  Double_t    backlr        = fmd1->GetInnerHoneyHighR();
-  Double_t    backhr        = fmd1->GetInnerHoneyHighR()+5;
-  Double_t    backth        = 0.2;
-  Double_t    toplr         = r->GetLowR();
-  Double_t    tophr         = fmd1->GetInnerHoneyHighR()+disce;
-  Double_t    wallbh        = (r->GetFullDepth() + disce);
-  Double_t    wallth        = wallbh+0.1;
   
   TGeoVolume* fmd1TopVolume = new TGeoVolumeAssembly(Form(fgkFMDName, 
                                                          fmd1->GetId(), 'T'));
@@ -687,93 +665,63 @@ AliFMDGeometryBuilder::FMD1Geometry(AliFMD1* fmd1,
   DetectorGeometry(fmd1, fmd1TopVolume, fmd1BotVolume, z, 
                   innerTop, innerBot, 0, 0);
 
-
-  // Back
-  TGeoTubeSeg* backShape  = new TGeoTubeSeg(backlr, backhr, backth / 2, 0, 180);
-  TGeoTubeSeg* wallbShape = new TGeoTubeSeg(backlr, backlr + backth, 
-                                           wallbh/2, 0, 180);
-  TGeoTubeSeg* topShape   = new TGeoTubeSeg(toplr, tophr, backth / 2, 0, 180);
-  TGeoTubeSeg* walltShape = new TGeoTubeSeg(tophr, tophr + backth, 
-                                           wallth/2, 0, 180);
-  TGeoVolume*  backVolume = new TGeoVolume(Form(fgkBackName, fmd1->GetId()), 
-                                          backShape, fC);
-  TGeoVolume*  wallbVolume= new TGeoVolume(Form(fgkFlangeName, fmd1->GetId()), 
-                                          wallbShape, fC);
-  TGeoVolume*  topVolume  = new TGeoVolume(Form(fgkTopName, fmd1->GetId()), 
-                                          topShape, fC);
-  TGeoVolume*  walltVolume= new TGeoVolume(Form(fgkBeamName, fmd1->GetId()), 
-                                          walltShape, fC);
-  backShape->SetName(Form(fgkBackName, fmd1->GetId()));
-  wallbShape->SetName(Form(fgkFlangeName, fmd1->GetId()));
-  topShape->SetName(Form(fgkTopName, fmd1->GetId()));
-  walltShape->SetName(Form(fgkBeamName, fmd1->GetId()));
-  backShape->SetTitle("FMD1 back saucer rim");
-  wallbShape->SetTitle("FMD1 back saucer wall");
-  topShape->SetTitle("FMD1 top lid");
-  walltShape->SetTitle("FMD1 top lid wall");
-  backVolume->SetFillColor(kGray);
-  topVolume->SetFillColor(kGray);
-  wallbVolume->SetFillColor(kGray);
-  walltVolume->SetFillColor(kGray);
-  backVolume->SetTitle("FMD1 back saucer rim");
-  wallbVolume->SetTitle("FMD1 back saucer wall");
-  topVolume->SetTitle("FMD1 top lid");
-  walltVolume->SetTitle("FMD1 top lid wall");
+  Double_t lidP[][3] = { {  0.00,  4.20, 20.95 }, 
+                        {  0.15,  4.20, 20.95 }, 
+                        {  0.15, 20.80, 20.95 }, 
+                        {  3.00, 20.80, 20.95 }, 
+                        {  3.00, 20.80, 22.30 }, 
+                        {  3.15, 20.80, 22.30 }, 
+                        {  3.15, 20.95, 24.65 },
+                        {  3.30, 20.95, 24.65 }, 
+                        {  3.30, 24.50, 24.65 }, 
+                        {  6.80, 24.50, 24.65 },
+                        {  6.80, 24.50, 26.00 },
+                        {  6.95, 24.50, 26.00 } };
+  TGeoPcon* lidBaseS = new TGeoPcon("FMD1_lid_base", 0, 180, 12);
+  for (size_t i = 0; i < 12; i++) 
+    lidBaseS->DefineSection(i, lidP[i][0], lidP[i][1], lidP[i][2]);
   
-  // Place volumes
-  Double_t zb = TMath::Abs(fmd1->GetInnerZ() - z);
-  Double_t zi = zb;
-  Int_t    n  = 2;
   
-  // Place top cover
-  zi -= disce / 2 + backth / 2;
-  zb =  zi;
-  for (Int_t i = 0; i  < 2; i++) {
-    TGeoVolume*   mother = (i == 0 ? fmd1TopVolume : fmd1BotVolume);
-    Double_t      phi    = 360. / n * i;
-    TGeoRotation* rot    = new TGeoRotation(Form("FMD1 top rotation %d",i));
-    rot->RotateZ(phi);
-    TGeoMatrix* matrix   = new TGeoCombiTrans(Form("FMD1 top wall trans %d", i),
-                                             0, 0, zi, rot);
-    mother->AddNode(topVolume, i, matrix);    
-  }
-  // Place outer wall
-  zi += wallth / 2 + backth / 2;
-  for (Int_t i = 0; i  < 2; i++) {
-    TGeoVolume*   mother = (i == 0 ? fmd1TopVolume : fmd1BotVolume);
-    Double_t      phi    = 360. / n * i;
-    TGeoRotation* rot    = new TGeoRotation(Form("FMD1 outer wall rotation %d",
-                                                i));
-    rot->RotateZ(phi);
-    TGeoMatrix* matrix   = new TGeoCombiTrans(Form("FMD1 outer wall trans %d",
-                                                  i), 0, 0, zi, rot);
-    mother->AddNode(walltVolume, i, matrix);    
-  }
-  // Place back
-  zi += wallth / 2 + backth / 2; // + disce / 2;
-  for (Int_t i = 0; i  < 2; i++) {
-    TGeoVolume*   mother = (i == 0 ? fmd1TopVolume : fmd1BotVolume);
-    Double_t      phi    = 360. / n * i;
-    TGeoRotation* rot    = new TGeoRotation(Form("FMD1 back rotation %d", i));
-    rot->RotateZ(phi);
-    TGeoMatrix* matrix   = new TGeoCombiTrans(Form("FMD1 back trans %d", i),
-                                            0, 0, zi, rot);
-    mother->AddNode(backVolume, i, matrix);    
+  Double_t lidH[][2] = { {  7.84903, 24.15680  }, 
+                        { 20.54900, 14.92970  },
+                        { 21.99700, 12.70000  },
+                        { 25.26090,  2.65502  } };
+  Double_t lidHR = .53 / 2;
+  Double_t lidHL = 0.16;
+  
+  new TGeoTube("FMD1_lid_hole", 0, lidHR, lidHL/2);
+  TString lidComp("FMD1_lid_base-(");
+  TGeoTranslation* trans = 0;
+  for (size_t i = 0; i < 4; i++) { 
+    trans = new TGeoTranslation(-lidH[i][0], lidH[i][1], 6.95-lidHL/2);
+    trans->SetName(Form("FMD1_lid_hole_mat%d", 2*i+0));
+    trans->RegisterYourself();
+    trans = new TGeoTranslation(+lidH[i][0], lidH[i][1], 6.95-lidHL/2);
+    trans->SetName(Form("FMD1_lid_hole_mat%d", 2*i+1));
+    trans->RegisterYourself();
+    lidComp.Append(Form("FMD1_lid_hole:FMD1_lid_hole_mat%d+" 
+                       "FMD1_lid_hole:FMD1_lid_hole_mat%d%c", 
+                       2 * i, 2 * i + 1, i == 3 ? ')' : '+'));
   }
-  // Place inner wall
-  zi -= wallbh / 2 + backth / 2; // + disce / 2;
+  TGeoCompositeShape* lidS = new TGeoCompositeShape(lidComp.Data());
+  lidS->SetName("FMD1_lid");
+  TGeoVolume* lidV = new TGeoVolume("FMD1_lid", lidS, fC);
+  lidV->SetTransparency(63);
+  
+  // Place top cover
+  Double_t lidZ = -(3.3 - r->GetModuleDepth() - r->GetModuleSpacing() / 2);
+  AliFMDDebug(1, ("FMD1 lid offset in Z=%f", lidZ));
+
   for (Int_t i = 0; i  < 2; i++) {
     TGeoVolume*   mother = (i == 0 ? fmd1TopVolume : fmd1BotVolume);
-    Double_t      phi    = 360. / n * i;
-    TGeoRotation* rot    = new TGeoRotation(Form("FMD1 inner wall rotation %d",
-                                                i)); 
+    Double_t      phi    = 360. / 2 * i;
+    TGeoRotation* rot    = new TGeoRotation(Form("FMD1_lid_rot%d",i));
     rot->RotateZ(phi);
-    TGeoMatrix*   matrix = new TGeoCombiTrans(Form("FMD1 inner wall trans %d", 
-                                                  i), 0, 0, zi, rot);
-    mother->AddNode(wallbVolume, i, matrix);    
+    TGeoMatrix* matrix   = new TGeoCombiTrans(Form("FMD1_lid_mat%d", i),
+                                             0, 0, lidZ, rot);
+    mother->AddNode(lidV, i, matrix);    
   }
 
-
   // Must add this after filling the assembly.
   TGeoVolume* top    = gGeoManager->GetVolume("ALIC");
   // TGeoMatrix* matrix = new TGeoTranslation("FMD1 trans", 0, 0, z);
@@ -802,13 +750,16 @@ AliFMDGeometryBuilder::FMD2Geometry(AliFMD2* fmd2,
   // See also AliFMDGeometryBuilder::DetectorGeometry 
   // 
   if (!fmd2 || !innerTop || !innerBot || !outerTop || !outerBot) return 0;
-  // AliFMDRing* r          = fmd2->GetOuter();
+  AliFMDRing* r          = fmd2->GetOuter();
   Double_t    z             = fmd2->GetOuterZ();  
   Double_t    framelr       = 32.01;  // fmd2->GetOuterHoneyHighR()+0.5;
   Double_t    framehr       = 33.611; // fmd2->GetOuterHoneyHighR()+1.8;
   Double_t    framel        = 14.8; // framehz - framelz;
   Double_t    backth        = 0.3;
-  Double_t    framelz       = -0.8;
+  Double_t    framelz       = -(2.38 
+                               - r->GetModuleDepth() 
+                               - r->GetModuleSpacing() / 2);
+  // Double_t    framelz       = -0.8;
   // Double_t    framehz       = framelz + backth + framel;
   Double_t    coverlr       = 4.3; // fmd2->GetInner()->GetLowR()+1;
   Double_t    coverhr       = framehr; //  - 1;
@@ -930,7 +881,7 @@ AliFMDGeometryBuilder::FMD2Geometry(AliFMD2* fmd2,
                                                 -f2d/2));
   TGeoRotation* tensionR = new TGeoRotation;
   tensionR->RotateY(90);
-  wingV->AddNode(tension, 1, new TGeoCombiTrans(4, 0, f1d+1, tensionR));
+  wingV->AddNode(tension, 1, new TGeoCombiTrans(4, 0, f1d+1.2, tensionR));
   TGeoRotation* wireR = new TGeoRotation;
   wireR->RotateY(90);
   wingV->AddNode(wireV, 1, new TGeoCombiTrans(-(framehr-coverlr)/2, 0, f1d+1,
@@ -959,6 +910,7 @@ AliFMDGeometryBuilder::FMD2Geometry(AliFMD2* fmd2,
   trans2->RotateZ(135);
   support->AddNode(wingV, 1, trans1);
   support->AddNode(wingV, 2, trans2);
+  AliFMDDebug(1, ("FMD2 support offset is %f", framelz));
   
   for (Int_t i = 0; i  < 2; i++) {
     TGeoVolume*   mother = (i < 1 ? fmd2TopVolume : fmd2BotVolume);
@@ -982,7 +934,6 @@ AliFMDGeometryBuilder::FMD2Geometry(AliFMD2* fmd2,
   return 0;
 }
   
-#if 1
 //____________________________________________________________________
 TGeoVolume*
 AliFMDGeometryBuilder::FMD3Geometry(AliFMD3* fmd3, 
@@ -1103,13 +1054,6 @@ AliFMDGeometryBuilder::FMD3Geometry(AliFMD3* fmd3,
                     - holeD * TMath::Sin(holeA2));
   Double_t holeX  = (fmd3->ConeR(-holeZ + fmd3->GetInnerZ() + fmd3->GetNoseZ())
                     - holeD * TMath::Sin(holeA2));
-  // Double_t plateA  = holeA - 2. / 180 * TMath::Pi();
-  // Double_t plateA2 = TMath::Pi() - plateA;
-  // Double_t plateZ  = (holeO
-  // + holeL * TMath::Cos(plateA)
-  // - 0.033 * TMath::Sin(plateA2));
-  // Double_t plateX = (fmd3->ConeR(-plateZ + fmd3->GetInnerZ()+fmd3->GetNoseZ()) 
-  // - 0.033 * TMath::Sin(plateA2));
   new TGeoTrd1("FMD3_cone_hole", holeLW, holeHW, holeD, holeL);
   TGeoTrd1* plateShape = new TGeoTrd1("FMD3_cooling_plate", 
                                      holeLW, holeHW, .033, holeL);
@@ -1278,9 +1222,9 @@ AliFMDGeometryBuilder::FMD3Geometry(AliFMD3* fmd3,
   Double_t         wireR1       = (tensionR 
                                   - tensionL * TMath::Sin(tensionAr) 
                                   + tensionH * TMath::Cos(tensionAr));
-  AliFMDDebug(0, ("Wire Z1: %f=%f-%f*cos(%f)-%f*sin(%f)", 
+  AliFMDDebug(10, ("Wire Z1: %f=%f-%f*cos(%f)-%f*sin(%f)", 
                  wireZ1, tensionZ, tensionL, tensionAr, tensionH, tensionAr));
-  AliFMDDebug(0, ("Wire R1: %f=%f-%f*sin(%f)-%f*cos(%f)", 
+  AliFMDDebug(10, ("Wire R1: %f=%f-%f*sin(%f)-%f*cos(%f)", 
                  wireR1, tensionR, tensionL, tensionAr, tensionH, tensionAr));
   
   Double_t         wireStartA   = 42.3 * TMath::Pi() / 180;
@@ -1290,7 +1234,7 @@ AliFMDGeometryBuilder::FMD3Geometry(AliFMD3* fmd3,
   /* (sheeveWheelZ * (1 - TMath::Sin(wireStartA))
                                   - wireT * TMath::Sin(wireStartA) 
                                   - sheeveL); */
-  AliFMDDebug(0, ("wireZ2=%f=%f*(1-%f)", wireZ2, sheeveWheelZ, 
+  AliFMDDebug(10, ("wireZ2=%f=%f*(1-%f)", wireZ2, sheeveWheelZ, 
                  TMath::Sin(wireStartA)));
   Double_t         wireR2       = (sheeveHoleR + 
                                   sheeveWheelZ * TMath::Cos(wireStartA) + 
@@ -1333,8 +1277,10 @@ AliFMDGeometryBuilder::FMD3Geometry(AliFMD3* fmd3,
   TGeoVolume*      wireEV = new TGeoVolume("FMD3_end_wire", wireES, fSteel);
   TGeoRotation*    wireER = new TGeoRotation;
   wireER->RotateY(90);
-  TGeoCombiTrans*  wireEM1 = new TGeoCombiTrans(colarR+wireEL/2,0,-wireT,wireER);
-  TGeoCombiTrans*  wireEM2 = new TGeoCombiTrans(colarR+wireEL/2,0,-wireT,wireER);
+  TGeoCombiTrans*  wireEM1 = new TGeoCombiTrans(colarR+wireEL/2,0,
+                                               -wireT,wireER);
+  TGeoCombiTrans*  wireEM2 = new TGeoCombiTrans(colarR+wireEL/2,0,
+                                               -wireT,wireER);
   wireEM1->RotateZ(45);
   wireEM2->RotateZ(135);
   support->AddNode(wireEV, 1, wireEM1);
@@ -1346,6 +1292,7 @@ AliFMDGeometryBuilder::FMD3Geometry(AliFMD3* fmd3,
   //__________________________________________________________________
   // Place support volumes in half-detector volumes 
   Double_t         z  = fmd3->GetInnerZ();
+  AliFMDDebug(1, ("FMD3 support at z=%f", -fmd3->GetNoseZ()));
   TGeoTranslation* t1 = new TGeoTranslation(0, 0, -fmd3->GetNoseZ());
   fmd3TopVolume->AddNode(support, 1, t1);
   TGeoCombiTrans*  t2 = new TGeoCombiTrans(*t1);
@@ -1364,197 +1311,6 @@ AliFMDGeometryBuilder::FMD3Geometry(AliFMD3* fmd3,
   return 0;
 }
 
-#else
-//____________________________________________________________________
-TGeoVolume*
-AliFMDGeometryBuilder::FMD3Geometry(AliFMD3* fmd3, 
-                                   TGeoVolume* innerTop, 
-                                   TGeoVolume* innerBot, 
-                                   TGeoVolume* outerTop,
-                                   TGeoVolume* outerBot) 
-{
-  // Setup the FMD3 geometry.  The FMD2 has a rather elaborate support
-  // structure, as the support will also support the vacuum
-  // beam-pipe. 
-  // 
-  // See also AliFMDGeometryBuilder::DetectorGeometry 
-  // 
-  if (!fmd3 || !innerTop || !innerBot || !outerTop || !outerBot) return 0;
-  Double_t nlen    = fmd3->GetNoseLength();
-  Double_t nz      = fmd3->GetNoseZ();
-  Double_t noser1  = fmd3->GetNoseLowR();
-  Double_t noser2  = fmd3->GetNoseHighR();
-  Double_t conet   = fmd3->GetBeamThickness();
-  Double_t conel   = fmd3->GetConeLength();
-  Double_t backl   = fmd3->GetBackLength();
-  // Double_t backr1  = fmd3->GetBackLowR();
-  Double_t backr2  = fmd3->GetBackHighR();
-  Double_t zdist   = conel -  backl - nlen;
-  Double_t tdist   = backr2 - noser2;
-  // Double_t beaml   = TMath::Sqrt(zdist * zdist + tdist * tdist);
-  Double_t theta   = -180. * TMath::ATan2(tdist, zdist) / TMath::Pi();
-  Double_t flanger = fmd3->GetFlangeR();
-  Double_t z       = fmd3->GetInnerZ(); // fmd3->GetZ();
-
-  TGeoVolume* fmd3TopVolume = new TGeoVolumeAssembly(Form(fgkFMDName, 
-                                                         fmd3->GetId(), 'T'));
-  TGeoVolume* fmd3BotVolume = new TGeoVolumeAssembly(Form(fgkFMDName, 
-                                                         fmd3->GetId(), 'B'));
-  fmd3TopVolume->SetTitle("FMD3 top half");
-  fmd3BotVolume->SetTitle("FMD3 bottom half");
-  
-  
-  DetectorGeometry(fmd3, fmd3TopVolume, fmd3BotVolume, z, 
-                  innerTop, innerBot, outerTop, outerBot);
-
-  
-  TGeoVolumeAssembly* support = new TGeoVolumeAssembly("F3SU");
-  support->SetTitle("FMD3 support");
-  
-  // Cone shape 
-  TGeoPcon*        coneBase = new TGeoPcon("FMD3 cone base", 0, 180, 6);
-  const TObjArray& radii    = fmd3.ConeRadii();
-  TVector3*        v1       = 0;
-  TVector3*        v4       = 0;
-  for (Int_t i = 0; i < radii.GetEntriesFast(); i++) { 
-    TVector3* v = static_cast<TVector3*>(radii.At(i));
-    coneBase->DefineSection(i,  v->X(), v->Y(), v->Z());
-    if (i == 1) v1 = v;
-    if (i == 4) v4 = v;
-    
-  }
-  Double_t  holeL = TMath::Sqrt(TMath::Power(v4->Z()-v1->Z(),2) + 
-                               TMath::Power(v4->X()-v1->X(),2));
-  
-  TGeoTrd1*       coneHole  = new TGeoTrd1("F3SC_hole",2,8,conet*3,
-                                          (conel-2-2)/2);
-  
-
-
-  // Nose volume 
-  TGeoTubeSeg* noseShape  = new TGeoTubeSeg(noser1, noser2, nlen / 2, 0, 180);
-  TGeoVolume*  noseVolume = new TGeoVolume(fgkNoseName, noseShape, fC);
-  support->AddNode(noseVolume, 0, new TGeoTranslation(0, 0, nlen/2));
-  noseShape->SetName(fgkNoseName);
-  noseShape->SetTitle("FMD3 nose");
-  noseVolume->SetTitle("FMD3 nose");
-  
-  // Steel bolts 
-  TGeoTube*       boltShape  = new TGeoTube("F3SB", 0, 0.3, conet / 2);
-  TGeoVolume*     boltVolume = new TGeoVolume("F3SB", boltShape, fSteel);
-  Double_t        z1         = -10;
-  Double_t        x1         = (fmd3->ConeR(nz+z1));
-  TGeoRotation*   r1         = new TGeoRotation();
-  r1->RotateY(theta);
-  TGeoCombiTrans* t          = new TGeoCombiTrans("F3SB1",x1,0,-z1,r1);
-  support->AddNode(boltVolume, 1, t);
-  z1                         = -20;
-  x1                         = (fmd3->ConeR(nz+z1));
-  t                          = new TGeoCombiTrans("F3SB2",x1,0,-z1,r1);
-  support->AddNode(boltVolume, 2, t);
-  boltShape->SetTitle("FMD3 steering bolt");
-  boltVolume->SetTitle("FMD3 steering bolt");
-
-  // Cooling plates
-  TGeoTrd1*   plateShape  = new TGeoTrd1(2, 8, 0.1, (conel-2-2)/2-.1);
-  TGeoVolume* plateVolume = new TGeoVolume("F3CO", plateShape, fAl);
-  plateShape->SetName("F3C0");
-  plateShape->SetTitle("FMD3 cooling plate");
-  plateVolume->SetTitle("FMD3 cooling plate");
-
-  // Shape for carbon half-cone
-  TGeoConeSeg*    innerCone = new TGeoConeSeg("F3SC_inner", conel/2,
-                                             noser2-conet, noser2, 
-                                             backr2-conet, backr2, 0., 180.);
-  innerCone->SetTitle("FMD3 cone inner");
-  TGeoTrd1*       coneHole  = new TGeoTrd1("F3SC_hole",2,8,conet*3,
-                                          (conel-2-2)/2);
-  coneHole->SetTitle("FMD3 cone hole");
-  Double_t        holeAng   = TMath::ATan2(backr2 - noser2, conel);
-  Double_t        holeX     = ((conel-2) / 2 * TMath::Sin(holeAng) +
-                              conet     * TMath::Cos(holeAng) +
-                              noser2);
-  TGeoRotation*   holeRot   = new TGeoRotation();
-  holeRot->SetName("FMD3 cone hole rotation");
-  holeRot->RotateZ(90);
-  holeRot->RotateY(holeAng*180./TMath::Pi());
-  TGeoCombiTrans* holeTrans = new TGeoCombiTrans(holeX, 0, -2, holeRot);
-  holeRot->SetName("FMD3 cone hole");
-
-  // Build-up the composite shape for the cone, and add cooling plates
-  // at the same time. 
-  TString coneExp("F3SC_inner-(");
-  for (int i = 0; i < 4; i++) { 
-    Double_t        thisAng   = 360. / 8 * (i + .5);
-    TGeoCombiTrans* thisTrans = new TGeoCombiTrans(*holeTrans);
-    thisTrans->RotateZ(thisAng);
-    thisTrans->SetName(Form("F3SC_rot%d", i));
-    thisTrans->RegisterYourself();
-    coneExp.Append(Form("F3SC_hole:F3SC_rot%d+", i));
-
-    const Double_t* tt         = thisTrans->GetTranslation();
-    Double_t        x          = tt[0]+1*TMath::Cos(thisAng*TMath::Pi()/180);
-    Double_t        y          = tt[1]+1*TMath::Sin(thisAng*TMath::Pi()/180);
-    TGeoCombiTrans* plateTrans = new TGeoCombiTrans(x,y,tt[2]-1+nlen+conel/2,
-                                                   thisTrans->GetRotation());
-    support->AddNode(plateVolume, i, plateTrans);
-  }
-  // Remove bolt holes 
-  coneExp.Append("F3SB:F3SB1+F3SB:F3SB2)");
-
-  // Finalize the half-cone shape and add volume
-  TGeoCompositeShape* coneShape  = new TGeoCompositeShape(coneExp.Data());
-  TGeoVolume*         coneVolume = new TGeoVolume("F3SC", coneShape, fC);
-  coneShape->SetName("F3SC");
-  coneShape->SetTitle("FMD3 cone");
-  coneVolume->SetTitle("FMD3 cone");
-  support->AddNode(coneVolume,1,new TGeoTranslation(0,0,nlen+conel/2));
-  
-  // The flanges 
-  TGeoBBox* flangeShape    = new TGeoBBox((flanger - backr2) / 2, 
-                                         fmd3->GetBeamWidth() / 2,
-                                         backl / 2);
-  TGeoVolume* flangeVolume = new TGeoVolume(Form(fgkFlangeName, fmd3->GetId()),
-                                           flangeShape, fC);
-  flangeShape->SetName(Form(fgkFlangeName, fmd3->GetId()));
-  flangeShape->SetTitle("FMD3 flange");
-  flangeVolume->SetTitle("FMD3 flange");
-  
-  Int_t    n               = fmd3->GetNFlange();
-  Double_t r               = backr2 + (flanger - backr2) / 2;
-  for (Int_t i = 0; i  < n/2; i++) {
-    Double_t phi       = 360. / n * i + 180. / n;
-    Double_t x         = r * TMath::Cos(TMath::Pi() / 180 * phi);
-    Double_t y         = r * TMath::Sin(TMath::Pi() / 180 * phi);
-    TGeoRotation* rot  = new TGeoRotation;
-    rot->RotateZ(phi);
-    TGeoMatrix* matrix = new TGeoCombiTrans(x, y, nlen+conel-backl/2, rot);
-    matrix->SetName(Form("FMD3_flange_%02d", i));
-    matrix->SetTitle(Form("FMD3_flange_%2d", i));
-    support->AddNode(flangeVolume, i, matrix);
-  }
-
-  // Place support volumes in half-detector volumes 
-  z                          = fmd3->GetInnerZ();
-  z1                         = z-nz;
-  fmd3TopVolume->AddNode(support, 1, new TGeoTranslation(0,0,z1));
-  r1                         = new TGeoRotation();
-  r1->RotateZ(180);
-  t                          = new TGeoCombiTrans(0,0,z1,r1);
-  fmd3BotVolume->AddNode(support, 2, t);
-
-  TGeoRotation*   rot        = new TGeoRotation("FMD3 rotatation");
-  rot->RotateY(180);
-  TGeoVolume*     top        = gGeoManager->GetVolume("ALIC");
-  TGeoMatrix* mmatrix        = new TGeoCombiTrans("FMD3 trans", 0, 0, z, rot);
-  AliFMDDebug(5, ("Placing volumes %s and %s in ALIC at z=%f", 
-                  fmd3TopVolume->GetName(), fmd3BotVolume->GetName(), z));
-  top->AddNode(fmd3TopVolume, fmd3->GetId(), mmatrix);
-  top->AddNode(fmd3BotVolume, fmd3->GetId(), mmatrix);
-
-  return 0;
-}
-#endif
 
 //____________________________________________________________________
 void
index eb6fc31..aebfcbf 100644 (file)
@@ -85,22 +85,46 @@ protected:
       fCopper(o.fCopper), 
       fSteel(o.fSteel)
   {}
-  /** Assignment operator */
+  /** 
+   * Assignment operator 
+   *
+   * @return Reference to this object
+   */  
   AliFMDGeometryBuilder& operator=(const AliFMDGeometryBuilder&){return *this;}
-  /** Make a ring volume 
-      @param r Ring geometry 
-      @return  Ring volume */
+
+  /** 
+   * Make a polygonic extrusion shape based on verticies passed in @a
+   * verticies 
+   * 
+   * @param verticies List of verticies
+   * @param thick     Thickness
+   * 
+   * @return newly allocated polygonic extrusion shape
+   */
+  virtual TGeoShape* MakeXTRU(const TObjArray& verticies, Double_t thick) const;
+  
+  /** 
+   * Make a ring volume 
+   * 
+   * @param r Ring geometry 
+   *
+   * @return  Ring volume 
+   */
   virtual TGeoVolume* RingGeometry(AliFMDRing* r);
 
-  /** Make a honey comb shape from passed parameters.
-      @param id       Detector identifier (1,2, or 3)
-      @param ring     Ring identifier ('I' or 'O')
-      @param r1       Inner radius
-      @param r2       Outer radius
-      @param w        width 
-      @param t        Thickness of material 
-      @param c        Clearing from horizontal. 
-      @return Pointer to newly allocated composite shape. */ 
+  /** 
+   * Make a honey comb shape from passed parameters.
+   *
+   * @param id       Detector identifier (1,2, or 3)
+   * @param ring     Ring identifier ('I' or 'O')
+   * @param r1       Inner radius
+   * @param r2       Outer radius
+   * @param w        width 
+   * @param t        Thickness of material 
+   * @param c        Clearing from horizontal. 
+   *
+   * @return Pointer to newly allocated composite shape. 
+   */ 
   virtual TGeoShape* HoneycombShape(Int_t id, Char_t ring,
                                    double r1, double r2, 
                                    double w, double t, double c=0.3);
@@ -137,25 +161,33 @@ protected:
   virtual TGeoVolume* FMD1Geometry(AliFMD1* d, 
                                   TGeoVolume* innerTop,
                                   TGeoVolume* innerBot);
-  /** Make FMD2 volume 
-      @param d Detector geometry 
-      @param innerTop Inner ring volume 
-      @param innerBot Inner ring volume 
-      @param outerTop Outer ring volume 
-      @param outerBot Outer ring volume 
-      @return FMD2 volume  */
+  /** 
+   * Make FMD2 volume 
+   *
+   * @param d Detector geometry 
+   * @param innerTop Inner ring volume 
+   * @param innerBot Inner ring volume 
+   * @param outerTop Outer ring volume 
+   * @param outerBot Outer ring volume 
+   *
+   * @return FMD2 volume  
+   */
   virtual TGeoVolume* FMD2Geometry(AliFMD2* d, 
                                   TGeoVolume* innerTop, 
                                   TGeoVolume* innerBot, 
                                   TGeoVolume* outerTop,
                                   TGeoVolume* outerBot);
-  /** Make FMD3 volume 
-      @param d Detector geometry 
-      @param innerTop Inner ring volume 
-      @param innerBot Inner ring volume 
-      @param outerTop Outer ring volume 
-      @param outerBot Outer ring volume 
-      @return FMD3 volume  */
+  /**
+   * Make FMD3 volume 
+   *
+   * @param d Detector geometry 
+   * @param innerTop Inner ring volume 
+   * @param innerBot Inner ring volume 
+   * @param outerTop Outer ring volume 
+   * @param outerBot Outer ring volume 
+   *
+   * @return FMD3 volume  
+   */
   virtual TGeoVolume* FMD3Geometry(AliFMD3* d, 
                                   TGeoVolume* innerTop, 
                                   TGeoVolume* innerBot, 
index 920b554..0bd0986 100644 (file)
@@ -227,9 +227,9 @@ AliFMDReconstructor::GetVertex() const
   fCurrentVertex = 0;
   if (fESD) {
     const AliESDVertex* vertex = fESD->GetPrimaryVertex();
-    if (!vertex) vertex = fESD->GetPrimaryVertexSPD();
-    if (!vertex) vertex = fESD->GetPrimaryVertexTPC();
-    if (!vertex) vertex = fESD->GetVertex();
+    if (!vertex)        vertex = fESD->GetPrimaryVertexSPD();
+    if (!vertex)        vertex = fESD->GetPrimaryVertexTPC();
+    if (!vertex)        vertex = fESD->GetVertex();
 
     if (vertex) {
       AliFMDDebug(2, ("Got %s (%s) from ESD: %f", 
index b53588f..f23b955 100644 (file)
@@ -65,7 +65,10 @@ AliFMDRing::AliFMDRing(Char_t id)
     fSpacing(0),
     fHoneycombThickness(0.),
     fAlThickness(0.),
-    fVerticies(0)
+    fVerticies(0), 
+    fSensorVerticies(0),
+    fHybridVerticies(0),
+    fFeetPositions(0)
 {
   // CTOR
   SetBondingWidth();
@@ -87,12 +90,56 @@ AliFMDRing::AliFMDRing(Char_t id)
     SetHighR(17.2);
     SetTheta(36/2);
     SetNStrips(512);
+    Double_t base = 0; // 4.1915;
+    fFeetPositions.Add(new TVector2( 0.0551687, 8.0534-base));
+    fFeetPositions.Add(new TVector2( 2.9993,   12.9457-base));
+    fFeetPositions.Add(new TVector2(-2.9062,   12.9508-base));
+    
+    fHybridVerticies.Add(new TVector2(0.0000,  4.1700));
+    fHybridVerticies.Add(new TVector2(1.0574,  4.1700));
+    fHybridVerticies.Add(new TVector2(4.6614, 15.2622));
+    fHybridVerticies.Add(new TVector2(0.9643, 17.4000));
+    fHybridVerticies.Add(new TVector2(0.0000, 17.4000));
+
+    fSensorVerticies.Add(new TVector2(0.0000,  4.1915));
+    fSensorVerticies.Add(new TVector2(1.5793,  4.1915));
+    fSensorVerticies.Add(new TVector2(5.2293, 15.4251));
+    fSensorVerticies.Add(new TVector2(1.9807, 17.3035));
+    fSensorVerticies.Add(new TVector2(0.0000, 17.3035));
+
+    fVerticies.Add(new TVector2(0.0000,  4.3000));
+    fVerticies.Add(new TVector2(1.3972,  4.3000));
+    fVerticies.Add(new TVector2(4.9895, 15.3560));
+    fVerticies.Add(new TVector2(1.8007, 17.2000));
+    fVerticies.Add(new TVector2(0.0000, 17.2000));
   }
   else if (fId == 'O' || fId == 'o') {
     SetLowR(15.6);
     SetHighR(28.0);
     SetTheta(18/2);
     SetNStrips(256);
+    Double_t base = 0; // 14.9104;
+    fFeetPositions.Add(new TVector2(-1.72540000, 20.6267-base));
+    fFeetPositions.Add(new TVector2( 1.72900000, 20.6267-base));
+    fFeetPositions.Add(new TVector2( 0.00177616, 26.6007-base));
+
+    fHybridVerticies.Add(new TVector2(0.0000, 14.9104));
+    fHybridVerticies.Add(new TVector2(2.0783, 14.9104));
+    fHybridVerticies.Add(new TVector2(3.9202, 26.5395));
+    fHybridVerticies.Add(new TVector2(0.6784, 28.2500));
+    fHybridVerticies.Add(new TVector2(0.0000, 28.2500));
+
+    fSensorVerticies.Add(new TVector2(0.0000, 15.0104));
+    fSensorVerticies.Add(new TVector2(2.5799, 15.0104));
+    fSensorVerticies.Add(new TVector2(4.4439, 26.7766));
+    fSensorVerticies.Add(new TVector2(1.8350, 28.1500));
+    fSensorVerticies.Add(new TVector2(0.0000, 28.1500));
+
+    fVerticies.Add(new TVector2(0.0000, 15.2104));
+    fVerticies.Add(new TVector2(2.4091, 15.2104));
+    fVerticies.Add(new TVector2(4.2231, 26.6638));
+    fVerticies.Add(new TVector2(1.8357, 27.9500));
+    fVerticies.Add(new TVector2(0.0000, 27.9500));
   }
 }
 
@@ -101,6 +148,7 @@ void
 AliFMDRing::Init()
 {
   // Initialize 
+#if 0
   Double_t tanTheta  = TMath::Tan(fTheta * TMath::Pi() / 180.);
   Double_t tanTheta2 = TMath::Power(tanTheta,2);
   Double_t r2        = TMath::Power(fWaferRadius,2);
@@ -122,10 +170,11 @@ AliFMDRing::Init()
   fVerticies.AddAt(new TVector2(fHighR,  yB), 3);
   fVerticies.AddAt(new TVector2(xC,      yC), 4);
   fVerticies.AddAt(new TVector2(fLowR,   yA), 5);  
+#endif
 
   // A's length. Corresponds to distance from nominal beam line to the
   // cornor of the active silicon element. 
-  fMinR = GetVertex(5)->Mod();
+  fMinR = GetVertex(1)->Mod(); // GetVertex(5)->Mod();
   // A's length. Corresponds to distance from nominal beam line to the
   // cornor of the active silicon element. 
   fMaxR = fHighR;
@@ -144,6 +193,30 @@ AliFMDRing::GetVertex(Int_t i) const
 }
 
 //____________________________________________________________________
+TVector2*
+AliFMDRing::GetSensorVertex(Int_t i) const
+{
+  // Get the i'th vertex of polygon shape
+  return static_cast<TVector2*>(fSensorVerticies.At(i));
+}
+
+//____________________________________________________________________
+TVector2*
+AliFMDRing::GetHybridVertex(Int_t i) const
+{
+  // Get the i'th vertex of polygon shape
+  return static_cast<TVector2*>(fHybridVerticies.At(i));
+}
+
+//____________________________________________________________________
+TVector2*
+AliFMDRing::GetFootPosition(Int_t i) const
+{
+  // Get the i'th vertex of polygon shape
+  return static_cast<TVector2*>(fFeetPositions.At(i));
+}
+
+//____________________________________________________________________
 Double_t
 AliFMDRing::GetStripRadius(UShort_t strip) const
 {
@@ -156,19 +229,27 @@ AliFMDRing::GetStripRadius(UShort_t strip) const
  
 //____________________________________________________________________
 Double_t
+AliFMDRing::GetModuleDepth() const
+{
+  return (GetSiThickness() 
+         + GetSpacing() 
+         + GetPrintboardThickness()
+         + GetCopperThickness()
+         + GetChipThickness()
+         + GetLegLength());
+  
+}
+
+//____________________________________________________________________
+Double_t
 AliFMDRing::GetFullDepth() const
 {
-  return (GetSiThickness() + 
-         GetSpacing() + 
-         GetPrintboardThickness() + 
-         GetCopperThickness() + 
-         GetChipThickness() + 
-         GetModuleSpacing() +
-         GetLegLength() + 
-         GetHoneycombThickness() + 
-         GetFMDDPrintboardThickness() + 
-         GetFMDDCopperThickness() + 
-         GetFMDDChipThickness() 
+  return (GetModuleDepth() 
+         + GetModuleSpacing()
+         + GetHoneycombThickness()
+         + GetFMDDPrintboardThickness()
+         + GetFMDDCopperThickness()
+         + GetFMDDChipThickness() 
          + 0.5);
 }
 
index f05f8b7..3861aba 100644 (file)
 class TBrowser;
 class TVector2;
 
-/** @brief Geometry description and parameters of a ring in the FMD 
-    detector. 
-    
-    As there are only 2 kinds of rings @e Inner (@c 'I') and @e
-    Outer (@c 'O') the two objects of this class is owned by the
-    Geometry::FMD singleton object.  The 3 Geometry::FMDDetector
-    objects shares these two instances as needed. 
-    @ingroup FMD_base
+/** 
+ * @brief Geometry description and parameters of a ring in the FMD 
+ * detector. 
+ *
+ * As there are only 2 kinds of rings @e Inner (@c 'I') and @e Outer
+ * (@c 'O') the two objects of this class is owned by the
+ * AliFMDGeometry singleton object.  The 3 AliFMDDetector objects
+ * shares these two instances as needed.
+ * @ingroup FMD_base
 */
 class AliFMDRing : public TNamed
 {
 public:
-  /** CTOR
-      @param fId Ring ID  */
+  /** 
+   * CTOR
+   *
+   * @param fId Ring ID  
+   */
   AliFMDRing(Char_t fId);
-  /** DTOR  */
+  /** 
+   * DTOR  
+   */
   virtual ~AliFMDRing() {}
-  /** Initialize the ring geometry */
+  /** 
+   * Initialize the ring geometry 
+   */
   virtual void Init();
   
-  /** @param x Value of The Id of this ring type */
+  /** 
+   *
+   * @param x Value of The Id of this ring type
+   */
   void SetId(Char_t x) { fId = x; }
-  /** @param x Value of With of bonding pad on sensor */
+  /** 
+   *
+   * @param x Value of With of bonding pad on sensor
+   */
   void SetBondingWidth(Double_t x=.5) { fBondingWidth = x; }
-  /** @param x Value of Size of wafer the sensor was made from */
+  /** 
+   *
+   * @param x Value of Size of wafer the sensor was made from
+   */
   void SetWaferRadius(Double_t x=13.4/2) { fWaferRadius = x; }
-  /** @param x Value of Thickness of sensor */
+  /** 
+   *
+   * @param x Value of Thickness of sensor
+   */
   void SetSiThickness(Double_t x=.032) { fSiThickness = x; }
-  /** @param x Value of Lower radius of ring */
+  /** 
+   *
+   * @param x Value of Lower radius of ring
+   */
   void SetLowR(Double_t x) { fLowR = x; }
-  /** @param x Value of Upper radius of ring */
+  /** 
+   *
+   * @param x Value of Upper radius of ring
+   */
   void SetHighR(Double_t x) { fHighR = x; }
-  /** @param x Value of Opening angle of the silicon wafers */
+  /** 
+   *
+   * @param x Value of Opening angle of the silicon wafers
+   */
   void SetTheta(Double_t x) { fTheta = x; }
-  /** @param x Value of Number of strips */
+  /** 
+   *
+   * @param x Value of Number of strips
+   */
   void SetNStrips(Int_t x) { fNStrips = x; }
-  /** @param x Value of How far the ring extends beyond the z value given. */
+  /** 
+   *
+   * @param x Value of How far the ring extends beyond the z value given.
+   */
   void SetRingDepth(Double_t x) { fRingDepth = x; }
-  /** @param x Value of Radius of support legs */
-  void SetLegRadius(Double_t x=.2) { fLegRadius = x; }
-  /** @param x Value of Radius of support legs */
-  void SetLegLength(Double_t x=1) { fLegLength = x; }
-  /** @param x Value of Radius of support legs */
+  /** 
+   *
+   * @param x Value of Radius of support legs
+   */
+  void SetLegRadius(Double_t x=.25) { fLegRadius = x; }
+  /** 
+   *
+   * @param x Value of Radius of support legs
+   */
+  void SetLegLength(Double_t x=.9) { fLegLength = x; }
+  /** 
+   *
+   * @param x Value of Radius of support legs
+   */
   void SetLegOffset(Double_t x=2) { fLegOffset = x; }
-  /** @param x Value of Staggering offset */
-  void SetModuleSpacing(Double_t x=.6) { fModuleSpacing = x; }
-  /** @param x Value of Thickness of print board */
-  void SetPrintboardThickness(Double_t x=.1) { fPrintboardThickness = x; }
-  /** @param x Value of Thickness of copper on print board */
+  /** 
+   *
+   * @param x Value of Staggering offset
+   */
+  void SetModuleSpacing(Double_t x=.5) { fModuleSpacing = x; }
+  /** 
+   *
+   * @param x Value of Thickness of print board
+   */
+  void SetPrintboardThickness(Double_t x=.08) { fPrintboardThickness = x; }
+  /** 
+   *
+   * @param x Value of Thickness of copper on print board
+   */
   void SetCopperThickness(Double_t x=.01) { fCopperThickness = x; }
-  /** @param x Value of Thickness of chip on print board */
+  /** 
+   *
+   * @param x Value of Thickness of chip on print board
+   */
   void SetChipThickness(Double_t x=.01) { fChipThickness = x; }
-  /** @param x Value of spacing between si and PCB */
+  /** 
+   *
+   * @param x Value of spacing between si and PCB
+   */
   void SetSpacing(Double_t x=.05) { fSpacing = x; }
-  /** @param x Thickness of honeycomb plate */
+  /** 
+   *
+   * @param x Thickness of honeycomb plate
+   */
   void SetHoneycombThickness(Double_t x=0.65) { fHoneycombThickness = x; }
-  /** @param x Thickness of aluminium of honeycomb */
+  /** 
+   *
+   * @param x Thickness of aluminium of honeycomb
+   */
   void SetAlThickness(Double_t x=.1) { fAlThickness = x; }
 
-  /** @return The Id of this ring type */
+  /** 
+   *
+   * @return The Id of this ring type
+   */
   Char_t GetId() const { return fId; }
-  /** @return With of bonding pad on sensor */
+  /** 
+   *
+   * @return With of bonding pad on sensor
+   */
   Double_t GetBondingWidth() const { return fBondingWidth; }
-  /** @return Size of wafer the sensor was made from */
+  /** 
+   *
+   * @return Size of wafer the sensor was made from
+   */
   Double_t GetWaferRadius() const { return fWaferRadius; }
-  /** @return Thickness of sensor */
+  /** 
+   *
+   * @return Thickness of sensor
+   */
   Double_t GetSiThickness() const { return fSiThickness; }
-  /** @return Minimum r for an active strip */
+  /** 
+   *
+   * @return Minimum r for an active strip
+   */
   Double_t GetMinR() const { return fMinR; }
-  /** @return Maximum r for an active strip */
+  /** 
+   *
+   * @return Maximum r for an active strip
+   */
   Double_t GetMaxR() const { return fMaxR; }
-  /** @return Lower radius of ring */
+  /** 
+   *
+   * @return Lower radius of ring
+   */
   Double_t GetLowR() const { return fLowR; }
-  /** @return Upper radius of ring */
+  /** 
+   *
+   * @return Upper radius of ring
+   */
   Double_t GetHighR() const { return fHighR; }
-  /** @return Opening angle of the sector (half that of silicon wafers) */
+  /** 
+   *
+   * @return Opening angle of the sector (half that of silicon wafers)
+   */
   Double_t GetTheta() const { return fTheta; }
-  /** @return Number of strips */
+  /** 
+   *
+   * @return Number of strips
+   */
   Int_t GetNStrips() const { return fNStrips; }
-  /** @return Number of sectors */
+  /** 
+   *
+   * @return Number of sectors
+   */
   Int_t GetNSectors() const { return Int_t(360. / fTheta); }
-  /** @return Number of modules (2 sectors per module) */
+  /** 
+   *
+   * @return Number of modules (2 sectors per module)
+   */
   Int_t GetNModules() const { return GetNSectors() / 2; }
-  /** @return How far the ring extends beyond the z value given. */
+  /** 
+   *
+   * @return How far the ring extends beyond the z value given.
+   */
   Double_t GetRingDepth() const { return fRingDepth; }
-  /** @return Radius of support legs */
+  /** 
+   *
+   * @return Radius of support legs
+   */
   Double_t GetLegRadius() const { return fLegRadius; }
-  /** @return Radius of support legs */
+  /** 
+   *
+   * @return Radius of support legs
+   */
   Double_t GetLegLength() const { return fLegLength; }
-  /** @return Radius of support legs */
+  /** 
+   *
+   * @return Radius of support legs
+   */
   Double_t GetLegOffset() const { return fLegOffset; }
-  /** @return Staggering offset */
+  /** 
+   *
+   * @return Staggering offset
+   */
   Double_t GetModuleSpacing() const { return fModuleSpacing; }
-  /** @return Thickness of print board */
+  /** 
+   *
+   * @return Thickness of print board
+   */
   Double_t GetPrintboardThickness() const { return fPrintboardThickness; }
-  /** @return Thickness copper of print board */
+  /** 
+   *
+   * @return Thickness copper of print board
+   */
   Double_t GetCopperThickness() const { return fCopperThickness; }
-  /** @return Thickness chip of print board */
+  /** 
+   *
+   * @return Thickness chip of print board
+   */
   Double_t GetChipThickness() const { return fChipThickness; }
-  /** @return Value of spacing between si and PCB */
+  /** 
+   *
+   * @return Value of spacing between si and PCB
+   */
   Double_t GetSpacing() const { return fSpacing; }
-  /** @return Thickness of honeycomb plate */
+  /** 
+   *
+   * @return Thickness of honeycomb plate
+   */
   Double_t GetHoneycombThickness() const { return fHoneycombThickness; }
-  /** @return Thickness of aluminium of honeycomb */
+  /** 
+   *
+   * @return Thickness of aluminium of honeycomb
+   */
   Double_t GetAlThickness() const { return fAlThickness; }
-  /** @return The strip pitch */ 
+  /** 
+   *
+   * @return The strip pitch
+   */ 
   Double_t GetPitch() const { return (fMaxR - fMinR) / fNStrips; }
-  /** @return Radius (in cm) correspondig to strip @a strip */
+  /** 
+   *
+   * @return Radius (in cm) correspondig to strip @a strip
+   */
   Double_t GetStripRadius(UShort_t strip) const;
-  /** @return Full depth of this (half) ring */
+  /** 
+   *
+   * @return Full depth of (low) modules in this (half) ring
+   */
+  Double_t GetModuleDepth() const;
+  /** 
+   *
+   * @return Full depth of this (half) ring
+   */
   Double_t GetFullDepth() const;
-  /** Get the inner radius of the digitizer cards */
+  /** 
+   * Get the inner radius of the digitizer cards 
+   *
+   * @return The inner radius of the digitizer cards 
+   */
   Double_t GetFMDDLowR() const { return 1.2*GetLowR(); }
-  /** Get the outer radius of the digitizer cards */
+  /** 
+   * Get the outer radius of the digitizer cards 
+   *
+   * @return The outer radius of the digitizer cards 
+   */
   Double_t GetFMDDHighR() const { return .95*GetHighR(); }
-  /** @return Thickness of print board */
+  /** 
+   *
+   * @return Thickness of print board
+   */
   Double_t GetFMDDPrintboardThickness() const { return 2*fPrintboardThickness; }
-  /** @return Thickness copper of print board */
+  /** 
+   *
+   * @return Thickness copper of print board
+   */
   Double_t GetFMDDCopperThickness() const { return 2*fCopperThickness; }
-  /** @return Thickness chip of print board */
+  /** 
+   *
+   * @return Thickness chip of print board
+   */
   Double_t GetFMDDChipThickness() const { return 2*fChipThickness; }
 
-  /** @return List of verticies */
+  /** 
+   *
+   * @return List of verticies
+   */
   const TObjArray& GetVerticies() const { return fVerticies; }
-  /** @return Number of verticies */
+  /** 
+   *
+   * @return Number of verticies
+   */
   Int_t GetNVerticies() const { return fVerticies.GetEntries(); }
-  /** @param i Vertex number 
-      @return the ith vertex */
+  /** 
+   * @param i Vertex number 
+   *
+   * @return the ith vertex 
+   */
   TVector2* GetVertex(Int_t i) const;
+  /** 
+   *
+   * @return List of verticies
+   */
+  const TObjArray& GetSensorVerticies() const { return fSensorVerticies; }
+  /** 
+   * @param i Vertex number 
+   *
+   * @return the ith vertex 
+   */
+  TVector2* GetSensorVertex(Int_t i) const;
+  /** 
+   *
+   * @return List of verticies
+   */
+  const TObjArray& GetHybridVerticies() const { return fHybridVerticies; }
+  /** 
+   * @param i Vertex number 
+   *
+   * @return the ith vertex 
+   */
+  TVector2* GetHybridVertex(Int_t i) const;
+
+  /** 
+   * Get a list of feet positions 
+   * 
+   * 
+   * @return List TVector2 of feet positions on hybrid card
+   */  
+  const TObjArray& GetFeetPositions() const { return fFeetPositions; }
+  /** 
+   * Get the number of feet positions 
+   * 
+   * 
+   * @return Number of feet positions 
+   */
+  Int_t GetNFeetPositions() const { return fFeetPositions.GetEntries(); }
+  /** 
+   * Get the @a i feet position
+   * 
+   * @param i Index
+   * 
+   * @return The foot position of stand-off @a i 
+   */  
+  TVector2* GetFootPosition(Int_t i) const;
+    
      
   /** Not used */
   void Detector2XYZ(UShort_t sector, UShort_t strip, 
@@ -187,8 +407,11 @@ private:
   Double_t     fHoneycombThickness;    // Thickness of honeycomb plate
   Double_t     fAlThickness;           // Thickness of aluminium of honeycomb
   
-  TObjArray    fVerticies;             // List of verticies
-
+  TObjArray    fVerticies;             // List of active sensor verticies
+  TObjArray     fSensorVerticies;       // List of physical sensor verticies
+  TObjArray     fHybridVerticies;       // List of hybrid card verticies
+  TObjArray     fFeetPositions;         // List of feet positions
+  
   ClassDef(AliFMDRing, 0);
 };
 #endif 
index a4306cc..0c50a1f 100644 (file)
@@ -475,241 +475,40 @@ Config()
   Bool_t useTRD   = kFALSE; 
   Bool_t useZDC   = kFALSE; 
   Bool_t useEMCAL = kFALSE; 
-  Bool_t useVZERO = kFALSE;
+  Bool_t useVZERO = kTRUE;
 
   cout << "\t* Creating the detectors ..." << endl;
   // ================= Alice BODY parameters =========================
   AliBODY *BODY = new AliBODY("BODY", "Alice envelop");
   
   
-  if (useMAG) {
-    // =================== MAG parameters ============================
-    // Start with Magnet since detector layouts may be depending on
-    // the selected Magnet dimensions 
-    AliMAG *MAG = new AliMAG("MAG", "Magnet");
-  }
-
-  if (useABSO) {
-    // =================== ABSO parameters ===========================
-    AliABSO *ABSO = new AliABSOv0("ABSO", "Muon Absorber");
-  }
-
-  if (useDIPO) {
-    // =================== DIPO parameters ===========================
-    AliDIPO *DIPO = new AliDIPOv2("DIPO", "Dipole version 2");
-  }
-
-  if (useHALL) {
-    // =================== HALL parameters ===========================
-    AliHALL *HALL = new AliHALL("HALL", "Alice Hall");
-  }
-
-
+  if (useMAG)   AliMAG  *MAG  = new AliMAG("MAG", "Magnet");
+  if (useABSO)  AliABSO *ABSO = new AliABSOv3("ABSO", "Muon Absorber");
+  if (useDIPO)  AliDIPO *DIPO = new AliDIPOv3("DIPO", "Dipole version 3");
+  if (useHALL)  AliHALL *HALL = new AliHALLv3("HALL", "Alice Hall");
   if (useFRAME) {
-    // ================== FRAME parameters ===========================
     AliFRAMEv2 *FRAME = new AliFRAMEv2("FRAME", "Space Frame");
     switch (geo) {
     case kHoles: FRAME->SetHoles(1); break;
     default:     FRAME->SetHoles(0); break;
     }
   }
-
-  if (useSHIL) {
-    // ================== SHIL parameters ============================
-    AliSHIL *SHIL = new AliSHILv2("SHIL", "Shielding Version 2");
-  }
-
-
-  if (usePIPE) {
-    // ================== PIPE parameters ============================
-    AliPIPE *PIPE = new AliPIPEv3("PIPE", "Beam Pipe");
-  }
-  
-  if (useITS) {
-     AliITS *ITS  = new AliITSv11Hybrid("ITS","ITS v11Hybrid");
-#if 0
-    // =================== ITS parameters ============================
-    //
-    // As the innermost detector in ALICE, the Inner Tracking System
-    // "impacts" on almost all other detectors. This involves the fact
-    // that the ITS geometry still has several options to be followed
-    // in parallel in order to determine the best set-up which
-    // minimizes the induced background. All the geometries available
-    // to date are described in the following. Read carefully the
-    // comments and use the default version (the only one uncommented)
-    // unless you are making comparisons and you know what you are
-    // doing. In this case just uncomment the ITS geometry you want to
-    // use and run Aliroot.
-    //
-    // Detailed geometries:
-    //
-    //
-    // AliITS *ITS = 
-    //   new AliITSv5symm("ITS", "Updated ITS TDR detailed version "
-    //                   "with symmetric services");
-    // AliITS *ITS  = 
-    //   new AliITSv5asymm("ITS","Updates ITS TDR detailed version "
-    //                            "with asymmetric services");
-    //
-    AliITSvPPRasymmFMD *ITS  = 
-      new AliITSvPPRasymmFMD("ITS","New ITS PPR detailed version "
-                            "with asymmetric services");
-     // don't touch this parameter if you're not an ITS developer
-    ITS->SetMinorVersion(2); 
-    // don't touch this parameter if you're not an ITS developer
-    ITS->SetReadDet(kTRUE);
-    // don't touch this parameter if you're not an ITS developer
-    // ITS->SetWriteDet("$ALICE_ROOT/ITS/ITSgeometry_vPPRasymm2.det");  
-    // detector thickness on layer 1 must be in the range [100,300]
-    ITS->SetThicknessDet1(200.);   
-    // detector thickness on layer 2 must be in the range [100,300]
-    ITS->SetThicknessDet2(200.);   
-    // chip thickness on layer 1 must be in the range [150,300]
-    ITS->SetThicknessChip1(200.);  
-    // chip thickness on layer 2 must be in the range [150,300]
-    ITS->SetThicknessChip2(200.);
-    // 1 --> rails in ; 0 --> rails out
-    ITS->SetRails(0);          
-    // 1 --> water ; 0 --> freon
-    ITS->SetCoolingFluid(1);   
-
-    // Coarse geometries (warning: no hits are produced with these
-    // coarse geometries and they unuseful for reconstruction !):
-    //
-    //
-    // AliITSvPPRcoarseasymm *ITS  = 
-    //   new AliITSvPPRcoarseasymm("ITS","New ITS PPR coarse version "
-    //                             "with asymmetric services");
-    // 1 --> rails in ; 0 --> rails out
-    // ITS->SetRails(0);
-    // 0 --> Copper ; 1 --> Aluminum ; 2 --> Carbon
-    // ITS->SetSupportMaterial(0);      
-    //
-    // AliITS *ITS  = 
-    //  new AliITSvPPRcoarsesymm("ITS","New ITS PPR coarse version "
-    //                           "with symmetric services");
-    // 1 --> rails in ; 0 --> rails out
-    // ITS->SetRails(0);                
-    // 0 --> Copper ; 1 --> Aluminum ; 2 --> Carbon
-    // ITS->SetSupportMaterial(0);      
-    //
-    // Geant3 <-> EUCLID conversion
-    // ============================
-    //
-    // SetEUCLID is a flag to output (=1) or not to output (=0) both
-    // geometry and media to two ASCII files (called by default
-    // ITSgeometry.euc and ITSgeometry.tme) in a format understandable
-    // to the CAD system EUCLID.  The default (=0) means that you dont
-    // want to use this facility.
-    //
-    ITS->SetEUCLID(0);
-#endif
-  }
-
-  if (useTPC) {
-    // =================== TPC parameters ============================
-    //
-    // This allows the user to specify sectors for the SLOW (TPC
-    // geometry 2) Simulator. SecAL (SecAU) <0 means that ALL lower
-    // (upper) sectors are specified, any value other than that
-    // requires at least one sector (lower or upper)to be specified!
-    //
-    // Reminder: 
-    //   sectors 1-24 are lower sectors (1-12 -> z>0, 13-24 -> z<0)
-    //   sectors 25-72 are the upper ones (25-48 -> z>0, 49-72 -> z<0)
-    //
-    //   SecLows - number of lower sectors specified (up to 6)
-    //   SecUps  - number of upper sectors specified (up to 12)
-    //   Sens    - sensitive strips for the Slow Simulator !!!
-    //
-    // This does NOT work if all S or L-sectors are specified, i.e.
-    // if SecAL or SecAU < 0
-    //
-    //
-    //----------------------------------------------------------------
-    //  gROOT->LoadMacro("SetTPCParam.C");
-    //  AliTPCParam *param = SetTPCParam();
-    AliTPC *TPC = new AliTPCv2("TPC", "Default");
-  }
-
-  if (useTOF) {
-    // ================== TOF parameters =============================
-    AliTOF *TOF = new AliTOFv4T0("TOF", "normal TOF");
-  }
-
-  if (useHMPID) {
-    // ================== HMPID parameters ============================
-    AliHMPID *HMPID = new AliHMPIDv1("HMPID", "normal HMPID");
-
-  }
-
-  if (useZDC) {
-    // ================== ZDC parameters =============================
-    AliZDC *ZDC = new AliZDCv2("ZDC", "normal ZDC");
-  }
-
-  if (useTRD) {
-    // ================== TRD parameters =============================
-    AliTRD *TRD = new AliTRDv1("TRD", "TRD slow simulator");
-
-    // Select the gas mixture (0: 97% Xe + 3% isobutane, 1: 90% Xe + 10% CO2)
-    TRD->SetGasMix(1);
-    if (geo == kHoles) {
-      // With hole in front of PHOS
-      TRD->SetPHOShole();
-      // With hole in front of HMPID
-      TRD->SetHMPIDhole();
-    }
-    // Switch on TR
-    AliTRDsim *TRDsim = TRD->CreateTR();
-  }
-
-  if (useFMD) {
-    // =================== FMD parameters ============================
-    AliFMD *FMD = new AliFMDv1("FMD", "normal FMD");
-    // FMD->UseDetailed(kFALSE);
-    // FMD->UseAssembly();
-    // FMD->UseOld();
-  }
-
-  if (useMUON) {
-    // =================== MUON parameters ===========================
-    AliMUON *MUON = new AliMUONv1("MUON", "default");
-    // MUON->AddGeometryBuilder(new AliMUONSt1GeometryBuilder(MUON));
-    // MUON->AddGeometryBuilder(new AliMUONSt2GeometryBuilder(MUON));
-    // MUON->AddGeometryBuilder(new AliMUONSlatGeometryBuilder(MUON));
-    // MUON->AddGeometryBuilder(new AliMUONTriggerGeometryBuilder(MUON));
-  }
-
-  if (usePHOS) {
-    // =================== PHOS parameters ===========================
-    AliPHOS *PHOS = new AliPHOSv1("PHOS", "IHEP");
-  }
-
-  if (usePMD) {
-    // =================== PMD parameters ============================
-    AliPMD *PMD = new AliPMDv1("PMD", "normal PMD");
-  }
-
-  if (useT0) {
-    // =================== T0 parameters ==========================
-    AliT0 *T0 = new AliT0v1("T0", "T0 Detector");
-  }
-
-  if (useEMCAL) {
-    // =================== EMCAL parameters ==========================
-    AliEMCAL *EMCAL = new AliEMCALv2("EMCAL", "EMCAL_COMPLETE");
-  }
-
-  if (useACORDE) {
-    // =================== ACORDE parameters ============================
-    AliACORDE *ACORDE = new AliACORDEv1("ACORDE", "normal ACORDE");
-  }
-
-  if (useVZERO) {
-    // =================== V0 parameters =============================
-    AliVZERO *VZERO = new AliVZEROv3("VZERO", "normal VZERO");
-  }
+  if (useSHIL)   AliSHIL   *SHIL   = new AliSHILv3("SHIL", "Shielding v3");
+  if (usePIPE)   AliPIPE   *PIPE   = new AliPIPEv3("PIPE", "Beam Pipe");
+  if (useITS)    AliITS    *ITS    = new AliITSv11Hybrid("ITS","ITS v11Hybrid");
+  if (useTPC)    AliTPC    *TPC    = new AliTPCv2("TPC", "Default");
+  if (useTOF)    AliTOF    *TOF    = new AliTOFv6T0("TOF", "normal TOF");
+  if (useHMPID)  AliHMPID  *HMPID  = new AliHMPIDv1("HMPID", "normal HMPID");
+  if (useZDC)    AliZDC    *ZDC    = new AliZDCv3("ZDC", "normal ZDC");
+  if (useTRD)    AliTRD    *TRD    = new AliTRDv1("TRD", "TRD slow simulator");
+  if (useFMD)    AliFMD    *FMD    = new AliFMDv1("FMD", "normal FMD");
+  if (useMUON)   AliMUON   *MUON   = new AliMUONv1("MUON", "default");
+  if (usePHOS)   AliPHOS   *PHOS   = new AliPHOSv1("PHOS", "IHEP");
+  if (usePMD)    AliPMD    *PMD    = new AliPMDv1("PMD", "normal PMD");
+  if (useT0)     AliT0     *T0     = new AliT0v1("T0", "T0 Detector");
+  if (useEMCAL)  AliEMCAL  *EMCAL  = new AliEMCALv2("EMCAL", "EMCAL_COMPLETE");
+  if (useACORDE) AliACORDE *ACORDE = new AliACORDEv1("ACORDE", "normal ACORDE");
+  if (useVZERO)  AliVZERO  *VZERO  = new AliVZEROv7("VZERO", "normal VZERO");
 }
 
 //____________________________________________________________________
index ff8f628..2e37305 100644 (file)
@@ -7,7 +7,8 @@ PhysicalCoordinates(UShort_t det, Char_t rng, UShort_t sec, UShort_t str)
   AliFMDGeometry::Instance()->Detector2XYZ(det, rng, sec, str, x, y, z);
   Double_t phi   = TMath::ATan2(y, x);
   Double_t r     = TMath::Sqrt(x * x + y * y);
-  Double_t theta = TMath::ATan2(z, r);
+  Double_t theta = TMath::ATan2(r, z);
+  if (theta < 0) theta += TMath::Pi();
   Double_t eta   = -TMath::Log(TMath::Tan(theta / 2));
   Double_t deg   = 180. / TMath::Pi();
   
@@ -34,7 +35,7 @@ ShowCoordinates()
            << std::setw(1+9+1+9+1+9+1+1)  << "+"
            << std::setw(1+9+1+9+1+9+1+1)  << "+" 
            << std::setfill(' ') << std::endl;
-  for (UShort_t d = 1; d < 3; d++) {
+  for (UShort_t d = 1; d <= 3; d++) {
     UShort_t nrng = (d == 1 ? 1 : 2);
     for (UShort_t ir = 0; ir < nrng; ir++) { 
       Char_t r = (ir == 0 ? 'I' : 'O');
index 6760db4..5836cca 100644 (file)
@@ -1,7 +1,7 @@
 void
 ShowFMDITS(const char* name="ALIC")
 {
-  // AliLog::SetModuleDebugLevel("FMD", 1);
+  AliLog::SetModuleDebugLevel("FMD", 1);
   gAlice->InitMC("$ALICE_ROOT/FMD/Config.C");
 
   const char* inv[] = { "RB24", "RB26Pipe", 
@@ -43,7 +43,7 @@ ShowFMDITS(const char* name="ALIC")
       std::cerr << "Volume " << n << " not found" << std::endl;
       continue;
     }
-    std::cout << "Processing " << n << std::endl;
+    // std::cout << "Processing " << n << std::endl;
     vol->SetVisDaughters(kFALSE);
     vol->SetVisContainers(kTRUE);
     vol->SetVisibility(kFALSE);