/root-5.34.01/geom/geom/inc/TGeoPatternFinder.h

# · C Header · 556 lines · 364 code · 65 blank · 127 comment · 0 complexity · 7567a8cd8ae02e9dd19c5c9cc36e1eba MD5 · raw file 

    

  1. // @(#)root/geom:$Id: TGeoPatternFinder.h 43564 2012-03-30 07:09:37Z agheata $
    2. 

  2. // Author: Andrei Gheata   30/10/01
    3. 

  3. 

  4. /*************************************************************************
    5. 

  5.  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
    6. 

  6.  * All rights reserved.                                                  *
    7. 

  7.  *                                                                       *
    8. 

  8.  * For the licensing terms see $ROOTSYS/LICENSE.                         *
    9. 

  9.  * For the list of contributors see $ROOTSYS/README/CREDITS.             *
    10. 

  10.  *************************************************************************/
    11. 

  11. 

  12. #ifndef ROOT_TGeoPatternFinder
    13. 

  13. #define ROOT_TGeoPatternFinder
    14. 

  14. 

  15. #ifndef ROOT_TObject
    16. 

  16. #include "TObject.h"
    17. 

  17. #endif
    18. 

  18. 

  19. #ifndef ROOT_TGeoVolume
    20. 

  20. #include "TGeoVolume.h"
    21. 

  21. #endif
    22. 

  22. 

  23. 

  24. class TGeoMatrix;
    25. 

  25. 

  26. ////////////////////////////////////////////////////////////////////////////////
    27. 

  27. //                                                                            //
    28. 

  28. // TGeoPatternFinder - base finder class for patterns. A pattern is specifying 
    29. 

  29. //   a division type                                                          //
    30. 

  30. //                                                                            //
    31. 

  31. ////////////////////////////////////////////////////////////////////////////////
    32. 

  32. 

  33. class TGeoPatternFinder : public TObject
    34. 

  34. {
    35. 

  35. public:
    36. 

  36.    struct ThreadData_t
    37. 

  37.    {
    38. 

  38.       TGeoMatrix      *fMatrix;         //! generic matrix
    39. 

  39.       Int_t            fCurrent;        //! current division element
    40. 

  40.       Int_t            fNextIndex;      //! index of next node
    41. 

  41. 

  42.       ThreadData_t();
    43. 

  43.       ~ThreadData_t();
    44. 

  44.    };
    45. 

  45.    ThreadData_t& GetThreadData()   const;
    46. 

  46.    void          ClearThreadData() const;
    47. 

  47.    void          CreateThreadData(Int_t nthreads);
    48. 

  48. 

  49. protected :
    50. 

  50.    enum EGeoPatternFlags {
    51. 

  51.       kPatternReflected = BIT(14),
    52. 

  52.       kPatternSpacedOut = BIT(15)
    53. 

  53.    };   
    54. 

  54.    Double_t            fStep;           // division step length
    55. 

  55.    Double_t            fStart;          // starting point on divided axis
    56. 

  56.    Double_t            fEnd;            // ending point
    57. 

  57.    Int_t               fNdivisions;     // number of divisions
    58. 

  58.    Int_t               fDivIndex;       // index of first div. node
    59. 

  59.    TGeoVolume         *fVolume;         // volume to which applies
    60. 

  60. 

  61.    mutable std::vector<ThreadData_t*> fThreadData; //! Vector of thread private transient data
    62. 

  62.    mutable Int_t                      fThreadSize; //! Size of the thread vector
    63. 

  63. 

  64. protected:
    65. 

  65.    TGeoPatternFinder(const TGeoPatternFinder&); 
    66. 

  66.    TGeoPatternFinder& operator=(const TGeoPatternFinder&);
    67. 

  67. 

  68. public:
    69. 

  69.    // constructors
    70. 

  70.    TGeoPatternFinder();
    71. 

  71.    TGeoPatternFinder(TGeoVolume *vol, Int_t ndiv);
    72. 

  72.    // destructor
    73. 

  73.    virtual ~TGeoPatternFinder();
    74. 

  74.    // methods
    75. 

  75.    virtual TGeoMatrix* CreateMatrix() const = 0;
    76. 

  76.    virtual void        cd(Int_t /*idiv*/) {}
    77. 

  77.    virtual TGeoNode   *CdNext();
    78. 

  78.    virtual TGeoNode   *FindNode(Double_t * /*point*/, const Double_t * /*dir*/=0) {return 0;} 
    79. 

  79.    virtual Int_t       GetByteCount() const {return 36;}
    80. 

  80.    Int_t               GetCurrent();//      {return fCurrent;}
    81. 

  81.    Int_t               GetDivIndex()     {return fDivIndex;}
    82. 

  82.    virtual Int_t       GetDivAxis()      {return 1;}
    83. 

  83.    virtual TGeoMatrix *GetMatrix();//       {return fMatrix;}
    84. 

  84.    Int_t               GetNdiv() const   {return fNdivisions;}
    85. 

  85.    Int_t               GetNext() const;//   {return fNextIndex;}
    86. 

  86.    TGeoNode           *GetNodeOffset(Int_t idiv) {return fVolume->GetNode(fDivIndex+idiv);}  
    87. 

  87.    Double_t            GetStart() const  {return fStart;}
    88. 

  88.    Double_t            GetStep() const   {return fStep;}
    89. 

  89.    Double_t            GetEnd() const    {return fEnd;}
    90. 

  90.    TGeoVolume         *GetVolume() const {return fVolume;}
    91. 

  91.    virtual Bool_t      IsOnBoundary(const Double_t * /*point*/) const {return kFALSE;}
    92. 

  92.    Bool_t              IsReflected() const {return TObject::TestBit(kPatternReflected);}
    93. 

  93.    Bool_t              IsSpacedOut() const {return TObject::TestBit(kPatternSpacedOut);}
    94. 

  94.    virtual 
    95. 

  95.    TGeoPatternFinder  *MakeCopy(Bool_t reflect=kFALSE) = 0;
    96. 

  96.    void                Reflect(Bool_t flag=kTRUE) {TObject::SetBit(kPatternReflected,flag);}
    97. 

  97.    void                SetDivIndex(Int_t index) {fDivIndex = index;}
    98. 

  98.    void                SetNext(Int_t index);//     {fNextIndex = index;}
    99. 

  99.    void                SetRange(Double_t start, Double_t step, Int_t ndivisions);
    100. 

  100.    void                SetSpacedOut(Bool_t flag) {TObject::SetBit(kPatternSpacedOut,flag);}
    101. 

  101.    void                SetVolume(TGeoVolume *vol) {fVolume = vol;}
    102. 

  102.    virtual void        UpdateMatrix(Int_t , TGeoHMatrix &) const {}
    103. 

  103. 

  104.    ClassDef(TGeoPatternFinder, 4)              // patterns to divide volumes
    105. 

  105. };
    106. 

  106. 

  107. ////////////////////////////////////////////////////////////////////////////
    108. 

  108. //                                                                        //
    109. 

  109. // TGeoPatternX - a X axis divison pattern                                //
    110. 

  110. //                                                                        //
    111. 

  111. ////////////////////////////////////////////////////////////////////////////
    112. 

  112. 

  113. class TGeoTranslation;
    114. 

  114. 

  115. class TGeoPatternX : public TGeoPatternFinder 
    116. 

  116. {
    117. 

  117. public:
    118. 

  118.    // constructors
    119. 

  119.    TGeoPatternX();
    120. 

  120.    TGeoPatternX(TGeoVolume *vol, Int_t ndivisions);
    121. 

  121.    TGeoPatternX(TGeoVolume *vol, Int_t ndivisions, Double_t step);
    122. 

  122.    TGeoPatternX(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
    123. 

  123.    TGeoPatternX(const TGeoPatternX &pf);
    124. 

  124.    TGeoPatternX& operator=(const TGeoPatternX&);
    125. 

  125. 

  126.    // destructor
    127. 

  127.    virtual ~TGeoPatternX();
    128. 

  128.    // methods
    129. 

  129.    virtual TGeoMatrix* CreateMatrix() const;
    130. 

  130.    virtual void        cd(Int_t idiv);
    131. 

  131.    virtual TGeoNode   *FindNode(Double_t *point, const Double_t *dir=0);
    132. 

  132.    virtual Double_t    FindNextBoundary(Double_t *point, Double_t *dir, Int_t &indnext);
    133. 

  133.    virtual Int_t       GetDivAxis()      {return 1;}
    134. 

  134.    virtual Bool_t      IsOnBoundary(const Double_t *point) const;
    135. 

  135.    virtual 
    136. 

  136.    TGeoPatternFinder  *MakeCopy(Bool_t reflect=kFALSE);
    137. 

  137.    virtual void        SavePrimitive(ostream &out, Option_t *option = "");
    138. 

  138.    virtual void        UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
    139. 

  139. 

  140.    ClassDef(TGeoPatternX, 1)              // X division pattern
    141. 

  141. };
    142. 

  142. 

  143. ////////////////////////////////////////////////////////////////////////////
    144. 

  144. //                                                                        //
    145. 

  145. // TGeoPatternY - a Y axis divison pattern                                //
    146. 

  146. //                                                                        //
    147. 

  147. ////////////////////////////////////////////////////////////////////////////
    148. 

  148. 

  149. class TGeoPatternY : public TGeoPatternFinder
    150. 

  150. {
    151. 

  151. public:
    152. 

  152.    // constructors
    153. 

  153.    TGeoPatternY();
    154. 

  154.    TGeoPatternY(TGeoVolume *vol, Int_t ndivisions);
    155. 

  155.    TGeoPatternY(TGeoVolume *vol, Int_t ndivisions, Double_t step);
    156. 

  156.    TGeoPatternY(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
    157. 

  157.    TGeoPatternY(const TGeoPatternY &pf);
    158. 

  158.    TGeoPatternY& operator=(const TGeoPatternY&);
    159. 

  159.    // destructor
    160. 

  160.    virtual ~TGeoPatternY();
    161. 

  161.    // methods
    162. 

  162.    virtual TGeoMatrix* CreateMatrix() const;
    163. 

  163.    virtual void        cd(Int_t idiv);
    164. 

  164.    virtual TGeoNode   *FindNode(Double_t *point, const Double_t *dir=0); 
    165. 

  165.    virtual Double_t    FindNextBoundary(Double_t *point, Double_t *dir, Int_t &indnext);
    166. 

  166.    virtual Int_t       GetDivAxis()      {return 2;}
    167. 

  167.    virtual Bool_t      IsOnBoundary(const Double_t *point) const;
    168. 

  168.    virtual 
    169. 

  169.    TGeoPatternFinder  *MakeCopy(Bool_t reflect=kFALSE);
    170. 

  170.    virtual void        SavePrimitive(ostream &out, Option_t *option = "");
    171. 

  171.    virtual void        UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
    172. 

  172. 

  173.    ClassDef(TGeoPatternY, 1)              // Y division pattern
    174. 

  174. };
    175. 

  175. 

  176. ////////////////////////////////////////////////////////////////////////////
    177. 

  177. //                                                                        //
    178. 

  178. // TGeoPatternZ - a Z axis divison pattern                                //
    179. 

  179. //                                                                        //
    180. 

  180. ////////////////////////////////////////////////////////////////////////////
    181. 

  181. 

  182. class TGeoPatternZ : public TGeoPatternFinder
    183. 

  183. {
    184. 

  184. public:
    185. 

  185.    // constructors
    186. 

  186.    TGeoPatternZ();
    187. 

  187.    TGeoPatternZ(TGeoVolume *vol, Int_t ndivisions);
    188. 

  188.    TGeoPatternZ(TGeoVolume *vol, Int_t ndivisions, Double_t step);
    189. 

  189.    TGeoPatternZ(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
    190. 

  190.    TGeoPatternZ(const TGeoPatternZ &pf);
    191. 

  191.    TGeoPatternZ& operator=(const TGeoPatternZ&);
    192. 

  192.    // destructor
    193. 

  193.    virtual ~TGeoPatternZ();
    194. 

  194.    // methods
    195. 

  195.    virtual TGeoMatrix* CreateMatrix() const;
    196. 

  196.    virtual void        cd(Int_t idiv);
    197. 

  197.    virtual TGeoNode   *FindNode(Double_t *point, const Double_t *dir=0); 
    198. 

  198.    virtual Double_t    FindNextBoundary(Double_t *point, Double_t *dir, Int_t &indnext);
    199. 

  199.    virtual Int_t       GetDivAxis()      {return 3;}
    200. 

  200.    virtual Bool_t      IsOnBoundary(const Double_t *point) const;
    201. 

  201.    virtual 
    202. 

  202.    TGeoPatternFinder  *MakeCopy(Bool_t reflect=kFALSE);
    203. 

  203.    virtual void        SavePrimitive(ostream &out, Option_t *option = "");
    204. 

  204.    virtual void        UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
    205. 

  205. 

  206.    ClassDef(TGeoPatternZ, 1)              // Z division pattern
    207. 

  207. };
    208. 

  208. 

  209. ////////////////////////////////////////////////////////////////////////////
    210. 

  210. //                                                                        //
    211. 

  211. // TGeoPatternParaX - a X axis divison pattern for PARA shapes            //
    212. 

  212. //                                                                        //
    213. 

  213. ////////////////////////////////////////////////////////////////////////////
    214. 

  214. 

  215. class TGeoPatternParaX : public TGeoPatternFinder 
    216. 

  216. {
    217. 

  217. public:
    218. 

  218.    // constructors
    219. 

  219.    TGeoPatternParaX();
    220. 

  220.    TGeoPatternParaX(TGeoVolume *vol, Int_t ndivisions);
    221. 

  221.    TGeoPatternParaX(TGeoVolume *vol, Int_t ndivisions, Double_t step);
    222. 

  222.    TGeoPatternParaX(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
    223. 

  223.    TGeoPatternParaX(const TGeoPatternParaX &pf);
    224. 

  224.    TGeoPatternParaX& operator=(const TGeoPatternParaX&);
    225. 

  225. 

  226.    // destructor
    227. 

  227.    virtual ~TGeoPatternParaX();
    228. 

  228.    // methods
    229. 

  229.    virtual TGeoMatrix* CreateMatrix() const;
    230. 

  230.    virtual void        cd(Int_t idiv);
    231. 

  231.    virtual TGeoNode   *FindNode(Double_t *point, const Double_t *dir=0);
    232. 

  232.    virtual Int_t       GetDivAxis()      {return 1;}
    233. 

  233.    virtual Bool_t      IsOnBoundary(const Double_t *point) const;
    234. 

  234.    virtual 
    235. 

  235.    TGeoPatternFinder  *MakeCopy(Bool_t reflect=kFALSE);
    236. 

  236.    virtual void        SavePrimitive(ostream &out, Option_t *option = "");
    237. 

  237.    virtual void        UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
    238. 

  238. 

  239.    ClassDef(TGeoPatternParaX, 1)              // Para X division pattern
    240. 

  240. };
    241. 

  241. 

  242. ////////////////////////////////////////////////////////////////////////////
    243. 

  243. //                                                                        //
    244. 

  244. // TGeoPatternParaY - a Y axis divison pattern for PARA shapes            //
    245. 

  245. //                                                                        //
    246. 

  246. ////////////////////////////////////////////////////////////////////////////
    247. 

  247. 

  248. class TGeoPatternParaY : public TGeoPatternFinder 
    249. 

  249. {
    250. 

  250. private :
    251. 

  251. // data members
    252. 

  252.    Double_t         fTxy;      // tangent of alpha
    253. 

  253. public:
    254. 

  254.    // constructors
    255. 

  255.    TGeoPatternParaY();
    256. 

  256.    TGeoPatternParaY(TGeoVolume *vol, Int_t ndivisions);
    257. 

  257.    TGeoPatternParaY(TGeoVolume *vol, Int_t ndivisions, Double_t step);
    258. 

  258.    TGeoPatternParaY(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
    259. 

  259.    TGeoPatternParaY(const TGeoPatternParaY &pf);
    260. 

  260.    TGeoPatternParaY& operator=(const TGeoPatternParaY&);
    261. 

  261. 

  262.    // destructor
    263. 

  263.    virtual ~TGeoPatternParaY();
    264. 

  264.    // methods
    265. 

  265.    virtual TGeoMatrix* CreateMatrix() const;
    266. 

  266.    virtual void        cd(Int_t idiv);
    267. 

  267.    virtual TGeoNode   *FindNode(Double_t *point, const Double_t *dir=0);
    268. 

  268.    virtual Int_t       GetDivAxis()      {return 2;}
    269. 

  269.    virtual Bool_t      IsOnBoundary(const Double_t *point) const;
    270. 

  270.    virtual 
    271. 

  271.    TGeoPatternFinder  *MakeCopy(Bool_t reflect=kFALSE);
    272. 

  272.    virtual void        SavePrimitive(ostream &out, Option_t *option = "");
    273. 

  273.    virtual void        UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
    274. 

  274. 

  275.    ClassDef(TGeoPatternParaY, 1)              // Para Y division pattern
    276. 

  276. };
    277. 

  277. 

  278. ////////////////////////////////////////////////////////////////////////////
    279. 

  279. //                                                                        //
    280. 

  280. // TGeoPatternParaZ - a Z axis divison pattern for PARA shapes            //
    281. 

  281. //                                                                        //
    282. 

  282. ////////////////////////////////////////////////////////////////////////////
    283. 

  283. 

  284. class TGeoPatternParaZ : public TGeoPatternFinder 
    285. 

  285. {
    286. 

  286. private :
    287. 

  287. // data members
    288. 

  288.    Double_t            fTxz;  // tangent of alpha xz
    289. 

  289.    Double_t            fTyz;  // tangent of alpha yz
    290. 

  290. public:
    291. 

  291.    // constructors
    292. 

  292.    TGeoPatternParaZ();
    293. 

  293.    TGeoPatternParaZ(TGeoVolume *vol, Int_t ndivisions);
    294. 

  294.    TGeoPatternParaZ(TGeoVolume *vol, Int_t ndivisions, Double_t step);
    295. 

  295.    TGeoPatternParaZ(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
    296. 

  296.    TGeoPatternParaZ(const TGeoPatternParaZ &pf);
    297. 

  297.    TGeoPatternParaZ& operator=(const TGeoPatternParaZ&);
    298. 

  298. 

  299.    // destructor
    300. 

  300.    virtual ~TGeoPatternParaZ();
    301. 

  301.    // methods
    302. 

  302.    virtual TGeoMatrix* CreateMatrix() const;
    303. 

  303.    virtual void        cd(Int_t idiv);
    304. 

  304.    virtual TGeoNode   *FindNode(Double_t *point, const Double_t *dir=0);
    305. 

  305.    virtual Int_t       GetDivAxis()      {return 3;}
    306. 

  306.    virtual Bool_t      IsOnBoundary(const Double_t *point) const;
    307. 

  307.    virtual 
    308. 

  308.    TGeoPatternFinder  *MakeCopy(Bool_t reflect=kFALSE);
    309. 

  309.    virtual void        SavePrimitive(ostream &out, Option_t *option = "");
    310. 

  310.    virtual void        UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
    311. 

  311. 

  312.    ClassDef(TGeoPatternParaZ, 1)              // Para Z division pattern
    313. 

  313. };
    314. 

  314. 

  315. ////////////////////////////////////////////////////////////////////////////
    316. 

  316. //                                                                        //
    317. 

  317. // TGeoPatternTrapZ - a Z axis divison pattern for TRAP or GTRA shapes    //
    318. 

  318. //                                                                        //
    319. 

  319. ////////////////////////////////////////////////////////////////////////////
    320. 

  320. 

  321. class TGeoPatternTrapZ : public TGeoPatternFinder 
    322. 

  322. {
    323. 

  323. private :
    324. 

  324. // data members
    325. 

  325.    Double_t            fTxz;  // tangent of alpha xz
    326. 

  326.    Double_t            fTyz;  // tangent of alpha yz
    327. 

  327. public:
    328. 

  328.    // constructors
    329. 

  329.    TGeoPatternTrapZ();
    330. 

  330.    TGeoPatternTrapZ(TGeoVolume *vol, Int_t ndivisions);
    331. 

  331.    TGeoPatternTrapZ(TGeoVolume *vol, Int_t ndivisions, Double_t step);
    332. 

  332.    TGeoPatternTrapZ(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
    333. 

  333.    TGeoPatternTrapZ(const TGeoPatternTrapZ &pf);
    334. 

  334.    TGeoPatternTrapZ& operator=(const TGeoPatternTrapZ&);
    335. 

  335. 

  336.    // destructor
    337. 

  337.    virtual ~TGeoPatternTrapZ();
    338. 

  338.    // methods
    339. 

  339.    virtual TGeoMatrix* CreateMatrix() const;
    340. 

  340.    Double_t            GetTxz() const {return fTxz;}
    341. 

  341.    Double_t            GetTyz() const {return fTyz;}
    342. 

  342.    virtual void        cd(Int_t idiv);
    343. 

  343.    virtual TGeoNode   *FindNode(Double_t *point, const Double_t *dir=0);
    344. 

  344.    virtual Int_t       GetDivAxis()      {return 3;}
    345. 

  345.    virtual Bool_t      IsOnBoundary(const Double_t *point) const;
    346. 

  346.    virtual 
    347. 

  347.    TGeoPatternFinder  *MakeCopy(Bool_t reflect=kFALSE);
    348. 

  348.    virtual void        SavePrimitive(ostream &out, Option_t *option = "");
    349. 

  349.    virtual void        UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
    350. 

  350. 

  351.    ClassDef(TGeoPatternTrapZ, 1)              // Trap od Gtra Z division pattern
    352. 

  352. };
    353. 

  353. 

  354. 

  355. ////////////////////////////////////////////////////////////////////////////
    356. 

  356. //                                                                        //
    357. 

  357. // TGeoPatternCylR - a cylindrical R divison pattern                      //
    358. 

  358. //                                                                        //
    359. 

  359. ////////////////////////////////////////////////////////////////////////////
    360. 

  360. 

  361. class TGeoPatternCylR : public TGeoPatternFinder
    362. 

  362. {
    363. 

  363. public:
    364. 

  364.    // constructors
    365. 

  365.    TGeoPatternCylR();
    366. 

  366.    TGeoPatternCylR(TGeoVolume *vol, Int_t ndivisions);
    367. 

  367.    TGeoPatternCylR(TGeoVolume *vol, Int_t ndivisions, Double_t step);
    368. 

  368.    TGeoPatternCylR(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
    369. 

  369.    TGeoPatternCylR(const TGeoPatternCylR &pf);
    370. 

  370.    TGeoPatternCylR& operator=(const TGeoPatternCylR&);
    371. 

  371.    // destructor
    372. 

  372.    virtual ~TGeoPatternCylR();
    373. 

  373.    // methods
    374. 

  374.    virtual TGeoMatrix* CreateMatrix() const;
    375. 

  375.    virtual void        cd(Int_t idiv);
    376. 

  376.    virtual TGeoNode   *FindNode(Double_t *point, const Double_t *dir=0); 
    377. 

  377.    virtual Int_t       GetDivAxis()      {return 1;}
    378. 

  378.    virtual Bool_t      IsOnBoundary(const Double_t *point) const;
    379. 

  379.    virtual 
    380. 

  380.    TGeoPatternFinder  *MakeCopy(Bool_t reflect=kFALSE);
    381. 

  381.    virtual void        SavePrimitive(ostream &out, Option_t *option = "");
    382. 

  382.    virtual void        UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
    383. 

  383. 

  384.    ClassDef(TGeoPatternCylR, 1)              // Cylindrical R division pattern
    385. 

  385. };
    386. 

  386. 

  387. ////////////////////////////////////////////////////////////////////////////
    388. 

  388. //                                                                        //
    389. 

  389. // TGeoPatternCylPhi - a cylindrical phi divison pattern                  //
    390. 

  390. //                                                                        //
    391. 

  391. ////////////////////////////////////////////////////////////////////////////
    392. 

  392. 

  393. class TGeoPatternCylPhi : public TGeoPatternFinder
    394. 

  394. {
    395. 

  395. private :
    396. 

  396. // data members
    397. 

  397.    Double_t           *fSinCos;          //![2*fNdivisions] table of sines/cosines
    398. 

  398. 

  399. protected:
    400. 

  400.    TGeoPatternCylPhi(const TGeoPatternCylPhi& pfc) 
    401. 

  401.      : TGeoPatternFinder(pfc), fSinCos(pfc.fSinCos) {CreateThreadData(1);}
    402. 

  402.    TGeoPatternCylPhi& operator=(const TGeoPatternCylPhi& pfc)
    403. 

  403.      {if(this!=&pfc) {TGeoPatternFinder::operator=(pfc); fSinCos=pfc.fSinCos; CreateThreadData(1);}
    404. 

  404.      return *this;}
    405. 

  405. 

  406. public:
    407. 

  407.    // constructors
    408. 

  408.    TGeoPatternCylPhi();
    409. 

  409.    TGeoPatternCylPhi(TGeoVolume *vol, Int_t ndivisions);
    410. 

  410.    TGeoPatternCylPhi(TGeoVolume *vol, Int_t ndivisions, Double_t step);
    411. 

  411.    TGeoPatternCylPhi(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
    412. 

  412.    // destructor
    413. 

  413.    virtual ~TGeoPatternCylPhi();
    414. 

  414.    // methods
    415. 

  415.    virtual TGeoMatrix* CreateMatrix() const;
    416. 

  416.    virtual void        cd(Int_t idiv);
    417. 

  417.    virtual TGeoNode   *FindNode(Double_t *point, const Double_t *dir=0); 
    418. 

  418.    virtual Int_t       GetDivAxis()      {return 2;}
    419. 

  419.    virtual Bool_t      IsOnBoundary(const Double_t *point) const;
    420. 

  420.    virtual 
    421. 

  421.    TGeoPatternFinder  *MakeCopy(Bool_t reflect=kFALSE);
    422. 

  422.    virtual void        SavePrimitive(ostream &out, Option_t *option = "");
    423. 

  423.    virtual void        UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
    424. 

  424. 

  425.    ClassDef(TGeoPatternCylPhi, 1)              // Cylindrical phi division pattern
    426. 

  426. };
    427. 

  427. 

  428. ////////////////////////////////////////////////////////////////////////////
    429. 

  429. //                                                                        //
    430. 

  430. // TGeoPatternSphR - a spherical R divison pattern                        //
    431. 

  431. //                                                                        //
    432. 

  432. ////////////////////////////////////////////////////////////////////////////
    433. 

  433. 

  434. class TGeoPatternSphR : public TGeoPatternFinder
    435. 

  435. {
    436. 

  436. public:
    437. 

  437.    // constructors
    438. 

  438.    TGeoPatternSphR();
    439. 

  439.    TGeoPatternSphR(TGeoVolume *vol, Int_t ndivisions);
    440. 

  440.    TGeoPatternSphR(TGeoVolume *vol, Int_t ndivisions, Double_t step);
    441. 

  441.    TGeoPatternSphR(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
    442. 

  442.    TGeoPatternSphR(const TGeoPatternSphR &pf);
    443. 

  443.    TGeoPatternSphR& operator=(const TGeoPatternSphR&);
    444. 

  444.    // destructor
    445. 

  445.    virtual ~TGeoPatternSphR();
    446. 

  446.    // methods
    447. 

  447.    virtual TGeoMatrix* CreateMatrix() const;
    448. 

  448.    virtual void        cd(Int_t idiv);
    449. 

  449.    virtual TGeoNode   *FindNode(Double_t *point, const Double_t *dir=0); 
    450. 

  450.    virtual Int_t       GetDivAxis()      {return 1;}
    451. 

  451.    virtual 
    452. 

  452.    TGeoPatternFinder  *MakeCopy(Bool_t reflect=kFALSE);
    453. 

  453.    virtual void        SavePrimitive(ostream &out, Option_t *option = "");
    454. 

  454.    virtual void        UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
    455. 

  455. 

  456.    ClassDef(TGeoPatternSphR, 1)              // spherical R division pattern
    457. 

  457. };
    458. 

  458. 

  459. ////////////////////////////////////////////////////////////////////////////
    460. 

  460. //                                                                        //
    461. 

  461. // TGeoPatternSphTheta - a spherical theta divison pattern                //
    462. 

  462. //                                                                        //
    463. 

  463. ////////////////////////////////////////////////////////////////////////////
    464. 

  464. 

  465. class TGeoPatternSphTheta : public TGeoPatternFinder
    466. 

  466. {
    467. 

  467. public:
    468. 

  468.    // constructors
    469. 

  469.    TGeoPatternSphTheta();
    470. 

  470.    TGeoPatternSphTheta(TGeoVolume *vol, Int_t ndivisions);
    471. 

  471.    TGeoPatternSphTheta(TGeoVolume *vol, Int_t ndivisions, Double_t step);
    472. 

  472.    TGeoPatternSphTheta(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
    473. 

  473.    TGeoPatternSphTheta(const TGeoPatternSphTheta &pf);
    474. 

  474.    TGeoPatternSphTheta& operator=(const TGeoPatternSphTheta&);
    475. 

  475.    // destructor
    476. 

  476.    virtual ~TGeoPatternSphTheta();
    477. 

  477.    // methods
    478. 

  478.    virtual TGeoMatrix* CreateMatrix() const;
    479. 

  479.    virtual void        cd(Int_t idiv);
    480. 

  480.    virtual TGeoNode   *FindNode(Double_t *point, const Double_t *dir=0); 
    481. 

  481.    virtual Int_t       GetDivAxis()      {return 2;}
    482. 

  482.    virtual 
    483. 

  483.    TGeoPatternFinder  *MakeCopy(Bool_t reflect=kFALSE);
    484. 

  484.    virtual void        SavePrimitive(ostream &out, Option_t *option = "");
    485. 

  485.    virtual void        UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
    486. 

  486. 

  487.    ClassDef(TGeoPatternSphTheta, 1)              // spherical theta division pattern
    488. 

  488. };
    489. 

  489. 

  490. ////////////////////////////////////////////////////////////////////////////
    491. 

  491. //                                                                        //
    492. 

  492. // TGeoPatternSphPhi - a spherical phi divison pattern                    //
    493. 

  493. //                                                                        //
    494. 

  494. ////////////////////////////////////////////////////////////////////////////
    495. 

  495. 

  496. class TGeoPatternSphPhi : public TGeoPatternFinder
    497. 

  497. {
    498. 

  498. public:
    499. 

  499.    // constructors
    500. 

  500.    TGeoPatternSphPhi();
    501. 

  501.    TGeoPatternSphPhi(TGeoVolume *vol, Int_t ndivisions);
    502. 

  502.    TGeoPatternSphPhi(TGeoVolume *vol, Int_t ndivisions, Double_t step);
    503. 

  503.    TGeoPatternSphPhi(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);
    504. 

  504.    TGeoPatternSphPhi(const TGeoPatternSphPhi &pf);
    505. 

  505.    TGeoPatternSphPhi& operator=(const TGeoPatternSphPhi&);
    506. 

  506.    // destructor
    507. 

  507.    virtual ~TGeoPatternSphPhi();
    508. 

  508.    // methods
    509. 

  509.    virtual TGeoMatrix* CreateMatrix() const;
    510. 

  510.    virtual void        cd(Int_t idiv);
    511. 

  511.    virtual TGeoNode   *FindNode(Double_t *point, const Double_t *dir=0); 
    512. 

  512.    virtual Int_t       GetDivAxis()      {return 3;}
    513. 

  513.    virtual 
    514. 

  514.    TGeoPatternFinder  *MakeCopy(Bool_t reflect=kFALSE);
    515. 

  515.    virtual void        SavePrimitive(ostream &out, Option_t *option = "");
    516. 

  516.    virtual void        UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
    517. 

  517. 

  518.    ClassDef(TGeoPatternSphPhi, 1)              // Spherical phi division pattern
    519. 

  519. };
    520. 

  520. 

  521. ////////////////////////////////////////////////////////////////////////////
    522. 

  522. //                                                                        //
    523. 

  523. // TGeoPatternHoneycomb - a divison pattern specialized for honeycombs    //
    524. 

  524. //                                                                        //
    525. 

  525. ////////////////////////////////////////////////////////////////////////////
    526. 

  526. 

  527. class TGeoPatternHoneycomb : public TGeoPatternFinder
    528. 

  528. {
    529. 

  529. private :
    530. 

  530. // data members
    531. 

  531.    Int_t               fNrows;                  // number of rows
    532. 

  532.    Int_t               fAxisOnRows;             // axis along each row
    533. 

  533.    Int_t              *fNdivisions;             // [fNrows] number of divisions for each row
    534. 

  534.    Double_t           *fStart;                  // [fNrows] starting points for each row
    535. 

  535. 

  536. protected:
    537. 

  537.    TGeoPatternHoneycomb(const TGeoPatternHoneycomb&);
    538. 

  538.    TGeoPatternHoneycomb& operator=(const TGeoPatternHoneycomb&);
    539. 

  539. 

  540. public:
    541. 

  541.    // constructors
    542. 

  542.    TGeoPatternHoneycomb();
    543. 

  543.    TGeoPatternHoneycomb(TGeoVolume *vol, Int_t nrows);
    544. 

  544.    // destructor
    545. 

  545.    virtual ~TGeoPatternHoneycomb();
    546. 

  546.    // methods
    547. 

  547.    TGeoPatternFinder  *MakeCopy(Bool_t) {return 0;}
    548. 

  548.    virtual TGeoMatrix* CreateMatrix() const;
    549. 

  549.    virtual void        cd(Int_t idiv);
    550. 

  550.    virtual TGeoNode   *FindNode(Double_t *point, const Double_t *dir=0); 
    551. 

  551.    virtual void        UpdateMatrix(Int_t idiv, TGeoHMatrix &matrix) const;
    552. 

  552. 

  553.    ClassDef(TGeoPatternHoneycomb, 1)             // pattern for honeycomb divisions
    554. 

  554. };
    555. 

  555. 

  556. #endif
    557.