| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer << 3 // * DISCLAIMER *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers *
6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which *
7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: *
8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license *
9 // * include a list of copyright holders. <<
10 // * 9 // * *
11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file << 14 // * use. *
16 // * for the full disclaimer and the limitatio <<
17 // * 15 // * *
18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the *
19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. *
20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work *
21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this *
22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. *
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* 21 // ********************************************************************
25 // 22 //
26 // G4ParameterisationPolyhedra[Rho/Phi/Z] << 23 //
>> 24 // $Id: G4ParameterisationPolyhedra.hh,v 1.7 2004/05/13 14:57:12 gcosmo Exp $
>> 25 // GEANT4 tag $Name: geant4-07-00-cand-01 $
>> 26 //
>> 27 // classes G4ParameterisationPolyhedraRho,
>> 28 // G4ParameterisationPolyhedraPhi,
>> 29 // G4ParameterisationPolyhedraZ
27 // 30 //
28 // Class description: 31 // Class description:
29 // 32 //
30 // These classes represent the parameterised p 33 // These classes represent the parameterised positioning equivalent to
31 // dividing a G4Polyhedra along one of each ax 34 // dividing a G4Polyhedra along one of each axis Rho, Phi, Z.
32 35
>> 36 // History:
>> 37 // -------
33 // 09.05.01 - P.Arce, Initial version 38 // 09.05.01 - P.Arce, Initial version
34 // 08.04.04 - I.Hrivnacova, Implemented reflec 39 // 08.04.04 - I.Hrivnacova, Implemented reflection
35 //-------------------------------------------- 40 //---------------------------------------------------------------------
36 #ifndef G4PARAMETERISATIONPOLYHEDRA_HH << 41 #ifndef G4ParameterisationPolyhedra_H
37 #define G4PARAMETERISATIONPOLYHEDRA_HH 1 << 42 #define G4ParameterisationPolyhedra_H 1
38 43
39 #include "G4VDivisionParameterisation.hh" 44 #include "G4VDivisionParameterisation.hh"
40 #include "G4Polyhedra.hh" 45 #include "G4Polyhedra.hh"
41 46
42 class G4VPhysicalVolume; 47 class G4VPhysicalVolume;
43 48
44 // Dummy declarations to get rid of warnings . 49 // Dummy declarations to get rid of warnings ...
45 // <<
46 class G4Trd; 50 class G4Trd;
47 class G4Trap; 51 class G4Trap;
48 class G4Cons; 52 class G4Cons;
49 class G4Sphere; 53 class G4Sphere;
50 class G4Orb; 54 class G4Orb;
51 class G4Ellipsoid; <<
52 class G4Torus; 55 class G4Torus;
53 class G4Para; 56 class G4Para;
54 class G4Hype; 57 class G4Hype;
55 class G4Tubs; 58 class G4Tubs;
56 class G4Polycone; 59 class G4Polycone;
57 60
58 class G4VParameterisationPolyhedra : public G4 61 class G4VParameterisationPolyhedra : public G4VDivisionParameterisation
59 { 62 {
60 public: // with description 63 public: // with description
61 64
62 G4VParameterisationPolyhedra( EAxis axis, 65 G4VParameterisationPolyhedra( EAxis axis, G4int nCopies,
63 G4double offset, G 66 G4double offset, G4double step,
64 G4VSolid* msolid, 67 G4VSolid* msolid, DivisionType divType );
65 68
66 ~G4VParameterisationPolyhedra() override; << 69 virtual ~G4VParameterisationPolyhedra();
67 70
68 private: 71 private:
69 72
70 G4double ConvertRadiusFactor(const G4Polyh 73 G4double ConvertRadiusFactor(const G4Polyhedra& phedra) const;
71 // Converts radius of the sides to radiu 74 // Converts radius of the sides to radius of the corners:
72 // r_corners = r_sides/factor 75 // r_corners = r_sides/factor
73 }; 76 };
74 77
75 //-------------------------------------------- 78 //---------------------------------------------------------------------
76 // Class G4ParameterisationPolyhedraRho 79 // Class G4ParameterisationPolyhedraRho
77 //-------------------------------------------- 80 //---------------------------------------------------------------------
78 81
79 class G4ParameterisationPolyhedraRho : public 82 class G4ParameterisationPolyhedraRho : public G4VParameterisationPolyhedra
80 { 83 {
81 public: // with description 84 public: // with description
82 85
83 G4ParameterisationPolyhedraRho( EAxis axis 86 G4ParameterisationPolyhedraRho( EAxis axis, G4int nCopies,
84 G4double o 87 G4double offset, G4double step,
85 G4VSolid* 88 G4VSolid* motherSolid,
86 DivisionTy 89 DivisionType divType );
87 ~G4ParameterisationPolyhedraRho() override; << 90 virtual ~G4ParameterisationPolyhedraRho();
88 91
89 void CheckParametersValidity() override; << 92 virtual void CheckParametersValidity();
90 93
91 G4double GetMaxParameter() const override; << 94 virtual G4double GetMaxParameter() const;
92 95
93 void ComputeTransformation( const G4int co << 96 virtual void ComputeTransformation( const G4int copyNo,
94 G4VPhysi << 97 G4VPhysicalVolume* physVol ) const;
95 void ComputeDimensions( G4Polyhedra& phedr 98 void ComputeDimensions( G4Polyhedra& phedra, const G4int copyNo,
96 const G4VPhysicalV << 99 const G4VPhysicalVolume* physVol ) const;
97 100
98 private: // Dummy declarations to get rid o 101 private: // Dummy declarations to get rid of warnings ...
99 102
100 void ComputeDimensions (G4Trd&,const G4int 103 void ComputeDimensions (G4Trd&,const G4int,
101 const G4VPhysicalV << 104 const G4VPhysicalVolume*) const {}
102 void ComputeDimensions (G4Trap&,const G4in 105 void ComputeDimensions (G4Trap&,const G4int,
103 const G4VPhysicalV << 106 const G4VPhysicalVolume*) const {}
104 void ComputeDimensions (G4Box&,const G4int 107 void ComputeDimensions (G4Box&,const G4int,
105 const G4VPhysicalV << 108 const G4VPhysicalVolume*) const {}
106 void ComputeDimensions (G4Sphere&,const G4 109 void ComputeDimensions (G4Sphere&,const G4int,
107 const G4VPhysicalV << 110 const G4VPhysicalVolume*) const {}
108 void ComputeDimensions (G4Orb&,const G4int 111 void ComputeDimensions (G4Orb&,const G4int,
109 const G4VPhysicalV << 112 const G4VPhysicalVolume*) const {}
110 void ComputeDimensions (G4Ellipsoid&,const <<
111 const G4VPhysicalV <<
112 void ComputeDimensions (G4Torus&,const G4i 113 void ComputeDimensions (G4Torus&,const G4int,
113 const G4VPhysicalV << 114 const G4VPhysicalVolume*) const {}
114 void ComputeDimensions (G4Para&,const G4in 115 void ComputeDimensions (G4Para&,const G4int,
115 const G4VPhysicalV << 116 const G4VPhysicalVolume*) const {}
116 void ComputeDimensions (G4Hype&,const G4in 117 void ComputeDimensions (G4Hype&,const G4int,
117 const G4VPhysicalV << 118 const G4VPhysicalVolume*) const {}
118 void ComputeDimensions (G4Tubs&,const G4in 119 void ComputeDimensions (G4Tubs&,const G4int,
119 const G4VPhysicalV << 120 const G4VPhysicalVolume*) const {}
120 void ComputeDimensions (G4Cons&,const G4in 121 void ComputeDimensions (G4Cons&,const G4int,
121 const G4VPhysicalV << 122 const G4VPhysicalVolume*) const {}
122 void ComputeDimensions (G4Polycone&,const 123 void ComputeDimensions (G4Polycone&,const G4int,
123 const G4VPhysicalV << 124 const G4VPhysicalVolume*) const {}
124 }; 125 };
125 126
126 //-------------------------------------------- 127 //---------------------------------------------------------------------
127 // Class G4ParameterisationPolyhedraPhi 128 // Class G4ParameterisationPolyhedraPhi
128 //-------------------------------------------- 129 //---------------------------------------------------------------------
129 130
130 class G4ParameterisationPolyhedraPhi : public 131 class G4ParameterisationPolyhedraPhi : public G4VParameterisationPolyhedra
131 { 132 {
132 public: // with description 133 public: // with description
133 134
134 G4ParameterisationPolyhedraPhi( EAxis axis 135 G4ParameterisationPolyhedraPhi( EAxis axis, G4int nCopies,
135 G4double of 136 G4double offset, G4double step,
136 G4VSolid* m 137 G4VSolid* motherSolid,
137 DivisionTyp 138 DivisionType divType );
138 ~G4ParameterisationPolyhedraPhi() override; << 139 virtual ~G4ParameterisationPolyhedraPhi();
139 140
140 void CheckParametersValidity() override; << 141 virtual void CheckParametersValidity();
141 142
142 G4double GetMaxParameter() const override; << 143 virtual G4double GetMaxParameter() const;
143 144
144 void ComputeTransformation( const G4int co << 145 virtual void ComputeTransformation( const G4int copyNo,
145 G4VPhysi << 146 G4VPhysicalVolume* physVol ) const;
146 void ComputeDimensions( G4Polyhedra& phedr 147 void ComputeDimensions( G4Polyhedra& phedra, const G4int copyNo,
147 const G4VPhysicalV << 148 const G4VPhysicalVolume* physVol ) const;
148 149
149 private: // Dummy declarations to get rid o 150 private: // Dummy declarations to get rid of warnings ...
150 151
151 void ComputeDimensions (G4Trd&,const G4int 152 void ComputeDimensions (G4Trd&,const G4int,
152 const G4VPhysicalV << 153 const G4VPhysicalVolume*) const {}
153 void ComputeDimensions (G4Trap&,const G4in 154 void ComputeDimensions (G4Trap&,const G4int,
154 const G4VPhysicalV << 155 const G4VPhysicalVolume*) const {}
155 void ComputeDimensions (G4Box&,const G4int 156 void ComputeDimensions (G4Box&,const G4int,
156 const G4VPhysicalV << 157 const G4VPhysicalVolume*) const {}
157 void ComputeDimensions (G4Sphere&,const G4 158 void ComputeDimensions (G4Sphere&,const G4int,
158 const G4VPhysicalV << 159 const G4VPhysicalVolume*) const {}
159 void ComputeDimensions (G4Orb&,const G4int 160 void ComputeDimensions (G4Orb&,const G4int,
160 const G4VPhysicalV << 161 const G4VPhysicalVolume*) const {}
161 void ComputeDimensions (G4Ellipsoid&,const <<
162 const G4VPhysicalV <<
163 void ComputeDimensions (G4Torus&,const G4i 162 void ComputeDimensions (G4Torus&,const G4int,
164 const G4VPhysicalV << 163 const G4VPhysicalVolume*) const {}
165 void ComputeDimensions (G4Para&,const G4in 164 void ComputeDimensions (G4Para&,const G4int,
166 const G4VPhysicalV << 165 const G4VPhysicalVolume*) const {}
167 void ComputeDimensions (G4Hype&,const G4in 166 void ComputeDimensions (G4Hype&,const G4int,
168 const G4VPhysicalV << 167 const G4VPhysicalVolume*) const {}
169 void ComputeDimensions (G4Tubs&,const G4in 168 void ComputeDimensions (G4Tubs&,const G4int,
170 const G4VPhysicalV << 169 const G4VPhysicalVolume*) const {}
171 void ComputeDimensions (G4Cons&,const G4in 170 void ComputeDimensions (G4Cons&,const G4int,
172 const G4VPhysicalV << 171 const G4VPhysicalVolume*) const {}
173 void ComputeDimensions (G4Polycone&,const 172 void ComputeDimensions (G4Polycone&,const G4int,
174 const G4VPhysicalV << 173 const G4VPhysicalVolume*) const {}
175 }; 174 };
176 175
177 //-------------------------------------------- 176 //---------------------------------------------------------------------
178 // Class G4ParameterisationPolyhedraZ 177 // Class G4ParameterisationPolyhedraZ
179 //-------------------------------------------- 178 //---------------------------------------------------------------------
180 179
181 class G4ParameterisationPolyhedraZ : public G4 180 class G4ParameterisationPolyhedraZ : public G4VParameterisationPolyhedra
182 { 181 {
183 public: // with description 182 public: // with description
184 183
185 G4ParameterisationPolyhedraZ( EAxis axis, 184 G4ParameterisationPolyhedraZ( EAxis axis, G4int nCopies,
186 G4double off 185 G4double offset, G4double step,
187 G4VSolid* mo 186 G4VSolid* motherSolid,
188 DivisionType 187 DivisionType divType );
189 ~G4ParameterisationPolyhedraZ() override; << 188 virtual ~G4ParameterisationPolyhedraZ();
190 189
191 void CheckParametersValidity() override; << 190 virtual void CheckParametersValidity();
192 191
193 G4double GetMaxParameter() const override; << 192 virtual G4double GetMaxParameter() const;
194 193
195 void ComputeTransformation( const G4int co << 194 virtual void ComputeTransformation( const G4int copyNo,
196 G4VPhysi << 195 G4VPhysicalVolume* physVol ) const;
197 void ComputeDimensions( G4Polyhedra& phedr 196 void ComputeDimensions( G4Polyhedra& phedra, const G4int copyNo,
198 const G4VPhysicalV << 197 const G4VPhysicalVolume* physVol ) const;
199 <<
200 private: <<
201 198
202 G4double GetR(G4double z, G4double z1, G4d << 199 private: // Dummy declarations to get rid of warnings ...
203 G4double z2, G4double r2) co <<
204 G4double GetRmin(G4double z, G4int nsegmen <<
205 G4double GetRmax(G4double z, G4int nsegmen <<
206 200
207 // Dummy declarations to get rid of warnin <<
208 void ComputeDimensions (G4Trd&,const G4int 201 void ComputeDimensions (G4Trd&,const G4int,
209 const G4VPhysicalV << 202 const G4VPhysicalVolume*) const {}
210 void ComputeDimensions (G4Trap&,const G4in 203 void ComputeDimensions (G4Trap&,const G4int,
211 const G4VPhysicalV << 204 const G4VPhysicalVolume*) const {}
212 void ComputeDimensions (G4Box&,const G4int 205 void ComputeDimensions (G4Box&,const G4int,
213 const G4VPhysicalV << 206 const G4VPhysicalVolume*) const {}
214 void ComputeDimensions (G4Sphere&,const G4 207 void ComputeDimensions (G4Sphere&,const G4int,
215 const G4VPhysicalV << 208 const G4VPhysicalVolume*) const {}
216 void ComputeDimensions (G4Orb&,const G4int 209 void ComputeDimensions (G4Orb&,const G4int,
217 const G4VPhysicalV << 210 const G4VPhysicalVolume*) const {}
218 void ComputeDimensions (G4Ellipsoid&,const <<
219 const G4VPhysicalV <<
220 void ComputeDimensions (G4Torus&,const G4i 211 void ComputeDimensions (G4Torus&,const G4int,
221 const G4VPhysicalV << 212 const G4VPhysicalVolume*) const {}
222 void ComputeDimensions (G4Para&,const G4in 213 void ComputeDimensions (G4Para&,const G4int,
223 const G4VPhysicalV << 214 const G4VPhysicalVolume*) const {}
224 void ComputeDimensions (G4Hype&,const G4in 215 void ComputeDimensions (G4Hype&,const G4int,
225 const G4VPhysicalV << 216 const G4VPhysicalVolume*) const {}
226 void ComputeDimensions (G4Tubs&,const G4in 217 void ComputeDimensions (G4Tubs&,const G4int,
227 const G4VPhysicalV << 218 const G4VPhysicalVolume*) const {}
228 void ComputeDimensions (G4Cons&,const G4in 219 void ComputeDimensions (G4Cons&,const G4int,
229 const G4VPhysicalV << 220 const G4VPhysicalVolume*) const {}
230 void ComputeDimensions (G4Polycone&,const 221 void ComputeDimensions (G4Polycone&,const G4int,
231 const G4VPhysicalV << 222 const G4VPhysicalVolume*) const {}
232 private: <<
233 <<
234 G4int fNSegment = 0; <<
235 G4PolyhedraHistorical* fOrigParamMother = <<
236 }; 223 };
237 224
238 #endif 225 #endif
239 226