| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // G4PVDivision Implementation file <<
27 // 26 //
28 // 26.05.03 - P.Arce, Initial version << 27 // $Id: G4PVDivision.cc,v 1.24 2010-09-06 09:28:24 gcosmo Exp $
>> 28 // GEANT4 tag $Name: not supported by cvs2svn $
>> 29 //
>> 30 // class G4PVDivision Implementation file
>> 31 //
>> 32 // 26.05.03 - P.Arce Initial version
29 // ------------------------------------------- 33 // --------------------------------------------------------------------
30 34
31 #include "G4PVDivision.hh" 35 #include "G4PVDivision.hh"
32 #include "G4LogicalVolume.hh" 36 #include "G4LogicalVolume.hh"
33 #include "G4VSolid.hh" 37 #include "G4VSolid.hh"
34 #include "G4ReflectedSolid.hh" 38 #include "G4ReflectedSolid.hh"
35 #include "G4ParameterisationBox.hh" 39 #include "G4ParameterisationBox.hh"
36 #include "G4ParameterisationTubs.hh" 40 #include "G4ParameterisationTubs.hh"
37 #include "G4ParameterisationCons.hh" 41 #include "G4ParameterisationCons.hh"
38 #include "G4ParameterisationTrd.hh" 42 #include "G4ParameterisationTrd.hh"
39 #include "G4ParameterisationPara.hh" 43 #include "G4ParameterisationPara.hh"
40 #include "G4ParameterisationPolycone.hh" 44 #include "G4ParameterisationPolycone.hh"
41 #include "G4ParameterisationPolyhedra.hh" 45 #include "G4ParameterisationPolyhedra.hh"
42 46
43 //-------------------------------------------- 47 //--------------------------------------------------------------------------
44 G4PVDivision::G4PVDivision(const G4String& pNa 48 G4PVDivision::G4PVDivision(const G4String& pName,
45 G4LogicalVolu 49 G4LogicalVolume* pLogical,
46 G4LogicalVolu 50 G4LogicalVolume* pMotherLogical,
47 const EAxis pAxis, 51 const EAxis pAxis,
48 const G4int nDivs, 52 const G4int nDivs,
49 const G4double widt 53 const G4double width,
50 const G4double offs 54 const G4double offset )
51 : G4PVReplica(pName, nDivs, pAxis, pLogical, << 55 : G4VPhysicalVolume(0,G4ThreeVector(),pName,pLogical,0),
>> 56 fcopyNo(-1)
52 { 57 {
53 if (pMotherLogical == nullptr) << 58 if (!pMotherLogical)
54 { 59 {
55 std::ostringstream message; 60 std::ostringstream message;
56 message << "Invalid setup." << G4endl 61 message << "Invalid setup." << G4endl
57 << "NULL pointer specified as moth 62 << "NULL pointer specified as mother for volume: " << pName;
58 G4Exception("G4PVDivision::G4PVDivision()" 63 G4Exception("G4PVDivision::G4PVDivision()", "GeomDiv0002",
59 FatalException, message); 64 FatalException, message);
60 return; 65 return;
61 } 66 }
62 if (pLogical == pMotherLogical) 67 if (pLogical == pMotherLogical)
63 { 68 {
64 std::ostringstream message; 69 std::ostringstream message;
65 message << "Invalid setup." << G4endl 70 message << "Invalid setup." << G4endl
66 << "Cannot place a volume inside i 71 << "Cannot place a volume inside itself! Volume: " << pName;
67 G4Exception("G4PVDivision::G4PVDivision()" 72 G4Exception("G4PVDivision::G4PVDivision()", "GeomDiv0002",
68 FatalException, message); 73 FatalException, message);
69 } 74 }
70 pMotherLogical->AddDaughter(this); 75 pMotherLogical->AddDaughter(this);
71 SetMotherLogical(pMotherLogical); 76 SetMotherLogical(pMotherLogical);
72 SetParameterisation(pMotherLogical, pAxis, n 77 SetParameterisation(pMotherLogical, pAxis, nDivs,
73 width, offset, DivNDIVan 78 width, offset, DivNDIVandWIDTH);
74 CheckAndSetParameters (pAxis, nDivs, width, 79 CheckAndSetParameters (pAxis, nDivs, width, offset,
75 DivNDIVandWIDTH, pMot 80 DivNDIVandWIDTH, pMotherLogical);
76 } 81 }
77 82
78 //-------------------------------------------- 83 //--------------------------------------------------------------------------
79 G4PVDivision::G4PVDivision(const G4String& pNa 84 G4PVDivision::G4PVDivision(const G4String& pName,
80 G4LogicalVolu 85 G4LogicalVolume* pLogical,
81 G4LogicalVolu 86 G4LogicalVolume* pMotherLogical,
82 const EAxis pAxis, 87 const EAxis pAxis,
83 const G4int nDivs, 88 const G4int nDivs,
84 const G4double offs 89 const G4double offset )
85 : G4PVReplica(pName, nDivs, pAxis, pLogical, << 90 : G4VPhysicalVolume(0,G4ThreeVector(),pName,pLogical,0),
>> 91 fcopyNo(-1)
86 { 92 {
87 if (pMotherLogical == nullptr) << 93 if (!pMotherLogical)
88 { 94 {
89 std::ostringstream message; 95 std::ostringstream message;
90 message << "Invalid setup." << G4endl 96 message << "Invalid setup." << G4endl
91 << "NULL pointer specified as moth 97 << "NULL pointer specified as mother! Volume: " << pName;
92 G4Exception("G4PVDivision::G4PVDivision()" 98 G4Exception("G4PVDivision::G4PVDivision()", "GeomDiv0002",
93 FatalException, message); 99 FatalException, message);
94 return; 100 return;
95 } 101 }
96 if (pLogical == pMotherLogical) 102 if (pLogical == pMotherLogical)
97 { 103 {
98 std::ostringstream message; 104 std::ostringstream message;
99 message << "Invalid setup." << G4endl 105 message << "Invalid setup." << G4endl
100 << "Cannot place a volume inside i 106 << "Cannot place a volume inside itself! Volume: " << pName;
101 G4Exception("G4PVDivision::G4PVDivision()" 107 G4Exception("G4PVDivision::G4PVDivision()", "GeomDiv0002",
102 FatalException, message); 108 FatalException, message);
103 } 109 }
104 pMotherLogical->AddDaughter(this); 110 pMotherLogical->AddDaughter(this);
105 SetMotherLogical(pMotherLogical); 111 SetMotherLogical(pMotherLogical);
106 SetParameterisation(pMotherLogical, pAxis, n 112 SetParameterisation(pMotherLogical, pAxis, nDivs, 0., offset, DivNDIV);
107 CheckAndSetParameters (pAxis, nDivs, 0., off 113 CheckAndSetParameters (pAxis, nDivs, 0., offset, DivNDIV, pMotherLogical);
108 } 114 }
109 115
110 //-------------------------------------------- 116 //--------------------------------------------------------------------------
111 G4PVDivision::G4PVDivision(const G4String& pNa 117 G4PVDivision::G4PVDivision(const G4String& pName,
112 G4LogicalVolu 118 G4LogicalVolume* pLogical,
113 G4LogicalVolu 119 G4LogicalVolume* pMotherLogical,
114 const EAxis pAxis, 120 const EAxis pAxis,
115 const G4double widt 121 const G4double width,
116 const G4double offs 122 const G4double offset )
117 : G4PVReplica(pName, 0, pAxis, pLogical, pMo << 123 : G4VPhysicalVolume(0,G4ThreeVector(),pName,pLogical,0),
>> 124 fcopyNo(-1)
118 { 125 {
119 if (pMotherLogical == nullptr) << 126 if (!pMotherLogical)
120 { 127 {
121 std::ostringstream message; 128 std::ostringstream message;
122 message << "Invalid setup." << G4endl 129 message << "Invalid setup." << G4endl
123 << "NULL pointer specified as moth 130 << "NULL pointer specified as mother! Volume: " + pName;
124 G4Exception("G4PVDivision::G4PVDivision()" 131 G4Exception("G4PVDivision::G4PVDivision()", "GeomDiv0002",
125 FatalException, message); 132 FatalException, message);
126 return; 133 return;
127 } 134 }
128 if (pLogical == pMotherLogical) 135 if (pLogical == pMotherLogical)
129 { 136 {
130 std::ostringstream message; 137 std::ostringstream message;
131 message << "Invalid setup." << G4endl 138 message << "Invalid setup." << G4endl
132 << "Cannot place a volume inside i 139 << "Cannot place a volume inside itself! Volume: "+ pName;
133 G4Exception("G4PVDivision::G4PVDivision()" 140 G4Exception("G4PVDivision::G4PVDivision()", "GeomDiv0002",
134 FatalException, message); 141 FatalException, message);
135 } 142 }
136 pMotherLogical->AddDaughter(this); 143 pMotherLogical->AddDaughter(this);
137 SetMotherLogical(pMotherLogical); 144 SetMotherLogical(pMotherLogical);
138 SetParameterisation(pMotherLogical, pAxis, 0 145 SetParameterisation(pMotherLogical, pAxis, 0, width, offset, DivWIDTH);
139 CheckAndSetParameters (pAxis, 0, width, offs 146 CheckAndSetParameters (pAxis, 0, width, offset, DivWIDTH, pMotherLogical);
140 } 147 }
141 148
142 //-------------------------------------------- 149 //--------------------------------------------------------------------------
143 G4PVDivision::G4PVDivision(const G4String& pNa <<
144 G4LogicalVolu <<
145 G4VPhysicalVo <<
146 const EAxis pAxis, <<
147 const G4int nDivs, <<
148 const G4double widt <<
149 const G4double offs <<
150 : G4PVReplica(pName, nDivs, pAxis, pLogical, <<
151 pMotherPhysical != nullptr ? p <<
152 { <<
153 if (pMotherPhysical == nullptr) <<
154 { <<
155 std::ostringstream message; <<
156 message << "Invalid setup." << G4endl <<
157 << "NULL pointer specified as moth <<
158 G4Exception("G4PVDivision::G4PVDivision()" <<
159 FatalException, message); <<
160 return; <<
161 } <<
162 G4LogicalVolume* pMotherLogical = pMotherPhy <<
163 if (pLogical == pMotherLogical) <<
164 { <<
165 std::ostringstream message; <<
166 message << "Invalid setup." << G4endl <<
167 << "Cannot place a volume inside i <<
168 G4Exception("G4PVDivision::G4PVDivision()" <<
169 FatalException, message); <<
170 } <<
171 pMotherLogical->AddDaughter(this); <<
172 SetMotherLogical(pMotherLogical); <<
173 SetParameterisation(pMotherLogical, pAxis, n <<
174 width, offset, DivNDIVan <<
175 CheckAndSetParameters (pAxis, nDivs, width, <<
176 DivNDIVandWIDTH, pMot <<
177 } <<
178 <<
179 //-------------------------------------------- <<
180 void 150 void
181 G4PVDivision::CheckAndSetParameters( const EAx 151 G4PVDivision::CheckAndSetParameters( const EAxis pAxis,
182 const G4i 152 const G4int nDivs,
183 const G4d 153 const G4double width,
184 const G4d 154 const G4double offset,
185 Div 155 DivisionType divType,
186 const G4L 156 const G4LogicalVolume* pMotherLogical )
187 { 157 {
188 if( divType == DivWIDTH ) 158 if( divType == DivWIDTH )
189 { 159 {
190 fnReplicas = fparam->GetNoDiv(); 160 fnReplicas = fparam->GetNoDiv();
191 } 161 }
192 else 162 else
193 { 163 {
194 fnReplicas = nDivs; 164 fnReplicas = nDivs;
195 } 165 }
196 if (fnReplicas < 1 ) 166 if (fnReplicas < 1 )
197 { 167 {
198 G4Exception("G4PVDivision::CheckAndSetPara 168 G4Exception("G4PVDivision::CheckAndSetParameters()", "GeomDiv0002",
199 FatalException, "Illegal numbe 169 FatalException, "Illegal number of replicas!");
200 } 170 }
201 171
202 if( divType != DivNDIV) 172 if( divType != DivNDIV)
203 { 173 {
204 fwidth = fparam->GetWidth(); 174 fwidth = fparam->GetWidth();
205 } 175 }
206 else 176 else
207 { 177 {
208 fwidth = width; 178 fwidth = width;
209 } 179 }
210 if( fwidth < 0 ) 180 if( fwidth < 0 )
211 { 181 {
212 G4Exception("G4PVDivision::CheckAndSetPara 182 G4Exception("G4PVDivision::CheckAndSetParameters()", "GeomDiv0002",
213 FatalException, "Width must be 183 FatalException, "Width must be positive!");
214 } 184 }
215 185
216 foffset = offset; 186 foffset = offset;
217 fdivAxis = pAxis; 187 fdivAxis = pAxis;
218 188
219 //!!!!! axis has to be x/y/z in G4VoxelLimit 189 //!!!!! axis has to be x/y/z in G4VoxelLimits::GetMinExtent
220 // 190 //
221 if( pAxis == kRho || pAxis == kRadial3D || p 191 if( pAxis == kRho || pAxis == kRadial3D || pAxis == kPhi )
222 { 192 {
223 faxis = kZAxis; 193 faxis = kZAxis;
224 } 194 }
225 else 195 else
226 { 196 {
227 faxis = pAxis; 197 faxis = pAxis;
228 } 198 }
229 199
230 // Create rotation matrix: for phi axis it w 200 // Create rotation matrix: for phi axis it will be changed
231 // in G4VPVParameterisation::ComputeTransfor 201 // in G4VPVParameterisation::ComputeTransformation, for others
232 // it will stay the unity 202 // it will stay the unity
233 // 203 //
234 auto pRMat = new G4RotationMatrix(); << 204 G4RotationMatrix *pRMat = new G4RotationMatrix();
235 SetRotation(pRMat); 205 SetRotation(pRMat);
236 206
237 switch (faxis) 207 switch (faxis)
238 { 208 {
239 case kPhi: 209 case kPhi:
240 break; 210 break;
241 case kRho: 211 case kRho:
242 case kXAxis: 212 case kXAxis:
243 case kYAxis: 213 case kYAxis:
244 case kZAxis: 214 case kZAxis:
245 break; 215 break;
246 default: 216 default:
247 G4Exception("G4PVDivision::CheckAndSetPa 217 G4Exception("G4PVDivision::CheckAndSetParameters()", "GeomDiv0002",
248 FatalException, "Unknown axi 218 FatalException, "Unknown axis of replication.");
249 break; 219 break;
250 } 220 }
251 221
252 222
253 //----- Check that mother solid is of the sa 223 //----- Check that mother solid is of the same type than
254 // daughter solid (otherwise, the corre 224 // daughter solid (otherwise, the corresponding
255 // Parameterisation::ComputeDimension() 225 // Parameterisation::ComputeDimension() will not be called)
256 // 226 //
257 G4String msolType = pMotherLogical->GetSolid 227 G4String msolType = pMotherLogical->GetSolid()->GetEntityType();
258 G4String dsolType = GetLogicalVolume()->GetS 228 G4String dsolType = GetLogicalVolume()->GetSolid()->GetEntityType();
259 if( msolType != dsolType && ( msolType != "G 229 if( msolType != dsolType && ( msolType != "G4Trd" || dsolType != "G4Trap" ) )
260 { 230 {
261 std::ostringstream message; 231 std::ostringstream message;
262 message << "Incorrect solid type for divis 232 message << "Incorrect solid type for division of volume "
263 << GetName() << "." << G4endl 233 << GetName() << "." << G4endl
264 << "It is: " << msolType 234 << "It is: " << msolType
265 << ", while it should be: " << dso 235 << ", while it should be: " << dsolType << "!";
266 G4Exception("G4PVDivision::CheckAndSetPara 236 G4Exception("G4PVDivision::CheckAndSetParameters()",
267 "GeomDiv0002", FatalException, 237 "GeomDiv0002", FatalException, message );
268 } 238 }
269 } 239 }
270 240
271 //-------------------------------------------- 241 //--------------------------------------------------------------------------
272 G4PVDivision::~G4PVDivision() = default; << 242 G4PVDivision::~G4PVDivision()
>> 243 {
>> 244 delete GetRotation();
>> 245 }
273 246
274 //-------------------------------------------- 247 //--------------------------------------------------------------------------
275 EAxis G4PVDivision::GetDivisionAxis() const 248 EAxis G4PVDivision::GetDivisionAxis() const
276 { 249 {
277 return fdivAxis; 250 return fdivAxis;
278 } 251 }
279 252
280 //-------------------------------------------- 253 //--------------------------------------------------------------------------
281 G4bool G4PVDivision::IsParameterised() const 254 G4bool G4PVDivision::IsParameterised() const
282 { 255 {
283 return true; 256 return true;
284 } 257 }
285 258
286 //-------------------------------------------- 259 //--------------------------------------------------------------------------
287 G4bool G4PVDivision::IsMany() const 260 G4bool G4PVDivision::IsMany() const
288 { 261 {
289 return false; 262 return false;
290 } 263 }
291 264
292 //-------------------------------------------- 265 //--------------------------------------------------------------------------
293 G4bool G4PVDivision::IsReplicated() const << 266 G4int G4PVDivision::GetCopyNo() const
294 { 267 {
295 return true; << 268 return fcopyNo;
296 } 269 }
297 270
298 //-------------------------------------------- 271 //--------------------------------------------------------------------------
299 G4int G4PVDivision::GetMultiplicity() const << 272 void G4PVDivision::SetCopyNo(G4int newCopyNo)
300 { 273 {
301 return fnReplicas; << 274 fcopyNo= newCopyNo;
>> 275 }
>> 276
>> 277 //--------------------------------------------------------------------------
>> 278 G4bool G4PVDivision::IsReplicated() const
>> 279 {
>> 280 return true;
302 } 281 }
303 282
304 //-------------------------------------------- 283 //--------------------------------------------------------------------------
305 G4VPVParameterisation* G4PVDivision::GetParame 284 G4VPVParameterisation* G4PVDivision::GetParameterisation() const
306 { 285 {
307 return fparam; 286 return fparam;
308 } 287 }
309 288
310 //-------------------------------------------- 289 //--------------------------------------------------------------------------
311 void G4PVDivision::GetReplicationData(EAxis& a 290 void G4PVDivision::GetReplicationData(EAxis& axis,
312 G4int& n 291 G4int& nDivs,
313 G4double 292 G4double& width,
314 G4double 293 G4double& offset,
315 G4bool& 294 G4bool& consuming ) const
316 { 295 {
317 axis = faxis; << 296 axis=faxis;
318 nDivs = fnReplicas; << 297 nDivs=fnReplicas;
319 width = fwidth; << 298 width=fwidth;
320 offset = foffset; << 299 offset=foffset;
321 consuming = false; << 300 consuming=false;
322 } 301 }
323 302
324 //-------------------------------------------- <<
325 EVolume G4PVDivision::VolumeType() const <<
326 { <<
327 return kParameterised; <<
328 } <<
329 303
330 //-------------------------------------------- 304 //--------------------------------------------------------------------------
331 // TODO: this method should check that the chi << 305 //TODO: this method should check that the child lv is of the correct type,
332 // else the ComputeDimensions will never << 306 // else the ComputeDimensions will never be called
333 // <<
334 void G4PVDivision::SetParameterisation( G4Logi 307 void G4PVDivision::SetParameterisation( G4LogicalVolume* motherLogical,
335 const EAxis 308 const EAxis axis,
336 const G4int 309 const G4int nDivs,
337 const G4doub 310 const G4double width,
338 const G4doub 311 const G4double offset,
339 Divisi 312 DivisionType divType )
340 { 313 {
341 // Check that solid is compatible with mothe 314 // Check that solid is compatible with mother solid and axis of division
342 // CheckSolid( solid, motherSolid ); 315 // CheckSolid( solid, motherSolid );
343 // G4cout << " Axis " << axis << G4endl; 316 // G4cout << " Axis " << axis << G4endl;
344 317
345 G4VSolid* mSolid = motherLogical->GetSolid() 318 G4VSolid* mSolid = motherLogical->GetSolid();
346 G4String mSolidType = mSolid->GetEntityType( 319 G4String mSolidType = mSolid->GetEntityType();
347 320
348 // If the solid is a reflected one, update t 321 // If the solid is a reflected one, update type to its
349 // real constituent solid. 322 // real constituent solid.
350 // 323 //
351 if (mSolidType == "G4ReflectedSolid") 324 if (mSolidType == "G4ReflectedSolid")
352 { 325 {
353 mSolidType = ((G4ReflectedSolid*)mSolid) 326 mSolidType = ((G4ReflectedSolid*)mSolid)->GetConstituentMovedSolid()
354 ->GetEntityType(); 327 ->GetEntityType();
355 } 328 }
356 329
357 // Parameterisation type depend of mother so 330 // Parameterisation type depend of mother solid type and axis of division
358 // 331 //
359 if( mSolidType == "G4Box" ) 332 if( mSolidType == "G4Box" )
360 { 333 {
361 switch( axis ) 334 switch( axis )
362 { 335 {
363 case kXAxis: 336 case kXAxis:
364 fparam = new G4ParameterisationBoxX( a 337 fparam = new G4ParameterisationBoxX( axis, nDivs, width,
365 o 338 offset, mSolid, divType );
366 break; 339 break;
367 case kYAxis: 340 case kYAxis:
368 fparam = new G4ParameterisationBoxY( a 341 fparam = new G4ParameterisationBoxY( axis, nDivs, width,
369 o 342 offset, mSolid, divType );
370 break; 343 break;
371 case kZAxis: 344 case kZAxis:
372 fparam = new G4ParameterisationBoxZ( a 345 fparam = new G4ParameterisationBoxZ( axis, nDivs, width,
373 o 346 offset, mSolid, divType );
374 break; 347 break;
375 default: 348 default:
376 ErrorInAxis( axis, mSolid ); 349 ErrorInAxis( axis, mSolid );
377 break; 350 break;
378 } 351 }
379 } 352 }
380 else if( mSolidType == "G4Tubs" ) 353 else if( mSolidType == "G4Tubs" )
381 { 354 {
382 switch( axis ) 355 switch( axis )
383 { 356 {
384 case kRho: 357 case kRho:
385 fparam = new G4ParameterisationTubsRho 358 fparam = new G4ParameterisationTubsRho( axis, nDivs, width,
386 359 offset, mSolid, divType );
387 break; 360 break;
388 case kPhi: 361 case kPhi:
389 fparam = new G4ParameterisationTubsPhi 362 fparam = new G4ParameterisationTubsPhi( axis, nDivs, width,
390 363 offset, mSolid, divType );
391 break; 364 break;
392 case kZAxis: 365 case kZAxis:
393 fparam = new G4ParameterisationTubsZ( 366 fparam = new G4ParameterisationTubsZ( axis, nDivs, width,
394 367 offset, mSolid, divType );
395 break; 368 break;
396 default: 369 default:
397 ErrorInAxis( axis, mSolid ); 370 ErrorInAxis( axis, mSolid );
398 break; 371 break;
399 } 372 }
400 } 373 }
401 else if( mSolidType == "G4Cons" ) 374 else if( mSolidType == "G4Cons" )
402 { 375 {
403 switch( axis ) 376 switch( axis )
404 { 377 {
405 case kRho: 378 case kRho:
406 fparam = new G4ParameterisationConsRho 379 fparam = new G4ParameterisationConsRho( axis, nDivs, width,
407 380 offset, mSolid, divType );
408 break; 381 break;
409 case kPhi: 382 case kPhi:
410 fparam = new G4ParameterisationConsPhi 383 fparam = new G4ParameterisationConsPhi( axis, nDivs, width,
411 384 offset, mSolid, divType );
412 break; 385 break;
413 case kZAxis: 386 case kZAxis:
414 fparam = new G4ParameterisationConsZ( 387 fparam = new G4ParameterisationConsZ( axis, nDivs, width,
415 388 offset, mSolid, divType );
416 break; 389 break;
417 default: 390 default:
418 ErrorInAxis( axis, mSolid ); 391 ErrorInAxis( axis, mSolid );
419 break; 392 break;
420 } 393 }
421 } 394 }
422 else if( mSolidType == "G4Trd" ) 395 else if( mSolidType == "G4Trd" )
423 { 396 {
424 switch( axis ) 397 switch( axis )
425 { 398 {
426 case kXAxis: 399 case kXAxis:
427 fparam = new G4ParameterisationTrdX( a 400 fparam = new G4ParameterisationTrdX( axis, nDivs, width,
428 o 401 offset, mSolid, divType );
429 break; 402 break;
430 case kYAxis: 403 case kYAxis:
431 fparam = new G4ParameterisationTrdY( a 404 fparam = new G4ParameterisationTrdY( axis, nDivs, width,
432 o 405 offset, mSolid, divType );
433 break; 406 break;
434 case kZAxis: 407 case kZAxis:
435 fparam = new G4ParameterisationTrdZ( a 408 fparam = new G4ParameterisationTrdZ( axis, nDivs, width,
436 o 409 offset, mSolid, divType );
437 break; 410 break;
438 default: 411 default:
439 ErrorInAxis( axis, mSolid ); 412 ErrorInAxis( axis, mSolid );
440 break; 413 break;
441 } 414 }
442 } 415 }
443 else if( mSolidType == "G4Para" ) 416 else if( mSolidType == "G4Para" )
444 { 417 {
445 switch( axis ) 418 switch( axis )
446 { 419 {
447 case kXAxis: 420 case kXAxis:
448 fparam = new G4ParameterisationParaX( 421 fparam = new G4ParameterisationParaX( axis, nDivs, width,
449 o 422 offset, mSolid, divType );
450 break; 423 break;
451 case kYAxis: 424 case kYAxis:
452 fparam = new G4ParameterisationParaY( 425 fparam = new G4ParameterisationParaY( axis, nDivs, width,
453 o 426 offset, mSolid, divType );
454 break; 427 break;
455 case kZAxis: 428 case kZAxis:
456 fparam = new G4ParameterisationParaZ( 429 fparam = new G4ParameterisationParaZ( axis, nDivs, width,
457 o 430 offset, mSolid, divType );
458 break; 431 break;
459 default: 432 default:
460 ErrorInAxis( axis, mSolid ); 433 ErrorInAxis( axis, mSolid );
461 break; 434 break;
462 } 435 }
463 } 436 }
464 // else if( mSolidType == "G4Trap" ) 437 // else if( mSolidType == "G4Trap" )
465 // { 438 // {
466 // } 439 // }
467 else if( mSolidType == "G4Polycone" ) 440 else if( mSolidType == "G4Polycone" )
468 { 441 {
469 switch( axis ) 442 switch( axis )
470 { 443 {
471 case kRho: 444 case kRho:
472 fparam = new G4ParameterisationPolycon 445 fparam = new G4ParameterisationPolyconeRho( axis, nDivs, width,
473 446 offset, mSolid, divType );
474 break; 447 break;
475 case kPhi: 448 case kPhi:
476 fparam = new G4ParameterisationPolycon 449 fparam = new G4ParameterisationPolyconePhi( axis, nDivs, width,
477 450 offset, mSolid, divType );
478 break; 451 break;
479 case kZAxis: 452 case kZAxis:
480 fparam = new G4ParameterisationPolycon 453 fparam = new G4ParameterisationPolyconeZ( axis, nDivs, width,
481 454 offset, mSolid, divType );
482 break; 455 break;
483 default: 456 default:
484 ErrorInAxis( axis, mSolid ); 457 ErrorInAxis( axis, mSolid );
485 break; 458 break;
486 } 459 }
487 } 460 }
488 else if( mSolidType == "G4Polyhedra" ) 461 else if( mSolidType == "G4Polyhedra" )
489 { 462 {
490 switch( axis ) 463 switch( axis )
491 { 464 {
492 case kRho: 465 case kRho:
493 fparam = new G4ParameterisationPolyhed 466 fparam = new G4ParameterisationPolyhedraRho( axis, nDivs, width,
494 467 offset, mSolid, divType );
495 break; 468 break;
496 case kPhi: 469 case kPhi:
497 fparam = new G4ParameterisationPolyhed 470 fparam = new G4ParameterisationPolyhedraPhi( axis, nDivs, width,
498 471 offset, mSolid, divType );
499 break; 472 break;
500 case kZAxis: 473 case kZAxis:
501 fparam = new G4ParameterisationPolyhed 474 fparam = new G4ParameterisationPolyhedraZ( axis, nDivs, width,
502 475 offset, mSolid, divType );
503 break; 476 break;
504 default: 477 default:
505 ErrorInAxis( axis, mSolid ); 478 ErrorInAxis( axis, mSolid );
506 break; 479 break;
507 } 480 }
508 } 481 }
509 else 482 else
510 { 483 {
511 std::ostringstream message; 484 std::ostringstream message;
512 message << "Solid type " << mSolidType << 485 message << "Solid type " << mSolidType << " not supported!" << G4endl
513 << "Divisions for " << mSolidType 486 << "Divisions for " << mSolidType << " are not implemented.";
514 G4Exception("G4PVDivision::SetParameterisa 487 G4Exception("G4PVDivision::SetParameterisation()", "GeomDiv0001",
515 FatalException, message); 488 FatalException, message);
516 } 489 }
517 } 490 }
518 491
519 //-------------------------------------------- 492 //--------------------------------------------------------------------------
520 void G4PVDivision::ErrorInAxis( EAxis axis, G4 493 void G4PVDivision::ErrorInAxis( EAxis axis, G4VSolid* solid )
521 { 494 {
522 G4String error = "Trying to divide solid " + 495 G4String error = "Trying to divide solid " + solid->GetName()
523 + " of type " + solid->GetEnt 496 + " of type " + solid->GetEntityType() + " along axis ";
524 switch( axis ) 497 switch( axis )
525 { 498 {
526 case kXAxis: 499 case kXAxis:
527 error += "X."; 500 error += "X.";
528 break; 501 break;
529 case kYAxis: 502 case kYAxis:
530 error += "Y."; 503 error += "Y.";
531 break; 504 break;
532 case kZAxis: 505 case kZAxis:
533 error += "Z."; 506 error += "Z.";
534 break; 507 break;
535 case kRho: 508 case kRho:
536 error += "Rho."; 509 error += "Rho.";
537 break; 510 break;
538 case kRadial3D: 511 case kRadial3D:
539 error += "Radial3D."; 512 error += "Radial3D.";
540 break; 513 break;
541 case kPhi: 514 case kPhi:
542 error += "Phi."; 515 error += "Phi.";
543 break; 516 break;
544 default: 517 default:
545 break; 518 break;
546 } 519 }
547 G4Exception("G4PVDivision::ErrorInAxis()", " 520 G4Exception("G4PVDivision::ErrorInAxis()", "GeomDiv0002",
548 FatalException, error); 521 FatalException, error);
549 } 522 }
550 << 523 // The next methods are for specialised repeated volumes
551 // The next methods are for specialised repeat << 524 // (replicas, parameterised vol.) which are completely regular.
552 // parameterised vol.) which are completely re <<
553 // Currently this is not applicable to divisio 525 // Currently this is not applicable to divisions ( J.A. Nov 2005 )
554 <<
555 // ------------------------------------------- 526 // ----------------------------------------------------------------------
556 // IsRegularStructure() << 527 // IsRegularRepeatedStructure()
557 // 528 //
558 G4bool G4PVDivision::IsRegularStructure() cons 529 G4bool G4PVDivision::IsRegularStructure() const
559 { 530 {
560 return false; 531 return false;
561 } 532 }
562 533
563 // ------------------------------------------- 534 // ----------------------------------------------------------------------
564 // GetRegularStructureId() << 535 // IsRegularRepeatedStructure()
565 // 536 //
566 G4int G4PVDivision::GetRegularStructureId() co 537 G4int G4PVDivision::GetRegularStructureId() const
567 { 538 {
568 return 0; 539 return 0;
569 } 540 }
>> 541 // This is for specialised repeated volumes (replicas, parameterised vol.)
570 542