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 // G4tgbGeometryDumper implementation << 27 // 26 // 28 // Author: P.Arce, CIEMAT (November 2007) << 27 // $Id: G4tgbGeometryDumper.cc,v 1.15 2010/11/02 11:13:05 gcosmo Exp $ 29 // ------------------------------------------- << 28 // GEANT4 tag $Name: geant4-09-04 $ >> 29 // >> 30 // >> 31 // class G4tgbGeometryDumper >> 32 >> 33 // History: >> 34 // - Created. P.Arce, CIEMAT (November 2007) >> 35 // ------------------------------------------------------------------------- 30 36 31 #include "G4tgbGeometryDumper.hh" 37 #include "G4tgbGeometryDumper.hh" 32 38 33 #include "G4tgrMessenger.hh" 39 #include "G4tgrMessenger.hh" 34 40 35 #include "G4UIcommand.hh" 41 #include "G4UIcommand.hh" 36 #include "G4Material.hh" 42 #include "G4Material.hh" 37 #include "G4Element.hh" 43 #include "G4Element.hh" 38 #include "G4VSolid.hh" 44 #include "G4VSolid.hh" 39 #include "G4Box.hh" 45 #include "G4Box.hh" 40 #include "G4Tubs.hh" 46 #include "G4Tubs.hh" 41 #include "G4Cons.hh" 47 #include "G4Cons.hh" 42 #include "G4Trap.hh" 48 #include "G4Trap.hh" 43 #include "G4Sphere.hh" 49 #include "G4Sphere.hh" 44 #include "G4Orb.hh" 50 #include "G4Orb.hh" 45 #include "G4Trd.hh" 51 #include "G4Trd.hh" 46 #include "G4Para.hh" 52 #include "G4Para.hh" 47 #include "G4Torus.hh" 53 #include "G4Torus.hh" 48 #include "G4Hype.hh" 54 #include "G4Hype.hh" 49 #include "G4Polycone.hh" 55 #include "G4Polycone.hh" 50 #include "G4GenericPolycone.hh" << 51 #include "G4Polyhedra.hh" 56 #include "G4Polyhedra.hh" 52 #include "G4EllipticalTube.hh" 57 #include "G4EllipticalTube.hh" 53 #include "G4Ellipsoid.hh" 58 #include "G4Ellipsoid.hh" 54 #include "G4EllipticalCone.hh" 59 #include "G4EllipticalCone.hh" 55 #include "G4Hype.hh" 60 #include "G4Hype.hh" 56 #include "G4Tet.hh" 61 #include "G4Tet.hh" 57 #include "G4TwistedBox.hh" 62 #include "G4TwistedBox.hh" 58 #include "G4TwistedTrap.hh" 63 #include "G4TwistedTrap.hh" 59 #include "G4TwistedTrd.hh" 64 #include "G4TwistedTrd.hh" 60 #include "G4TwistedTubs.hh" 65 #include "G4TwistedTubs.hh" 61 #include "G4MultiUnion.hh" << 62 #include "G4ScaledSolid.hh" << 63 #include "G4PVPlacement.hh" 66 #include "G4PVPlacement.hh" 64 #include "G4PVParameterised.hh" 67 #include "G4PVParameterised.hh" 65 #include "G4PVReplica.hh" 68 #include "G4PVReplica.hh" 66 #include "G4BooleanSolid.hh" 69 #include "G4BooleanSolid.hh" 67 #include "G4ReflectionFactory.hh" 70 #include "G4ReflectionFactory.hh" 68 #include "G4ReflectedSolid.hh" 71 #include "G4ReflectedSolid.hh" 69 #include "G4LogicalVolumeStore.hh" 72 #include "G4LogicalVolumeStore.hh" 70 #include "G4PhysicalVolumeStore.hh" 73 #include "G4PhysicalVolumeStore.hh" 71 #include "G4GeometryTolerance.hh" 74 #include "G4GeometryTolerance.hh" 72 #include "G4VPVParameterisation.hh" 75 #include "G4VPVParameterisation.hh" 73 #include "G4SystemOfUnits.hh" << 74 #include <iomanip> 76 #include <iomanip> 75 77 76 // ------------------------------------------- << 78 //------------------------------------------------------------------------ 77 G4ThreadLocal G4tgbGeometryDumper* G4tgbGeomet << 79 G4tgbGeometryDumper* G4tgbGeometryDumper::theInstance = 0; 78 80 79 // ------------------------------------------- << 81 //------------------------------------------------------------------------ 80 G4tgbGeometryDumper::G4tgbGeometryDumper() 82 G4tgbGeometryDumper::G4tgbGeometryDumper() >> 83 : theFile(0), theRotationNumber(0) 81 { 84 { 82 } 85 } 83 86 84 // ------------------------------------------- << 87 //------------------------------------------------------------------------ 85 G4tgbGeometryDumper* G4tgbGeometryDumper::GetI 88 G4tgbGeometryDumper* G4tgbGeometryDumper::GetInstance() 86 { 89 { 87 if(theInstance == nullptr) << 90 if( theInstance == 0 ){ 88 { << 89 theInstance = new G4tgbGeometryDumper; 91 theInstance = new G4tgbGeometryDumper; 90 } 92 } >> 93 91 return theInstance; 94 return theInstance; >> 95 92 } 96 } 93 97 94 // ------------------------------------------- << 98 //------------------------------------------------------------------------ 95 void G4tgbGeometryDumper::DumpGeometry(const G << 99 void G4tgbGeometryDumper::DumpGeometry( const G4String& fname ) 96 { 100 { 97 theFile = new std::ofstream(fname); 101 theFile = new std::ofstream(fname); 98 102 99 G4VPhysicalVolume* pv = GetTopPhysVol(); 103 G4VPhysicalVolume* pv = GetTopPhysVol(); 100 DumpPhysVol(pv); // dump volume and recursi << 104 DumpPhysVol( pv ); // dump volume and recursively it will dump all hierarchy 101 } 105 } 102 106 103 // ------------------------------------------- << 107 //--------------------------------------------------------------------- 104 G4VPhysicalVolume* G4tgbGeometryDumper::GetTop 108 G4VPhysicalVolume* G4tgbGeometryDumper::GetTopPhysVol() 105 { 109 { 106 G4PhysicalVolumeStore* pvstore = G4PhysicalV 110 G4PhysicalVolumeStore* pvstore = G4PhysicalVolumeStore::GetInstance(); 107 G4VPhysicalVolume* pv = *(pvstore->cbegin()) << 111 G4PhysicalVolumeStore::const_iterator ite; 108 for(;;) << 112 G4VPhysicalVolume* pv = *(pvstore->begin()); >> 113 for( ;; ) 109 { 114 { 110 G4LogicalVolume* lv = pv->GetMotherLogical 115 G4LogicalVolume* lv = pv->GetMotherLogical(); 111 if(lv == 0) << 116 if( lv == 0 ) { break; } 112 { << 113 break; << 114 } << 115 117 116 //----- look for one PV of this LV 118 //----- look for one PV of this LV 117 for(auto ite = pvstore->cbegin(); ite != p << 119 for( ite = pvstore->begin(); ite != pvstore->end(); ite++ ) 118 { 120 { 119 pv = (*ite); 121 pv = (*ite); 120 if(pv->GetLogicalVolume() == lv) << 122 if( pv->GetLogicalVolume() == lv ) 121 { 123 { 122 break; 124 break; 123 } 125 } 124 } 126 } 125 } 127 } 126 128 127 return pv; 129 return pv; 128 } 130 } 129 131 130 // ------------------------------------------- << 132 >> 133 //------------------------------------------------------------------------ 131 G4tgbGeometryDumper::~G4tgbGeometryDumper() 134 G4tgbGeometryDumper::~G4tgbGeometryDumper() 132 { 135 { 133 } 136 } 134 137 135 // ------------------------------------------- << 138 //------------------------------------------------------------------------ 136 void G4tgbGeometryDumper::DumpPhysVol(G4VPhysi << 139 void G4tgbGeometryDumper::DumpPhysVol( G4VPhysicalVolume* pv ) 137 { 140 { >> 141 138 //--- Dump logical volume first 142 //--- Dump logical volume first 139 G4LogicalVolume* lv = pv->GetLogicalVolume() 143 G4LogicalVolume* lv = pv->GetLogicalVolume(); 140 144 141 G4ReflectionFactory* reffact = G4ReflectionF 145 G4ReflectionFactory* reffact = G4ReflectionFactory::Instance(); 142 146 143 //--- It is not needed to dump _refl volumes 147 //--- It is not needed to dump _refl volumes created when parent is reflected 144 // !!WARNING : it must be avoided to reflect 148 // !!WARNING : it must be avoided to reflect a volume hierarchy if children 145 // has also been reflected, as b 149 // has also been reflected, as both will have same name 146 150 147 if(reffact->IsReflected(lv) && reffact->IsRe << 151 if( reffact->IsReflected( lv ) 148 { << 152 && reffact->IsReflected( pv->GetMotherLogical() ) ) { return; } 149 return; << 150 } << 151 153 152 G4bool bVolExists = CheckIfLogVolExists(lv-> << 153 154 >> 155 G4bool bVolExists = CheckIfLogVolExists( lv->GetName(), lv ); >> 156 154 //---- Construct this PV 157 //---- Construct this PV 155 if(pv->GetMotherLogical() != nullptr) // no << 158 if( pv->GetMotherLogical() != 0 ) // not WORLD volume 156 { 159 { 157 if(!pv->IsReplicated()) << 160 if( !pv->IsReplicated() ) 158 { << 161 { 159 G4String lvName = lv->GetName(); 162 G4String lvName = lv->GetName(); 160 if(!bVolExists) << 163 if( !bVolExists ) 161 { 164 { 162 lvName = DumpLogVol(lv); << 165 lvName = DumpLogVol( lv ); 163 } 166 } 164 DumpPVPlacement(pv, lvName); << 167 DumpPVPlacement( pv, lvName ); 165 } << 168 } 166 else if(pv->IsParameterised()) << 169 else if( pv->IsParameterised() ) 167 { << 170 { 168 G4PVParameterised* pvparam = (G4PVParame << 171 G4PVParameterised* pvparam = (G4PVParameterised*)(pv); 169 DumpPVParameterised(pvparam); << 172 DumpPVParameterised( pvparam ); 170 } << 173 } 171 else << 174 else 172 { 175 { 173 G4String lvName = lv->GetName(); 176 G4String lvName = lv->GetName(); 174 if(!bVolExists) << 177 if( !bVolExists ) 175 { 178 { 176 lvName = DumpLogVol(lv); << 179 lvName = DumpLogVol( lv ); 177 } 180 } 178 G4PVReplica* pvrepl = (G4PVReplica*) (pv << 181 G4PVReplica* pvrepl = (G4PVReplica*)(pv); 179 DumpPVReplica(pvrepl, lvName); << 182 DumpPVReplica( pvrepl, lvName ); 180 } 183 } >> 184 181 } 185 } 182 else << 186 else 183 { 187 { 184 DumpLogVol(lv); << 188 DumpLogVol( lv ); 185 } 189 } 186 190 187 if(!bVolExists) << 191 if( !bVolExists ) 188 { 192 { 189 //---- Construct PV's who has this LV as m 193 //---- Construct PV's who has this LV as mother 190 std::vector<G4VPhysicalVolume*> pvChildren << 194 std::vector<G4VPhysicalVolume*> pvChildren = GetPVChildren( lv ); 191 for(auto ite = pvChildren.cbegin(); ite != << 195 std::vector<G4VPhysicalVolume*>::const_iterator ite; >> 196 for( ite = pvChildren.begin(); ite != pvChildren.end(); ite++ ) 192 { 197 { 193 DumpPhysVol(*ite); << 198 DumpPhysVol( *ite ); 194 } 199 } 195 } 200 } 196 } 201 } 197 202 198 // ------------------------------------------- << 203 //------------------------------------------------------------------------ 199 void G4tgbGeometryDumper::DumpPVPlacement(G4VP << 204 void 200 cons << 205 G4tgbGeometryDumper::DumpPVPlacement( G4VPhysicalVolume* pv, >> 206 const G4String& lvName, G4int copyNo ) 201 { 207 { 202 G4String pvName = pv->GetName(); 208 G4String pvName = pv->GetName(); 203 << 209 204 G4RotationMatrix* rotMat = pv->GetRotation() 210 G4RotationMatrix* rotMat = pv->GetRotation(); 205 if(rotMat == nullptr) << 211 if( !rotMat ) rotMat = new G4RotationMatrix(); 206 rotMat = new G4RotationMatrix(); << 212 207 << 208 //---- Check if it is reflected 213 //---- Check if it is reflected 209 G4ReflectionFactory* reffact = G4ReflectionF 214 G4ReflectionFactory* reffact = G4ReflectionFactory::Instance(); 210 G4LogicalVolume* lv = pv->GetLogica << 215 G4LogicalVolume* lv = pv->GetLogicalVolume(); 211 if(reffact->IsReflected(lv)) << 216 if( reffact->IsReflected( lv ) ) 212 { 217 { 213 #ifdef G4VERBOSE 218 #ifdef G4VERBOSE 214 if(G4tgrMessenger::GetVerboseLevel() >= 1) << 219 if( G4tgrMessenger::GetVerboseLevel() >= 1 ) 215 { << 220 { 216 G4cout << " G4tgbGeometryDumper::DumpPVP << 221 G4cout << " G4tgbGeometryDumper::DumpPVPlacement() - Reflected volume: " 217 << pv->GetName() << G4endl; << 222 << pv->GetName() << G4endl; 218 } << 223 } 219 #endif 224 #endif 220 G4ThreeVector colx = rotMat->colX(); 225 G4ThreeVector colx = rotMat->colX(); 221 G4ThreeVector coly = rotMat->colY(); 226 G4ThreeVector coly = rotMat->colY(); 222 G4ThreeVector colz = rotMat->colZ(); 227 G4ThreeVector colz = rotMat->colZ(); 223 // apply a Z reflection (reflection matrix 228 // apply a Z reflection (reflection matrix is decomposed in new 224 // reflection-free rotation + z-reflection 229 // reflection-free rotation + z-reflection) 225 colz *= -1.; 230 colz *= -1.; 226 G4Rep3x3 rottemp(colx.x(), coly.x(), colz. << 231 CLHEP::HepRep3x3 rottemp(colx.x(),coly.x(),colz.x(), 227 colx.z(), coly.z(), colz. << 232 colx.y(),coly.y(),colz.y(), >> 233 colx.z(),coly.z(),colz.z()); 228 // matrix representation (inverted) 234 // matrix representation (inverted) 229 *rotMat = G4RotationMatrix(rottemp); 235 *rotMat = G4RotationMatrix(rottemp); 230 *rotMat = (*rotMat).inverse(); 236 *rotMat = (*rotMat).inverse(); 231 pvName += "_refl"; 237 pvName += "_refl"; 232 } 238 } 233 const G4String& rotName = DumpRotationMatri << 239 G4String rotName = DumpRotationMatrix( rotMat ); 234 G4ThreeVector pos = pv->GetTranslation(); 240 G4ThreeVector pos = pv->GetTranslation(); 235 241 236 if(copyNo == -999) // for parameterisations << 242 if( copyNo == -999 ) //for parameterisations copy number is provided 237 { 243 { 238 copyNo = pv->GetCopyNo(); 244 copyNo = pv->GetCopyNo(); 239 } 245 } 240 246 241 const G4String& fullname = pvName + "#" + G4 << 247 G4String fullname = pvName 242 + "/" + pv->GetMoth << 248 +"#"+G4UIcommand::ConvertToString(copyNo) 243 << 249 +"/"+pv->GetMotherLogical()->GetName(); 244 if(!CheckIfPhysVolExists(fullname, pv)) << 250 >> 251 if( !CheckIfPhysVolExists(fullname, pv )) 245 { 252 { 246 (*theFile) << ":PLACE " << SubstituteRefl( << 253 (*theFile) 247 << copyNo << " " << 254 << ":PLACE " 248 << SubstituteRefl(AddQuotes(pv- << 255 << SubstituteRefl(AddQuotes(lvName)) 249 << " " << AddQuotes(rotName) << << 256 << " " << copyNo << " " 250 << " " << pos.z() << G4endl; << 257 << SubstituteRefl(AddQuotes(pv->GetMotherLogical()->GetName())) 251 << 258 << " " << AddQuotes(rotName) << " " >> 259 << pos.x() << " " << pos.y() << " " << pos.z() << G4endl; >> 260 252 thePhysVols[fullname] = pv; 261 thePhysVols[fullname] = pv; 253 } 262 } 254 } 263 } 255 264 256 // ------------------------------------------- << 265 257 void G4tgbGeometryDumper::DumpPVParameterised( << 266 //------------------------------------------------------------------------ >> 267 void G4tgbGeometryDumper::DumpPVParameterised( G4PVParameterised* pv ) 258 { 268 { 259 G4String pvName = pv->GetName(); 269 G4String pvName = pv->GetName(); 260 << 270 261 EAxis axis; 271 EAxis axis; 262 G4int nReplicas; 272 G4int nReplicas; 263 G4double width; 273 G4double width; 264 G4double offset; 274 G4double offset; 265 G4bool consuming; 275 G4bool consuming; 266 pv->GetReplicationData(axis, nReplicas, widt 276 pv->GetReplicationData(axis, nReplicas, width, offset, consuming); 267 277 268 G4VPVParameterisation* param = pv->GetParame 278 G4VPVParameterisation* param = pv->GetParameterisation(); 269 279 270 G4LogicalVolume* lv = pv->GetLog << 280 G4LogicalVolume* lv = pv->GetLogicalVolume(); 271 G4VSolid* solid1st = param->Com << 281 G4VSolid* solid1st = param->ComputeSolid(0, pv); 272 G4Material* mate1st = param->Com << 282 G4Material* mate1st = param->ComputeMaterial(0, pv ); 273 std::vector<G4double> params1st = GetSolidPa << 283 std::vector<G4double> params1st = GetSolidParams( solid1st ); 274 std::vector<G4double> newParams; 284 std::vector<G4double> newParams; 275 G4VSolid* newSolid = solid1st; 285 G4VSolid* newSolid = solid1st; 276 G4String lvName; 286 G4String lvName; 277 << 287 278 for(G4int ii = 0; ii < nReplicas; ++ii) << 288 for( G4int ii = 0; ii < nReplicas; ii++ ) 279 { 289 { 280 G4Material* newMate = param->ComputeMateri << 290 G4Material* newMate = param->ComputeMaterial(ii, pv ); 281 if(solid1st->GetEntityType() == "G4Box") << 291 if( solid1st->GetEntityType() == "G4Box") 282 { 292 { 283 G4Box* box = (G4Box*) (solid1st); << 293 G4Box* box = (G4Box*)(solid1st); 284 param->ComputeDimensions(*box, ii, pv); << 294 param->ComputeDimensions(*box, ii, pv ); 285 newParams = GetSolidParams(box); << 295 newParams = GetSolidParams( box ); 286 newSolid = (G4VSolid*) box; << 296 newSolid = (G4VSolid*)box; 287 } << 297 } 288 else if(solid1st->GetEntityType() == "G4Tu << 298 else if( solid1st->GetEntityType() == "G4Tubs") 289 { 299 { 290 G4Tubs* tubs = (G4Tubs*) (solid1st); << 300 G4Tubs* tubs = (G4Tubs*)(solid1st); 291 param->ComputeDimensions(*tubs, ii, pv); << 301 param->ComputeDimensions(*tubs, ii, pv ); 292 newParams = GetSolidParams(tubs); << 302 newParams = GetSolidParams( tubs ); 293 newSolid = (G4VSolid*) tubs; << 303 newSolid = (G4VSolid*)tubs; 294 } 304 } 295 else if(solid1st->GetEntityType() == "G4Tr << 305 else if( solid1st->GetEntityType() == "G4Trd") 296 { 306 { 297 G4Trd* trd = (G4Trd*) (solid1st); << 307 G4Trd* trd = (G4Trd*)(solid1st); 298 param->ComputeDimensions(*trd, ii, pv); << 308 param->ComputeDimensions(*trd, ii, pv ); 299 newParams = GetSolidParams(trd); << 309 newParams = GetSolidParams( trd ); 300 newSolid = (G4VSolid*) trd; << 310 newSolid = (G4VSolid*)trd; 301 } 311 } 302 else if(solid1st->GetEntityType() == "G4Tr << 312 else if( solid1st->GetEntityType() == "G4Trap") 303 { 313 { 304 G4Trap* trap = (G4Trap*) (solid1st); << 314 G4Trap* trap = (G4Trap*)(solid1st); 305 param->ComputeDimensions(*trap, ii, pv); << 315 param->ComputeDimensions(*trap, ii, pv ); 306 newParams = GetSolidParams(trap); << 316 newParams = GetSolidParams( trap ); 307 newSolid = (G4VSolid*) trap; << 317 newSolid = (G4VSolid*)trap; 308 } 318 } 309 else if(solid1st->GetEntityType() == "G4Co << 319 else if( solid1st->GetEntityType() == "G4Cons") 310 { 320 { 311 G4Cons* cons = (G4Cons*) (solid1st); << 321 G4Cons* cons = (G4Cons*)(solid1st); 312 param->ComputeDimensions(*cons, ii, pv); << 322 param->ComputeDimensions(*cons, ii, pv ); 313 newParams = GetSolidParams(cons); << 323 newParams = GetSolidParams( cons ); 314 newSolid = (G4VSolid*) cons; << 324 newSolid = (G4VSolid*)cons; 315 } 325 } 316 else if(solid1st->GetEntityType() == "G4Sp << 326 else if( solid1st->GetEntityType() == "G4Sphere") 317 { 327 { 318 G4Sphere* sphere = (G4Sphere*) (solid1st << 328 G4Sphere* sphere = (G4Sphere*)(solid1st); 319 param->ComputeDimensions(*sphere, ii, pv << 329 param->ComputeDimensions(*sphere, ii, pv ); 320 newParams = GetSolidParams(sphere); << 330 newParams = GetSolidParams( sphere ); 321 newSolid = (G4VSolid*) sphere; << 331 newSolid = (G4VSolid*)sphere; 322 } 332 } 323 else if(solid1st->GetEntityType() == "G4Or << 333 else if( solid1st->GetEntityType() == "G4Orb") 324 { 334 { 325 G4Orb* orb = (G4Orb*) (solid1st); << 335 G4Orb* orb = (G4Orb*)(solid1st); 326 param->ComputeDimensions(*orb, ii, pv); << 336 param->ComputeDimensions(*orb, ii, pv ); 327 newParams = GetSolidParams(orb); << 337 newParams = GetSolidParams( orb ); 328 newSolid = (G4VSolid*) orb; << 338 newSolid = (G4VSolid*)orb; 329 } 339 } 330 else if(solid1st->GetEntityType() == "G4To << 340 else if( solid1st->GetEntityType() == "G4Torus") 331 { 341 { 332 G4Torus* torus = (G4Torus*) (solid1st); << 342 G4Torus* torus = (G4Torus*)(solid1st); 333 param->ComputeDimensions(*torus, ii, pv) << 343 param->ComputeDimensions(*torus, ii, pv ); 334 newParams = GetSolidParams(torus); << 344 newParams = GetSolidParams( torus ); 335 newSolid = (G4VSolid*) torus; << 345 newSolid = (G4VSolid*)torus; 336 } 346 } 337 else if(solid1st->GetEntityType() == "G4Pa << 347 else if( solid1st->GetEntityType() == "G4Para") 338 { 348 { 339 G4Para* para = (G4Para*) (solid1st); << 349 G4Para* para = (G4Para*)(solid1st); 340 param->ComputeDimensions(*para, ii, pv); << 350 param->ComputeDimensions(*para, ii, pv ); 341 newParams = GetSolidParams(para); << 351 newParams = GetSolidParams( para ); 342 newSolid = (G4VSolid*) para; << 352 newSolid = (G4VSolid*)para; 343 } 353 } 344 else if(solid1st->GetEntityType() == "G4Po << 354 else if( solid1st->GetEntityType() == "G4Polycone") 345 { 355 { 346 G4Polycone* polycone = (G4Polycone*) (so << 356 G4Polycone* polycone = (G4Polycone*)(solid1st); 347 param->ComputeDimensions(*polycone, ii, << 357 param->ComputeDimensions(*polycone, ii, pv ); 348 newParams = GetSolidParams(polycone); << 358 newParams = GetSolidParams( polycone ); 349 newSolid = (G4VSolid*) polycone; << 359 newSolid = (G4VSolid*)polycone; 350 } 360 } 351 else if(solid1st->GetEntityType() == "G4Po << 361 else if( solid1st->GetEntityType() == "G4Polyhedra") 352 { 362 { 353 G4Polyhedra* polyhedra = (G4Polyhedra*) << 363 G4Polyhedra* polyhedra = (G4Polyhedra*)(solid1st); 354 param->ComputeDimensions(*polyhedra, ii, << 364 param->ComputeDimensions(*polyhedra, ii, pv ); 355 newParams = GetSolidParams(polyhedra); << 365 newParams = GetSolidParams( polyhedra ); 356 newSolid = (G4VSolid*) polyhedra; << 366 newSolid = (G4VSolid*)polyhedra; 357 } 367 } 358 else if(solid1st->GetEntityType() == "G4Hy << 368 else if( solid1st->GetEntityType() == "G4Hype") 359 { 369 { 360 G4Hype* hype = (G4Hype*) (solid1st); << 370 G4Hype* hype = (G4Hype*)(solid1st); 361 param->ComputeDimensions(*hype, ii, pv); << 371 param->ComputeDimensions(*hype, ii, pv ); 362 newParams = GetSolidParams(hype); << 372 newParams = GetSolidParams( hype ); 363 newSolid = (G4VSolid*) hype; << 373 newSolid = (G4VSolid*)hype; 364 } 374 } 365 if(ii == 0 || mate1st != newMate || params << 375 if( ii == 0 || mate1st != newMate || params1st[0] != newParams[0] ) 366 { 376 { 367 G4String extraName = ""; 377 G4String extraName = ""; 368 if(ii != 0) << 378 if( ii != 0 ) 369 { 379 { 370 extraName = "#" + G4UIcommand::Convert << 380 extraName= "#"+G4UIcommand::ConvertToString(ii) 371 pv->GetMotherLogical()->Ge << 381 +"/"+pv->GetMotherLogical()->GetName(); 372 } 382 } 373 lvName = DumpLogVol(lv, extraName, newSo << 383 lvName = DumpLogVol( lv, extraName, newSolid, newMate ); 374 } 384 } 375 << 385 376 param->ComputeTransformation(ii, pv); 386 param->ComputeTransformation(ii, pv); 377 DumpPVPlacement(pv, lvName, ii); << 387 DumpPVPlacement( pv, lvName, ii ); 378 } 388 } 379 } 389 } 380 390 381 // ------------------------------------------- << 391 382 void G4tgbGeometryDumper::DumpPVReplica(G4PVRe << 392 //------------------------------------------------------------------------ >> 393 void G4tgbGeometryDumper::DumpPVReplica( G4PVReplica* pv, >> 394 const G4String& lvName ) 383 { 395 { 384 EAxis axis; 396 EAxis axis; 385 G4int nReplicas; 397 G4int nReplicas; 386 G4double width; 398 G4double width; 387 G4double offset; 399 G4double offset; 388 G4bool consuming; 400 G4bool consuming; 389 pv->GetReplicationData(axis, nReplicas, widt 401 pv->GetReplicationData(axis, nReplicas, width, offset, consuming); 390 G4String axisName; 402 G4String axisName; 391 switch(axis) << 403 switch (axis ) 392 { 404 { 393 case kXAxis: << 405 case kXAxis: 394 axisName = "X"; << 406 axisName = "X"; 395 break; << 407 break; 396 case kYAxis: << 408 case kYAxis: 397 axisName = "Y"; << 409 axisName = "Y"; 398 break; << 410 break; 399 case kZAxis: << 411 case kZAxis: 400 axisName = "Z"; << 412 axisName = "Z"; 401 break; << 413 break; 402 case kRho: << 414 case kRho: 403 axisName = "R"; << 415 axisName = "R"; 404 break; << 416 break; 405 case kPhi: << 417 case kPhi: 406 axisName = "PHI"; << 418 axisName = "PHI"; 407 break; << 419 break; 408 case kRadial3D: << 420 case kRadial3D: 409 case kUndefined: << 421 case kUndefined: 410 G4String ErrMessage = << 422 G4String ErrMessage = "Unknown axis of replication for volume" 411 "Unknown axis of replication for volum << 423 + pv->GetName(); 412 G4Exception("G4tgbGeometryDumper::DumpPV << 424 G4Exception("G4tgbGeometryDumper::DumpPVReplica", 413 FatalException, ErrMessage); << 425 "Wrong axis ", FatalException, ErrMessage); 414 break; << 426 break; 415 } 427 } 416 428 417 const G4String& fullname = lvName + "/" + pv << 429 G4String fullname = lvName 418 << 430 +"/"+pv->GetMotherLogical()->GetName(); 419 if(!CheckIfPhysVolExists(fullname, pv)) << 431 >> 432 if( !CheckIfPhysVolExists(fullname, pv )) 420 { 433 { 421 (*theFile) << ":REPL " << SubstituteRefl(A << 434 (*theFile) 422 << SubstituteRefl(AddQuotes(pv- << 435 << ":REPL " 423 << " " << axisName << " " << nR << 436 << SubstituteRefl(AddQuotes(lvName)) 424 if(axis != kPhi) << 437 << " " << SubstituteRefl(AddQuotes(pv->GetMotherLogical()->GetName())) 425 { << 438 << " " << axisName 426 (*theFile) << " " << width << " " << off << 439 << " " << nReplicas; 427 } << 440 if( axis != kPhi ) >> 441 { >> 442 (*theFile) >> 443 << " " << width >> 444 << " " << offset << G4endl; >> 445 } 428 else 446 else 429 { 447 { 430 (*theFile) << " " << width / deg << "*de << 448 (*theFile) 431 << " " << offset / deg << "*d << 449 << " " << width/deg << "*deg" >> 450 << " " << offset/deg << "*deg" << G4endl; 432 } 451 } 433 452 434 thePhysVols[fullname] = pv; 453 thePhysVols[fullname] = pv; 435 } 454 } 436 } 455 } 437 456 438 // ------------------------------------------- << 457 439 G4String G4tgbGeometryDumper::DumpLogVol(G4Log << 458 //------------------------------------------------------------------------ 440 const << 459 G4String 441 G4VSo << 460 G4tgbGeometryDumper::DumpLogVol( G4LogicalVolume* lv, G4String extraName, 442 G4Mat << 461 G4VSolid* solid, G4Material* mate ) 443 { 462 { 444 G4String lvName; 463 G4String lvName; 445 << 464 446 if(extraName == "") //--- take out the '_re << 465 if( extraName == "" ) //--- take out the '_refl' in the name 447 { 466 { 448 lvName = GetObjectName(lv, theLogVols); << 467 lvName = GetObjectName(lv,theLogVols); 449 } << 468 } 450 else << 469 else 451 { 470 { 452 lvName = lv->GetName() + extraName; << 471 lvName = lv->GetName()+extraName; 453 } 472 } 454 473 455 if(theLogVols.find(lvName) != theLogVols.cen << 474 if( theLogVols.find( lvName ) != theLogVols.end() ) // alredy dumped 456 { 475 { 457 return lvName; 476 return lvName; 458 } 477 } 459 478 460 if(solid == nullptr) << 479 if( !solid ) { solid = lv->GetSolid(); } 461 { << 462 solid = lv->GetSolid(); << 463 } << 464 480 465 //---- Dump solid << 481 //---- Dump solid 466 const G4String& solidName = DumpSolid(solid, << 482 G4String solidName = DumpSolid( solid, extraName ); 467 483 468 //---- Dump material 484 //---- Dump material 469 if(mate == nullptr) << 485 if( !mate ) { mate = lv->GetMaterial(); } 470 { << 486 G4String mateName = DumpMaterial( mate ); 471 mate = lv->GetMaterial(); << 472 } << 473 const G4String& mateName = DumpMaterial(mate << 474 487 475 //---- Dump logical volume (solid + material 488 //---- Dump logical volume (solid + material) 476 (*theFile) << ":VOLU " << SubstituteRefl(Add 489 (*theFile) << ":VOLU " << SubstituteRefl(AddQuotes(lvName)) << " " 477 << SupressRefl(AddQuotes(solidNam << 490 << SupressRefl(AddQuotes(solidName)) 478 << G4endl; << 491 << " " << AddQuotes(mateName) << G4endl; 479 492 480 theLogVols[lvName] = lv; 493 theLogVols[lvName] = lv; 481 494 482 return lvName; 495 return lvName; 483 } 496 } 484 497 485 // ------------------------------------------- << 498 486 G4String G4tgbGeometryDumper::DumpMaterial(G4M << 499 //------------------------------------------------------------------------ >> 500 G4String G4tgbGeometryDumper::DumpMaterial( G4Material* mat ) 487 { 501 { 488 const G4String& mateName = GetObjectName(mat << 502 G4String mateName = GetObjectName(mat,theMaterials); 489 if(theMaterials.find(mateName) != theMateria << 503 if( theMaterials.find( mateName ) != theMaterials.end() ) // alredy dumped 490 { 504 { 491 return mateName; 505 return mateName; 492 } 506 } 493 507 494 std::size_t numElements = mat->GetNumberOfEl << 508 size_t numElements = mat->GetNumberOfElements(); 495 G4double density = mat->GetDensity() / g * << 509 G4double density = mat->GetDensity()/g*cm3; 496 510 >> 511 497 // start tag 512 // start tag 498 // 513 // 499 if(numElements == 1) << 514 if (numElements == 1) 500 { 515 { 501 (*theFile) << ":MATE " << AddQuotes(mateNa << 516 (*theFile) << ":MATE " << AddQuotes(mateName) << " " 502 << mat->GetA() / (g / mole) << << 517 << mat->GetZ() << " " << mat->GetA()/(g/mole) << " " >> 518 << density << G4endl; 503 } 519 } 504 else 520 else 505 { 521 { 506 const G4ElementVector* elems = mat->GetEle 522 const G4ElementVector* elems = mat->GetElementVector(); 507 const G4double* fractions = mat->GetFra 523 const G4double* fractions = mat->GetFractionVector(); 508 for(std::size_t ii = 0; ii < numElements; << 524 for (size_t ii = 0; ii < numElements; ii++) 509 { 525 { 510 DumpElement(const_cast<G4Element*>((*ele << 526 DumpElement( (*elems)[ii] ); 511 } 527 } 512 528 513 (*theFile) << ":MIXT " << AddQuotes(mateNa << 529 (*theFile) << ":MIXT "<< AddQuotes(mateName) << " " 514 << numElements << G4endl; << 530 << density << " " << numElements << G4endl; 515 // close start element tag and get ready t 531 // close start element tag and get ready to do composit "parts" 516 for(std::size_t ii = 0; ii < numElements; << 532 for (size_t ii = 0; ii < numElements; ii++) 517 { 533 { 518 (*theFile) << " " << AddQuotes(GetObje << 534 (*theFile) << " " 519 << " " << fractions[ii] << G4 << 535 << AddQuotes(GetObjectName((*elems)[ii],theElements)) << " " >> 536 << fractions[ii] << G4endl; 520 } 537 } 521 } << 522 538 523 (*theFile) << ":MATE_MEE " << AddQuotes(mate << 524 << mat->GetIonisation()->GetMeanE << 525 << G4endl; << 526 << 527 (*theFile) << ":MATE_TEMPERATURE " << AddQuo << 528 << mat->GetTemperature() / kelvin << 529 << 530 (*theFile) << ":MATE_PRESSURE " << AddQuotes << 531 << mat->GetPressure() / atmospher << 532 << 533 G4State state = mat->GetState(); << 534 G4String stateStr; << 535 switch(state) << 536 { << 537 case kStateUndefined: << 538 stateStr = "Undefined"; << 539 break; << 540 case kStateSolid: << 541 stateStr = "Solid"; << 542 break; << 543 case kStateLiquid: << 544 stateStr = "Liquid"; << 545 break; << 546 case kStateGas: << 547 stateStr = "Gas"; << 548 break; << 549 } 539 } 550 540 551 (*theFile) << ":MATE_STATE " << AddQuotes(ma << 541 (*theFile) << ":MATE_MEE " << AddQuotes(mateName) << " " 552 << G4endl; << 542 << mat->GetIonisation()->GetMeanExcitationEnergy()/eV >> 543 << "*eV" << G4endl; 553 544 554 theMaterials[mateName] = mat; 545 theMaterials[mateName] = mat; 555 546 556 return mateName; 547 return mateName; 557 } 548 } 558 549 559 // ------------------------------------------- << 550 560 void G4tgbGeometryDumper::DumpElement(G4Elemen << 551 //------------------------------------------------------------------------ >> 552 void G4tgbGeometryDumper::DumpElement( G4Element* ele) 561 { 553 { 562 const G4String& elemName = GetObjectName(ele << 554 G4String elemName = GetObjectName(ele,theElements); 563 555 564 if(theElements.find(elemName) != theElements << 556 if( theElements.find( elemName ) != theElements.end() ) // alredy dumped 565 { 557 { 566 return; 558 return; 567 } 559 } 568 560 569 //--- Add symbol name: Material mixtures sto 561 //--- Add symbol name: Material mixtures store the components as elements 570 // (even if the input are materials), but 562 // (even if the input are materials), but without symbol 571 // 563 // 572 G4String symbol = ele->GetSymbol(); 564 G4String symbol = ele->GetSymbol(); 573 if(symbol == "" || symbol == " ") << 565 if( symbol == "" || symbol == " " ) 574 { 566 { 575 symbol = elemName; 567 symbol = elemName; 576 } 568 } 577 569 578 if(ele->GetNumberOfIsotopes() == 0) << 570 if( ele->GetNumberOfIsotopes() == 0 ) 579 { 571 { 580 (*theFile) << ":ELEM " << AddQuotes(elemNa << 572 (*theFile) << ":ELEM " << AddQuotes(elemName) << " " 581 << " " << ele->GetZ() << " " << << 573 << AddQuotes(symbol) << " " << ele->GetZ() << " " 582 << G4endl; << 574 << ele->GetA()/(g/mole) << " " << G4endl; 583 } << 575 } 584 else << 576 else 585 { 577 { 586 const G4IsotopeVector* isots = ele->GetIso 578 const G4IsotopeVector* isots = ele->GetIsotopeVector(); 587 for(std::size_t ii = 0; ii < ele->GetNumbe << 579 for (size_t ii = 0; ii < ele->GetNumberOfIsotopes(); ii++) 588 { 580 { 589 DumpIsotope((*isots)[ii]); << 581 DumpIsotope( (*isots)[ii] ); 590 } 582 } 591 583 592 (*theFile) << ":ELEM_FROM_ISOT " << AddQuo 584 (*theFile) << ":ELEM_FROM_ISOT " << AddQuotes(elemName) << " " 593 << AddQuotes(symbol) << " " << 585 << AddQuotes(symbol) << " " << ele->GetNumberOfIsotopes() 594 << G4endl; 586 << G4endl; 595 const G4double* fractions = ele->GetRelati << 587 const G4double* fractions = ele->GetRelativeAbundanceVector(); 596 for(std::size_t ii = 0; ii < ele->GetNumbe << 588 for (size_t ii = 0; ii < ele->GetNumberOfIsotopes(); ii++) 597 { 589 { 598 (*theFile) << " " << AddQuotes(GetObje << 590 (*theFile) << " " 599 << " " << fractions[ii] << G4 << 591 << AddQuotes(GetObjectName((*isots)[ii],theIsotopes)) << " " >> 592 << fractions[ii] << G4endl; 600 } 593 } 601 } 594 } 602 theElements[elemName] = ele; 595 theElements[elemName] = ele; 603 } 596 } 604 597 605 // ------------------------------------------- << 598 606 void G4tgbGeometryDumper::DumpIsotope(G4Isotop << 599 //------------------------------------------------------------------------ >> 600 void G4tgbGeometryDumper::DumpIsotope( G4Isotope* isot) 607 { 601 { 608 const G4String& isotName = GetObjectName(iso << 602 G4String isotName = GetObjectName(isot,theIsotopes); 609 if(theIsotopes.find(isotName) != theIsotopes << 603 if( theIsotopes.find( isotName ) != theIsotopes.end() ) // alredy dumped 610 { 604 { 611 return; 605 return; 612 } 606 } 613 607 614 (*theFile) << ":ISOT " << AddQuotes(isotName << 608 (*theFile) << ":ISOT " << AddQuotes(isotName) << " " 615 << isot->GetN() << " " << isot->G << 609 << isot->GetZ() << " " << isot->GetN() << " " 616 << G4endl; << 610 << isot->GetA()/(g/mole) << " " << G4endl; 617 611 618 theIsotopes[isotName] = isot; 612 theIsotopes[isotName] = isot; 619 } 613 } 620 614 621 // ------------------------------------------- << 615 622 G4String G4tgbGeometryDumper::DumpSolid(G4VSol << 616 //------------------------------------------------------------------------ 623 const << 617 G4String G4tgbGeometryDumper::DumpSolid( G4VSolid* solid, >> 618 const G4String& extraName ) 624 { 619 { 625 G4String solidName; 620 G4String solidName; 626 if(extraName == "") << 621 if( extraName == "" ) 627 { 622 { 628 solidName = GetObjectName(solid, theSolids << 623 solidName = GetObjectName(solid,theSolids); 629 } << 624 } 630 else << 625 else 631 { 626 { 632 solidName = solid->GetName() + extraName; << 627 solidName = solid->GetName()+extraName; 633 } 628 } 634 629 635 if(theSolids.find(solidName) != theSolids.ce << 630 if( theSolids.find( solidName ) != theSolids.end() ) // alredy dumped 636 { 631 { 637 return solidName; 632 return solidName; 638 } 633 } 639 634 640 G4String solidType = solid->GetEntityType(); 635 G4String solidType = solid->GetEntityType(); 641 solidType = GetTGSolidType(solidTyp << 636 solidType = GetTGSolidType( solidType ); 642 << 637 643 if(solidType == "UNIONSOLID") << 638 if (solidType == "UNIONSOLID") 644 { << 645 DumpBooleanVolume("UNION", solid); << 646 } << 647 else if(solidType == "SUBTRACTIONSOLID") << 648 { << 649 DumpBooleanVolume("SUBTRACTION", solid); << 650 } << 651 else if(solidType == "INTERSECTIONSOLID") << 652 { << 653 DumpBooleanVolume("INTERSECTION", solid); << 654 } << 655 else if(solidType == "REFLECTEDSOLID") << 656 { 639 { >> 640 DumpBooleanVolume( "UNION", solid ); >> 641 >> 642 } else if (solidType == "SUBTRACTIONSOLID") { >> 643 DumpBooleanVolume( "SUBTRACTION", solid ); >> 644 >> 645 } else if (solidType == "INTERSECTIONSOLID") { >> 646 DumpBooleanVolume( "INTERSECTION", solid ); >> 647 >> 648 } else if (solidType == "REFLECTEDSOLID") { 657 G4ReflectedSolid* solidrefl = dynamic_cast 649 G4ReflectedSolid* solidrefl = dynamic_cast<G4ReflectedSolid*>(solid); 658 if(solidrefl == nullptr) << 650 if (!solidrefl) 659 { 651 { 660 G4Exception("G4tgbGeometryDumper::DumpSo << 652 G4Exception("G4tgbGeometryDumper::DumpSolid()", 661 FatalException, "Invalid ref << 653 "InvalidType", FatalException, "Invalid reflected solid!"); 662 return solidName; 654 return solidName; 663 } 655 } 664 G4VSolid* solidori = solidrefl->GetConstit 656 G4VSolid* solidori = solidrefl->GetConstituentMovedSolid(); 665 DumpSolid(solidori); << 657 DumpSolid( solidori ); 666 } << 667 else if(solidType == "MULTIUNION") << 668 { << 669 DumpMultiUnionVolume(solid); << 670 } << 671 else if(solidType == "SCALEDSOLID") << 672 { << 673 DumpScaledVolume(solid); << 674 } 658 } 675 else 659 else 676 { 660 { 677 (*theFile) << ":SOLID " << AddQuotes(solid 661 (*theFile) << ":SOLID " << AddQuotes(solidName) << " "; 678 (*theFile) << AddQuotes(solidType) << " "; 662 (*theFile) << AddQuotes(solidType) << " "; 679 DumpSolidParams( solid ); 663 DumpSolidParams( solid ); 680 theSolids[solidName] = solid; 664 theSolids[solidName] = solid; 681 } 665 } 682 666 683 return solidName; 667 return solidName; 684 } 668 } 685 669 686 // ------------------------------------------- << 670 687 void G4tgbGeometryDumper::DumpBooleanVolume(co << 671 //------------------------------------------------------------------------ 688 G4 << 672 void G4tgbGeometryDumper::DumpBooleanVolume( const G4String& solidType, 689 { << 673 G4VSolid* so ) 690 G4BooleanSolid* bso = dynamic_cast<G4Boolean << 674 { 691 if(bso == nullptr) << 675 G4BooleanSolid * bso = dynamic_cast < G4BooleanSolid * > (so); 692 { << 676 if (!bso) { return; } 693 return; << 677 G4VSolid* solid0 = bso->GetConstituentSolid( 0 ); 694 } << 678 G4VSolid* solid1 = bso->GetConstituentSolid( 1 ); 695 G4VSolid* solid0 = bso->GetConst << 679 G4DisplacedSolid* solid1Disp = 0; 696 G4VSolid* solid1 = bso->GetConst << 680 G4bool displaced = dynamic_cast<G4DisplacedSolid*>(solid1); 697 G4DisplacedSolid* solid1Disp = nullptr; << 681 if( displaced ) 698 G4bool displaced = dynamic_cast< << 699 if(displaced) << 700 { 682 { 701 solid1Disp = dynamic_cast<G4DisplacedSolid 683 solid1Disp = dynamic_cast<G4DisplacedSolid*>(solid1); 702 if(solid1Disp != nullptr) << 684 if (solid1Disp) { solid1 = solid1Disp->GetConstituentMovedSolid(); } 703 { << 704 solid1 = solid1Disp->GetConstituentMoved << 705 } << 706 else << 707 { << 708 return; << 709 } << 710 } 685 } 711 DumpSolid(solid0); << 686 DumpSolid( solid0 ); 712 DumpSolid(solid1); << 687 DumpSolid( solid1 ); 713 688 714 G4String rotName; 689 G4String rotName; 715 G4ThreeVector pos; 690 G4ThreeVector pos; 716 if(displaced) << 691 if( displaced ) 717 { 692 { 718 pos = solid1Disp->GetObjectTranslation(); << 693 pos = solid1Disp->GetObjectTranslation(); // translation is of mother frame 719 rotName = DumpRotationMatrix(new G4Rotatio << 694 rotName = DumpRotationMatrix( new G4RotationMatrix( (solid1Disp-> 720 (solid1Disp->GetTransform().NetRotation( << 695 GetTransform().NetRotation()).inverse() ) ); 721 } 696 } 722 else // no displacement 697 else // no displacement 723 { 698 { 724 rotName = DumpRotationMatrix(new G4Rotatio << 699 rotName = DumpRotationMatrix( new G4RotationMatrix ); 725 pos = G4ThreeVector(); << 700 pos = G4ThreeVector(); 726 } 701 } 727 702 728 const G4String& bsoName = GetObjectName(so, << 703 G4String bsoName = GetObjectName(so,theSolids); 729 if(theSolids.find(bsoName) != theSolids.cend << 704 if( theSolids.find( bsoName ) != theSolids.end() ) return; // alredy dumped 730 const G4String& solid0Name = FindSolidName(s << 705 G4String solid0Name = FindSolidName( solid0 ); 731 const G4String& solid1Name = FindSolidName(s << 706 G4String solid1Name = FindSolidName( solid1 ); 732 << 707 733 (*theFile) << ":SOLID " << AddQuotes(bsoName << 708 (*theFile) << ":SOLID " 734 << " " << AddQuotes(solid0Name) < << 709 << AddQuotes(bsoName) << " " 735 << " " << AddQuotes(rotName) << " << 710 << AddQuotes(solidType) << " " 736 << approxTo0(pos.y()) << " " << a << 711 << AddQuotes(solid0Name) << " " 737 << G4endl; << 712 << AddQuotes(solid1Name) << " " >> 713 << AddQuotes(rotName) << " " >> 714 << approxTo0(pos.x()) << " " >> 715 << approxTo0(pos.y()) << " " >> 716 << approxTo0(pos.z()) << " " << G4endl; 738 717 739 theSolids[bsoName] = bso; 718 theSolids[bsoName] = bso; 740 } 719 } 741 720 742 // ------------------------------------------- << 743 void G4tgbGeometryDumper::DumpMultiUnionVolume << 744 { << 745 const G4MultiUnion* muun = dynamic_cast<cons << 746 if(muun != nullptr) << 747 { << 748 G4int nSolids = muun->GetNumberOfSolids( << 749 std::vector<G4String> rotList; << 750 for( G4int iso = 0; iso < nSolids; iso++ << 751 G4Transform3D trans = muun->GetTransformatio << 752 const G4String& rotName = DumpRotationMatrix << 753 rotList.push_back(rotName); << 754 G4VSolid* solN = muun->GetSolid(iso); << 755 DumpSolid(solN); << 756 } << 757 const G4String& bsoName = GetObjectName( << 758 (*theFile) << ":SOLID " << AddQuotes(bso << 759 << nSolids; << 760 << 761 for( G4int iso = 0; iso < nSolids; ++iso << 762 G4VSolid* solN = muun->GetSolid(iso); << 763 G4Transform3D trans = muun->GetTransformatio << 764 G4ThreeVector pos = trans.getTranslation(); << 765 (*theFile) << " " << solN->GetName() << 766 << " " << " " << rotList[iso] << 767 << " " << approxTo0(pos.x()) << 768 << " " << approxTo0(pos.y()) << 769 << " " << approxTo0(pos.z()); << 770 } << 771 (*theFile) << G4endl; << 772 << 773 } << 774 } << 775 721 776 // ------------------------------------------- << 722 //------------------------------------------------------------------------ 777 void G4tgbGeometryDumper::DumpScaledVolume( G4 << 723 void G4tgbGeometryDumper::DumpSolidParams( G4VSolid * so) 778 { 724 { 779 const G4ScaledSolid* ssol = dynamic_cast<con << 725 std::vector<G4double> params = GetSolidParams( so ); 780 if(ssol != nullptr) << 726 for( size_t ii = 0 ; ii < params.size(); ii++ ) 781 { << 727 { 782 G4VSolid* unscaledSolid = ssol->GetUnsca << 728 (*theFile) << params[ii] << " " ; 783 G4Scale3D scaleTransf = ssol->GetScaleTr << 784 G4String bsoName = GetObjectName(const_c << 785 (*theFile) << ":SOLID " << AddQuotes(bso << 786 << unscaledSolid->GetName() << " " << 787 << scaleTransf.xx() << " " << 788 << scaleTransf.yy() << " " << 789 << scaleTransf.zz() << G4endl; << 790 } << 791 } << 792 << 793 // ------------------------------------------- << 794 void G4tgbGeometryDumper::DumpSolidParams(G4VS << 795 { << 796 std::vector<G4double> params = GetSolidParam << 797 for(std::size_t ii = 0; ii < params.size(); << 798 { << 799 (*theFile) << params[ii] << " "; << 800 } 729 } 801 (*theFile) << G4endl; 730 (*theFile) << G4endl; 802 } 731 } 803 732 804 // ------------------------------------------- << 733 805 std::vector<G4double> G4tgbGeometryDumper::Get << 734 //------------------------------------------------------------------------ >> 735 std::vector<G4double> G4tgbGeometryDumper::GetSolidParams( const G4VSolid * so) 806 { 736 { 807 std::vector<G4double> params; 737 std::vector<G4double> params; 808 738 809 G4String solidType = so->GetEntityType(); 739 G4String solidType = so->GetEntityType(); 810 solidType = GetTGSolidType(solidTyp << 740 solidType = GetTGSolidType( solidType ); 811 741 812 if(solidType == "BOX") << 742 if (solidType == "BOX") { 813 { << 743 const G4Box * sb = dynamic_cast < const G4Box*>(so); 814 const G4Box* sb = dynamic_cast<const G4Box << 744 if (sb) { 815 if(sb != nullptr) << 745 params.push_back( sb->GetXHalfLength() ); 816 { << 746 params.push_back( sb->GetYHalfLength() ); 817 params.push_back(sb->GetXHalfLength()); << 747 params.push_back( sb->GetZHalfLength() ); 818 params.push_back(sb->GetYHalfLength()); << 748 } 819 params.push_back(sb->GetZHalfLength()); << 749 } else if (solidType == "TUBS") { 820 } << 750 const G4Tubs * tu = dynamic_cast < const G4Tubs * > (so); 821 } << 751 if (tu) { 822 else if(solidType == "TUBS") << 752 params.push_back( tu->GetInnerRadius() ); 823 { << 753 params.push_back( tu->GetOuterRadius() ); 824 const G4Tubs* tu = dynamic_cast<const G4Tu << 754 params.push_back( tu->GetZHalfLength() ); 825 if(tu != nullptr) << 755 params.push_back( tu->GetStartPhiAngle()/deg ); 826 { << 756 params.push_back( tu->GetDeltaPhiAngle()/deg ); 827 params.push_back(tu->GetInnerRadius()); << 757 } 828 params.push_back(tu->GetOuterRadius()); << 758 } else if (solidType == "TRAP") { 829 params.push_back(tu->GetZHalfLength()); << 759 const G4Trap * trp = dynamic_cast < const G4Trap * > (so); 830 params.push_back(tu->GetStartPhiAngle() << 760 if (trp) { 831 params.push_back(tu->GetDeltaPhiAngle() << 832 } << 833 } << 834 else if(solidType == "TRAP") << 835 { << 836 const G4Trap* trp = dynamic_cast<const G4T << 837 if(trp != nullptr) << 838 { << 839 G4ThreeVector symAxis(trp->GetSymAxis()) 761 G4ThreeVector symAxis(trp->GetSymAxis()); 840 params.push_back(trp->GetZHalfLength()); << 762 G4double theta = symAxis.theta()/deg; 841 params.push_back(symAxis.theta() / deg); << 763 G4double phi = symAxis.phi()/deg; 842 params.push_back(symAxis.phi() / deg); << 764 params.push_back( trp->GetZHalfLength() ); 843 params.push_back(trp->GetYHalfLength1()) << 765 params.push_back( theta ); 844 params.push_back(trp->GetXHalfLength1()) << 766 params.push_back( phi); 845 params.push_back(trp->GetXHalfLength2()) << 767 params.push_back( trp->GetYHalfLength1() ); 846 params.push_back(std::atan(trp->GetTanAl << 768 params.push_back( trp->GetXHalfLength1() ); 847 params.push_back(trp->GetYHalfLength2()) << 769 params.push_back( trp->GetXHalfLength2() ); 848 params.push_back(trp->GetXHalfLength3()) << 770 params.push_back( std::atan(trp->GetTanAlpha1())/deg ); 849 params.push_back(trp->GetXHalfLength4()) << 771 params.push_back( trp->GetYHalfLength2() ); 850 params.push_back(std::atan(trp->GetTanAl << 772 params.push_back( trp->GetXHalfLength3() ); 851 } << 773 params.push_back( trp->GetXHalfLength4() ); 852 } << 774 params.push_back( std::atan(trp->GetTanAlpha2())/deg ); 853 else if(solidType == "TRD") << 775 } 854 { << 776 } else if (solidType == "TRD") { 855 const G4Trd* tr = dynamic_cast<const G4Trd << 777 const G4Trd * tr = dynamic_cast < const G4Trd * > (so); 856 if(tr != nullptr) << 778 if (tr) { 857 { << 779 params.push_back( tr->GetXHalfLength1() ); 858 params.push_back(tr->GetXHalfLength1()); << 780 params.push_back( tr->GetXHalfLength2() ); 859 params.push_back(tr->GetXHalfLength2()); << 781 params.push_back( tr->GetYHalfLength1() ); 860 params.push_back(tr->GetYHalfLength1()); << 782 params.push_back( tr->GetYHalfLength2() ); 861 params.push_back(tr->GetYHalfLength2()); << 783 params.push_back( tr->GetZHalfLength()); 862 params.push_back(tr->GetZHalfLength()); << 784 } >> 785 } else if (solidType == "PARA") { >> 786 const G4Para * para = dynamic_cast < const G4Para * > (so); >> 787 if (para) { >> 788 G4double phi = 0.; >> 789 if(para->GetSymAxis().z()!=1.0) >> 790 { phi = std::atan(para->GetSymAxis().y()/para->GetSymAxis().x()); } >> 791 params.push_back( para->GetXHalfLength()); >> 792 params.push_back( para->GetYHalfLength()); >> 793 params.push_back( para->GetZHalfLength()); >> 794 params.push_back( std::atan(para->GetTanAlpha())/deg); >> 795 params.push_back( std::acos(para->GetSymAxis().z())/deg); >> 796 params.push_back( phi/deg); >> 797 } >> 798 } else if (solidType == "CONS") { >> 799 const G4Cons * cn = dynamic_cast < const G4Cons * > (so); >> 800 if (cn) { >> 801 params.push_back( cn->GetInnerRadiusMinusZ() ); >> 802 params.push_back( cn->GetOuterRadiusMinusZ() ); >> 803 params.push_back( cn->GetInnerRadiusPlusZ() ); >> 804 params.push_back( cn->GetOuterRadiusPlusZ() ); >> 805 params.push_back( cn->GetZHalfLength() ); >> 806 params.push_back( cn->GetStartPhiAngle()/deg ); >> 807 params.push_back( cn->GetDeltaPhiAngle()/deg ); >> 808 } >> 809 } else if (solidType == "SPHERE") { >> 810 const G4Sphere * sphere = dynamic_cast < const G4Sphere * > (so); >> 811 if (sphere) { >> 812 params.push_back( sphere->GetInnerRadius()); >> 813 params.push_back( sphere->GetOuterRadius()); >> 814 params.push_back( sphere->GetStartPhiAngle()/deg); >> 815 params.push_back( sphere->GetDeltaPhiAngle()/deg); >> 816 params.push_back( sphere->GetStartThetaAngle()/deg); >> 817 params.push_back( sphere->GetDeltaThetaAngle()/deg); >> 818 } >> 819 } else if (solidType == "ORB") { >> 820 const G4Orb * orb = dynamic_cast < const G4Orb * > (so); >> 821 if (orb) { >> 822 params.push_back( orb->GetRadius()); >> 823 } >> 824 } else if (solidType == "TORUS") { >> 825 const G4Torus * torus = dynamic_cast < const G4Torus * > (so); >> 826 if (torus) { >> 827 params.push_back( torus->GetRmin()); >> 828 params.push_back( torus->GetRmax()); >> 829 params.push_back( torus->GetRtor()); >> 830 params.push_back( torus->GetSPhi()/deg); >> 831 params.push_back( torus->GetDPhi()/deg); 863 } 832 } 864 } << 833 } else if (solidType == "POLYCONE") { 865 else if(solidType == "PARA") << 866 { << 867 const G4Para* para = dynamic_cast<const G4 << 868 if(para != nullptr) << 869 { << 870 G4ThreeVector symAxis(para->GetSymAxis() << 871 params.push_back(para->GetXHalfLength()) << 872 params.push_back(para->GetYHalfLength()) << 873 params.push_back(para->GetZHalfLength()) << 874 params.push_back(std::atan(para->GetTanA << 875 params.push_back(symAxis.theta() / deg); << 876 params.push_back(symAxis.phi() / deg); << 877 } << 878 } << 879 else if(solidType == "CONS") << 880 { << 881 const G4Cons* cn = dynamic_cast<const G4Co << 882 if(cn != nullptr) << 883 { << 884 params.push_back(cn->GetInnerRadiusMinus << 885 params.push_back(cn->GetOuterRadiusMinus << 886 params.push_back(cn->GetInnerRadiusPlusZ << 887 params.push_back(cn->GetOuterRadiusPlusZ << 888 params.push_back(cn->GetZHalfLength()); << 889 params.push_back(cn->GetStartPhiAngle() << 890 params.push_back(cn->GetDeltaPhiAngle() << 891 } << 892 } << 893 else if(solidType == "SPHERE") << 894 { << 895 const G4Sphere* sphere = dynamic_cast<cons << 896 if(sphere != nullptr) << 897 { << 898 params.push_back(sphere->GetInnerRadius( << 899 params.push_back(sphere->GetOuterRadius( << 900 params.push_back(sphere->GetStartPhiAngl << 901 params.push_back(sphere->GetDeltaPhiAngl << 902 params.push_back(sphere->GetStartThetaAn << 903 params.push_back(sphere->GetDeltaThetaAn << 904 } << 905 } << 906 else if(solidType == "ORB") << 907 { << 908 const G4Orb* orb = dynamic_cast<const G4Or << 909 if(orb != nullptr) << 910 { << 911 params.push_back(orb->GetRadius()); << 912 } << 913 } << 914 else if(solidType == "TORUS") << 915 { << 916 const G4Torus* torus = dynamic_cast<const << 917 if(torus != nullptr) << 918 { << 919 params.push_back(torus->GetRmin()); << 920 params.push_back(torus->GetRmax()); << 921 params.push_back(torus->GetRtor()); << 922 params.push_back(torus->GetSPhi() / deg) << 923 params.push_back(torus->GetDPhi() / deg) << 924 } << 925 } << 926 else if(solidType == "POLYCONE") << 927 { << 928 //--- Dump RZ corners, as original paramet 834 //--- Dump RZ corners, as original parameters will not be present 929 // if it was build from RZ corners 835 // if it was build from RZ corners 930 const G4Polycone* plc = dynamic_cast<const << 836 const G4Polycone * pc = dynamic_cast < const G4Polycone * > (so); 931 if(plc != nullptr) << 837 if (pc) { 932 { << 838 G4double angphi = pc->GetStartPhi()/deg; 933 G4double angphi = plc->GetStartPhi() / d << 839 if( angphi > 180*deg ) { angphi -= 360*deg; } 934 if(angphi > 180 * deg) << 840 G4int ncor = pc->GetNumRZCorner(); 935 { << 841 params.push_back( angphi ); 936 angphi -= 360 * deg; << 842 params.push_back( pc->GetOriginalParameters()->Opening_angle/deg ); 937 } << 843 params.push_back( ncor ); 938 G4double endphi = plc->GetEndPhi() / deg << 844 939 if(endphi > 180 * deg) << 845 for( G4int ii = 0; ii < ncor; ii++ ) 940 { << 941 endphi -= 360 * deg; << 942 } << 943 params.push_back(angphi); << 944 params.push_back(endphi - angphi); << 945 // params.push_back(plc->GetOrigina << 946 G4int ncor = plc->GetNumRZCorner(); << 947 params.push_back(ncor); << 948 << 949 for(G4int ii = 0; ii < ncor; ++ii) << 950 { << 951 params.push_back(plc->GetCorner(ii).r) << 952 params.push_back(plc->GetCorner(ii).z) << 953 } << 954 } << 955 } << 956 else if(solidType == "GENERICPOLYCONE") << 957 { << 958 //--- Dump RZ corners << 959 const G4GenericPolycone* plc = dynamic_cas << 960 if(plc != nullptr) << 961 { << 962 G4double angphi = plc->GetStartPhi() / d << 963 if(angphi > 180 * deg) << 964 { << 965 angphi -= 360 * deg; << 966 } << 967 G4double endphi = plc->GetEndPhi() / deg << 968 if(endphi > 180 * deg) << 969 { 846 { 970 endphi -= 360 * deg; << 847 params.push_back( pc->GetCorner(ii).r ); 971 } << 848 params.push_back( pc->GetCorner(ii).z ); 972 params.push_back(angphi); << 973 params.push_back(endphi - angphi); << 974 G4int ncor = plc->GetNumRZCorner(); << 975 params.push_back(ncor); << 976 << 977 for(G4int ii = 0; ii < ncor; ++ii) << 978 { << 979 params.push_back(plc->GetCorner(ii).r) << 980 params.push_back(plc->GetCorner(ii).z) << 981 } 849 } 982 } 850 } 983 } << 851 } else if (solidType == "POLYHEDRA") { 984 else if(solidType == "POLYHEDRA") << 985 { << 986 //--- Dump RZ corners, as original paramet 852 //--- Dump RZ corners, as original parameters will not be present 987 // if it was build from RZ corners 853 // if it was build from RZ corners 988 const G4Polyhedra* ph = (dynamic_cast<cons << 854 const G4Polyhedra * ph = (dynamic_cast < const G4Polyhedra * > (so)); 989 if(ph != nullptr) << 855 if (ph) { 990 { << 856 G4double angphi = ph->GetStartPhi()/deg; 991 G4double angphi = ph->GetStartPhi() / de << 857 if( angphi > 180*deg ) angphi -= 360*deg; 992 if(angphi > 180 * deg) << 993 angphi -= 360 * deg; << 994 858 995 G4int ncor = ph->GetNumRZCorner(); 859 G4int ncor = ph->GetNumRZCorner(); >> 860 >> 861 params.push_back( angphi ); >> 862 params.push_back( ph->GetOriginalParameters()->Opening_angle/deg ); >> 863 params.push_back( ph->GetNumSide() ); >> 864 params.push_back( ncor ); 996 865 997 params.push_back(angphi); << 866 for( G4int ii = 0; ii < ncor; ii++ ) 998 params.push_back(ph->GetOriginalParamete << 999 params.push_back(ph->GetNumSide()); << 1000 params.push_back(ncor); << 1001 << 1002 for(G4int ii = 0; ii < ncor; ++ii) << 1003 { 867 { 1004 params.push_back(ph->GetCorner(ii).r) << 868 params.push_back( ph->GetCorner(ii).r ); 1005 params.push_back(ph->GetCorner(ii).z) << 869 params.push_back( ph->GetCorner(ii).z ); 1006 } 870 } 1007 } 871 } 1008 } << 872 } else if (solidType == "ELLIPTICALTUBE") { 1009 else if(solidType == "ELLIPTICALTUBE") << 873 const G4EllipticalTube * eltu = 1010 { << 874 dynamic_cast < const G4EllipticalTube * > (so); 1011 const G4EllipticalTube* eltu = dynamic_ca << 875 if (eltu) { 1012 if(eltu != nullptr) << 876 params.push_back( eltu->GetDx()); 1013 { << 877 params.push_back( eltu->GetDy()); 1014 params.push_back(eltu->GetDx()); << 878 params.push_back( eltu->GetDz()); 1015 params.push_back(eltu->GetDy()); << 879 } 1016 params.push_back(eltu->GetDz()); << 880 } else if (solidType == "ELLIPSOID" ){ 1017 } << 881 const G4Ellipsoid* dso = dynamic_cast < const G4Ellipsoid * > (so); 1018 } << 882 if (dso) { 1019 else if(solidType == "ELLIPSOID") << 883 params.push_back( dso->GetSemiAxisMax(0) ); 1020 { << 884 params.push_back( dso->GetSemiAxisMax(1) ); 1021 const G4Ellipsoid* dso = dynamic_cast<con << 885 params.push_back( dso->GetSemiAxisMax(2) ); 1022 if(dso != nullptr) << 886 params.push_back( dso->GetZBottomCut() ); 1023 { << 887 params.push_back( dso->GetZTopCut() ); 1024 params.push_back(dso->GetSemiAxisMax(0) << 888 } 1025 params.push_back(dso->GetSemiAxisMax(1) << 889 } else if (solidType == "ELLIPTICAL_CONE") { 1026 params.push_back(dso->GetSemiAxisMax(2) << 890 const G4EllipticalCone * elco = 1027 params.push_back(dso->GetZBottomCut()); << 891 dynamic_cast < const G4EllipticalCone * > (so); 1028 params.push_back(dso->GetZTopCut()); << 892 if (elco) { 1029 } << 893 params.push_back( elco-> GetSemiAxisX() ); 1030 } << 894 params.push_back( elco-> GetSemiAxisY() ); 1031 else if(solidType == "ELLIPTICAL_CONE") << 895 params.push_back( elco-> GetZMax() ); 1032 { << 896 params.push_back( elco-> GetZTopCut() ); 1033 const G4EllipticalCone* elco = dynamic_ca << 897 } 1034 if(elco != nullptr) << 898 } else if (solidType == "HYPE") { 1035 { << 899 const G4Hype* hype = dynamic_cast < const G4Hype * > (so); 1036 params.push_back(elco->GetSemiAxisX()); << 900 if (hype) { 1037 params.push_back(elco->GetSemiAxisY()); << 901 params.push_back( hype->GetInnerRadius()); 1038 params.push_back(elco->GetZMax()); << 902 params.push_back( hype->GetOuterRadius()); 1039 params.push_back(elco->GetZTopCut()); << 903 params.push_back( hype->GetInnerStereo()/deg); 1040 } << 904 params.push_back( hype->GetOuterStereo()/deg); 1041 } << 905 params.push_back( 2*hype->GetZHalfLength()); 1042 else if(solidType == "HYPE") << 906 } 1043 { << 907 // } else if( solidType == "TET" ) { 1044 const G4Hype* hype = dynamic_cast<const G << 908 1045 if(hype != nullptr) << 909 } else if( solidType == "TWISTEDBOX" ) { 1046 { << 910 const G4TwistedBox* tbox = dynamic_cast < const G4TwistedBox * > (so); 1047 params.push_back(hype->GetInnerRadius() << 911 if (tbox) { 1048 params.push_back(hype->GetOuterRadius() << 912 params.push_back( tbox->GetPhiTwist()/deg ); 1049 params.push_back(hype->GetInnerStereo() << 913 params.push_back( tbox->GetXHalfLength() ); 1050 params.push_back(hype->GetOuterStereo() << 914 params.push_back( tbox->GetYHalfLength() ); 1051 params.push_back(2 * hype->GetZHalfLeng << 915 params.push_back( tbox->GetZHalfLength() ); 1052 } << 916 } 1053 // } else if( solidType == "TET" ) { << 917 } else if( solidType == "TWISTEDTRAP" ) { 1054 } << 918 const G4TwistedTrap * ttrap = dynamic_cast < const G4TwistedTrap * > (so); 1055 else if(solidType == "TWISTEDBOX") << 919 if (ttrap) { 1056 { << 920 params.push_back( ttrap->GetPhiTwist()/deg ); 1057 const G4TwistedBox* tbox = dynamic_cast<c << 921 params.push_back( ttrap->GetZHalfLength() ); 1058 if(tbox != nullptr) << 922 params.push_back( ttrap->GetPolarAngleTheta()/deg ); 1059 { << 923 params.push_back( ttrap->GetAzimuthalAnglePhi()/deg ); 1060 params.push_back(tbox->GetPhiTwist() / << 924 params.push_back( ttrap->GetY1HalfLength() ); 1061 params.push_back(tbox->GetXHalfLength() << 925 params.push_back( ttrap->GetX1HalfLength() ); 1062 params.push_back(tbox->GetYHalfLength() << 926 params.push_back( ttrap->GetX2HalfLength() ); 1063 params.push_back(tbox->GetZHalfLength() << 927 params.push_back( ttrap->GetY2HalfLength() ); 1064 } << 928 params.push_back( ttrap->GetX3HalfLength() ); 1065 } << 929 params.push_back( ttrap->GetX4HalfLength() ); 1066 else if(solidType == "TWISTEDTRAP") << 930 params.push_back( ttrap->GetTiltAngleAlpha()/deg ); 1067 { << 931 } 1068 const G4TwistedTrap* ttrap = dynamic_cast << 932 } else if( solidType == "TWISTEDTRD" ) { 1069 if(ttrap != nullptr) << 933 const G4TwistedTrd * ttrd = dynamic_cast < const G4TwistedTrd * > (so); 1070 { << 934 if (ttrd) { 1071 params.push_back(ttrap->GetPhiTwist() / << 935 params.push_back( ttrd->GetX1HalfLength()); 1072 params.push_back(ttrap->GetZHalfLength( << 936 params.push_back( ttrd->GetX2HalfLength() ); 1073 params.push_back(ttrap->GetPolarAngleTh << 937 params.push_back( ttrd->GetY1HalfLength() ); 1074 params.push_back(ttrap->GetAzimuthalAng << 938 params.push_back( ttrd->GetY2HalfLength() ); 1075 params.push_back(ttrap->GetY1HalfLength << 939 params.push_back( ttrd->GetZHalfLength() ); 1076 params.push_back(ttrap->GetX1HalfLength << 940 params.push_back( ttrd->GetPhiTwist()/deg ); 1077 params.push_back(ttrap->GetX2HalfLength << 941 } 1078 params.push_back(ttrap->GetY2HalfLength << 942 } else if( solidType == "TWISTEDTUBS" ) { 1079 params.push_back(ttrap->GetX3HalfLength << 943 const G4TwistedTubs * ttub = dynamic_cast < const G4TwistedTubs * > (so); 1080 params.push_back(ttrap->GetX4HalfLength << 944 if (ttub) { 1081 params.push_back(ttrap->GetTiltAngleAlp << 945 params.push_back( ttub->GetInnerRadius() ); 1082 } << 946 params.push_back( ttub->GetOuterRadius() ); 1083 } << 947 params.push_back( ttub->GetZHalfLength() ); 1084 else if(solidType == "TWISTEDTRD") << 948 params.push_back( ttub->GetDPhi()/deg ); 1085 { << 949 params.push_back( ttub->GetPhiTwist()/deg ); 1086 const G4TwistedTrd* ttrd = dynamic_cast<c << 1087 if(ttrd != nullptr) << 1088 { << 1089 params.push_back(ttrd->GetX1HalfLength( << 1090 params.push_back(ttrd->GetX2HalfLength( << 1091 params.push_back(ttrd->GetY1HalfLength( << 1092 params.push_back(ttrd->GetY2HalfLength( << 1093 params.push_back(ttrd->GetZHalfLength() << 1094 params.push_back(ttrd->GetPhiTwist() / << 1095 } << 1096 } << 1097 else if(solidType == "TWISTEDTUBS") << 1098 { << 1099 const G4TwistedTubs* ttub = dynamic_cast< << 1100 if(ttub != nullptr) << 1101 { << 1102 params.push_back(ttub->GetInnerRadius() << 1103 params.push_back(ttub->GetOuterRadius() << 1104 params.push_back(ttub->GetZHalfLength() << 1105 params.push_back(ttub->GetDPhi() / deg) << 1106 params.push_back(ttub->GetPhiTwist() / << 1107 } 950 } 1108 } 951 } 1109 else 952 else 1110 { 953 { 1111 const G4String& ErrMessage = "Solid type << 954 G4String ErrMessage = "Solid type not supported, sorry... " + solidType; 1112 G4Exception("G4tgbGeometryDumper::DumpSol << 955 G4Exception("G4tgbGeometryDumpe::DumpSolidParams()", 1113 FatalException, ErrMessage); << 956 "NotImplemented", FatalException, ErrMessage); 1114 } 957 } 1115 << 958 1116 return params; 959 return params; 1117 } << 960 } >> 961 1118 962 1119 // ------------------------------------------ << 963 //------------------------------------------------------------------------ 1120 G4String G4tgbGeometryDumper::DumpRotationMat << 964 G4String G4tgbGeometryDumper::DumpRotationMatrix( G4RotationMatrix* rotm ) 1121 { 965 { 1122 if(rotm == nullptr) << 966 if (!rotm) { rotm = new G4RotationMatrix(); } 1123 { << 1124 rotm = new G4RotationMatrix(); << 1125 } << 1126 967 1127 G4double de = MatDeterminant(rotm); << 968 G4double de = MatDeterminant(rotm); 1128 G4String rotName = LookForExistingRotation( << 969 G4String rotName = LookForExistingRotation( rotm ); 1129 if(rotName != "") << 970 if( rotName != "" ) { return rotName; } 1130 { << 1131 return rotName; << 1132 } << 1133 971 1134 G4ThreeVector v(1., 1., 1.); << 972 G4ThreeVector v(1.,1.,1.); 1135 if(de < -0.9) // a reflection .... << 973 if (de < -0.9 ) // a reflection .... 1136 { 974 { 1137 (*theFile) << ":ROTM "; 975 (*theFile) << ":ROTM "; 1138 rotName = "RRM"; 976 rotName = "RRM"; 1139 rotName += G4UIcommand::ConvertToString(t 977 rotName += G4UIcommand::ConvertToString(theRotationNumber++); 1140 << 978 1141 (*theFile) << AddQuotes(rotName) << std:: << 979 (*theFile) << AddQuotes(rotName) << std::setprecision(9) << " " 1142 << approxTo0(rotm->xx()) << " << 980 << approxTo0(rotm->xx()) << " " 1143 << approxTo0(rotm->zx()) << " << 981 << approxTo0(rotm->yx()) << " " 1144 << approxTo0(rotm->yy()) << " << 982 << approxTo0(rotm->zx()) << " " 1145 << approxTo0(rotm->xz()) << " << 983 << approxTo0(rotm->xy()) << " " 1146 << approxTo0(rotm->zz()) << G4 << 984 << approxTo0(rotm->yy()) << " " >> 985 << approxTo0(rotm->zy()) << " " >> 986 << approxTo0(rotm->xz()) << " " >> 987 << approxTo0(rotm->yz()) << " " >> 988 << approxTo0(rotm->zz()) << G4endl; 1147 } 989 } 1148 else if(de > 0.9) // a rotation .... << 990 else if(de > 0.9 ) // a rotation .... 1149 { 991 { 1150 (*theFile) << ":ROTM "; 992 (*theFile) << ":ROTM "; 1151 rotName = "RM"; 993 rotName = "RM"; 1152 rotName += G4UIcommand::ConvertToString(t 994 rotName += G4UIcommand::ConvertToString(theRotationNumber++); 1153 << 995 1154 (*theFile) << AddQuotes(rotName) << " " < << 996 (*theFile) << AddQuotes(rotName) << " " 1155 << " " << approxTo0(rotm->phiX << 997 << approxTo0(rotm->thetaX()/deg) << " " 1156 << approxTo0(rotm->thetaY() / << 998 << approxTo0(rotm->phiX()/deg) << " " 1157 << approxTo0(rotm->phiY() / de << 999 << approxTo0(rotm->thetaY()/deg) << " " 1158 << approxTo0(rotm->thetaZ() / << 1000 << approxTo0(rotm->phiY()/deg) << " " 1159 << approxTo0(rotm->phiZ() / de << 1001 << approxTo0(rotm->thetaZ()/deg) << " " >> 1002 << approxTo0(rotm->phiZ()/deg) << G4endl; 1160 } 1003 } 1161 << 1004 1162 theRotMats[rotName] = rotm; 1005 theRotMats[rotName] = rotm; 1163 1006 1164 return rotName; 1007 return rotName; 1165 } 1008 } 1166 1009 1167 // ------------------------------------------ << 1010 >> 1011 //------------------------------------------------------------------------ 1168 std::vector<G4VPhysicalVolume*> 1012 std::vector<G4VPhysicalVolume*> 1169 G4tgbGeometryDumper::GetPVChildren(G4LogicalV << 1013 G4tgbGeometryDumper::GetPVChildren( G4LogicalVolume* lv ) 1170 { 1014 { 1171 G4PhysicalVolumeStore* pvstore = G4Physical 1015 G4PhysicalVolumeStore* pvstore = G4PhysicalVolumeStore::GetInstance(); >> 1016 G4PhysicalVolumeStore::const_iterator ite; 1172 std::vector<G4VPhysicalVolume*> children; 1017 std::vector<G4VPhysicalVolume*> children; 1173 for(auto ite = pvstore->cbegin(); ite != pv << 1018 for( ite = pvstore->begin(); ite != pvstore->end(); ite++ ) 1174 { 1019 { 1175 if((*ite)->GetMotherLogical() == lv) << 1020 if( (*ite)->GetMotherLogical() == lv ) 1176 { 1021 { 1177 children.push_back(*ite); << 1022 children.push_back( *ite ); 1178 #ifdef G4VERBOSE 1023 #ifdef G4VERBOSE 1179 if(G4tgrMessenger::GetVerboseLevel() >= << 1024 if( G4tgrMessenger::GetVerboseLevel() >= 1 ) 1180 { 1025 { 1181 G4cout << " G4tgbGeometryDumper::GetP 1026 G4cout << " G4tgbGeometryDumper::GetPVChildren() - adding children: " 1182 << (*ite)->GetName() << " of " << 1027 << (*ite)->GetName() << " of " << lv->GetName() << G4endl; 1183 } 1028 } 1184 #endif 1029 #endif 1185 } 1030 } 1186 } 1031 } 1187 1032 1188 return children; 1033 return children; 1189 } 1034 } 1190 1035 1191 // ------------------------------------------ << 1036 1192 G4String G4tgbGeometryDumper::GetTGSolidType( << 1037 //------------------------------------------------------------------------ >> 1038 G4String G4tgbGeometryDumper::GetTGSolidType( const G4String& solidType ) 1193 { 1039 { 1194 G4String newsolidType = solidType.substr(2, << 1040 G4String newsolidType = solidType.substr(2,solidType.length() ); 1195 for(G4int ii = 0; ii < (G4int)newsolidType. << 1041 for( size_t ii = 0; ii < newsolidType.length(); ii++ ) 1196 { 1042 { 1197 newsolidType[ii] = (char)std::toupper(new << 1043 newsolidType[ii] = toupper(newsolidType[ii] ); 1198 } 1044 } 1199 return newsolidType; 1045 return newsolidType; 1200 } 1046 } 1201 1047 1202 // ------------------------------------------ << 1048 1203 G4double G4tgbGeometryDumper::MatDeterminant( << 1049 //------------------------------------------------------------------------ >> 1050 G4double G4tgbGeometryDumper::MatDeterminant(G4RotationMatrix * ro) 1204 { 1051 { 1205 G4Rep3x3 r = ro->rep3x3(); << 1052 CLHEP::HepRep3x3 r = ro->rep3x3(); 1206 return r.xx_ * (r.yy_ * r.zz_ - r.zy_ * r.y << 1053 return r.xx_*(r.yy_*r.zz_ - r.zy_*r.yz_) 1207 r.yx_ * (r.xy_ * r.zz_ - r.zy_ * r.x << 1054 - r.yx_*(r.xy_*r.zz_ - r.zy_*r.xz_) 1208 r.zx_ * (r.xy_ * r.yz_ - r.yy_ * r.x << 1055 + r.zx_*(r.xy_*r.yz_ - r.yy_*r.xz_); 1209 } 1056 } 1210 1057 1211 // ------------------------------------------ << 1058 1212 G4double G4tgbGeometryDumper::approxTo0(G4dou << 1059 //----------------------------------------------------------------------- >> 1060 G4double G4tgbGeometryDumper::approxTo0( G4double val ) 1213 { 1061 { 1214 G4double precision = << 1062 G4double precision = G4GeometryTolerance::GetInstance() 1215 G4GeometryTolerance::GetInstance()->GetSu << 1063 ->GetSurfaceTolerance(); 1216 1064 1217 if(std::fabs(val) < precision) << 1065 if( std::fabs(val) < precision ) { val = 0; } 1218 { << 1219 val = 0.0; << 1220 } << 1221 return val; 1066 return val; 1222 } 1067 } 1223 1068 1224 // ------------------------------------------ << 1069 1225 G4String G4tgbGeometryDumper::AddQuotes(const << 1070 //----------------------------------------------------------------------- >> 1071 G4String G4tgbGeometryDumper::AddQuotes( const G4String& str ) 1226 { 1072 { 1227 //--- look if there is a separating blank 1073 //--- look if there is a separating blank 1228 1074 1229 G4bool bBlank = FALSE; 1075 G4bool bBlank = FALSE; 1230 std::size_t siz = str.length(); << 1076 size_t siz = str.length(); 1231 for(std::size_t ii = 0; ii < siz; ++ii) << 1077 for( size_t ii = 0; ii < siz; ii++ ) 1232 { 1078 { 1233 if(str.substr(ii, 1) == " ") << 1079 if( str.substr(ii,1) == " " ) 1234 { 1080 { 1235 bBlank = TRUE; 1081 bBlank = TRUE; 1236 break; 1082 break; 1237 } 1083 } 1238 } 1084 } 1239 G4String str2 = str; 1085 G4String str2 = str; 1240 if(bBlank) << 1086 if( bBlank ) 1241 { 1087 { 1242 str2 = G4String("\"") + str2 + G4String(" 1088 str2 = G4String("\"") + str2 + G4String("\""); 1243 } 1089 } 1244 return str2; 1090 return str2; 1245 } 1091 } 1246 1092 1247 // ------------------------------------------ << 1093 1248 G4String G4tgbGeometryDumper::SupressRefl(G4S << 1094 //------------------------------------------------------------------------ >> 1095 G4String G4tgbGeometryDumper::SupressRefl( G4String name ) 1249 { 1096 { 1250 std::size_t irefl = name.rfind("_refl"); << 1097 G4int irefl = name.rfind("_refl"); 1251 if(irefl != G4String::npos) << 1098 if( irefl != -1 ) 1252 { 1099 { 1253 name = name.substr(0, irefl); << 1100 name = name.substr( 0, irefl ); 1254 } 1101 } 1255 return name; 1102 return name; 1256 } 1103 } 1257 1104 1258 // ------------------------------------------ << 1105 //------------------------------------------------------------------------ 1259 G4String G4tgbGeometryDumper::SubstituteRefl( << 1106 G4String G4tgbGeometryDumper::SubstituteRefl( G4String name ) 1260 { 1107 { 1261 std::size_t irefl = name.rfind("_refl"); << 1108 G4int irefl = name.rfind("_refl"); 1262 if(irefl != G4String::npos) << 1109 if( irefl != -1 ) 1263 { 1110 { 1264 name = name.substr(0, irefl) + "_REFL"; << 1111 name = name.substr( 0, irefl ) + "_REFL"; 1265 } 1112 } 1266 return name; 1113 return name; 1267 } 1114 } 1268 1115 1269 // ------------------------------------------ << 1116 1270 G4String G4tgbGeometryDumper::GetIsotopeName( << 1117 //------------------------------------------------------------------------ >> 1118 G4String G4tgbGeometryDumper::GetIsotopeName( G4Isotope* isot ) 1271 { 1119 { 1272 G4String isotName = isot->GetName(); 1120 G4String isotName = isot->GetName(); 1273 // first look if this is isotope is already 1121 // first look if this is isotope is already dumped, 1274 // with original isotope name or new one 1122 // with original isotope name or new one 1275 // 1123 // 1276 std::map<G4String, G4Isotope*>::const_itera << 1124 std::map<G4String,G4Isotope*>::const_iterator ite; 1277 for(ite = theIsotopes.cbegin(); ite != theI << 1125 for( ite = theIsotopes.begin(); ite != theIsotopes.end(); ite++ ) 1278 { 1126 { 1279 if(isot == (*ite).second) << 1127 if( isot == (*ite).second ) { return (*ite).first; } 1280 { << 1281 return (*ite).first; << 1282 } << 1283 } 1128 } 1284 1129 1285 // Now look if there is another isotope dum 1130 // Now look if there is another isotope dumped with same name, 1286 // and if found add _N to the name 1131 // and if found add _N to the name 1287 // 1132 // 1288 ite = theIsotopes.find(isotName); << 1133 ite = theIsotopes.find( isotName ); 1289 if(ite != theIsotopes.cend()) // Isotope f << 1134 if( ite != theIsotopes.end() ) // Isotope found with same name 1290 { 1135 { 1291 G4Isotope* isotold = (*ite).second; 1136 G4Isotope* isotold = (*ite).second; 1292 if(isot != isotold) // new isotope it is << 1137 if( isot != isotold ) // new isotope it is not the really 1293 { // the same one as i << 1138 { // the same one as isotope found 1294 if(!Same2G4Isotopes(isot, isotold)) << 1139 if( !Same2G4Isotopes(isot, isotold)) 1295 { // if the two have sam << 1140 { // if the two have same data, use the old one 1296 G4int ii = 2; // G4Nist does names i << 1141 G4int ii = 2; // G4Nist does names isotopes of same element 1297 // with same name << 1142 // with same name 1298 for(;; ++ii) << 1143 for(;;ii++) 1299 { 1144 { 1300 const G4String& newIsotName = << 1145 G4String newIsotName = isotName + "_" 1301 isotName + "_" + G4UIcommand::Con << 1146 + G4UIcommand::ConvertToString(ii); 1302 std::map<G4String, G4Isotope*>::con << 1147 std::map<G4String,G4Isotope*>::const_iterator ite2 = 1303 theIsotopes.find(newIsotName); << 1148 theIsotopes.find( newIsotName ); 1304 if(ite2 == theIsotopes.cend()) << 1149 if( ite2 == theIsotopes.end() ) 1305 { 1150 { 1306 isotName = newIsotName; 1151 isotName = newIsotName; 1307 break; 1152 break; 1308 } 1153 } 1309 else 1154 else 1310 { 1155 { 1311 if(Same2G4Isotopes(isot, (*ite2). << 1156 if( Same2G4Isotopes( isot, (*ite2).second ) ) 1312 { 1157 { 1313 isotName = newIsotName; 1158 isotName = newIsotName; 1314 break; 1159 break; 1315 } 1160 } 1316 } 1161 } 1317 } 1162 } 1318 } 1163 } 1319 } 1164 } 1320 } 1165 } 1321 return isotName; 1166 return isotName; 1322 } 1167 } 1323 1168 1324 // ------------------------------------------ << 1169 1325 template <class TYP> << 1170 //------------------------------------------------------------------------ 1326 G4String G4tgbGeometryDumper::GetObjectName( << 1171 template< class TYP > G4String G4tgbGeometryDumper:: 1327 TYP* obj, std::map<G4String, TYP*> objectsD << 1172 GetObjectName( TYP* obj, std::map<G4String,TYP*> objectsDumped ) 1328 { 1173 { 1329 G4String objName = obj->GetName(); 1174 G4String objName = obj->GetName(); 1330 1175 1331 // first look if this is objecy is already 1176 // first look if this is objecy is already dumped, 1332 // with original object name or new one 1177 // with original object name or new one 1333 // 1178 // 1334 typename std::map<G4String, TYP*>::const_it << 1179 typename std::map<G4String,TYP*>::const_iterator ite; 1335 for(ite = objectsDumped.cbegin(); ite != ob << 1180 for( ite = objectsDumped.begin(); ite != objectsDumped.end(); ite++ ) 1336 { 1181 { 1337 if(obj == (*ite).second) << 1182 if( obj == (*ite).second ) { return (*ite).first; } 1338 { << 1339 return (*ite).first; << 1340 } << 1341 } 1183 } 1342 1184 1343 // Now look if there is another object dump 1185 // Now look if there is another object dumped with same name, 1344 // and if found add _N to the name 1186 // and if found add _N to the name 1345 // 1187 // 1346 ite = objectsDumped.find(objName); << 1188 ite = objectsDumped.find( objName ); 1347 1189 1348 if(ite != objectsDumped.cend()) // Object << 1190 if( ite != objectsDumped.end() ) // Object found with same name 1349 { 1191 { 1350 TYP* objold = (*ite).second; 1192 TYP* objold = (*ite).second; 1351 if(obj != objold) // new object it is no << 1193 if( obj != objold ) // new object it is not the really 1352 { // the same one as obj << 1194 { // the same one as object found 1353 G4int ii = 2; 1195 G4int ii = 2; 1354 for(;; ++ii) << 1196 for(;;ii++) 1355 { 1197 { 1356 const G4String& newObjName = objName << 1198 G4String newObjName = objName + "_" + G4UIcommand::ConvertToString(ii); 1357 typename std::map<G4String, TYP*>::co << 1199 typename std::map<G4String,TYP*>::const_iterator ite2 = 1358 objectsDumped.find(newObjName); << 1200 objectsDumped.find( newObjName ); 1359 if(ite2 == objectsDumped.cend()) << 1201 if( ite2 == objectsDumped.end() ) 1360 { 1202 { 1361 objName = newObjName; 1203 objName = newObjName; 1362 break; 1204 break; 1363 } 1205 } 1364 } 1206 } 1365 } 1207 } 1366 } 1208 } 1367 return objName; 1209 return objName; 1368 } 1210 } 1369 1211 1370 // ------------------------------------------ << 1212 1371 G4bool G4tgbGeometryDumper::CheckIfLogVolExis << 1213 //------------------------------------------------------------------------ 1372 << 1214 G4bool G4tgbGeometryDumper::CheckIfLogVolExists( const G4String& name, >> 1215 G4LogicalVolume* pt ) 1373 { 1216 { 1374 if(theLogVols.find(name) != theLogVols.cend << 1217 if( theLogVols.find( name ) != theLogVols.end() ) 1375 { 1218 { 1376 G4LogicalVolume* lvnew = (*(theLogVols.fi 1219 G4LogicalVolume* lvnew = (*(theLogVols.find(name))).second; 1377 if(lvnew != pt) << 1220 if( lvnew != pt ) 1378 { 1221 { 1379 /* 1222 /* 1380 //---- Reflected volumes are repeated 1223 //---- Reflected volumes are repeated 1381 1224 1382 G4ReflectionFactory* reffact = G4Reflec 1225 G4ReflectionFactory* reffact = G4ReflectionFactory::Instance(); 1383 if( !reffact->IsReflected( pt ) && !ref 1226 if( !reffact->IsReflected( pt ) && !reffact->IsReflected( lvnew ) ) 1384 { 1227 { 1385 G4String ErrMessage = "LogVol found b 1228 G4String ErrMessage = "LogVol found but not same as before: " + name; 1386 G4Exception("G4tgbGeometryDumper::Che 1229 G4Exception("G4tgbGeometryDumper::CheckIfLogVolExists()", 1387 "InvalidSetup", FatalExce 1230 "InvalidSetup", FatalException, ErrMessage); 1388 } 1231 } 1389 */ 1232 */ 1390 } 1233 } 1391 return true; << 1234 return 1; 1392 } 1235 } 1393 else 1236 else 1394 { 1237 { 1395 return false; << 1238 return 0; 1396 } 1239 } 1397 } 1240 } 1398 1241 1399 // ------------------------------------------ << 1242 1400 G4bool G4tgbGeometryDumper::CheckIfPhysVolExi << 1243 //----------------------------------------------------------------------- 1401 << 1244 G4bool G4tgbGeometryDumper::CheckIfPhysVolExists( const G4String& name, >> 1245 G4VPhysicalVolume* pt ) 1402 { 1246 { 1403 #ifdef G4VERBOSE 1247 #ifdef G4VERBOSE 1404 if(G4tgrMessenger::GetVerboseLevel() >= 1) << 1248 if( G4tgrMessenger::GetVerboseLevel() >= 1 ) 1405 { 1249 { 1406 G4cout << " G4tgbGeometryDumper::CheckIfP << 1250 G4cout << " G4tgbGeometryDumper::CheckIfPhysVolExists() - " 1407 << G4endl; << 1251 << name << G4endl; 1408 } 1252 } 1409 #endif 1253 #endif 1410 if(thePhysVols.find(name) != thePhysVols.ce << 1254 if( thePhysVols.find( name ) != thePhysVols.end() ) 1411 { 1255 { 1412 if((*(thePhysVols.find(name))).second != << 1256 if( (*(thePhysVols.find(name))).second != pt ) 1413 { 1257 { 1414 // G4String ErrMessage = "Placement fou 1258 // G4String ErrMessage = "Placement found but not same as before: " 1415 // + name; 1259 // + name; 1416 // G4Exception("G4tgbGeometryDumper::Ch 1260 // G4Exception("G4tgbGeometryDumper::CheckIfPhysVolExists()", 1417 // "InvalidSetup", FatalExc 1261 // "InvalidSetup", FatalException, ErrMessage); 1418 G4cerr << " G4tgbGeometryDumper::CheckI 1262 G4cerr << " G4tgbGeometryDumper::CheckIfPhysVolExists () -" 1419 << " Placement found but not sam 1263 << " Placement found but not same as before : " << name << G4endl; 1420 } 1264 } 1421 return true; << 1265 return 1; 1422 } 1266 } 1423 else 1267 else 1424 { 1268 { 1425 return false; << 1269 return 0; 1426 } 1270 } 1427 } 1271 } 1428 1272 1429 // ------------------------------------------ << 1273 >> 1274 //----------------------------------------------------------------------- 1430 G4String 1275 G4String 1431 G4tgbGeometryDumper::LookForExistingRotation( << 1276 G4tgbGeometryDumper::LookForExistingRotation( const G4RotationMatrix* rotm ) 1432 { 1277 { 1433 G4String rmName = ""; 1278 G4String rmName = ""; 1434 1279 1435 for(auto ite = theRotMats.cbegin(); ite != << 1280 std::map<G4String,G4RotationMatrix*>::const_iterator ite; >> 1281 for( ite = theRotMats.begin(); ite != theRotMats.end(); ite++ ) 1436 { 1282 { 1437 if((*ite).second->isNear(*rotm)) << 1283 if( (*ite).second->isNear( *rotm ) ) 1438 { 1284 { 1439 rmName = (*ite).first; 1285 rmName = (*ite).first; 1440 break; 1286 break; 1441 } 1287 } 1442 } 1288 } 1443 return rmName; 1289 return rmName; 1444 } 1290 } 1445 1291 1446 // ------------------------------------------ << 1292 1447 G4bool G4tgbGeometryDumper::Same2G4Isotopes(G << 1293 //------------------------------------------------------------------------ 1448 { << 1294 G4bool 1449 if((isot1->GetZ() != isot2->GetZ()) || (iso << 1295 G4tgbGeometryDumper::Same2G4Isotopes( G4Isotope* isot1, G4Isotope* isot2 ) 1450 (isot1->GetA() != isot2->GetA())) << 1296 { >> 1297 if ( (isot1->GetZ() != isot2->GetZ()) >> 1298 || (isot1->GetN() != isot2->GetN()) >> 1299 || (isot1->GetA() != isot2->GetA()) ) 1451 { 1300 { 1452 return false; << 1301 return 0; 1453 } 1302 } 1454 else 1303 else 1455 { 1304 { 1456 return true; << 1305 return 1; 1457 } 1306 } 1458 } 1307 } 1459 1308 1460 // ------------------------------------------ << 1309 1461 const G4String& G4tgbGeometryDumper::FindSoli << 1310 //------------------------------------------------------------------------ >> 1311 const G4String& G4tgbGeometryDumper::FindSolidName( G4VSolid* solid ) 1462 { 1312 { 1463 std::map<G4String, G4VSolid*>::const_iterat << 1313 std::map<G4String,G4VSolid*>::const_iterator ite; 1464 for(ite = theSolids.cbegin(); ite != theSol << 1314 for( ite = theSolids.begin(); ite != theSolids.end(); ite++ ) 1465 { 1315 { 1466 if(solid == (*ite).second) << 1316 if( solid == (*ite).second ) { return (*ite).first; } 1467 { << 1468 return (*ite).first; << 1469 } << 1470 } 1317 } 1471 1318 1472 if(ite == theSolids.cend()) << 1319 if( ite == theSolids.end() ) 1473 { 1320 { 1474 G4Exception("G4tgbGeometryDumper::FindSol 1321 G4Exception("G4tgbGeometryDumper::FindSolidName()", "ReadError", 1475 FatalException, "Programming 1322 FatalException, "Programming error."); 1476 } 1323 } 1477 return (*ite).first; 1324 return (*ite).first; 1478 } 1325 } 1479 1326