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 :
53  enum EGeoPatternFlags {
54  kPatternReflected = BIT(14),
55  kPatternSpacedOut = BIT(15)
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:
68  TGeoPatternFinder(const TGeoPatternFinder&);
69  TGeoPatternFinder& operator=(const TGeoPatternFinder&);
70 
71 public:
72  // constructors
73  TGeoPatternFinder();
74  TGeoPatternFinder(TGeoVolume *vol, Int_t ndiv);
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;}
84  Int_t GetDivIndex() {return fDivIndex;}
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;}
95  Bool_t IsReflected() const {return TObject::TestBit(kPatternReflected);}
96  Bool_t IsSpacedOut() const {return TObject::TestBit(kPatternSpacedOut);}
97  virtual
98  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE) = 0;
99  void Reflect(Bool_t flag=kTRUE) {TObject::SetBit(kPatternReflected,flag);}
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);
103  void SetSpacedOut(Bool_t flag) {TObject::SetBit(kPatternSpacedOut,flag);}
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 
118 class TGeoPatternX : public TGeoPatternFinder
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);
127  TGeoPatternX& operator=(const TGeoPatternX&);
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
139  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
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 
152 class TGeoPatternY : public TGeoPatternFinder
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);
161  TGeoPatternY& operator=(const TGeoPatternY&);
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
172  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
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 
185 class TGeoPatternZ : public TGeoPatternFinder
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);
194  TGeoPatternZ& operator=(const TGeoPatternZ&);
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
205  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
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 
218 class TGeoPatternParaX : public TGeoPatternFinder
219 {
220 public:
221  // constructors
222  TGeoPatternParaX();
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);
226  TGeoPatternParaX(const TGeoPatternParaX &pf);
227  TGeoPatternParaX& operator=(const TGeoPatternParaX&);
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
238  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
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 
251 class TGeoPatternParaY : public TGeoPatternFinder
252 {
253 private :
254 // data members
255  Double_t fTxy; // tangent of alpha
256 public:
257  // constructors
258  TGeoPatternParaY();
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);
262  TGeoPatternParaY(const TGeoPatternParaY &pf);
263  TGeoPatternParaY& operator=(const TGeoPatternParaY&);
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
274  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
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 
287 class TGeoPatternParaZ : public TGeoPatternFinder
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
295  TGeoPatternParaZ();
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);
299  TGeoPatternParaZ(const TGeoPatternParaZ &pf);
300  TGeoPatternParaZ& operator=(const TGeoPatternParaZ&);
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
311  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
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 
324 class TGeoPatternTrapZ : public TGeoPatternFinder
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
332  TGeoPatternTrapZ();
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);
336  TGeoPatternTrapZ(const TGeoPatternTrapZ &pf);
337  TGeoPatternTrapZ& operator=(const TGeoPatternTrapZ&);
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
350  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
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 
364 class TGeoPatternCylR : public TGeoPatternFinder
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);
373  TGeoPatternCylR& operator=(const TGeoPatternCylR&);
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
383  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
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 
396 class TGeoPatternCylPhi : public TGeoPatternFinder
397 {
398 private :
399 // data members
400  Double_t *fSinCos; //![2*fNdivisions] table of sines/cosines
401 
402 protected:
403  TGeoPatternCylPhi(const TGeoPatternCylPhi& pfc)
404  : TGeoPatternFinder(pfc), fSinCos(pfc.fSinCos) {CreateThreadData(1);}
405  TGeoPatternCylPhi& operator=(const TGeoPatternCylPhi& pfc)
406  {if(this!=&pfc) {TGeoPatternFinder::operator=(pfc); fSinCos=pfc.fSinCos; CreateThreadData(1);}
407  return *this;}
408 
409 public:
410  // constructors
411  TGeoPatternCylPhi();
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
424  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
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 
437 class TGeoPatternSphR : public TGeoPatternFinder
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);
446  TGeoPatternSphR& operator=(const TGeoPatternSphR&);
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
455  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
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 
468 class TGeoPatternSphTheta : public TGeoPatternFinder
469 {
470 public:
471  // constructors
472  TGeoPatternSphTheta();
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);
476  TGeoPatternSphTheta(const TGeoPatternSphTheta &pf);
477  TGeoPatternSphTheta& operator=(const TGeoPatternSphTheta&);
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
486  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
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 
499 class TGeoPatternSphPhi : public TGeoPatternFinder
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
510  TGeoPatternSphPhi();
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
523  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
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 
536 class TGeoPatternHoneycomb : public TGeoPatternFinder
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:
546  TGeoPatternHoneycomb(const TGeoPatternHoneycomb&);
547  TGeoPatternHoneycomb& operator=(const TGeoPatternHoneycomb&);
548 
549 public:
550  // constructors
551  TGeoPatternHoneycomb();
552  TGeoPatternHoneycomb(TGeoVolume *vol, Int_t nrows);
553  // destructor
554  virtual ~TGeoPatternHoneycomb();
555  // methods
556  TGeoPatternFinder *MakeCopy(Bool_t) {return 0;}
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
TGeoPatternFinder::ThreadData_t::operator=
ThreadData_t & operator=(const ThreadData_t &)
TGeoPatternParaY::GetDivAxis
virtual Int_t GetDivAxis()
Definition: TGeoPatternFinder.h:271
TGeoPatternFinder::CreateThreadData
void CreateThreadData(Int_t nthreads)
Create thread data for n threads max.
Definition: TGeoPatternFinder.cxx:119
TGeoPatternSphR::GetDivAxis
virtual Int_t GetDivAxis()
Definition: TGeoPatternFinder.h:453
TGeoPatternFinder::SetVolume
void SetVolume(TGeoVolume *vol)
Definition: TGeoPatternFinder.h:104
TGeoPatternY::GetDivAxis
virtual Int_t GetDivAxis()
Definition: TGeoPatternFinder.h:169
Option_t
const char Option_t
Definition: RtypesCore.h:62
TGeoMatrix
Geometrical transformation package.
Definition: TGeoMatrix.h:40
TGeoPatternFinder::FindNode
virtual TGeoNode * FindNode(Double_t *, const Double_t *=0)
Definition: TGeoPatternFinder.h:81
TGeoPatternFinder::GetByteCount
virtual Int_t GetByteCount() const
Definition: TGeoPatternFinder.h:82
TGeoVolume::GetNode
TGeoNode * GetNode(const char *name) const
get the pointer to a daughter node
Definition: TGeoVolume.cxx:2112
TObject::TestBit
Bool_t TestBit(UInt_t f) const
Definition: TObject.h:157
BIT
#define BIT(n)
Definition: Rtypes.h:120
TGeoPatternFinder::GetNodeOffset
TGeoNode * GetNodeOffset(Int_t idiv)
Definition: TGeoPatternFinder.h:89
TGeoPatternTrapZ::GetTxz
Double_t GetTxz() const
Definition: TGeoPatternFinder.h:343
TGeoVolume
TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes.
Definition: TGeoVolume.h:61
TGeoPatternFinder::operator=
TGeoPatternFinder & operator=(const TGeoPatternFinder &)
assignment operator
Definition: TGeoPatternFinder.cxx:178
TGeoPatternFinder::GetThreadData
ThreadData_t & GetThreadData() const
Definition: TGeoPatternFinder.cxx:75
TGeoTranslation
Class describing translations.
Definition: TGeoMatrix.h:131
TGeoPatternFinder::ThreadData_t::~ThreadData_t
~ThreadData_t()
Destructor.
Definition: TGeoPatternFinder.cxx:68
TGeoHMatrix
Matrix class used for computing global transformations Should NOT be used for node definition...
Definition: TGeoMatrix.h:410
Int_t
int Int_t
Definition: RtypesCore.h:41
Bool_t
bool Bool_t
Definition: RtypesCore.h:59
kFALSE
const Bool_t kFALSE
Definition: Rtypes.h:92
TGeoPatternFinder::GetNdiv
Int_t GetNdiv() const
Definition: TGeoPatternFinder.h:87
TGeoPatternCylR::GetDivAxis
virtual Int_t GetDivAxis()
Definition: TGeoPatternFinder.h:380
TGeoPatternFinder::GetCurrent
Int_t GetCurrent()
Return current index.
Definition: TGeoPatternFinder.cxx:203
TObject::SetBit
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:739
ClassDef
#define ClassDef(name, id)
Definition: Rtypes.h:254
TGeoPatternSphPhi::GetDivAxis
virtual Int_t GetDivAxis()
Definition: TGeoPatternFinder.h:520
TGeoPatternParaX::GetDivAxis
virtual Int_t GetDivAxis()
Definition: TGeoPatternFinder.h:235
TGeoPatternFinder::fThreadSize
Int_t fThreadSize
Vector of thread private transient data.
Definition: TGeoPatternFinder.h:65
TGeoPatternFinder::ThreadData_t
Definition: TGeoPatternFinder.h:36
TGeoPatternFinder::GetVolume
TGeoVolume * GetVolume() const
Definition: TGeoPatternFinder.h:93
TGeoPatternFinder::TGeoPatternFinder
TGeoPatternFinder()
Default constructor.
Definition: TGeoPatternFinder.cxx:136
TGeoPatternFinder::fVolume
TGeoVolume * fVolume
Definition: TGeoPatternFinder.h:62
TGeoPatternFinder::SetRange
void SetRange(Double_t start, Double_t step, Int_t ndivisions)
Set division range. Use this method only when dividing an assembly.
Definition: TGeoPatternFinder.cxx:246
TGeoPatternFinder
Base finder class for patterns.
Definition: TGeoPatternFinder.h:33
TGeoPatternFinder::GetStep
Double_t GetStep() const
Definition: TGeoPatternFinder.h:91
TGeoPatternFinder::ThreadData_t::fCurrent
Int_t fCurrent
generic matrix
Definition: TGeoPatternFinder.h:39
TGeoPatternSphTheta::GetDivAxis
virtual Int_t GetDivAxis()
Definition: TGeoPatternFinder.h:484
TGeoPatternFinder::SetSpacedOut
void SetSpacedOut(Bool_t flag)
Definition: TGeoPatternFinder.h:103
TGeoPatternHoneycomb::MakeCopy
TGeoPatternFinder * MakeCopy(Bool_t)
Definition: TGeoPatternFinder.h:556
TGeoPatternFinder::MakeCopy
virtual TGeoPatternFinder * MakeCopy(Bool_t reflect=kFALSE)=0
TGeoPatternParaZ::GetDivAxis
virtual Int_t GetDivAxis()
Definition: TGeoPatternFinder.h:308
TGeoPatternFinder::GetStart
Double_t GetStart() const
Definition: TGeoPatternFinder.h:90
TGeoPatternFinder::ThreadData_t::fNextIndex
Int_t fNextIndex
current division element
Definition: TGeoPatternFinder.h:40
TGeoPatternFinder::IsOnBoundary
virtual Bool_t IsOnBoundary(const Double_t *) const
Definition: TGeoPatternFinder.h:94
TGeoPatternCylPhi::operator=
TGeoPatternCylPhi & operator=(const TGeoPatternCylPhi &pfc)
Definition: TGeoPatternFinder.h:405
TGeoPatternFinder::SetDivIndex
void SetDivIndex(Int_t index)
Definition: TGeoPatternFinder.h:100
TGeoPatternFinder::UpdateMatrix
virtual void UpdateMatrix(Int_t, TGeoHMatrix &) const
Definition: TGeoPatternFinder.h:105
TGeoPatternFinder::CreateMatrix
virtual TGeoMatrix * CreateMatrix() const =0
TGeoPatternCylPhi::TGeoPatternCylPhi
TGeoPatternCylPhi(const TGeoPatternCylPhi &pfc)
[2*fNdivisions] table of sines/cosines
Definition: TGeoPatternFinder.h:403
TGeoPatternFinder::IsReflected
Bool_t IsReflected() const
Definition: TGeoPatternFinder.h:95
Double_t
double Double_t
Definition: RtypesCore.h:55
TGeoPatternFinder::GetMatrix
virtual TGeoMatrix * GetMatrix()
Return current matrix.
Definition: TGeoPatternFinder.cxx:211
TGeoPatternTrapZ::GetTyz
Double_t GetTyz() const
Definition: TGeoPatternFinder.h:344
TGeoPatternFinder::GetDivAxis
virtual Int_t GetDivAxis()
Definition: TGeoPatternFinder.h:85
TObject
Mother of all ROOT objects.
Definition: TObject.h:37
TGeoPatternFinder::IsSpacedOut
Bool_t IsSpacedOut() const
Definition: TGeoPatternFinder.h:96
TGeoNode
A node represent a volume positioned inside another.They store links to both volumes and to the TGeoM...
Definition: TGeoNode.h:51
TGeoPatternTrapZ::GetDivAxis
virtual Int_t GetDivAxis()
Definition: TGeoPatternFinder.h:347
TGeoPatternFinder::~TGeoPatternFinder
virtual ~TGeoPatternFinder()
Destructor.
Definition: TGeoPatternFinder.cxx:195
TGeoPatternZ::GetDivAxis
virtual Int_t GetDivAxis()
Definition: TGeoPatternFinder.h:202
TGeoPatternFinder::GetEnd
Double_t GetEnd() const
Definition: TGeoPatternFinder.h:92
TGeoPatternFinder::ThreadData_t::fMatrix
TGeoMatrix * fMatrix
Definition: TGeoPatternFinder.h:38
TGeoPatternFinder::CdNext
virtual TGeoNode * CdNext()
Make next node (if any) current.
Definition: TGeoPatternFinder.cxx:235
TGeoPatternX::GetDivAxis
virtual Int_t GetDivAxis()
Definition: TGeoPatternFinder.h:136
TGeoPatternFinder::cd
virtual void cd(Int_t)
Definition: TGeoPatternFinder.h:79
TGeoPatternFinder::ClearThreadData
void ClearThreadData() const
Definition: TGeoPatternFinder.cxx:102
TGeoPatternFinder::GetNext
Int_t GetNext() const
Get index of next division.
Definition: TGeoPatternFinder.cxx:219
kTRUE
const Bool_t kTRUE
Definition: Rtypes.h:91
TGeoPatternFinder::SetNext
void SetNext(Int_t index)
Set index of next division.
Definition: TGeoPatternFinder.cxx:227
TGeoPatternCylPhi::GetDivAxis
virtual Int_t GetDivAxis()
Definition: TGeoPatternFinder.h:421
TGeoPatternFinder::fThreadData
std::vector< ThreadData_t * > fThreadData
Definition: TGeoPatternFinder.h:64
TGeoPatternFinder::ThreadData_t::ThreadData_t
ThreadData_t()
index of next node
Definition: TGeoPatternFinder.cxx:60
TGeoPatternFinder::Reflect
void Reflect(Bool_t flag=kTRUE)
Definition: TGeoPatternFinder.h:99
TObject::SavePrimitive
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