FMD/FMDbase/AliFMDGeometry.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, 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 /* $Id$ */
  16 /**
  17  * @file    AliFMDGeometry.cxx
  18  * @author  Christian Holm Christensen <cholm@nbi.dk>
  19  * @date    Mon Mar 27 12:40:37 2006
  20  * @brief   Geometry mananger for the FMD
  21  */
  22 //____________________________________________________________________
  23 //
  24 // Forward Multiplicity Detector based on Silicon wafers.
  25 //
  26 // This class is a singleton that handles the geometry parameters of
  27 // the FMD detectors.
  28 //
  29 // The actual code is done by various separate classes.   Below is
  30 // diagram showing the relationship between the various FMD classes
  31 // that handles the geometry
  32 //
  33 //                               +------------+
  34 //                            +- | AliFMDRing |
  35 //                         2  |  +------------+
  36 //      +----------------+<>--+        |
  37 //      | AliFMDGeometry |             ^
  38 //      +----------------+<>--+        V 1..2
  39 //                         3  | +----------------+
  40 //                            +-| AliFMDDetector |
  41 //                              +----------------+
  42 //                                     ^
  43 //                                     |
  44 //                       +-------------+-------------+
  45 //                       |             |             |
  46 //                  +---------+   +---------+   +---------+
  47 //                  | AliFMD1 |   | AliFMD2 |   | AliFMD3 |
  48 //                  +---------+   +---------+   +---------+
  49 //
  50 //
  51 // *  AliFMDRing
  52 //    This class contains all stuff needed to do with a ring.  It's
  53 //    used by the AliFMDDetector objects to instantise inner and
  54 //    outer rings.  The AliFMDRing objects are shared by the
  55 //    AliFMDDetector objects, and owned by the AliFMDv1 object.
  56 //
  57 // *  AliFMD1, AliFMD2, and AliFMD3
  58 //    These are specialisation of AliFMDDetector, that contains the
  59 //    particularities of each of the sub-detector system.  It is
  60 //    envisioned that the classes should also define the support
  61 //    volumes and material for each of the detectors.
  62 //
  63 //
  64 #include "AliFMDGeometry.h"     // ALIFMDGEOMETRY_H
  65 #include "AliFMDRing.h"         // ALIFMDRING_H
  66 #include "AliFMD1.h"            // ALIFMD1_H
  67 #include "AliFMD2.h"            // ALIFMD2_H
  68 #include "AliFMD3.h"            // ALIFMD2_H
  69 #include "AliRecPoint.h"        // ALIRECPOINT_H
  70 #include "AliFMDDebug.h"                   // ALILOG_H
  71 #include <TVector3.h>           // ROOT_TVector3
  72 // #include <TMatrix.h>            // ROOT_TMatrix
  73 // #include <TParticle.h>          // ROOT_TParticle
  74 #include <Riostream.h>
  75 #include "AliFMDGeometryBuilder.h"
  76 // #include <TArrayI.h>
  77 #include <TGeoManager.h>
  78 #include <TGeoVolume.h>
  79 #include <TGeoNode.h>
  80 #include <TMath.h>
  81 static Int_t FindNodeDepth(const char* name, const char* volname);
  82
  83
  84 //====================================================================
  85 ClassImp(AliFMDGeometry)
  86 #if 0
  87   ; // This is here to keep Emacs for indenting the next line
  88 #endif
  89
  90 //____________________________________________________________________
  91 AliFMDGeometry* AliFMDGeometry::fgInstance = 0;
  92
  93 //____________________________________________________________________
  94 AliFMDGeometry*
  95 AliFMDGeometry::Instance()
  96 {
  97   //
  98   // singleton access
  99   //
 100   // Return:
 101   //    Singleton
 102   //
 103   if (!fgInstance) fgInstance = new AliFMDGeometry("FMD");
 104   return fgInstance;
 105 }
 106
 107 //____________________________________________________________________
 108 AliFMDGeometry::AliFMDGeometry()
 109   : AliGeometry(),
 110     fIsInitialized(kFALSE),
 111     fInner(0),
 112     fOuter(0),
 113     fFMD1(0),
 114     fFMD2(0),
 115     fFMD3(0),
 116     fUseFMD1(kTRUE),
 117     fUseFMD2(kTRUE),
 118     fUseFMD3(kTRUE),
 119     fIsInitTrans(kFALSE),
 120     fBuilder(0),
 121     fDetectorOff(0),
 122     fModuleOff(0),
 123     fRingOff(0),
 124     fSectorOff(0),
 125     fActive(2),
 126     fDetailed(kTRUE),
 127     fUseAssembly(kTRUE)
 128 {
 129   // PROTECTED
 130   //
 131   // CTOR
 132   //
 133 }
 134
 135 //____________________________________________________________________
 136 AliFMDGeometry::AliFMDGeometry(const char* )
 137   : AliGeometry("FMD", "Forward multiplicity"),
 138     fIsInitialized(kFALSE),
 139     fInner(0),
 140     fOuter(0),
 141     fFMD1(0),
 142     fFMD2(0),
 143     fFMD3(0),
 144     fUseFMD1(kTRUE),
 145     fUseFMD2(kTRUE),
 146     fUseFMD3(kTRUE),
 147     fIsInitTrans(kFALSE),
 148     fBuilder(0),
 149     fDetectorOff(0),
 150     fModuleOff(0),
 151     fRingOff(0),
 152     fSectorOff(0),
 153     fActive(2),
 154     fDetailed(kTRUE),
 155     fUseAssembly(kTRUE)
 156 {
 157   // PROTECTED
 158   //
 159   // CTOR
 160   //
 161   // Parameters:
 162   //    name Not used
 163   //
 164   fInner = new AliFMDRing('I');
 165   fOuter = new AliFMDRing('O');
 166   fFMD1  = new AliFMD1(fInner);
 167   fFMD2  = new AliFMD2(fInner, fOuter);
 168   fFMD3  = new AliFMD3(fInner, fOuter);
 169   fIsInitialized = kFALSE;
 170   fActive.Reset(-1);
 171 }
 172
 173 //____________________________________________________________________
 174 AliFMDGeometry::AliFMDGeometry(const AliFMDGeometry& other)
 175   : AliGeometry(other),
 176     fIsInitialized(other.fIsInitialized),
 177     fInner(other.fInner),
 178     fOuter(other.fOuter),
 179     fFMD1(other.fFMD1),
 180     fFMD2(other.fFMD2),
 181     fFMD3(other.fFMD3),
 182     fUseFMD1(other.fUseFMD1),
 183     fUseFMD2(other.fUseFMD2),
 184     fUseFMD3(other.fUseFMD3),
 185     fIsInitTrans(other.fIsInitTrans),
 186     fBuilder(other.fBuilder),
 187     fDetectorOff(other.fDetectorOff),
 188     fModuleOff(other.fModuleOff),
 189     fRingOff(other.fRingOff),
 190     fSectorOff(other.fSectorOff),
 191     fActive(other.fActive),
 192     fDetailed(other.fDetailed),
 193     fUseAssembly(other.fUseAssembly)
 194 {
 195   // PROTECTED
 196   //
 197   // Copy CTOR
 198   //
 199   // Parameters:
 200   //    other To copy from
 201   //
 202 }
 203
 204
 205
 206 //____________________________________________________________________
 207 AliFMDGeometry&
 208 AliFMDGeometry::operator=(const AliFMDGeometry& other)
 209 {
 210   // PROTECTED
 211   //
 212   // Assignment operator
 213   //
 214   // Parameters:
 215   //    other To assig from
 216   // Return:
 217   //    reference to this.
 218   //
 219   if (&other == this) return *this;
 220   fUseFMD1              = other.fUseFMD1;
 221   fUseFMD2              = other.fUseFMD2;
 222   fUseFMD3              = other.fUseFMD3;
 223   fFMD1                 = other.fFMD1;
 224   fFMD2                 = other.fFMD2;
 225   fFMD3                 = other.fFMD3;
 226   fInner                = other.fInner;
 227   fOuter                = other.fOuter;
 228   fIsInitialized        = other.fIsInitialized;
 229   return *this;
 230 }
 231
 232 //____________________________________________________________________
 233 void
 234 AliFMDGeometry::Init()
 235 {
 236   //
 237   // Initialize the the singleton if not done so already
 238   //
 239   if (fIsInitialized) return;
 240   fInner->Init();
 241   fOuter->Init();
 242   fFMD1->Init();
 243   fFMD2->Init();
 244   fFMD3->Init();
 245 }
 246
 247 //____________________________________________________________________
 248 void
 249 AliFMDGeometry::InitTransformations(Bool_t force)
 250 {
 251   //
 252   // Find all local <-> global transforms
 253   //
 254   if (force) fIsInitTrans = kFALSE;
 255   if (fIsInitTrans) return;
 256   if (!gGeoManager) {
 257     AliError("No TGeoManager defined");
 258     return;
 259   }
 260   AliFMDDebug(1, ("Initialising transforms for FMD geometry"));
 261   if (fFMD1) fFMD1->InitTransformations();
 262   if (fFMD2) fFMD2->InitTransformations();
 263   if (fFMD3) fFMD3->InitTransformations();
 264   fIsInitTrans = kTRUE;
 265 }
 266
 267 //____________________________________________________________________
 268 void
 269 AliFMDGeometry::Build()
 270 {
 271   //
 272   // Make the geometry.  This delegates to AliFMDGeometryBuilder
 273   //
 274   if (!fBuilder) fBuilder = new AliFMDGeometryBuilder(fDetailed);
 275   fBuilder->SetDetailed(fDetailed);
 276   fBuilder->UseAssembly(fUseAssembly);
 277   fBuilder->Exec();
 278 }
 279
 280 //____________________________________________________________________
 281 void
 282 AliFMDGeometry::SetActive(Int_t* active, Int_t n)
 283 {
 284   //
 285   // Set active volumes
 286   //
 287   // Parameters:
 288   //    active Active volume id array
 289   //    n elements of @a active
 290   //
 291   fActive.Set(n);
 292   for (Int_t i = 0; i < n; i++) {
 293     AliFMDDebug(1, ("Active vol id # %d: %d", i, active[i]));
 294     fActive[i] = active[i];
 295   }
 296 }
 297
 298 //____________________________________________________________________
 299 void
 300 AliFMDGeometry::AddActive(Int_t active)
 301 {
 302   //
 303   // Add an active volume
 304   //
 305   // Parameters:
 306   //    id Register volume @a id to be active
 307   //
 308   //
 309   Int_t n = fActive.fN;
 310   fActive.Set(n+1);
 311   fActive[n] = active;
 312 }
 313
 314 //____________________________________________________________________
 315 Bool_t
 316 AliFMDGeometry::IsActive(Int_t vol) const
 317 {
 318   //
 319   // Check if volume @a vol is marked as active
 320   //
 321   // Parameters:
 322   //    vol Volume ID
 323   // Return:
 324   //     @c true if @a vol is declared active
 325   //
 326   for (Int_t i = 0; i < fActive.fN; i++)
 327     if (fActive[i] == vol) return kTRUE;
 328   return kFALSE;
 329 }
 330
 331 //____________________________________________________________________
 332 AliFMDDetector*
 333 AliFMDGeometry::GetDetector(Int_t i) const
 334 {
 335   //
 336   // Get description of a sub-detector
 337   //
 338   // Parameters:
 339   //    i Sub-detector #
 340   // Return:
 341   //    Description of sub-detector, or 0
 342   //
 343   switch (i) {
 344   case 1: return fUseFMD1 ? static_cast<AliFMDDetector*>(fFMD1) : 0;
 345   case 2: return fUseFMD2 ? static_cast<AliFMDDetector*>(fFMD2) : 0;
 346   case 3: return fUseFMD3 ? static_cast<AliFMDDetector*>(fFMD3) : 0;
 347   }
 348   return 0;
 349 }
 350
 351 //____________________________________________________________________
 352 AliFMDRing*
 353 AliFMDGeometry::GetRing(Char_t i) const
 354 {
 355   //
 356   // Get description of a ring, i should be one of 'I' or 'O' (case
 357   // insensitive).  If an invalid parameter is passed, 0 (NULL) is
 358   // returned.
 359   //
 360   // Parameters:
 361   //    i Ring id
 362   // Return:
 363   //    Description of ring, or 0
 364   //
 365   switch (i) {
 366   case 'I':
 367   case 'i': return fInner;
 368   case 'O':
 369   case 'o': return fOuter;
 370   }
 371   return 0;
 372 }
 373
 374 //____________________________________________________________________
 375 void
 376 AliFMDGeometry::Enable(Int_t i)
 377 {
 378   //
 379   // Enable the ith detector
 380   //
 381   // Parameters:
 382   //    i IF true, enable sub-detector @a i
 383   //
 384   switch (i) {
 385   case 1: fUseFMD1 = kTRUE; break;
 386   case 2: fUseFMD2 = kTRUE; break;
 387   case 3: fUseFMD3 = kTRUE; break;
 388   }
 389 }
 390
 391 //____________________________________________________________________
 392 void
 393 AliFMDGeometry::Disable(Int_t i)
 394 {
 395   //
 396   // Disable the ith detector
 397   //
 398   // Parameters:
 399   //    i IF true, disable sub-detector @a i
 400   //
 401   switch (i) {
 402   case 1: fUseFMD1 = kFALSE; break;
 403   case 2: fUseFMD2 = kFALSE; break;
 404   case 3: fUseFMD3 = kFALSE; break;
 405   }
 406 }
 407
 408 //____________________________________________________________________
 409 void
 410 AliFMDGeometry::Detector2XYZ(UShort_t  detector,
 411                              Char_t    ring,
 412                              UShort_t  sector,
 413                              UShort_t  strip,
 414                              Double_t& x,
 415                              Double_t& y,
 416                              Double_t& z) const
 417 {
 418   //
 419   // Translate detector coordinates (detector, ring, sector, strip)
 420   // to spatial coordinates (x, y, z) in the master reference frame
 421   // of ALICE.  The member function uses the transformations
 422   // previously obtained from the TGeoManager.
 423   //
 424   // Parameters:
 425   //    detector Detector number
 426   //    ring     Ring id
 427   //    sector   Sector number
 428   //    strip    Strip number
 429   //    x        On return, X coordinate
 430   //    y        On return, Y coordinate
 431   //    z        On return, Z coordinate
 432   //
 433   AliFMDDetector* det = GetDetector(detector);
 434   if (!det) {
 435     AliWarning(Form("Unknown detector %d", detector));
 436     return;
 437   }
 438   det->Detector2XYZ(ring, sector, strip, x, y, z);
 439 }
 440
 441 //____________________________________________________________________
 442 Bool_t
 443 AliFMDGeometry::XYZ2Detector(Double_t  x,
 444                              Double_t  y,
 445                              Double_t  z,
 446                              UShort_t& detector,
 447                              Char_t&   ring,
 448                              UShort_t& sector,
 449                              UShort_t& strip) const
 450 {
 451   //
 452   // Translate spatial coordinates (x,y,z) in the master reference
 453   // frame of ALICE to the detector coordinates (detector, ring,
 454   // sector, strip).  Note, that if this method is to be used in
 455   // reconstruction or the like, then the input z-coordinate should
 456   //  be corrected for the events interactions points z-coordinate,
 457   // like
 458   // @code
 459   // geom->XYZ2Detector(x,y,z-ipz,d,r,s,t);
 460   // @endcode
 461   //
 462   // Parameters:
 463   //    x        X coordinate
 464   //    y             Y coordinate
 465   //    z             Z coordinate
 466   //    detector On return, Detector number
 467   //    ring     On return, Ring id
 468   //    sector   On return, Sector number
 469   //    strip    On return, Strip number
 470   // Return:
 471   //    @c  false of (@a x, @a y, @a z) is not within this
 472   // detector.
 473   //
 474   AliFMDDetector* det = 0;
 475   detector = 0;
 476   for (int i = 1; i <= 3; i++) {
 477     det = GetDetector(i);
 478     if (!det) continue;
 479     if (det->XYZ2Detector(x, y, z, ring, sector, strip)) {
 480       detector = det->GetId();
 481       return kTRUE;
 482     }
 483   }
 484   return kFALSE;
 485 }
 486
 487 //____________________________________________________________________
 488 Bool_t
 489 AliFMDGeometry::XYZ2REtaPhiTheta(Double_t  x,   Double_t y,
 490                                  Double_t  z,
 491                                  Double_t& r,   Double_t& eta,
 492                                  Double_t& phi, Double_t& theta)
 493 {
 494
 495   //
 496   // Service function to convert Cartisean XYZ to r, eta, phi, and theta.
 497   //
 498   // Note, that the z input should be corrected for the vertex location
 499   // if needed.
 500   //
 501   // Parameters:
 502   //    x      Cartisean X coordinate
 503   //    y      Cartisean Y coordinate
 504   //    z      Cartisean Z coordinate
 505   //    r      On return, the radius
 506   //    eta    On return, the pseudo-rapidity
 507   //    phi    On return, the azimuthal angle
 508   //    theta  On return, the polar angle;
 509   //
 510   // Return:
 511   //    kTRUE on success, kFALSE in case of problems
 512   //
 513   if (x == 0 && y == 0 && z == 0) return kFALSE;
 514
 515   // Correct for vertex offset.
 516   phi   =  TMath::ATan2(y, x);
 517   r     =  TMath::Sqrt(y * y + x * x);
 518   theta =  TMath::ATan2(r, z);
 519   eta   = -TMath::Log(TMath::Tan(theta / 2));
 520
 521   return kTRUE;
 522 }
 523
 524
 525 //____________________________________________________________________
 526 void
 527 AliFMDGeometry::GetGlobal(const AliRecPoint* p,
 528                           TVector3& pos,
 529                           TMatrixF& /* mat */) const
 530 {
 531   //
 532   // Get global coordinates cooresponding to a rec point.
 533   //
 534   // Parameters:
 535   //    p   Reconstructed point.
 536   //    pos On return, the position
 537   //    mat On return, the material at @a post
 538   //
 539   GetGlobal(p, pos);
 540 }
 541
 542 //____________________________________________________________________
 543 void
 544 AliFMDGeometry::GetGlobal(const AliRecPoint* p, TVector3& pos) const
 545 {
 546   //
 547   // Get global coordinates cooresponding to a rec point.
 548   //
 549   // Parameters:
 550   //    p   Reconstructed point.
 551   //    pos On return, the position
 552   //
 553   // FIXME: Implement this function to work with outer rings too.
 554   Double_t x, y, z;
 555   TVector3 local;
 556   p->GetLocalPosition(local);
 557   UShort_t detector = UShort_t(local.X());
 558   UShort_t sector   = UShort_t(local.Y());
 559   UShort_t strip    = UShort_t(local.Z());
 560   Detector2XYZ(detector, 'I', sector, strip, x, y, z);
 561   pos.SetXYZ(x, y, z);
 562 }
 563
 564 //____________________________________________________________________
 565 Bool_t
 566 AliFMDGeometry::Impact(const TParticle* /* particle */) const
 567 {
 568   //
 569   // Check if particle will hit an active detector element.
 570   //
 571   // @todo implement this function
 572   //
 573   // Parameters:
 574   //    particle Track
 575   // Return:
 576   //    @c true if @a particle will hit this detector
 577   //
 578   return kFALSE;
 579 }
 580
 581 //____________________________________________________________________
 582 void
 583 AliFMDGeometry::SetAlignableVolumes() const
 584 {
 585   //
 586   // Declare alignable volumes
 587   //
 588   for (Int_t d = 1; d <= 3; d++)
 589     if (GetDetector(d)) GetDetector(d)->SetAlignableVolumes();
 590 }
 591
 592
 593 //____________________________________________________________________
 594 void
 595 AliFMDGeometry::ExtractGeomInfo()
 596 {
 597   // Check the volume depth of some nodes, get the active volume
 598   // numbers, and so forth.
 599   //
 600   // TODO: Here, we should actually also get the parameters of the
 601   // shapes, like the verticies of the polygon shape that makes up the
 602   // silicon sensor, the strip pitch, the ring radii, the z-positions,
 603   // and so on - that is, all the geometric information we need for
 604   // futher processing, such as simulation, digitization,
 605   // reconstruction, etc.
 606   Int_t detectorDepth = FindNodeDepth("F1MT_1", "ALIC");
 607   Int_t ringDepth     = FindNodeDepth(Form("FITV_%d", int('I')), "ALIC");
 608   Int_t moduleDepth   = FindNodeDepth("FIBH_0", "ALIC");
 609   Int_t sectorDepth   = FindNodeDepth("FISC_1", "ALIC");
 610   fActive.Set(0);
 611   fActive.Reset(-1);
 612   AliFMDDebug(1, ("Geometry depths:\n"
 613                    "   Sector:     %d\n"
 614                    "   Module:     %d\n"
 615                    "   Ring:       %d\n"
 616                    "   Detector:   %d",
 617                    sectorDepth, moduleDepth, ringDepth, detectorDepth));
 618   if (sectorDepth < 0 && moduleDepth < 0) {
 619     fDetailed    = kFALSE;
 620     fSectorOff   = -1;
 621     fModuleOff   = -1;
 622     fRingOff     = 0;
 623     fDetectorOff = (ringDepth - detectorDepth);
 624     TGeoVolume* actiVol = gGeoManager->GetVolume("FIAC");
 625     TGeoVolume* actoVol = gGeoManager->GetVolume("FOAC");
 626     if (actiVol) AddActive(actiVol->GetNumber());
 627     if (actiVol) AddActive(actoVol->GetNumber());
 628   }
 629   else if (sectorDepth < 0) {
 630     fDetailed    = kFALSE;
 631     fSectorOff   = -1;
 632     fModuleOff   = 1;
 633     fRingOff     = (moduleDepth - ringDepth) + 1;
 634     fDetectorOff = (moduleDepth - detectorDepth) + 1;
 635     TGeoVolume* modiVol = gGeoManager->GetVolume("FIMO");
 636     TGeoVolume* modoVol = gGeoManager->GetVolume("FOMO");
 637     if (modiVol) AddActive(modiVol->GetNumber());
 638     if (modoVol) AddActive(modoVol->GetNumber());
 639   }
 640   else {
 641     Int_t stripDepth    = FindNodeDepth("FIST_1", "ALIC");
 642     fDetailed    = kTRUE;
 643     fSectorOff   = (stripDepth - sectorDepth);
 644     fModuleOff   = (moduleDepth >= 0 ? (stripDepth - moduleDepth) : -1);
 645     fRingOff     = (stripDepth - ringDepth);
 646     fDetectorOff = (stripDepth - detectorDepth );
 647     TGeoVolume* striVol = gGeoManager->GetVolume("FIST");
 648     TGeoVolume* stroVol = gGeoManager->GetVolume("FOST");
 649     if (striVol) AddActive(striVol->GetNumber());
 650     if (stroVol) AddActive(stroVol->GetNumber());
 651   }
 652   AliFMDDebug(1, ("Geometry offsets:\n"
 653                    "   Sector:     %d\n"
 654                    "   Module:     %d\n"
 655                    "   Ring:       %d\n"
 656                    "   Detector:   %d",
 657                    fSectorOff, fModuleOff, fRingOff, fDetectorOff));
 658 }
 659
 660 #if 0
 661 //____________________________________________________________________
 662 static Int_t
 663 CheckNodes(TGeoNode* node, const char* name, Int_t& lvl)
 664 {
 665   // If there's no node here.
 666   if (!node) return -1;
 667   // Check if it this one
 668   TString sname(name);
 669   if (sname == node->GetName()) return lvl;
 670
 671   // Check if the node is an immediate daugther
 672   TObjArray* nodes = node->GetNodes();
 673   if (!nodes) return -1;
 674   // Increase the level, and search immediate sub nodes.
 675   lvl++;
 676   TGeoNode*  found = static_cast<TGeoNode*>(nodes->FindObject(name));
 677   if (found) return lvl;
 678
 679   // Check the sub node, if any of their sub-nodes match.
 680   for (Int_t i = 0; i < nodes->GetEntries(); i++) {
 681     TGeoNode* sub = static_cast<TGeoNode*>(nodes->At(i));
 682     if (!sub) continue;
 683     // Recurive check
 684     if (CheckNodes(sub, name, lvl) >= 0) return lvl;
 685   }
 686   // If not found, decrease the level
 687   lvl--;
 688   return -1;
 689 }
 690 #endif
 691
 692 //____________________________________________________________________
 693 Int_t
 694 FindNodeDepth(const char* name, const char* volname)
 695 {
 696   // Find the depth of a node
 697   TGeoVolume* vol  = gGeoManager->GetVolume(volname);
 698   if (!vol) {
 699     std::cerr << "No top volume defined" << std::endl;
 700     return -1;
 701   }
 702
 703   TGeoIterator next(vol);
 704   TGeoNode*    node = 0;
 705   TString      sName(name);
 706   while ((node = next())) {
 707     if (sName == node->GetName()) {
 708       //std::cout << "Found node " << node->GetName() << " at level "
 709       //                << next.GetLevel() << std::endl;
 710       return next.GetLevel();
 711     }
 712   }
 713   return -1;
 714 #if 0
 715   TObjArray* nodes = vol->GetNodes();
 716   if (!nodes) {
 717     std::cerr << "No nodes in top volume" << std::endl;
 718     return -1;
 719   }
 720   TIter next(nodes);
 721   TGeoNode* node = 0;
 722   Int_t lvl = 0;
 723   while ((node = static_cast<TGeoNode*>(next())))
 724     if (CheckNodes(node, name, lvl) >= 0) return lvl;
 725   return -1;
 726 #endif
 727 }
 728
 729 //____________________________________________________________________
 730 //
 731 // EOF
 732 //