FMD/AliFMDRing.cxx

   1 /**************************************************************************
   2  * Copyright(c) 2004, ALICE Experiment at CERN, All rights reserved.      *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 //__________________________________________________________________
  19 //
  20 // Utility class to help implement collection of FMD modules into
  21 // rings.  This is used by AliFMDSubDetector and AliFMD.
  22 //
  23 // The AliFMD object owns the AliFMDRing objects, and the
  24 // AliFMDSubDetector objects reference these.  That is, the AliFMDRing
  25 // objects are share amoung the AliFMDSubDetector objects.
  26 //
  27 // Latest changes by Christian Holm Christensen
  28 //
  29
  30 #include <math.h>               // fmod
  31 #include <AliLog.h>             // ALILOG_H
  32 #include "AliFMDRing.h"         // ALIFMDRING_H
  33 #include <TMath.h>              // ROOT_TMath
  34 #include <TH2.h>                // ROOT_TH2
  35 #include <TVirtualMC.h>         // ROOT_TVirtualMC
  36 #include <TVector2.h>           // ROOT_TVector2
  37 #include <TBrowser.h>           // ROOT_TBrowser
  38 #include <TString.h>            // ROOT_TString
  39 #include <TArc.h>               // ROOT_TArc
  40 #include <TObjArray.h>          // ROOT_TObjArray
  41 #include <TXTRU.h>              // ROOT_TXTRU
  42 #include <TNode.h>              // ROOT_TNode
  43 #include <TRotMatrix.h>         // ROOT_TRotMatrix
  44 #include <TList.h>              // ROOT_TList
  45
  46 const Char_t* AliFMDRing::fgkRingFormat         = "FRG%c";
  47 const Char_t* AliFMDRing::fgkVirtualFormat      = "FV%c%c";
  48 const Char_t* AliFMDRing::fgkActiveFormat       = "FAC%c";
  49 const Char_t* AliFMDRing::fgkSectorFormat       = "FSE%c";
  50 const Char_t* AliFMDRing::fgkStripFormat        = "FST%c";
  51 const Char_t* AliFMDRing::fgkPrintboardFormat   = "FP%c%c";
  52
  53
  54 //____________________________________________________________________
  55 ClassImp(AliFMDRing);
  56
  57 //____________________________________________________________________
  58 AliFMDRing::AliFMDRing(Char_t id, Bool_t detailed)
  59   : fId(id),
  60     fDetailed(detailed),
  61     fActiveId(0),
  62     fPrintboardBottomId(0),
  63     fPrintboardTopId(0),
  64     fRingId(0),
  65     fSectionId(0),
  66     fStripId(0),
  67     fVirtualBackId(0),
  68     fVirtualFrontId(0),
  69     fBondingWidth(0),
  70     fWaferRadius(0),
  71     fSiThickness(0),
  72     fLowR(0),
  73     fHighR(0),
  74     fTheta(0),
  75     fNStrips(0),
  76     fRingDepth(0),
  77     fLegRadius(0),
  78     fLegLength(0),
  79     fLegOffset(0),
  80     fModuleSpacing(0),
  81     fPrintboardThickness(0),
  82     fShape(0),
  83     fRotMatricies(0)
  84 {
  85   // Construct a alifmdring.
  86   //
  87   //     id             Id of the ring (either 'i' or 'o').
  88   //     detailed       Whether the strips are made or not.
  89   //
  90 }
  91
  92 //____________________________________________________________________
  93 AliFMDRing::AliFMDRing(const AliFMDRing& other)
  94   : TObject(other),
  95     fId(other.fId),
  96     fDetailed(other.fDetailed),
  97     fActiveId(other.fActiveId),
  98     fPrintboardBottomId(other.fPrintboardBottomId),
  99     fPrintboardTopId(other.fPrintboardTopId),
 100     fRingId(other.fRingId),
 101     fSectionId(other.fSectionId),
 102     fStripId(other.fStripId),
 103     fVirtualBackId(other.fVirtualBackId),
 104     fVirtualFrontId(other.fVirtualFrontId),
 105     fBondingWidth(other.fBondingWidth),
 106     fWaferRadius(other.fWaferRadius),
 107     fSiThickness(other.fSiThickness),
 108     fLowR(other.fLowR),
 109     fHighR(other.fHighR),
 110     fTheta(other.fTheta),
 111     fNStrips(other.fNStrips),
 112     fRingDepth(other.fRingDepth),
 113     fLegRadius(other.fLegRadius),
 114     fLegLength(other.fLegLength),
 115     fLegOffset(other.fLegOffset),
 116     fModuleSpacing(other.fModuleSpacing),
 117     fPrintboardThickness(other.fPrintboardThickness),
 118     fRotations(other.fRotations),
 119     fShape(other.fShape),
 120     fRotMatricies(other.fRotMatricies)
 121 {
 122   // Copy constructor of a AliFMDRing.
 123 }
 124
 125 //____________________________________________________________________
 126 AliFMDRing&
 127 AliFMDRing::operator=(const AliFMDRing& other)
 128 {
 129   // Assignment operator
 130   //
 131   fId                   = other.fId;
 132   fDetailed             = other.fDetailed;
 133   fActiveId             = other.fActiveId;
 134   fPrintboardBottomId   = other.fPrintboardBottomId;
 135   fPrintboardTopId      = other.fPrintboardTopId;
 136   fRingId               = other.fRingId;
 137   fSectionId            = other.fSectionId;
 138   fStripId              = other.fStripId;
 139   fVirtualBackId        = other.fVirtualBackId;
 140   fVirtualFrontId       = other.fVirtualFrontId;
 141   fBondingWidth         = other.fBondingWidth;
 142   fWaferRadius          = other.fWaferRadius;
 143   fSiThickness          = other.fSiThickness;
 144   fLowR                 = other.fLowR;
 145   fHighR                = other.fHighR;
 146   fTheta                = other.fTheta;
 147   fNStrips              = other.fNStrips;
 148   fRingDepth            = other.fRingDepth;
 149   fLegRadius            = other.fLegRadius;
 150   fLegLength            = other.fLegLength;
 151   fLegOffset            = other.fLegOffset;
 152   fModuleSpacing        = other.fModuleSpacing;
 153   fPrintboardThickness  = other.fPrintboardThickness;
 154   fRotations            = other.fRotations;
 155   if (other.fShape)  {
 156     if (other.fShape->IsA() == TXTRU::Class())
 157       ((TXTRU*)other.fShape)->Copy(*fShape);
 158     else
 159       fShape = 0;
 160   }
 161   if (other.fRotMatricies) {
 162     Int_t n = other.fRotMatricies->GetEntries();
 163     if (!fRotMatricies) fRotMatricies = new TObjArray(n);
 164     else                fRotMatricies->Expand(n);
 165     TIter next(other.fRotMatricies);
 166     TObject* o = 0;
 167     while ((o = next())) fRotMatricies->Add(o);
 168   }
 169   return *this;
 170 }
 171
 172
 173
 174 //____________________________________________________________________
 175 void
 176 AliFMDRing::Init()
 177 {
 178   // Initialize the ring object.
 179   // DebugGuard guard("AliFMDRing::Init");
 180   AliDebug(10, "AliFMDRing::Init");
 181   fPolygon.Clear();
 182   SetupCoordinates();
 183 }
 184
 185 //____________________________________________________________________
 186 AliFMDRing::~AliFMDRing()
 187 {
 188   // Destructor - deletes shape and rotation matricies
 189   if (fShape) delete fShape;
 190   if (fRotMatricies) delete fRotMatricies;
 191 }
 192
 193
 194 //____________________________________________________________________
 195 void
 196 AliFMDRing::Browse(TBrowser* /* b */)
 197 {
 198   // DebugGuard guard("AliFMDRing::Browse");
 199   AliDebug(10, "AliFMDRing::Browse");
 200 }
 201
 202
 203 //____________________________________________________________________
 204 void
 205 AliFMDRing::SetupCoordinates()
 206 {
 207   // Calculates the parameters of the polygon shape.
 208   //
 209   // DebugGuard guard("AliFMDRing::SetupCoordinates");
 210   AliDebug(10, "AliFMDRing::SetupCoordinates");
 211   // Get out immediately if we have already done all this
 212   if (fPolygon.GetNVerticies() > 1) return;
 213
 214   double tanTheta  = TMath::Tan(fTheta * TMath::Pi() / 180.);
 215   double tanTheta2 = TMath::Power(tanTheta,2);
 216   double r2         = TMath::Power(fWaferRadius,2);
 217   double yA        = tanTheta * fLowR;
 218   double lr2        = TMath::Power(fLowR, 2);
 219   double hr2        = TMath::Power(fHighR,2);
 220   double xD        = fLowR + TMath::Sqrt(r2 - tanTheta2 * lr2);
 221   double xD2       = TMath::Power(xD,2);
 222   //double xD_2      = fLowR - TMath::Sqrt(r2 - tanTheta2 * lr2);
 223   double yB        = TMath::Sqrt(r2 - hr2 + 2 * fHighR * xD - xD2);
 224   double xC        = ((xD + TMath::Sqrt(-tanTheta2 * xD2 + r2
 225                                         + r2 * tanTheta2))
 226                        / (1 + tanTheta2));
 227   double yC        = tanTheta * xC;
 228
 229   fPolygon.AddVertex(fLowR,  -yA);
 230   fPolygon.AddVertex(xC,     -yC);
 231   fPolygon.AddVertex(fHighR, -yB);
 232   fPolygon.AddVertex(fHighR,  yB);
 233   fPolygon.AddVertex(xC,      yC);
 234   fPolygon.AddVertex(fLowR,   yA);
 235 }
 236
 237 //____________________________________________________________________
 238 bool
 239 AliFMDRing::IsWithin(size_t moduleNo, double x, double y) const
 240 {
 241   // Checks if a point (x,y) is inside the module with number moduleNo
 242   //
 243   // DebugGuard guard("AliFMDRing::IsWithin");
 244   AliDebug(10, "AliFMDRing::IsWithin");
 245   bool   ret            = false;
 246   double r2             = x * x + y * y;
 247   if (r2 < fHighR * fHighR && r2 > fLowR * fLowR) {
 248     // double point_angle    = TMath::ATan2(y, x);
 249     // int    n_modules      = 360 / Int_t(fTheta * 2);
 250     double m_angle        = (.5 + moduleNo) * 2 * fTheta;
 251     double m_radians      = TMath::Pi() * m_angle / 180.;
 252
 253     // Rotate the point.
 254     double xr = x * TMath::Cos(-m_radians) - y * TMath::Sin(-m_radians);
 255     double yr = x * TMath::Sin(-m_radians) + y * TMath::Cos(-m_radians);
 256
 257     ret = fPolygon.Contains(xr,yr);
 258   }
 259   return ret;
 260 }
 261
 262
 263
 264
 265 //____________________________________________________________________
 266 void
 267 AliFMDRing::Draw(Option_t* option) const
 268 {
 269   // Draw a the shape of the ring into a 2D histogram.  Useful for
 270   // superimposing the actual shape of the ring onto a scatter plot of
 271   // hits in the detector.
 272   //
 273   // DebugGuard guard("AliFMDRing::Draw");
 274   AliDebug(10, "AliFMDRing::Draw");
 275   // The unrotated coordinates of the polygon verticies
 276   if (fPolygon.GetNVerticies() < 1) return;
 277
 278   TVector2 v[6];
 279   for (size_t i = 0; i < fPolygon.GetNVerticies(); i++)
 280     v[i] = fPolygon.GetVertex(i);
 281
 282   Int_t    nModules  = 360 / Int_t(fTheta * 2);
 283   Double_t dTheta    = fTheta * 2;
 284
 285   TString opt(option);
 286   if (opt.Contains("B", TString::kIgnoreCase)) {
 287     opt.Remove(opt.Index("B", 1, TString::kIgnoreCase),1);
 288     TH1* null = new TH2F("null", "Null",
 289                          100, -fHighR * 1.1, fHighR * 1.1,
 290                          100, -fHighR * 1.1, fHighR * 1.1);
 291     null->SetStats(0);
 292     null->Draw(opt.Data());
 293   }
 294
 295   for (int i = 0; i < nModules; i++) {
 296     Double_t theta = (i + .5) * dTheta;
 297     AliFMDPolygon p;
 298     for (int j = 0; j < 6; j++) {
 299       TVector2 vr(v[j].Rotate(TMath::Pi() * theta / 180.));
 300       if (!p.AddVertex(vr.X(),vr.Y())) {
 301         // std::cerr << "Draw of polygon " << i << " failed" << std::endl;
 302         break;
 303       }
 304     }
 305     p.Draw(opt.Data(), Form("MOD%c_%d", fId, i));
 306   }
 307   if (opt.Contains("0", TString::kIgnoreCase)) {
 308     TArc* arcH = new TArc(0,0, fHighR);
 309     arcH->SetLineStyle(2);
 310     arcH->SetLineColor(4);
 311     arcH->Draw();
 312
 313     TArc* arcL = new TArc(0,0, fLowR);
 314     arcL->SetLineStyle(2);
 315     arcL->SetLineColor(4);
 316     arcL->Draw();
 317   }
 318 }
 319
 320 //____________________________________________________________________
 321 void
 322 AliFMDRing::SetupGeometry(Int_t vacuumId, Int_t siId, Int_t pcbId,
 323                           Int_t pbRotId, Int_t idRotId)
 324 {
 325   // Setup the geometry of the ring.  It defines the volumes
 326   // RNGI or RNGO which can later be positioned in a sub-detector
 327   // volume.
 328   //
 329   // The hieracy of the RNGx volume is
 330   //
 331   //    FRGx                        // Ring volume
 332   //      FVFx                      // Container of hybrid + legs
 333   //        FACx                    // Active volume (si sensor approx)
 334   //          FSEx                  // Section division
 335   //            FSTx                // Strip division
 336   //        FPTx                    // Print board (bottom)
 337   //        FPBx                    // Print board (top)
 338   //        FLL                     // Support leg (long version)
 339   //      FVBx                      // Container of hybrid + legs
 340   //        FACx                    // Active volume (si sensor approx)
 341   //          FSEx                  // Section division
 342   //            FSTx                // Strip division
 343   //        FPTx                    // Print board (bottom)
 344   //        FPBx                    // Print board (top)
 345   //        FSL                     // Support leg (long version)
 346   //
 347   // Parameters:
 348   //
 349   //   vacuumId        Medium of inactive virtual volumes
 350   //   siId            Medium of Silicon sensor (active)
 351   //   pcbId           Medium of print boards
 352   //   pbRotId         Print board rotation matrix
 353   //   idRotId         Identity rotation matrix
 354   //
 355   // DebugGuard guard("AliFMDRing::SetupGeometry");
 356   AliDebug(10, "AliFMDRing::SetupGeometry");
 357
 358   const TVector2& bCorner   = fPolygon.GetVertex(3); // Third  corner
 359   const TVector2& aCorner   = fPolygon.GetVertex(5); // First  corner
 360   const TVector2& cCorner   = fPolygon.GetVertex(4); // Second corner
 361   TString name;
 362   TString name2;
 363   Double_t dStrip     = (bCorner.Mod() - aCorner.Mod()) / fNStrips;
 364   Double_t stripOff   = aCorner.Mod();
 365   Double_t rmin       = fLowR;
 366   Double_t rmax       = bCorner.Mod();
 367   Double_t pars[10];
 368   fRingDepth          = (fSiThickness
 369                          + fPrintboardThickness
 370                          + fLegLength
 371                          + fModuleSpacing);
 372
 373   // Ring virtual volume
 374   pars[0]             = rmin;
 375   pars[1]             = rmax;
 376   pars[2]             = fRingDepth / 2;
 377   name                = Form(fgkRingFormat, fId);
 378   fRingId             = gMC->Gsvolu(name.Data(), "TUBE", vacuumId, pars, 3);
 379
 380   // Virtual volume for modules with long legs
 381   pars[1]             = rmax;
 382   pars[3]             = -fTheta;
 383   pars[4]             =  fTheta;
 384   name                = Form(fgkVirtualFormat, 'F', fId);
 385   fVirtualFrontId     = gMC->Gsvolu(name.Data(), "TUBS", vacuumId, pars, 5);
 386
 387   // Virtual volume for modules with long legs
 388   pars[2]             =  (fRingDepth - fModuleSpacing) / 2;
 389   name                =  Form(fgkVirtualFormat, 'B', fId);
 390   fVirtualBackId      =  gMC->Gsvolu(name.Data(), "TUBS", vacuumId, pars, 5);
 391
 392   // Virtual mother volume for silicon
 393   pars[2]             =  fSiThickness/2;
 394   name2               =  name;
 395   name                =  Form(fgkActiveFormat, fId);
 396   fActiveId           =  gMC->Gsvolu(name.Data(), "TUBS", vacuumId , pars, 5);
 397
 398   if (fDetailed) {
 399     // Virtual sector volumes
 400     name2               = name;
 401     name                = Form(fgkSectorFormat, fId);
 402     gMC->Gsdvn2(name.Data(), name2.Data(), 2, 2, -fTheta, vacuumId);
 403     fSectionId          = gMC->VolId(name.Data());
 404
 405     // Active strip volumes
 406     name2               = name;
 407     name                = Form(fgkStripFormat, fId);
 408     gMC->Gsdvt2(name.Data(), name2.Data(), dStrip, 1,stripOff, siId, fNStrips);
 409     fStripId            = gMC->VolId(name.Data());
 410   }
 411
 412   // Print-board on back of module
 413   pars[4]             = TMath::Tan(TMath::Pi() * fTheta / 180) * fBondingWidth;
 414   // Top of the print board
 415   pars[0]             = cCorner.Y() - pars[4];
 416   pars[1]             = bCorner.Y() - pars[4];
 417   pars[2]             = fPrintboardThickness / 2; // PCB half thickness
 418   pars[3]             = (bCorner.X() - cCorner.X()) / 2;
 419   name                = Form(fgkPrintboardFormat, 'T', fId);
 420   fPrintboardTopId    = gMC->Gsvolu(name.Data(), "TRD1", pcbId, pars, 4);
 421
 422   // Bottom of the print board
 423   pars[0]             = aCorner.Y() - pars[4];
 424   pars[1]             = cCorner.Y() - pars[4];
 425   pars[3]             = (cCorner.X() - aCorner.X()) / 2;
 426   name                = Form(fgkPrintboardFormat, 'B', fId);
 427   fPrintboardBottomId = gMC->Gsvolu(name.Data(), "TRD1", pcbId, pars, 4);
 428
 429   // Define rotation matricies
 430   Int_t    nModules  = 360 / Int_t(fTheta * 2);
 431   Double_t dTheta    = fTheta * 2;
 432   fRotations.Set(nModules);
 433   for (int i = 0; i < nModules; i++) {
 434     Double_t theta  = (i + .5) * dTheta;
 435     Int_t    idrot  = 0;
 436     // Rotation matrix for virtual module volumes
 437     gMC->Matrix(idrot, 90, theta, 90, fmod(90 + theta, 360), 0, 0);
 438     fRotations[i] = idrot;
 439   }
 440
 441
 442   // Int_t    nModules  = 360 / Int_t(fTheta * 2);
 443   // Double_t dTheta    = fTheta * 2;
 444   Double_t pbTopL    = (bCorner.X() - cCorner.X());
 445   Double_t pbBotL    = (cCorner.X() - aCorner.X());
 446   Double_t yoffset   = ((TMath::Tan(TMath::Pi() * fTheta / 180)
 447                          * fBondingWidth));
 448
 449   for (int i = 0; i < nModules; i++) {
 450     TString  name2    = Form(fgkRingFormat, fId);
 451
 452     Int_t     id      = i;
 453     // Double_t  theta   = (i + .5) * dTheta;
 454     Bool_t    isFront = (i % 2 == 1);
 455     Double_t  dz      = 0;
 456     Double_t  w       = fRingDepth - (isFront ? 0 : fModuleSpacing);
 457
 458     // Place virtual module volume
 459     name = Form(fgkVirtualFormat, (isFront ? 'F' : 'B'), fId);
 460     dz   = (w - fRingDepth) / 2;
 461     gMC->Gspos(name.Data(), id, name2.Data(), 0., 0., dz,fRotations[i]);
 462
 463     // We only need to place the children once, they are copied when
 464     // we place the other virtual volumes.
 465     if (i > 1) continue;
 466     name2 = name;
 467
 468     // Place active silicon wafer - this is put so that the front of
 469     // the silicon is on the edge of the virtual volume.
 470     name  = Form(fgkActiveFormat, fId);
 471     dz    = (w - fSiThickness) / 2;
 472     gMC->Gspos(name.Data(), id, name2.Data(),0.,0.,dz,idRotId);
 473
 474     // Place print board.  This is put immediately behind the silicon
 475     name = Form(fgkPrintboardFormat, 'T', fId);
 476     dz   =  w / 2 - fSiThickness - fPrintboardThickness / 2;
 477     gMC->Gspos(name.Data(), id, name2.Data(),
 478                fLowR + pbBotL + pbTopL / 2, 0, dz, pbRotId, "ONLY");
 479     name = Form(fgkPrintboardFormat, 'B', fId);
 480     gMC->Gspos(name.Data(), id, name2.Data(),
 481                fLowR + pbBotL / 2, 0, dz, pbRotId, "ONLY");
 482
 483     // Support legs
 484     // This is put immediately behind the pringboard.
 485     dz     = (w / 2 - fSiThickness - fPrintboardThickness
 486              - (fLegLength + (isFront ? fModuleSpacing : 0)) /2);
 487     name  = (isFront ? "FLL" : "FSL");
 488     gMC->Gspos(name.Data(), id*10 + 1, name2.Data(),
 489                aCorner.X() + fLegOffset + fLegRadius, 0., dz, idRotId, "");
 490     Double_t y = cCorner.Y() - yoffset - fLegOffset - fLegRadius;
 491     gMC->Gspos(name.Data(),id*10+2,name2.Data(),cCorner.X(), y,dz,idRotId,"");
 492     gMC->Gspos(name.Data(),id*10+3,name2.Data(),cCorner.X(), -y,dz,idRotId,"");
 493   }
 494 }
 495 //____________________________________________________________________
 496 void
 497 AliFMDRing::Geometry(const char* mother, Int_t baseId, Double_t z,
 498                      Int_t /* pbRotId */, Int_t idRotId)
 499 {
 500   // Positions a RNGx volume inside a mother.
 501   //
 502   // Parameters
 503   //
 504   //    mother    Mother volume to position the RNGx volume in
 505   //    baseId    Base copy number
 506   //    z         Z coordinate where the front of the active silicon
 507   //              should be in the mother volume, so we need to
 508   //              subtract half the ring width.
 509   //    idRotId   Identity rotation matrix
 510   //
 511   // DebugGuard guard("AliFMDRing::Geometry");
 512   AliDebug(10, "AliFMDRing::Geometry");
 513   TString  name;
 514   Double_t offsetZ   = (fSiThickness
 515                         + fPrintboardThickness
 516                         + fLegLength + fModuleSpacing) / 2;
 517   name = Form(fgkRingFormat, fId);
 518   gMC->Gspos(name.Data(), baseId, mother, 0., 0., z - offsetZ, idRotId, "");
 519 }
 520
 521 //____________________________________________________________________
 522 void
 523 AliFMDRing::SimpleGeometry(TList* nodes,
 524                            TNode* mother,
 525                            Int_t colour,
 526                            Double_t z,
 527                            Int_t n)
 528 {
 529   // Make a simple geometry of the ring for event display.
 530   //
 531   // The simple geometry is made from ROOT TNode and TShape objects.
 532   // Note, that we cache the TShape and TRotMatrix objects used for
 533   // this.
 534   //
 535   // Parameters
 536   //
 537   //    nodes     List of nodes to register all create nodes in
 538   //    mother    Mother node to put the ring in.
 539   //    colour    Colour of the nodes
 540   //    z         Z position of the node in the mother volume
 541   //    n         Detector number
 542   //
 543   // DebugGuard guard("AliFMDRing::SimpleGeometry");
 544   AliDebug(10, "AliFMDRing::SimpleGeometry");
 545   SetupCoordinates();
 546
 547   // If the shape hasn't been defined yet, we define it here.
 548   if (!fShape) {
 549     TString name(Form(fgkActiveFormat, fId));
 550     TString title(Form("Shape of modules in %c Rings", fId));
 551     Int_t n = fPolygon.GetNVerticies();
 552     TXTRU* shape = new TXTRU(name.Data(), title.Data(), "void", n, 2);
 553     for (Int_t i = 0; i < n; i++) {
 554       const TVector2& v = fPolygon.GetVertex(i);
 555       shape->DefineVertex(i, v.X(), v.Y());
 556     }
 557     shape->DefineSection(0, - fSiThickness / 2, 1, 0, 0);
 558     shape->DefineSection(1, + fSiThickness / 2, 1, 0, 0);
 559     fShape = shape;
 560     fShape->SetLineColor(colour);
 561   }
 562
 563   Int_t    nModules  = 360 / Int_t(fTheta * 2);
 564   Double_t dTheta    = fTheta * 2;
 565
 566   // If the roation matricies hasn't been defined yet, we do so here
 567   if (!fRotMatricies) {
 568     fRotMatricies = new TObjArray(nModules);
 569     for (int i = 0; i < nModules; i++) {
 570       Double_t theta  = (i + .5) * dTheta;
 571       TString name(Form("FMD_ring_%c_rot", fId));
 572       TString title(Form("FMD Ring %c Rotation", fId));
 573       TRotMatrix* rot =
 574         new TRotMatrix(name.Data(), title.Data(),
 575                        90, theta, 90, fmod(90 + theta, 360), 0, 0);
 576       fRotMatricies->AddAt(rot, i);
 577     }
 578   }
 579
 580   Double_t offsetZ   = (fSiThickness
 581                         + fPrintboardThickness
 582                         + fLegLength + fModuleSpacing) / 2;
 583
 584   // Make all the nodes
 585   for (int i = 0; i < nModules; i++) {
 586     Bool_t    isFront = (i % 2 == 1);
 587     mother->cd();
 588     TRotMatrix* rot = static_cast<TRotMatrix*>(fRotMatricies->At(i));
 589     TString name(Form("FAC%c_%d_%d", fId, n, i));
 590     TString title(Form("Active FMD%d volume in %c Ring", n, fId));
 591     TNode* node = new TNode(name.Data(), title.Data(), fShape,
 592                             0, 0,
 593                             z - offsetZ + (isFront ? fModuleSpacing : 0),
 594                             rot);
 595     node->SetLineColor(colour);
 596     nodes->Add(node);
 597   }
 598 }
 599
 600
 601
 602 //____________________________________________________________________
 603 void
 604 AliFMDRing::Gsatt()
 605 {
 606   // Set drawing attributes for the RING
 607   //
 608   // DebugGuard guard("AliFMDRing::Gsatt");
 609   AliDebug(10, "AliFMDRing::Gsatt");
 610   TString name;
 611   name = Form(fgkRingFormat,fId);
 612   gMC->Gsatt(name.Data(), "SEEN", 0);
 613
 614   name = Form(fgkVirtualFormat, 'T', fId);
 615   gMC->Gsatt(name.Data(), "SEEN", 0);
 616
 617   name = Form(fgkVirtualFormat, 'B', fId);
 618   gMC->Gsatt(name.Data(), "SEEN", 0);
 619
 620   name = Form(fgkActiveFormat,fId);
 621   gMC->Gsatt(name.Data(), "SEEN", 1);
 622
 623   name = Form(fgkPrintboardFormat, 'T', fId);
 624   gMC->Gsatt(name.Data(), "SEEN", 1);
 625
 626   name = Form(fgkPrintboardFormat, 'B',fId);
 627   gMC->Gsatt(name.Data(), "SEEN", 1);
 628 }
 629
 630 //
 631 // EOF
 632 //