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