Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TGeoManager.cxx
Go to the documentation of this file.
1// @(#)root/geom:$Id$
2// Author: Andrei Gheata 25/10/01
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12/** \class TGeoManager
13\ingroup Geometry_classes
14
15The manager class for any TGeo geometry. Provides user
16interface for geometry creation, navigation, state querying,
17visualization, IO, geometry checking and other utilities.
18
19## General architecture
20
21 The ROOT geometry package is a tool designed for building, browsing,
22tracking and visualizing a detector geometry. The code is independent from
23other external MC for simulation, therefore it does not contain any
24constraints related to physics. However, the package defines a number of
25hooks for tracking, such as media, materials, magnetic field or track state flags,
26in order to allow interfacing to tracking MC's. The final goal is to be
27able to use the same geometry for several purposes, such as tracking,
28reconstruction or visualization, taking advantage of the ROOT features
29related to bookkeeping, I/O, histogramming, browsing and GUI's.
30
31 The geometrical modeler is the most important component of the package and
32it provides answers to the basic questions like "Where am I ?" or "How far
33from the next boundary ?", but also to more complex ones like "How far from
34the closest surface ?" or "Which is the next crossing along a helix ?".
35
36 The architecture of the modeler is a combination between a GEANT-like
37containment scheme and a normal CSG binary tree at the level of shapes. An
38important common feature of all detector geometry descriptions is the
39mother-daughter concept. This is the most natural approach when tracking
40is concerned and imposes a set of constraints to the way geometry is defined.
41Constructive solid geometry composition is used only in order to create more
42complex shapes from an existing set of primitives through boolean operations.
43This feature is not implemented yet but in future full definition of boolean
44expressions will be supported.
45
46 Practically every geometry defined in GEANT style can be mapped by the modeler.
47The basic components used for building the logical hierarchy of the geometry
48are called "volumes" and "nodes". Volumes (sometimes called "solids") are fully
49defined geometrical objects having a given shape and medium and possibly
50containing a list of nodes. Nodes represent just positioned instances of volumes
51inside a container volume and they are not directly defined by user. They are
52automatically created as a result of adding one volume inside other or dividing
53a volume. The geometrical transformation hold by nodes is always defined with
54respect to their mother (relative positioning). Reflection matrices are allowed.
55All volumes have to be fully aware of their containees when the geometry is
56closed. They will build additional structures (voxels) in order to fasten-up
57the search algorithms. Finally, nodes can be regarded as bidirectional links
58between containers and containees objects.
59
60 The structure defined in this way is a graph structure since volumes are
61replicable (same volume can become daughter node of several other volumes),
62every volume becoming a branch in this graph. Any volume in the logical graph
63can become the actual top volume at run time (see TGeoManager::SetTopVolume()).
64All functionalities of the modeler will behave in this case as if only the
65corresponding branch starting from this volume is the registered geometry.
66
67\image html geom_graf.jpg
68
69 A given volume can be positioned several times in the geometry. A volume
70can be divided according default or user-defined patterns, creating automatically
71the list of division nodes inside. The elementary volumes created during the
72dividing process follow the same scheme as usual volumes, therefore it is possible
73to position further geometrical structures inside or to divide them further more
74(see TGeoVolume::Divide()).
75
76 The primitive shapes supported by the package are basically the GEANT3
77shapes (see class TGeoShape), arbitrary wedges with eight vertices on two parallel
78planes. All basic primitives inherits from class TGeoBBox since the bounding box
79of a solid is essential for the tracking algorithms. They also implement the
80virtual methods defined in the virtual class TGeoShape (point and segment
81classification). User-defined primitives can be directly plugged into the modeler
82provided that they override these methods. Composite shapes will be soon supported
83by the modeler. In order to build a TGeoCompositeShape, one will have to define
84first the primitive components. The object that handle boolean
85operations among components is called TGeoBoolCombinator and it has to be
86constructed providing a string boolean expression between the components names.
87
88
89## Example for building a simple geometry
90
91Begin_Macro(source)
92../../../tutorials/geom/rootgeom.C
93End_Macro
94
95## TGeoManager - the manager class for the geometry package.
96
97 TGeoManager class is embedding all the API needed for building and tracking
98a geometry. It defines a global pointer (gGeoManager) in order to be fully
99accessible from external code. The mechanism of handling multiple geometries
100at the same time will be soon implemented.
101
102 TGeoManager is the owner of all geometry objects defined in a session,
103therefore users must not try to control their deletion. It contains lists of
104media, materials, transformations, shapes and volumes. Logical nodes (positioned
105volumes) are created and destroyed by the TGeoVolume class. Physical
106nodes and their global transformations are subjected to a caching mechanism
107due to the sometimes very large memory requirements of logical graph expansion.
108The caching mechanism is triggered by the total number of physical instances
109of volumes and the cache manager is a client of TGeoManager. The manager class
110also controls the painter client. This is linked with ROOT graphical libraries
111loaded on demand in order to control visualization actions.
112
113## Rules for building a valid geometry
114
115 A given geometry can be built in various ways, but there are mandatory steps
116that have to be followed in order to be validated by the modeler. There are
117general rules : volumes needs media and shapes in order to be created,
118both container and containee volumes must be created before linking them together,
119and the relative transformation matrix must be provided. All branches must
120have an upper link point otherwise they will not be considered as part of the
121geometry. Visibility or tracking properties of volumes can be provided both
122at build time or after geometry is closed, but global visualization settings
123(see TGeoPainter class) should not be provided at build time, otherwise the
124drawing package will be loaded. There is also a list of specific rules :
125positioned daughters should not extrude their mother or intersect with sisters
126unless this is specified (see TGeoVolume::AddNodeOverlap()), the top volume
127(containing all geometry tree) must be specified before closing the geometry
128and must not be positioned - it represents the global reference frame. After
129building the full geometry tree, the geometry must be closed
130(see TGeoManager::CloseGeometry()). Voxelization can be redone per volume after
131this process.
132
133
134 Below is the general scheme of the manager class.
135
136\image html geom_mgr.jpg
137
138## An interactive session
139
140 Provided that a geometry was successfully built and closed (for instance the
141previous example $ROOTSYS/tutorials/geom/rootgeom.C ), the manager class will register
142itself to ROOT and the logical/physical structures will become immediately browsable.
143The ROOT browser will display starting from the geometry folder : the list of
144transformations and media, the top volume and the top logical node. These last
145two can be fully expanded, any intermediate volume/node in the browser being subject
146of direct access context menu operations (right mouse button click). All user
147utilities of classes TGeoManager, TGeoVolume and TGeoNode can be called via the
148context menu.
149
150\image html geom_browser.jpg
151
152### Drawing the geometry
153
154 Any logical volume can be drawn via TGeoVolume::Draw() member function.
155This can be directly accessed from the context menu of the volume object
156directly from the browser.
157 There are several drawing options that can be set with
158TGeoManager::SetVisOption(Int_t opt) method :
159
160#### opt=0
161 only the content of the volume is drawn, N levels down (default N=3).
162 This is the default behavior. The number of levels to be drawn can be changed
163 via TGeoManager::SetVisLevel(Int_t level) method.
164
165\image html geom_frame0.jpg
166
167#### opt=1
168 the final leaves (e.g. daughters with no containment) of the branch
169 starting from volume are drawn down to the current number of levels.
170 WARNING : This mode is memory consuming
171 depending of the size of geometry, so drawing from top level within this mode
172 should be handled with care for expensive geometries. In future there will be
173 a limitation on the maximum number of nodes to be visualized.
174
175\image html geom_frame1.jpg
176
177#### opt=2
178 only the clicked volume is visualized. This is automatically set by
179 TGeoVolume::DrawOnly() method
180
181#### opt=3 - only a given path is visualized. This is automatically set by
182 TGeoVolume::DrawPath(const char *path) method
183
184 The current view can be exploded in cartesian, cylindrical or spherical
185coordinates :
186 TGeoManager::SetExplodedView(Int_t opt). Options may be :
187- 0 - default (no bombing)
188- 1 - cartesian coordinates. The bomb factor on each axis can be set with
189 TGeoManager::SetBombX(Double_t bomb) and corresponding Y and Z.
190- 2 - bomb in cylindrical coordinates. Only the bomb factors on Z and R
191 are considered
192 \image html geom_frameexp.jpg
193
194- 3 - bomb in radial spherical coordinate : TGeoManager::SetBombR()
195
196Volumes themselves support different visualization settings :
197 - TGeoVolume::SetVisibility() : set volume visibility.
198 - TGeoVolume::VisibleDaughters() : set daughters visibility.
199All these actions automatically updates the current view if any.
200
201### Checking the geometry
202
203 Several checking methods are accessible from the volume context menu. They
204generally apply only to the visible parts of the drawn geometry in order to
205ease geometry checking, and their implementation is in the TGeoChecker class
206from the painting package.
207
208#### Checking a given point.
209 Can be called from TGeoManager::CheckPoint(Double_t x, Double_t y, Double_t z).
210This method is drawing the daughters of the volume containing the point one
211level down, printing the path to the deepest physical node holding this point.
212It also computes the closest distance to any boundary. The point will be drawn
213in red.
214
215\image html geom_checkpoint.jpg
216
217#### Shooting random points.
218 Can be called from TGeoVolume::RandomPoints() (context menu function) and
219it will draw this volume with current visualization settings. Random points
220are generated in the bounding box of the top drawn volume. The points are
221classified and drawn with the color of their deepest container. Only points
222in visible nodes will be drawn.
223
224\image html geom_random1.jpg
225
226
227#### Raytracing.
228 Can be called from TGeoVolume::RandomRays() (context menu of volumes) and
229will shoot rays from a given point in the local reference frame with random
230directions. The intersections with displayed nodes will appear as segments
231having the color of the touched node. Drawn geometry will be then made invisible
232in order to enhance rays.
233
234\image html geom_random2.jpg
235*/
236
237#include <cstdlib>
238#include <iostream>
239#include <fstream>
240
241#include "TROOT.h"
242#include "TGeoManager.h"
243#include "TStyle.h"
244#include "TVirtualPad.h"
245#include "TBrowser.h"
246#include "TFile.h"
247#include "TKey.h"
248#include "THashList.h"
249#include "TClass.h"
250#include "ThreadLocalStorage.h"
251#include "TBufferText.h"
252
253#include "TGeoVoxelFinder.h"
254#include "TGeoElement.h"
255#include "TGeoMaterial.h"
256#include "TGeoMedium.h"
257#include "TGeoMatrix.h"
258#include "TGeoNode.h"
259#include "TGeoPhysicalNode.h"
260#include "TGeoPara.h"
261#include "TGeoParaboloid.h"
262#include "TGeoTube.h"
263#include "TGeoEltu.h"
264#include "TGeoHype.h"
265#include "TGeoCone.h"
266#include "TGeoSphere.h"
267#include "TGeoArb8.h"
268#include "TGeoPgon.h"
269#include "TGeoTrd1.h"
270#include "TGeoTrd2.h"
271#include "TGeoTorus.h"
272#include "TGeoXtru.h"
273#include "TGeoCompositeShape.h"
274#include "TGeoBoolNode.h"
275#include "TGeoBuilder.h"
276#include "TVirtualGeoPainter.h"
277#include "TPluginManager.h"
278#include "TVirtualGeoTrack.h"
279#include "TQObject.h"
280#include "TMath.h"
281#include "TEnv.h"
282#include "TGeoParallelWorld.h"
283#include "TGeoRegion.h"
284#include "TGDMLMatrix.h"
285#include "TGeoOpticalSurface.h"
286
287// statics and globals
288
290
292
293std::mutex TGeoManager::fgMutex;
305
306////////////////////////////////////////////////////////////////////////////////
307/// Default constructor.
308
310{
314 fTmin = 0.;
315 fTmax = 999.;
316 fPhiCut = kFALSE;
317 fPhimin = 0;
318 fPhimax = 360;
323 fClosed = kFALSE;
325 fBits = 0;
327 fMaterials = 0;
328 fHashPNE = 0;
329 fArrayPNE = 0;
330 fMatrices = 0;
331 fNodes = 0;
332 fOverlaps = 0;
333 fRegions = 0;
334 fNNodes = 0;
335 fMaxVisNodes = 10000;
336 fVolumes = 0;
337 fPhysicalNodes = 0;
338 fShapes = 0;
339 fGVolumes = 0;
340 fGShapes = 0;
341 fTracks = 0;
342 fMedia = 0;
343 fNtracks = 0;
344 fNpdg = 0;
345 fPdgNames = 0;
346 fGDMLMatrices = 0;
348 fSkinSurfaces = 0;
349 fBorderSurfaces = 0;
350 memset(fPdgId, 0, 1024*sizeof(Int_t));
351// TObjArray *fNavigators; //! list of navigators
352 fCurrentTrack = 0;
353 fCurrentVolume = 0;
354 fTopVolume = 0;
355 fTopNode = 0;
356 fMasterVolume = 0;
357 fPainter = 0;
360 fVisDensity = 0.;
361 fVisLevel = 3;
362 fVisOption = 1;
363 fExplodedView = 0;
364 fNsegments = 20;
365 fNLevel = 0;
366 fUniqueVolumes = 0;
367 fClippingShape = 0;
370 fGLMatrix = 0;
371 fPaintVolume = 0;
373 fElementTable = 0;
374 fHashVolumes = 0;
375 fHashGVolumes = 0;
376 fSizePNEId = 0;
377 fNPNEId = 0;
378 fKeyPNEId = 0;
379 fValuePNEId = 0;
381 fRaytraceMode = 0;
382 fMaxThreads = 0;
384 fParallelWorld = 0;
386 } else {
387 Init();
390 }
391}
392
393////////////////////////////////////////////////////////////////////////////////
394/// Constructor.
395
396TGeoManager::TGeoManager(const char *name, const char *title)
397 :TNamed(name, title)
398{
399 if (!gROOT->GetListOfGeometries()->FindObject(this)) gROOT->GetListOfGeometries()->Add(this);
400 if (!gROOT->GetListOfBrowsables()->FindObject(this)) gROOT->GetListOfBrowsables()->Add(this);
401 Init();
402 gGeoIdentity = new TGeoIdentity("Identity");
404 if (fgVerboseLevel>0) Info("TGeoManager","Geometry %s, %s created", GetName(), GetTitle());
405}
406
407////////////////////////////////////////////////////////////////////////////////
408/// Initialize manager class.
409
411{
412 if (gGeoManager) {
413 Warning("Init","Deleting previous geometry: %s/%s",gGeoManager->GetName(),gGeoManager->GetTitle());
414 delete gGeoManager;
415 if (fgLock) Fatal("Init", "New geometry created while the old one locked !!!");
416 }
417
418 gGeoManager = this;
421 fTmin = 0.;
422 fTmax = 999.;
423 fPhiCut = kFALSE;
424 fPhimin = 0;
425 fPhimax = 360;
430 fClosed = kFALSE;
432 fBits = new UChar_t[50000]; // max 25000 nodes per volume
434 fHashPNE = new THashList(256,3);
435 fArrayPNE = 0;
436 fMaterials = new THashList(200,3);
437 fMatrices = new TObjArray(256);
438 fNodes = new TObjArray(30);
439 fOverlaps = new TObjArray(256);
440 fRegions = new TObjArray(256);
441 fNNodes = 0;
442 fMaxVisNodes = 10000;
443 fVolumes = new TObjArray(256);
444 fPhysicalNodes = new TObjArray(256);
445 fShapes = new TObjArray(256);
446 fGVolumes = new TObjArray(256);
447 fGShapes = new TObjArray(256);
448 fTracks = new TObjArray(256);
449 fMedia = new THashList(200,3);
450 fNtracks = 0;
451 fNpdg = 0;
452 fPdgNames = 0;
453 fGDMLMatrices = new TObjArray();
455 fSkinSurfaces = new TObjArray();
457 memset(fPdgId, 0, 1024*sizeof(Int_t));
458 fCurrentTrack = 0;
459 fCurrentVolume = 0;
460 fTopVolume = 0;
461 fTopNode = 0;
462 fMasterVolume = 0;
463 fPainter = 0;
466 fVisDensity = 0.;
467 fVisLevel = 3;
468 fVisOption = 1;
469 fExplodedView = 0;
470 fNsegments = 20;
471 fNLevel = 0;
472 fUniqueVolumes = new TObjArray(256);
473 fClippingShape = 0;
476 fGLMatrix = new TGeoHMatrix();
477 fPaintVolume = 0;
479 fElementTable = 0;
480 fHashVolumes = 0;
481 fHashGVolumes = 0;
482 fSizePNEId = 0;
483 fNPNEId = 0;
484 fKeyPNEId = 0;
485 fValuePNEId = 0;
487 fRaytraceMode = 0;
488 fMaxThreads = 0;
490 fParallelWorld = 0;
492}
493
494////////////////////////////////////////////////////////////////////////////////
495/// Destructor
496
498{
499 if (gGeoManager != this) gGeoManager = this;
501
502 if (gROOT->GetListOfFiles()) { //in case this function is called from TROOT destructor
503 gROOT->GetListOfGeometries()->Remove(this);
504 gROOT->GetListOfBrowsables()->Remove(this);
505 }
506// TSeqCollection *brlist = gROOT->GetListOfBrowsers();
507// TIter next(brlist);
508// TBrowser *browser = 0;
509// while ((browser=(TBrowser*)next())) browser->RecursiveRemove(this);
512 delete TGeoBuilder::Instance(this);
513 if (fBits) delete [] fBits;
521 if (fHashVolumes) { fHashVolumes->Clear("nodelete"); SafeDelete(fHashVolumes); }
524 if (fArrayPNE) {delete fArrayPNE;}
537 CleanGarbage();
540 if (fSizePNEId) {
541 delete [] fKeyPNEId;
542 delete [] fValuePNEId;
543 }
544 delete fParallelWorld;
546 gGeoIdentity = 0;
547 gGeoManager = 0;
548}
549
550////////////////////////////////////////////////////////////////////////////////
551/// Add a material to the list. Returns index of the material in list.
552
554{
555 return TGeoBuilder::Instance(this)->AddMaterial((TGeoMaterial*)material);
556}
557
558////////////////////////////////////////////////////////////////////////////////
559/// Add an illegal overlap/extrusion to the list.
560
562{
564 fOverlaps->Add((TObject*)ovlp);
565 return size;
566}
567
568////////////////////////////////////////////////////////////////////////////////
569/// Add a new region of volumes.
571{
572 Int_t size = fRegions->GetEntriesFast();
573 fRegions->Add(region);
574 return size;
575}
576
577////////////////////////////////////////////////////////////////////////////////
578/// Add a user-defined property. Returns true if added, false if existing.
579
580Bool_t TGeoManager::AddProperty(const char* property, Double_t value)
581{
582 auto pos = fProperties.insert(ConstPropMap_t::value_type(property, value));
583 if (!pos.second) {
584 Warning("AddProperty", "Property \"%s\" already exists with value %g", property, (pos.first)->second);
585 return false;
586 }
587 return true;
588}
589
590////////////////////////////////////////////////////////////////////////////////
591/// Get a user-defined property
592
593Double_t TGeoManager::GetProperty(const char *property, Bool_t *error) const
594{
595 auto pos = fProperties.find(property);
596 if (pos == fProperties.end()) {
597 if (error) *error = kTRUE;
598 return 0.;
599 }
600 if (error) *error = kFALSE;
601 return pos->second;
602}
603
604////////////////////////////////////////////////////////////////////////////////
605/// Get a user-defined property from a given index
606
608{
609 // This is a quite inefficient way to access map elements, but needed for the GDML writer to
610 if (i >= fProperties.size()) {
611 if (error) *error = kTRUE;
612 return 0.;
613 }
614 size_t pos = 0;
615 auto it = fProperties.begin();
616 while (pos < i) { ++it; ++pos; }
617 if (error) *error = kFALSE;
618 name = (*it).first;
619 return (*it).second;
620}
621
622////////////////////////////////////////////////////////////////////////////////
623/// Add a matrix to the list. Returns index of the matrix in list.
624
626{
627 return TGeoBuilder::Instance(this)->AddTransformation((TGeoMatrix*)matrix);
628}
629
630////////////////////////////////////////////////////////////////////////////////
631/// Add a shape to the list. Returns index of the shape in list.
632
634{
635 return TGeoBuilder::Instance(this)->AddShape((TGeoShape*)shape);
636}
637
638////////////////////////////////////////////////////////////////////////////////
639/// Add a track to the list of tracks. Use this for primaries only. For secondaries,
640/// add them to the parent track. The method create objects that are registered
641/// to the analysis manager but have to be cleaned-up by the user via ClearTracks().
642
644{
645 Int_t index = fNtracks;
646 fTracks->AddAtAndExpand(GetGeomPainter()->AddTrack(id,pdgcode,particle),fNtracks++);
647 return index;
648}
649
650////////////////////////////////////////////////////////////////////////////////
651/// Add a track to the list of tracks
652
654{
655 Int_t index = fNtracks;
657 return index;
658}
659
660////////////////////////////////////////////////////////////////////////////////
661/// Makes a primary track but do not attach it to the list of tracks. The track
662/// can be attached as daughter to another one with TVirtualGeoTrack::AddTrack
663
665{
666 TVirtualGeoTrack *track = GetGeomPainter()->AddTrack(id,pdgcode,particle);
667 return track;
668}
669
670////////////////////////////////////////////////////////////////////////////////
671/// Add a volume to the list. Returns index of the volume in list.
672
674{
675 if (!volume) {
676 Error("AddVolume", "invalid volume");
677 return -1;
678 }
680 if (!uid) uid++;
681 if (!fCurrentVolume) {
682 fCurrentVolume = volume;
683 fUniqueVolumes->AddAtAndExpand(volume,uid);
684 } else {
685 if (!strcmp(volume->GetName(), fCurrentVolume->GetName())) {
686 uid = fCurrentVolume->GetNumber();
687 } else {
688 fCurrentVolume = volume;
689 Int_t olduid = GetUID(volume->GetName());
690 if (olduid<0) {
691 fUniqueVolumes->AddAtAndExpand(volume,uid);
692 } else {
693 uid = olduid;
694 }
695 }
696 }
697 volume->SetNumber(uid);
698 if (!fHashVolumes) {
699 fHashVolumes = new THashList(256);
700 fHashGVolumes = new THashList(256);
701 }
702 TObjArray *list = fVolumes;
703 if (!volume->GetShape() || volume->IsRunTime() || volume->IsVolumeMulti()) {
704 list = fGVolumes;
705 fHashGVolumes->Add(volume);
706 } else {
707 fHashVolumes->Add(volume);
708 }
709 Int_t index = list->GetEntriesFast();
710 list->AddAtAndExpand(volume,index);
711 return uid;
712}
713
714////////////////////////////////////////////////////////////////////////////////
715/// Add a navigator in the list of navigators. If it is the first one make it
716/// current navigator.
717
719{
720 if (fMultiThread) { TGeoManager::ThreadId(); fgMutex.lock(); }
721 std::thread::id threadId = std::this_thread::get_id();
722 NavigatorsMap_t::const_iterator it = fNavigators.find(threadId);
723 TGeoNavigatorArray *array = 0;
724 if (it != fNavigators.end()) array = it->second;
725 else {
726 array = new TGeoNavigatorArray(this);
727 fNavigators.insert(NavigatorsMap_t::value_type(threadId, array));
728 }
729 TGeoNavigator *nav = array->AddNavigator();
730 if (fClosed) nav->GetCache()->BuildInfoBranch();
731 if (fMultiThread) fgMutex.unlock();
732 return nav;
733}
734
735////////////////////////////////////////////////////////////////////////////////
736/// Returns current navigator for the calling thread.
737
739{
740 TTHREAD_TLS(TGeoNavigator*) tnav = 0;
741 if (!fMultiThread) return fCurrentNavigator;
742 TGeoNavigator *nav = tnav; // TTHREAD_TLS_GET(TGeoNavigator*,tnav);
743 if (nav) return nav;
744 std::thread::id threadId = std::this_thread::get_id();
745 NavigatorsMap_t::const_iterator it = fNavigators.find(threadId);
746 if (it == fNavigators.end()) return 0;
747 TGeoNavigatorArray *array = it->second;
748 nav = array->GetCurrentNavigator();
749 tnav = nav; // TTHREAD_TLS_SET(TGeoNavigator*,tnav,nav);
750 return nav;
751}
752
753////////////////////////////////////////////////////////////////////////////////
754/// Get list of navigators for the calling thread.
755
757{
758 std::thread::id threadId = std::this_thread::get_id();
759 NavigatorsMap_t::const_iterator it = fNavigators.find(threadId);
760 if (it == fNavigators.end()) return 0;
761 TGeoNavigatorArray *array = it->second;
762 return array;
763}
764
765////////////////////////////////////////////////////////////////////////////////
766/// Switch to another existing navigator for the calling thread.
767
769{
770 std::thread::id threadId = std::this_thread::get_id();
771 NavigatorsMap_t::const_iterator it = fNavigators.find(threadId);
772 if (it == fNavigators.end()) {
773 Error("SetCurrentNavigator", "No navigator defined for this thread\n");
774 std::cout << " thread id: " << threadId << std::endl;
775 return kFALSE;
776 }
777 TGeoNavigatorArray *array = it->second;
778 TGeoNavigator *nav = array->SetCurrentNavigator(index);
779 if (!nav) {
780 Error("SetCurrentNavigator", "Navigator %d not existing for this thread\n", index);
781 std::cout << " thread id: " << threadId << std::endl;
782 return kFALSE;
783 }
785 return kTRUE;
786}
787
788////////////////////////////////////////////////////////////////////////////////
789/// Set the lock for navigators.
790
792{
793 fgLockNavigators = flag;
794}
795
796////////////////////////////////////////////////////////////////////////////////
797/// Clear all navigators.
798
800{
801 if (fMultiThread) fgMutex.lock();
802 TGeoNavigatorArray *arr = 0;
803 for (NavigatorsMap_t::iterator it = fNavigators.begin();
804 it != fNavigators.end(); ++it) {
805 arr = (*it).second;
806 if (arr) delete arr;
807 }
808 fNavigators.clear();
809 if (fMultiThread) fgMutex.unlock();
810}
811
812////////////////////////////////////////////////////////////////////////////////
813/// Clear a single navigator.
814
816{
817 if (fMultiThread) fgMutex.lock();
818 for (NavigatorsMap_t::iterator it = fNavigators.begin(); it != fNavigators.end(); ++it) {
819 TGeoNavigatorArray *arr = (*it).second;
820 if (arr) {
821 if ((TGeoNavigator*)arr->Remove((TObject*)nav)) {
822 delete nav;
823 if (!arr->GetEntries()) fNavigators.erase(it);
824 if (fMultiThread) fgMutex.unlock();
825 return;
826 }
827 }
828 }
829 Error("Remove navigator", "Navigator %p not found", nav);
830 if (fMultiThread) fgMutex.unlock();
831}
832
833////////////////////////////////////////////////////////////////////////////////
834/// Set maximum number of threads for navigation.
835
837{
838 if (!fClosed) {
839 Error("SetMaxThreads", "Cannot set maximum number of threads before closing the geometry");
840 return;
841 }
842 if (!fMultiThread) {
844 std::thread::id threadId = std::this_thread::get_id();
845 NavigatorsMap_t::const_iterator it = fNavigators.find(threadId);
846 if (it != fNavigators.end()) {
847 TGeoNavigatorArray *array = it->second;
848 fNavigators.erase(it);
849 fNavigators.insert(NavigatorsMap_t::value_type(threadId, array));
850 }
851 }
852 if (fMaxThreads) {
855 }
856 fMaxThreads = nthreads+1;
857 if (fMaxThreads>0) {
860 }
861}
862
863////////////////////////////////////////////////////////////////////////////////
864
866{
867 if (!fMaxThreads) return;
868 fgMutex.lock();
869 TIter next(fVolumes);
870 TGeoVolume *vol;
871 while ((vol=(TGeoVolume*)next())) vol->ClearThreadData();
872 fgMutex.unlock();
873}
874
875////////////////////////////////////////////////////////////////////////////////
876/// Create thread private data for all geometry objects.
877
879{
880 if (!fMaxThreads) return;
881 fgMutex.lock();
882 TIter next(fVolumes);
883 TGeoVolume *vol;
884 while ((vol=(TGeoVolume*)next())) vol->CreateThreadData(fMaxThreads);
885 fgMutex.unlock();
886}
887
888////////////////////////////////////////////////////////////////////////////////
889/// Clear the current map of threads. This will be filled again by the calling
890/// threads via ThreadId calls.
891
893{
894 if (gGeoManager && !gGeoManager->IsMultiThread()) return;
895 fgMutex.lock();
896 if (!fgThreadId->empty()) fgThreadId->clear();
897 fgNumThreads = 0;
898 fgMutex.unlock();
899}
900
901////////////////////////////////////////////////////////////////////////////////
902/// Translates the current thread id to an ordinal number. This can be used to
903/// manage data which is specific for a given thread.
904
906{
907 TTHREAD_TLS(Int_t) tid = -1;
908 Int_t ttid = tid; // TTHREAD_TLS_GET(Int_t,tid);
909 if (ttid > -1) return ttid;
910 if (gGeoManager && !gGeoManager->IsMultiThread()) return 0;
911 std::thread::id threadId = std::this_thread::get_id();
912 TGeoManager::ThreadsMapIt_t it = fgThreadId->find(threadId);
913 if (it != fgThreadId->end()) return it->second;
914 // Map needs to be updated.
915 fgMutex.lock();
916 (*fgThreadId)[threadId] = fgNumThreads;
917 tid = fgNumThreads; // TTHREAD_TLS_SET(Int_t,tid,fgNumThreads);
918 ttid = fgNumThreads++;
919 fgMutex.unlock();
920 return ttid;
921}
922
923////////////////////////////////////////////////////////////////////////////////
924/// Describe how to browse this object.
925
927{
928 if (!b) return;
929 if (fMaterials) b->Add(fMaterials, "Materials");
930 if (fMedia) b->Add(fMedia, "Media");
931 if (fMatrices) b->Add(fMatrices, "Local transformations");
932 if (fOverlaps) b->Add(fOverlaps, "Illegal overlaps");
933 if (fTracks) b->Add(fTracks, "Tracks");
934 if (fMasterVolume) b->Add(fMasterVolume, "Master Volume", fMasterVolume->IsVisible());
935 if (fTopVolume) b->Add(fTopVolume, "Top Volume", fTopVolume->IsVisible());
936 if (fTopNode) b->Add(fTopNode);
937 TString browserImp(gEnv->GetValue("Browser.Name", "TRootBrowserLite"));
938 TQObject::Connect(browserImp.Data(), "Checked(TObject*,Bool_t)",
939 "TGeoManager", this, "SetVisibility(TObject*,Bool_t)");
940}
941
942////////////////////////////////////////////////////////////////////////////////
943/// Append a pad for this geometry.
944
946 AppendPad("");
947 GetGeomPainter()->EditGeometry(option);
948}
949
950////////////////////////////////////////////////////////////////////////////////
951/// Set visibility for a volume.
952
954{
955 if(obj->IsA() == TGeoVolume::Class()) {
956 TGeoVolume *vol = (TGeoVolume *) obj;
957 vol->SetVisibility(vis);
958 } else {
959 if (obj->InheritsFrom(TGeoNode::Class())) {
960 TGeoNode *node = (TGeoNode *) obj;
961 node->SetVisibility(vis);
962 } else return;
963 }
965}
966
967////////////////////////////////////////////////////////////////////////////////
968/// Get the new 'bombed' translation vector according current exploded view mode.
969
971{
972 if (fPainter) fPainter->BombTranslation(tr, bombtr);
973 return;
974}
975
976////////////////////////////////////////////////////////////////////////////////
977/// Get the new 'unbombed' translation vector according current exploded view mode.
978
980{
981 if (fPainter) fPainter->UnbombTranslation(tr, bombtr);
982 return;
983}
984
985////////////////////////////////////////////////////////////////////////////////
986/// Backup the current state without affecting the cache stack.
987
989{
991}
992
993////////////////////////////////////////////////////////////////////////////////
994/// Restore a backed-up state without affecting the cache stack.
995
997{
999}
1000
1001////////////////////////////////////////////////////////////////////////////////
1002/// Register a matrix to the list of matrices. It will be cleaned-up at the
1003/// destruction TGeoManager.
1004
1006{
1007 return TGeoBuilder::Instance(this)->RegisterMatrix((TGeoMatrix*)matrix);
1008}
1009
1010////////////////////////////////////////////////////////////////////////////////
1011/// Replaces all occurrences of VORIG with VNEW in the geometry tree. The volume VORIG
1012/// is not replaced from the list of volumes, but all node referencing it will reference
1013/// VNEW instead. Returns number of occurrences changed.
1014
1016{
1017 Int_t nref = 0;
1018 if (!vorig || !vnew) return nref;
1019 TGeoMedium *morig = vorig->GetMedium();
1020 Bool_t checkmed = kFALSE;
1021 if (morig) checkmed = kTRUE;
1022 TGeoMedium *mnew = vnew->GetMedium();
1023 // Try to limit the damage produced by incorrect usage.
1024 if (!mnew && !vnew->IsAssembly()) {
1025 Error("ReplaceVolume","Replacement volume %s has no medium and it is not an assembly",
1026 vnew->GetName());
1027 return nref;
1028 }
1029 if (mnew && checkmed) {
1030 if (mnew->GetId() != morig->GetId())
1031 Warning("ReplaceVolume","Replacement volume %s has different medium than original volume %s",
1032 vnew->GetName(), vorig->GetName());
1033 checkmed = kFALSE;
1034 }
1035
1036 // Medium checking now performed only if replacement is an assembly and old volume a real one.
1037 // Check result is dependent on positioning.
1038 Int_t nvol = fVolumes->GetEntriesFast();
1039 Int_t i,j,nd;
1040 Int_t ierr = 0;
1041 TGeoVolume *vol;
1042 TGeoNode *node;
1043 TGeoVoxelFinder *voxels;
1044 for (i=0; i<nvol; i++) {
1045 vol = (TGeoVolume*)fVolumes->At(i);
1046 if (!vol) continue;
1047 if (vol==vorig || vol==vnew) continue;
1048 nd = vol->GetNdaughters();
1049 for (j=0; j<nd; j++) {
1050 node = vol->GetNode(j);
1051 if (node->GetVolume() == vorig) {
1052 if (checkmed) {
1053 mnew = node->GetMotherVolume()->GetMedium();
1054 if (mnew && mnew->GetId()!=morig->GetId()) ierr++;
1055 }
1056 nref++;
1057 if (node->IsOverlapping()) {
1058 node->SetOverlapping(kFALSE);
1059 Info("ReplaceVolume","%s replaced with assembly and declared NON-OVERLAPPING!",node->GetName());
1060 }
1061 node->SetVolume(vnew);
1062 voxels = node->GetMotherVolume()->GetVoxels();
1063 if (voxels) voxels->SetNeedRebuild();
1064 } else {
1065 if (node->GetMotherVolume() == vorig) {
1066 nref++;
1067 node->SetMotherVolume(vnew);
1068 if (node->IsOverlapping()) {
1069 node->SetOverlapping(kFALSE);
1070 Info("ReplaceVolume","%s inside substitute assembly %s declared NON-OVERLAPPING!",node->GetName(),vnew->GetName());
1071 }
1072 }
1073 }
1074 }
1075 }
1076 if (ierr) Warning("ReplaceVolume", "Volumes should not be replaced with assemblies if they are positioned in containers having a different medium ID.\n %i occurrences for assembly replacing volume %s",
1077 ierr, vorig->GetName());
1078 return nref;
1079}
1080
1081////////////////////////////////////////////////////////////////////////////////
1082/// Transform all volumes named VNAME to assemblies. The volumes must be virtual.
1083
1085{
1086 TGeoVolume *toTransform = FindVolumeFast(vname);
1087 if (!toTransform) {
1088 Warning("TransformVolumeToAssembly", "Volume %s not found", vname);
1089 return 0;
1090 }
1091 Int_t index = fVolumes->IndexOf(toTransform);
1092 Int_t count = 0;
1093 Int_t indmax = fVolumes->GetEntries();
1094 Bool_t replace = kTRUE;
1095 TGeoVolume *transformed;
1096 while (index<indmax) {
1097 if (replace) {
1098 replace = kFALSE;
1099 transformed = TGeoVolumeAssembly::MakeAssemblyFromVolume(toTransform);
1100 if (transformed) {
1101 ReplaceVolume(toTransform, transformed);
1102 count++;
1103 } else {
1104 if (toTransform->IsAssembly())
1105 Warning("TransformVolumeToAssembly", "Volume %s already assembly", toTransform->GetName());
1106 if (!toTransform->GetNdaughters())
1107 Warning("TransformVolumeToAssembly", "Volume %s has no daughters, cannot transform", toTransform->GetName());
1108 if (toTransform->IsVolumeMulti())
1109 Warning("TransformVolumeToAssembly", "Volume %s divided, cannot transform", toTransform->GetName());
1110 }
1111 }
1112 index++;
1113 if (index >= indmax) return count;
1114 toTransform = (TGeoVolume*)fVolumes->At(index);
1115 if (!strcmp(toTransform->GetName(),vname)) replace = kTRUE;
1116 }
1117 return count;
1118}
1119
1120////////////////////////////////////////////////////////////////////////////////
1121/// Create a new volume by dividing an existing one (GEANT3 like)
1122///
1123/// Divides MOTHER into NDIV divisions called NAME
1124/// along axis IAXIS starting at coordinate value START
1125/// and having size STEP. The created volumes will have tracking
1126/// media ID=NUMED (if NUMED=0 -> same media as MOTHER)
1127/// The behavior of the division operation can be triggered using OPTION :
1128///
1129/// OPTION (case insensitive) :
1130/// - N - divide all range in NDIV cells (same effect as STEP<=0) (GSDVN in G3)
1131/// - NX - divide range starting with START in NDIV cells (GSDVN2 in G3)
1132/// - S - divide all range with given STEP. NDIV is computed and divisions will be centered
1133/// in full range (same effect as NDIV<=0) (GSDVS, GSDVT in G3)
1134/// - SX - same as DVS, but from START position. (GSDVS2, GSDVT2 in G3)
1135
1136TGeoVolume *TGeoManager::Division(const char *name, const char *mother, Int_t iaxis,
1137 Int_t ndiv, Double_t start, Double_t step, Int_t numed, Option_t *option)
1138{
1139 return TGeoBuilder::Instance(this)->Division(name, mother, iaxis, ndiv, start, step, numed, option);
1140}
1141
1142////////////////////////////////////////////////////////////////////////////////
1143/// Create rotation matrix named 'mat<index>'.
1144///
1145/// - index rotation matrix number
1146/// - theta1 polar angle for axis X
1147/// - phi1 azimuthal angle for axis X
1148/// - theta2 polar angle for axis Y
1149/// - phi2 azimuthal angle for axis Y
1150/// - theta3 polar angle for axis Z
1151/// - phi3 azimuthal angle for axis Z
1152///
1153
1155 Double_t theta2, Double_t phi2,
1156 Double_t theta3, Double_t phi3)
1157{
1158 TGeoBuilder::Instance(this)->Matrix(index, theta1, phi1, theta2, phi2, theta3, phi3);
1159}
1160
1161////////////////////////////////////////////////////////////////////////////////
1162/// Create material with given A, Z and density, having an unique id.
1163
1165{
1166 return TGeoBuilder::Instance(this)->Material(name, a, z, dens, uid, radlen, intlen);
1167
1168}
1169
1170////////////////////////////////////////////////////////////////////////////////
1171/// Create mixture OR COMPOUND IMAT as composed by THE BASIC nelem
1172/// materials defined by arrays A,Z and WMAT, having an unique id.
1173
1175 Int_t nelem, Float_t *wmat, Int_t uid)
1176{
1177 return TGeoBuilder::Instance(this)->Mixture(name, a, z, dens, nelem, wmat, uid);
1178}
1179
1180////////////////////////////////////////////////////////////////////////////////
1181/// Create mixture OR COMPOUND IMAT as composed by THE BASIC nelem
1182/// materials defined by arrays A,Z and WMAT, having an unique id.
1183
1185 Int_t nelem, Double_t *wmat, Int_t uid)
1186{
1187 return TGeoBuilder::Instance(this)->Mixture(name, a, z, dens, nelem, wmat, uid);
1188}
1189
1190////////////////////////////////////////////////////////////////////////////////
1191/// Create tracking medium
1192///
1193/// - numed tracking medium number assigned
1194/// - name tracking medium name
1195/// - nmat material number
1196/// - isvol sensitive volume flag
1197/// - ifield magnetic field
1198/// - fieldm max. field value (kilogauss)
1199/// - tmaxfd max. angle due to field (deg/step)
1200/// - stemax max. step allowed
1201/// - deemax max. fraction of energy lost in a step
1202/// - epsil tracking precision (cm)
1203/// - stmin min. step due to continuous processes (cm)
1204///
1205/// - ifield = 0 if no magnetic field; ifield = -1 if user decision in guswim;
1206/// - ifield = 1 if tracking performed with g3rkuta; ifield = 2 if tracking
1207/// performed with g3helix; ifield = 3 if tracking performed with g3helx3.
1208///
1209
1210TGeoMedium *TGeoManager::Medium(const char *name, Int_t numed, Int_t nmat, Int_t isvol,
1211 Int_t ifield, Double_t fieldm, Double_t tmaxfd,
1212 Double_t stemax, Double_t deemax, Double_t epsil,
1213 Double_t stmin)
1214{
1215 return TGeoBuilder::Instance(this)->Medium(name, numed, nmat, isvol, ifield, fieldm, tmaxfd, stemax, deemax, epsil, stmin);
1216}
1217
1218////////////////////////////////////////////////////////////////////////////////
1219/// Create a node called <name_nr> pointing to the volume called <name>
1220/// as daughter of the volume called <mother> (gspos). The relative matrix is
1221/// made of : a translation (x,y,z) and a rotation matrix named <matIROT>.
1222/// In case npar>0, create the volume to be positioned in mother, according
1223/// its actual parameters (gsposp).
1224/// - NAME Volume name
1225/// - NUMBER Copy number of the volume
1226/// - MOTHER Mother volume name
1227/// - X X coord. of the volume in mother ref. sys.
1228/// - Y Y coord. of the volume in mother ref. sys.
1229/// - Z Z coord. of the volume in mother ref. sys.
1230/// - IROT Rotation matrix number w.r.t. mother ref. sys.
1231/// - ISONLY ONLY/MANY flag
1232
1233void TGeoManager::Node(const char *name, Int_t nr, const char *mother,
1234 Double_t x, Double_t y, Double_t z, Int_t irot,
1235 Bool_t isOnly, Float_t *upar, Int_t npar)
1236{
1237 TGeoBuilder::Instance(this)->Node(name, nr, mother, x, y, z, irot, isOnly, upar, npar);
1238}
1239
1240////////////////////////////////////////////////////////////////////////////////
1241/// Create a node called <name_nr> pointing to the volume called <name>
1242/// as daughter of the volume called <mother> (gspos). The relative matrix is
1243/// made of : a translation (x,y,z) and a rotation matrix named <matIROT>.
1244/// In case npar>0, create the volume to be positioned in mother, according
1245/// its actual parameters (gsposp).
1246/// - NAME Volume name
1247/// - NUMBER Copy number of the volume
1248/// - MOTHER Mother volume name
1249/// - X X coord. of the volume in mother ref. sys.
1250/// - Y Y coord. of the volume in mother ref. sys.
1251/// - Z Z coord. of the volume in mother ref. sys.
1252/// - IROT Rotation matrix number w.r.t. mother ref. sys.
1253/// - ISONLY ONLY/MANY flag
1254
1255void TGeoManager::Node(const char *name, Int_t nr, const char *mother,
1256 Double_t x, Double_t y, Double_t z, Int_t irot,
1257 Bool_t isOnly, Double_t *upar, Int_t npar)
1258{
1259 TGeoBuilder::Instance(this)->Node(name, nr, mother, x, y, z, irot, isOnly, upar, npar);
1260
1261}
1262
1263////////////////////////////////////////////////////////////////////////////////
1264/// Create a volume in GEANT3 style.
1265/// - NAME Volume name
1266/// - SHAPE Volume type
1267/// - NMED Tracking medium number
1268/// - NPAR Number of shape parameters
1269/// - UPAR Vector containing shape parameters
1270
1271TGeoVolume *TGeoManager::Volume(const char *name, const char *shape, Int_t nmed,
1272 Float_t *upar, Int_t npar)
1273{
1274 return TGeoBuilder::Instance(this)->Volume(name, shape, nmed, upar, npar);
1275}
1276
1277////////////////////////////////////////////////////////////////////////////////
1278/// Create a volume in GEANT3 style.
1279/// - NAME Volume name
1280/// - SHAPE Volume type
1281/// - NMED Tracking medium number
1282/// - NPAR Number of shape parameters
1283/// - UPAR Vector containing shape parameters
1284
1285TGeoVolume *TGeoManager::Volume(const char *name, const char *shape, Int_t nmed,
1286 Double_t *upar, Int_t npar)
1287{
1288 return TGeoBuilder::Instance(this)->Volume(name, shape, nmed, upar, npar);
1289}
1290
1291////////////////////////////////////////////////////////////////////////////////
1292/// Assigns uid's for all materials,media and matrices.
1293
1295{
1296 Int_t index = 1;
1297 TIter next(fMaterials);
1298 TGeoMaterial *mater;
1299 while ((mater=(TGeoMaterial*)next())) {
1300 mater->SetUniqueID(index++);
1302 }
1303 index = 1;
1304 TIter next1(fMedia);
1305 TGeoMedium *med;
1306 while ((med=(TGeoMedium*)next1())) {
1307 med->SetUniqueID(index++);
1309 }
1310 index = 1;
1311 TIter next2(fShapes);
1312 TGeoShape *shape;
1313 while ((shape=(TGeoShape*)next2())) {
1314 shape->SetUniqueID(index++);
1315 if (shape->IsComposite()) ((TGeoCompositeShape*)shape)->GetBoolNode()->RegisterMatrices();
1316 }
1317
1318 TIter next3(fMatrices);
1319 TGeoMatrix *matrix;
1320 while ((matrix=(TGeoMatrix*)next3())) {
1321 matrix->RegisterYourself();
1322 }
1323 TIter next4(fMatrices);
1324 index = 1;
1325 while ((matrix=(TGeoMatrix*)next4())) {
1326 matrix->SetUniqueID(index++);
1328 }
1329 TIter next5(fVolumes);
1330 TGeoVolume *vol;
1331 while ((vol=(TGeoVolume*)next5())) vol->UnmarkSaved();
1332}
1333
1334////////////////////////////////////////////////////////////////////////////////
1335/// Reset all attributes to default ones. Default attributes for visualization
1336/// are those defined before closing the geometry.
1337
1339{
1340 if (gPad) delete gPad;
1341 gPad = 0;
1342 SetVisOption(0);
1343 SetVisLevel(3);
1344 SetExplodedView(0);
1346 if (!gStyle) return;
1347 TIter next(fVolumes);
1348 TGeoVolume *vol = 0;
1349 while ((vol=(TGeoVolume*)next())) {
1350 if (!vol->IsVisTouched()) continue;
1351 vol->SetVisTouched(kFALSE);
1352 }
1353}
1354////////////////////////////////////////////////////////////////////////////////
1355/// Closing geometry implies checking the geometry validity, fixing shapes
1356/// with negative parameters (run-time shapes)building the cache manager,
1357/// voxelizing all volumes, counting the total number of physical nodes and
1358/// registering the manager class to the browser.
1359
1361{
1362 if (fClosed) {
1363 Warning("CloseGeometry", "geometry already closed");
1364 return;
1365 }
1366 if (!fMasterVolume) {
1367 Error("CloseGeometry","you MUST call SetTopVolume() first !");
1368 return;
1369 }
1370 if (!gROOT->GetListOfGeometries()->FindObject(this)) gROOT->GetListOfGeometries()->Add(this);
1371 if (!gROOT->GetListOfBrowsables()->FindObject(this)) gROOT->GetListOfBrowsables()->Add(this);
1372// TSeqCollection *brlist = gROOT->GetListOfBrowsers();
1373// TIter next(brlist);
1374// TBrowser *browser = 0;
1375// while ((browser=(TBrowser*)next())) browser->Refresh();
1376 TString opt(option);
1377 opt.ToLower();
1378// Bool_t dummy = opt.Contains("d");
1379 Bool_t nodeid = opt.Contains("i");
1380 // Create a geometry navigator if not present
1381 TGeoNavigator *nav = 0;
1382 Int_t nnavigators = 0;
1383 // Check if the geometry is streamed from file
1384 if (fIsGeomReading) {
1385 if (fgVerboseLevel>0) Info("CloseGeometry","Geometry loaded from file...");
1388 if (!fTopNode) {
1389 if (!fMasterVolume) {
1390 Error("CloseGeometry", "Master volume not streamed");
1391 return;
1392 }
1394 if (fStreamVoxels && fgVerboseLevel>0) Info("CloseGeometry","Voxelization retrieved from file");
1395 }
1396 // Create a geometry navigator if not present
1398 nnavigators = GetListOfNavigators()->GetEntriesFast();
1399 if (!opt.Contains("nv")) {
1400 Voxelize("ALL");
1401 }
1402 CountLevels();
1403 for (Int_t i=0; i<nnavigators; i++) {
1404 nav = (TGeoNavigator*)GetListOfNavigators()->At(i);
1405 nav->GetCache()->BuildInfoBranch();
1406 if (nodeid) nav->GetCache()->BuildIdArray();
1407 }
1408 if (!fHashVolumes) {
1409 Int_t nvol = fVolumes->GetEntriesFast();
1410 Int_t ngvol = fGVolumes->GetEntriesFast();
1411 fHashVolumes = new THashList(nvol+1);
1412 fHashGVolumes = new THashList(ngvol+1);
1413 Int_t i;
1414 for (i=0; i<ngvol; i++) fHashGVolumes->AddLast(fGVolumes->At(i));
1415 for (i=0; i<nvol; i++) fHashVolumes->AddLast(fVolumes->At(i));
1416 }
1417 fClosed = kTRUE;
1418 if (fParallelWorld) {
1419 if (fgVerboseLevel>0) Info("CloseGeometry","Recreating parallel world %s ...",fParallelWorld->GetName());
1421 }
1422
1423 if (fgVerboseLevel>0) Info("CloseGeometry","%i nodes/ %i volume UID's in %s", fNNodes, fUniqueVolumes->GetEntriesFast()-1, GetTitle());
1424 if (fgVerboseLevel>0) Info("CloseGeometry","----------------modeler ready----------------");
1425 return;
1426 }
1427
1428 // Create a geometry navigator if not present
1430 nnavigators = GetListOfNavigators()->GetEntriesFast();
1432 CheckGeometry();
1433 if (fgVerboseLevel>0) Info("CloseGeometry","Counting nodes...");
1434 fNNodes = CountNodes();
1436 if (fNLevel<30) fNLevel = 100;
1437
1438 // BuildIdArray();
1439 // avoid voxelization if requested to speed up geometry startup
1440 if (!opt.Contains("nv")) {
1441 Voxelize("ALL");
1442 } else {
1443 TGeoVolume *vol;
1444 TIter next(fVolumes);
1445 while ((vol = (TGeoVolume *)next())) {
1446 vol->SortNodes();
1447 }
1448 }
1449 if (fgVerboseLevel>0) Info("CloseGeometry","Building cache...");
1450 CountLevels();
1451 for (Int_t i=0; i<nnavigators; i++) {
1452 nav = (TGeoNavigator*)GetListOfNavigators()->At(i);
1453 nav->GetCache()->BuildInfoBranch();
1454 if (nodeid) nav->GetCache()->BuildIdArray();
1455 }
1456 fClosed = kTRUE;
1457 if (fgVerboseLevel>0) {
1458 Info("CloseGeometry","%i nodes/ %i volume UID's in %s", fNNodes, fUniqueVolumes->GetEntriesFast()-1, GetTitle());
1459 Info("CloseGeometry","----------------modeler ready----------------");
1460 }
1461}
1462
1463////////////////////////////////////////////////////////////////////////////////
1464/// Clear the list of overlaps.
1465
1467{
1468 if (fOverlaps) {
1469 fOverlaps->Delete();
1470 delete fOverlaps;
1471 }
1472 fOverlaps = new TObjArray();
1473}
1474
1475////////////////////////////////////////////////////////////////////////////////
1476/// Remove a shape from the list of shapes.
1477
1479{
1480 if (fShapes->FindObject(shape)) fShapes->Remove((TGeoShape*)shape);
1481 delete shape;
1482}
1483
1484////////////////////////////////////////////////////////////////////////////////
1485/// Clean temporary volumes and shapes from garbage collection.
1486
1488{
1489 if (!fGVolumes && !fGShapes) return;
1490 Int_t i,nentries;
1491 if (fGVolumes) {
1493 TGeoVolume *vol = 0;
1494 for (i=0; i<nentries; i++) {
1495 vol=(TGeoVolume*)fGVolumes->At(i);
1496 if (vol) vol->SetFinder(0);
1497 }
1498 fGVolumes->Delete();
1499 delete fGVolumes;
1500 fGVolumes = 0;
1501 }
1502 if (fGShapes) {
1503 fGShapes->Delete();
1504 delete fGShapes;
1505 fGShapes = 0;
1506 }
1507}
1508
1509////////////////////////////////////////////////////////////////////////////////
1510/// Change current path to point to the node having this id.
1511/// Node id has to be in range : 0 to fNNodes-1 (no check for performance reasons)
1512
1514{
1515 GetCurrentNavigator()->CdNode(nodeid);
1516}
1517
1518////////////////////////////////////////////////////////////////////////////////
1519/// Get the unique ID of the current node.
1520
1522{
1524}
1525
1526////////////////////////////////////////////////////////////////////////////////
1527/// Make top level node the current node. Updates the cache accordingly.
1528/// Determine the overlapping state of current node.
1529
1531{
1533}
1534
1535////////////////////////////////////////////////////////////////////////////////
1536/// Go one level up in geometry. Updates cache accordingly.
1537/// Determine the overlapping state of current node.
1538
1540{
1542}
1543
1544////////////////////////////////////////////////////////////////////////////////
1545/// Make a daughter of current node current. Can be called only with a valid
1546/// daughter index (no check). Updates cache accordingly.
1547
1549{
1550 GetCurrentNavigator()->CdDown(index);
1551}
1552
1553////////////////////////////////////////////////////////////////////////////////
1554/// Do a cd to the node found next by FindNextBoundary
1555
1557{
1559}
1560
1561////////////////////////////////////////////////////////////////////////////////
1562/// Browse the tree of nodes starting from fTopNode according to pathname.
1563/// Changes the path accordingly.
1564
1565Bool_t TGeoManager::cd(const char *path)
1566{
1567 return GetCurrentNavigator()->cd(path);
1568}
1569
1570////////////////////////////////////////////////////////////////////////////////
1571/// Check if a geometry path is valid without changing the state of the current navigator.
1572
1573Bool_t TGeoManager::CheckPath(const char *path) const
1574{
1575 return GetCurrentNavigator()->CheckPath(path);
1576}
1577
1578////////////////////////////////////////////////////////////////////////////////
1579/// Convert all reflections in geometry to normal rotations + reflected shapes.
1580
1582{
1583 if (!fTopNode) return;
1584 if (fgVerboseLevel>0) Info("ConvertReflections", "Converting reflections in: %s - %s ...", GetName(), GetTitle());
1586 TGeoNode *node;
1587 TGeoNodeMatrix *nodematrix;
1588 TGeoMatrix *matrix, *mclone;
1589 TGeoVolume *reflected;
1590 while ((node=next())) {
1591 matrix = node->GetMatrix();
1592 if (matrix->IsReflection()) {
1593// printf("%s before\n", node->GetName());
1594// matrix->Print();
1595 mclone = new TGeoCombiTrans(*matrix);
1596 mclone->RegisterYourself();
1597 // Reflect just the rotation component
1598 mclone->ReflectZ(kFALSE, kTRUE);
1599 nodematrix = (TGeoNodeMatrix*)node;
1600 nodematrix->SetMatrix(mclone);
1601// printf("%s after\n", node->GetName());
1602// node->GetMatrix()->Print();
1603 reflected = node->GetVolume()->MakeReflectedVolume();
1604 node->SetVolume(reflected);
1605 }
1606 }
1607 if (fgVerboseLevel>0) Info("ConvertReflections", "Done");
1608}
1609
1610////////////////////////////////////////////////////////////////////////////////
1611/// Count maximum number of nodes per volume, maximum depth and maximum
1612/// number of xtru vertices.
1613
1615{
1616 if (!fTopNode) {
1617 Error("CountLevels", "Top node not defined.");
1618 return;
1619 }
1621 Bool_t fixrefs = fIsGeomReading && (fMasterVolume->GetRefCount()==1);
1623 if (fgVerboseLevel>1 && fixrefs) Info("CountLevels", "Fixing volume reference counts");
1624 TGeoNode *node;
1625 Int_t maxlevel = 1;
1626 Int_t maxnodes = fTopVolume->GetNdaughters();
1627 Int_t maxvertices = 1;
1628 while ((node=next())) {
1629 if (fixrefs) {
1630 node->GetVolume()->Grab();
1631 for (Int_t ibit=10; ibit<14; ibit++) {
1632 node->SetBit(BIT(ibit+4), node->TestBit(BIT(ibit)));
1633// node->ResetBit(BIT(ibit)); // cannot overwrite old crap for reproducibility
1634 }
1635 }
1636 if (node->GetNdaughters() > maxnodes)
1637 maxnodes = node->GetNdaughters();
1638 if (next.GetLevel()>maxlevel) maxlevel = next.GetLevel();
1639 if (node->GetVolume()->GetShape()->IsA()==TGeoXtru::Class()) {
1640 TGeoXtru *xtru = (TGeoXtru*)node->GetVolume()->GetShape();
1641 if (xtru->GetNvert()>maxvertices) maxvertices = xtru->GetNvert();
1642 }
1643 }
1644 fgMaxLevel = maxlevel;
1645 fgMaxDaughters = maxnodes;
1646 fgMaxXtruVert = maxvertices;
1647 if (fgVerboseLevel>0) Info("CountLevels", "max level = %d, max placements = %d", fgMaxLevel, fgMaxDaughters);
1648}
1649
1650////////////////////////////////////////////////////////////////////////////////
1651/// Count the total number of nodes starting from a volume, nlevels down.
1652
1654{
1655 TGeoVolume *top;
1656 if (!vol) {
1657 top = fTopVolume;
1658 } else {
1659 top = (TGeoVolume*)vol;
1660 }
1661 Int_t count = top->CountNodes(nlevels, option);
1662 return count;
1663}
1664
1665////////////////////////////////////////////////////////////////////////////////
1666/// Set default angles for a given view.
1667
1669{
1671}
1672
1673////////////////////////////////////////////////////////////////////////////////
1674/// Draw current point in the same view.
1675
1677{
1678 if (fPainter) fPainter->DrawCurrentPoint(color);
1679}
1680
1681////////////////////////////////////////////////////////////////////////////////
1682/// Draw animation of tracks
1683
1685{
1688 if (tmin<0 || tmin>=tmax || nframes<1) return;
1690 box[0] = box[1] = box[2] = 0;
1691 box[3] = box[4] = box[5] = 100;
1692 Double_t dt = (tmax-tmin)/Double_t(nframes);
1693 Double_t delt = 2E-9;
1694 Double_t t = tmin;
1695 Int_t i, j;
1696 TString opt(option);
1697 Bool_t save = kFALSE, geomanim=kFALSE;
1698 TString fname;
1699 if (opt.Contains("/S")) save = kTRUE;
1700
1701 if (opt.Contains("/G")) geomanim = kTRUE;
1702 SetTminTmax(0,0);
1703 DrawTracks(opt.Data());
1704 Double_t start[6], end[6];
1705 Double_t dd[6] = {0,0,0,0,0,0};
1706 Double_t dlat=0, dlong=0, dpsi=0;
1707 if (geomanim) {
1708 fPainter->EstimateCameraMove(tmin+5*dt, tmin+15*dt, start, end);
1709 for (i=0; i<3; i++) {
1710 start[i+3] = 20 + 1.3*start[i+3];
1711 end[i+3] = 20 + 0.9*end[i+3];
1712 }
1713 for (i=0; i<6; i++) {
1714 dd[i] = (end[i]-start[i])/10.;
1715 }
1716 memcpy(box, start, 6*sizeof(Double_t));
1717 fPainter->GetViewAngles(dlong,dlat,dpsi);
1718 dlong = (-206-dlong)/Double_t(nframes);
1719 dlat = (126-dlat)/Double_t(nframes);
1720 dpsi = (75-dpsi)/Double_t(nframes);
1722 }
1723
1724 for (i=0; i<nframes; i++) {
1725 if (t-delt<0) SetTminTmax(t-delt,t);
1726 else gGeoManager->SetTminTmax(t-delt,t);
1727 if (geomanim) {
1728 for (j=0; j<6; j++) box[j]+=dd[j];
1729 fPainter->GrabFocus(1,dlong,dlat,dpsi);
1730 } else {
1731 ModifiedPad();
1732 }
1733 if (save) {
1734 fname = TString::Format("anim%04d.gif", i);
1735 gPad->Print(fname);
1736 }
1737 t += dt;
1738 }
1740}
1741
1742////////////////////////////////////////////////////////////////////////////////
1743/// Draw tracks over the geometry, according to option. By default, only
1744/// primaries are drawn. See TGeoTrack::Draw() for additional options.
1745
1747{
1748 TVirtualGeoTrack *track;
1749 //SetVisLevel(1);
1750 //SetVisOption(1);
1752 for (Int_t i=0; i<fNtracks; i++) {
1753 track = GetTrack(i);
1754 if (track) track->Draw(option);
1755 }
1757 ModifiedPad();
1758}
1759
1760////////////////////////////////////////////////////////////////////////////////
1761/// Draw current path
1762
1763void TGeoManager::DrawPath(const char *path, Option_t *option)
1764{
1765 if (!fTopVolume) return;
1767 GetGeomPainter()->DrawPath(path, option);
1768}
1769
1770////////////////////////////////////////////////////////////////////////////////
1771/// Draw random points in the bounding box of a volume.
1772
1773void TGeoManager::RandomPoints(const TGeoVolume *vol, Int_t npoints, Option_t *option)
1774{
1775 GetGeomPainter()->RandomPoints((TGeoVolume*)vol, npoints, option);
1776}
1777
1778////////////////////////////////////////////////////////////////////////////////
1779/// Check time of finding "Where am I" for n points.
1780
1781void TGeoManager::Test(Int_t npoints, Option_t *option)
1782{
1783 GetGeomPainter()->Test(npoints, option);
1784}
1785
1786////////////////////////////////////////////////////////////////////////////////
1787/// Geometry overlap checker based on sampling.
1788
1789void TGeoManager::TestOverlaps(const char* path)
1790{
1792}
1793
1794////////////////////////////////////////////////////////////////////////////////
1795/// Fill volume names of current branch into an array.
1796
1798{
1800}
1801
1802////////////////////////////////////////////////////////////////////////////////
1803/// Get name for given pdg code;
1804
1805const char *TGeoManager::GetPdgName(Int_t pdg) const
1806{
1807 static char defaultname[5] = { "XXX" };
1808 if (!fPdgNames || !pdg) return defaultname;
1809 for (Int_t i=0; i<fNpdg; i++) {
1810 if (fPdgId[i]==pdg) return fPdgNames->At(i)->GetName();
1811 }
1812 return defaultname;
1813}
1814
1815////////////////////////////////////////////////////////////////////////////////
1816/// Set a name for a particle having a given pdg.
1817
1818void TGeoManager::SetPdgName(Int_t pdg, const char *name)
1819{
1820 if (!pdg) return;
1821 if (!fPdgNames) {
1822 fPdgNames = new TObjArray(1024);
1823 }
1824 if (!strcmp(name, GetPdgName(pdg))) return;
1825 // store pdg name
1826 if (fNpdg>1023) {
1827 Warning("SetPdgName", "No more than 256 different pdg codes allowed");
1828 return;
1829 }
1830 fPdgId[fNpdg] = pdg;
1831 TNamed *pdgname = new TNamed(name, "");
1832 fPdgNames->AddAtAndExpand(pdgname, fNpdg++);
1833}
1834
1835////////////////////////////////////////////////////////////////////////////////
1836/// Get GDML matrix with a given name;
1837
1839{
1841}
1842
1843////////////////////////////////////////////////////////////////////////////////
1844/// Add GDML matrix;
1846{
1847 if (GetGDMLMatrix(mat->GetName())) {
1848 Error("AddGDMLMatrix", "Matrix %s already added to manager", mat->GetName());
1849 return;
1850 }
1851 fGDMLMatrices->Add(mat);
1852}
1853
1854////////////////////////////////////////////////////////////////////////////////
1855/// Get optical surface with a given name;
1856
1858{
1860}
1861
1862////////////////////////////////////////////////////////////////////////////////
1863/// Add optical surface;
1865{
1866 if (GetOpticalSurface(optsurf->GetName())) {
1867 Error("AddOpticalSurface", "Surface %s already added to manager", optsurf->GetName());
1868 return;
1869 }
1870 fOpticalSurfaces->Add(optsurf);
1871}
1872
1873////////////////////////////////////////////////////////////////////////////////
1874/// Get skin surface with a given name;
1875
1877{
1879}
1880
1881////////////////////////////////////////////////////////////////////////////////
1882/// Add skin surface;
1884{
1885 if (GetSkinSurface(surf->GetName())) {
1886 Error("AddSkinSurface", "Surface %s already added to manager", surf->GetName());
1887 return;
1888 }
1889 fSkinSurfaces->Add(surf);
1890}
1891
1892////////////////////////////////////////////////////////////////////////////////
1893/// Get border surface with a given name;
1894
1896{
1898}
1899
1900////////////////////////////////////////////////////////////////////////////////
1901/// Add border surface;
1903{
1904 if (GetBorderSurface(surf->GetName())) {
1905 Error("AddBorderSurface", "Surface %s already added to manager", surf->GetName());
1906 return;
1907 }
1908 fBorderSurfaces->Add(surf);
1909}
1910
1911////////////////////////////////////////////////////////////////////////////////
1912/// Fill node copy numbers of current branch into an array.
1913
1914void TGeoManager::GetBranchNumbers(Int_t *copyNumbers, Int_t *volumeNumbers) const
1915{
1916 GetCurrentNavigator()->GetBranchNumbers(copyNumbers, volumeNumbers);
1917}
1918
1919////////////////////////////////////////////////////////////////////////////////
1920/// Fill node copy numbers of current branch into an array.
1921
1923{
1925}
1926
1927////////////////////////////////////////////////////////////////////////////////
1928/// Retrieve cartesian and radial bomb factors.
1929
1930void TGeoManager::GetBombFactors(Double_t &bombx, Double_t &bomby, Double_t &bombz, Double_t &bombr) const
1931{
1932 if (fPainter) {
1933 fPainter->GetBombFactors(bombx, bomby, bombz, bombr);
1934 return;
1935 }
1936 bombx = bomby = bombz = bombr = 1.3;
1937}
1938
1939////////////////////////////////////////////////////////////////////////////////
1940/// Return maximum number of daughters of a volume used in the geometry.
1941
1943{
1944 return fgMaxDaughters;
1945}
1946
1947////////////////////////////////////////////////////////////////////////////////
1948/// Return maximum number of levels used in the geometry.
1949
1951{
1952 return fgMaxLevel;
1953}
1954
1955////////////////////////////////////////////////////////////////////////////////
1956/// Return maximum number of vertices for an xtru shape used.
1957
1959{
1960 return fgMaxXtruVert;
1961}
1962
1963////////////////////////////////////////////////////////////////////////////////
1964/// Returns number of threads that were set to use geometry.
1965
1967{
1968 return fgNumThreads;
1969}
1970
1971////////////////////////////////////////////////////////////////////////////////
1972/// Return stored current matrix (global matrix of the next touched node).
1973
1975{
1976 if (!GetCurrentNavigator()) return NULL;
1977 return GetCurrentNavigator()->GetHMatrix();
1978}
1979
1980////////////////////////////////////////////////////////////////////////////////
1981/// Returns current depth to which geometry is drawn.
1982
1984{
1985 return fVisLevel;
1986}
1987
1988////////////////////////////////////////////////////////////////////////////////
1989/// Returns current depth to which geometry is drawn.
1990
1992{
1993 return fVisOption;
1994}
1995
1996////////////////////////////////////////////////////////////////////////////////
1997/// Find level of virtuality of current overlapping node (number of levels
1998/// up having the same tracking media.
1999
2001{
2003}
2004
2005////////////////////////////////////////////////////////////////////////////////
2006/// Search the track hierarchy to find the track with the
2007/// given id
2008///
2009/// if 'primsFirst' is true, then:
2010/// first tries TGeoManager::GetTrackOfId, then does a
2011/// recursive search if that fails. this would be faster
2012/// if the track is somehow known to be a primary
2013
2015{
2016 TVirtualGeoTrack* trk = 0;
2017 trk = GetTrackOfId(id);
2018 if (trk) return trk;
2019 // need recursive search
2020 TIter next(fTracks);
2021 TVirtualGeoTrack* prim;
2022 while ((prim = (TVirtualGeoTrack*)next())) {
2023 trk = prim->FindTrackWithId(id);
2024 if (trk) return trk;
2025 }
2026 return NULL;
2027}
2028
2029////////////////////////////////////////////////////////////////////////////////
2030/// Get track with a given ID.
2031
2033{
2034 TVirtualGeoTrack *track;
2035 for (Int_t i=0; i<fNtracks; i++) {
2036 if ((track = (TVirtualGeoTrack *)fTracks->UncheckedAt(i))) {
2037 if (track->GetId() == id) return track;
2038 }
2039 }
2040 return 0;
2041}
2042
2043////////////////////////////////////////////////////////////////////////////////
2044/// Get parent track with a given ID.
2045
2047{
2049 while ((track=track->GetMother())) {
2050 if (track->GetId()==id) return track;
2051 }
2052 return 0;
2053}
2054
2055////////////////////////////////////////////////////////////////////////////////
2056/// Get index for track id, -1 if not found.
2057
2059{
2060 TVirtualGeoTrack *track;
2061 for (Int_t i=0; i<fNtracks; i++) {
2062 if ((track = (TVirtualGeoTrack *)fTracks->UncheckedAt(i))) {
2063 if (track->GetId() == id) return i;
2064 }
2065 }
2066 return -1;
2067}
2068
2069////////////////////////////////////////////////////////////////////////////////
2070/// Go upwards the tree until a non-overlapping node
2071
2073{
2075}
2076
2077////////////////////////////////////////////////////////////////////////////////
2078/// Go upwards the tree until a non-overlapping node
2079
2081{
2083}
2084
2085////////////////////////////////////////////////////////////////////////////////
2086/// Set default volume colors according to A of material
2087
2089{
2090 const Int_t nmax = 110;
2091 Int_t col[nmax];
2092 for (Int_t i=0;i<nmax;i++) col[i] = kGray;
2093
2094 //here we should create a new TColor with the same rgb as in the default
2095 //ROOT colors used below
2096 col[ 3] = kYellow-10;
2097 col[ 4] = col[ 5] = kGreen-10;
2098 col[ 6] = col[ 7] = kBlue-7;
2099 col[ 8] = col[ 9] = kMagenta-3;
2100 col[10] = col[11] = kRed-10;
2101 col[12] = kGray+1;
2102 col[13] = kBlue-10;
2103 col[14] = kOrange+7;
2104 col[16] = kYellow+1;
2105 col[20] = kYellow-10;
2106 col[24] = col[25] = col[26] = kBlue-8;
2107 col[29] = kOrange+9;
2108 col[79] = kOrange-2;
2109
2110 TGeoVolume *vol;
2111 TIter next(fVolumes);
2112 while ((vol=(TGeoVolume*)next())) {
2113 TGeoMedium *med = vol->GetMedium();
2114 if (!med) continue;
2115 TGeoMaterial *mat = med->GetMaterial();
2116 Int_t matZ = (Int_t)mat->GetZ();
2117 vol->SetLineColor(col[matZ]);
2118 if (mat->GetDensity()<0.1) vol->SetTransparency(60);
2119 }
2120}
2121
2122////////////////////////////////////////////////////////////////////////////////
2123/// Compute safe distance from the current point. This represent the distance
2124/// from POINT to the closest boundary.
2125
2127{
2128 return GetCurrentNavigator()->Safety(inside);
2129}
2130
2131////////////////////////////////////////////////////////////////////////////////
2132/// Set volume attributes in G3 style.
2133
2134void TGeoManager::SetVolumeAttribute(const char *name, const char *att, Int_t val)
2135{
2136 TGeoVolume *volume;
2137 Bool_t all = kFALSE;
2138 if (strstr(name,"*")) all=kTRUE;
2139 Int_t ivo=0;
2140 TIter next(fVolumes);
2141 TString chatt = att;
2142 chatt.ToLower();
2143 while ((volume=(TGeoVolume*)next())) {
2144 if (strcmp(volume->GetName(), name) && !all) continue;
2145 ivo++;
2146 if (chatt.Contains("colo")) volume->SetLineColor(val);
2147 if (chatt.Contains("lsty")) volume->SetLineStyle(val);
2148 if (chatt.Contains("lwid")) volume->SetLineWidth(val);
2149 if (chatt.Contains("fill")) volume->SetFillColor(val);
2150 if (chatt.Contains("seen")) volume->SetVisibility(val);
2151 }
2152 TIter next1(fGVolumes);
2153 while ((volume=(TGeoVolume*)next1())) {
2154 if (strcmp(volume->GetName(), name) && !all) continue;
2155 ivo++;
2156 if (chatt.Contains("colo")) volume->SetLineColor(val);
2157 if (chatt.Contains("lsty")) volume->SetLineStyle(val);
2158 if (chatt.Contains("lwid")) volume->SetLineWidth(val);
2159 if (chatt.Contains("fill")) volume->SetFillColor(val);
2160 if (chatt.Contains("seen")) volume->SetVisibility(val);
2161 }
2162 if (!ivo) {
2163 Warning("SetVolumeAttribute","volume: %s does not exist",name);
2164 }
2165}
2166
2167////////////////////////////////////////////////////////////////////////////////
2168/// Set factors that will "bomb" all translations in cartesian and cylindrical coordinates.
2169
2171{
2172 if (fPainter) fPainter->SetBombFactors(bombx, bomby, bombz, bombr);
2173}
2174
2175////////////////////////////////////////////////////////////////////////////////
2176/// Set a user-defined shape as clipping for ray tracing.
2177
2179{
2181 if (shape) {
2183 fClippingShape = shape;
2184 }
2185 painter->SetClippingShape(shape);
2186}
2187
2188////////////////////////////////////////////////////////////////////////////////
2189/// set the maximum number of visible nodes.
2190
2192 fMaxVisNodes = maxnodes;
2193 if (maxnodes>0 && fgVerboseLevel>0)
2194 Info("SetMaxVisNodes","Automatic visible depth for %d visible nodes", maxnodes);
2195 if (!fPainter) return;
2197 Int_t level = fPainter->GetVisLevel();
2198 if (level != fVisLevel) fVisLevel = level;
2199}
2200
2201////////////////////////////////////////////////////////////////////////////////
2202/// make top volume visible on screen
2203
2206 fPainter->SetTopVisible(vis);
2207}
2208
2209////////////////////////////////////////////////////////////////////////////////
2210/// Assign a given node to be checked for overlaps. Any other overlaps will be ignored.
2211
2214}
2215
2216////////////////////////////////////////////////////////////////////////////////
2217/// Set the number of points to be generated on the shape outline when checking
2218/// for overlaps.
2219
2221{
2222 GetGeomPainter()->SetNmeshPoints(npoints);
2223}
2224
2225////////////////////////////////////////////////////////////////////////////////
2226/// set drawing mode :
2227/// - option=0 (default) all nodes drawn down to vislevel
2228/// - option=1 leaves and nodes at vislevel drawn
2229/// - option=2 path is drawn
2230/// - option=4 visibility changed
2231
2233 if ((option>=0) && (option<3)) fVisOption=option;
2234 if (fPainter) fPainter->SetVisOption(option);
2235}
2236
2237////////////////////////////////////////////////////////////////////////////////
2238/// Set visualization option (leaves only OR all volumes)
2239
2241{
2242 if (flag) SetVisOption(1);
2243 else SetVisOption(0);
2244}
2245
2246////////////////////////////////////////////////////////////////////////////////
2247/// Set density threshold. Volumes with densities lower than this become
2248/// transparent.
2249
2251{
2252 fVisDensity = density;
2254}
2255
2256////////////////////////////////////////////////////////////////////////////////
2257/// set default level down to which visualization is performed
2258
2260 if (level>0) {
2261 fVisLevel = level;
2262 fMaxVisNodes = 0;
2263 if (fgVerboseLevel>0)
2264 Info("SetVisLevel","Automatic visible depth disabled");
2266 } else {
2268 }
2269}
2270
2271////////////////////////////////////////////////////////////////////////////////
2272/// Sort overlaps by decreasing overlap distance. Extrusions comes first.
2273
2275{
2276 fOverlaps->Sort();
2277}
2278
2279////////////////////////////////////////////////////////////////////////////////
2280/// Optimize voxelization type for all volumes. Save best choice in a macro.
2281
2282void TGeoManager::OptimizeVoxels(const char *filename)
2283{
2284 if (!fTopNode) {
2285 Error("OptimizeVoxels","Geometry must be closed first");
2286 return;
2287 }
2288 std::ofstream out;
2289 TString fname = filename;
2290 if (fname.IsNull()) fname = "tgeovox.C";
2291 out.open(fname, std::ios::out);
2292 if (!out.good()) {
2293 Error("OptimizeVoxels", "cannot open file");
2294 return;
2295 }
2296 // write header
2297 TDatime t;
2298 TString sname(fname);
2299 sname.ReplaceAll(".C", "");
2300 out << sname.Data()<<"()"<<std::endl;
2301 out << "{" << std::endl;
2302 out << "//=== Macro generated by ROOT version "<< gROOT->GetVersion()<<" : "<<t.AsString()<<std::endl;
2303 out << "//=== Voxel optimization for " << GetTitle() << " geometry"<<std::endl;
2304 out << "//===== <run this macro JUST BEFORE closing the geometry>"<<std::endl;
2305 out << " TGeoVolume *vol = 0;"<<std::endl;
2306 out << " // parse all voxelized volumes"<<std::endl;
2307 TGeoVolume *vol = 0;
2308 Bool_t cyltype;
2309 TIter next(fVolumes);
2310 while ((vol=(TGeoVolume*)next())) {
2311 if (!vol->GetVoxels()) continue;
2312 out<<" vol = gGeoManager->GetVolume(\""<<vol->GetName()<<"\");"<<std::endl;
2313 cyltype = vol->OptimizeVoxels();
2314 if (cyltype) {
2315 out<<" vol->SetCylVoxels();"<<std::endl;
2316 } else {
2317 out<<" vol->SetCylVoxels(kFALSE);"<<std::endl;
2318 }
2319 }
2320 out << "}" << std::endl;
2321 out.close();
2322}
2323////////////////////////////////////////////////////////////////////////////////
2324/// Parse a string boolean expression and do a syntax check. Find top
2325/// level boolean operator and returns its type. Fill the two
2326/// substrings to which this operator applies. The returned integer is :
2327/// - -1 : parse error
2328/// - 0 : no boolean operator
2329/// - 1 : union - represented as '+' in expression
2330/// - 2 : difference (subtraction) - represented as '-' in expression
2331/// - 3 : intersection - represented as '*' in expression.
2332/// Parentheses should be used to avoid ambiguities. For instance :
2333/// - A+B-C will be interpreted as (A+B)-C which is not the same as A+(B-C)
2334/// eliminate not needed parentheses
2335
2336Int_t TGeoManager::Parse(const char *expr, TString &expr1, TString &expr2, TString &expr3)
2337{
2338 TString startstr(expr);
2339 Int_t len = startstr.Length();
2340 Int_t i;
2341 TString e0 = "";
2342 expr3 = "";
2343 // eliminate blanks
2344 for (i=0; i< len; i++) {
2345 if (startstr(i)==' ') continue;
2346 e0 += startstr(i, 1);
2347 }
2348 Int_t level = 0;
2349 Int_t levmin = 999;
2350 Int_t boolop = 0;
2351 Int_t indop = 0;
2352 Int_t iloop = 1;
2353 Int_t lastop = 0;
2354 Int_t lastdp = 0;
2355 Int_t lastpp = 0;
2356 Bool_t foundmat = kFALSE;
2357 // check/eliminate parentheses
2358 while (iloop==1) {
2359 iloop = 0;
2360 lastop = 0;
2361 lastdp = 0;
2362 lastpp = 0;
2363 len = e0.Length();
2364 for (i=0; i<len; i++) {
2365 if (e0(i)=='(') {
2366 if (!level) iloop++;
2367 level++;
2368 continue;
2369 }
2370 if (e0(i)==')') {
2371 level--;
2372 if (level==0) lastpp=i;
2373 continue;
2374 }
2375 if ((e0(i)=='+') || (e0(i)=='-') || (e0(i)=='*')) {
2376 lastop = i;
2377 if (level<levmin) {
2378 levmin = level;
2379 indop = i;
2380 }
2381 continue;
2382 }
2383 if ((e0(i)==':') && (level==0)) {
2384 lastdp = i;
2385 continue;
2386 }
2387 }
2388 if (level!=0) {
2389 if (gGeoManager) gGeoManager->Error("Parse","parentheses does not match");
2390 return -1;
2391 }
2392 if (iloop==1 && (e0(0)=='(') && (e0(len-1)==')')) {
2393 // eliminate extra parentheses
2394 e0=e0(1, len-2);
2395 continue;
2396 }
2397 if (foundmat) break;
2398 if (((lastop==0) && (lastdp>0)) || ((lastpp>0) && (lastdp>lastpp) && (indop<lastpp))) {
2399 expr3 = e0(lastdp+1, len-lastdp);
2400 e0=e0(0, lastdp);
2401 foundmat = kTRUE;
2402 iloop = 1;
2403 continue;
2404 } else break;
2405 }
2406 // loop expression and search parentheses/operators
2407 levmin = 999;
2408 for (i=0; i<len; i++) {
2409 if (e0(i)=='(') {
2410 level++;
2411 continue;
2412 }
2413 if (e0(i)==')') {
2414 level--;
2415 continue;
2416 }
2417 // Take LAST operator at lowest level (revision 28/07/08)
2418 if (level<=levmin) {
2419 if (e0(i)=='+') {
2420 boolop = 1; // union
2421 levmin = level;
2422 indop = i;
2423 }
2424 if (e0(i)=='-') {
2425 boolop = 2; // difference
2426 levmin = level;
2427 indop = i;
2428 }
2429 if (e0(i)=='*') {
2430 boolop = 3; // intersection
2431 levmin = level;
2432 indop = i;
2433 }
2434 }
2435 }
2436 if (indop==0) {
2437 expr1=e0;
2438 return indop;
2439 }
2440 expr1 = e0(0, indop);
2441 expr2 = e0(indop+1, len-indop);
2442 return boolop;
2443}
2444
2445
2446////////////////////////////////////////////////////////////////////////////////
2447/// Save current attributes in a macro
2448
2449void TGeoManager::SaveAttributes(const char *filename)
2450{
2451 if (!fTopNode) {
2452 Error("SaveAttributes","geometry must be closed first\n");
2453 return;
2454 }
2455 std::ofstream out;
2456 TString fname(filename);
2457 if (fname.IsNull()) fname = "tgeoatt.C";
2458 out.open(fname, std::ios::out);
2459 if (!out.good()) {
2460 Error("SaveAttributes", "cannot open file");
2461 return;
2462 }
2463 // write header
2464 TDatime t;
2465 TString sname(fname);
2466 sname.ReplaceAll(".C", "");
2467 out << sname.Data()<<"()"<<std::endl;
2468 out << "{" << std::endl;
2469 out << "//=== Macro generated by ROOT version "<< gROOT->GetVersion()<<" : "<<t.AsString()<<std::endl;
2470 out << "//=== Attributes for " << GetTitle() << " geometry"<<std::endl;
2471 out << "//===== <run this macro AFTER loading the geometry in memory>"<<std::endl;
2472 // save current top volume
2473 out << " TGeoVolume *top = gGeoManager->GetVolume(\""<<fTopVolume->GetName()<<"\");"<<std::endl;
2474 out << " TGeoVolume *vol = 0;"<<std::endl;
2475 out << " TGeoNode *node = 0;"<<std::endl;
2476 out << " // clear all volume attributes and get painter"<<std::endl;
2477 out << " gGeoManager->ClearAttributes();"<<std::endl;
2478 out << " gGeoManager->GetGeomPainter();"<<std::endl;
2479 out << " // set visualization modes and bomb factors"<<std::endl;
2480 out << " gGeoManager->SetVisOption("<<GetVisOption()<<");"<<std::endl;
2481 out << " gGeoManager->SetVisLevel("<<GetVisLevel()<<");"<<std::endl;
2482 out << " gGeoManager->SetExplodedView("<<GetBombMode()<<");"<<std::endl;
2483 Double_t bombx, bomby, bombz, bombr;
2484 GetBombFactors(bombx, bomby, bombz, bombr);
2485 out << " gGeoManager->SetBombFactors("<<bombx<<","<<bomby<<","<<bombz<<","<<bombr<<");"<<std::endl;
2486 out << " // iterate volumes container and set new attributes"<<std::endl;
2487// out << " TIter next(gGeoManager->GetListOfVolumes());"<<std::endl;
2488 TGeoVolume *vol = 0;
2490
2491 TIter next(fVolumes);
2492 while ((vol=(TGeoVolume*)next())) {
2493 vol->SetVisStreamed(kFALSE);
2494 }
2495 out << " // draw top volume with new settings"<<std::endl;
2496 out << " top->Draw();"<<std::endl;
2497 out << " gPad->x3d();"<<std::endl;
2498 out << "}" << std::endl;
2499 out.close();
2500}
2501
2502////////////////////////////////////////////////////////////////////////////////
2503/// Returns the deepest node containing fPoint, which must be set a priori.
2504
2506{
2507 return GetCurrentNavigator()->SearchNode(downwards, skipnode);
2508}
2509
2510////////////////////////////////////////////////////////////////////////////////
2511/// Cross next boundary and locate within current node
2512/// The current point must be on the boundary of fCurrentNode.
2513
2515{
2516 return GetCurrentNavigator()->CrossBoundaryAndLocate(downwards, skipnode);
2517}
2518
2519////////////////////////////////////////////////////////////////////////////////
2520/// Compute distance to next boundary within STEPMAX. If no boundary is found,
2521/// propagate current point along current direction with fStep=STEPMAX. Otherwise
2522/// propagate with fStep=SNEXT (distance to boundary) and locate/return the next
2523/// node.
2524
2526{
2527 return GetCurrentNavigator()->FindNextBoundaryAndStep(stepmax, compsafe);
2528}
2529
2530////////////////////////////////////////////////////////////////////////////////
2531/// Find distance to next boundary and store it in fStep. Returns node to which this
2532/// boundary belongs. If PATH is specified, compute only distance to the node to which
2533/// PATH points. If STEPMAX is specified, compute distance only in case fSafety is smaller
2534/// than this value. STEPMAX represent the step to be made imposed by other reasons than
2535/// geometry (usually physics processes). Therefore in this case this method provides the
2536/// answer to the question : "Is STEPMAX a safe step ?" returning a NULL node and filling
2537/// fStep with a big number.
2538/// In case frombdr=kTRUE, the isotropic safety is set to zero.
2539///
2540/// Note : safety distance for the current point is computed ONLY in case STEPMAX is
2541/// specified, otherwise users have to call explicitly TGeoManager::Safety() if
2542/// they want this computed for the current point.
2543
2544TGeoNode *TGeoManager::FindNextBoundary(Double_t stepmax, const char *path, Bool_t frombdr)
2545{
2546 // convert current point and direction to local reference
2547 return GetCurrentNavigator()->FindNextBoundary(stepmax,path, frombdr);
2548}
2549
2550////////////////////////////////////////////////////////////////////////////////
2551/// Computes as fStep the distance to next daughter of the current volume.
2552/// The point and direction must be converted in the coordinate system of the current volume.
2553/// The proposed step limit is fStep.
2554
2556{
2557 return GetCurrentNavigator()->FindNextDaughterBoundary(point, dir, idaughter, compmatrix);
2558}
2559
2560////////////////////////////////////////////////////////////////////////////////
2561/// Reset current state flags.
2562
2564{
2566}
2567
2568////////////////////////////////////////////////////////////////////////////////
2569/// Returns deepest node containing current point.
2570
2572{
2573 return GetCurrentNavigator()->FindNode(safe_start);
2574}
2575
2576////////////////////////////////////////////////////////////////////////////////
2577/// Returns deepest node containing current point.
2578
2580{
2581 return GetCurrentNavigator()->FindNode(x, y, z);
2582}
2583
2584////////////////////////////////////////////////////////////////////////////////
2585/// Computes fast normal to next crossed boundary, assuming that the current point
2586/// is close enough to the boundary. Works only after calling FindNextBoundary.
2587
2589{
2591}
2592
2593////////////////////////////////////////////////////////////////////////////////
2594/// Computes normal vector to the next surface that will be or was already
2595/// crossed when propagating on a straight line from a given point/direction.
2596/// Returns the normal vector cosines in the MASTER coordinate system. The dot
2597/// product of the normal and the current direction is positive defined.
2598
2600{
2601 return GetCurrentNavigator()->FindNormal(forward);
2602}
2603
2604////////////////////////////////////////////////////////////////////////////////
2605/// Checks if point (x,y,z) is still in the current node.
2606
2608{
2609 return GetCurrentNavigator()->IsSameLocation(x,y,z,change);
2610}
2611
2612////////////////////////////////////////////////////////////////////////////////
2613/// Check if a new point with given coordinates is the same as the last located one.
2614
2616{
2617 return GetCurrentNavigator()->IsSamePoint(x,y,z);
2618}
2619
2620////////////////////////////////////////////////////////////////////////////////
2621/// True if current node is in phi range
2622
2624{
2625 if (!fPhiCut) return kTRUE;
2626 const Double_t *origin;
2628 origin = ((TGeoBBox*)GetCurrentNavigator()->GetCurrentVolume()->GetShape())->GetOrigin();
2629 Double_t point[3];
2630 LocalToMaster(origin, &point[0]);
2631 Double_t phi = TMath::ATan2(point[1], point[0])*TMath::RadToDeg();
2632 if (phi<0) phi+=360.;
2633 if ((phi>=fPhimin) && (phi<=fPhimax)) return kFALSE;
2634 return kTRUE;
2635}
2636
2637////////////////////////////////////////////////////////////////////////////////
2638/// Initialize current point and current direction vector (normalized)
2639/// in MARS. Return corresponding node.
2640
2642{
2643 return GetCurrentNavigator()->InitTrack(point, dir);
2644}
2645
2646////////////////////////////////////////////////////////////////////////////////
2647/// Initialize current point and current direction vector (normalized)
2648/// in MARS. Return corresponding node.
2649
2651{
2652 return GetCurrentNavigator()->InitTrack(x,y,z,nx,ny,nz);
2653}
2654
2655////////////////////////////////////////////////////////////////////////////////
2656/// Inspects path and all flags for the current state.
2657
2659{
2661}
2662
2663////////////////////////////////////////////////////////////////////////////////
2664/// Get path to the current node in the form /node0/node1/...
2665
2666const char *TGeoManager::GetPath() const
2667{
2668 return GetCurrentNavigator()->GetPath();
2669}
2670
2671////////////////////////////////////////////////////////////////////////////////
2672/// Get total size of geometry in bytes.
2673
2675{
2676 Int_t count = 0;
2677 TIter next(fVolumes);
2678 TGeoVolume *vol;
2679 while ((vol=(TGeoVolume*)next())) count += vol->GetByteCount();
2680 TIter next1(fMatrices);
2681 TGeoMatrix *matrix;
2682 while ((matrix=(TGeoMatrix*)next1())) count += matrix->GetByteCount();
2683 TIter next2(fMaterials);
2684 TGeoMaterial *mat;
2685 while ((mat=(TGeoMaterial*)next2())) count += mat->GetByteCount();
2686 TIter next3(fMedia);
2687 TGeoMedium *med;
2688 while ((med=(TGeoMedium*)next3())) count += med->GetByteCount();
2689 if (fgVerboseLevel>0) Info("GetByteCount","Total size of logical tree : %i bytes", count);
2690 return count;
2691}
2692
2693////////////////////////////////////////////////////////////////////////////////
2694/// Make a default painter if none present. Returns pointer to it.
2695
2697{
2698 if (!fPainter) {
2699 const char *kind = "root";
2700 if (gROOT->IsWebDisplay() && !gROOT->IsWebDisplayBatch()) kind = "web";
2701 if (auto h = gROOT->GetPluginManager()->FindHandler("TVirtualGeoPainter", kind)) {
2702 if (h->LoadPlugin() == -1) {
2703 Error("GetGeomPainter", "could not load plugin for %s geo_painter", kind);
2704 return nullptr;
2705 }
2706 fPainter = (TVirtualGeoPainter*)h->ExecPlugin(1,this);
2707 if (!fPainter) {
2708 Error("GetGeomPainter", "could not create %s geo_painter", kind);
2709 return nullptr;
2710 }
2711 } else {
2712 Error("GetGeomPainter", "not found plugin %s for geo_painter", kind);
2713 }
2714 }
2715 return fPainter;
2716}
2717
2718////////////////////////////////////////////////////////////////////////////////
2719/// Search for a named volume. All trailing blanks stripped.
2720
2722{
2723 TString sname = name;
2724 sname = sname.Strip();
2725 TGeoVolume *vol = (TGeoVolume*)fVolumes->FindObject(sname.Data());
2726 return vol;
2727}
2728
2729////////////////////////////////////////////////////////////////////////////////
2730/// Fast search for a named volume. All trailing blanks stripped.
2731
2733{
2734 if (!fHashVolumes) {
2735 Int_t nvol = fVolumes->GetEntriesFast();
2736 Int_t ngvol = fGVolumes->GetEntriesFast();
2737 fHashVolumes = new THashList(nvol+1);
2738 fHashGVolumes = new THashList(ngvol+1);
2739 Int_t i;
2740 for (i=0; i<ngvol; i++) fHashGVolumes->AddLast(fGVolumes->At(i));
2741 for (i=0; i<nvol; i++) fHashVolumes->AddLast(fVolumes->At(i));
2742 }
2743 TString sname = name;
2744 sname = sname.Strip();
2745 THashList *list = fHashVolumes;
2746 if (multi) list = fHashGVolumes;
2747 TGeoVolume *vol = (TGeoVolume*)list->FindObject(sname.Data());
2748 return vol;
2749}
2750
2751////////////////////////////////////////////////////////////////////////////////
2752/// Retrieve unique id for a volume name. Return -1 if name not found.
2753
2754Int_t TGeoManager::GetUID(const char *volname) const
2755{
2756 TGeoManager *geom = (TGeoManager*)this;
2757 TGeoVolume *vol = geom->FindVolumeFast(volname, kFALSE);
2758 if (!vol) vol = geom->FindVolumeFast(volname, kTRUE);
2759 if (!vol) return -1;
2760 return vol->GetNumber();
2761}
2762
2763////////////////////////////////////////////////////////////////////////////////
2764/// Find if a given material duplicates an existing one.
2765
2767{
2768 Int_t index = fMaterials->IndexOf(mat);
2769 if (index <= 0) return 0;
2770 TGeoMaterial *other;
2771 for (Int_t i=0; i<index; i++) {
2772 other = (TGeoMaterial*)fMaterials->At(i);
2773 if (other == mat) continue;
2774 if (other->IsEq(mat)) return other;
2775 }
2776 return 0;
2777}
2778
2779////////////////////////////////////////////////////////////////////////////////
2780/// Search for a named material. All trailing blanks stripped.
2781
2782TGeoMaterial *TGeoManager::GetMaterial(const char *matname) const
2783{
2784 TString sname = matname;
2785 sname = sname.Strip();
2787 return mat;
2788}
2789
2790////////////////////////////////////////////////////////////////////////////////
2791/// Search for a named tracking medium. All trailing blanks stripped.
2792
2793TGeoMedium *TGeoManager::GetMedium(const char *medium) const
2794{
2795 TString sname = medium;
2796 sname = sname.Strip();
2797 TGeoMedium *med = (TGeoMedium*)fMedia->FindObject(sname.Data());
2798 return med;
2799}
2800
2801////////////////////////////////////////////////////////////////////////////////
2802/// Search for a tracking medium with a given ID.
2803
2805{
2806 TIter next(fMedia);
2807 TGeoMedium *med;
2808 while ((med=(TGeoMedium*)next())) {
2809 if (med->GetId()==numed) return med;
2810 }
2811 return 0;
2812}
2813
2814////////////////////////////////////////////////////////////////////////////////
2815/// Return material at position id.
2816
2818{
2819 if (id<0 || id >= fMaterials->GetSize()) return 0;
2820 TGeoMaterial *mat = (TGeoMaterial*)fMaterials->At(id);
2821 return mat;
2822}
2823
2824////////////////////////////////////////////////////////////////////////////////
2825/// Return index of named material.
2826
2827Int_t TGeoManager::GetMaterialIndex(const char *matname) const
2828{
2829 TIter next(fMaterials);
2830 TGeoMaterial *mat;
2831 Int_t id = 0;
2832 TString sname = matname;
2833 sname = sname.Strip();
2834 while ((mat = (TGeoMaterial*)next())) {
2835 if (!strcmp(mat->GetName(),sname.Data()))
2836 return id;
2837 id++;
2838 }
2839 return -1; // fail
2840}
2841
2842////////////////////////////////////////////////////////////////////////////////
2843/// Randomly shoot nrays and plot intersections with surfaces for current
2844/// top node.
2845
2846void TGeoManager::RandomRays(Int_t nrays, Double_t startx, Double_t starty, Double_t startz, const char *target_vol, Bool_t check_norm)
2847{
2848 GetGeomPainter()->RandomRays(nrays, startx, starty, startz, target_vol, check_norm);
2849}
2850
2851////////////////////////////////////////////////////////////////////////////////
2852/// Remove material at given index.
2853
2855{
2856 TObject *obj = fMaterials->At(index);
2857 if (obj) fMaterials->Remove(obj);
2858}
2859
2860////////////////////////////////////////////////////////////////////////////////
2861/// Sets all pointers TGeoVolume::fField to NULL. User data becomes decoupled
2862/// from geometry. Deletion has to be managed by users.
2863
2865{
2866 TIter next(fVolumes);
2867 TGeoVolume *vol;
2868 while ((vol=(TGeoVolume*)next())) vol->SetField(0);
2869}
2870
2871////////////////////////////////////////////////////////////////////////////////
2872/// Change raytracing mode.
2873
2875{
2876 fRaytraceMode = mode;
2878}
2879
2880////////////////////////////////////////////////////////////////////////////////
2881/// Restore the master volume of the geometry.
2882
2884{
2885 if (fTopVolume == fMasterVolume) return;
2887}
2888
2889////////////////////////////////////////////////////////////////////////////////
2890/// Voxelize all non-divided volumes.
2891
2893{
2894 TGeoVolume *vol;
2895// TGeoVoxelFinder *vox = 0;
2896 if (!fStreamVoxels && fgVerboseLevel>0) Info("Voxelize","Voxelizing...");
2897// Int_t nentries = fVolumes->GetSize();
2898 TIter next(fVolumes);
2899 while ((vol = (TGeoVolume*)next())) {
2900 if (!fIsGeomReading) vol->SortNodes();
2901 if (!fStreamVoxels) {
2902 vol->Voxelize(option);
2903 }
2904 if (!fIsGeomReading) vol->FindOverlaps();
2905 }
2906}
2907
2908////////////////////////////////////////////////////////////////////////////////
2909/// Send "Modified" signal to painter.
2910
2912{
2913 if (!fPainter) return;
2915}
2916
2917////////////////////////////////////////////////////////////////////////////////
2918/// Make an TGeoArb8 volume.
2919
2921 Double_t dz, Double_t *vertices)
2922{
2923 return TGeoBuilder::Instance(this)->MakeArb8(name, medium, dz, vertices);
2924}
2925
2926////////////////////////////////////////////////////////////////////////////////
2927/// Make in one step a volume pointing to a box shape with given medium.
2928
2930 Double_t dx, Double_t dy, Double_t dz)
2931{
2932 return TGeoBuilder::Instance(this)->MakeBox(name, medium, dx, dy, dz);
2933}
2934
2935////////////////////////////////////////////////////////////////////////////////
2936/// Make in one step a volume pointing to a parallelepiped shape with given medium.
2937
2939 Double_t dx, Double_t dy, Double_t dz,
2940 Double_t alpha, Double_t theta, Double_t phi)
2941{
2942 return TGeoBuilder::Instance(this)->MakePara(name, medium, dx, dy, dz, alpha, theta, phi);
2943}
2944
2945////////////////////////////////////////////////////////////////////////////////
2946/// Make in one step a volume pointing to a sphere shape with given medium
2947
2949 Double_t rmin, Double_t rmax, Double_t themin, Double_t themax,
2950 Double_t phimin, Double_t phimax)
2951{
2952 return TGeoBuilder::Instance(this)->MakeSphere(name, medium, rmin, rmax, themin, themax, phimin, phimax);
2953}
2954
2955////////////////////////////////////////////////////////////////////////////////
2956/// Make in one step a volume pointing to a torus shape with given medium.
2957
2959 Double_t rmin, Double_t rmax, Double_t phi1, Double_t dphi)
2960{
2961 return TGeoBuilder::Instance(this)->MakeTorus(name, medium, r, rmin, rmax, phi1, dphi);
2962}
2963
2964////////////////////////////////////////////////////////////////////////////////
2965/// Make in one step a volume pointing to a tube shape with given medium.
2966
2968 Double_t rmin, Double_t rmax, Double_t dz)
2969{
2970 return TGeoBuilder::Instance(this)->MakeTube(name, medium, rmin, rmax, dz);
2971}
2972
2973////////////////////////////////////////////////////////////////////////////////
2974/// Make in one step a volume pointing to a tube segment shape with given medium.
2975/// The segment will be from phiStart to phiEnd, the angles are expressed in degree
2976
2978 Double_t rmin, Double_t rmax, Double_t dz,
2979 Double_t phiStart, Double_t phiEnd)
2980{
2981 return TGeoBuilder::Instance(this)->MakeTubs(name, medium, rmin, rmax, dz, phiStart, phiEnd);
2982}
2983
2984////////////////////////////////////////////////////////////////////////////////
2985/// Make in one step a volume pointing to a tube shape with given medium
2986
2989{
2990 return TGeoBuilder::Instance(this)->MakeEltu(name, medium, a, b, dz);
2991}
2992
2993////////////////////////////////////////////////////////////////////////////////
2994/// Make in one step a volume pointing to a tube shape with given medium
2995
2997 Double_t rin, Double_t stin, Double_t rout, Double_t stout, Double_t dz)
2998{
2999 return TGeoBuilder::Instance(this)->MakeHype(name, medium, rin, stin, rout, stout, dz);
3000}
3001
3002////////////////////////////////////////////////////////////////////////////////
3003/// Make in one step a volume pointing to a tube shape with given medium
3004
3006 Double_t rlo, Double_t rhi, Double_t dz)
3007{
3008 return TGeoBuilder::Instance(this)->MakeParaboloid(name, medium, rlo, rhi, dz);
3009}
3010
3011////////////////////////////////////////////////////////////////////////////////
3012/// Make in one step a volume pointing to a tube segment shape with given medium
3013
3015 Double_t rmin, Double_t rmax, Double_t dz, Double_t phi1, Double_t phi2,
3016 Double_t lx, Double_t ly, Double_t lz, Double_t tx, Double_t ty, Double_t tz)
3017{
3018 return TGeoBuilder::Instance(this)->MakeCtub(name, medium, rmin, rmax, dz, phi1, phi2, lx, ly, lz, tx, ty, tz);
3019}
3020
3021////////////////////////////////////////////////////////////////////////////////
3022/// Make in one step a volume pointing to a cone shape with given medium.
3023
3025 Double_t dz, Double_t rmin1, Double_t rmax1,
3026 Double_t rmin2, Double_t rmax2)
3027{
3028 return TGeoBuilder::Instance(this)->MakeCone(name, medium, dz, rmin1, rmax1, rmin2, rmax2);
3029}
3030
3031////////////////////////////////////////////////////////////////////////////////
3032/// Make in one step a volume pointing to a cone segment shape with given medium
3033
3035 Double_t dz, Double_t rmin1, Double_t rmax1,
3036 Double_t rmin2, Double_t rmax2,
3037 Double_t phi1, Double_t phi2)
3038{
3039 return TGeoBuilder::Instance(this)->MakeCons(name, medium, dz, rmin1, rmax1, rmin2, rmax2, phi1, phi2);
3040}
3041
3042////////////////////////////////////////////////////////////////////////////////
3043/// Make in one step a volume pointing to a polycone shape with given medium.
3044
3046 Double_t phi, Double_t dphi, Int_t nz)
3047{
3048 return TGeoBuilder::Instance(this)->MakePcon(name, medium, phi, dphi, nz);
3049}
3050
3051////////////////////////////////////////////////////////////////////////////////
3052/// Make in one step a volume pointing to a polygone shape with given medium.
3053
3055 Double_t phi, Double_t dphi, Int_t nedges, Int_t nz)
3056{
3057 return TGeoBuilder::Instance(this)->MakePgon(name, medium, phi, dphi, nedges, nz);
3058}
3059
3060////////////////////////////////////////////////////////////////////////////////
3061/// Make in one step a volume pointing to a TGeoTrd1 shape with given medium.
3062
3064 Double_t dx1, Double_t dx2, Double_t dy, Double_t dz)
3065{
3066 return TGeoBuilder::Instance(this)->MakeTrd1(name, medium, dx1, dx2, dy, dz);
3067}
3068
3069////////////////////////////////////////////////////////////////////////////////
3070/// Make in one step a volume pointing to a TGeoTrd2 shape with given medium.
3071
3073 Double_t dx1, Double_t dx2, Double_t dy1, Double_t dy2,
3074 Double_t dz)
3075{
3076 return TGeoBuilder::Instance(this)->MakeTrd2(name, medium, dx1, dx2, dy1, dy2, dz);
3077}
3078
3079////////////////////////////////////////////////////////////////////////////////
3080/// Make in one step a volume pointing to a trapezoid shape with given medium.
3081
3083 Double_t dz, Double_t theta, Double_t phi, Double_t h1,
3084 Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Double_t bl2,
3085 Double_t tl2, Double_t alpha2)
3086{
3087 return TGeoBuilder::Instance(this)->MakeTrap(name, medium, dz, theta, phi, h1, bl1, tl1, alpha1, h2, bl2, tl2, alpha2);
3088}
3089
3090////////////////////////////////////////////////////////////////////////////////
3091/// Make in one step a volume pointing to a twisted trapezoid shape with given medium.
3092
3094 Double_t dz, Double_t theta, Double_t phi, Double_t twist, Double_t h1,
3095 Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Double_t bl2,
3096 Double_t tl2, Double_t alpha2)
3097{
3098 return TGeoBuilder::Instance(this)->MakeGtra(name, medium, dz, theta, phi, twist, h1, bl1, tl1, alpha1, h2, bl2, tl2, alpha2);
3099}
3100
3101////////////////////////////////////////////////////////////////////////////////
3102/// Make a TGeoXtru-shaped volume with nz planes
3103
3105{
3106 return TGeoBuilder::Instance(this)->MakeXtru(name, medium, nz);
3107}
3108
3109////////////////////////////////////////////////////////////////////////////////
3110/// Creates an alignable object with unique name corresponding to a path
3111/// and adds it to the list of alignables. An optional unique ID can be
3112/// provided, in which case PN entries can be searched fast by uid.
3113
3114TGeoPNEntry *TGeoManager::SetAlignableEntry(const char *unique_name, const char *path,
3115 Int_t uid)
3116{
3117 if (!CheckPath(path)) return NULL;
3118 if (!fHashPNE) fHashPNE = new THashList(256,3);
3119 if (!fArrayPNE) fArrayPNE = new TObjArray(256);
3120 TGeoPNEntry *entry = GetAlignableEntry(unique_name);
3121 if (entry) {
3122 Error("SetAlignableEntry", "An alignable object with name %s already existing. NOT ADDED !", unique_name);
3123 return 0;
3124 }
3125 entry = new TGeoPNEntry(unique_name, path);
3126 Int_t ientry = fHashPNE->GetSize();
3127 fHashPNE->Add(entry);
3128 fArrayPNE->AddAtAndExpand(entry, ientry);
3129 if (uid>=0) {
3130 Bool_t added = InsertPNEId(uid, ientry);
3131 if (!added) Error("SetAlignableEntry", "A PN entry: has already uid=%i", uid);
3132 }
3133 return entry;
3134}
3135
3136////////////////////////////////////////////////////////////////////////////////
3137/// Retrieves an existing alignable object.
3138
3140{
3141 if (!fHashPNE) return 0;
3143}
3144
3145////////////////////////////////////////////////////////////////////////////////
3146/// Retrieves an existing alignable object at a given index.
3147
3149{
3150 if (!fArrayPNE && !InitArrayPNE()) return 0;
3151 return (TGeoPNEntry*)fArrayPNE->At(index);
3152}
3153
3154////////////////////////////////////////////////////////////////////////////////
3155/// Retrieves an existing alignable object having a preset UID.
3156
3158{
3159 if (!fNPNEId || (!fArrayPNE && !InitArrayPNE())) return NULL;
3161 if (index<0 || fKeyPNEId[index]!=uid) return NULL;
3162 return (TGeoPNEntry*)fArrayPNE->At(fValuePNEId[index]);
3163}
3164
3165////////////////////////////////////////////////////////////////////////////////
3166/// Retrieves number of PN entries with or without UID.
3167
3169{
3170 if (!fHashPNE) return 0;
3171 if (with_uid) return fNPNEId;
3172 return fHashPNE->GetSize();
3173}
3174
3175////////////////////////////////////////////////////////////////////////////////
3176/// Insert a PN entry in the sorted array of indexes.
3177
3179{
3180 if (!fSizePNEId) {
3181 // Create the arrays.
3182 fSizePNEId = 128;
3183 fKeyPNEId = new Int_t[fSizePNEId];
3184 memset(fKeyPNEId, 0, fSizePNEId*sizeof(Int_t));
3186 memset(fValuePNEId, 0, fSizePNEId*sizeof(Int_t));
3187 fKeyPNEId[fNPNEId] = uid;
3188 fValuePNEId[fNPNEId++] = ientry;
3189 return kTRUE;
3190 }
3191 // Search id in the existing array and return false if it already exists.
3193 if (index>0 && fKeyPNEId[index]==uid) return kFALSE;
3194 // Resize the arrays and insert the value
3195 Bool_t resize = (fNPNEId==fSizePNEId)?kTRUE:kFALSE;
3196 if (resize) {
3197 // Double the size of the array
3198 fSizePNEId *= 2;
3199 // Create new arrays of keys and values
3200 Int_t *keys = new Int_t[fSizePNEId];
3201 memset(keys, 0, fSizePNEId*sizeof(Int_t));
3202 Int_t *values = new Int_t[fSizePNEId];
3203 memset(values, 0, fSizePNEId*sizeof(Int_t));
3204 // Copy all keys<uid in the new keys array (0 to index)
3205 memcpy(keys, fKeyPNEId, (index+1)*sizeof(Int_t));
3206 memcpy(values, fValuePNEId, (index+1)*sizeof(Int_t));
3207 // Insert current key at index+1
3208 keys[index+1] = uid;
3209 values[index+1] = ientry;
3210 // Copy all remaining keys from the old to new array
3211 memcpy(&keys[index+2], &fKeyPNEId[index+1], (fNPNEId-index-1)*sizeof(Int_t));
3212 memcpy(&values[index+2], &fValuePNEId[index+1], (fNPNEId-index-1)*sizeof(Int_t));
3213 delete [] fKeyPNEId;
3214 fKeyPNEId = keys;
3215 delete [] fValuePNEId;
3216 fValuePNEId = values;
3217 fNPNEId++;
3218 return kTRUE;
3219 }
3220 // Insert the value in the existing arrays
3221 Int_t i;
3222 for (i=fNPNEId-1; i>index; i--) {
3223 fKeyPNEId[i+1] = fKeyPNEId[i];
3224 fValuePNEId[i+1] = fValuePNEId[i];
3225 }
3226 fKeyPNEId[index+1] = uid;
3227 fValuePNEId[index+1] = ientry;
3228 fNPNEId++;
3229 return kTRUE;
3230}
3231
3232////////////////////////////////////////////////////////////////////////////////
3233/// Make a physical node from the path pointed by an alignable object with a given name.
3234
3236{
3238 if (!entry) {
3239 Error("MakeAlignablePN","No alignable object named %s found !", name);
3240 return 0;
3241 }
3242 return MakeAlignablePN(entry);
3243}
3244
3245////////////////////////////////////////////////////////////////////////////////
3246/// Make a physical node from the path pointed by a given alignable object.
3247
3249{
3250 if (!entry) {
3251 Error("MakeAlignablePN","No alignable object specified !");
3252 return 0;
3253 }
3254 const char *path = entry->GetTitle();
3255 if (!cd(path)) {
3256 Error("MakeAlignablePN", "Alignable object %s poins to invalid path: %s",
3257 entry->GetName(), path);
3258 return 0;
3259 }
3260 TGeoPhysicalNode *node = MakePhysicalNode(path);
3261 entry->SetPhysicalNode(node);
3262 return node;
3263}
3264
3265////////////////////////////////////////////////////////////////////////////////
3266/// Makes a physical node corresponding to a path. If PATH is not specified,
3267/// makes physical node matching current modeller state.
3268
3270{
3271 TGeoPhysicalNode *node;
3272 if (path) {
3273 if (!CheckPath(path)) {
3274 Error("MakePhysicalNode", "path: %s not valid", path);
3275 return NULL;
3276 }
3277 node = new TGeoPhysicalNode(path);
3278 } else {
3279 node = new TGeoPhysicalNode(GetPath());
3280 }
3281 fPhysicalNodes->Add(node);
3282 return node;
3283}
3284
3285////////////////////////////////////////////////////////////////////////////////
3286/// Refresh physical nodes to reflect the actual geometry paths after alignment
3287/// was applied. Optionally locks physical nodes (default).
3288
3290{
3292 TGeoPhysicalNode *pn;
3293 while ((pn=(TGeoPhysicalNode*)next())) pn->Refresh();
3295 if (lock) LockGeometry();
3296}
3297
3298////////////////////////////////////////////////////////////////////////////////
3299/// Clear the current list of physical nodes, so that we can start over with a new list.
3300/// If MUSTDELETE is true, delete previous nodes.
3301
3303{
3304 if (mustdelete) fPhysicalNodes->Delete();
3305 else fPhysicalNodes->Clear();
3306}
3307
3308////////////////////////////////////////////////////////////////////////////////
3309/// Make an assembly of volumes.
3310
3312{
3314}
3315
3316////////////////////////////////////////////////////////////////////////////////
3317/// Make a TGeoVolumeMulti handling a list of volumes.
3318
3320{
3321 return TGeoBuilder::Instance(this)->MakeVolumeMulti(name, medium);
3322}
3323
3324////////////////////////////////////////////////////////////////////////////////
3325/// Set type of exploding view (see TGeoPainter::SetExplodedView())
3326
3328{
3329 if ((ibomb>=0) && (ibomb<4)) fExplodedView = ibomb;
3330 if (fPainter) fPainter->SetExplodedView(ibomb);
3331}
3332
3333////////////////////////////////////////////////////////////////////////////////
3334/// Set cut phi range
3335
3337{
3338 if ((phimin==0) && (phimax==360)) {
3339 fPhiCut = kFALSE;
3340 return;
3341 }
3342 fPhiCut = kTRUE;
3343 fPhimin = phimin;
3344 fPhimax = phimax;
3345}
3346
3347////////////////////////////////////////////////////////////////////////////////
3348/// Set number of segments for approximating circles in drawing.
3349
3351{
3352 if (fNsegments==nseg) return;
3353 if (nseg>2) fNsegments = nseg;
3354 if (fPainter) fPainter->SetNsegments(nseg);
3355}
3356
3357////////////////////////////////////////////////////////////////////////////////
3358/// Get number of segments approximating circles
3359
3361{
3362 return fNsegments;
3363}
3364
3365////////////////////////////////////////////////////////////////////////////////
3366/// Now just a shortcut for GetElementTable.
3367
3369{
3372}
3373
3374////////////////////////////////////////////////////////////////////////////////
3375/// Returns material table. Creates it if not existing.
3376
3378{
3380 return fElementTable;
3381}
3382
3383////////////////////////////////////////////////////////////////////////////////
3384/// Make a rectilinear step of length fStep from current point (fPoint) on current
3385/// direction (fDirection). If the step is imposed by geometry, is_geom flag
3386/// must be true (default). The cross flag specifies if the boundary should be
3387/// crossed in case of a geometry step (default true). Returns new node after step.
3388/// Set also on boundary condition.
3389
3391{
3392 return GetCurrentNavigator()->Step(is_geom, cross);
3393}
3394
3395////////////////////////////////////////////////////////////////////////////////
3396/// shoot npoints randomly in a box of 1E-5 around current point.
3397/// return minimum distance to points outside
3398
3400 const char* g3path)
3401{
3402 return GetGeomPainter()->SamplePoints(npoints, dist, epsil, g3path);
3403}
3404
3405////////////////////////////////////////////////////////////////////////////////
3406/// Set the top volume and corresponding node as starting point of the geometry.
3407
3409{
3410 if (fTopVolume==vol) return;
3411
3412 TSeqCollection *brlist = gROOT->GetListOfBrowsers();
3413 TIter next(brlist);
3414 TBrowser *browser = 0;
3415
3416 if (fTopVolume) fTopVolume->SetTitle("");
3417 fTopVolume = vol;
3418 vol->SetTitle("Top volume");
3419 if (fTopNode) {
3420 TGeoNode *topn = fTopNode;
3421 fTopNode = 0;
3422 while ((browser=(TBrowser*)next())) browser->RecursiveRemove(topn);
3423 delete topn;
3424 } else {
3425 fMasterVolume = vol;
3428 if (fgVerboseLevel>0) Info("SetTopVolume","Top volume is %s. Master volume is %s", fTopVolume->GetName(),
3430 }
3431// fMasterVolume->FindMatrixOfDaughterVolume(vol);
3432// fCurrentMatrix->Print();
3434 fTopNode->SetName(TString::Format("%s_1",vol->GetName()));
3435 fTopNode->SetNumber(1);
3436 fTopNode->SetTitle("Top logical node");
3437 fNodes->AddAt(fTopNode, 0);
3438 if (!GetCurrentNavigator()) {
3440 return;
3441 }
3442 Int_t nnavigators = 0;
3444 if (!arr) return;
3445 nnavigators = arr->GetEntriesFast();
3446 for (Int_t i=0; i<nnavigators; i++) {
3447 TGeoNavigator *nav = (TGeoNavigator*)arr->At(i);
3448 nav->ResetAll();
3449 if (fClosed) nav->GetCache()->BuildInfoBranch();
3450 }
3451}
3452
3453////////////////////////////////////////////////////////////////////////////////
3454/// Define different tracking media.
3455
3457{
3458/*
3459 Int_t nmat = fMaterials->GetSize();
3460 if (!nmat) {printf(" No materials !\n"); return;}
3461 Int_t *media = new Int_t[nmat];
3462 memset(media, 0, nmat*sizeof(Int_t));
3463 Int_t imedia = 1;
3464 TGeoMaterial *mat, *matref;
3465 mat = (TGeoMaterial*)fMaterials->At(0);
3466 if (mat->GetMedia()) {
3467 for (Int_t i=0; i<nmat; i++) {
3468 mat = (TGeoMaterial*)fMaterials->At(i);
3469 mat->Print();
3470 }
3471 return;
3472 }
3473 mat->SetMedia(imedia);
3474 media[0] = imedia++;
3475 mat->Print();
3476 for (Int_t i=0; i<nmat; i++) {
3477 mat = (TGeoMaterial*)fMaterials->At(i);
3478 for (Int_t j=0; j<i; j++) {
3479 matref = (TGeoMaterial*)fMaterials->At(j);
3480 if (mat->IsEq(matref)) {
3481 mat->SetMedia(media[j]);
3482 break;
3483 }
3484 if (j==(i-1)) {
3485 // different material
3486 mat->SetMedia(imedia);
3487 media[i] = imedia++;
3488 mat->Print();
3489 }
3490 }
3491 }
3492*/
3493}
3494
3495////////////////////////////////////////////////////////////////////////////////
3496/// Check pushes and pulls needed to cross the next boundary with respect to the
3497/// position given by FindNextBoundary. If radius is not mentioned the full bounding
3498/// box will be sampled.
3499
3501{
3502 GetGeomPainter()->CheckBoundaryErrors(ntracks, radius);
3503}
3504
3505////////////////////////////////////////////////////////////////////////////////
3506/// Check the boundary errors reference file created by CheckBoundaryErrors method.
3507/// The shape for which the crossing failed is drawn with the starting point in red
3508/// and the extrapolated point to boundary (+/- failing push/pull) in yellow.
3509
3511{
3513}
3514
3515////////////////////////////////////////////////////////////////////////////////
3516/// Classify a given point. See TGeoChecker::CheckPoint().
3517
3519{
3520 GetGeomPainter()->CheckPoint(x,y,z,option);
3521}
3522
3523////////////////////////////////////////////////////////////////////////////////
3524/// Test for shape navigation methods. Summary for test numbers:
3525/// - 1: DistFromInside/Outside. Sample points inside the shape. Generate
3526/// directions randomly in cos(theta). Compute DistFromInside and move the
3527/// point with bigger distance. Compute DistFromOutside back from new point.
3528/// Plot d-(d1+d2)
3529///
3530
3531void TGeoManager::CheckShape(TGeoShape *shape, Int_t testNo, Int_t nsamples, Option_t *option)
3532{
3533 GetGeomPainter()->CheckShape(shape, testNo, nsamples, option);
3534}
3535
3536////////////////////////////////////////////////////////////////////////////////
3537/// Geometry checking.
3538/// - if option contains 'o': Optional overlap checkings (by sampling and by mesh).
3539/// - if option contains 'b': Optional boundary crossing check + timing per volume.
3540///
3541/// STAGE 1: extensive overlap checking by sampling per volume. Stdout need to be
3542/// checked by user to get report, then TGeoVolume::CheckOverlaps(0.01, "s") can
3543/// be called for the suspicious volumes.
3544///
3545/// STAGE 2: normal overlap checking using the shapes mesh - fills the list of
3546/// overlaps.
3547///
3548/// STAGE 3: shooting NRAYS rays from VERTEX and counting the total number of
3549/// crossings per volume (rays propagated from boundary to boundary until
3550/// geometry exit). Timing computed and results stored in a histo.
3551///
3552/// STAGE 4: shooting 1 mil. random rays inside EACH volume and calling
3553/// FindNextBoundary() + Safety() for each call. The timing is normalized by the
3554/// number of crossings computed at stage 2 and presented as percentage.
3555/// One can get a picture on which are the most "burned" volumes during
3556/// transportation from geometry point of view. Another plot of the timing per
3557/// volume vs. number of daughters is produced.
3558
3560{
3561 TString opt(option);
3562 opt.ToLower();
3563 if (!opt.Length()) {
3564 Error("CheckGeometryFull","The option string must contain a letter. See method documentation.");
3565 return;
3566 }
3567 Bool_t checkoverlaps = opt.Contains("o");
3568 Bool_t checkcrossings = opt.Contains("b");
3569 Double_t vertex[3];
3570 vertex[0] = vx;
3571 vertex[1] = vy;
3572 vertex[2] = vz;
3573 GetGeomPainter()->CheckGeometryFull(checkoverlaps,checkcrossings,ntracks,vertex);
3574}
3575
3576////////////////////////////////////////////////////////////////////////////////
3577/// Perform last checks on the geometry
3578
3580{
3581 if (fgVerboseLevel>0) Info("CheckGeometry","Fixing runtime shapes...");
3582 TIter next(fShapes);
3583 TIter nextv(fVolumes);
3584 TGeoShape *shape;
3585 TGeoVolume *vol;
3586 Bool_t has_runtime = kFALSE;
3587 while ((shape = (TGeoShape*)next())) {
3588 if (shape->IsRunTimeShape()) {
3589 has_runtime = kTRUE;
3590 }
3591 if (fIsGeomReading) shape->AfterStreamer();
3594 }
3595 if (has_runtime) fTopNode->CheckShapes();
3596 else if (fgVerboseLevel>0) Info("CheckGeometry","...Nothing to fix");
3597 // Compute bounding box for assemblies
3599 while ((vol = (TGeoVolume*)nextv())) {
3600 if (vol->IsAssembly()) vol->GetShape()->ComputeBBox();
3601 else if (vol->GetMedium() == dummy) {
3602 Warning("CheckGeometry", "Volume \"%s\" has no medium: assigned dummy medium and material", vol->GetName());
3603 vol->SetMedium(dummy);
3604 }
3605 }
3606}
3607
3608////////////////////////////////////////////////////////////////////////////////
3609/// Check all geometry for illegal overlaps within a limit OVLP.
3610
3612{
3613 if (!fTopNode) {
3614 Error("CheckOverlaps","Top node not set");
3615 return;
3616 }
3617 fTopNode->CheckOverlaps(ovlp,option);
3618}
3619
3620////////////////////////////////////////////////////////////////////////////////
3621/// Prints the current list of overlaps.
3622
3624{
3625 if (!fOverlaps) return;
3626 Int_t novlp = fOverlaps->GetEntriesFast();
3627 if (!novlp) return;
3628 TGeoManager *geom = (TGeoManager*)this;
3629 geom->GetGeomPainter()->PrintOverlaps();
3630}
3631
3632////////////////////////////////////////////////////////////////////////////////
3633/// Estimate weight of volume VOL with a precision SIGMA(W)/W better than PRECISION.
3634/// Option can be "v" - verbose (default)
3635
3637{
3639 TString opt(option);
3640 opt.ToLower();
3641 Double_t weight;
3642 TGeoVolume *volume = fTopVolume;
3643 if (opt.Contains("v")) {
3644 if (opt.Contains("a")) {
3645 if (fgVerboseLevel>0) Info("Weight", "Computing analytically weight of %s", volume->GetName());
3646 weight = volume->WeightA();
3647 if (fgVerboseLevel>0) Info("Weight", "Computed weight: %f [kg]\n", weight);
3648 return weight;
3649 }
3650 if (fgVerboseLevel>0) {
3651 Info("Weight", "Estimating weight of %s with %g %% precision", fTopVolume->GetName(), 100.*precision);
3652 printf(" event weight err\n");
3653 printf("========================================\n");
3654 }
3655 }
3656 weight = fPainter->Weight(precision, option);
3657 return weight;
3658}
3659
3660////////////////////////////////////////////////////////////////////////////////
3661/// computes the total size in bytes of the branch starting with node.
3662/// The option can specify if all the branch has to be parsed or only the node
3663
3664ULong_t TGeoManager::SizeOf(const TGeoNode * /*node*/, Option_t * /*option*/)
3665{
3666 return 0;
3667}
3668
3669////////////////////////////////////////////////////////////////////////////////
3670/// Stream an object of class TGeoManager.
3671
3672void TGeoManager::Streamer(TBuffer &R__b)
3673{
3674 if (R__b.IsReading()) {
3675 R__b.ReadClassBuffer(TGeoManager::Class(), this);
3677 CloseGeometry();
3680 } else {
3681 R__b.WriteClassBuffer(TGeoManager::Class(), this);
3682 }
3683}
3684
3685////////////////////////////////////////////////////////////////////////////////
3686/// Execute mouse actions on this manager.
3687
3689{
3690 if (!fPainter) return;
3691 fPainter->ExecuteManagerEvent(this, event, px, py);
3692}
3693
3694////////////////////////////////////////////////////////////////////////////////
3695/// Export this geometry to a file
3696///
3697/// - Case 1: root file or root/xml file
3698/// if filename end with ".root". The key will be named name
3699/// By default the geometry is saved without the voxelisation info.
3700/// Use option 'v" to save the voxelisation info.
3701/// if filename end with ".xml" a root/xml file is produced.
3702///
3703/// - Case 2: C++ script
3704/// if filename end with ".C"
3705///
3706/// - Case 3: gdml file
3707/// if filename end with ".gdml"
3708/// NOTE that to use this option, the PYTHONPATH must be defined like
3709/// export PYTHONPATH=$ROOTSYS/lib:$ROOTSYS/geom/gdml
3710///
3711
3712Int_t TGeoManager::Export(const char *filename, const char *name, Option_t *option)
3713{
3714 TString sfile(filename);
3715 if (sfile.Contains(".C")) {
3716 //Save geometry as a C++ script
3717 if (fgVerboseLevel>0) Info("Export","Exporting %s %s as C++ code", GetName(), GetTitle());
3718 fTopVolume->SaveAs(filename);
3719 return 1;
3720 }
3721 if (sfile.Contains(".gdml")) {
3722 //Save geometry as a gdml file
3723 if (fgVerboseLevel>0) Info("Export","Exporting %s %s as gdml code", GetName(), GetTitle());
3724 //C++ version
3725 TString cmd ;
3726 cmd = TString::Format("TGDMLWrite::StartGDMLWriting(gGeoManager,\"%s\",\"%s\")", filename, option);
3727 gROOT->ProcessLineFast(cmd);
3728 return 1;
3729 }
3730 if (sfile.Contains(".root") || sfile.Contains(".xml")) {
3731 //Save geometry as a root file
3732 TFile *f = TFile::Open(filename,"recreate");
3733 if (!f || f->IsZombie()) {
3734 Error("Export","Cannot open file");
3735 return 0;
3736 }
3737 TString keyname = name;
3738 if (keyname.IsNull()) keyname = GetName();
3739 TString opt = option;
3740 opt.ToLower();
3741 if (opt.Contains("v")) {
3743 if (fgVerboseLevel>0) Info("Export","Exporting %s %s as root file. Optimizations streamed.", GetName(), GetTitle());
3744 } else {
3746 if (fgVerboseLevel>0) Info("Export","Exporting %s %s as root file. Optimizations not streamed.", GetName(), GetTitle());
3747 }
3748
3749 const char *precision_dbl = TBufferText::GetDoubleFormat();
3750 const char *precision_flt = TBufferText::GetFloatFormat();
3751 TString new_format_dbl = TString::Format("%%.%dg", TGeoManager::GetExportPrecision());
3752 if (sfile.Contains(".xml")) {
3753 TBufferText::SetDoubleFormat(new_format_dbl.Data());
3754 TBufferText::SetFloatFormat(new_format_dbl.Data());
3755 }
3756 Int_t nbytes = Write(keyname);
3757 if (sfile.Contains(".xml")) {
3758 TBufferText::SetFloatFormat(precision_dbl);
3759 TBufferText::SetDoubleFormat(precision_flt);
3760 }
3761
3763 delete f;
3764 return nbytes;
3765 }
3766 return 0;
3767}
3768
3769////////////////////////////////////////////////////////////////////////////////
3770/// Lock current geometry so that no other geometry can be imported.
3771
3773{
3774 fgLock = kTRUE;
3775}
3776
3777////////////////////////////////////////////////////////////////////////////////
3778/// Unlock current geometry.
3779
3781{
3782 fgLock = kFALSE;
3783}
3784
3785////////////////////////////////////////////////////////////////////////////////
3786/// Check lock state.
3787
3789{
3790 return fgLock;
3791}
3792
3793////////////////////////////////////////////////////////////////////////////////
3794/// Set verbosity level (static function).
3795/// - 0 - suppress messages related to geom-painter visibility level
3796/// - 1 - default value
3797
3799{
3800 return fgVerboseLevel;
3801}
3802
3803////////////////////////////////////////////////////////////////////////////////
3804/// Return current verbosity level (static function).
3805
3807{
3808 fgVerboseLevel = vl;
3809}
3810
3811////////////////////////////////////////////////////////////////////////////////
3812///static function
3813///Import a geometry from a gdml or ROOT file
3814///
3815/// - Case 1: gdml
3816/// if filename ends with ".gdml" the foreign geometry described with gdml
3817/// is imported executing some python scripts in $ROOTSYS/gdml.
3818/// NOTE that to use this option, the PYTHONPATH must be defined like
3819/// export PYTHONPATH=$ROOTSYS/lib:$ROOTSYS/gdml
3820///
3821/// - Case 2: root file (.root) or root/xml file (.xml)
3822/// Import in memory from filename the geometry with key=name.
3823/// if name="" (default), the first TGeoManager object in the file is returned.
3824///
3825/// Note that this function deletes the current gGeoManager (if one)
3826/// before importing the new object.
3827
3828TGeoManager *TGeoManager::Import(const char *filename, const char *name, Option_t * /*option*/)
3829{
3830 if (fgLock) {
3831 ::Warning("TGeoManager::Import", "TGeoMananager in lock mode. NOT IMPORTING new geometry");
3832 return NULL;
3833 }
3834 if (!filename) return 0;
3835 if (fgVerboseLevel>0) ::Info("TGeoManager::Import","Reading geometry from file: %s",filename);
3836
3837 if (gGeoManager) delete gGeoManager;
3838 gGeoManager = 0;
3839
3840 if (strstr(filename,".gdml")) {
3841 // import from a gdml file
3842 new TGeoManager("GDMLImport", "Geometry imported from GDML");
3843 TString cmd = TString::Format("TGDMLParse::StartGDML(\"%s\")", filename);
3844 TGeoVolume* world = (TGeoVolume*)gROOT->ProcessLineFast(cmd);
3845
3846 if(world == 0) {
3847 ::Error("TGeoManager::Import", "Cannot open file");
3848 }
3849 else {
3850 gGeoManager->SetTopVolume(world);
3853 }
3854 } else {
3855 // import from a root file
3857 // in case a web file is specified, use the cacheread option to cache
3858 // this file in the cache directory
3859 TFile *f = 0;
3860 if (strstr(filename,"http")) f = TFile::Open(filename,"CACHEREAD");
3861 else f = TFile::Open(filename);
3862 if (!f || f->IsZombie()) {
3863 ::Error("TGeoManager::Import", "Cannot open file");
3864 return 0;
3865 }
3866 if (name && strlen(name) > 0) {
3867 gGeoManager = (TGeoManager*)f->Get(name);
3868 } else {
3869 TIter next(f->GetListOfKeys());
3870 TKey *key;
3871 while ((key = (TKey*)next())) {
3872 if (strcmp(key->GetClassName(),"TGeoManager") != 0) continue;
3873 gGeoManager = (TGeoManager*)key->ReadObj();
3874 break;
3875 }
3876 }
3877 delete f;
3878 }
3879 if (!gGeoManager) return 0;
3880 if (!gROOT->GetListOfGeometries()->FindObject(gGeoManager)) gROOT->GetListOfGeometries()->Add(gGeoManager);
3881 if (!gROOT->GetListOfBrowsables()->FindObject(gGeoManager)) gROOT->GetListOfBrowsables()->Add(gGeoManager);
3883 return gGeoManager;
3884}
3885
3886////////////////////////////////////////////////////////////////////////////////
3887/// Update element flags when geometry is loaded from a file.
3888
3890{
3891 if (!fElementTable) return;
3892 TIter next(fMaterials);
3893 TGeoMaterial *mat;
3894 TGeoMixture *mix;
3895 TGeoElement *elem, *elem_table;
3896 Int_t i, nelem;
3897 while ((mat=(TGeoMaterial*)next())) {
3898 if (mat->IsMixture()) {
3899 mix = (TGeoMixture*)mat;
3900 nelem = mix->GetNelements();
3901 for (i=0; i<nelem; i++) {
3902 elem = mix->GetElement(i);
3903 if (!elem) continue;
3904 elem_table = fElementTable->GetElement(elem->Z());
3905 if (!elem_table) continue;
3906 if (elem != elem_table) {
3907 elem_table->SetDefined(elem->IsDefined());
3908 elem_table->SetUsed(elem->IsUsed());
3909 } else {
3910 elem_table->SetDefined();
3911 }
3912 }
3913 } else {
3914 elem = mat->GetElement();
3915 if (!elem) continue;
3916 elem_table = fElementTable->GetElement(elem->Z());
3917 if (!elem_table) continue;
3918 if (elem != elem_table) {
3919 elem_table->SetDefined(elem->IsDefined());
3920 elem_table->SetUsed(elem->IsUsed());
3921 } else {
3922 elem_table->SetUsed();
3923 }
3924 }
3925 }
3926}
3927
3928////////////////////////////////////////////////////////////////////////////////
3929/// Initialize PNE array for fast access via index and unique-id.
3930
3932{
3933 if (fHashPNE) {
3935 TIter next(fHashPNE);
3936 TObject *obj;
3937 while ((obj = next())) {
3938 fArrayPNE->Add(obj);
3939 }
3940 return kTRUE;
3941 }
3942 return kFALSE;
3943}
3944
3945////////////////////////////////////////////////////////////////////////////////
3946/// Get time cut for drawing tracks.
3947
3949{
3950 tmin = fTmin;
3951 tmax = fTmax;
3952 return fTimeCut;
3953}
3954
3955////////////////////////////////////////////////////////////////////////////////
3956/// Set time cut interval for drawing tracks. If called with no arguments, time
3957/// cut will be disabled.
3958
3960{
3961 fTmin = tmin;
3962 fTmax = tmax;
3963 if (tmin==0 && tmax==999) fTimeCut = kFALSE;
3964 else fTimeCut = kTRUE;
3966}
3967
3968////////////////////////////////////////////////////////////////////////////////
3969/// Convert coordinates from master volume frame to top.
3970
3971void TGeoManager::MasterToTop(const Double_t *master, Double_t *top) const
3972{
3973 GetCurrentNavigator()->MasterToLocal(master, top);
3974}
3975
3976////////////////////////////////////////////////////////////////////////////////
3977/// Convert coordinates from top volume frame to master.
3978
3979void TGeoManager::TopToMaster(const Double_t *top, Double_t *master) const
3980{
3981 GetCurrentNavigator()->LocalToMaster(top, master);
3982}
3983
3984////////////////////////////////////////////////////////////////////////////////
3985/// Create a parallel world for prioritised navigation. This can be populated
3986/// with physical nodes and can be navigated independently using its API.
3987/// In case the flag SetUseParallelWorldNav is set, any navigation query in the
3988/// main geometry is checked against the parallel geometry, which gets priority
3989/// in case of overlaps with the main geometry volumes.
3990
3992{
3994 return fParallelWorld;
3995}
3996
3997////////////////////////////////////////////////////////////////////////////////
3998/// Activate/deactivate usage of parallel world navigation. Can only be done if
3999/// there is a parallel world. Activating navigation will automatically close
4000/// the parallel geometry.
4001
4003{
4004 if (!fParallelWorld) {
4005 Error("SetUseParallelWorldNav", "No parallel world geometry defined. Use CreateParallelWorld.");
4006 return;
4007 }
4008 if (!flag) {
4009 fUsePWNav = flag;
4010 return;
4011 }
4012 if (!fClosed) {
4013 Error("SetUseParallelWorldNav", "The geometry must be closed first");
4014 return;
4015 }
4016 // Closing the parallel world geometry is mandatory
4018}
4019
4021 Bool_t val = gGeometryLocked;
4022 gGeometryLocked = new_value;
4023 return val;
4024}
4025
4027{
4028 return fgDefaultUnits;
4029}
4030
4032{
4033 if ( fgDefaultUnits == new_value ) {
4034 return;
4035 }
4036 else if ( gGeometryLocked ) {
4037 ::Fatal("TGeoManager","The system of units may only be changed once, \n"
4038 "BEFORE any elements and materials are created! \n"
4039 "Alternatively unlock the default units at own risk.");
4040 }
4041 else if ( new_value == kG4Units ) {
4042 ::Warning("TGeoManager","Changing system of units to Geant4 units (mm, ns, MeV).");
4043 }
4044 else if ( new_value == kRootUnits ) {
4045 ::Warning("TGeoManager","Changing system of units to ROOT units (cm, s, GeV).");
4046 }
4047 fgDefaultUnits = new_value;
4048}
ROOT::R::TRInterface & r
Definition Object.C:4
#define SafeDelete(p)
Definition RConfig.hxx:547
#define b(i)
Definition RSha256.hxx:100
#define f(i)
Definition RSha256.hxx:104
#define a(i)
Definition RSha256.hxx:99
#define h(i)
Definition RSha256.hxx:106
int Int_t
Definition RtypesCore.h:45
unsigned char UChar_t
Definition RtypesCore.h:38
unsigned int UInt_t
Definition RtypesCore.h:46
const Bool_t kFALSE
Definition RtypesCore.h:92
unsigned long ULong_t
Definition RtypesCore.h:55
bool Bool_t
Definition RtypesCore.h:63
double Double_t
Definition RtypesCore.h:59
float Float_t
Definition RtypesCore.h:57
const Bool_t kTRUE
Definition RtypesCore.h:91
const char Option_t
Definition RtypesCore.h:66
#define BIT(n)
Definition Rtypes.h:85
#define ClassImp(name)
Definition Rtypes.h:364
@ kGray
Definition Rtypes.h:65
@ kRed
Definition Rtypes.h:66
@ kOrange
Definition Rtypes.h:67
@ kGreen
Definition Rtypes.h:66
@ kMagenta
Definition Rtypes.h:66
@ kBlue
Definition Rtypes.h:66
@ kYellow
Definition Rtypes.h:66
R__EXTERN TEnv * gEnv
Definition TEnv.h:171
XFontStruct * id
Definition TGX11.cxx:109
char name[80]
Definition TGX11.cxx:110
TGeoManager * gGeoManager
static Bool_t gGeometryLocked
R__EXTERN TGeoManager * gGeoManager
R__EXTERN TGeoIdentity * gGeoIdentity
Definition TGeoMatrix.h:478
int nentries
#define gROOT
Definition TROOT.h:406
R__EXTERN TStyle * gStyle
Definition TStyle.h:412
#define gPad
virtual void SetFillColor(Color_t fcolor)
Set the fill area color.
Definition TAttFill.h:37
Using a TBrowser one can browse all ROOT objects.
Definition TBrowser.h:37
virtual void RecursiveRemove(TObject *obj)
Recursively remove obj from browser.
Definition TBrowser.cxx:377
static const char * GetFloatFormat()
return current printf format for float members, default "%e"
static void SetFloatFormat(const char *fmt="%e")
set printf format for float/double members, default "%e" to change format only for doubles,...
static const char * GetDoubleFormat()
return current printf format for double members, default "%.14e"
static void SetDoubleFormat(const char *fmt="%.14e")
set printf format for double members, default "%.14e" use it after SetFloatFormat,...
Buffer base class used for serializing objects.
Definition TBuffer.h:43
virtual Int_t ReadClassBuffer(const TClass *cl, void *pointer, const TClass *onfile_class=0)=0
Bool_t IsReading() const
Definition TBuffer.h:86
virtual Int_t WriteClassBuffer(const TClass *cl, void *pointer)=0
@ kRealNew
Definition TClass.h:107
@ kDummyNew
Definition TClass.h:107
static ENewType IsCallingNew()
Static method returning the defConstructor flag passed to TClass::New().
Definition TClass.cxx:5879
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
This class stores the date and time with a precision of one second in an unsigned 32 bit word (950130...
Definition TDatime.h:37
const char * AsString() const
Return the date & time as a string (ctime() format).
Definition TDatime.cxx:102
Small helper to keep current directory context.
Definition TDirectory.h:52
virtual Int_t GetValue(const char *name, Int_t dflt) const
Returns the integer value for a resource.
Definition TEnv.cxx:491
A ROOT file is a suite of consecutive data records (TKey instances) with a well defined format.
Definition TFile.h:54
static TFile * Open(const char *name, Option_t *option="", const char *ftitle="", Int_t compress=ROOT::RCompressionSetting::EDefaults::kUseCompiledDefault, Int_t netopt=0)
Create / open a file.
Definition TFile.cxx:3997
This class is used in the process of reading and writing the GDML "matrix" tag.
Definition TGDMLMatrix.h:34
Bool_t IsVisTouched() const
Definition TGeoAtt.h:96
void SetVisStreamed(Bool_t vis=kTRUE)
Mark attributes as "streamed to file".
Definition TGeoAtt.cxx:123
void SetVisTouched(Bool_t vis=kTRUE)
Mark visualization attributes as "modified".
Definition TGeoAtt.cxx:131
void SetVisBranch()
Set branch type visibility.
Definition TGeoAtt.cxx:67
Box class.
Definition TGeoBBox.h:18
void Node(const char *name, Int_t nr, const char *mother, Double_t x, Double_t y, Double_t z, Int_t irot, Bool_t isOnly, Float_t *upar, Int_t npar=0)
Create a node called <name_nr> pointing to the volume called <name> as daughter of the volume called ...
TGeoVolume * MakePgon(const char *name, TGeoMedium *medium, Double_t phi, Double_t dphi, Int_t nedges, Int_t nz)
Make in one step a volume pointing to a polygone shape with given medium.
TGeoVolume * MakeGtra(const char *name, TGeoMedium *medium, Double_t dz, Double_t theta, Double_t phi, Double_t twist, Double_t h1, Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Double_t bl2, Double_t tl2, Double_t alpha2)
Make in one step a volume pointing to a twisted trapezoid shape with given medium.
TGeoVolume * MakeXtru(const char *name, TGeoMedium *medium, Int_t nz)
Make a TGeoXtru-shaped volume with nz planes.
TGeoVolume * MakePcon(const char *name, TGeoMedium *medium, Double_t phi, Double_t dphi, Int_t nz)
Make in one step a volume pointing to a polycone shape with given medium.
TGeoVolume * MakeTrap(const char *name, TGeoMedium *medium, Double_t dz, Double_t theta, Double_t phi, Double_t h1, Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Double_t bl2, Double_t tl2, Double_t alpha2)
Make in one step a volume pointing to a trapezoid shape with given medium.
Int_t AddShape(TGeoShape *shape)
Add a shape to the list. Returns index of the shape in list.
TGeoVolume * MakeTorus(const char *name, TGeoMedium *medium, Double_t r, Double_t rmin, Double_t rmax, Double_t phi1=0, Double_t dphi=360)
Make in one step a volume pointing to a torus shape with given medium.
static TGeoBuilder * Instance(TGeoManager *geom)
Return pointer to singleton.
TGeoVolume * MakeEltu(const char *name, TGeoMedium *medium, Double_t a, Double_t b, Double_t dz)
Make in one step a volume pointing to a tube shape with given medium.
TGeoVolume * MakeHype(const char *name, TGeoMedium *medium, Double_t rin, Double_t stin, Double_t rout, Double_t stout, Double_t dz)
Make in one step a volume pointing to a tube shape with given medium.
TGeoMaterial * Material(const char *name, Double_t a, Double_t z, Double_t dens, Int_t uid, Double_t radlen=0, Double_t intlen=0)
Create material with given A, Z and density, having an unique id.
TGeoVolume * MakeTube(const char *name, TGeoMedium *medium, Double_t rmin, Double_t rmax, Double_t dz)
Make in one step a volume pointing to a tube shape with given medium.
TGeoVolume * MakePara(const char *name, TGeoMedium *medium, Double_t dx, Double_t dy, Double_t dz, Double_t alpha, Double_t theta, Double_t phi)
Make in one step a volume pointing to a parallelepiped shape with given medium.
Int_t AddTransformation(TGeoMatrix *matrix)
Add a matrix to the list. Returns index of the matrix in list.
TGeoVolume * MakeSphere(const char *name, TGeoMedium *medium, Double_t rmin, Double_t rmax, Double_t themin=0, Double_t themax=180, Double_t phimin=0, Double_t phimax=360)
Make in one step a volume pointing to a sphere shape with given medium.
TGeoMedium * Medium(const char *name, Int_t numed, Int_t nmat, Int_t isvol, Int_t ifield, Double_t fieldm, Double_t tmaxfd, Double_t stemax, Double_t deemax, Double_t epsil, Double_t stmin)
Create tracking medium.
TGeoVolume * MakeTubs(const char *name, TGeoMedium *medium, Double_t rmin, Double_t rmax, Double_t dz, Double_t phi1, Double_t phi2)
Make in one step a volume pointing to a tube segment shape with given medium.
TGeoVolume * MakeBox(const char *name, TGeoMedium *medium, Double_t dx, Double_t dy, Double_t dz)
Make in one step a volume pointing to a box shape with given medium.
void Matrix(Int_t index, Double_t theta1, Double_t phi1, Double_t theta2, Double_t phi2, Double_t theta3, Double_t phi3)
Create rotation matrix named 'mat<index>'.
TGeoVolume * Division(const char *name, const char *mother, Int_t iaxis, Int_t ndiv, Double_t start, Double_t step, Int_t numed=0, Option_t *option="")
Create a new volume by dividing an existing one (GEANT3 like)
TGeoVolume * MakeParaboloid(const char *name, TGeoMedium *medium, Double_t rlo, Double_t rhi, Double_t dz)
Make in one step a volume pointing to a tube shape with given medium.
TGeoVolume * MakeTrd1(const char *name, TGeoMedium *medium, Double_t dx1, Double_t dx2, Double_t dy, Double_t dz)
Make in one step a volume pointing to a TGeoTrd1 shape with given medium.
TGeoVolumeAssembly * MakeVolumeAssembly(const char *name)
Make an assembly of volumes.
TGeoVolume * MakeCons(const char *name, TGeoMedium *medium, Double_t dz, Double_t rmin1, Double_t rmax1, Double_t rmin2, Double_t rmax2, Double_t phi1, Double_t phi2)
Make in one step a volume pointing to a cone segment shape with given medium.
Int_t AddMaterial(TGeoMaterial *material)
Add a material to the list. Returns index of the material in list.
TGeoVolumeMulti * MakeVolumeMulti(const char *name, TGeoMedium *medium)
Make a TGeoVolumeMulti handling a list of volumes.
TGeoVolume * MakeTrd2(const char *name, TGeoMedium *medium, Double_t dx1, Double_t dx2, Double_t dy1, Double_t dy2, Double_t dz)
Make in one step a volume pointing to a TGeoTrd2 shape with given medium.
TGeoVolume * MakeArb8(const char *name, TGeoMedium *medium, Double_t dz, Double_t *vertices=0)
Make an TGeoArb8 volume.
TGeoVolume * Volume(const char *name, const char *shape, Int_t nmed, Float_t *upar, Int_t npar=0)
Create a volume in GEANT3 style.
TGeoMaterial * Mixture(const char *name, Float_t *a, Float_t *z, Double_t dens, Int_t nelem, Float_t *wmat, Int_t uid)
Create mixture OR COMPOUND IMAT as composed by THE BASIC nelem materials defined by arrays A,...
TGeoVolume * MakeCone(const char *name, TGeoMedium *medium, Double_t dz, Double_t rmin1, Double_t rmax1, Double_t rmin2, Double_t rmax2)
Make in one step a volume pointing to a cone shape with given medium.
void RegisterMatrix(TGeoMatrix *matrix)
Register a matrix to the list of matrices.
TGeoVolume * MakeCtub(const char *name, TGeoMedium *medium, Double_t rmin, Double_t rmax, Double_t dz, Double_t phi1, Double_t phi2, Double_t lx, Double_t ly, Double_t lz, Double_t tx, Double_t ty, Double_t tz)
Make in one step a volume pointing to a tube segment shape with given medium.
Class describing rotation + translation.
Definition TGeoMatrix.h:292
Class handling Boolean composition of shapes.
Table of elements.
TGeoElement * GetElement(Int_t z)
Base class for chemical elements.
Definition TGeoElement.h:37
Bool_t IsDefined() const
Definition TGeoElement.h:86
void SetDefined(Bool_t flag=kTRUE)
Definition TGeoElement.h:90
Int_t Z() const
Definition TGeoElement.h:73
void SetUsed(Bool_t flag=kTRUE)
Definition TGeoElement.h:91
Bool_t IsUsed() const
Definition TGeoElement.h:88
Matrix class used for computing global transformations Should NOT be used for node definition.
Definition TGeoMatrix.h:421
An identity transformation.
Definition TGeoMatrix.h:384
A geometry iterator.
Definition TGeoNode.h:245
Int_t GetLevel() const
Definition TGeoNode.h:276
The manager class for any TGeo geometry.
Definition TGeoManager.h:45
static void UnlockGeometry()
Unlock current geometry.
Double_t fPhimax
lowest range for phi cut
Definition TGeoManager.h:67
TGeoVolume * MakeCone(const char *name, TGeoMedium *medium, Double_t dz, Double_t rmin1, Double_t rmax1, Double_t rmin2, Double_t rmax2)
Make in one step a volume pointing to a cone shape with given medium.
void AnimateTracks(Double_t tmin=0, Double_t tmax=5E-8, Int_t nframes=200, Option_t *option="/*")
Draw animation of tracks.
void AddSkinSurface(TGeoSkinSurface *surf)
Add skin surface;.
TGeoVolume * MakeXtru(const char *name, TGeoMedium *medium, Int_t nz)
Make a TGeoXtru-shaped volume with nz planes.
Double_t * FindNormalFast()
Computes fast normal to next crossed boundary, assuming that the current point is close enough to the...
TGeoVolume * MakePcon(const char *name, TGeoMedium *medium, Double_t phi, Double_t dphi, Int_t nz)
Make in one step a volume pointing to a polycone shape with given medium.
void Browse(TBrowser *b)
Describe how to browse this object.
Int_t fRaytraceMode
Flag for multi-threading.
Double_t fVisDensity
particles to be drawn
Definition TGeoManager.h:73
TGeoNavigator * AddNavigator()
Add a navigator in the list of navigators.
TVirtualGeoTrack * GetTrackOfId(Int_t id) const
Get track with a given ID.
TGeoMaterial * FindDuplicateMaterial(const TGeoMaterial *mat) const
Find if a given material duplicates an existing one.
TGeoVolume * Division(const char *name, const char *mother, Int_t iaxis, Int_t ndiv, Double_t start, Double_t step, Int_t numed=0, Option_t *option="")
Create a new volume by dividing an existing one (GEANT3 like)
TGeoVolume * Volume(const char *name, const char *shape, Int_t nmed, Float_t *upar, Int_t npar=0)
Create a volume in GEANT3 style.
Int_t ReplaceVolume(TGeoVolume *vorig, TGeoVolume *vnew)
Replaces all occurrences of VORIG with VNEW in the geometry tree.
void DoRestoreState()
Restore a backed-up state without affecting the cache stack.
Int_t GetCurrentNodeId() const
Get the unique ID of the current node.
TGeoNode * SearchNode(Bool_t downwards=kFALSE, const TGeoNode *skipnode=0)
Returns the deepest node containing fPoint, which must be set a priori.
TGeoPNEntry * GetAlignableEntry(const char *name) const
Retrieves an existing alignable object.
TGeoVolume * fMasterVolume
top physical node
TVirtualGeoTrack * FindTrackWithId(Int_t id) const
Search the track hierarchy to find the track with the given id.
TObjArray * fArrayPNE
virtual Int_t GetByteCount(Option_t *option=0)
Get total size of geometry in bytes.
void TestOverlaps(const char *path="")
Geometry overlap checker based on sampling.
static EDefaultUnits GetDefaultUnits()
void RemoveMaterial(Int_t index)
Remove material at given index.
Int_t CountNodes(const TGeoVolume *vol=0, Int_t nlevels=10000, Int_t option=0)
Count the total number of nodes starting from a volume, nlevels down.
void Matrix(Int_t index, Double_t theta1, Double_t phi1, Double_t theta2, Double_t phi2, Double_t theta3, Double_t phi3)
Create rotation matrix named 'mat<index>'.
TGeoElementTable * GetElementTable()
Returns material table. Creates it if not existing.
Int_t fNtracks
Definition TGeoManager.h:78
THashList * fHashPNE
hash list of group volumes providing fast search
TGeoVolume * MakeArb8(const char *name, TGeoMedium *medium, Double_t dz, Double_t *vertices=0)
Make an TGeoArb8 volume.
static Int_t fgVerboseLevel
Lock preventing a second geometry to be loaded.
Definition TGeoManager.h:55
void Init()
Initialize manager class.
Bool_t InitArrayPNE() const
Initialize PNE array for fast access via index and unique-id.
TObjArray * fPhysicalNodes
virtual ULong_t SizeOf(const TGeoNode *node, Option_t *option)
computes the total size in bytes of the branch starting with node.
TObjArray * fUniqueVolumes
static UInt_t fgExportPrecision
Maximum number of Xtru vertices.
Definition TGeoManager.h:59
TObjArray * fRegions
void Node(const char *name, Int_t nr, const char *mother, Double_t x, Double_t y, Double_t z, Int_t irot, Bool_t isOnly, Float_t *upar, Int_t npar=0)
Create a node called <name_nr> pointing to the volume called <name> as daughter of the volume called ...
TObjArray * fGShapes
TGeoVolume * fPaintVolume
TGeoSkinSurface * GetSkinSurface(const char *name) const
Get skin surface with a given name;.
void UpdateElements()
Update element flags when geometry is loaded from a file.
TGeoManager()
Default constructor.
ConstPropMap_t fProperties
TGeoVolume * MakeTube(const char *name, TGeoMedium *medium, Double_t rmin, Double_t rmax, Double_t dz)
Make in one step a volume pointing to a tube shape with given medium.
void CdUp()
Go one level up in geometry.
void DoBackupState()
Backup the current state without affecting the cache stack.
TList * fMaterials
void CheckBoundaryErrors(Int_t ntracks=1000000, Double_t radius=-1.)
Check pushes and pulls needed to cross the next boundary with respect to the position given by FindNe...
TObjArray * fVolumes
Definition TGeoManager.h:99
Int_t * fValuePNEId
TGeoPNEntry * GetAlignableEntryByUID(Int_t uid) const
Retrieves an existing alignable object having a preset UID.
void AddGDMLMatrix(TGDMLMatrix *mat)
Add GDML matrix;.
Bool_t fTimeCut
Definition TGeoManager.h:89
void AddBorderSurface(TGeoBorderSurface *surf)
Add border surface;.
void SetClippingShape(TGeoShape *clip)
Set a user-defined shape as clipping for ray tracing.
TGeoVolume * fCurrentVolume
current navigator
void ClearOverlaps()
Clear the list of overlaps.
TGeoVolume * MakeCons(const char *name, TGeoMedium *medium, Double_t dz, Double_t rmin1, Double_t rmax1, Double_t rmin2, Double_t rmax2, Double_t phi1, Double_t phi2)
Make in one step a volume pointing to a cone segment shape with given medium.
THashList * fHashGVolumes
hash list of volumes providing fast search
Int_t fVisOption
Definition TGeoManager.h:75
static std::mutex fgMutex
Definition TGeoManager.h:53
Bool_t IsInPhiRange() const
True if current node is in phi range.
virtual Bool_t cd(const char *path="")
Browse the tree of nodes starting from fTopNode according to pathname.
TGeoMaterial * Material(const char *name, Double_t a, Double_t z, Double_t dens, Int_t uid, Double_t radlen=0, Double_t intlen=0)
Create material with given A, Z and density, having an unique id.
void LocalToMaster(const Double_t *local, Double_t *master) const
Double_t fPhimin
Definition TGeoManager.h:66
static Bool_t fgLockNavigators
Number of registered threads.
void SaveAttributes(const char *filename="tgeoatt.C")
Save current attributes in a macro.
void RestoreMasterVolume()
Restore the master volume of the geometry.
Bool_t fDrawExtra
Definition TGeoManager.h:90
virtual Int_t Export(const char *filename, const char *name="", Option_t *option="vg")
Export this geometry to a file.
TGeoNode * FindNextDaughterBoundary(Double_t *point, Double_t *dir, Int_t &idaughter, Bool_t compmatrix=kFALSE)
Computes as fStep the distance to next daughter of the current volume.
Int_t GetUID(const char *volname) const
Retrieve unique id for a volume name. Return -1 if name not found.
TGeoShape * fClippingShape
TGeoNavigator * GetCurrentNavigator() const
Returns current navigator for the calling thread.
THashList * fHashVolumes
TObjArray * fMatrices
current painter
Definition TGeoManager.h:97
static Int_t GetNumThreads()
Returns number of threads that were set to use geometry.
TGeoVolumeMulti * MakeVolumeMulti(const char *name, TGeoMedium *medium)
Make a TGeoVolumeMulti handling a list of volumes.
void ClearNavigators()
Clear all navigators.
Int_t AddTrack(Int_t id, Int_t pdgcode, TObject *particle=0)
Add a track to the list of tracks.
Int_t AddTransformation(const TGeoMatrix *matrix)
Add a matrix to the list. Returns index of the matrix in list.
TObjArray * fOpticalSurfaces
TVirtualGeoTrack * GetParentTrackOfId(Int_t id) const
Get parent track with a given ID.
void CdNode(Int_t nodeid)
Change current path to point to the node having this id.
UChar_t * fBits
static Int_t GetMaxLevels()
Return maximum number of levels used in the geometry.
Double_t fTmin
highest range for phi cut
Definition TGeoManager.h:68
static Bool_t IsLocked()
Check lock state.
TGeoVolume * fTopVolume
current volume
void RandomRays(Int_t nrays=1000, Double_t startx=0, Double_t starty=0, Double_t startz=0, const char *target_vol=0, Bool_t check_norm=kFALSE)
Randomly shoot nrays and plot intersections with surfaces for current top node.
TGeoVolume * fUserPaintVolume
volume currently painted
TVirtualGeoPainter * GetGeomPainter()
Make a default painter if none present. Returns pointer to it.
void GetBranchOnlys(Int_t *isonly) const
Fill node copy numbers of current branch into an array.
TGeoNode * GetCurrentNode() const
void SetVisOption(Int_t option=0)
set drawing mode :
void SetPdgName(Int_t pdg, const char *name)
Set a name for a particle having a given pdg.
TObjArray * fBorderSurfaces
Int_t GetNAlignable(Bool_t with_uid=kFALSE) const
Retrieves number of PN entries with or without UID.
void RefreshPhysicalNodes(Bool_t lock=kTRUE)
Refresh physical nodes to reflect the actual geometry paths after alignment was applied.
static Bool_t fgLock
mutex for navigator booking in MT mode
Definition TGeoManager.h:54
TGeoVolume * MakePara(const char *name, TGeoMedium *medium, Double_t dx, Double_t dy, Double_t dz, Double_t alpha, Double_t theta, Double_t phi)
Make in one step a volume pointing to a parallelepiped shape with given medium.
void TopToMaster(const Double_t *top, Double_t *master) const
Convert coordinates from top volume frame to master.
TObjArray * fShapes
Definition TGeoManager.h:98
void AddOpticalSurface(TGeoOpticalSurface *optsurf)
Add optical surface;.
static void SetDefaultUnits(EDefaultUnits new_value)
Bool_t fLoopVolumes
flag that geometry is closed
Definition TGeoManager.h:84
Int_t AddMaterial(const TGeoMaterial *material)
Add a material to the list. Returns index of the material in list.
void ClearAttributes()
Reset all attributes to default ones.
static Int_t fgMaxDaughters
Maximum level in geometry.
Definition TGeoManager.h:57
Bool_t fUsePWNav
Raytrace mode: 0=normal, 1=pass through, 2=transparent.
void SetRTmode(Int_t mode)
Change raytracing mode.
Bool_t CheckPath(const char *path) const
Check if a geometry path is valid without changing the state of the current navigator.
void InspectState() const
Inspects path and all flags for the current state.
void ConvertReflections()
Convert all reflections in geometry to normal rotations + reflected shapes.
void SetVisLevel(Int_t level=3)
set default level down to which visualization is performed
TGeoNode * FindNextBoundary(Double_t stepmax=TGeoShape::Big(), const char *path="", Bool_t frombdr=kFALSE)
Find distance to next boundary and store it in fStep.
static TGeoManager * Import(const char *filename, const char *name="", Option_t *option="")
static function Import a geometry from a gdml or ROOT file
void CountLevels()
Count maximum number of nodes per volume, maximum depth and maximum number of xtru vertices.
Int_t fMaxThreads
Bool_t fIsGeomReading
Definition TGeoManager.h:86
TGeoVolume * MakeTorus(const char *name, TGeoMedium *medium, Double_t r, Double_t rmin, Double_t rmax, Double_t phi1=0, Double_t dphi=360)
Make in one step a volume pointing to a torus shape with given medium.
TGeoHMatrix * GetHMatrix()
Return stored current matrix (global matrix of the next touched node).
TGeoParallelWorld * fParallelWorld
void RegisterMatrix(const TGeoMatrix *matrix)
Register a matrix to the list of matrices.
TVirtualGeoTrack * GetTrack(Int_t index)
static Int_t GetMaxDaughters()
Return maximum number of daughters of a volume used in the geometry.
static void ClearThreadsMap()
Clear the current map of threads.
Int_t AddVolume(TGeoVolume *volume)
Add a volume to the list. Returns index of the volume in list.
TVirtualGeoPainter * fPainter
flag that nodes are the selected objects in pad rather than volumes
Definition TGeoManager.h:95
void SetVolumeAttribute(const char *name, const char *att, Int_t val)
Set volume attributes in G3 style.
const char * GetPdgName(Int_t pdg) const
Get name for given pdg code;.
void CheckGeometryFull(Int_t ntracks=1000000, Double_t vx=0., Double_t vy=0., Double_t vz=0., Option_t *option="ob")
Geometry checking.
Bool_t fIsNodeSelectable
switch ON/OFF volume activity (default OFF - all volumes active))
Definition TGeoManager.h:94
TGeoNode * Step(Bool_t is_geom=kTRUE, Bool_t cross=kTRUE)
Make a rectilinear step of length fStep from current point (fPoint) on current direction (fDirection)...
Bool_t GotoSafeLevel()
Go upwards the tree until a non-overlapping node.
Bool_t fActivity
flag for GL reflections
Definition TGeoManager.h:93
void GetBranchNames(Int_t *names) const
Fill volume names of current branch into an array.
static ThreadsMap_t * fgThreadId
Map between thread id's and navigator arrays.
void CloseGeometry(Option_t *option="d")
Closing geometry implies checking the geometry validity, fixing shapes with negative parameters (run-...
TVirtualGeoTrack * MakeTrack(Int_t id, Int_t pdgcode, TObject *particle)
Makes a primary track but do not attach it to the list of tracks.
Int_t GetTrackIndex(Int_t id) const
Get index for track id, -1 if not found.
Int_t fNNodes
upper time limit for tracks drawing
Definition TGeoManager.h:70
virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py)
Execute mouse actions on this manager.
Int_t fNLevel
table of elements
void OptimizeVoxels(const char *filename="tgeovox.C")
Optimize voxelization type for all volumes. Save best choice in a macro.
void CheckPoint(Double_t x=0, Double_t y=0, Double_t z=0, Option_t *option="")
Classify a given point. See TGeoChecker::CheckPoint().
TGeoVolume * GetVolume(const char *name) const
Search for a named volume. All trailing blanks stripped.
void SetAnimateTracks(Bool_t flag=kTRUE)
Bool_t fIsGeomCleaning
flag set when reading geometry
Definition TGeoManager.h:87
Bool_t IsSameLocation() const
void DefaultColors()
Set default volume colors according to A of material.
TGeoNode * FindNextBoundaryAndStep(Double_t stepmax=TGeoShape::Big(), Bool_t compsafe=kFALSE)
Compute distance to next boundary within STEPMAX.
TGeoVolume * MakeTrd2(const char *name, TGeoMedium *medium, Double_t dx1, Double_t dx2, Double_t dy1, Double_t dy2, Double_t dz)
Make in one step a volume pointing to a TGeoTrd2 shape with given medium.
Double_t * FindNormal(Bool_t forward=kTRUE)
Computes normal vector to the next surface that will be or was already crossed when propagating on a ...
TGeoVolume * MakeGtra(const char *name, TGeoMedium *medium, Double_t dz, Double_t theta, Double_t phi, Double_t twist, Double_t h1, Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Double_t bl2, Double_t tl2, Double_t alpha2)
Make in one step a volume pointing to a twisted trapezoid shape with given medium.
TGeoElementTable * fElementTable
clipping shape for raytracing
static void SetNavigatorsLock(Bool_t flag)
Set the lock for navigators.
static Int_t fgMaxXtruVert
Maximum number of daughters.
Definition TGeoManager.h:58
TGeoNode * FindNode(Bool_t safe_start=kTRUE)
Returns deepest node containing current point.
Int_t GetVisOption() const
Returns current depth to which geometry is drawn.
static void LockGeometry()
Lock current geometry so that no other geometry can be imported.
static UInt_t GetExportPrecision()
TGeoVolume * MakeBox(const char *name, TGeoMedium *medium, Double_t dx, Double_t dy, Double_t dz)
Make in one step a volume pointing to a box shape with given medium.
void CheckShape(TGeoShape *shape, Int_t testNo, Int_t nsamples, Option_t *option)
Test for shape navigation methods.
static Int_t fgMaxLevel
Verbosity level for Info messages (no IO).
Definition TGeoManager.h:56
Int_t fNpdg
current track
Definition TGeoManager.h:81
void PrintOverlaps() const
Prints the current list of overlaps.
TGeoVolume * MakeTrd1(const char *name, TGeoMedium *medium, Double_t dx1, Double_t dx2, Double_t dy, Double_t dz)
Make in one step a volume pointing to a TGeoTrd1 shape with given medium.
TGeoVolume * MakeSphere(const char *name, TGeoMedium *medium, Double_t rmin, Double_t rmax, Double_t themin=0, Double_t themax=180, Double_t phimin=0, Double_t phimax=360)
Make in one step a volume pointing to a sphere shape with given medium.
void ResetUserData()
Sets all pointers TGeoVolume::fField to NULL.
TGeoVolume * FindVolumeFast(const char *name, Bool_t multi=kFALSE)
Fast search for a named volume. All trailing blanks stripped.
TList * fMedia
Bool_t GetTminTmax(Double_t &tmin, Double_t &tmax) const
Get time cut for drawing tracks.
TGeoNode * InitTrack(const Double_t *point, const Double_t *dir)
Initialize current point and current direction vector (normalized) in MARS.
ThreadsMap_t::const_iterator ThreadsMapIt_t
Bool_t fMatrixTransform
flag that the list of physical nodes has to be drawn
Definition TGeoManager.h:91
void Voxelize(Option_t *option=0)
Voxelize all non-divided volumes.
void SetVisibility(TObject *obj, Bool_t vis)
Set visibility for a volume.
void SetTopVolume(TGeoVolume *vol)
Set the top volume and corresponding node as starting point of the geometry.
Bool_t fMatrixReflection
flag for using GL matrix
Definition TGeoManager.h:92
TGeoPNEntry * SetAlignableEntry(const char *unique_name, const char *path, Int_t uid=-1)
Creates an alignable object with unique name corresponding to a path and adds it to the list of align...
void ClearShape(const TGeoShape *shape)
Remove a shape from the list of shapes.
void ModifiedPad() const
Send "Modified" signal to painter.
void BombTranslation(const Double_t *tr, Double_t *bombtr)
Get the new 'bombed' translation vector according current exploded view mode.
TGeoNavigator * fCurrentNavigator
Lock existing navigators.
static Bool_t LockDefaultUnits(Bool_t new_value)
virtual ~TGeoManager()
Destructor.
Int_t fMaxVisNodes
Definition TGeoManager.h:79
TGeoMedium * GetMedium(const char *medium) const
Search for a named tracking medium. All trailing blanks stripped.
Bool_t InsertPNEId(Int_t uid, Int_t ientry)
Insert a PN entry in the sorted array of indexes.
Int_t fVisLevel
Definition TGeoManager.h:76
void ViewLeaves(Bool_t flag=kTRUE)
Set visualization option (leaves only OR all volumes)
TGeoVolume * MakeCtub(const char *name, TGeoMedium *medium, Double_t rmin, Double_t rmax, Double_t dz, Double_t phi1, Double_t phi2, Double_t lx, Double_t ly, Double_t lz, Double_t tx, Double_t ty, Double_t tz)
Make in one step a volume pointing to a tube segment shape with given medium.
void SetTminTmax(Double_t tmin=0, Double_t tmax=999)
Set time cut interval for drawing tracks.
NavigatorsMap_t fNavigators
void GetBranchNumbers(Int_t *copyNumbers, Int_t *volumeNumbers) const
Fill node copy numbers of current branch into an array.
Bool_t fPhiCut
flag to notify that the manager is being destructed
Definition TGeoManager.h:88
TGeoNode * CrossBoundaryAndLocate(Bool_t downwards, TGeoNode *skipnode)
Cross next boundary and locate within current node The current point must be on the boundary of fCurr...
void DrawTracks(Option_t *option="")
Draw tracks over the geometry, according to option.
void BuildDefaultMaterials()
Now just a shortcut for GetElementTable.
void SetMaxThreads(Int_t nthreads)
Set maximum number of threads for navigation.
TGeoMedium * Medium(const char *name, Int_t numed, Int_t nmat, Int_t isvol, Int_t ifield, Double_t fieldm, Double_t tmaxfd, Double_t stemax, Double_t deemax, Double_t epsil, Double_t stmin)
Create tracking medium.
void SetExplodedView(Int_t iopt=0)
Set type of exploding view (see TGeoPainter::SetExplodedView())
Double_t Weight(Double_t precision=0.01, Option_t *option="va")
Estimate weight of volume VOL with a precision SIGMA(W)/W better than PRECISION.
void ClearPhysicalNodes(Bool_t mustdelete=kFALSE)
Clear the current list of physical nodes, so that we can start over with a new list.
static Int_t Parse(const char *expr, TString &expr1, TString &expr2, TString &expr3)
Parse a string boolean expression and do a syntax check.
void GetBombFactors(Double_t &bombx, Double_t &bomby, Double_t &bombz, Double_t &bombr) const
Retrieve cartesian and radial bomb factors.
Double_t GetProperty(const char *name, Bool_t *error=nullptr) const
Get a user-defined property.
TObjArray * fTracks
list of runtime volumes
Bool_t IsAnimatingTracks() const
const char * GetPath() const
Get path to the current node in the form /node0/node1/...
static Int_t fgNumThreads
Thread id's map.
TObjArray * fGDMLMatrices
TGeoPhysicalNode * MakeAlignablePN(const char *name)
Make a physical node from the path pointed by an alignable object with a given name.
void SetCheckedNode(TGeoNode *node)
Assign a given node to be checked for overlaps. Any other overlaps will be ignored.
Int_t AddOverlap(const TNamed *ovlp)
Add an illegal overlap/extrusion to the list.
void CreateThreadData() const
Create thread private data for all geometry objects.
Int_t fNsegments
Definition TGeoManager.h:77
TObjArray * fOverlaps
TGeoNode * SamplePoints(Int_t npoints, Double_t &dist, Double_t epsil=1E-5, const char *g3path="")
shoot npoints randomly in a box of 1E-5 around current point.
Bool_t IsMultiThread() const
TGDMLMatrix * GetGDMLMatrix(const char *name) const
Get GDML matrix with a given name;.
Double_t fTmax
lower time limit for tracks drawing
Definition TGeoManager.h:69
Int_t TransformVolumeToAssembly(const char *vname)
Transform all volumes named VNAME to assemblies. The volumes must be virtual.
Bool_t fMultiThread
Max number of threads.
TGeoVolume * MakePgon(const char *name, TGeoMedium *medium, Double_t phi, Double_t dphi, Int_t nedges, Int_t nz)
Make in one step a volume pointing to a polygone shape with given medium.
TGeoVolume * MakeTrap(const char *name, TGeoMedium *medium, Double_t dz, Double_t theta, Double_t phi, Double_t h1, Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Double_t bl2, Double_t tl2, Double_t alpha2)
Make in one step a volume pointing to a trapezoid shape with given medium.
void DrawCurrentPoint(Int_t color=2)
Draw current point in the same view.
static void SetVerboseLevel(Int_t vl)
Return current verbosity level (static function).
TGeoOpticalSurface * GetOpticalSurface(const char *name) const
Get optical surface with a given name;.
void SetNsegments(Int_t nseg)
Set number of segments for approximating circles in drawing.
Bool_t IsSamePoint(Double_t x, Double_t y, Double_t z) const
Check if a new point with given coordinates is the same as the last located one.
void SetNmeshPoints(Int_t npoints=1000)
Set the number of points to be generated on the shape outline when checking for overlaps.
void CheckBoundaryReference(Int_t icheck=-1)
Check the boundary errors reference file created by CheckBoundaryErrors method.
static Int_t GetVerboseLevel()
Set verbosity level (static function).
Int_t GetVisLevel() const
Returns current depth to which geometry is drawn.
static EDefaultUnits fgDefaultUnits
Precision to be used in ASCII exports.
Definition TGeoManager.h:60
virtual void Edit(Option_t *option="")
Append a pad for this geometry.
Bool_t AddProperty(const char *property, Double_t value)
Add a user-defined property. Returns true if added, false if existing.
TObjArray * fNodes
TGeoMaterial * GetMaterial(const char *matname) const
Search for a named material. All trailing blanks stripped.
void CheckGeometry(Option_t *option="")
Perform last checks on the geometry.
TGeoVolumeAssembly * MakeVolumeAssembly(const char *name)
Make an assembly of volumes.
Int_t GetBombMode() const
Int_t AddRegion(TGeoRegion *region)
Add a new region of volumes.
void SelectTrackingMedia()
Define different tracking media.
void CdNext()
Do a cd to the node found next by FindNextBoundary.
void CdTop()
Make top level node the current node.
Double_t Safety(Bool_t inside=kFALSE)
Compute safe distance from the current point.
Int_t * fKeyPNEId
void DefaultAngles()
Set default angles for a given view.
TGeoMaterial * Mixture(const char *name, Float_t *a, Float_t *z, Double_t dens, Int_t nelem, Float_t *wmat, Int_t uid)
Create mixture OR COMPOUND IMAT as composed by THE BASIC nelem materials defined by arrays A,...
std::map< std::thread::id, Int_t > ThreadsMap_t
void SetUseParallelWorldNav(Bool_t flag)
Activate/deactivate usage of parallel world navigation.
void Test(Int_t npoints=1000000, Option_t *option="")
Check time of finding "Where am I" for n points.
Int_t GetSafeLevel() const
Go upwards the tree until a non-overlapping node.
TObjArray * fGVolumes
list of runtime shapes
void SetBombFactors(Double_t bombx=1.3, Double_t bomby=1.3, Double_t bombz=1.3, Double_t bombr=1.3)
Set factors that will "bomb" all translations in cartesian and cylindrical coordinates.
TGeoPhysicalNode * MakePhysicalNode(const char *path=0)
Makes a physical node corresponding to a path.
TGeoNode * fTopNode
top level volume in geometry
void UnbombTranslation(const Double_t *tr, Double_t *bombtr)
Get the new 'unbombed' translation vector according current exploded view mode.
void ResetState()
Reset current state flags.
void RandomPoints(const TGeoVolume *vol, Int_t npoints=10000, Option_t *option="")
Draw random points in the bounding box of a volume.
TGeoParallelWorld * CreateParallelWorld(const char *name)
Create a parallel world for prioritised navigation.
Int_t GetMaterialIndex(const char *matname) const
Return index of named material.
void CdDown(Int_t index)
Make a daughter of current node current.
TGeoNavigatorArray * GetListOfNavigators() const
Get list of navigators for the calling thread.
static Int_t GetMaxXtruVert()
Return maximum number of vertices for an xtru shape used.
void SetAllIndex()
Assigns uid's for all materials,media and matrices.
TObjArray * fSkinSurfaces
void SetVisDensity(Double_t dens=0.01)
Set density threshold.
Int_t fExplodedView
Definition TGeoManager.h:74
Bool_t fClosed
Definition TGeoManager.h:83
Int_t GetNsegments() const
Get number of segments approximating circles.
void SetPhiRange(Double_t phimin=0., Double_t phimax=360.)
Set cut phi range.
TGeoHMatrix * fGLMatrix
TVirtualGeoTrack * fCurrentTrack
Definition TGeoManager.h:80
TObjArray * fPdgNames
void DrawPath(const char *path, Option_t *option="")
Draw current path.
TObjArray * GetListOfPhysicalNodes()
static Int_t ThreadId()
Translates the current thread id to an ordinal number.
Bool_t SetCurrentNavigator(Int_t index)
Switch to another existing navigator for the calling thread.
void SetTopVisible(Bool_t vis=kTRUE)
make top volume visible on screen
TGeoVolume * MakeHype(const char *name, TGeoMedium *medium, Double_t rin, Double_t stin, Double_t rout, Double_t stout, Double_t dz)
Make in one step a volume pointing to a tube shape with given medium.
TGeoVolume * MakeParaboloid(const char *name, TGeoMedium *medium, Double_t rlo, Double_t rhi, Double_t dz)
Make in one step a volume pointing to a tube shape with given medium.
Int_t AddShape(const TGeoShape *shape)
Add a shape to the list. Returns index of the shape in list.
void SetMaxVisNodes(Int_t maxnodes=10000)
set the maximum number of visible nodes.
void CleanGarbage()
Clean temporary volumes and shapes from garbage collection.
Int_t GetVirtualLevel()
Find level of virtuality of current overlapping node (number of levels up having the same tracking me...
TGeoBorderSurface * GetBorderSurface(const char *name) const
Get border surface with a given name;.
void ClearThreadData() const
Int_t fSizePNEId
array of physical node entries
void CheckOverlaps(Double_t ovlp=0.1, Option_t *option="")
Check all geometry for illegal overlaps within a limit OVLP.
TGeoVolume * MakeTubs(const char *name, TGeoMedium *medium, Double_t rmin, Double_t rmax, Double_t dz, Double_t phi1, Double_t phi2)
Make in one step a volume pointing to a tube segment shape with given medium.
Int_t fPdgId[1024]
Definition TGeoManager.h:82
void SortOverlaps()
Sort overlaps by decreasing overlap distance. Extrusions comes first.
TGeoVolume * MakeEltu(const char *name, TGeoMedium *medium, Double_t a, Double_t b, Double_t dz)
Make in one step a volume pointing to a tube shape with given medium.
void RemoveNavigator(const TGeoNavigator *nav)
Clear a single navigator.
void MasterToTop(const Double_t *master, Double_t *top) const
Convert coordinates from master volume frame to top.
Bool_t fStreamVoxels
flag volume lists loop
Definition TGeoManager.h:85
Base class describing materials.
virtual Bool_t IsMixture() const
virtual Int_t GetByteCount() const
TGeoElement * GetElement() const
Get a pointer to the element this material is made of.
virtual Bool_t IsEq(const TGeoMaterial *other) const
return true if the other material has the same physical properties
virtual Double_t GetDensity() const
virtual Double_t GetZ() const
Geometrical transformation package.
Definition TGeoMatrix.h:41
@ kGeoSavePrimitive
Definition TGeoMatrix.h:51
virtual void ReflectZ(Bool_t leftside, Bool_t rotonly=kFALSE)
Multiply by a reflection respect to XY.
Bool_t IsReflection() const
Definition TGeoMatrix.h:69
virtual void RegisterYourself()
Register the matrix in the current manager, which will become the owner.
virtual Int_t GetByteCount() const
Get total size in bytes of this.
Media are used to store properties related to tracking and which are useful only when using geometry ...
Definition TGeoMedium.h:24
Int_t GetId() const
Definition TGeoMedium.h:48
@ kMedSavePrimitive
Definition TGeoMedium.h:27
TGeoMaterial * GetMaterial() const
Definition TGeoMedium.h:52
virtual Int_t GetByteCount() const
Definition TGeoMedium.h:47
Mixtures of elements.
virtual TGeoElement * GetElement(Int_t i=0) const
Retrieve the pointer to the element corresponding to component I.
virtual Int_t GetNelements() const
TGeoNavigator * AddNavigator()
Add a new navigator to the array.
TGeoNavigator * GetCurrentNavigator() const
TGeoNavigator * SetCurrentNavigator(Int_t inav)
Class providing navigation API for TGeo geometries.
void CdUp()
Go one level up in geometry.
void DoBackupState()
Backup the current state without affecting the cache stack.
void DoRestoreState()
Restore a backed-up state without affecting the cache stack.
TGeoNode * CrossBoundaryAndLocate(Bool_t downwards, TGeoNode *skipnode)
Cross next boundary and locate within current node The current point must be on the boundary of fCurr...
TGeoHMatrix * GetHMatrix()
Return stored current matrix (global matrix of the next touched node).
void LocalToMaster(const Double_t *local, Double_t *master) const
void CdNext()
Do a cd to the node found next by FindNextBoundary.
Double_t Safety(Bool_t inside=kFALSE)
Compute safe distance from the current point.
Bool_t GotoSafeLevel()
Go upwards the tree until a non-overlapping node.
Bool_t cd(const char *path="")
Browse the tree of nodes starting from top node according to pathname.
Bool_t IsSameLocation(Double_t x, Double_t y, Double_t z, Bool_t change=kFALSE)
Checks if point (x,y,z) is still in the current node.
void MasterToLocal(const Double_t *master, Double_t *local) const
TGeoNode * SearchNode(Bool_t downwards=kFALSE, const TGeoNode *skipnode=0)
Returns the deepest node containing fPoint, which must be set a priori.
Int_t GetVirtualLevel()
Find level of virtuality of current overlapping node (number of levels up having the same tracking me...
TGeoNode * InitTrack(const Double_t *point, const Double_t *dir)
Initialize current point and current direction vector (normalized) in MARS.
void InspectState() const
Inspects path and all flags for the current state.
TGeoNode * Step(Bool_t is_geom=kTRUE, Bool_t cross=kTRUE)
Make a rectiliniar step of length fStep from current point (fPoint) on current direction (fDirection)...
TGeoVolume * GetCurrentVolume() const
void ResetState()
Reset current state flags.
TGeoNode * FindNextDaughterBoundary(Double_t *point, Double_t *dir, Int_t &idaughter, Bool_t compmatrix=kFALSE)
Computes as fStep the distance to next daughter of the current volume.
void GetBranchNumbers(Int_t *copyNumbers, Int_t *volumeNumbers) const
Fill node copy numbers of current branch into an array.
Bool_t CheckPath(const char *path) const
Check if a geometry path is valid without changing the state of the navigator.
TGeoNode * FindNextBoundary(Double_t stepmax=TGeoShape::Big(), const char *path="", Bool_t frombdr=kFALSE)
Find distance to next boundary and store it in fStep.
TGeoNode * FindNode(Bool_t safe_start=kTRUE)
Returns deepest node containing current point.
TGeoNode * FindNextBoundaryAndStep(Double_t stepmax=TGeoShape::Big(), Bool_t compsafe=kFALSE)
Compute distance to next boundary within STEPMAX.
void CdTop()
Make top level node the current node.
Int_t GetCurrentNodeId() const
Double_t * FindNormalFast()
Computes fast normal to next crossed boundary, assuming that the current point is close enough to the...
void GetBranchOnlys(Int_t *isonly) const
Fill node copy numbers of current branch into an array.
void CdNode(Int_t nodeid)
Change current path to point to the node having this id.
TGeoNodeCache * GetCache() const
void ResetAll()
Reset the navigator.
Bool_t IsSamePoint(Double_t x, Double_t y, Double_t z) const
Check if a new point with given coordinates is the same as the last located one.
void CdDown(Int_t index)
Make a daughter of current node current.
const char * GetPath() const
Get path to the current node in the form /node0/node1/...
Int_t GetSafeLevel() const
Go upwards the tree until a non-overlapping node.
Double_t * FindNormal(Bool_t forward=kTRUE)
Computes normal vector to the next surface that will be or was already crossed when propagating on a ...
void GetBranchNames(Int_t *names) const
Fill volume names of current branch into an array.
void BuildIdArray()
Builds node id array.
void BuildInfoBranch()
Builds info branch. Navigation is possible only after this step.
A node containing local transformation.
Definition TGeoNode.h:153
void SetMatrix(const TGeoMatrix *matrix)
Matrix setter.
Definition TGeoNode.cxx:767
A node represent a volume positioned inside another.They store links to both volumes and to the TGeoM...
Definition TGeoNode.h:41
Bool_t IsOverlapping() const
Definition TGeoNode.h:105
TGeoVolume * GetVolume() const
Definition TGeoNode.h:97
void SaveAttributes(std::ostream &out)
save attributes for this node
Definition TGeoNode.cxx:404
void SetVolume(TGeoVolume *volume)
Definition TGeoNode.h:115
void CheckShapes()
check for wrong parameters in shapes
Definition TGeoNode.cxx:303
void SetOverlapping(Bool_t flag=kTRUE)
Definition TGeoNode.h:118
Int_t GetNdaughters() const
Definition TGeoNode.h:93
virtual TGeoMatrix * GetMatrix() const =0
void SetMotherVolume(TGeoVolume *mother)
Definition TGeoNode.h:123
TGeoVolume * GetMotherVolume() const
Definition TGeoNode.h:92
void SetVisibility(Bool_t vis=kTRUE)
Set visibility of the node (obsolete).
Definition TGeoNode.cxx:663
void SetNumber(Int_t number)
Definition TGeoNode.h:116
void CheckOverlaps(Double_t ovlp=0.1, Option_t *option="")
Check overlaps bigger than OVLP hierarchically, starting with this node.
Definition TGeoNode.cxx:179
The knowledge of the path to the objects that need to be misaligned is essential since there is no ot...
void SetPhysicalNode(TGeoPhysicalNode *node)
Setter for the corresponding physical node.
Base class for a flat parallel geometry.
Bool_t CloseGeometry()
The main geometry must be closed.
void RefreshPhysicalNodes()
Refresh the node pointers and re-voxelize.
Bool_t IsClosed() const
Physical nodes are the actual 'touchable' objects in the geometry, representing a path of positioned ...
void Refresh()
Refresh this physical node.
Regions are groups of volumes having a common set of user tracking cuts.
Definition TGeoRegion.h:36
Base abstract class for all shapes.
Definition TGeoShape.h:26
virtual Bool_t IsComposite() const
Definition TGeoShape.h:130
Bool_t IsRunTimeShape() const
Definition TGeoShape.h:139
virtual void ComputeBBox()=0
virtual void AfterStreamer()
Definition TGeoShape.h:94
@ kGeoClosedShape
Definition TGeoShape.h:60
Bool_t TestShapeBit(UInt_t f) const
Definition TGeoShape.h:163
Volume assemblies.
Definition TGeoVolume.h:305
static TGeoVolumeAssembly * MakeAssemblyFromVolume(TGeoVolume *vol)
Make a clone of volume VOL but which is an assembly.
Volume families.
Definition TGeoVolume.h:255
TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes.
Definition TGeoVolume.h:49
Double_t WeightA() const
Analytical computation of the weight.
virtual void ClearThreadData() const
void SetNumber(Int_t number)
Definition TGeoVolume.h:233
TGeoMedium * GetMedium() const
Definition TGeoVolume.h:174
Int_t GetRefCount() const
Definition TGeoVolume.h:135
void SortNodes()
sort nodes by decreasing volume of the bounding box.
void Voxelize(Option_t *option)
build the voxels for this volume
Bool_t IsRunTime() const
Definition TGeoVolume.h:114
virtual void CreateThreadData(Int_t nthreads)
virtual Int_t GetByteCount() const
get the total size in bytes for this volume
Bool_t OptimizeVoxels()
Perform an extensive sampling to find which type of voxelization is most efficient.
virtual Bool_t IsVolumeMulti() const
Definition TGeoVolume.h:115
Int_t CountNodes(Int_t nlevels=1000, Int_t option=0)
Count total number of subnodes starting from this volume, nlevels down.
void UnmarkSaved()
Reset SavePrimitive bits.
void SetFinder(TGeoPatternFinder *finder)
Definition TGeoVolume.h:232
Int_t GetNdaughters() const
Definition TGeoVolume.h:351
virtual void SetLineStyle(Style_t lstyle)
Set the line style.
void Grab()
Definition TGeoVolume.h:140
void SetTransparency(Char_t transparency=0)
Definition TGeoVolume.h:218
void Release()
Definition TGeoVolume.h:141
void FindOverlaps() const
loop all nodes marked as overlaps and find overlapping brothers
TGeoNode * GetNode(const char *name) const
get the pointer to a daughter node
virtual void SetVisibility(Bool_t vis=kTRUE)
set visibility of this volume
void SaveAs(const char *filename, Option_t *option="") const
Save geometry having this as top volume as a C++ macro.
virtual void SetMedium(TGeoMedium *medium)
Definition TGeoVolume.h:230
TGeoVoxelFinder * GetVoxels() const
Getter for optimization structure.
static TGeoMedium * DummyMedium()
Int_t GetNumber() const
Definition TGeoVolume.h:183
TGeoShape * GetShape() const
Definition TGeoVolume.h:189
void SetField(TObject *field)
Definition TGeoVolume.h:219
static void CreateDummyMedium()
Create a dummy medium.
virtual void SetLineWidth(Width_t lwidth)
Set the line width.
virtual void SetLineColor(Color_t lcolor)
Set the line color.
virtual Bool_t IsAssembly() const
Returns true if the volume is an assembly or a scaled assembly.
TGeoVolume * MakeReflectedVolume(const char *newname="") const
Make a copy of this volume which is reflected with respect to XY plane.
virtual Bool_t IsVisible() const
Definition TGeoVolume.h:154
Finder class handling voxels.
void SetNeedRebuild(Bool_t flag=kTRUE)
An extrusion with fixed outline shape in x-y and a sequence of z extents (segments).
Definition TGeoXtru.h:23
Int_t GetNvert() const
Definition TGeoXtru.h:95
THashList implements a hybrid collection class consisting of a hash table and a list to store TObject...
Definition THashList.h:34
TObject * FindObject(const char *name) const
Find object using its name.
void Clear(Option_t *option="")
Remove all objects from the list.
void Delete(Option_t *option="")
Remove all objects from the list AND delete all heap based objects.
void AddLast(TObject *obj)
Add object at the end of the list.
Definition THashList.cxx:95
Book space in a file, create I/O buffers, to fill them, (un)compress them.
Definition TKey.h:28
virtual const char * GetClassName() const
Definition TKey.h:76
virtual TObject * ReadObj()
To read a TObject* from the file.
Definition TKey.cxx:750
virtual void Add(TObject *obj)
Definition TList.h:87
virtual TObject * Remove(TObject *obj)
Remove object from the list.
Definition TList.cxx:822
virtual TObject * FindObject(const char *name) const
Find an object in this list using its name.
Definition TList.cxx:578
virtual TObject * At(Int_t idx) const
Returns the object at position idx. Returns 0 if idx is out of range.
Definition TList.cxx:357
virtual void Delete(Option_t *option="")
Remove all objects from the list AND delete all heap based objects.
Definition TList.cxx:470
The TNamed class is the base class for all named ROOT classes.
Definition TNamed.h:29
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition TNamed.cxx:164
TNamed()
Definition TNamed.h:36
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition TNamed.cxx:140
virtual const char * GetTitle() const
Returns title of object.
Definition TNamed.h:48
virtual const char * GetName() const
Returns name of object.
Definition TNamed.h:47
An array of TObjects.
Definition TObjArray.h:37
Int_t IndexOf(const TObject *obj) const
Int_t GetEntriesFast() const
Definition TObjArray.h:64
virtual void Sort(Int_t upto=kMaxInt)
If objects in array are sortable (i.e.
virtual void AddAtAndExpand(TObject *obj, Int_t idx)
Add object at position idx.
void Add(TObject *obj)
Definition TObjArray.h:74
Int_t GetEntries() const
Return the number of objects in array (i.e.
virtual void Clear(Option_t *option="")
Remove all objects from the array.
TObject * UncheckedAt(Int_t i) const
Definition TObjArray.h:90
virtual void Delete(Option_t *option="")
Remove all objects from the array AND delete all heap based objects.
virtual TObject * FindObject(const char *name) const
Find an object in this collection using its name.
virtual TObject * Remove(TObject *obj)
Remove object from array.
virtual void AddAt(TObject *obj, Int_t idx)
Add object at position ids.
TObject * At(Int_t idx) const
Definition TObjArray.h:166
Mother of all ROOT objects.
Definition TObject.h:37
virtual Int_t Write(const char *name=0, Int_t option=0, Int_t bufsize=0)
Write this object to the current directory.
Definition TObject.cxx:798
virtual const char * GetName() const
Returns name of object.
Definition TObject.cxx:359
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition TObject.h:187
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition TObject.cxx:879
virtual void AppendPad(Option_t *option="")
Append graphics object to current pad.
Definition TObject.cxx:107
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition TObject.cxx:696
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition TObject.cxx:445
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition TObject.cxx:893
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
Definition TObject.cxx:921
virtual void SetUniqueID(UInt_t uid)
Set the unique object id.
Definition TObject.cxx:707
virtual void Draw(Option_t *option="")
Default Draw method for all objects.
Definition TObject.cxx:197
void ResetBit(UInt_t f)
Definition TObject.h:186
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition TObject.cxx:867
Bool_t Connect(const char *signal, const char *receiver_class, void *receiver, const char *slot)
Non-static method is used to connect from the signal of this object to the receiver slot.
Definition TQObject.cxx:866
Sequenceable collection abstract base class.
virtual Int_t IndexOf(const TObject *obj) const
Return index of object in collection.
Basic string class.
Definition TString.h:136
Ssiz_t Length() const
Definition TString.h:410
void ToLower()
Change string to lower-case.
Definition TString.cxx:1145
TSubString Strip(EStripType s=kTrailing, char c=' ') const
Return a substring of self stripped at beginning and/or end.
Definition TString.cxx:1126
const char * Data() const
Definition TString.h:369
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition TString.h:692
Bool_t IsNull() const
Definition TString.h:407
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString.
Definition TString.cxx:2331
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition TString.h:624
Abstract class for geometry painters.
virtual TGeoNode * SamplePoints(Int_t npoints, Double_t &dist, Double_t epsil, const char *g3path)=0
virtual void SetTopVisible(Bool_t vis=kTRUE)=0
virtual Int_t GetVisLevel() const =0
virtual Double_t Weight(Double_t precision, Option_t *option="v")=0
virtual void CheckGeometryFull(Bool_t checkoverlaps=kTRUE, Bool_t checkcrossings=kTRUE, Int_t nrays=10000, const Double_t *vertex=nullptr)=0
virtual void DrawPath(const char *path, Option_t *option="")=0
virtual void ModifiedPad(Bool_t update=kFALSE) const =0
virtual void SetCheckedNode(TGeoNode *node)=0
virtual void GetViewAngles(Double_t &, Double_t &, Double_t &)
virtual TVirtualGeoTrack * AddTrack(Int_t id, Int_t pdgcode, TObject *particle)=0
virtual void SetExplodedView(Int_t iopt=0)=0
virtual Bool_t IsRaytracing() const =0
virtual void DrawCurrentPoint(Int_t color)=0
virtual void SetClippingShape(TGeoShape *shape)=0
virtual void TestOverlaps(const char *path)=0
virtual void CheckPoint(Double_t x=0, Double_t y=0, Double_t z=0, Option_t *option="")=0
virtual void PrintOverlaps() const =0
virtual void GrabFocus(Int_t nfr=0, Double_t dlong=0, Double_t dlat=0, Double_t dpsi=0)=0
virtual void Test(Int_t npoints, Option_t *option)=0
virtual void SetVisOption(Int_t option=0)=0
virtual Double_t * GetViewBox()=0
virtual void EstimateCameraMove(Double_t, Double_t, Double_t *, Double_t *)
virtual void CheckBoundaryReference(Int_t icheck=-1)=0
virtual void SetNsegments(Int_t nseg=20)=0
virtual void RandomRays(Int_t nrays, Double_t startx, Double_t starty, Double_t startz, const char *target_vol, Bool_t check_norm)=0
virtual void RandomPoints(const TGeoVolume *vol, Int_t npoints, Option_t *option="")=0
virtual Int_t CountVisibleNodes()=0
virtual void DefaultAngles()=0
virtual void SetNmeshPoints(Int_t npoints)=0
virtual void UnbombTranslation(const Double_t *tr, Double_t *bombtr)=0
virtual void EditGeometry(Option_t *option="")=0
virtual void GetBombFactors(Double_t &bombx, Double_t &bomby, Double_t &bombz, Double_t &bombr) const =0
virtual void BombTranslation(const Double_t *tr, Double_t *bombtr)=0
virtual void CheckShape(TGeoShape *shape, Int_t testNo, Int_t nsamples, Option_t *option)=0
virtual void ExecuteManagerEvent(TGeoManager *geom, Int_t event, Int_t px, Int_t py)=0
virtual void SetBombFactors(Double_t bombx=1.3, Double_t bomby=1.3, Double_t bombz=1.3, Double_t bombr=1.3)=0
virtual void CheckBoundaryErrors(Int_t ntracks=1000000, Double_t radius=-1.)=0
Base class for user-defined tracks attached to a geometry.
Int_t GetId() const
TVirtualGeoTrack * GetMother() const
virtual TVirtualGeoTrack * FindTrackWithId(Int_t id) const
Recursively search through this track for a daughter particle (at any depth) with the specified id.
void box(Int_t pat, Double_t x1, Double_t y1, Double_t x2, Double_t y2)
Definition fillpatterns.C:1
Double_t y[n]
Definition legend1.C:17
Double_t x[n]
Definition legend1.C:17
TH1F * h1
Definition legend1.C:5
void EnableThreadSafety()
Enables the global mutex to make ROOT thread safe/aware.
Definition TROOT.cxx:494
Double_t ATan2(Double_t y, Double_t x)
Definition TMath.h:679
Long64_t BinarySearch(Long64_t n, const T *array, T value)
Definition TMathBase.h:278
constexpr Double_t RadToDeg()
Conversion from radian to degree:
Definition TMath.h:73
REAL * vertex
Definition triangle.c:512