Logo ROOT   6.08/07
Reference Guide
TGeoPatternFinder.h
Go to the documentation of this file.
1 // @(#)root/geom:$Id$
2 // Author: Andrei Gheata 30/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 #ifndef ROOT_TGeoPatternFinder
13 #define ROOT_TGeoPatternFinder
14 
15 #ifndef ROOT_TObject
16 #include "TObject.h"
17 #endif
18 
19 #ifndef ROOT_TGeoVolume
20 #include "TGeoVolume.h"
21 #endif
22 
23 
24 class TGeoMatrix;
25 
26 /////////////////////////////////////////////////////////////////////////////////
27 // //
28 // TGeoPatternFinder - base finder class for patterns. A pattern is specifying //
29 // a division type //
30 // //
31 /////////////////////////////////////////////////////////////////////////////////
32 
33 class TGeoPatternFinder : public TObject
34 {
35 public:
36  struct ThreadData_t
37  {
38  TGeoMatrix *fMatrix; //! generic matrix
39  Int_t fCurrent; //! current division element
40  Int_t fNextIndex; //! index of next node
41 
42  ThreadData_t();
43  ~ThreadData_t();
44  private:
45  ThreadData_t(const ThreadData_t&); // Not implemented
46  ThreadData_t& operator=(const ThreadData_t&); // Not implemented
47  };
48  ThreadData_t& GetThreadData() const;
49  void ClearThreadData() const;
50  void CreateThreadData(Int_t nthreads);
51 
52 protected :
56  };
57  Double_t fStep; // division step length
58  Double_t fStart; // starting point on divided axis
59  Double_t fEnd; // ending point
60  Int_t fNdivisions; // number of divisions
61  Int_t fDivIndex; // index of first div. node
62  TGeoVolume *fVolume; // volume to which applies
63 
64  mutable std::vector<ThreadData_t*> fThreadData; //! Vector of thread private transient data
65  mutable Int_t fThreadSize; //! Size of the thread vector
66 
67 protected:
70 
71 public:
72  // constructors
75  // destructor
76  virtual ~TGeoPatternFinder();
77  // methods
78  virtual TGeoMatrix* CreateMatrix() const = 0;
79  virtual void cd(Int_t /*idiv*/) {}
80  virtual TGeoNode *CdNext();
81  virtual TGeoNode *FindNode(Double_t * /*point*/, const Double_t * /*dir*/=0) {return 0;}
82  virtual Int_t GetByteCount() const {return 36;}
83  Int_t GetCurrent();// {return fCurrent;}
85  virtual Int_t GetDivAxis() {return 1;}
86  virtual TGeoMatrix *GetMatrix();// {return fMatrix;}
87  Int_t GetNdiv() const {return fNdivisions;}
88  Int_t GetNext() const;// {return fNextIndex;}
89  TGeoNode *GetNodeOffset(Int_t idiv) {return fVolume->GetNode(fDivIndex+idiv);}
90  Double_t GetStart() const {return fStart;}
91  Double_t GetStep() const {return fStep;}
92  Double_t GetEnd() const {return fEnd;}
93  TGeoVolume *GetVolume() const {return fVolume;}
94  virtual Bool_t IsOnBoundary(const Double_t * /*point*/) const {return kFALSE;}
97  virtual
100  void SetDivIndex(Int_t index) {fDivIndex = index;}
101  void SetNext(Int_t index);// {fNextIndex = index;}
102  void SetRange(Double_t start, Double_t step, Int_t ndivisions);
104  void SetVolume(TGeoVolume *vol) {fVolume = vol;}
105  virtual void UpdateMatrix(Int_t , TGeoHMatrix &) const {}
106 
107  ClassDef(TGeoPatternFinder, 4) // patterns to divide volumes
108 };
109 
110 ////////////////////////////////////////////////////////////////////////////
111 // //
112 // TGeoPatternX - a X axis divison pattern //
113 // //
114 ////////////////////////////////////////////////////////////////////////////
115 
116 class TGeoTranslation;
117 
119 {
120 public:
121  // constructors
122  TGeoPatternX();
123  TGeoPatternX(TGeoVolume *vol, Int_t ndivisions);
124  TGeoPatternX(TGeoVolume *vol, Int_t ndivisions, Double_t step);
125  TGeoPatternX(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
126  TGeoPatternX(const TGeoPatternX &pf);
128 
129  // destructor
130  virtual ~TGeoPatternX();
131  // methods
132  virtual TGeoMatrix* CreateMatrix() const;
133  virtual void cd(Int_t idiv);
134  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
135  virtual Double_t FindNextBoundary(Double_t *point, Double_t *dir, Int_t &indnext);
136  virtual Int_t GetDivAxis() {return 1;}
137  virtual Bool_t IsOnBoundary(const Double_t *point) const;
138  virtual
140  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
141  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
142 
143  ClassDef(TGeoPatternX, 1) // X division pattern
144 };
145 
146 ////////////////////////////////////////////////////////////////////////////
147 // //
148 // TGeoPatternY - a Y axis divison pattern //
149 // //
150 ////////////////////////////////////////////////////////////////////////////
151 
153 {
154 public:
155  // constructors
156  TGeoPatternY();
157  TGeoPatternY(TGeoVolume *vol, Int_t ndivisions);
158  TGeoPatternY(TGeoVolume *vol, Int_t ndivisions, Double_t step);
159  TGeoPatternY(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
160  TGeoPatternY(const TGeoPatternY &pf);
162  // destructor
163  virtual ~TGeoPatternY();
164  // methods
165  virtual TGeoMatrix* CreateMatrix() const;
166  virtual void cd(Int_t idiv);
167  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
168  virtual Double_t FindNextBoundary(Double_t *point, Double_t *dir, Int_t &indnext);
169  virtual Int_t GetDivAxis() {return 2;}
170  virtual Bool_t IsOnBoundary(const Double_t *point) const;
171  virtual
173  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
174  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
175 
176  ClassDef(TGeoPatternY, 1) // Y division pattern
177 };
178 
179 ////////////////////////////////////////////////////////////////////////////
180 // //
181 // TGeoPatternZ - a Z axis divison pattern //
182 // //
183 ////////////////////////////////////////////////////////////////////////////
184 
186 {
187 public:
188  // constructors
189  TGeoPatternZ();
190  TGeoPatternZ(TGeoVolume *vol, Int_t ndivisions);
191  TGeoPatternZ(TGeoVolume *vol, Int_t ndivisions, Double_t step);
192  TGeoPatternZ(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
193  TGeoPatternZ(const TGeoPatternZ &pf);
195  // destructor
196  virtual ~TGeoPatternZ();
197  // methods
198  virtual TGeoMatrix* CreateMatrix() const;
199  virtual void cd(Int_t idiv);
200  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
201  virtual Double_t FindNextBoundary(Double_t *point, Double_t *dir, Int_t &indnext);
202  virtual Int_t GetDivAxis() {return 3;}
203  virtual Bool_t IsOnBoundary(const Double_t *point) const;
204  virtual
206  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
207  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
208 
209  ClassDef(TGeoPatternZ, 1) // Z division pattern
210 };
211 
212 ////////////////////////////////////////////////////////////////////////////
213 // //
214 // TGeoPatternParaX - a X axis divison pattern for PARA shapes //
215 // //
216 ////////////////////////////////////////////////////////////////////////////
217 
219 {
220 public:
221  // constructors
223  TGeoPatternParaX(TGeoVolume *vol, Int_t ndivisions);
224  TGeoPatternParaX(TGeoVolume *vol, Int_t ndivisions, Double_t step);
225  TGeoPatternParaX(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
228 
229  // destructor
230  virtual ~TGeoPatternParaX();
231  // methods
232  virtual TGeoMatrix* CreateMatrix() const;
233  virtual void cd(Int_t idiv);
234  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
235  virtual Int_t GetDivAxis() {return 1;}
236  virtual Bool_t IsOnBoundary(const Double_t *point) const;
237  virtual
239  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
240  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
241 
242  ClassDef(TGeoPatternParaX, 1) // Para X division pattern
243 };
244 
245 ////////////////////////////////////////////////////////////////////////////
246 // //
247 // TGeoPatternParaY - a Y axis divison pattern for PARA shapes //
248 // //
249 ////////////////////////////////////////////////////////////////////////////
250 
252 {
253 private :
254 // data members
255  Double_t fTxy; // tangent of alpha
256 public:
257  // constructors
259  TGeoPatternParaY(TGeoVolume *vol, Int_t ndivisions);
260  TGeoPatternParaY(TGeoVolume *vol, Int_t ndivisions, Double_t step);
261  TGeoPatternParaY(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
264 
265  // destructor
266  virtual ~TGeoPatternParaY();
267  // methods
268  virtual TGeoMatrix* CreateMatrix() const;
269  virtual void cd(Int_t idiv);
270  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
271  virtual Int_t GetDivAxis() {return 2;}
272  virtual Bool_t IsOnBoundary(const Double_t *point) const;
273  virtual
275  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
276  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
277 
278  ClassDef(TGeoPatternParaY, 1) // Para Y division pattern
279 };
280 
281 ////////////////////////////////////////////////////////////////////////////
282 // //
283 // TGeoPatternParaZ - a Z axis divison pattern for PARA shapes //
284 // //
285 ////////////////////////////////////////////////////////////////////////////
286 
288 {
289 private :
290 // data members
291  Double_t fTxz; // tangent of alpha xz
292  Double_t fTyz; // tangent of alpha yz
293 public:
294  // constructors
296  TGeoPatternParaZ(TGeoVolume *vol, Int_t ndivisions);
297  TGeoPatternParaZ(TGeoVolume *vol, Int_t ndivisions, Double_t step);
298  TGeoPatternParaZ(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
301 
302  // destructor
303  virtual ~TGeoPatternParaZ();
304  // methods
305  virtual TGeoMatrix* CreateMatrix() const;
306  virtual void cd(Int_t idiv);
307  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
308  virtual Int_t GetDivAxis() {return 3;}
309  virtual Bool_t IsOnBoundary(const Double_t *point) const;
310  virtual
312  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
313  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
314 
315  ClassDef(TGeoPatternParaZ, 1) // Para Z division pattern
316 };
317 
318 ////////////////////////////////////////////////////////////////////////////
319 // //
320 // TGeoPatternTrapZ - a Z axis divison pattern for TRAP or GTRA shapes //
321 // //
322 ////////////////////////////////////////////////////////////////////////////
323 
325 {
326 private :
327 // data members
328  Double_t fTxz; // tangent of alpha xz
329  Double_t fTyz; // tangent of alpha yz
330 public:
331  // constructors
333  TGeoPatternTrapZ(TGeoVolume *vol, Int_t ndivisions);
334  TGeoPatternTrapZ(TGeoVolume *vol, Int_t ndivisions, Double_t step);
335  TGeoPatternTrapZ(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
338 
339  // destructor
340  virtual ~TGeoPatternTrapZ();
341  // methods
342  virtual TGeoMatrix* CreateMatrix() const;
343  Double_t GetTxz() const {return fTxz;}
344  Double_t GetTyz() const {return fTyz;}
345  virtual void cd(Int_t idiv);
346  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
347  virtual Int_t GetDivAxis() {return 3;}
348  virtual Bool_t IsOnBoundary(const Double_t *point) const;
349  virtual
351  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
352  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
353 
354  ClassDef(TGeoPatternTrapZ, 1) // Trap od Gtra Z division pattern
355 };
356 
357 
358 ////////////////////////////////////////////////////////////////////////////
359 // //
360 // TGeoPatternCylR - a cylindrical R divison pattern //
361 // //
362 ////////////////////////////////////////////////////////////////////////////
363 
365 {
366 public:
367  // constructors
368  TGeoPatternCylR();
369  TGeoPatternCylR(TGeoVolume *vol, Int_t ndivisions);
370  TGeoPatternCylR(TGeoVolume *vol, Int_t ndivisions, Double_t step);
371  TGeoPatternCylR(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
372  TGeoPatternCylR(const TGeoPatternCylR &pf);
374  // destructor
375  virtual ~TGeoPatternCylR();
376  // methods
377  virtual TGeoMatrix* CreateMatrix() const;
378  virtual void cd(Int_t idiv);
379  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
380  virtual Int_t GetDivAxis() {return 1;}
381  virtual Bool_t IsOnBoundary(const Double_t *point) const;
382  virtual
384  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
385  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
386 
387  ClassDef(TGeoPatternCylR, 1) // Cylindrical R division pattern
388 };
389 
390 ////////////////////////////////////////////////////////////////////////////
391 // //
392 // TGeoPatternCylPhi - a cylindrical phi divison pattern //
393 // //
394 ////////////////////////////////////////////////////////////////////////////
395 
397 {
398 private :
399 // data members
400  Double_t *fSinCos; //![2*fNdivisions] table of sines/cosines
401 
402 protected:
404  : TGeoPatternFinder(pfc), fSinCos(pfc.fSinCos) {CreateThreadData(1);}
406  {if(this!=&pfc) {TGeoPatternFinder::operator=(pfc); fSinCos=pfc.fSinCos; CreateThreadData(1);}
407  return *this;}
408 
409 public:
410  // constructors
412  TGeoPatternCylPhi(TGeoVolume *vol, Int_t ndivisions);
413  TGeoPatternCylPhi(TGeoVolume *vol, Int_t ndivisions, Double_t step);
414  TGeoPatternCylPhi(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
415  // destructor
416  virtual ~TGeoPatternCylPhi();
417  // methods
418  virtual TGeoMatrix* CreateMatrix() const;
419  virtual void cd(Int_t idiv);
420  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
421  virtual Int_t GetDivAxis() {return 2;}
422  virtual Bool_t IsOnBoundary(const Double_t *point) const;
423  virtual
425  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
426  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
427 
428  ClassDef(TGeoPatternCylPhi, 1) // Cylindrical phi division pattern
429 };
430 
431 ////////////////////////////////////////////////////////////////////////////
432 // //
433 // TGeoPatternSphR - a spherical R divison pattern //
434 // //
435 ////////////////////////////////////////////////////////////////////////////
436 
438 {
439 public:
440  // constructors
441  TGeoPatternSphR();
442  TGeoPatternSphR(TGeoVolume *vol, Int_t ndivisions);
443  TGeoPatternSphR(TGeoVolume *vol, Int_t ndivisions, Double_t step);
444  TGeoPatternSphR(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
445  TGeoPatternSphR(const TGeoPatternSphR &pf);
447  // destructor
448  virtual ~TGeoPatternSphR();
449  // methods
450  virtual TGeoMatrix* CreateMatrix() const;
451  virtual void cd(Int_t idiv);
452  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
453  virtual Int_t GetDivAxis() {return 1;}
454  virtual
456  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
457  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
458 
459  ClassDef(TGeoPatternSphR, 1) // spherical R division pattern
460 };
461 
462 ////////////////////////////////////////////////////////////////////////////
463 // //
464 // TGeoPatternSphTheta - a spherical theta divison pattern //
465 // //
466 ////////////////////////////////////////////////////////////////////////////
467 
469 {
470 public:
471  // constructors
473  TGeoPatternSphTheta(TGeoVolume *vol, Int_t ndivisions);
474  TGeoPatternSphTheta(TGeoVolume *vol, Int_t ndivisions, Double_t step);
475  TGeoPatternSphTheta(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
478  // destructor
479  virtual ~TGeoPatternSphTheta();
480  // methods
481  virtual TGeoMatrix* CreateMatrix() const;
482  virtual void cd(Int_t idiv);
483  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
484  virtual Int_t GetDivAxis() {return 3;}
485  virtual
487  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
488  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
489 
490  ClassDef(TGeoPatternSphTheta, 1) // spherical theta division pattern
491 };
492 
493 ////////////////////////////////////////////////////////////////////////////
494 // //
495 // TGeoPatternSphPhi - a spherical phi divison pattern //
496 // //
497 ////////////////////////////////////////////////////////////////////////////
498 
500 {
501 private:
502  Double_t *fSinCos; //! Sincos table
503 
504 protected:
505  TGeoPatternSphPhi(const TGeoPatternSphPhi& pfc); // Not implemented
506  TGeoPatternSphPhi& operator=(const TGeoPatternSphPhi& pfc); // Not implemented
507  Double_t *CreateSinCos();
508 public:
509  // constructors
511  TGeoPatternSphPhi(TGeoVolume *vol, Int_t ndivisions);
512  TGeoPatternSphPhi(TGeoVolume *vol, Int_t ndivisions, Double_t step);
513  TGeoPatternSphPhi(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
514  // destructor
515  virtual ~TGeoPatternSphPhi();
516  // methods
517  virtual TGeoMatrix* CreateMatrix() const;
518  virtual void cd(Int_t idiv);
519  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
520  virtual Int_t GetDivAxis() {return 2;}
521  virtual Bool_t IsOnBoundary(const Double_t *point) const;
522  virtual
524  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
525  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
526 
527  ClassDef(TGeoPatternSphPhi, 1) // Spherical phi division pattern
528 };
529 
530 ////////////////////////////////////////////////////////////////////////////
531 // //
532 // TGeoPatternHoneycomb - a divison pattern specialized for honeycombs //
533 // //
534 ////////////////////////////////////////////////////////////////////////////
535 
537 {
538 private :
539 // data members
540  Int_t fNrows; // number of rows
541  Int_t fAxisOnRows; // axis along each row
542  Int_t *fNdivisions; // [fNrows] number of divisions for each row
543  Double_t *fStart; // [fNrows] starting points for each row
544 
545 protected:
548 
549 public:
550  // constructors
553  // destructor
554  virtual ~TGeoPatternHoneycomb();
555  // methods
557  virtual TGeoMatrix* CreateMatrix() const;
558  virtual void cd(Int_t idiv);
559  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
560  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
561 
562  ClassDef(TGeoPatternHoneycomb, 1) // pattern for honeycomb divisions
563 };
564 
565 #endif
ThreadData_t & operator=(const ThreadData_t &)
virtual Int_t GetDivAxis()
void CreateThreadData(Int_t nthreads)
Create thread data for n threads max.
virtual Int_t GetDivAxis()
void SetVolume(TGeoVolume *vol)
virtual Int_t GetDivAxis()
const char Option_t
Definition: RtypesCore.h:62
Geometrical transformation package.
Definition: TGeoMatrix.h:40
virtual TGeoNode * FindNode(Double_t *, const Double_t *=0)
virtual Int_t GetByteCount() const
TGeoNode * GetNode(const char *name) const
get the pointer to a daughter node
Bool_t TestBit(UInt_t f) const
Definition: TObject.h:157
#define BIT(n)
Definition: Rtypes.h:120
TGeoNode * GetNodeOffset(Int_t idiv)
Double_t GetTxz() const
TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes.
Definition: TGeoVolume.h:61
TGeoPatternFinder & operator=(const TGeoPatternFinder &)
assignment operator
ThreadData_t & GetThreadData() const
Class describing translations.
Definition: TGeoMatrix.h:131
Matrix class used for computing global transformations Should NOT be used for node definition...
Definition: TGeoMatrix.h:410
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
const Bool_t kFALSE
Definition: Rtypes.h:92
Int_t GetNdiv() const
virtual Int_t GetDivAxis()
Int_t GetCurrent()
Return current index.
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:739
#define ClassDef(name, id)
Definition: Rtypes.h:254
virtual Int_t GetDivAxis()
virtual Int_t GetDivAxis()
Int_t fThreadSize
Vector of thread private transient data.
TGeoVolume * GetVolume() const
TGeoPatternFinder()
Default constructor.
TGeoVolume * fVolume
void SetRange(Double_t start, Double_t step, Int_t ndivisions)
Set division range. Use this method only when dividing an assembly.
Base finder class for patterns.
Double_t GetStep() const
virtual Int_t GetDivAxis()
void SetSpacedOut(Bool_t flag)
TGeoPatternFinder * MakeCopy(Bool_t)
virtual TGeoPatternFinder * MakeCopy(Bool_t reflect=kFALSE)=0
virtual Int_t GetDivAxis()
Double_t GetStart() const
Int_t fNextIndex
current division element
virtual Bool_t IsOnBoundary(const Double_t *) const
TGeoPatternCylPhi & operator=(const TGeoPatternCylPhi &pfc)
void SetDivIndex(Int_t index)
virtual void UpdateMatrix(Int_t, TGeoHMatrix &) const
virtual TGeoMatrix * CreateMatrix() const =0
TGeoPatternCylPhi(const TGeoPatternCylPhi &pfc)
[2*fNdivisions] table of sines/cosines
Bool_t IsReflected() const
double Double_t
Definition: RtypesCore.h:55
virtual TGeoMatrix * GetMatrix()
Return current matrix.
Double_t GetTyz() const
virtual Int_t GetDivAxis()
Mother of all ROOT objects.
Definition: TObject.h:37
Bool_t IsSpacedOut() const
A node represent a volume positioned inside another.They store links to both volumes and to the TGeoM...
Definition: TGeoNode.h:51
virtual Int_t GetDivAxis()
virtual ~TGeoPatternFinder()
Destructor.
virtual Int_t GetDivAxis()
Double_t GetEnd() const
virtual TGeoNode * CdNext()
Make next node (if any) current.
virtual Int_t GetDivAxis()
virtual void cd(Int_t)
void ClearThreadData() const
Int_t GetNext() const
Get index of next division.
const Bool_t kTRUE
Definition: Rtypes.h:91
void SetNext(Int_t index)
Set index of next division.
virtual Int_t GetDivAxis()
std::vector< ThreadData_t * > fThreadData
void Reflect(Bool_t flag=kTRUE)
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save a primitive as a C++ statement(s) on output stream "out".
Definition: TObject.cxx:709