Logo ROOT   6.30.04
Reference Guide
 All Namespaces Files Pages
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 #include <mutex>
16 
17 #include "TObject.h"
18 
19 #include "TGeoVolume.h"
20 
21 
22 class TGeoMatrix;
23 
24 /////////////////////////////////////////////////////////////////////////////////
25 // //
26 // TGeoPatternFinder - base finder class for patterns. A pattern is specifying //
27 // a division type //
28 // //
29 /////////////////////////////////////////////////////////////////////////////////
30 
31 class TGeoPatternFinder : public TObject
32 {
33 public:
34  struct ThreadData_t
35  {
36  TGeoMatrix *fMatrix; //! generic matrix
37  Int_t fCurrent; //! current division element
38  Int_t fNextIndex; //! index of next node
39 
40  ThreadData_t();
41  ~ThreadData_t();
42  private:
43  ThreadData_t(const ThreadData_t&); // Not implemented
44  ThreadData_t& operator=(const ThreadData_t&); // Not implemented
45  };
46  ThreadData_t& GetThreadData() const;
47  void ClearThreadData() const;
48  void CreateThreadData(Int_t nthreads);
49 
50 protected :
51  enum EGeoPatternFlags {
52  kPatternReflected = BIT(14),
53  kPatternSpacedOut = BIT(15)
54  };
55  Double_t fStep; // division step length
56  Double_t fStart; // starting point on divided axis
57  Double_t fEnd; // ending point
58  Int_t fNdivisions; // number of divisions
59  Int_t fDivIndex; // index of first div. node
60  TGeoVolume *fVolume; // volume to which applies
61 
62  mutable std::vector<ThreadData_t*> fThreadData; //! Vector of thread private transient data
63  mutable Int_t fThreadSize; //! Size of the thread vector
64  mutable std::mutex fMutex; //! Mutex for thread data
65 
66 protected:
67  TGeoPatternFinder(const TGeoPatternFinder&);
68  TGeoPatternFinder& operator=(const TGeoPatternFinder&);
69 
70 public:
71  // constructors
72  TGeoPatternFinder();
73  TGeoPatternFinder(TGeoVolume *vol, Int_t ndiv);
74  // destructor
75  virtual ~TGeoPatternFinder();
76  // methods
77  virtual TGeoMatrix* CreateMatrix() const = 0;
78  virtual void cd(Int_t /*idiv*/) {}
79  virtual TGeoNode *CdNext();
80  virtual TGeoNode *FindNode(Double_t * /*point*/, const Double_t * /*dir*/=0) {return 0;}
81  virtual Int_t GetByteCount() const {return 36;}
82  Int_t GetCurrent();// {return fCurrent;}
83  Int_t GetDivIndex() {return fDivIndex;}
84  virtual Int_t GetDivAxis() {return 1;}
85  virtual TGeoMatrix *GetMatrix();// {return fMatrix;}
86  Int_t GetNdiv() const {return fNdivisions;}
87  Int_t GetNext() const;// {return fNextIndex;}
88  TGeoNode *GetNodeOffset(Int_t idiv) {return fVolume->GetNode(fDivIndex+idiv);}
89  Double_t GetStart() const {return fStart;}
90  Double_t GetStep() const {return fStep;}
91  Double_t GetEnd() const {return fEnd;}
92  TGeoVolume *GetVolume() const {return fVolume;}
93  virtual Bool_t IsOnBoundary(const Double_t * /*point*/) const {return kFALSE;}
94  Bool_t IsReflected() const {return TObject::TestBit(kPatternReflected);}
95  Bool_t IsSpacedOut() const {return TObject::TestBit(kPatternSpacedOut);}
96  virtual
97  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE) = 0;
98  void Reflect(Bool_t flag=kTRUE) {TObject::SetBit(kPatternReflected,flag);}
99  void SetDivIndex(Int_t index) {fDivIndex = index;}
100  void SetNext(Int_t index);// {fNextIndex = index;}
101  void SetRange(Double_t start, Double_t step, Int_t ndivisions);
102  void SetSpacedOut(Bool_t flag) {TObject::SetBit(kPatternSpacedOut,flag);}
103  void SetVolume(TGeoVolume *vol) {fVolume = vol;}
104  virtual void UpdateMatrix(Int_t , TGeoHMatrix &) const {}
105 
106  ClassDef(TGeoPatternFinder, 4) // patterns to divide volumes
107 };
108 
109 ////////////////////////////////////////////////////////////////////////////
110 // //
111 // TGeoPatternX - a X axis divison pattern //
112 // //
113 ////////////////////////////////////////////////////////////////////////////
114 
115 class TGeoTranslation;
116 
117 class TGeoPatternX : public TGeoPatternFinder
118 {
119 public:
120  // constructors
121  TGeoPatternX();
122  TGeoPatternX(TGeoVolume *vol, Int_t ndivisions);
123  TGeoPatternX(TGeoVolume *vol, Int_t ndivisions, Double_t step);
124  TGeoPatternX(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
125  TGeoPatternX(const TGeoPatternX &pf);
126  TGeoPatternX& operator=(const TGeoPatternX&);
127 
128  // destructor
129  virtual ~TGeoPatternX();
130  // methods
131  virtual TGeoMatrix* CreateMatrix() const;
132  virtual void cd(Int_t idiv);
133  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
134  virtual Double_t FindNextBoundary(Double_t *point, Double_t *dir, Int_t &indnext);
135  virtual Int_t GetDivAxis() {return 1;}
136  virtual Bool_t IsOnBoundary(const Double_t *point) const;
137  virtual
138  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
139  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
140  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
141 
142  ClassDef(TGeoPatternX, 1) // X division pattern
143 };
144 
145 ////////////////////////////////////////////////////////////////////////////
146 // //
147 // TGeoPatternY - a Y axis divison pattern //
148 // //
149 ////////////////////////////////////////////////////////////////////////////
150 
151 class TGeoPatternY : public TGeoPatternFinder
152 {
153 public:
154  // constructors
155  TGeoPatternY();
156  TGeoPatternY(TGeoVolume *vol, Int_t ndivisions);
157  TGeoPatternY(TGeoVolume *vol, Int_t ndivisions, Double_t step);
158  TGeoPatternY(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
159  TGeoPatternY(const TGeoPatternY &pf);
160  TGeoPatternY& operator=(const TGeoPatternY&);
161  // destructor
162  virtual ~TGeoPatternY();
163  // methods
164  virtual TGeoMatrix* CreateMatrix() const;
165  virtual void cd(Int_t idiv);
166  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
167  virtual Double_t FindNextBoundary(Double_t *point, Double_t *dir, Int_t &indnext);
168  virtual Int_t GetDivAxis() {return 2;}
169  virtual Bool_t IsOnBoundary(const Double_t *point) const;
170  virtual
171  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
172  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
173  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
174 
175  ClassDef(TGeoPatternY, 1) // Y division pattern
176 };
177 
178 ////////////////////////////////////////////////////////////////////////////
179 // //
180 // TGeoPatternZ - a Z axis divison pattern //
181 // //
182 ////////////////////////////////////////////////////////////////////////////
183 
184 class TGeoPatternZ : public TGeoPatternFinder
185 {
186 public:
187  // constructors
188  TGeoPatternZ();
189  TGeoPatternZ(TGeoVolume *vol, Int_t ndivisions);
190  TGeoPatternZ(TGeoVolume *vol, Int_t ndivisions, Double_t step);
191  TGeoPatternZ(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
192  TGeoPatternZ(const TGeoPatternZ &pf);
193  TGeoPatternZ& operator=(const TGeoPatternZ&);
194  // destructor
195  virtual ~TGeoPatternZ();
196  // methods
197  virtual TGeoMatrix* CreateMatrix() const;
198  virtual void cd(Int_t idiv);
199  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
200  virtual Double_t FindNextBoundary(Double_t *point, Double_t *dir, Int_t &indnext);
201  virtual Int_t GetDivAxis() {return 3;}
202  virtual Bool_t IsOnBoundary(const Double_t *point) const;
203  virtual
204  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
205  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
206  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
207 
208  ClassDef(TGeoPatternZ, 1) // Z division pattern
209 };
210 
211 ////////////////////////////////////////////////////////////////////////////
212 // //
213 // TGeoPatternParaX - a X axis divison pattern for PARA shapes //
214 // //
215 ////////////////////////////////////////////////////////////////////////////
216 
217 class TGeoPatternParaX : public TGeoPatternFinder
218 {
219 public:
220  // constructors
221  TGeoPatternParaX();
222  TGeoPatternParaX(TGeoVolume *vol, Int_t ndivisions);
223  TGeoPatternParaX(TGeoVolume *vol, Int_t ndivisions, Double_t step);
224  TGeoPatternParaX(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
225  TGeoPatternParaX(const TGeoPatternParaX &pf);
226  TGeoPatternParaX& operator=(const TGeoPatternParaX&);
227 
228  // destructor
229  virtual ~TGeoPatternParaX();
230  // methods
231  virtual TGeoMatrix* CreateMatrix() const;
232  virtual void cd(Int_t idiv);
233  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
234  virtual Int_t GetDivAxis() {return 1;}
235  virtual Bool_t IsOnBoundary(const Double_t *point) const;
236  virtual
237  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
238  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
239  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
240 
241  ClassDef(TGeoPatternParaX, 1) // Para X division pattern
242 };
243 
244 ////////////////////////////////////////////////////////////////////////////
245 // //
246 // TGeoPatternParaY - a Y axis divison pattern for PARA shapes //
247 // //
248 ////////////////////////////////////////////////////////////////////////////
249 
250 class TGeoPatternParaY : public TGeoPatternFinder
251 {
252 private :
253 // data members
254  Double_t fTxy = 0.; // tangent of alpha
255 public:
256  // constructors
257  TGeoPatternParaY();
258  TGeoPatternParaY(TGeoVolume *vol, Int_t ndivisions);
259  TGeoPatternParaY(TGeoVolume *vol, Int_t ndivisions, Double_t step);
260  TGeoPatternParaY(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
261  TGeoPatternParaY(const TGeoPatternParaY &pf);
262  TGeoPatternParaY& operator=(const TGeoPatternParaY&);
263 
264  // destructor
265  virtual ~TGeoPatternParaY();
266  // methods
267  virtual TGeoMatrix* CreateMatrix() const;
268  virtual void cd(Int_t idiv);
269  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
270  virtual Int_t GetDivAxis() {return 2;}
271  virtual Bool_t IsOnBoundary(const Double_t *point) const;
272  virtual
273  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
274  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
275  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
276 
277  ClassDef(TGeoPatternParaY, 1) // Para Y division pattern
278 };
279 
280 ////////////////////////////////////////////////////////////////////////////
281 // //
282 // TGeoPatternParaZ - a Z axis divison pattern for PARA shapes //
283 // //
284 ////////////////////////////////////////////////////////////////////////////
285 
286 class TGeoPatternParaZ : public TGeoPatternFinder
287 {
288 private :
289 // data members
290  Double_t fTxz = 0.; // tangent of alpha xz
291  Double_t fTyz = 0.; // tangent of alpha yz
292 public:
293  // constructors
294  TGeoPatternParaZ();
295  TGeoPatternParaZ(TGeoVolume *vol, Int_t ndivisions);
296  TGeoPatternParaZ(TGeoVolume *vol, Int_t ndivisions, Double_t step);
297  TGeoPatternParaZ(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
298  TGeoPatternParaZ(const TGeoPatternParaZ &pf);
299  TGeoPatternParaZ& operator=(const TGeoPatternParaZ&);
300 
301  // destructor
302  virtual ~TGeoPatternParaZ();
303  // methods
304  virtual TGeoMatrix* CreateMatrix() const;
305  virtual void cd(Int_t idiv);
306  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
307  virtual Int_t GetDivAxis() {return 3;}
308  virtual Bool_t IsOnBoundary(const Double_t *point) const;
309  virtual
310  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
311  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
312  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
313 
314  ClassDef(TGeoPatternParaZ, 1) // Para Z division pattern
315 };
316 
317 ////////////////////////////////////////////////////////////////////////////
318 // //
319 // TGeoPatternTrapZ - a Z axis divison pattern for TRAP or GTRA shapes //
320 // //
321 ////////////////////////////////////////////////////////////////////////////
322 
323 class TGeoPatternTrapZ : public TGeoPatternFinder
324 {
325 private :
326 // data members
327  Double_t fTxz = 0.; // tangent of alpha xz
328  Double_t fTyz = 0.; // tangent of alpha yz
329 public:
330  // constructors
331  TGeoPatternTrapZ();
332  TGeoPatternTrapZ(TGeoVolume *vol, Int_t ndivisions);
333  TGeoPatternTrapZ(TGeoVolume *vol, Int_t ndivisions, Double_t step);
334  TGeoPatternTrapZ(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
335  TGeoPatternTrapZ(const TGeoPatternTrapZ &pf);
336  TGeoPatternTrapZ& operator=(const TGeoPatternTrapZ&);
337 
338  // destructor
339  virtual ~TGeoPatternTrapZ();
340  // methods
341  virtual TGeoMatrix* CreateMatrix() const;
342  Double_t GetTxz() const {return fTxz;}
343  Double_t GetTyz() const {return fTyz;}
344  virtual void cd(Int_t idiv);
345  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
346  virtual Int_t GetDivAxis() {return 3;}
347  virtual Bool_t IsOnBoundary(const Double_t *point) const;
348  virtual
349  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
350  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
351  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
352 
353  ClassDef(TGeoPatternTrapZ, 1) // Trap od Gtra Z division pattern
354 };
355 
356 
357 ////////////////////////////////////////////////////////////////////////////
358 // //
359 // TGeoPatternCylR - a cylindrical R divison pattern //
360 // //
361 ////////////////////////////////////////////////////////////////////////////
362 
363 class TGeoPatternCylR : public TGeoPatternFinder
364 {
365 public:
366  // constructors
367  TGeoPatternCylR();
368  TGeoPatternCylR(TGeoVolume *vol, Int_t ndivisions);
369  TGeoPatternCylR(TGeoVolume *vol, Int_t ndivisions, Double_t step);
370  TGeoPatternCylR(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
371  TGeoPatternCylR(const TGeoPatternCylR &pf);
372  TGeoPatternCylR& operator=(const TGeoPatternCylR&);
373  // destructor
374  virtual ~TGeoPatternCylR();
375  // methods
376  virtual TGeoMatrix* CreateMatrix() const;
377  virtual void cd(Int_t idiv);
378  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
379  virtual Int_t GetDivAxis() {return 1;}
380  virtual Bool_t IsOnBoundary(const Double_t *point) const;
381  virtual
382  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
383  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
384  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
385 
386  ClassDef(TGeoPatternCylR, 1) // Cylindrical R division pattern
387 };
388 
389 ////////////////////////////////////////////////////////////////////////////
390 // //
391 // TGeoPatternCylPhi - a cylindrical phi divison pattern //
392 // //
393 ////////////////////////////////////////////////////////////////////////////
394 
395 class TGeoPatternCylPhi : public TGeoPatternFinder
396 {
397 private :
398 // data members
399  Double_t *fSinCos = nullptr; //![2*fNdivisions] table of sines/cosines
400 
401 protected:
402  TGeoPatternCylPhi(const TGeoPatternCylPhi& pfc)
403  : TGeoPatternFinder(pfc), fSinCos(pfc.fSinCos) {CreateThreadData(1);}
404  TGeoPatternCylPhi& operator=(const TGeoPatternCylPhi& pfc)
405  {if(this!=&pfc) {TGeoPatternFinder::operator=(pfc); fSinCos=pfc.fSinCos; CreateThreadData(1);}
406  return *this;}
407 
408 public:
409  // constructors
410  TGeoPatternCylPhi();
411  TGeoPatternCylPhi(TGeoVolume *vol, Int_t ndivisions);
412  TGeoPatternCylPhi(TGeoVolume *vol, Int_t ndivisions, Double_t step);
413  TGeoPatternCylPhi(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
414  // destructor
415  virtual ~TGeoPatternCylPhi();
416  // methods
417  virtual TGeoMatrix* CreateMatrix() const;
418  virtual void cd(Int_t idiv);
419  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
420  virtual Int_t GetDivAxis() {return 2;}
421  virtual Bool_t IsOnBoundary(const Double_t *point) const;
422  virtual
423  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
424  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
425  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
426 
427  ClassDef(TGeoPatternCylPhi, 1) // Cylindrical phi division pattern
428 };
429 
430 ////////////////////////////////////////////////////////////////////////////
431 // //
432 // TGeoPatternSphR - a spherical R divison pattern //
433 // //
434 ////////////////////////////////////////////////////////////////////////////
435 
436 class TGeoPatternSphR : public TGeoPatternFinder
437 {
438 public:
439  // constructors
440  TGeoPatternSphR();
441  TGeoPatternSphR(TGeoVolume *vol, Int_t ndivisions);
442  TGeoPatternSphR(TGeoVolume *vol, Int_t ndivisions, Double_t step);
443  TGeoPatternSphR(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
444  TGeoPatternSphR(const TGeoPatternSphR &pf);
445  TGeoPatternSphR& operator=(const TGeoPatternSphR&);
446  // destructor
447  virtual ~TGeoPatternSphR();
448  // methods
449  virtual TGeoMatrix* CreateMatrix() const;
450  virtual void cd(Int_t idiv);
451  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
452  virtual Int_t GetDivAxis() {return 1;}
453  virtual
454  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
455  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
456  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
457 
458  ClassDef(TGeoPatternSphR, 1) // spherical R division pattern
459 };
460 
461 ////////////////////////////////////////////////////////////////////////////
462 // //
463 // TGeoPatternSphTheta - a spherical theta divison pattern //
464 // //
465 ////////////////////////////////////////////////////////////////////////////
466 
467 class TGeoPatternSphTheta : public TGeoPatternFinder
468 {
469 public:
470  // constructors
471  TGeoPatternSphTheta();
472  TGeoPatternSphTheta(TGeoVolume *vol, Int_t ndivisions);
473  TGeoPatternSphTheta(TGeoVolume *vol, Int_t ndivisions, Double_t step);
474  TGeoPatternSphTheta(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
475  TGeoPatternSphTheta(const TGeoPatternSphTheta &pf);
476  TGeoPatternSphTheta& operator=(const TGeoPatternSphTheta&);
477  // destructor
478  virtual ~TGeoPatternSphTheta();
479  // methods
480  virtual TGeoMatrix* CreateMatrix() const;
481  virtual void cd(Int_t idiv);
482  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
483  virtual Int_t GetDivAxis() {return 3;}
484  virtual
485  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
486  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
487  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
488 
489  ClassDef(TGeoPatternSphTheta, 1) // spherical theta division pattern
490 };
491 
492 ////////////////////////////////////////////////////////////////////////////
493 // //
494 // TGeoPatternSphPhi - a spherical phi divison pattern //
495 // //
496 ////////////////////////////////////////////////////////////////////////////
497 
498 class TGeoPatternSphPhi : public TGeoPatternFinder
499 {
500 private:
501  Double_t *fSinCos = nullptr; //! Sincos table
502 
503 protected:
504  TGeoPatternSphPhi(const TGeoPatternSphPhi& pfc); // Not implemented
505  TGeoPatternSphPhi& operator=(const TGeoPatternSphPhi& pfc); // Not implemented
506  Double_t *CreateSinCos();
507 public:
508  // constructors
509  TGeoPatternSphPhi();
510  TGeoPatternSphPhi(TGeoVolume *vol, Int_t ndivisions);
511  TGeoPatternSphPhi(TGeoVolume *vol, Int_t ndivisions, Double_t step);
512  TGeoPatternSphPhi(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
513  // destructor
514  virtual ~TGeoPatternSphPhi();
515  // methods
516  virtual TGeoMatrix* CreateMatrix() const;
517  virtual void cd(Int_t idiv);
518  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
519  virtual Int_t GetDivAxis() {return 2;}
520  virtual Bool_t IsOnBoundary(const Double_t *point) const;
521  virtual
522  TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
523  virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
524  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
525 
526  ClassDef(TGeoPatternSphPhi, 1) // Spherical phi division pattern
527 };
528 
529 ////////////////////////////////////////////////////////////////////////////
530 // //
531 // TGeoPatternHoneycomb - a divison pattern specialized for honeycombs //
532 // //
533 ////////////////////////////////////////////////////////////////////////////
534 
535 class TGeoPatternHoneycomb : public TGeoPatternFinder
536 {
537 private :
538 // data members
539  Int_t fNrows; // number of rows
540  Int_t fAxisOnRows; // axis along each row
541  Int_t *fNdivisions; // [fNrows] number of divisions for each row
542  Double_t *fStart; // [fNrows] starting points for each row
543 
544 protected:
545  TGeoPatternHoneycomb(const TGeoPatternHoneycomb&);
546  TGeoPatternHoneycomb& operator=(const TGeoPatternHoneycomb&);
547 
548 public:
549  // constructors
550  TGeoPatternHoneycomb();
551  TGeoPatternHoneycomb(TGeoVolume *vol, Int_t nrows);
552  // destructor
553  virtual ~TGeoPatternHoneycomb();
554  // methods
555  TGeoPatternFinder *MakeCopy(Bool_t) {return 0;}
556  virtual TGeoMatrix* CreateMatrix() const;
557  virtual void cd(Int_t idiv);
558  virtual TGeoNode *FindNode(Double_t *point, const Double_t *dir=0);
559  virtual void UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
560 
561  ClassDef(TGeoPatternHoneycomb, 1) // pattern for honeycomb divisions
562 };
563 
564 #endif