[1035] | 1 | // |
---|
| 2 | // ******************************************************************** |
---|
| 3 | // * License and Disclaimer * |
---|
| 4 | // * * |
---|
| 5 | // * The Geant4 software is copyright of the Copyright Holders of * |
---|
| 6 | // * the Geant4 Collaboration. It is provided under the terms and * |
---|
| 7 | // * conditions of the Geant4 Software License, included in the file * |
---|
| 8 | // * LICENSE and available at http://cern.ch/geant4/license . These * |
---|
| 9 | // * include a list of copyright holders. * |
---|
| 10 | // * * |
---|
| 11 | // * Neither the authors of this software system, nor their employing * |
---|
| 12 | // * institutes,nor the agencies providing financial support for this * |
---|
| 13 | // * work make any representation or warranty, express or implied, * |
---|
| 14 | // * regarding this software system or assume any liability for its * |
---|
| 15 | // * use. Please see the license in the file LICENSE and URL above * |
---|
| 16 | // * for the full disclaimer and the limitation of liability. * |
---|
| 17 | // * * |
---|
| 18 | // * This code implementation is the result of the scientific and * |
---|
| 19 | // * technical work of the GEANT4 collaboration. * |
---|
| 20 | // * By using, copying, modifying or distributing the software (or * |
---|
| 21 | // * any work based on the software) you agree to acknowledge its * |
---|
| 22 | // * use in resulting scientific publications, and indicate your * |
---|
| 23 | // * acceptance of all terms of the Geant4 Software license. * |
---|
| 24 | // ******************************************************************** |
---|
| 25 | // |
---|
| 26 | // |
---|
| 27 | // |
---|
| 28 | // class G4tgbVolume |
---|
| 29 | |
---|
| 30 | // History: |
---|
| 31 | // - Created. P.Arce, CIEMAT (November 2007) |
---|
| 32 | // ------------------------------------------------------------------------- |
---|
| 33 | |
---|
| 34 | #include "G4tgbVolume.hh" |
---|
| 35 | #include "G4tgbVolumeMgr.hh" |
---|
| 36 | #include "G4tgbMaterialMgr.hh" |
---|
| 37 | #include "G4tgbRotationMatrixMgr.hh" |
---|
| 38 | #include "G4tgbPlaceParamLinear.hh" |
---|
| 39 | #include "G4tgbPlaceParamSquare.hh" |
---|
| 40 | #include "G4tgbPlaceParamCircle.hh" |
---|
| 41 | |
---|
| 42 | #include "G4tgrSolid.hh" |
---|
| 43 | #include "G4tgrSolidBoolean.hh" |
---|
| 44 | #include "G4tgrVolume.hh" |
---|
| 45 | #include "G4tgrVolumeDivision.hh" |
---|
| 46 | #include "G4tgrVolumeAssembly.hh" |
---|
| 47 | #include "G4tgrVolumeMgr.hh" |
---|
| 48 | #include "G4tgrPlace.hh" |
---|
| 49 | #include "G4tgrPlaceSimple.hh" |
---|
| 50 | #include "G4tgrPlaceDivRep.hh" |
---|
| 51 | #include "G4tgrPlaceParameterisation.hh" |
---|
| 52 | #include "G4tgrUtils.hh" |
---|
| 53 | |
---|
| 54 | #include "G4VSolid.hh" |
---|
| 55 | #include "G4UnionSolid.hh" |
---|
| 56 | #include "G4SubtractionSolid.hh" |
---|
| 57 | #include "G4IntersectionSolid.hh" |
---|
| 58 | #include "G4LogicalVolume.hh" |
---|
| 59 | #include "G4VPhysicalVolume.hh" |
---|
| 60 | #include "G4PVPlacement.hh" |
---|
| 61 | #include "G4PVDivision.hh" |
---|
| 62 | #include "G4PVReplica.hh" |
---|
| 63 | #include "G4PVParameterised.hh" |
---|
| 64 | #include "G4Box.hh" |
---|
| 65 | #include "G4Tubs.hh" |
---|
| 66 | #include "G4Cons.hh" |
---|
| 67 | #include "G4Trap.hh" |
---|
| 68 | #include "G4Sphere.hh" |
---|
| 69 | #include "G4Orb.hh" |
---|
| 70 | #include "G4Trd.hh" |
---|
| 71 | #include "G4Para.hh" |
---|
| 72 | #include "G4Torus.hh" |
---|
| 73 | #include "G4Hype.hh" |
---|
| 74 | #include "G4Polycone.hh" |
---|
| 75 | #include "G4Polyhedra.hh" |
---|
| 76 | #include "G4EllipticalTube.hh" |
---|
| 77 | #include "G4Ellipsoid.hh" |
---|
| 78 | #include "G4EllipticalCone.hh" |
---|
| 79 | #include "G4Hype.hh" |
---|
| 80 | #include "G4Tet.hh" |
---|
| 81 | #include "G4TwistedBox.hh" |
---|
| 82 | #include "G4TwistedTrap.hh" |
---|
| 83 | #include "G4TwistedTrd.hh" |
---|
| 84 | #include "G4TwistedTubs.hh" |
---|
| 85 | #include "G4AssemblyVolume.hh" |
---|
| 86 | #include "G4BREPSolidBox.hh" |
---|
| 87 | #include "G4BREPSolidCylinder.hh" |
---|
| 88 | #include "G4BREPSolidCone.hh" |
---|
| 89 | #include "G4BREPSolidSphere.hh" |
---|
| 90 | #include "G4BREPSolidTorus.hh" |
---|
| 91 | #include "G4BREPSolidPCone.hh" |
---|
| 92 | #include "G4BREPSolidPolyhedra.hh" |
---|
| 93 | #include "G4BREPSolidOpenPCone.hh" |
---|
| 94 | #include "G4VisExtent.hh" |
---|
| 95 | |
---|
| 96 | #include "G4Material.hh" |
---|
| 97 | #include "G4RotationMatrix.hh" |
---|
| 98 | #include "G4ReflectionFactory.hh" |
---|
| 99 | |
---|
| 100 | #include "G4VisAttributes.hh" |
---|
| 101 | #include "G4RegionStore.hh" |
---|
| 102 | #include "G4tgrMessenger.hh" |
---|
| 103 | #include "G4UIcommand.hh" |
---|
| 104 | #include "G4GeometryTolerance.hh" |
---|
| 105 | |
---|
| 106 | //------------------------------------------------------------------- |
---|
| 107 | G4tgbVolume::G4tgbVolume() |
---|
| 108 | { |
---|
| 109 | } |
---|
| 110 | |
---|
| 111 | |
---|
| 112 | //------------------------------------------------------------------- |
---|
| 113 | G4tgbVolume::~G4tgbVolume() |
---|
| 114 | { |
---|
| 115 | } |
---|
| 116 | |
---|
| 117 | |
---|
| 118 | //------------------------------------------------------------------- |
---|
| 119 | G4tgbVolume::G4tgbVolume( G4tgrVolume* vol) |
---|
| 120 | { |
---|
| 121 | theTgrVolume = vol; |
---|
| 122 | theG4AssemblyVolume = 0; |
---|
| 123 | } |
---|
| 124 | |
---|
| 125 | |
---|
| 126 | //------------------------------------------------------------------- |
---|
| 127 | void G4tgbVolume::ConstructG4Volumes( const G4tgrPlace* place, |
---|
| 128 | const G4LogicalVolume* parentLV ) |
---|
| 129 | { |
---|
| 130 | #ifdef G4VERBOSE |
---|
| 131 | if( G4tgrMessenger::GetVerboseLevel() >= 2 ) |
---|
| 132 | { |
---|
| 133 | G4cout << G4endl << "@@@ G4tgbVolume::ConstructG4Volumes - " << GetName() << G4endl; |
---|
| 134 | if( place && parentLV ) G4cout << " place in LV " << parentLV->GetName() << G4endl; |
---|
| 135 | } |
---|
| 136 | #endif |
---|
| 137 | G4tgbVolumeMgr* g4vmgr = G4tgbVolumeMgr::GetInstance(); |
---|
| 138 | G4LogicalVolume* logvol = g4vmgr->FindG4LogVol( GetName() ); |
---|
| 139 | G4bool bFirstCopy = false; |
---|
| 140 | if( (logvol == 0) ) |
---|
| 141 | { |
---|
| 142 | bFirstCopy = true; |
---|
| 143 | if( theTgrVolume->GetType() != "VOLDivision" ) |
---|
| 144 | { |
---|
| 145 | //--- If first time build solid and LogVol |
---|
| 146 | G4VSolid* solid = FindOrConstructG4Solid( theTgrVolume->GetSolid() ); |
---|
| 147 | if( solid != 0 ) // for G4AssemblyVolume it is 0 |
---|
| 148 | { |
---|
| 149 | g4vmgr->RegisterMe( solid ); |
---|
| 150 | logvol = ConstructG4LogVol( solid ); |
---|
| 151 | g4vmgr->RegisterMe( logvol ); |
---|
| 152 | g4vmgr->RegisterChildParentLVs( logvol, parentLV ); |
---|
| 153 | |
---|
| 154 | } |
---|
| 155 | } |
---|
| 156 | } |
---|
| 157 | //--- Construct PhysVol |
---|
| 158 | G4VPhysicalVolume* physvol = ConstructG4PhysVol( place, logvol, parentLV ); |
---|
| 159 | if( physvol != 0 ) // 0 for G4AssemblyVolumes |
---|
| 160 | { |
---|
| 161 | g4vmgr->RegisterMe( physvol ); |
---|
| 162 | |
---|
| 163 | if( logvol == 0 ) // case of divisions |
---|
| 164 | { |
---|
| 165 | logvol = physvol->GetLogicalVolume(); |
---|
| 166 | } |
---|
| 167 | } |
---|
| 168 | else |
---|
| 169 | { |
---|
| 170 | return; |
---|
| 171 | } |
---|
| 172 | |
---|
| 173 | //--- If first copy build children placements in this LogVol |
---|
| 174 | if(bFirstCopy) |
---|
| 175 | { |
---|
| 176 | std::pair<G4mmapspl::iterator, G4mmapspl::iterator> children |
---|
| 177 | = G4tgrVolumeMgr::GetInstance()->GetChildren( GetName() ); |
---|
| 178 | G4mmapspl::iterator cite; |
---|
| 179 | for( cite = children.first; cite != children.second; cite++ ) |
---|
| 180 | { |
---|
| 181 | //----- Call G4tgrPlace ->constructG4Volumes |
---|
| 182 | //---- find G4tgbVolume corresponding to the G4tgrVolume |
---|
| 183 | // pointed by G4tgrPlace |
---|
| 184 | G4tgrPlace* pl = const_cast<G4tgrPlace*>((*cite).second); |
---|
| 185 | G4tgbVolume* svol = g4vmgr->FindVolume( pl->GetVolume()->GetName() ); |
---|
| 186 | //--- find copyNo |
---|
| 187 | #ifdef G4VERBOSE |
---|
| 188 | if( G4tgrMessenger::GetVerboseLevel() >= 2 ) |
---|
| 189 | { |
---|
| 190 | G4cout << " G4tgbVolume::ConstructG4Volumes - construct daughter " << pl->GetVolume()->GetName() << " # " << pl->GetCopyNo() << G4endl; |
---|
| 191 | } |
---|
| 192 | #endif |
---|
| 193 | svol->ConstructG4Volumes( pl, logvol ); |
---|
| 194 | } |
---|
| 195 | } |
---|
| 196 | |
---|
| 197 | } |
---|
| 198 | |
---|
| 199 | |
---|
| 200 | |
---|
| 201 | //------------------------------------------------------------------- |
---|
| 202 | G4VSolid* G4tgbVolume::FindOrConstructG4Solid( const G4tgrSolid* sol ) |
---|
| 203 | { |
---|
| 204 | G4double angularTolerance = G4GeometryTolerance::GetInstance() |
---|
| 205 | ->GetAngularTolerance(); |
---|
| 206 | |
---|
| 207 | if( sol == 0 ) { return 0; } |
---|
| 208 | |
---|
| 209 | #ifdef G4VERBOSE |
---|
| 210 | if( G4tgrMessenger::GetVerboseLevel() >= 2 ) |
---|
| 211 | { |
---|
| 212 | G4cout << " G4tgbVolume::FindOrConstructG4Solid():" << G4endl |
---|
| 213 | << " SOLID = " << sol << G4endl |
---|
| 214 | << " " << sol->GetName() << " of type " << sol->GetType() |
---|
| 215 | << G4endl; |
---|
| 216 | } |
---|
| 217 | #endif |
---|
| 218 | |
---|
| 219 | //----- Check if solid exists already |
---|
| 220 | G4VSolid* solid = G4tgbVolumeMgr::GetInstance() |
---|
| 221 | ->FindG4Solid( sol->GetName() ); |
---|
| 222 | if( solid ) { return solid; } |
---|
| 223 | |
---|
| 224 | // Give 'sol' as Boolean solids needs to call this method twice |
---|
| 225 | |
---|
| 226 | #ifdef G4VERBOSE |
---|
| 227 | if( G4tgrMessenger::GetVerboseLevel() >= 2 ) |
---|
| 228 | { |
---|
| 229 | G4cout << " G4tgbVolume::FindOrConstructG4Solid() - " |
---|
| 230 | << sol->GetSolidParams().size() << G4endl; |
---|
| 231 | } |
---|
| 232 | #endif |
---|
| 233 | |
---|
| 234 | std::vector<G4double> solParam; |
---|
| 235 | |
---|
| 236 | // In case of BOOLEAN solids, solidParams are taken from components |
---|
| 237 | |
---|
| 238 | if( sol->GetSolidParams().size() == 1) |
---|
| 239 | { |
---|
| 240 | solParam = * sol->GetSolidParams()[ 0 ]; |
---|
| 241 | } |
---|
| 242 | |
---|
| 243 | //----------- instantiate the appropiate G4VSolid type |
---|
| 244 | G4String stype = sol->GetType(); |
---|
| 245 | G4String sname = sol->GetName(); |
---|
| 246 | |
---|
| 247 | if( stype == "BOX" ) |
---|
| 248 | { |
---|
| 249 | CheckNoSolidParams( stype, 3, solParam.size() ); |
---|
| 250 | solid = new G4Box( sname, solParam[0], solParam[1], solParam[2] ); |
---|
| 251 | |
---|
| 252 | } |
---|
| 253 | else if( stype == "TUBE" ) |
---|
| 254 | { |
---|
| 255 | CheckNoSolidParams( stype, 3, solParam.size() ); |
---|
| 256 | solid = new G4Tubs( sname, solParam[0], solParam[1], solParam[2], |
---|
| 257 | 0.*deg, 360.*deg ); |
---|
| 258 | } |
---|
| 259 | else if( stype == "TUBS" ) |
---|
| 260 | { |
---|
| 261 | CheckNoSolidParams( stype, 5, solParam.size() ); |
---|
| 262 | G4double phiDelta = solParam[4]; |
---|
| 263 | if( std::fabs(phiDelta - twopi) < angularTolerance ) { phiDelta = twopi; } |
---|
| 264 | solid = new G4Tubs( sname, solParam[0], solParam[1], solParam[2], |
---|
| 265 | solParam[3], phiDelta ); |
---|
| 266 | } |
---|
| 267 | else if( stype == "TRAP" ) |
---|
| 268 | { |
---|
| 269 | if( solParam.size() == 11 ) |
---|
| 270 | { |
---|
| 271 | solid = new G4Trap( sname, solParam[0], solParam[1], solParam[2], |
---|
| 272 | solParam[3], solParam[4], solParam[5], solParam[6], |
---|
| 273 | solParam[7], solParam[8], solParam[9], solParam[10] ); |
---|
| 274 | } |
---|
| 275 | else if( solParam.size() == 4 ) |
---|
| 276 | { |
---|
| 277 | solid = new G4Trap( sname, solParam[0], solParam[1]/deg, |
---|
| 278 | solParam[2]/deg, solParam[3]); |
---|
| 279 | } |
---|
| 280 | else |
---|
| 281 | { |
---|
| 282 | G4String ErrMessage1 = "Solid type " + stype; |
---|
| 283 | G4String ErrMessage2 = " should have 11 or 4 parameters,\n"; |
---|
| 284 | G4String ErrMessage3 = "and it has " |
---|
| 285 | + G4UIcommand::ConvertToString(G4int(solParam.size())); |
---|
| 286 | G4String ErrMessage = ErrMessage1 + ErrMessage2 + ErrMessage3 + " !"; |
---|
| 287 | G4Exception("G4tgbVolume::FindOrConstructG4Solid()", |
---|
| 288 | "InvalidSetup", FatalException, ErrMessage); |
---|
| 289 | } |
---|
| 290 | |
---|
| 291 | } |
---|
| 292 | else if( stype == "TRD" ) |
---|
| 293 | { |
---|
| 294 | CheckNoSolidParams( stype, 5, solParam.size() ); |
---|
| 295 | solid = new G4Trd( sname, solParam[0], solParam[1], solParam[2], |
---|
| 296 | solParam[3], solParam[4] ); |
---|
| 297 | } |
---|
| 298 | else if( stype == "PARA" ) |
---|
| 299 | { |
---|
| 300 | CheckNoSolidParams( stype, 6, solParam.size() ); |
---|
| 301 | solid = new G4Para( sname, solParam[0], solParam[1], solParam[2], |
---|
| 302 | solParam[3], solParam[4], solParam[5] ); |
---|
| 303 | } |
---|
| 304 | else if( stype == "CONE" ) |
---|
| 305 | { |
---|
| 306 | CheckNoSolidParams( stype, 5, solParam.size() ); |
---|
| 307 | solid = new G4Cons( sname, solParam[0], solParam[1], solParam[2], |
---|
| 308 | solParam[3], solParam[4], 0., 360.*deg); |
---|
| 309 | } |
---|
| 310 | else if( stype == "CONS" ) |
---|
| 311 | { |
---|
| 312 | CheckNoSolidParams( stype, 7, solParam.size() ); |
---|
| 313 | G4double phiDelta = solParam[6]; |
---|
| 314 | if( std::fabs(phiDelta - twopi) < angularTolerance ) { phiDelta = twopi; } |
---|
| 315 | solid = new G4Cons( sname, solParam[0], solParam[1], solParam[2], |
---|
| 316 | solParam[3], solParam[4], solParam[5], phiDelta); |
---|
| 317 | } |
---|
| 318 | else if( stype == "SPHERE" ) |
---|
| 319 | { |
---|
| 320 | CheckNoSolidParams( stype, 6, solParam.size() ); |
---|
| 321 | G4double phiDelta = solParam[3]; |
---|
| 322 | if( std::fabs(phiDelta - twopi) < angularTolerance ) { phiDelta = twopi; } |
---|
| 323 | G4double thetaDelta = solParam[5]; |
---|
| 324 | if( std::fabs(thetaDelta - pi) < angularTolerance ) { thetaDelta = pi; } |
---|
| 325 | solid = new G4Sphere( sname, solParam[0], solParam[1], solParam[2], |
---|
| 326 | phiDelta, solParam[4], thetaDelta); |
---|
| 327 | } |
---|
| 328 | else if( stype == "ORB" ) |
---|
| 329 | { |
---|
| 330 | CheckNoSolidParams( stype, 1, solParam.size() ); |
---|
| 331 | solid = new G4Orb( sname, solParam[0] ); |
---|
| 332 | } |
---|
| 333 | else if( stype == "TORUS" ) |
---|
| 334 | { |
---|
| 335 | CheckNoSolidParams( stype, 5, solParam.size() ); |
---|
| 336 | G4double phiDelta = solParam[4]; |
---|
| 337 | if( std::fabs(phiDelta - twopi) < angularTolerance ) { phiDelta = twopi; } |
---|
| 338 | solid = new G4Torus( sname, solParam[0], solParam[1], solParam[2], |
---|
| 339 | solParam[3], phiDelta ); |
---|
| 340 | } |
---|
| 341 | else if( stype == "POLYCONE" ) |
---|
| 342 | { |
---|
| 343 | size_t nplanes = size_t(solParam[2]); |
---|
| 344 | G4bool genericPoly = false; |
---|
| 345 | if( solParam.size() == 3+nplanes*3 ) |
---|
| 346 | { |
---|
| 347 | genericPoly = true; |
---|
| 348 | } |
---|
| 349 | else if( solParam.size() == 3+nplanes*2 ) |
---|
| 350 | { |
---|
| 351 | genericPoly = false; |
---|
| 352 | } |
---|
| 353 | else |
---|
| 354 | { |
---|
| 355 | G4String Err1 = "Solid type " + stype + " should have "; |
---|
| 356 | G4String Err2 = G4UIcommand::ConvertToString(G4int(3+nplanes*3)) |
---|
| 357 | + " (Z,Rmin,Rmax)\n"; |
---|
| 358 | G4String Err3 = "or " + G4UIcommand::ConvertToString(G4int(3+nplanes*2)); |
---|
| 359 | G4String Err4 = " (RZ corners) parameters,\n"; |
---|
| 360 | G4String Err5 = "and it has " |
---|
| 361 | + G4UIcommand::ConvertToString(G4int(solParam.size())); |
---|
| 362 | G4String ErrMessage = Err1 + Err2 + Err3 + Err4 + Err5 + " !"; |
---|
| 363 | G4Exception("G4tgbVolume::FindOrConstructG4Solid()", |
---|
| 364 | "InvalidSetup", FatalException, ErrMessage); |
---|
| 365 | } |
---|
| 366 | |
---|
| 367 | if( genericPoly ) |
---|
| 368 | { |
---|
| 369 | std::vector<G4double>* z_p = new std::vector<G4double>; |
---|
| 370 | std::vector<G4double>* rmin_p = new std::vector<G4double>; |
---|
| 371 | std::vector<G4double>* rmax_p = new std::vector<G4double>; |
---|
| 372 | for( size_t ii = 0; ii < nplanes; ii++ ) |
---|
| 373 | { |
---|
| 374 | (*z_p).push_back( solParam[3+3*ii] ); |
---|
| 375 | (*rmin_p).push_back( solParam[3+3*ii+1] ); |
---|
| 376 | (*rmax_p).push_back( solParam[3+3*ii+2] ); |
---|
| 377 | } |
---|
| 378 | G4double phiTotal = solParam[1]; |
---|
| 379 | if( std::fabs(phiTotal - twopi) < angularTolerance ) { phiTotal = twopi; } |
---|
| 380 | solid = new G4Polycone( sname, solParam[0], phiTotal, // start,delta-phi |
---|
| 381 | nplanes, // sections |
---|
| 382 | &((*z_p)[0]), &((*rmin_p)[0]), &((*rmax_p)[0])); |
---|
| 383 | } |
---|
| 384 | else |
---|
| 385 | { |
---|
| 386 | std::vector<G4double>* R_c = new std::vector<G4double>; |
---|
| 387 | std::vector<G4double>* Z_c = new std::vector<G4double>; |
---|
| 388 | for( size_t ii = 0; ii < nplanes; ii++ ) |
---|
| 389 | { |
---|
| 390 | (*R_c).push_back( solParam[3+2*ii] ); |
---|
| 391 | (*Z_c).push_back( solParam[3+2*ii+1] ); |
---|
| 392 | } |
---|
| 393 | G4double phiTotal = solParam[1]; |
---|
| 394 | if( std::fabs(phiTotal - twopi) < angularTolerance ) { phiTotal = twopi; } |
---|
| 395 | solid = new G4Polycone( sname, solParam[0], phiTotal, // start,delta-phi |
---|
| 396 | nplanes, // sections |
---|
| 397 | &((*R_c)[0]), &((*Z_c)[0])); |
---|
| 398 | } |
---|
| 399 | |
---|
| 400 | } |
---|
| 401 | else if( stype == "POLYHEDRA" ) |
---|
| 402 | { |
---|
| 403 | size_t nplanes = size_t(solParam[3]); |
---|
| 404 | G4bool genericPoly = false; |
---|
| 405 | if( solParam.size() == 4+nplanes*3 ) |
---|
| 406 | { |
---|
| 407 | genericPoly = true; |
---|
| 408 | } |
---|
| 409 | else if( solParam.size() == 4+nplanes*2 ) |
---|
| 410 | { |
---|
| 411 | genericPoly = false; |
---|
| 412 | } |
---|
| 413 | else |
---|
| 414 | { |
---|
| 415 | G4String Err1 = "Solid type " + stype + " should have "; |
---|
| 416 | G4String Err2 = G4UIcommand::ConvertToString(G4int(4+nplanes*3)) |
---|
| 417 | + " (Z,Rmin,Rmax)\n"; |
---|
| 418 | G4String Err3 = "or " + G4UIcommand::ConvertToString(G4int(4+nplanes*2)); |
---|
| 419 | G4String Err4 = " (RZ corners) parameters,\n"; |
---|
| 420 | G4String Err5 = "and it has " |
---|
| 421 | + G4UIcommand::ConvertToString(G4int(solParam.size())); |
---|
| 422 | G4String ErrMessage = Err1 + Err2 + Err3 + Err4 + Err5 + " !"; |
---|
| 423 | G4Exception("G4tgbVolume::FindOrConstructG4Solid()", |
---|
| 424 | "InvalidSetup", FatalException, ErrMessage); |
---|
| 425 | } |
---|
| 426 | |
---|
| 427 | if( genericPoly ) |
---|
| 428 | { |
---|
| 429 | std::vector<G4double>* z_p = new std::vector<G4double>; |
---|
| 430 | std::vector<G4double>* rmin_p = new std::vector<G4double>; |
---|
| 431 | std::vector<G4double>* rmax_p = new std::vector<G4double>; |
---|
| 432 | for( size_t ii = 0; ii < nplanes; ii++ ) |
---|
| 433 | { |
---|
| 434 | (*z_p).push_back( solParam[4+3*ii] ); |
---|
| 435 | (*rmin_p).push_back( solParam[4+3*ii+1] ); |
---|
| 436 | (*rmax_p).push_back( solParam[4+3*ii+2] ); |
---|
| 437 | } |
---|
| 438 | G4double phiTotal = solParam[1]; |
---|
| 439 | if( std::fabs(phiTotal - twopi) < angularTolerance ) { phiTotal = twopi; } |
---|
| 440 | solid = new G4Polyhedra( sname, solParam[0], phiTotal, |
---|
| 441 | G4int(solParam[2]), nplanes, |
---|
| 442 | &((*z_p)[0]), &((*rmin_p)[0]), &((*rmax_p)[0])); |
---|
| 443 | } |
---|
| 444 | else |
---|
| 445 | { |
---|
| 446 | std::vector<G4double>* R_c = new std::vector<G4double>; |
---|
| 447 | std::vector<G4double>* Z_c = new std::vector<G4double>; |
---|
| 448 | for( size_t ii = 0; ii < nplanes; ii++ ) |
---|
| 449 | { |
---|
| 450 | (*R_c).push_back( solParam[4+2*ii] ); |
---|
| 451 | (*Z_c).push_back( solParam[4+2*ii+1] ); |
---|
| 452 | } |
---|
| 453 | G4double phiTotal = solParam[1]; |
---|
| 454 | if( std::fabs(phiTotal - twopi) < angularTolerance ) { phiTotal = twopi; } |
---|
| 455 | solid = new G4Polyhedra( sname, solParam[0], phiTotal, |
---|
| 456 | G4int(solParam[2]), nplanes, |
---|
| 457 | &((*R_c)[0]), &((*Z_c)[0])); |
---|
| 458 | } |
---|
| 459 | } |
---|
| 460 | else if( stype == "ELLIPTICALTUBE" ) |
---|
| 461 | { |
---|
| 462 | CheckNoSolidParams( stype, 3, solParam.size() ); |
---|
| 463 | solid = new G4EllipticalTube( sname, solParam[0], solParam[1], solParam[2]); |
---|
| 464 | } |
---|
| 465 | else if( stype == "ELLIPSOID" ) |
---|
| 466 | { |
---|
| 467 | CheckNoSolidParams( stype, 5, solParam.size() ); |
---|
| 468 | solid = new G4Ellipsoid( sname, solParam[0], solParam[1], solParam[2], |
---|
| 469 | solParam[3], solParam[4] ); |
---|
| 470 | } |
---|
| 471 | else if( stype == "ELLIPTICALCONE" ) |
---|
| 472 | { |
---|
| 473 | CheckNoSolidParams( stype, 4, solParam.size() ); |
---|
| 474 | solid = new G4EllipticalCone( sname, solParam[0], solParam[1], |
---|
| 475 | solParam[2], solParam[3] ); |
---|
| 476 | } |
---|
| 477 | else if( stype == "HYPE" ) |
---|
| 478 | { |
---|
| 479 | CheckNoSolidParams( stype, 5, solParam.size() ); |
---|
| 480 | solid = new G4Hype( sname, solParam[0], solParam[1], solParam[2], |
---|
| 481 | solParam[3], solParam[4] ); |
---|
| 482 | } |
---|
| 483 | else if( stype == "TET" ) |
---|
| 484 | { |
---|
| 485 | CheckNoSolidParams( stype, 12, solParam.size() ); |
---|
| 486 | G4ThreeVector anchor(solParam[0], solParam[1], solParam[2]); |
---|
| 487 | G4ThreeVector p2(solParam[3], solParam[4], solParam[5]); |
---|
| 488 | G4ThreeVector p3(solParam[6], solParam[7], solParam[8]); |
---|
| 489 | G4ThreeVector p4(solParam[9], solParam[10], solParam[11]); |
---|
| 490 | solid = new G4Tet( sname, anchor, p2, p3, p4 ); |
---|
| 491 | } |
---|
| 492 | else if( stype == "TWISTEDBOX" ) |
---|
| 493 | { |
---|
| 494 | CheckNoSolidParams( stype, 4, solParam.size() ); |
---|
| 495 | solid = new G4TwistedBox( sname, solParam[0], solParam[1], |
---|
| 496 | solParam[2], solParam[3]); |
---|
| 497 | } |
---|
| 498 | else if( stype == "TWISTEDTRAP" ) |
---|
| 499 | { |
---|
| 500 | CheckNoSolidParams( stype, 11, solParam.size() ); |
---|
| 501 | solid = new G4TwistedTrap( sname, solParam[0], solParam[1], solParam[2], |
---|
| 502 | solParam[3], solParam[4], solParam[5], solParam[6], |
---|
| 503 | solParam[7], solParam[8], solParam[9], solParam[10] ); |
---|
| 504 | } |
---|
| 505 | else if( stype == "TWISTEDTRD" ) |
---|
| 506 | { |
---|
| 507 | CheckNoSolidParams( stype, 6, solParam.size() ); |
---|
| 508 | solid = new G4TwistedTrd( sname, solParam[0], solParam[1], solParam[2], |
---|
| 509 | solParam[3], solParam[4], solParam[5]); |
---|
| 510 | } |
---|
| 511 | else if( stype == "TWISTEDTUBS" ) |
---|
| 512 | { |
---|
| 513 | CheckNoSolidParams( stype, 5, solParam.size() ); |
---|
| 514 | G4double phiTotal = solParam[4]; |
---|
| 515 | if( std::fabs(phiTotal - twopi) < angularTolerance ) { phiTotal = twopi; } |
---|
| 516 | solid = new G4TwistedTubs( sname, solParam[0], solParam[1], solParam[2], |
---|
| 517 | solParam[3], phiTotal); |
---|
| 518 | } |
---|
| 519 | else if( stype == "BREPBOX" ) // EntityType is = "Closed_Shell" |
---|
| 520 | { |
---|
| 521 | CheckNoSolidParams( stype, 24, solParam.size() ); |
---|
| 522 | std::vector<G4Point3D> points; |
---|
| 523 | for( size_t ii = 0; ii < 8; ii++ ) |
---|
| 524 | { |
---|
| 525 | points.push_back( G4Point3D(solParam[ii*3+0], |
---|
| 526 | solParam[ii*3+1], |
---|
| 527 | solParam[ii*3+2]) ); |
---|
| 528 | } |
---|
| 529 | solid = new G4BREPSolidBox( sname, points[0], points[1], points[2], |
---|
| 530 | points[3], points[4], points[5], points[6], |
---|
| 531 | points[7] ); |
---|
| 532 | } |
---|
| 533 | else if( stype == "BREPCYLINDER" ) // EntityType is = "Closed_Shell" |
---|
| 534 | { |
---|
| 535 | CheckNoSolidParams( stype, 11, solParam.size() ); |
---|
| 536 | solid = new G4BREPSolidCylinder( sname, |
---|
| 537 | G4ThreeVector( solParam[0], solParam[1], solParam[2] ), |
---|
| 538 | G4ThreeVector( solParam[3], solParam[4], solParam[5] ), |
---|
| 539 | G4ThreeVector( solParam[6], solParam[7], solParam[8] ), |
---|
| 540 | solParam[9], solParam[10] ); |
---|
| 541 | } |
---|
| 542 | else if( stype == "BREPCONE" ) // EntityType is = "Closed_Shell" |
---|
| 543 | { |
---|
| 544 | CheckNoSolidParams( stype, 12, solParam.size() ); |
---|
| 545 | solid = new G4BREPSolidCone( sname, |
---|
| 546 | G4ThreeVector( solParam[0], solParam[1], solParam[2] ), |
---|
| 547 | G4ThreeVector( solParam[3], solParam[4], solParam[5] ), |
---|
| 548 | G4ThreeVector( solParam[6], solParam[7], solParam[8] ), |
---|
| 549 | solParam[9], solParam[10], solParam[11] ); |
---|
| 550 | } |
---|
| 551 | else if( stype == "BREPSPHERE" ) // EntityType is = "Closed_Shell" |
---|
| 552 | { |
---|
| 553 | CheckNoSolidParams( stype, 10, solParam.size() ); |
---|
| 554 | solid = new G4BREPSolidSphere( sname, |
---|
| 555 | G4ThreeVector( solParam[0], solParam[1], solParam[2] ), |
---|
| 556 | G4ThreeVector( solParam[3], solParam[4], solParam[5] ), |
---|
| 557 | G4ThreeVector( solParam[6], solParam[7], solParam[8] ), |
---|
| 558 | solParam[9] ); |
---|
| 559 | |
---|
| 560 | } |
---|
| 561 | else if( stype == "BREPTORUS" ) // EntityType is = "Closed_Shell" |
---|
| 562 | { |
---|
| 563 | CheckNoSolidParams( stype, 11, solParam.size() ); |
---|
| 564 | solid = new G4BREPSolidTorus( sname, |
---|
| 565 | G4ThreeVector( solParam[0], solParam[1], solParam[2] ), |
---|
| 566 | G4ThreeVector( solParam[3], solParam[4], solParam[5] ), |
---|
| 567 | G4ThreeVector( solParam[6], solParam[7], solParam[8] ), |
---|
| 568 | solParam[9], solParam[10] ); |
---|
| 569 | } |
---|
| 570 | else if( stype == "BREPPCONE" ) // EntityType is = "Closed_Shell" |
---|
| 571 | { |
---|
| 572 | size_t nplanes = size_t(solParam[2]); |
---|
| 573 | CheckNoSolidParams( stype, 4+3*nplanes, solParam.size() ); |
---|
| 574 | std::vector<G4double>* z_p = new std::vector<G4double>; |
---|
| 575 | std::vector<G4double>* rmin_p = new std::vector<G4double>; |
---|
| 576 | std::vector<G4double>* rmax_p = new std::vector<G4double>; |
---|
| 577 | for( size_t ii = 0; ii < nplanes; ii++ ) |
---|
| 578 | { |
---|
| 579 | (*z_p).push_back( solParam[4+3*ii] ); |
---|
| 580 | (*rmin_p).push_back( solParam[4+3*ii+1] ); |
---|
| 581 | (*rmax_p).push_back( solParam[4+3*ii+2] ); |
---|
| 582 | } |
---|
| 583 | G4double phiTotal = solParam[1]; |
---|
| 584 | if( std::fabs(phiTotal - twopi) < angularTolerance ) { phiTotal = twopi; } |
---|
| 585 | CheckNoSolidParams( stype, 12, solParam.size() ); |
---|
| 586 | solid = new G4BREPSolidPCone( sname, solParam[0], phiTotal, // start,dph |
---|
| 587 | nplanes, // sections |
---|
| 588 | solParam[3], // z_start |
---|
| 589 | &((*z_p)[0]), &((*rmin_p)[0]), |
---|
| 590 | &((*rmax_p)[0])); |
---|
| 591 | } |
---|
| 592 | else if( stype == "BREPPOLYHEDRA" ) // EntityType is = "Closed_Shell" |
---|
| 593 | { |
---|
| 594 | size_t nplanes = size_t(solParam[3]); |
---|
| 595 | CheckNoSolidParams( stype, 5+3*nplanes, solParam.size() ); |
---|
| 596 | std::vector<G4double>* z_p = new std::vector<G4double>; |
---|
| 597 | std::vector<G4double>* rmin_p = new std::vector<G4double>; |
---|
| 598 | std::vector<G4double>* rmax_p = new std::vector<G4double>; |
---|
| 599 | for( size_t ii = 0; ii < nplanes; ii++ ) |
---|
| 600 | { |
---|
| 601 | (*z_p).push_back( solParam[5+3*ii] ); |
---|
| 602 | (*rmin_p).push_back( solParam[5+3*ii+1] ); |
---|
| 603 | (*rmax_p).push_back( solParam[5+3*ii+2] ); |
---|
| 604 | } |
---|
| 605 | G4double phiTotal = solParam[1]; |
---|
| 606 | if( std::fabs(phiTotal - twopi) < angularTolerance ) { phiTotal = twopi; } |
---|
| 607 | CheckNoSolidParams( stype, 12, solParam.size() ); |
---|
| 608 | solid = new G4BREPSolidPolyhedra( sname, solParam[0], phiTotal, // start,dph |
---|
| 609 | G4int(solParam[2]), // sides |
---|
| 610 | nplanes, // sections |
---|
| 611 | solParam[4], // z_start |
---|
| 612 | &((*z_p)[0]), &((*rmin_p)[0]), |
---|
| 613 | &((*rmax_p)[0])); |
---|
| 614 | } |
---|
| 615 | else if( stype == "BREPOPENPCONE" ) // EntityType is = "Closed_Shell" |
---|
| 616 | { |
---|
| 617 | size_t nplanes = size_t(solParam[2]); |
---|
| 618 | std::vector<G4double>* z_p = new std::vector<G4double>; |
---|
| 619 | std::vector<G4double>* rmin_p = new std::vector<G4double>; |
---|
| 620 | std::vector<G4double>* rmax_p = new std::vector<G4double>; |
---|
| 621 | for( size_t ii = 0; ii < nplanes; ii++ ) |
---|
| 622 | { |
---|
| 623 | (*z_p).push_back( solParam[4+3*ii] ); |
---|
| 624 | (*rmin_p).push_back( solParam[4+3*ii+1] ); |
---|
| 625 | (*rmax_p).push_back( solParam[4+3*ii+2] ); |
---|
| 626 | } |
---|
| 627 | G4double phiTotal = solParam[1]; |
---|
| 628 | if( std::fabs(phiTotal - twopi) < angularTolerance ) { phiTotal = twopi; } |
---|
| 629 | CheckNoSolidParams( stype, 12, solParam.size() ); |
---|
| 630 | solid = new G4BREPSolidOpenPCone( sname, solParam[0], phiTotal, // start,dph |
---|
| 631 | nplanes, // sections |
---|
| 632 | solParam[3], // z_start |
---|
| 633 | &((*z_p)[0]), &((*rmin_p)[0]), |
---|
| 634 | &((*rmax_p)[0])); |
---|
| 635 | } |
---|
| 636 | else if( stype.substr(0,7) == "Boolean" ) |
---|
| 637 | { |
---|
| 638 | const G4tgrSolidBoolean* solb = dynamic_cast<const G4tgrSolidBoolean*>(sol); |
---|
| 639 | G4VSolid* sol1 = FindOrConstructG4Solid( solb->GetSolid(0)); |
---|
| 640 | G4VSolid* sol2 = FindOrConstructG4Solid( solb->GetSolid(1)); |
---|
| 641 | G4RotationMatrix* relRotMat = G4tgbRotationMatrixMgr::GetInstance() |
---|
| 642 | ->FindOrBuildG4RotMatrix( sol->GetRelativeRotMatName() ); |
---|
| 643 | G4ThreeVector relPlace = solb->GetRelativePlace(); |
---|
| 644 | |
---|
| 645 | if( stype == "Boolean_UNION" ) |
---|
| 646 | { |
---|
| 647 | solid = new G4UnionSolid( sname, sol1, sol2, relRotMat, relPlace ); |
---|
| 648 | } |
---|
| 649 | else if( stype == "Boolean_SUBTRACTION" ) |
---|
| 650 | { |
---|
| 651 | solid = new G4SubtractionSolid( sname, sol1, sol2, relRotMat, relPlace ); |
---|
| 652 | } |
---|
| 653 | else if( stype == "Boolean_INTERSECTION" ) |
---|
| 654 | { |
---|
| 655 | solid = new G4IntersectionSolid( sname, sol1, sol2, relRotMat, relPlace ); |
---|
| 656 | } |
---|
| 657 | else |
---|
| 658 | { |
---|
| 659 | G4String ErrMessage = "Unknown Boolean type " + stype; |
---|
| 660 | G4Exception("G4tgbVolume::FindOrConstructG4Solid()", |
---|
| 661 | "InvalidSetup", FatalException, ErrMessage); |
---|
| 662 | } |
---|
| 663 | } |
---|
| 664 | else |
---|
| 665 | { |
---|
| 666 | G4String ErrMessage = "Solids of type " + stype |
---|
| 667 | + " not implemented yet, sorry..."; |
---|
| 668 | G4Exception("G4tgbVolume::FindOrConstructG4Solid()", "NotImplemented", |
---|
| 669 | FatalException, ErrMessage); |
---|
| 670 | } |
---|
| 671 | |
---|
| 672 | #ifdef G4VERBOSE |
---|
| 673 | if( G4tgrMessenger::GetVerboseLevel() >= 2 ) |
---|
| 674 | { |
---|
| 675 | G4cout << " G4tgbVolume::FindOrConstructG4Solid()" << G4endl |
---|
| 676 | << " Created solid " << sname |
---|
| 677 | << " of type " << solid->GetEntityType() << G4endl; |
---|
| 678 | } |
---|
| 679 | #endif |
---|
| 680 | |
---|
| 681 | #ifdef G4VERBOSE |
---|
| 682 | if( G4tgrMessenger::GetVerboseLevel() >= 1 ) |
---|
| 683 | { |
---|
| 684 | G4cout << " Constructing new G4Solid: " |
---|
| 685 | << *solid << G4endl; |
---|
| 686 | } |
---|
| 687 | #endif |
---|
| 688 | |
---|
| 689 | return solid; |
---|
| 690 | } |
---|
| 691 | |
---|
| 692 | //------------------------------------------------------------------- |
---|
| 693 | void G4tgbVolume::CheckNoSolidParams( const G4String& solidType, |
---|
| 694 | const unsigned int NoParamExpected, |
---|
| 695 | const unsigned int NoParam ) |
---|
| 696 | { |
---|
| 697 | if( NoParamExpected != NoParam ) |
---|
| 698 | { |
---|
| 699 | G4String Err1 = "Solid type " + solidType + " should have "; |
---|
| 700 | G4String Err2 = G4UIcommand::ConvertToString(G4int(NoParamExpected)) |
---|
| 701 | + " parameters,\n"; |
---|
| 702 | G4String Err3 = "and it has " |
---|
| 703 | + G4UIcommand::ConvertToString(G4int(NoParam)); |
---|
| 704 | G4String ErrMessage = Err1 + Err2 + Err3 + " !"; |
---|
| 705 | G4Exception("G4tgbVolume::CheckNoSolidParams()", "InvalidSetup", |
---|
| 706 | FatalException, ErrMessage); |
---|
| 707 | } |
---|
| 708 | } |
---|
| 709 | |
---|
| 710 | |
---|
| 711 | //------------------------------------------------------------------- |
---|
| 712 | G4LogicalVolume* G4tgbVolume::ConstructG4LogVol( const G4VSolid* solid ) |
---|
| 713 | { |
---|
| 714 | G4LogicalVolume* logvol; |
---|
| 715 | |
---|
| 716 | #ifdef G4VERBOSE |
---|
| 717 | if( G4tgrMessenger::GetVerboseLevel() >= 2 ) |
---|
| 718 | { |
---|
| 719 | G4cout << " G4tgbVolume::ConstructG4LogVol() - " << GetName() << G4endl; |
---|
| 720 | } |
---|
| 721 | #endif |
---|
| 722 | |
---|
| 723 | //----------- Get the material first |
---|
| 724 | G4Material* mate = G4tgbMaterialMgr::GetInstance() |
---|
| 725 | ->FindOrBuildG4Material( theTgrVolume->GetMaterialName() ); |
---|
| 726 | if( mate == 0 ) |
---|
| 727 | { |
---|
| 728 | G4String ErrMessage = "Material not found " |
---|
| 729 | + theTgrVolume->GetMaterialName() |
---|
| 730 | + " for volume " + GetName() + "."; |
---|
| 731 | G4Exception("G4tgbVolume::ConstructG4LogVol()", "InvalidSetup", |
---|
| 732 | FatalException, ErrMessage); |
---|
| 733 | } |
---|
| 734 | #ifdef G4VERBOSE |
---|
| 735 | if( G4tgrMessenger::GetVerboseLevel() >= 2 ) |
---|
| 736 | { |
---|
| 737 | G4cout << " G4tgbVolume::ConstructG4LogVol() -" |
---|
| 738 | << " Material constructed: " << mate->GetName() << G4endl; |
---|
| 739 | } |
---|
| 740 | #endif |
---|
| 741 | |
---|
| 742 | //---------- Construct the LV |
---|
| 743 | logvol = new G4LogicalVolume( const_cast<G4VSolid*>(solid), |
---|
| 744 | const_cast<G4Material*>(mate), GetName() ); |
---|
| 745 | |
---|
| 746 | #ifdef G4VERBOSE |
---|
| 747 | if( G4tgrMessenger::GetVerboseLevel() >= 1 ) |
---|
| 748 | { |
---|
| 749 | G4cout << " Constructing new G4LogicalVolume: " |
---|
| 750 | << logvol->GetName() << " mate " << mate->GetName() << G4endl; |
---|
| 751 | } |
---|
| 752 | #endif |
---|
| 753 | |
---|
| 754 | //---------- Set visibility and colour |
---|
| 755 | if( !GetVisibility() || GetColour()[0] != -1 ) |
---|
| 756 | { |
---|
| 757 | G4VisAttributes* visAtt = new G4VisAttributes(); |
---|
| 758 | #ifdef G4VERBOSE |
---|
| 759 | if( G4tgrMessenger::GetVerboseLevel() >= 1 ) |
---|
| 760 | { |
---|
| 761 | G4cout << " Constructing new G4VisAttributes: " |
---|
| 762 | << *visAtt << G4endl; |
---|
| 763 | } |
---|
| 764 | #endif |
---|
| 765 | |
---|
| 766 | if( !GetVisibility() ) |
---|
| 767 | { |
---|
| 768 | visAtt->SetVisibility( GetVisibility() ); |
---|
| 769 | } |
---|
| 770 | else if( GetColour()[0] != -1 ) |
---|
| 771 | { |
---|
| 772 | // this else should not be necessary, because if the visibility |
---|
| 773 | // is set to off, colour should have no effect. But it does not |
---|
| 774 | // work: if you set colour and vis off, it is visualized!?!?!? |
---|
| 775 | |
---|
| 776 | const G4double* col = GetColour(); |
---|
| 777 | if( col[3] == -1. ) |
---|
| 778 | { |
---|
| 779 | visAtt->SetColour( G4Colour(col[0],col[1],col[2])); |
---|
| 780 | } |
---|
| 781 | else |
---|
| 782 | { |
---|
| 783 | visAtt->SetColour( G4Colour(col[0],col[1],col[2],col[3])); |
---|
| 784 | } |
---|
| 785 | } |
---|
| 786 | logvol->SetVisAttributes(visAtt); |
---|
| 787 | } |
---|
| 788 | |
---|
| 789 | #ifdef G4VERBOSE |
---|
| 790 | if( G4tgrMessenger::GetVerboseLevel() >= 2 ) |
---|
| 791 | { |
---|
| 792 | G4cout << " G4tgbVolume::ConstructG4LogVol() -" |
---|
| 793 | << " Created logical volume: " << GetName() << G4endl; |
---|
| 794 | } |
---|
| 795 | #endif |
---|
| 796 | |
---|
| 797 | return logvol; |
---|
| 798 | } |
---|
| 799 | |
---|
| 800 | |
---|
| 801 | //------------------------------------------------------------------- |
---|
| 802 | G4VPhysicalVolume* |
---|
| 803 | G4tgbVolume::ConstructG4PhysVol( const G4tgrPlace* place, |
---|
| 804 | const G4LogicalVolume* currentLV, |
---|
| 805 | const G4LogicalVolume* parentLV ) |
---|
| 806 | { |
---|
| 807 | G4VPhysicalVolume* physvol = 0; |
---|
| 808 | G4int copyNo; |
---|
| 809 | |
---|
| 810 | //----- Case of placement of top volume |
---|
| 811 | if( place == 0 ) |
---|
| 812 | { |
---|
| 813 | #ifdef G4VERBOSE |
---|
| 814 | if( G4tgrMessenger::GetVerboseLevel() >= 2 ) |
---|
| 815 | { |
---|
| 816 | G4cout << " G4tgbVolume::ConstructG4PhysVol() - World: " |
---|
| 817 | << GetName() << G4endl; |
---|
| 818 | } |
---|
| 819 | #endif |
---|
| 820 | physvol = new G4PVPlacement(0, G4ThreeVector(), |
---|
| 821 | const_cast<G4LogicalVolume*>(currentLV), |
---|
| 822 | GetName(), 0, false, 0, |
---|
| 823 | theTgrVolume->GetCheckOverlaps()); |
---|
| 824 | #ifdef G4VERBOSE |
---|
| 825 | if( G4tgrMessenger::GetVerboseLevel() >= 1 ) |
---|
| 826 | { |
---|
| 827 | G4cout << " Constructing new : G4PVPlacement " |
---|
| 828 | << physvol->GetName() << G4endl; |
---|
| 829 | } |
---|
| 830 | #endif |
---|
| 831 | } |
---|
| 832 | else |
---|
| 833 | { |
---|
| 834 | copyNo = place->GetCopyNo(); |
---|
| 835 | |
---|
| 836 | #ifdef G4VERBOSE |
---|
| 837 | if( G4tgrMessenger::GetVerboseLevel() >= 2 ) |
---|
| 838 | { |
---|
| 839 | G4cout << " G4tgbVolume::ConstructG4PhysVol() - " << GetName() << G4endl |
---|
| 840 | << " inside " << parentLV->GetName() << " copy No: " << copyNo |
---|
| 841 | << " of type= " << theTgrVolume->GetType() << G4endl |
---|
| 842 | << " placement type= " << place->GetType() << G4endl; |
---|
| 843 | } |
---|
| 844 | #endif |
---|
| 845 | |
---|
| 846 | if( theTgrVolume->GetType() == "VOLSimple" ) |
---|
| 847 | { |
---|
| 848 | //----- Get placement |
---|
| 849 | #ifdef G4VERBOSE |
---|
| 850 | if( G4tgrMessenger::GetVerboseLevel() >= 2 ) |
---|
| 851 | { |
---|
| 852 | G4cout << " G4tgbVolume::ConstructG4PhysVol() - Placement type = " |
---|
| 853 | << place->GetType() << G4endl; |
---|
| 854 | } |
---|
| 855 | #endif |
---|
| 856 | |
---|
| 857 | //--------------- If it is G4tgrPlaceSimple |
---|
| 858 | if( place->GetType() == "PlaceSimple" ) |
---|
| 859 | { |
---|
| 860 | //----- Get rotation matrix |
---|
| 861 | G4tgrPlaceSimple* placeSimple = (G4tgrPlaceSimple*)place; |
---|
| 862 | G4String rmName = placeSimple->GetRotMatName(); |
---|
| 863 | |
---|
| 864 | G4RotationMatrix* rotmat = G4tgbRotationMatrixMgr::GetInstance() |
---|
| 865 | ->FindOrBuildG4RotMatrix( rmName ); |
---|
| 866 | //----- Place volume in mother |
---|
| 867 | G4double check = (rotmat->colX().cross(rotmat->colY()))*rotmat->colZ(); |
---|
| 868 | G4double tol = 1.0e-3; |
---|
| 869 | //---- Check that matrix is ortogonal |
---|
| 870 | if (1-std::abs(check)>tol) |
---|
| 871 | { |
---|
| 872 | G4cerr << " Matrix : " << rmName << " " << rotmat->colX() |
---|
| 873 | << " " << rotmat->colY() << " " << rotmat->colZ() << G4endl |
---|
| 874 | << " product x X y * z = " << check << " x X y " |
---|
| 875 | << rotmat->colX().cross(rotmat->colY()) << G4endl; |
---|
| 876 | G4String ErrMessage = "Rotation is not ortogonal " + rmName + " !"; |
---|
| 877 | G4Exception("G4tgbVolume::ConstructG4PhysVol()", |
---|
| 878 | "InvalidSetup", FatalException, ErrMessage); |
---|
| 879 | //---- Check if it is reflection |
---|
| 880 | } |
---|
| 881 | else if (1+check<=tol) |
---|
| 882 | { |
---|
| 883 | G4Translate3D transl = place->GetPlacement(); |
---|
| 884 | G4Transform3D trfrm = transl * G4Rotate3D(*rotmat); |
---|
| 885 | physvol = (G4ReflectionFactory::Instance()->Place(trfrm, GetName(), |
---|
| 886 | const_cast<G4LogicalVolume*>(currentLV), |
---|
| 887 | const_cast<G4LogicalVolume*>(parentLV), |
---|
| 888 | false, copyNo, false )).first; |
---|
| 889 | } |
---|
| 890 | else |
---|
| 891 | { |
---|
| 892 | #ifdef G4VERBOSE |
---|
| 893 | if( G4tgrMessenger::GetVerboseLevel() >= 1 ) |
---|
| 894 | { |
---|
| 895 | G4cout << "Construction new G4VPhysicalVolume" |
---|
| 896 | << " through G4ReflectionFactory " << GetName() |
---|
| 897 | << " in volume " << parentLV->GetName() |
---|
| 898 | << " copyNo " << copyNo |
---|
| 899 | << " position " << place->GetPlacement() |
---|
| 900 | << " ROT " << rotmat->colX() |
---|
| 901 | << " " << rotmat->colY() |
---|
| 902 | << " " << rotmat->colZ() << G4endl; |
---|
| 903 | } |
---|
| 904 | #endif |
---|
| 905 | physvol = new G4PVPlacement( rotmat, place->GetPlacement(), |
---|
| 906 | const_cast<G4LogicalVolume*>(currentLV), |
---|
| 907 | GetName(), |
---|
| 908 | const_cast<G4LogicalVolume*>(parentLV), |
---|
| 909 | false, copyNo, |
---|
| 910 | theTgrVolume->GetCheckOverlaps()); |
---|
| 911 | } |
---|
| 912 | |
---|
| 913 | //--------------- If it is G4tgrPlaceParam |
---|
| 914 | } |
---|
| 915 | else if( place->GetType() == "PlaceParam" ) |
---|
| 916 | { |
---|
| 917 | G4tgrPlaceParameterisation* dp = (G4tgrPlaceParameterisation*)(place); |
---|
| 918 | |
---|
| 919 | //----- See what parameterisation type |
---|
| 920 | #ifdef G4VERBOSE |
---|
| 921 | if( G4tgrMessenger::GetVerboseLevel() >= 2 ) |
---|
| 922 | { |
---|
| 923 | G4cout << " G4tgbVolume::ConstructG4PhysVol() -" << G4endl |
---|
| 924 | << " param: " << GetName() << " in " << parentLV->GetName() |
---|
| 925 | << " param type= " << dp->GetParamType() << G4endl; |
---|
| 926 | } |
---|
| 927 | #endif |
---|
| 928 | |
---|
| 929 | G4tgbPlaceParameterisation * param=0; |
---|
| 930 | |
---|
| 931 | if( (dp->GetParamType() == "CIRCLE") |
---|
| 932 | || (dp->GetParamType() == "CIRCLE_XY") |
---|
| 933 | || (dp->GetParamType() == "CIRCLE_XZ") |
---|
| 934 | || (dp->GetParamType() == "CIRCLE_YZ") ) |
---|
| 935 | { |
---|
| 936 | param = new G4tgbPlaceParamCircle(dp); |
---|
| 937 | |
---|
| 938 | } |
---|
| 939 | else if( (dp->GetParamType() == "LINEAR") |
---|
| 940 | || (dp->GetParamType() == "LINEAR_X") |
---|
| 941 | || (dp->GetParamType() == "LINEAR_Y") |
---|
| 942 | || (dp->GetParamType() == "LINEAR_Z") ) |
---|
| 943 | { |
---|
| 944 | param = new G4tgbPlaceParamLinear(dp); |
---|
| 945 | |
---|
| 946 | } |
---|
| 947 | else if( (dp->GetParamType() == "SQUARE") |
---|
| 948 | || (dp->GetParamType() == "SQUARE_XY") |
---|
| 949 | || (dp->GetParamType() == "SQUARE_XZ") |
---|
| 950 | || (dp->GetParamType() == "SQUARE_YZ") ) |
---|
| 951 | { |
---|
| 952 | param = new G4tgbPlaceParamSquare(dp); |
---|
| 953 | } |
---|
| 954 | else |
---|
| 955 | { |
---|
| 956 | G4String ErrMessage = "Parameterisation has wrong type, TYPE: " |
---|
| 957 | + G4String(dp->GetParamType()) + " !"; |
---|
| 958 | G4Exception("G4tgbVolume::ConstructG4PhysVol", "WrongArgument", |
---|
| 959 | FatalException, ErrMessage); |
---|
| 960 | } |
---|
| 961 | #ifdef G4VERBOSE |
---|
| 962 | if( G4tgrMessenger::GetVerboseLevel() >= 1 ) |
---|
| 963 | { |
---|
| 964 | G4cout << " G4tgbVolume::ConstructG4PhysVol() -" << G4endl |
---|
| 965 | << " New G4PVParameterised: " << GetName() << " vol " |
---|
| 966 | << currentLV->GetName() << " in vol " << parentLV->GetName() |
---|
| 967 | << " axis " << param->GetAxis() << " nCopies " |
---|
| 968 | << param->GetNCopies() << G4endl; |
---|
| 969 | } |
---|
| 970 | #endif |
---|
| 971 | physvol = new G4PVParameterised(GetName(), |
---|
| 972 | const_cast<G4LogicalVolume*>(currentLV), |
---|
| 973 | const_cast<G4LogicalVolume*>(parentLV), |
---|
| 974 | EAxis(param->GetAxis()), |
---|
| 975 | param->GetNCopies(), param); |
---|
| 976 | #ifdef G4VERBOSE |
---|
| 977 | if( G4tgrMessenger::GetVerboseLevel() >= 1 ) |
---|
| 978 | { |
---|
| 979 | G4cout << " Constructing new G4PVParameterised: " |
---|
| 980 | << physvol->GetName() << " in volume " << parentLV->GetName() |
---|
| 981 | << " N copies " << param->GetNCopies() |
---|
| 982 | << " axis " << param->GetAxis() << G4endl; |
---|
| 983 | } |
---|
| 984 | #endif |
---|
| 985 | |
---|
| 986 | } |
---|
| 987 | else if( place->GetType() == "PlaceReplica" ) |
---|
| 988 | { |
---|
| 989 | //--------------- If it is PlaceReplica |
---|
| 990 | G4tgrPlaceDivRep* dpr = (G4tgrPlaceDivRep*)place; |
---|
| 991 | |
---|
| 992 | #ifdef G4VERBOSE |
---|
| 993 | if( G4tgrMessenger::GetVerboseLevel() >= 2 ) |
---|
| 994 | { |
---|
| 995 | G4cout << " G4tgbVolume::ConstructG4PhysVol() -" << G4endl |
---|
| 996 | << " replica" << " " << currentLV->GetName() |
---|
| 997 | << " in " << parentLV->GetName() |
---|
| 998 | << " NDiv " << dpr->GetNDiv() << " Width " << dpr->GetWidth() |
---|
| 999 | << " offset " << dpr->GetOffset() << G4endl; |
---|
| 1000 | } |
---|
| 1001 | #endif |
---|
| 1002 | physvol = new G4PVReplica(GetName(), |
---|
| 1003 | const_cast<G4LogicalVolume*>(currentLV), |
---|
| 1004 | const_cast<G4LogicalVolume*>(parentLV), |
---|
| 1005 | EAxis(dpr->GetAxis()), dpr->GetNDiv(), |
---|
| 1006 | dpr->GetWidth(), dpr->GetOffset()); |
---|
| 1007 | #ifdef G4VERBOSE |
---|
| 1008 | if( G4tgrMessenger::GetVerboseLevel() >= 1 ) |
---|
| 1009 | { |
---|
| 1010 | G4cout << " Constructing new G4PVReplica: " |
---|
| 1011 | << currentLV->GetName() |
---|
| 1012 | << " in " << parentLV->GetName() |
---|
| 1013 | << " NDiv " << dpr->GetNDiv() << " Width " << dpr->GetWidth() |
---|
| 1014 | << " offset " << dpr->GetOffset() << G4endl; |
---|
| 1015 | } |
---|
| 1016 | #endif |
---|
| 1017 | } |
---|
| 1018 | } |
---|
| 1019 | else if( theTgrVolume->GetType() == "VOLDivision" ) |
---|
| 1020 | { |
---|
| 1021 | G4tgrVolumeDivision* volr = (G4tgrVolumeDivision*)theTgrVolume; |
---|
| 1022 | G4tgrPlaceDivRep* placeDiv = volr->GetPlaceDivision() ; |
---|
| 1023 | G4VSolid* solid = BuildSolidForDivision( parentLV->GetSolid(), placeDiv->GetAxis() ); |
---|
| 1024 | G4Material* mate = G4tgbMaterialMgr::GetInstance() |
---|
| 1025 | ->FindOrBuildG4Material( theTgrVolume->GetMaterialName() ); |
---|
| 1026 | G4LogicalVolume* divLV = new G4LogicalVolume(solid, |
---|
| 1027 | const_cast<G4Material*>(mate), |
---|
| 1028 | GetName() ); |
---|
| 1029 | #ifdef G4VERBOSE |
---|
| 1030 | if( G4tgrMessenger::GetVerboseLevel() >= 1 ) |
---|
| 1031 | { |
---|
| 1032 | G4cout << " Constructed new G4LogicalVolume for division: " |
---|
| 1033 | << divLV->GetName() << " mate " << mate->GetName() << G4endl; |
---|
| 1034 | } |
---|
| 1035 | #endif |
---|
| 1036 | |
---|
| 1037 | G4DivType divType = placeDiv->GetDivType(); |
---|
| 1038 | switch (divType) |
---|
| 1039 | { |
---|
| 1040 | case DivByNdiv: |
---|
| 1041 | physvol = new G4PVDivision(GetName(), (G4LogicalVolume*)divLV, |
---|
| 1042 | const_cast<G4LogicalVolume*>(parentLV), |
---|
| 1043 | placeDiv->GetAxis(), placeDiv->GetNDiv(), |
---|
| 1044 | placeDiv->GetOffset()); |
---|
| 1045 | #ifdef G4VERBOSE |
---|
| 1046 | if( G4tgrMessenger::GetVerboseLevel() >= 1 ) |
---|
| 1047 | { |
---|
| 1048 | G4cout << " Constructing new G4PVDivision by number of divisions: " |
---|
| 1049 | << GetName() << " in " << parentLV->GetName() |
---|
| 1050 | << " axis " << placeDiv->GetAxis() |
---|
| 1051 | << " Ndiv " << placeDiv->GetNDiv() |
---|
| 1052 | << " offset " << placeDiv->GetOffset() << G4endl; |
---|
| 1053 | } |
---|
| 1054 | #endif |
---|
| 1055 | break; |
---|
| 1056 | case DivByWidth: |
---|
| 1057 | physvol = new G4PVDivision(GetName(), (G4LogicalVolume*)divLV, |
---|
| 1058 | const_cast<G4LogicalVolume*>(parentLV), |
---|
| 1059 | placeDiv->GetAxis(), placeDiv->GetWidth(), |
---|
| 1060 | placeDiv->GetOffset()); |
---|
| 1061 | #ifdef G4VERBOSE |
---|
| 1062 | if( G4tgrMessenger::GetVerboseLevel() >= 1 ) |
---|
| 1063 | { |
---|
| 1064 | G4cout << " Constructing new G4PVDivision by width: " |
---|
| 1065 | << GetName() << " in " << parentLV->GetName() |
---|
| 1066 | << " axis " << placeDiv->GetAxis() |
---|
| 1067 | << " width " << placeDiv->GetWidth() |
---|
| 1068 | << " offset " << placeDiv->GetOffset() << G4endl; |
---|
| 1069 | } |
---|
| 1070 | #endif |
---|
| 1071 | break; |
---|
| 1072 | case DivByNdivAndWidth: |
---|
| 1073 | physvol = new G4PVDivision(GetName(), (G4LogicalVolume*)divLV, |
---|
| 1074 | const_cast<G4LogicalVolume*>(parentLV), |
---|
| 1075 | placeDiv->GetAxis(), placeDiv->GetNDiv(), |
---|
| 1076 | placeDiv->GetWidth(), |
---|
| 1077 | placeDiv->GetOffset()); |
---|
| 1078 | #ifdef G4VERBOSE |
---|
| 1079 | if( G4tgrMessenger::GetVerboseLevel() >= 1 ) |
---|
| 1080 | { |
---|
| 1081 | G4cout << " Constructing new G4PVDivision by width" |
---|
| 1082 | << " and number of divisions: " |
---|
| 1083 | << GetName() << " in " << parentLV->GetName() |
---|
| 1084 | << " axis " << placeDiv->GetAxis() |
---|
| 1085 | << " Ndiv " << placeDiv->GetNDiv() |
---|
| 1086 | << " width " << placeDiv->GetWidth() |
---|
| 1087 | << " offset " << placeDiv->GetOffset() << G4endl; |
---|
| 1088 | } |
---|
| 1089 | #endif |
---|
| 1090 | break; |
---|
| 1091 | } |
---|
| 1092 | } |
---|
| 1093 | else if( theTgrVolume->GetType() == "VOLAssembly" ) |
---|
| 1094 | { |
---|
| 1095 | // Define one layer as one assembly volume |
---|
| 1096 | G4tgrVolumeAssembly * tgrAssembly = (G4tgrVolumeAssembly *)theTgrVolume; |
---|
| 1097 | |
---|
| 1098 | if( !theG4AssemblyVolume ) |
---|
| 1099 | { |
---|
| 1100 | theG4AssemblyVolume = new G4AssemblyVolume; |
---|
| 1101 | #ifdef G4VERBOSE |
---|
| 1102 | if( G4tgrMessenger::GetVerboseLevel() >= 1 ) |
---|
| 1103 | { |
---|
| 1104 | G4cout << " Constructing new G4AssemblyVolume: " |
---|
| 1105 | << " number of assembly components " |
---|
| 1106 | << tgrAssembly->GetNoComponents() << G4endl; |
---|
| 1107 | } |
---|
| 1108 | #endif |
---|
| 1109 | G4tgbVolumeMgr* g4vmgr = G4tgbVolumeMgr::GetInstance(); |
---|
| 1110 | for( G4int ii = 0; ii < tgrAssembly->GetNoComponents(); ii++ ) |
---|
| 1111 | { |
---|
| 1112 | // Rotation and translation of a plate inside the assembly |
---|
| 1113 | |
---|
| 1114 | G4ThreeVector transl = tgrAssembly->GetComponentPos(ii); |
---|
| 1115 | G4String rmName = tgrAssembly->GetComponentRM(ii); |
---|
| 1116 | G4RotationMatrix* rotmat = G4tgbRotationMatrixMgr::GetInstance() |
---|
| 1117 | ->FindOrBuildG4RotMatrix( rmName ); |
---|
| 1118 | |
---|
| 1119 | //----- Get G4LogicalVolume of component |
---|
| 1120 | G4String lvname = tgrAssembly->GetComponentName(ii); |
---|
| 1121 | G4LogicalVolume* logvol = g4vmgr->FindG4LogVol( lvname); |
---|
| 1122 | if( logvol == 0 ) |
---|
| 1123 | { |
---|
| 1124 | g4vmgr->FindVolume( lvname )->ConstructG4Volumes( 0, 0); |
---|
| 1125 | logvol = g4vmgr->FindG4LogVol( lvname, true ); |
---|
| 1126 | } |
---|
| 1127 | // Fill the assembly by the plates |
---|
| 1128 | theG4AssemblyVolume->AddPlacedVolume( logvol, transl, rotmat ); |
---|
| 1129 | #ifdef G4VERBOSE |
---|
| 1130 | if( G4tgrMessenger::GetVerboseLevel() >= 1 ) |
---|
| 1131 | { |
---|
| 1132 | G4cout << " G4AssemblyVolume->AddPlacedVolume " << ii |
---|
| 1133 | << " " << logvol->GetName() |
---|
| 1134 | << " translation " << transl |
---|
| 1135 | << " rotmat " << rotmat->colX() |
---|
| 1136 | << " " << rotmat->colY() |
---|
| 1137 | << " " << rotmat->colZ() << G4endl; |
---|
| 1138 | } |
---|
| 1139 | #endif |
---|
| 1140 | |
---|
| 1141 | } |
---|
| 1142 | } |
---|
| 1143 | |
---|
| 1144 | // Rotation and Translation of the assembly inside the world |
---|
| 1145 | |
---|
| 1146 | G4tgrPlaceSimple* placeSimple = (G4tgrPlaceSimple*)place; |
---|
| 1147 | G4String rmName = placeSimple->GetRotMatName(); |
---|
| 1148 | G4RotationMatrix* rotmat = G4tgbRotationMatrixMgr::GetInstance() |
---|
| 1149 | ->FindOrBuildG4RotMatrix( rmName ); |
---|
| 1150 | G4ThreeVector transl = place->GetPlacement(); |
---|
| 1151 | |
---|
| 1152 | G4LogicalVolume* parentLV_nonconst = |
---|
| 1153 | const_cast<G4LogicalVolume*>(parentLV); |
---|
| 1154 | theG4AssemblyVolume->MakeImprint( parentLV_nonconst, transl, rotmat ); |
---|
| 1155 | |
---|
| 1156 | } |
---|
| 1157 | else // If it is G4tgrVolumeAssembly |
---|
| 1158 | { |
---|
| 1159 | G4String ErrMessage = "Volume type not supported: " |
---|
| 1160 | + theTgrVolume->GetType() + ", sorry..."; |
---|
| 1161 | G4Exception("G4tgbVolume::ConstructG4PhysVol()", "NotImplemented", |
---|
| 1162 | FatalException, ErrMessage); |
---|
| 1163 | } |
---|
| 1164 | } |
---|
| 1165 | |
---|
| 1166 | return physvol; |
---|
| 1167 | } |
---|
| 1168 | |
---|
| 1169 | |
---|
| 1170 | //------------------------------------------------------------------- |
---|
| 1171 | G4VSolid* G4tgbVolume::BuildSolidForDivision( G4VSolid* parentSolid, EAxis axis ) |
---|
| 1172 | { |
---|
| 1173 | G4VSolid* solid=0; |
---|
| 1174 | G4double redf = (parentSolid->GetExtent().GetXmax()-parentSolid->GetExtent().GetXmin()); |
---|
| 1175 | redf = std::min(redf,parentSolid->GetExtent().GetYmax()-parentSolid->GetExtent().GetYmin()); |
---|
| 1176 | redf = std::min(redf,parentSolid->GetExtent().GetZmax()-parentSolid->GetExtent().GetZmin()); |
---|
| 1177 | redf *= 0.001; //make daugther much smaller, to fit in parent |
---|
| 1178 | |
---|
| 1179 | if( parentSolid->GetEntityType() == "G4Box" ) |
---|
| 1180 | { |
---|
| 1181 | G4Box* psolid = (G4Box*)(parentSolid); |
---|
| 1182 | solid = new G4Box(GetName(), psolid->GetXHalfLength()*redf, |
---|
| 1183 | psolid->GetZHalfLength()*redf, |
---|
| 1184 | psolid->GetZHalfLength()*redf); |
---|
| 1185 | } |
---|
| 1186 | else if ( parentSolid->GetEntityType() == "G4Tubs" ) |
---|
| 1187 | { |
---|
| 1188 | G4Tubs* psolid = (G4Tubs*)(parentSolid); |
---|
| 1189 | solid = new G4Tubs( GetName(), psolid->GetInnerRadius()*redf, |
---|
| 1190 | psolid->GetOuterRadius()*redf, |
---|
| 1191 | psolid->GetZHalfLength()*redf, |
---|
| 1192 | psolid->GetSPhi(), psolid->GetDPhi()); |
---|
| 1193 | } |
---|
| 1194 | else if ( parentSolid->GetEntityType() == "G4Cons" ) |
---|
| 1195 | { |
---|
| 1196 | G4Cons* psolid = (G4Cons*)(parentSolid); |
---|
| 1197 | solid = new G4Cons( GetName(), psolid->GetInnerRadiusMinusZ()*redf, |
---|
| 1198 | psolid->GetOuterRadiusMinusZ()*redf, |
---|
| 1199 | psolid->GetInnerRadiusPlusZ()*redf, |
---|
| 1200 | psolid->GetOuterRadiusPlusZ()*redf, |
---|
| 1201 | psolid->GetZHalfLength()*redf, |
---|
| 1202 | psolid->GetSPhi(), psolid->GetDPhi()); |
---|
| 1203 | } |
---|
| 1204 | else if ( parentSolid->GetEntityType() == "G4Trd" ) |
---|
| 1205 | { |
---|
| 1206 | G4Trd* psolid = (G4Trd*)(parentSolid); |
---|
| 1207 | G4double mpDx1 = psolid->GetXHalfLength1(); |
---|
| 1208 | G4double mpDx2 = psolid->GetXHalfLength2(); |
---|
| 1209 | |
---|
| 1210 | if( axis == kXAxis && std::fabs(mpDx1 - mpDx2) > G4GeometryTolerance::GetInstance()->GetSurfaceTolerance() ) |
---|
| 1211 | { |
---|
| 1212 | solid = new G4Trap( GetName(), psolid->GetZHalfLength()*redf, |
---|
| 1213 | psolid->GetYHalfLength1()*redf, |
---|
| 1214 | psolid->GetXHalfLength2()*redf, |
---|
| 1215 | psolid->GetXHalfLength1()*redf ); |
---|
| 1216 | } |
---|
| 1217 | else |
---|
| 1218 | { |
---|
| 1219 | solid = new G4Trd( GetName(), psolid->GetXHalfLength1()*redf, |
---|
| 1220 | psolid->GetXHalfLength2()*redf, |
---|
| 1221 | psolid->GetYHalfLength1()*redf, |
---|
| 1222 | psolid->GetYHalfLength2()*redf, |
---|
| 1223 | psolid->GetZHalfLength()*redf); |
---|
| 1224 | } |
---|
| 1225 | |
---|
| 1226 | } |
---|
| 1227 | else if ( parentSolid->GetEntityType() == "G4Para" ) |
---|
| 1228 | { |
---|
| 1229 | G4Para* psolid = (G4Para*)(parentSolid); |
---|
| 1230 | solid = new G4Para( GetName(), psolid->GetXHalfLength()*redf, |
---|
| 1231 | psolid->GetYHalfLength()*redf, |
---|
| 1232 | psolid->GetZHalfLength()*redf, |
---|
| 1233 | std::atan(psolid->GetTanAlpha()), |
---|
| 1234 | psolid->GetSymAxis().theta(), |
---|
| 1235 | psolid->GetSymAxis().phi() ); |
---|
| 1236 | } |
---|
| 1237 | else if ( parentSolid->GetEntityType() == "G4Polycone" ) |
---|
| 1238 | { |
---|
| 1239 | G4Polycone* psolid = (G4Polycone*)(parentSolid); |
---|
| 1240 | G4PolyconeHistorical origParam = *(psolid->GetOriginalParameters()); |
---|
| 1241 | for( G4int ii = 0; ii < origParam.Num_z_planes; ii++ ) |
---|
| 1242 | { |
---|
| 1243 | origParam.Rmin[ii] = origParam.Rmin[ii]*redf; |
---|
| 1244 | origParam.Rmax[ii] = origParam.Rmax[ii]*redf; |
---|
| 1245 | } |
---|
| 1246 | solid = new G4Polycone( GetName(), psolid->GetStartPhi(), |
---|
| 1247 | psolid->GetEndPhi(), |
---|
| 1248 | origParam.Num_z_planes, origParam.Z_values, |
---|
| 1249 | origParam.Rmin, origParam.Rmax); |
---|
| 1250 | |
---|
| 1251 | } |
---|
| 1252 | else if ( parentSolid->GetEntityType() == "G4Polyhedra" ) |
---|
| 1253 | { |
---|
| 1254 | G4Polyhedra* psolid = (G4Polyhedra*)(parentSolid); |
---|
| 1255 | G4PolyhedraHistorical origParam = *(psolid->GetOriginalParameters()); |
---|
| 1256 | for( G4int ii = 0; ii < origParam.Num_z_planes; ii++ ) |
---|
| 1257 | { |
---|
| 1258 | origParam.Rmin[ii] = origParam.Rmin[ii]*redf; |
---|
| 1259 | origParam.Rmax[ii] = origParam.Rmax[ii]*redf; |
---|
| 1260 | } |
---|
| 1261 | solid = new G4Polyhedra( GetName(), psolid->GetStartPhi(), |
---|
| 1262 | psolid->GetEndPhi(), |
---|
| 1263 | psolid->GetNumSide(), |
---|
| 1264 | origParam.Num_z_planes, origParam.Z_values, |
---|
| 1265 | origParam.Rmin, origParam.Rmax); |
---|
| 1266 | } |
---|
| 1267 | else |
---|
| 1268 | { |
---|
| 1269 | G4String ErrMessage = "Solid type not supported. VOLUME= " + GetName() |
---|
| 1270 | + " Solid type= " + parentSolid->GetEntityType() + "\n" |
---|
| 1271 | + "Only supported types are: G4Box, G4Tubs, G4Cons," |
---|
| 1272 | + " G4Trd, G4Para, G4Polycone, G4Polyhedra."; |
---|
| 1273 | G4Exception("G4tgbVolume::BuildSolidForDivision()", "NotImplemented", |
---|
| 1274 | FatalException, ErrMessage); |
---|
| 1275 | } |
---|
| 1276 | |
---|
| 1277 | #ifdef G4VERBOSE |
---|
| 1278 | if( G4tgrMessenger::GetVerboseLevel() >= 1 ) |
---|
| 1279 | { |
---|
| 1280 | G4cout << " Constructing new G4Solid for division: " |
---|
| 1281 | << *solid << G4endl; |
---|
| 1282 | } |
---|
| 1283 | #endif |
---|
| 1284 | return solid; |
---|
| 1285 | } |
---|
| 1286 | |
---|