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