ROOT   6.14/05 Reference Guide
TGeoNode.cxx
Go to the documentation of this file.
1 // @(#)root/geom:$Id$
2 // Author: Andrei Gheata 24/10/01
3
4 /*************************************************************************
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. * 9 * For the list of contributors see$ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11
12 /** \class TGeoNode
13 \ingroup Geometry_classes
14
15  A node represent a volume positioned inside another.They store links to both
16 volumes and to the TGeoMatrix representing the relative positioning. Node are
17 never instantiated directly by users, but created as a result of volume operations.
18 Adding a volume named A with a given user ID inside a volume B will create a node
19 node named A_ID. This will be added to the list of nodes stored by B. Also,
20 when applying a division operation in N slices to a volume A, a list of nodes
21 B_1, B_2, ..., B_N is also created. A node B_i does not represent a unique
22 object in the geometry because its container A might be at its turn positioned
23 as node inside several other volumes. Only when a complete branch of nodes
24 is fully defined up to the top node in the geometry, a given path like:
25
26  /TOP_1/.../A_3/B_7 will represent an unique object.
27
28 Its global transformation matrix can be computed as the pile-up of all local
29 transformations in its branch. We will therefore call "logical graph" the
30 hierarchy defined by nodes and volumes. The expansion of the logical graph by
31 all possible paths defines a tree structure where all nodes are unique
32 "touchable" objects. We will call this the "physical tree". Unlike the logical
33 graph, the physical tree can become a huge structure with several milions of nodes
34 in case of complex geometries, therefore it is not always a good idea to keep it
35 transient in memory. Since a the logical and physical structures are correlated, the
36 modeller rather keeps track only of the current branch, updating the current
37 global matrix at each change of the level in geometry. The current physical node
38 is not an object that can be asked for at a given moment, but rather represented
39 by the combination: current node + current global matrix. However, physical nodes
40 have unique ID's that can be retrieved for a given modeler state. These can be
41 fed back to the modeler in order to force a physical node to become current.
42 The advantage of this comes from the fact that all navigation queries check
43 first the current node, therefore knowing the location of a point in the
44 geometry can be saved as a starting state for later use.
45
46  Nodes can be declared as "overlapping" in case they do overlap with other
47 nodes inside the same container or extrude this container. Non-overlapping
48 nodes can be created with:
49
50 ~~~ {.cpp}
51  TGeoVolume::AddNode(TGeoVolume *daughter, Int_t copy_No, TGeoMatrix *matr);
52 ~~~
53
54 The creation of overlapping nodes can be done with a similar prototype:
55
56 ~~~ {.cpp}
58 ~~~
59
60 When closing the geometry, overlapping nodes perform a check of possible
61 overlaps with their neighbours. These are stored and checked all the time
63 into geometry.
64
65  Node have visualization attributes as volume have. When undefined by users,
66 painting a node on a pad will take the corresponding volume attributes.
67
68 \image html geom_t_node.png
69 */
70
71 #include "Riostream.h"
72
73 #include "TBrowser.h"
74 #include "TObjArray.h"
75 #include "TStyle.h"
76
77 #include "TGeoManager.h"
78 #include "TGeoMatrix.h"
79 #include "TGeoShape.h"
80 #include "TGeoVolume.h"
81 #include "TVirtualGeoPainter.h"
82 #include "TGeoVoxelFinder.h"
83 #include "TGeoNode.h"
84 #include "TMath.h"
85 #include "TStopwatch.h"
86 #include "TGeoExtension.h"
87
88 // statics and globals
89
91
92 ////////////////////////////////////////////////////////////////////////////////
93 /// Default constructor
94
96 {
97  fVolume = 0;
98  fMother = 0;
99  fNumber = 0;
100  fNovlp = 0;
101  fOverlaps = 0;
102  fUserExtension = 0;
103  fFWExtension = 0;
104 }
105
106 ////////////////////////////////////////////////////////////////////////////////
107 /// Constructor
108
110 {
111  if (!vol) {
112  Error("ctor", "volume not specified");
113  return;
114  }
115  fVolume = (TGeoVolume*)vol;
118  fMother = 0;
119  fNumber = 0;
120  fNovlp = 0;
121  fOverlaps = 0;
122  fUserExtension = 0;
123  fFWExtension = 0;
124 }
125
126 ////////////////////////////////////////////////////////////////////////////////
127 ///copy constructor
128
130  TNamed(gn),
131  TGeoAtt(gn),
132  fVolume(gn.fVolume),
133  fMother(gn.fMother),
134  fNumber(gn.fNumber),
135  fNovlp(gn.fNovlp),
136  fOverlaps(gn.fOverlaps),
137  fUserExtension(gn.fUserExtension->Grab()),
138  fFWExtension(gn.fFWExtension->Grab())
139 {
140 }
141
142 ////////////////////////////////////////////////////////////////////////////////
143 ///assignment operator
144
146 {
147  if(this!=&gn) {
148  TNamed::operator=(gn);
149  TGeoAtt::operator=(gn);
150  fVolume=gn.fVolume;
151  fMother=gn.fMother;
152  fNumber=gn.fNumber;
153  fNovlp=gn.fNovlp;
154  fOverlaps=gn.fOverlaps;
157  }
158  return *this;
159 }
160
161 ////////////////////////////////////////////////////////////////////////////////
162 /// Destructor
163
165 {
166  if (fOverlaps) delete [] fOverlaps;
169 }
170
171 ////////////////////////////////////////////////////////////////////////////////
172 /// How-to-browse for a node.
173
175 {
176  if (!b) return;
177  if (!GetNdaughters()) return;
178  TGeoNode *daughter;
179  TString title;
180  for (Int_t i=0; i<GetNdaughters(); i++) {
181  daughter = GetDaughter(i);
183  }
184 }
185
186 ////////////////////////////////////////////////////////////////////////////////
187 /// Returns the number of daughters. Nodes pointing to same volume counted
188 /// once if unique_volumes is set.
189
191 {
192  static Int_t icall = 0;
193  Int_t counter = 0;
194  // Count this node
195  if (unique_volumes) {
196  if (!fVolume->IsSelected()) {
197  counter++;
199  }
200  } else counter++;
201  icall++;
202  Int_t nd = fVolume->GetNdaughters();
203  // Count daughters recursively
204  for (Int_t i=0; i<nd; i++) counter += GetDaughter(i)->CountDaughters(unique_volumes);
205  icall--;
206  // Un-mark volumes
207  if (icall == 0) fVolume->SelectVolume(kTRUE);
208  return counter;
209 }
210
211 ////////////////////////////////////////////////////////////////////////////////
212 /// Check overlaps bigger than OVLP hierarchically, starting with this node.
213
215 {
216  Int_t icheck = 0;
217  Int_t ncheck = 0;
218  TStopwatch *timer;
219  Int_t i;
220  Bool_t sampling = kFALSE;
221  TString opt(option);
222  opt.ToLower();
223  if (opt.Contains("s")) sampling = kTRUE;
224
225  TGeoManager *geom = fVolume->GetGeoManager();
226  ncheck = CountDaughters(kFALSE);
227  timer = new TStopwatch();
228  geom->ClearOverlaps();
229  geom->SetCheckingOverlaps(kTRUE);
230  Info("CheckOverlaps", "Checking overlaps for %s and daughters within %g", fVolume->GetName(),ovlp);
231  if (sampling) {
232  Info("CheckOverlaps", "Checking overlaps by sampling <%s> for %s and daughters", option, fVolume->GetName());
233  Info("CheckOverlaps", "=== NOTE: Extrusions NOT checked with sampling option ! ===");
234  }
235  timer->Start();
236  geom->GetGeomPainter()->OpProgress(fVolume->GetName(),icheck,ncheck,timer,kFALSE);
237  fVolume->CheckOverlaps(ovlp,option);
238  icheck++;
239  TGeoIterator next(fVolume);
240  TGeoNode *node;
241  TString path;
242  TObjArray *overlaps = geom->GetListOfOverlaps();
243  Int_t novlps;
244  TString msg;
245  while ((node=next())) {
246  next.GetPath(path);
247  icheck++;
248  if (!node->GetVolume()->IsSelected()) {
249  msg = TString::Format("found %d overlaps", overlaps->GetEntriesFast());
250  geom->GetGeomPainter()->OpProgress(node->GetVolume()->GetName(),icheck,ncheck,timer,kFALSE, msg);
251  node->GetVolume()->SelectVolume(kFALSE);
252  node->GetVolume()->CheckOverlaps(ovlp,option);
253  }
254  }
257  geom->SortOverlaps();
258  novlps = overlaps->GetEntriesFast();
259  TNamed *obj;
260  for (i=0; i<novlps; i++) {
261  obj = (TNamed*)overlaps->At(i);
262  obj->SetName(TString::Format("ov%05d",i));
263  }
264  geom->GetGeomPainter()->OpProgress("Check overlaps:",icheck,ncheck,timer,kTRUE);
265  Info("CheckOverlaps", "Number of illegal overlaps/extrusions : %d\n", novlps);
266  delete timer;
267 }
268
269 ////////////////////////////////////////////////////////////////////////////////
270 /// compute the closest distance of approach from point px,py to this node
271
273 {
274  Int_t dist = 9999;
275  if (!fVolume) return dist;
278  if (!painter) return dist;
279  dist = painter->DistanceToPrimitiveVol(fVolume, px, py);
280  return dist;
281 }
282
283 ////////////////////////////////////////////////////////////////////////////////
284 /// Execute mouse actions on this volume.
285
287 {
288  if (!fVolume) return;
290  if (!painter) return;
291  painter->ExecuteVolumeEvent(fVolume, event, px, py);
292 }
293
294 ////////////////////////////////////////////////////////////////////////////////
295 /// Get node info for the browser.
296
298 {
299  if (!fVolume) return 0;
301  if (!painter) return 0;
302  return (char*)painter->GetVolumeInfo(fVolume, px, py);
303 }
304
305 ////////////////////////////////////////////////////////////////////////////////
306 /// check if this node is drawn. Assumes that this node is current
307
309 {
311  return kFALSE;
312 }
313
314 ////////////////////////////////////////////////////////////////////////////////
315 /// Inspect this node.
316
318 {
319  printf("== Inspecting node %s ", GetName());
320  if (fMother) printf("mother volume %s. ", fMother->GetName());
321  if (IsOverlapping()) printf("(Node is MANY)\n");
322  else printf("\n");
323  if (fOverlaps && fMother) {
324  printf(" possibly overlapping with : ");
325  for (Int_t i=0; i<fNovlp; i++)
326  printf(" %s ", fMother->GetNode(fOverlaps[i])->GetName());
327  printf("\n");
328  }
329  printf("Transformation matrix:\n");
330  TGeoMatrix *matrix = GetMatrix();
331  if (GetMatrix()) matrix->Print();
332  fVolume->Print();
333 }
334
335 ////////////////////////////////////////////////////////////////////////////////
336 /// check for wrong parameters in shapes
337
339 {
340  fVolume->CheckShapes();
341  Int_t nd = GetNdaughters();
342  if (!nd) return;
343  for (Int_t i=0; i<nd; i++) fVolume->GetNode(i)->CheckShapes();
344 }
345
346 ////////////////////////////////////////////////////////////////////////////////
347 /// draw only this node independently of its vis options
348
350 {
351  fVolume->DrawOnly(option);
352 }
353
354 ////////////////////////////////////////////////////////////////////////////////
355 /// draw current node according to option
356
358 {
360  gGeoManager->CdUp();
361  Double_t point[3];
363  gGeoManager->SetCurrentPoint(&point[0]);
364  gGeoManager->GetCurrentVolume()->Draw(option);
365 }
366
367 ////////////////////////////////////////////////////////////////////////////////
368 /// Method drawing the overlap candidates with this node.
369
371 {
372  if (!fNovlp) {printf("node %s is ONLY\n", GetName()); return;}
373  if (!fOverlaps) {printf("node %s no overlaps\n", GetName()); return;}
374  TGeoNode *node;
375  Int_t i;
376  Int_t nd = fMother->GetNdaughters();
377  for (i=0; i<nd; i++) {
378  node = fMother->GetNode(i);
379  node->GetVolume()->SetVisibility(kFALSE);
380  }
382  for (i=0; i<fNovlp; i++) {
383  node = fMother->GetNode(fOverlaps[i]);
384  node->GetVolume()->SetVisibility(kTRUE);
385  }
387  fMother->Draw();
388 }
389
390 ////////////////////////////////////////////////////////////////////////////////
391 /// Fill array with node id. Recursive on node branch.
392
393 void TGeoNode::FillIdArray(Int_t &ifree, Int_t &nodeid, Int_t *array) const
394 {
395  Int_t nd = GetNdaughters();
396  if (!nd) return;
397  TGeoNode *daughter;
398  Int_t istart = ifree; // start index for daughters
399  ifree += nd;
400  for (Int_t id=0; id<nd; id++) {
401  daughter = GetDaughter(id);
402  array[istart+id] = ifree;
403  array[ifree++] = ++nodeid;
404  daughter->FillIdArray(ifree, nodeid, array);
405  }
406 }
407
408
409 ////////////////////////////////////////////////////////////////////////////////
410 /// Search for a node within the branch of this one.
411
413 {
414  Int_t nd = GetNdaughters();
415  if (!nd) return -1;
416  TIter next(fVolume->GetNodes());
417  TGeoNode *daughter;
418  while ((daughter=(TGeoNode*)next())) {
419  if (daughter==node) {
421  return (level+1);
422  }
423  }
424  next.Reset();
425  Int_t new_level;
426  while ((daughter=(TGeoNode*)next())) {
427  new_level = daughter->FindNode(node, level+1);
428  if (new_level>=0) {
430  return new_level;
431  }
432  }
433  return -1;
434 }
435
436 ////////////////////////////////////////////////////////////////////////////////
437 /// save attributes for this node
438
439 void TGeoNode::SaveAttributes(std::ostream &out)
440 {
441  if (IsVisStreamed()) return;
443  char quote='"';
444  Bool_t voldef = kFALSE;
445  if ((fVolume->IsVisTouched()) && (!fVolume->IsVisStreamed())) {
447  out << " vol = gGeoManager->GetVolume("<<quote<<fVolume->GetName()<<quote<<");"<<std::endl;
448  voldef = kTRUE;
449  if (!fVolume->IsVisDaughters())
450  out << " vol->SetVisDaughters(kFALSE);"<<std::endl;
451  if (fVolume->IsVisible()) {
452 /*
453  if (fVolume->GetLineColor() != gStyle->GetLineColor())
454  out<<" vol->SetLineColor("<<fVolume->GetLineColor()<<");"<<std::endl;
455  if (fVolume->GetLineStyle() != gStyle->GetLineStyle())
456  out<<" vol->SetLineStyle("<<fVolume->GetLineStyle()<<");"<<std::endl;
457  if (fVolume->GetLineWidth() != gStyle->GetLineWidth())
458  out<<" vol->SetLineWidth("<<fVolume->GetLineWidth()<<");"<<std::endl;
459 */
460  } else {
461  out <<" vol->SetVisibility(kFALSE);"<<std::endl;
462  }
463  }
464  if (!IsVisDaughters()) return;
465  Int_t nd = GetNdaughters();
466  if (!nd) return;
467  TGeoNode *node;
468  for (Int_t i=0; i<nd; i++) {
469  node = GetDaughter(i);
470  if (node->IsVisStreamed()) continue;
471  if (node->IsVisTouched()) {
472  if (!voldef)
473  out << " vol = gGeoManager->GetVolume("<<quote<<fVolume->GetName()<<quote<<");"<<std::endl;
474  out<<" node = vol->GetNode("<<i<<");"<<std::endl;
475  if (!node->IsVisDaughters()) {
476  out<<" node->VisibleDaughters(kFALSE);"<<std::endl;
477  node->SetVisStreamed(kTRUE);
478  continue;
479  }
480  if (!node->IsVisible())
481  out<<" node->SetVisibility(kFALSE);"<<std::endl;
482  }
483  node->SaveAttributes(out);
484  node->SetVisStreamed(kTRUE);
485  }
486 }
487
488 ////////////////////////////////////////////////////////////////////////////////
489 /// Connect user-defined extension to the node. The node "grabs" a copy, so
490 /// the original object can be released by the producer. Release the previously
491 /// connected extension if any.
492 ///
493 /// NOTE: This interface is intended for user extensions and is guaranteed not
494 /// to be used by TGeo
495
497 {
499  fUserExtension = 0;
500  if (ext) fUserExtension = ext->Grab();
501 }
502
503 ////////////////////////////////////////////////////////////////////////////////
504 /// Connect framework defined extension to the node. The node "grabs" a copy,
505 /// so the original object can be released by the producer. Release the previously
506 /// connected extension if any.
507 ///
508 /// NOTE: This interface is intended for the use by TGeo and the users should
509 /// NOT connect extensions using this method
510
512 {
514  fFWExtension = 0;
515  if (ext) fFWExtension = ext->Grab();
516 }
517
518 ////////////////////////////////////////////////////////////////////////////////
519 /// Get a copy of the user extension pointer. The user must call Release() on
520 /// the copy pointer once this pointer is not needed anymore (equivalent to
521 /// delete() after calling new())
522
524 {
525  if (fUserExtension) return fUserExtension->Grab();
526  return 0;
527 }
528
529 ////////////////////////////////////////////////////////////////////////////////
530 /// Get a copy of the framework extension pointer. The user must call Release() on
531 /// the copy pointer once this pointer is not needed anymore (equivalent to
532 /// delete() after calling new())
533
535 {
536  if (fFWExtension) return fFWExtension->Grab();
537  return 0;
538 }
539 ////////////////////////////////////////////////////////////////////////////////
540 /// Check the overlab between the bounding box of the node overlaps with the one
541 /// the brother with index IOTHER.
542
544 {
545  if (!fOverlaps) return kFALSE;
546  for (Int_t i=0; i<fNovlp; i++) if (fOverlaps[i]==iother) return kTRUE;
547  return kFALSE;
548 }
549
550 ////////////////////////////////////////////////////////////////////////////////
551 /// Convert the point coordinates from mother reference to local reference system
552
553 void TGeoNode::MasterToLocal(const Double_t *master, Double_t *local) const
554 {
555  GetMatrix()->MasterToLocal(master, local);
556 }
557
558 ////////////////////////////////////////////////////////////////////////////////
559 /// Convert a vector from mother reference to local reference system
560
561 void TGeoNode::MasterToLocalVect(const Double_t *master, Double_t *local) const
562 {
563  GetMatrix()->MasterToLocalVect(master, local);
564 }
565
566 ////////////////////////////////////////////////////////////////////////////////
567 /// Convert the point coordinates from local reference system to mother reference
568
569 void TGeoNode::LocalToMaster(const Double_t *local, Double_t *master) const
570 {
571  GetMatrix()->LocalToMaster(local, master);
572 }
573
574 ////////////////////////////////////////////////////////////////////////////////
575 /// Convert a vector from local reference system to mother reference
576
577 void TGeoNode::LocalToMasterVect(const Double_t *local, Double_t *master) const
578 {
579  GetMatrix()->LocalToMasterVect(local, master);
580 }
581
582 ////////////////////////////////////////////////////////////////////////////////
583 /// Print the path (A/B/C/...) to this node on stdout
584
585 void TGeoNode::ls(Option_t * /*option*/) const
586 {
587 }
588
589 ////////////////////////////////////////////////////////////////////////////////
590 /// Paint this node and its content according to visualization settings.
591
593 {
595  if (!painter) return;
596  painter->PaintNode(this, option);
597 }
598
599 ////////////////////////////////////////////////////////////////////////////////
600 /// print daughters candidates for containing current point
601
603 {
604  Double_t point[3];
606  printf(" Local : %g, %g, %g\n", point[0], point[1], point[2]);
607  if (!fVolume->Contains(&point[0])) {
608  printf("current point not inside this\n");
609  return;
610  }
611  TGeoPatternFinder *finder = fVolume->GetFinder();
612  TGeoNode *node;
613  if (finder) {
614  printf("current node divided\n");
615  node = finder->FindNode(&point[0]);
616  if (!node) {
617  printf("point not inside division element\n");
618  return;
619  }
620  printf("inside division element %s\n", node->GetName());
621  return;
622  }
623  TGeoVoxelFinder *voxels = fVolume->GetVoxels();
624  if (!voxels) {
625  printf("volume not voxelized\n");
626  return;
627  }
628  Int_t ncheck = 0;
630  TGeoStateInfo &info = *nav->GetCache()->GetInfo();
631  Int_t *check_list = voxels->GetCheckList(&point[0], ncheck, info);
632  nav->GetCache()->ReleaseInfo();
633  voxels->PrintVoxelLimits(&point[0]);
634  if (!check_list) {
635  printf("no candidates for current point\n");
636  return;
637  }
638  TString overlap = "ONLY";
639  for (Int_t id=0; id<ncheck; id++) {
640  node = fVolume->GetNode(check_list[id]);
641  if (node->IsOverlapping()) overlap = "MANY";
642  else overlap = "ONLY";
643  printf("%i %s %s\n", check_list[id], node->GetName(), overlap.Data());
644  }
645  PrintOverlaps();
646 }
647
648 ////////////////////////////////////////////////////////////////////////////////
649 /// print possible overlapping nodes
650
652 {
653  if (!fOverlaps) {printf("node %s no overlaps\n", GetName()); return;}
654  printf("Overlaps for node %s :\n", GetName());
655  TGeoNode *node;
656  for (Int_t i=0; i<fNovlp; i++) {
657  node = fMother->GetNode(fOverlaps[i]);
658  printf(" %s\n", node->GetName());
659  }
660 }
661
662 ////////////////////////////////////////////////////////////////////////////////
663 /// computes the closest distance from given point to this shape
664
665 Double_t TGeoNode::Safety(const Double_t *point, Bool_t in) const
666 {
667  Double_t local[3];
668  GetMatrix()->MasterToLocal(point,local);
669  return fVolume->GetShape()->Safety(local,in);
670 }
671
672 ////////////////////////////////////////////////////////////////////////////////
673 /// set the list of overlaps for this node (ovlp must be created with operator new)
674
676 {
677  if (fOverlaps) delete [] fOverlaps;
678  fOverlaps = ovlp;
679  fNovlp = novlp;
680 }
681
682 ////////////////////////////////////////////////////////////////////////////////
683 /// Set visibility of the node (obsolete).
684
686 {
689  if (vis && !fVolume->IsVisible()) fVolume->SetVisibility(vis);
691 }
692
693 ////////////////////////////////////////////////////////////////////////////////
694 /// Set visibility of the daughters (obsolete).
695
697 {
699  SetVisDaughters(vis);
701 }
702
703 /** \class TGeoNodeMatrix
704 \ingroup Geometry_classes
705 A node containing local transformation.
706 */
707
709
710 ////////////////////////////////////////////////////////////////////////////////
711 /// Default constructor
712
714 {
715  fMatrix = 0;
716 }
717
718 ////////////////////////////////////////////////////////////////////////////////
719 /// Constructor.
720
722  TGeoNode(vol)
723 {
724  fMatrix = (TGeoMatrix*)matrix;
725  if (!fMatrix) fMatrix = gGeoIdentity;
726 }
727
728 ////////////////////////////////////////////////////////////////////////////////
729 /// Copy ctor.
730
732  :TGeoNode(gnm),
733  fMatrix(gnm.fMatrix)
734 {
735 }
736
737 ////////////////////////////////////////////////////////////////////////////////
738 /// Assignment.
739
741 {
742  if (this!=&gnm) {
743  TGeoNode::operator=(gnm);
744  fMatrix=gnm.fMatrix;
745  }
746  return *this;
747 }
748
749 ////////////////////////////////////////////////////////////////////////////////
750 /// Destructor
751
753 {
754 }
755
756 ////////////////////////////////////////////////////////////////////////////////
757 /// return the total size in bytes of this node
758
760 {
761  Int_t count = 40 + 4; // TGeoNode + fMatrix
762 // if (fMatrix) count += fMatrix->GetByteCount();
763  return count;
764 }
765
766 ////////////////////////////////////////////////////////////////////////////////
767 /// Returns type of optimal voxelization for this node.
768 /// - type = 0 -> cartesian
769 /// - type = 1 -> cylindrical
770
772 {
774  if (!type) return 0;
776  const Double_t *transl = fMatrix->GetTranslation();
777  if (TMath::Abs(transl[0])>1E-10) return 0;
778  if (TMath::Abs(transl[1])>1E-10) return 0;
779  return 1;
780 }
781
782 ////////////////////////////////////////////////////////////////////////////////
783 /// Make a copy of this node.
784
786 {
788  node->SetName(GetName());
789  // set the mother
790  node->SetMotherVolume(fMother);
791  // set the copy number
792  node->SetNumber(fNumber);
793  // copy overlaps
794  if (fNovlp>0) {
795  if (fOverlaps) {
796  Int_t *ovlps = new Int_t[fNovlp];
797  memcpy(ovlps, fOverlaps, fNovlp*sizeof(Int_t));
798  node->SetOverlaps(ovlps, fNovlp);
799  } else {
800  node->SetOverlaps(fOverlaps, fNovlp);
801  }
802  }
803  // copy VC
804  if (IsVirtual()) node->SetVirtual();
805  if (IsOverlapping()) node->SetOverlapping(); // <--- ADDED
806  // Copy extensions
809  node->SetCloned();
810  return node;
811 }
812
813 ////////////////////////////////////////////////////////////////////////////////
814 /// Matrix setter.
815
817 {
818  fMatrix = (TGeoMatrix*)matrix;
819  if (!fMatrix) fMatrix = gGeoIdentity;
820 }
821
822 /** \class TGeoNodeOffset
823 \ingroup Geometry_classes
824 Node containing an offset.
825 */
826
828
829 ////////////////////////////////////////////////////////////////////////////////
830 /// Default constructor
831
833 {
835  fOffset = 0;
836  fIndex = 0;
837  fFinder = 0;
838 }
839
840 ////////////////////////////////////////////////////////////////////////////////
841 /// Constructor. Null pointer to matrix means identity transformation
842
844  TGeoNode(vol)
845 {
847  fOffset = offset;
848  fIndex = index;
849  fFinder = 0;
850 }
851
852 ////////////////////////////////////////////////////////////////////////////////
853 ///copy constructor
854
856  TGeoNode(gno),
857  fOffset(gno.fOffset),
858  fIndex(gno.fIndex),
859  fFinder(gno.fFinder)
860 {
861 }
862
863 ////////////////////////////////////////////////////////////////////////////////
864 /// Assignment operator
865
867 {
868  if(this!=&gno) {
869  TGeoNode::operator=(gno);
870  fOffset=gno.fOffset;
871  fIndex=gno.fIndex;
872  fFinder=gno.fFinder;
873  }
874  return *this;
875 }
876
877 ////////////////////////////////////////////////////////////////////////////////
878 /// Destructor
879
881 {
882 }
883
884 ////////////////////////////////////////////////////////////////////////////////
885 /// Get the index of this offset.
886
888 {
889  return (fIndex+fFinder->GetDivIndex());
890 }
891
892 ////////////////////////////////////////////////////////////////////////////////
893 /// Make a copy of this node
894
896 {
898  node->SetName(GetName());
899  // set the mother
900  node->SetMotherVolume(fMother);
901  // set the copy number
902  node->SetNumber(fNumber);
903  if (IsVirtual()) node->SetVirtual();
904  // set the finder
905  node->SetFinder(GetFinder());
906  // set extensions
909  return node;
910 }
911
912 /** \class TGeoIterator
913 \ingroup Geometry_classes
914 A geometry iterator.
915
916 A geometry iterator that sequentially follows all nodes of the geometrical
917 hierarchy of a volume. The iterator has to be initiated with a top volume
918 pointer:
919
920 ~~~ {.cpp}
921  TGeoIterator next(myVolume);
922 ~~~
923
924 One can use the iterator as any other in ROOT:
925
926 ~~~ {.cpp}
927  TGeoNode *node;
928  while ((node=next())) {
929  ...
930  }
931 ~~~
932
933 The iterator can perform 2 types of iterations that can be selected via:
934
935 ~~~ {.cpp}
936  next.SetType(Int_t type);
937 ~~~
938
939 Here TYPE can be:
940  - 0 (default) - 'first daughter next' behavior
941  - 1 - iteration at the current level only
942
943 Supposing the tree structure looks like:
944
945 ~~~ {.cpp}
946 TOP ___ A_1 ___ A1_1 ___ A11_1
947  | | |___ A12_1
948  | |_____A2_1 ___ A21_1
949  | |___ A21_2
950  |___ B_1 ...
951 ~~~
952
953 The order of iteration for TYPE=0 is: A_1, A1_1, A11_1, A12_1, A2_1, A21_1,
954 A21_2, B_1, ...
955
956 The order of iteration for TYPE=1 is: A_1, B_1, ...
957 At any moment during iteration, TYPE can be changed. If the last iterated node
958 is for instance A1_1 and the iteration type was 0, one can do:
959
960 ~~~ {.cpp}
961  next.SetType(1);
962 ~~~
963
964 The next iterated nodes will be the rest of A daughters: A2,A3,... The iterator
965 will return 0 after finishing all daughters of A.
966
967 During iteration, the following can be retrieved:
968  - Top volume where iteration started: TGeoIterator::GetTopVolume()
969  - Node at level I in the current branch: TGeoIterator::GetNode(Int_t i)
970  - Iteration type: TGeoIterator::GetType()
971  - Global matrix of the current node with respect to the top volume:
972  TGeoIterator::GetCurrentMatrix()
973
974 The iterator can be reset by changing (or not) the top volume:
975
976 ~~~ {.cpp}
977  TGeoIterator::Reset(TGeoVolume *top);
978 ~~~
979
980 ### Example:
981
982 We want to find out a volume named "MyVol" in the hierarchy of TOP volume.
983
984 ~~~ {.cpp}
985  TIter next(TOP);
986  TGeoNode *node;
987  TString name("MyVol");
988  while ((node=next()))
989  if (name == node->GetVolume()->GetName()) return node->GetVolume();
990 ~~~
991 */
992
993 /** \class TGeoIteratorPlugin
994 \ingroup Geometry_classes
995 */
996
999
1000 ////////////////////////////////////////////////////////////////////////////////
1001 /// Geometry iterator for a branch starting with a TOP node.
1002
1004 {
1005  fTop = top;
1006  fLevel = 0;
1007  fMustResume = kFALSE;
1008  fMustStop = kFALSE;
1009  fType = 0;
1010  fArray = new Int_t[30];
1011  fMatrix = new TGeoHMatrix();
1012  fTopName = fTop->GetName();
1013  fPlugin = 0;
1014  fPluginAutoexec = kFALSE;
1015 }
1016
1017 ////////////////////////////////////////////////////////////////////////////////
1018 /// Copy ctor.
1019
1021 {
1022  fTop = iter.GetTopVolume();
1023  fLevel = iter.GetLevel();
1024  fMustResume = kFALSE;
1025  fMustStop = kFALSE;
1026  fType = iter.GetType();
1027  fArray = new Int_t[30+ 30*Int_t(fLevel/30)];
1028  for (Int_t i=0; i<fLevel+1; i++) fArray[i] = iter.GetIndex(i);
1029  fMatrix = new TGeoHMatrix(*iter.GetCurrentMatrix());
1030  fTopName = fTop->GetName();
1031  fPlugin = iter.fPlugin;
1032  fPluginAutoexec = iter.fPluginAutoexec;;
1033 }
1034
1035 ////////////////////////////////////////////////////////////////////////////////
1036 /// Destructor.
1037
1039 {
1040  if (fArray) delete [] fArray;
1041  delete fMatrix;
1042 }
1043
1044 ////////////////////////////////////////////////////////////////////////////////
1045 /// Assignment.
1046
1048 {
1049  if (&iter == this) return *this;
1050  fTop = iter.GetTopVolume();
1051  fLevel = iter.GetLevel();
1052  fMustResume = kFALSE;
1053  fMustStop = kFALSE;
1054  fType = iter.GetType();
1055  if (fArray) delete [] fArray;
1056  fArray = new Int_t[30+ 30*Int_t(fLevel/30)];
1057  for (Int_t i=0; i<fLevel+1; i++) fArray[i] = iter.GetIndex(i);
1058  if (!fMatrix) fMatrix = new TGeoHMatrix();
1059  *fMatrix = *iter.GetCurrentMatrix();
1060  fTopName = fTop->GetName();
1061  fPlugin = iter.fPlugin;
1062  fPluginAutoexec = iter.fPluginAutoexec;;
1063  return *this;
1064 }
1065
1066 ////////////////////////////////////////////////////////////////////////////////
1067 /// Returns next node.
1068
1070 {
1071  if (fMustStop) return 0;
1072  TGeoNode *mother = 0;
1073  TGeoNode *next = 0;
1074  Int_t i;
1075  Int_t nd = fTop->GetNdaughters();
1076  if (!nd) {
1077  fMustStop = kTRUE;
1078  return 0;
1079  }
1080  if (!fLevel) {
1081  fArray[++fLevel] = 0;
1082  next = fTop->GetNode(0);
1083  if (fPlugin && fPluginAutoexec) fPlugin->ProcessNode();
1084  return next;
1085  }
1086  next = fTop->GetNode(fArray[1]);
1087  // Move to current node
1088  for (i=2; i<fLevel+1; i++) {
1089  mother = next;
1090  next = mother->GetDaughter(fArray[i]);
1091  }
1092  if (fMustResume) {
1093  fMustResume = kFALSE;
1094  if (fPlugin && fPluginAutoexec) fPlugin->ProcessNode();
1095  return next;
1096  }
1097
1098  switch (fType) {
1099  case 0: // default next daughter behavior
1100  nd = next->GetNdaughters();
1101  if (nd) {
1102  // First daughter next
1103  fLevel++;
1104  if ((fLevel%30)==0) IncreaseArray();
1105  fArray[fLevel] = 0;
1106  if (fPlugin && fPluginAutoexec) fPlugin->ProcessNode();
1107  return next->GetDaughter(0);
1108  }
1109  // cd up and pick next
1110  while (next) {
1111  next = GetNode(fLevel-1);
1112  if (!next) {
1113  nd = fTop->GetNdaughters();
1114  if (fArray[fLevel]<nd-1) {
1115  fArray[fLevel]++;
1116  if (fPlugin && fPluginAutoexec) fPlugin->ProcessNode();
1117  return fTop->GetNode(fArray[fLevel]);
1118  }
1119  fMustStop = kTRUE;
1120  return 0;
1121  } else {
1122  nd = next->GetNdaughters();
1123  if (fArray[fLevel]<nd-1) {
1124  fArray[fLevel]++;
1125  if (fPlugin && fPluginAutoexec) fPlugin->ProcessNode();
1126  return next->GetDaughter(fArray[fLevel]);
1127  }
1128  }
1129  fLevel--;
1130  }
1131  break;
1132  case 1: // one level search
1133  if (mother) nd = mother->GetNdaughters();
1134  if (fArray[fLevel]<nd-1) {
1135  fArray[fLevel]++;
1136  if (fPlugin && fPluginAutoexec) fPlugin->ProcessNode();
1137  if (!mother) return fTop->GetNode(fArray[fLevel]);
1138  else return mother->GetDaughter(fArray[fLevel]);
1139  }
1140  }
1141  fMustStop = kTRUE;
1142  return 0;
1143 }
1144
1145 ////////////////////////////////////////////////////////////////////////////////
1146 /// Returns next node.
1147
1149 {
1150  return Next();
1151 }
1152
1153 ////////////////////////////////////////////////////////////////////////////////
1154 /// Returns global matrix for current node.
1155
1157 {
1158  fMatrix->Clear();
1159  if (!fLevel) return fMatrix;
1160  TGeoNode *node = fTop->GetNode(fArray[1]);
1161  fMatrix->Multiply(node->GetMatrix());
1162  for (Int_t i=2; i<fLevel+1; i++) {
1163  node = node->GetDaughter(fArray[i]);
1164  fMatrix->Multiply(node->GetMatrix());
1165  }
1166  return fMatrix;
1167 }
1168
1169 ////////////////////////////////////////////////////////////////////////////////
1170 /// Returns current node at a given level.
1171
1173 {
1174  if (!level || level>fLevel) return 0;
1175  TGeoNode *node = fTop->GetNode(fArray[1]);
1176  for (Int_t i=2; i<level+1; i++) node = node->GetDaughter(fArray[i]);
1177  return node;
1178 }
1179
1180 ////////////////////////////////////////////////////////////////////////////////
1181 /// Returns the path for the current node.
1182
1184 {
1185  path = fTopName;
1186  if (!fLevel) return;
1187  TGeoNode *node = fTop->GetNode(fArray[1]);
1188  path += "/";
1189  path += node->GetName();
1190  for (Int_t i=2; i<fLevel+1; i++) {
1191  node = node->GetDaughter(fArray[i]);
1192  path += "/";
1193  path += node->GetName();
1194  }
1195 }
1196
1197 ////////////////////////////////////////////////////////////////////////////////
1198 /// Increase by 30 the size of the array.
1199
1201 {
1202  Int_t *array = new Int_t[fLevel+30];
1203  memcpy(array, fArray, fLevel*sizeof(Int_t));
1204  delete [] fArray;
1205  fArray = array;
1206 }
1207
1208 ////////////////////////////////////////////////////////////////////////////////
1209 /// Resets the iterator for volume TOP.
1210
1212 {
1213  if (top) fTop = top;
1214  fLevel = 0;
1215  fMustResume = kFALSE;
1216  fMustStop = kFALSE;
1217 }
1218
1219 ////////////////////////////////////////////////////////////////////////////////
1220 /// Set the top name for path
1221
1223 {
1224  fTopName = name;
1225 }
1226
1227 ////////////////////////////////////////////////////////////////////////////////
1228 /// Stop iterating the current branch. The iteration of the next node will
1229 /// behave as if the branch starting from the current node (included) is not existing.
1230
1232 {
1233  fMustResume = kTRUE;
1234  TGeoNode *next = GetNode(fLevel);
1235  if (!next) return;
1236  Int_t nd;
1237  switch (fType) {
1238  case 0: // default next daughter behavior
1239  // cd up and pick next
1240  while (next) {
1241  next = GetNode(fLevel-1);
1242  nd = (next==0)?fTop->GetNdaughters():next->GetNdaughters();
1243  if (fArray[fLevel]<nd-1) {
1244  ++fArray[fLevel];
1245  return;
1246  }
1247  fLevel--;
1248  if (!fLevel) {
1249  fMustStop = kTRUE;
1250  return;
1251  }
1252  }
1253  break;
1254  case 1: // one level search
1255  next = GetNode(fLevel-1);
1256  nd = (next==0)?fTop->GetNdaughters():next->GetNdaughters();
1257  if (fArray[fLevel]<nd-1) {
1258  ++fArray[fLevel];
1259  return;
1260  }
1261  fMustStop = kTRUE;
1262  break;
1263  }
1264 }
1265
1266 ////////////////////////////////////////////////////////////////////////////////
1267 /// Set a plugin.
1268
1270 {
1271  fPlugin = plugin;
1272  if (plugin) plugin->SetIterator(this);
1273 }
Statefull info for the current geometry level.
Definition: TGeoStateInfo.h:21
void Add(TObject *obj, const char *name=0, Int_t check=-1)
Add object with name to browser.
Definition: TBrowser.cxx:261
virtual void ls(Option_t *option="") const
Print the path (A/B/C/...) to this node on stdout.
Definition: TGeoNode.cxx:585
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
TGeoVolume * fMother
Definition: TGeoNode.h:44
A node containing local transformation.
Definition: TGeoNode.h:149
Send "Modified" signal to painter.
double dist(Rotation3D const &r1, Rotation3D const &r2)
Definition: 3DDistances.cxx:48
TGeoPatternFinder * fFinder
Definition: TGeoNode.h:186
Int_t fNovlp
Definition: TGeoNode.h:46
An array of TObjects.
Definition: TObjArray.h:37
void SetReplicated()
Definition: TGeoVolume.h:214
virtual void LocalToMasterVect(const Double_t *local, Double_t *master) const
Convert a vector from local reference system to mother reference.
Definition: TGeoNode.cxx:577
void Print(Option_t *option="") const
print the matrix in 4x4 format
Definition: TGeoMatrix.cxx:486
void GetPath(TString &path) const
Returns the path for the current node.
Definition: TGeoNode.cxx:1183
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition: TObject.cxx:854
Bool_t TestAttBit(UInt_t f) const
Definition: TGeoAtt.h:68
The manager class for any TGeo geometry.
Definition: TGeoManager.h:38
void DrawOnly(Option_t *option="")
draw only this node independently of its vis options
Definition: TGeoNode.cxx:349
virtual void MasterToLocalVect(const Double_t *master, Double_t *local) const
convert a point by multiplying its column vector (x, y, z, 1) to matrix
Definition: TGeoMatrix.cxx:431
void Start(Bool_t reset=kTRUE)
Start the stopwatch.
Definition: TStopwatch.cxx:58
Int_t fNumber
Definition: TGeoNode.h:45
TGeoNode()
Default constructor.
Definition: TGeoNode.cxx:95
void SetUserPlugin(TGeoIteratorPlugin *plugin)
Set a plugin.
Definition: TGeoNode.cxx:1269
virtual void ExecuteVolumeEvent(TGeoVolume *volume, Int_t event, Int_t px, Int_t py)=0
Bool_t IsOverlapping() const
Definition: TGeoNode.h:102
void SetVirtual()
Definition: TGeoNode.h:116
const char Option_t
Definition: RtypesCore.h:62
Geometrical transformation package.
Definition: TGeoMatrix.h:40
Visualization and tracking attributes for volumes and nodes.
Definition: TGeoAtt.h:17
virtual TGeoNode * FindNode(Double_t *, const Double_t *=0)
virtual Int_t * GetCheckList(const Double_t *point, Int_t &nelem, TGeoStateInfo &td)
get the list of daughter indices for which point is inside their bbox
TGeoStateInfo * GetInfo()
Get next state info pointer.
Definition: TGeoCache.cxx:318
TGeoNode * GetNode(const char *name) const
get the pointer to a daughter node
void CdUp()
Go one level up in geometry.
TVirtualGeoPainter * GetPainter() const
Definition: TGeoManager.h:191
virtual ~TGeoIterator()
Destructor.
Definition: TGeoNode.cxx:1038
virtual void SetVisibility(Bool_t vis=kTRUE)
Set visibility for this object.
Definition: TGeoAtt.cxx:105
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition: TNamed.cxx:140
virtual void MasterToLocalVect(const Double_t *master, Double_t *local) const
Convert a vector from mother reference to local reference system.
Definition: TGeoNode.cxx:561
TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes.
Definition: TGeoVolume.h:48
void Skip()
Stop iterating the current branch.
Definition: TGeoNode.cxx:1231
virtual void Draw(Option_t *option="")
draw top volume according to option
virtual void Print(Option_t *option="") const
Print volume info.
Int_t FindNode(const TGeoNode *node, Int_t level)
Search for a node within the branch of this one.
Definition: TGeoNode.cxx:412
TGeoNode * Next()
Returns next node.
Definition: TGeoNode.cxx:1069
virtual char * GetObjectInfo(Int_t px, Int_t py) const
Get node info for the browser.
Definition: TGeoNode.cxx:297
TGeoNode * operator()()
Returns next node.
Definition: TGeoNode.cxx:1148
TGeoMatrix * fMatrix
Definition: TGeoNode.h:152
Basic string class.
Definition: TString.h:131
Matrix class used for computing global transformations Should NOT be used for node definition...
Definition: TGeoMatrix.h:420
void MasterToLocal(const Double_t *master, Double_t *local) const
Definition: TGeoManager.h:517
virtual void DrawOnly(Option_t *option="")
draw only this volume
void ToLower()
Change string to lower-case.
Definition: TString.cxx:1100
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
Double_t fOffset
Definition: TGeoNode.h:184
TGeoNodeCache * GetCache() const
TGeoNode * GetNode(Int_t level) const
Returns current node at a given level.
Definition: TGeoNode.cxx:1172
virtual void Paint(Option_t *option="")
Paint this node and its content according to visualization settings.
Definition: TGeoNode.cxx:592
void Reset(TGeoVolume *top=0)
Resets the iterator for volume TOP.
Definition: TGeoNode.cxx:1211
TObject * At(Int_t idx) const
Definition: TObjArray.h:165
void IncreaseArray()
Increase by 30 the size of the array.
Definition: TGeoNode.cxx:1200
TGeoVoxelFinder * GetVoxels() const
Getter for optimization structure.
Short_t Abs(Short_t d)
Definition: TMathBase.h:108
void VisibleDaughters(Bool_t vis=kTRUE)
Set visibility of the daughters (obsolete).
Definition: TGeoNode.cxx:696
virtual TGeoPatternFinder * GetFinder() const
Definition: TGeoNode.h:202
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:694
Int_t GetType() const
Definition: TGeoNode.h:281
virtual void PaintNode(TGeoNode *node, Option_t *option="", TGeoMatrix *global=0)=0
virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py)
Execute mouse actions on this volume.
Definition: TGeoNode.cxx:286
TObjArray * GetNodes()
Definition: TGeoVolume.h:170
Int_t GetNdaughters() const
Definition: TGeoVolume.h:350
virtual void Clear(Option_t *option="")
Set name and title to empty strings ("").
Definition: TNamed.cxx:64
void SetUserExtension(TGeoExtension *ext)
Connect user-defined extension to the node.
Definition: TGeoNode.cxx:496
TGeoExtension * fUserExtension
Definition: TGeoNode.h:48
TGeoPatternFinder * GetFinder() const
Definition: TGeoVolume.h:178
void PrintVoxelLimits(const Double_t *point) const
print the voxel containing point
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:2286
Int_t GetLevel() const
Definition: TGeoNode.h:274
void PrintOverlaps() const
print possible overlapping nodes
Definition: TGeoNode.cxx:651
virtual Int_t GetOptimalVoxels() const
Returns type of optimal voxelization for this node.
Definition: TGeoNode.cxx:771
void SetCurrentPoint(Double_t *point)
Definition: TGeoManager.h:506
TObjArray * GetListOfNodes()
Definition: TGeoManager.h:462
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
A geometry iterator.
Definition: TGeoNode.h:243
virtual TGeoNode * MakeCopyNode() const
Make a copy of this node.
Definition: TGeoNode.cxx:785
void SetVisStreamed(Bool_t vis=kTRUE)
Mark attributes as "streamed to file".
Definition: TGeoAtt.cxx:123
void InspectNode() const
Inspect this node.
Definition: TGeoNode.cxx:317
void SortOverlaps()
Sort overlaps by decreasing overlap distance. Extrusions comes first.
void SetFWExtension(TGeoExtension *ext)
Connect framework defined extension to the node.
Definition: TGeoNode.cxx:511
Bool_t IsOnScreen() const
check if this node is drawn. Assumes that this node is current
Definition: TGeoNode.cxx:308
const TGeoMatrix * GetCurrentMatrix() const
Returns global matrix for current node.
Definition: TGeoNode.cxx:1156
void SetTopName(const char *name)
Set the top name for path.
Definition: TGeoNode.cxx:1222
virtual Bool_t IsVisible() const
Definition: TGeoVolume.h:156
virtual TGeoMatrix * GetMatrix() const =0
virtual ~TGeoNodeOffset()
Destructor.
Definition: TGeoNode.cxx:880
Definition: TGeoVolume.h:148
XFontStruct * id
Definition: TGX11.cxx:108
virtual void LocalToMasterVect(const Double_t *local, Double_t *master) const
convert a vector by multiplying its column vector (x, y, z, 1) to matrix inverse
Definition: TGeoMatrix.cxx:363
TGeoIteratorPlugin * fPlugin
Definition: TGeoNode.h:255
virtual Int_t DistanceToPrimitiveVol(TGeoVolume *vol, Int_t px, Int_t py)=0
Definition: TGeoVolume.h:213
void Browse(TBrowser *b)
How-to-browse for a node.
Definition: TGeoNode.cxx:174
virtual Int_t GetIndex() const
Get the index of this offset.
Definition: TGeoNode.cxx:887
void ReleaseInfo()
Release last used state info pointer.
Definition: TGeoCache.cxx:335
Base finder class for patterns.
Bool_t fPluginAutoexec
Definition: TGeoNode.h:256
Using a TBrowser one can browse all ROOT objects.
Definition: TBrowser.h:37
virtual void Release() const =0
Int_t GetIndex(Int_t i) const
Definition: TGeoNode.h:273
void DrawOverlaps()
Method drawing the overlap candidates with this node.
Definition: TGeoNode.cxx:370
TNamed & operator=(const TNamed &rhs)
TNamed assignment operator.
Definition: TNamed.cxx:51
void CheckOverlaps(Double_t ovlp=0.1, Option_t *option="")
Check overlaps bigger than OVLP hierarchically, starting with this node.
Definition: TGeoNode.cxx:214
void SetMotherVolume(TGeoVolume *mother)
Definition: TGeoNode.h:120
TGeoNode * GetDaughter(Int_t ind) const
Definition: TGeoNode.h:82
TGeoVolume * fVolume
Definition: TGeoNode.h:43
void SaveAttributes(std::ostream &out)
save attributes for this node
Definition: TGeoNode.cxx:439
Bool_t IsVisStreamed() const
Definition: TGeoAtt.h:95
void Draw(Option_t *option="")
draw current node according to option
Definition: TGeoNode.cxx:357
ABC for user objects attached to TGeoVolume or TGeoNode.
Definition: TGeoExtension.h:19
void PrintCandidates() const
print daughters candidates for containing current point
Definition: TGeoNode.cxx:602
TGeoExtension * fFWExtension
Transient user-defined extension to volumes.
Definition: TGeoNode.h:49
virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) const =0
void SetMatrix(const TGeoMatrix *matrix)
Matrix setter.
Definition: TGeoNode.cxx:816
TGeoVolume * GetCurrentVolume() const
Definition: TGeoManager.h:494
virtual Int_t GetByteCount() const
return the total size in bytes of this node
Definition: TGeoNode.cxx:759
Int_t GetEntriesFast() const
Definition: TObjArray.h:64
Bool_t IsVisDaughters() const
Definition: TGeoNode.h:105
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:880
Bool_t IsVirtual() const
Definition: TGeoNode.h:103
TGeoNodeMatrix()
Default constructor.
Definition: TGeoNode.cxx:713
void CheckOverlaps(Double_t ovlp=0.1, Option_t *option="") const
Overlap checking tool.
Definition: TGeoVolume.cxx:641
void SetIterator(const TGeoIterator *iter)
Definition: TGeoNode.h:232
virtual void AddAt(TObject *obj, Int_t idx)
Definition: TObjArray.cxx:253
constexpr Double_t E()
Base of natural log: .
Definition: TMath.h:97
virtual void LocalToMaster(const Double_t *local, Double_t *master) const
convert a point by multiplying its column vector (x, y, z, 1) to matrix inverse
Definition: TGeoMatrix.cxx:339
Int_t CountDaughters(Bool_t unique_volumes=kFALSE)
Returns the number of daughters.
Definition: TGeoNode.cxx:190
TGeoNode * FindNode(Bool_t safe_start=kTRUE)
Returns deepest node containing current point.
Bool_t Contains(const Double_t *point) const
Definition: TGeoVolume.h:112
virtual void MasterToLocal(const Double_t *master, Double_t *local) const
Convert the point coordinates from mother reference to local reference system.
Definition: TGeoNode.cxx:553
const Bool_t kFALSE
Definition: RtypesCore.h:88
PyObject * fType
void SetFinder(TGeoPatternFinder *finder)
Definition: TGeoNode.h:205
void SetCloned(Bool_t flag=kTRUE)
Definition: TGeoNode.h:114
void SetOverlapping(Bool_t flag=kTRUE)
Definition: TGeoNode.h:115
#define ClassImp(name)
Definition: Rtypes.h:359
R__EXTERN TGeoManager * gGeoManager
Definition: TGeoManager.h:562
virtual void MasterToLocal(const Double_t *master, Double_t *local) const
convert a point by multiplying its column vector (x, y, z, 1) to matrix
Definition: TGeoMatrix.cxx:406
double Double_t
Definition: RtypesCore.h:55
virtual void SetVisibility(Bool_t vis=kTRUE)
set visibility of this volume
int type
Definition: TGX11.cxx:120
TGeoExtension * GrabFWExtension() const
Get a copy of the framework extension pointer.
Definition: TGeoNode.cxx:534
TGeoNodeMatrix & operator=(const TGeoNodeMatrix &gnm)
Assignment.
Definition: TGeoNode.cxx:740
Int_t * fOverlaps
Definition: TGeoNode.h:47
virtual const char * GetVolumeInfo(const TGeoVolume *volume, Int_t px, Int_t py) const =0
Node containing an offset.
Definition: TGeoNode.h:181
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:619
void FillIdArray(Int_t &ifree, Int_t &nodeid, Int_t *array) const
Fill array with node id. Recursive on node branch.
Definition: TGeoNode.cxx:393
Finder class handling voxels.
void SetCheckingOverlaps(Bool_t flag=kTRUE)
Definition: TGeoManager.h:396
Binding & operator=(OUT(*fun)(void))
Bool_t IsSelected() const
Definition: TGeoVolume.h:151
TGeoNode & operator=(const TGeoNode &)
assignment operator
Definition: TGeoNode.cxx:145
virtual ~TGeoNode()
Destructor.
Definition: TGeoNode.cxx:164
Class providing navigation API for TGeo geometries.
Definition: TGeoNavigator.h:33
Bool_t MayOverlap(Int_t iother) const
Check the overlab between the bounding box of the node overlaps with the one the brother with index I...
Definition: TGeoNode.cxx:543
Abstract class for geometry painters.
void ClearOverlaps()
Clear the list of overlaps.
A node represent a volume positioned inside another.They store links to both volumes and to the TGeoM...
Definition: TGeoNode.h:39
void CheckShapes()
check for wrong parameters in shapes
Definition: TGeoNode.cxx:338
virtual Int_t DistancetoPrimitive(Int_t px, Int_t py)
compute the closest distance of approach from point px,py to this node
Definition: TGeoNode.cxx:272
virtual TGeoExtension * Grab()=0
TGeoNodeOffset()
Default constructor.
Definition: TGeoNode.cxx:832
R__EXTERN TGeoIdentity * gGeoIdentity
Definition: TGeoMatrix.h:478
void SetVisLevel(Int_t level=3)
set default level down to which visualization is performed
Bool_t IsVisDaughters() const
Definition: TGeoAtt.h:89
TGeoNavigator * GetCurrentNavigator() const
Returns current navigator for the calling thread.
Bool_t IsVisTouched() const
Definition: TGeoAtt.h:96
TGeoExtension * GrabUserExtension() const
Get a copy of the user extension pointer.
Definition: TGeoNode.cxx:523
Double_t Safety(const Double_t *point, Bool_t in=kTRUE) const
computes the closest distance from given point to this shape
Definition: TGeoNode.cxx:665
void SetVisDaughters(Bool_t vis=kTRUE)
Set visibility for the daughters.
Definition: TGeoAtt.cxx:114
virtual void LocalToMaster(const Double_t *local, Double_t *master) const
Convert the point coordinates from local reference system to mother reference.
Definition: TGeoNode.cxx:569
const Double_t * GetCurrentPoint() const
Definition: TGeoManager.h:492
you should not use this method at all Int_t Int_t Double_t Double_t Double_t Int_t Double_t Double_t Double_t Double_t b
Definition: TRolke.cxx:630
Int_t GetNdaughters() const
Definition: TGeoNode.h:90
virtual TGeoNode * MakeCopyNode() const
Make a copy of this node.
Definition: TGeoNode.cxx:895
Int_t fIndex
Definition: TGeoNode.h:185
TGeoManager * GetGeoManager() const
Definition: TGeoVolume.h:174
virtual ~TGeoNodeMatrix()
Destructor.
Definition: TGeoNode.cxx:752
void SetVisibility(Bool_t vis=kTRUE)
Set visibility of the node (obsolete).
Definition: TGeoNode.cxx:685
TObjArray * GetListOfOverlaps()
Definition: TGeoManager.h:464
Bool_t IsClosed() const
Definition: TGeoManager.h:283
TGeoShape * GetShape() const
Definition: TGeoVolume.h:191
virtual void OpProgress(const char *opname, Long64_t current, Long64_t size, TStopwatch *watch=0, Bool_t last=kFALSE, Bool_t refresh=kFALSE, const char *msg="")=0
void SetVisTouched(Bool_t vis=kTRUE)
Mark visualization attributes as "modified".
Definition: TGeoAtt.cxx:131
void CheckShapes()
check for negative parameters in shapes.
Definition: TGeoVolume.cxx:700
TGeoNodeOffset & operator=(const TGeoNodeOffset &)
Assignment operator.
Definition: TGeoNode.cxx:866
const Bool_t kTRUE
Definition: RtypesCore.h:87
virtual const Double_t * GetTranslation() const =0
virtual Bool_t IsCylType() const =0
void SelectVolume(Bool_t clear=kFALSE)
Select this volume as matching an arbitrary criteria.
TVirtualGeoPainter * GetGeomPainter()
Make a default painter if none present. Returns pointer to it.
TGeoVolume * GetVolume() const
Definition: TGeoNode.h:94
Returns true if no rotation or the rotation is about Z axis.
Definition: TGeoMatrix.cxx:269
TGeoIterator & operator=(const TGeoIterator &iter)
Assignment.
Definition: TGeoNode.cxx:1047
char name[80]
Definition: TGX11.cxx:109
void SetOverlaps(Int_t *ovlp, Int_t novlp)
set the list of overlaps for this node (ovlp must be created with operator new)
Definition: TGeoNode.cxx:675
void SetNumber(Int_t number)
Definition: TGeoNode.h:113
TGeoVolume * GetTopVolume() const
Definition: TGeoNode.h:280
Bool_t IsVisible() const
Definition: TGeoNode.h:104
const char * Data() const
Definition: TString.h:364
Stopwatch class.
Definition: TStopwatch.h:28