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