// @(#)root/geom:$Name: $:$Id: TGeoManager.cxx,v 1.120 2005/06/16 13:25:22 brun Exp $
// Author: Andrei Gheata 25/10/01
/*************************************************************************
* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
* All rights reserved. *
* *
* For the licensing terms see $ROOTSYS/LICENSE. *
* For the list of contributors see $ROOTSYS/README/CREDITS. *
*************************************************************************/
////////////////////////////////////////////////////////////////////////////////
// General architecture
// --------------------
//
// The new ROOT geometry package is a tool designed for building, browsing,
// tracking and visualizing a detector geometry. The code is independent from
// other external MC for simulation, therefore it does not contain any
// constraints related to physics. However, the package defines a number of
// hooks for tracking, such as media, materials, magnetic field or track state flags,
// in order to allow interfacing to tracking MC's. The final goal is to be
// able to use the same geometry for several purposes, such as tracking,
// reconstruction or visualization, taking advantage of the ROOT features
// related to bookkeeping, I/O, histograming, browsing and GUI's.
//
// The geometrical modeler is the most important component of the package and
// it provides answers to the basic questions like "Where am I ?" or "How far
// from the next boundary ?", but also to more complex ones like "How far from
// the closest surface ?" or "Which is the next crossing along a helix ?".
//
// The architecture of the modeler is a combination between a GEANT-like
// containment scheme and a normal CSG binary tree at the level of shapes. An
// important common feature of all detector geometry descriptions is the
// mother-daughter concept. This is the most natural approach when tracking
// is concerned and imposes a set of constraints to the way geometry is defined.
// Constructive solid geometry composition is used only in order to create more
// complex shapes from an existing set of primitives through boolean operations.
// This feature is not implemented yet but in future full definition of boolean
// expressions will be supported.
//
// Practically every geometry defined in GEANT style can be mapped by the modeler.
// The basic components used for building the logical hierarchy of the geometry
// are called "volumes" and "nodes". Volumes (sometimes called "solids") are fully
// defined geometrical objects having a given shape and medium and possibly
// containing a list of nodes. Nodes represent just positioned instances of volumes
// inside a container volume and they are not directly defined by user. They are
// automatically created as a result of adding one volume inside other or dividing
// a volume. The geometrical transformation hold by nodes is always defined with
// respect to their mother (relative positioning). Reflection matrices are allowed.
// All volumes have to be fully aware of their containees when the geometry is
// closed. They will build aditional structures (voxels) in order to fasten-up
// the search algorithms. Finally, nodes can be regarded as bidirectional links
// between containers and containees objects.
//
// The structure defined in this way is a graph structure since volumes are
// replicable (same volume can become daughter node of several other volumes),
// every volume becoming a branch in this graph. Any volume in the logical graph
// can become the actual top volume at run time (see TGeoManager::SetTopVolume()).
// All functionalities of the modeler will behave in this case as if only the
// corresponding branch starting from this volume is the registered geometry.
//
//
/*
*/
//
//
// A given volume can be positioned several times in the geometry. A volume
// can be divided according default or user-defined patterns, creating automatically
// the list of division nodes inside. The elementary volumes created during the
// dividing process follow the same scheme as usual volumes, therefore it is possible
// to position further geometrical structures inside or to divide them further more
// (see TGeoVolume::Divide()).
//
// The primitive shapes supported by the package are basically the GEANT3
// shapes (see class TGeoShape), arbitrary wedges with eight vertices on two parallel
// planes. All basic primitives inherits from class TGeoBBox since the bounding box
// of a solid is essential for the tracking algorithms. They also implement the
// virtual methods defined in the virtual class TGeoShape (point and segment
// classification). User-defined primitives can be direcly plugged into the modeler
// provided that they override these methods. Composite shapes will be soon supported
// by the modeler. In order to build a TGeoCompositeShape, one will have to define
// first the primitive components. The object that handle boolean
// operations among components is called TGeoBoolCombinator and it has to be
// constructed providing a string boolean expression between the components names.
//
//
// Example for building a simple geometry :
//-----------------------------------------
//
//______________________________________________________________________________
//void rootgeom()
//{
////--- Definition of a simple geometry
// gSystem->Load("libGeom");
// TGeoManager *geom = new TGeoManager("simple1", "Simple geometry");
//
// //--- define some materials
// TGeoMaterial *matVacuum = new TGeoMaterial("Vacuum", 0,0,0);
// TGeoMaterial *matAl = new TGeoMaterial("Al", 26.98,13,2.7);
// //--- define some media
// TGeoMedium *med;
// TGeoMedium *Vacuum = new TGeoMedium(1, matVacuum);
// TGeoMedium *Al = new TGeoMedium(2, matAl);
//
// //--- define the transformations
// TGeoTranslation *tr1 = new TGeoTranslation(20., 0, 0.);
// TGeoTranslation *tr2 = new TGeoTranslation(10., 0., 0.);
// TGeoTranslation *tr3 = new TGeoTranslation(10., 20., 0.);
// TGeoTranslation *tr4 = new TGeoTranslation(5., 10., 0.);
// TGeoTranslation *tr5 = new TGeoTranslation(20., 0., 0.);
// TGeoTranslation *tr6 = new TGeoTranslation(-5., 0., 0.);
// TGeoTranslation *tr7 = new TGeoTranslation(7.5, 7.5, 0.);
// TGeoRotation *rot1 = new TGeoRotation("rot1", 90., 0., 90., 270., 0., 0.);
// TGeoCombiTrans *combi1 = new TGeoCombiTrans(7.5, -7.5, 0., rot1);
// TGeoTranslation *tr8 = new TGeoTranslation(7.5, -5., 0.);
// TGeoTranslation *tr9 = new TGeoTranslation(7.5, 20., 0.);
// TGeoTranslation *tr10 = new TGeoTranslation(85., 0., 0.);
// TGeoTranslation *tr11 = new TGeoTranslation(35., 0., 0.);
// TGeoTranslation *tr12 = new TGeoTranslation(-15., 0., 0.);
// TGeoTranslation *tr13 = new TGeoTranslation(-65., 0., 0.);
//
// TGeoTranslation *tr14 = new TGeoTranslation(0,0,-100);
// TGeoCombiTrans *combi2 = new TGeoCombiTrans(0,0,100,
// new TGeoRotation("rot2",90,180,90,90,180,0));
// TGeoCombiTrans *combi3 = new TGeoCombiTrans(100,0,0,
// new TGeoRotation("rot3",90,270,0,0,90,180));
// TGeoCombiTrans *combi4 = new TGeoCombiTrans(-100,0,0,
// new TGeoRotation("rot4",90,90,0,0,90,0));
// TGeoCombiTrans *combi5 = new TGeoCombiTrans(0,100,0,
// new TGeoRotation("rot5",0,0,90,180,90,270));
// TGeoCombiTrans *combi6 = new TGeoCombiTrans(0,-100,0,
// new TGeoRotation("rot6",180,0,90,180,90,90));
//
// //--- make the top container volume
// Double_t worldx = 110.;
// Double_t worldy = 50.;
// Double_t worldz = 5.;
// TGeoVolume *top = geom->MakeBox("TOP", Vacuum, 270., 270., 120.);
// geom->SetTopVolume(top); // mandatory !
// //--- build other container volumes
// TGeoVolume *replica = geom->MakeBox("REPLICA", Vacuum,120,120,120);
// replica->SetVisibility(kFALSE);
// TGeoVolume *rootbox = geom->MakeBox("ROOT", Vacuum, 110., 50., 5.);
// rootbox->SetVisibility(kFALSE); // this will hold word 'ROOT'
//
// //--- make letter 'R'