Geant4 Cross Reference |
1 // ******************************************* 1 // ******************************************************************** 2 // * License and Disclaimer 2 // * License and Disclaimer * 3 // * 3 // * * 4 // * The Geant4 software is copyright of th 4 // * The Geant4 software is copyright of the Copyright Holders of * 5 // * the Geant4 Collaboration. It is provided 5 // * the Geant4 Collaboration. It is provided under the terms and * 6 // * conditions of the Geant4 Software License 6 // * conditions of the Geant4 Software License, included in the file * 7 // * LICENSE and available at http://cern.ch/ 7 // * LICENSE and available at http://cern.ch/geant4/license . These * 8 // * include a list of copyright holders. 8 // * include a list of copyright holders. * 9 // * 9 // * * 10 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing * 11 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this * 12 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, * 13 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its * 14 // * use. Please see the license in the file 14 // * use. Please see the license in the file LICENSE and URL above * 15 // * for the full disclaimer and the limitatio 15 // * for the full disclaimer and the limitation of liability. * 16 // * 16 // * * 17 // * This code implementation is the result 17 // * This code implementation is the result of the scientific and * 18 // * technical work of the GEANT4 collaboratio 18 // * technical work of the GEANT4 collaboration. * 19 // * By using, copying, modifying or distri 19 // * By using, copying, modifying or distributing the software (or * 20 // * any work based on the software) you ag 20 // * any work based on the software) you agree to acknowledge its * 21 // * use in resulting scientific publicati 21 // * use in resulting scientific publications, and indicate your * 22 // * acceptance of all terms of the Geant4 Sof 22 // * acceptance of all terms of the Geant4 Software license. * 23 // ******************************************* 23 // ******************************************************************** 24 // 24 // >> 25 // $Id: G4Molecule.cc 74551 2013-10-14 12:59:14Z gcosmo $ 25 // 26 // 26 // ------------------------------------------- 27 // --------------------------------------------------------------------- 27 // GEANT 4 class header file 28 // GEANT 4 class header file 28 // 29 // 29 // History: first implementation, based on G4 30 // History: first implementation, based on G4DynamicParticle 30 // New dependency : G4VUserTrackInfo 31 // New dependency : G4VUserTrackInformation 31 // 32 // 32 // ---------------- G4Molecule --------- 33 // ---------------- G4Molecule ---------------- 33 // first design&implementation by Alfonso 34 // first design&implementation by Alfonso Mantero, 7 Apr 2009 34 // New developments Alfonso Mantero & Mat 35 // New developments Alfonso Mantero & Mathieu Karamitros 35 // Oct/Nov 2009 Class Name changed to G4M 36 // Oct/Nov 2009 Class Name changed to G4Molecule 36 // Removed dependency from G 37 // Removed dependency from G4DynamicParticle 37 // New constructors : 38 // New constructors : 38 // copy constructor 39 // copy constructor 39 // direct ionized/excited m 40 // direct ionized/excited molecule 40 // New methods : 41 // New methods : 41 // Get : name,atoms' number 42 // Get : name,atoms' number,nb electrons,decayChannel 42 // PrintState //To get the 43 // PrintState //To get the electronic level and the 43 // correspondi 44 // corresponding name of the excitation 44 // Kinematic : 45 // Kinematic : 45 // BuildTrack,GetKineticEne 46 // BuildTrack,GetKineticEnergy,GetDiffusionVelocity 46 // Change the way dynCharge 47 // Change the way dynCharge and eNb is calculated 47 // ------------------------------------------- 48 // --------------------------------------------------------------------- 48 49 49 #include "G4Molecule.hh" 50 #include "G4Molecule.hh" 50 #include "G4MolecularConfiguration.hh" 51 #include "G4MolecularConfiguration.hh" 51 #include "Randomize.hh" 52 #include "Randomize.hh" 52 #include "G4PhysicalConstants.hh" 53 #include "G4PhysicalConstants.hh" 53 #include "G4SystemOfUnits.hh" 54 #include "G4SystemOfUnits.hh" 54 #include "G4Track.hh" 55 #include "G4Track.hh" 55 #include "G4VMoleculeCounter.hh" << 56 #include "G4MoleculeCounter.hh" 56 57 57 using namespace std; 58 using namespace std; 58 59 59 G4Allocator<G4Molecule>*& aMoleculeAllocator() << 60 /*G4ThreadLocal*/ G4double G4Molecule::fgTemperature = 310; // 310*kelvin; 60 { << 61 // 37°C, used to shoot an energy 61 G4ThreadLocalStatic G4Allocator<G4Molecule << 62 return _instance; << 63 } << 64 << 65 //____________________________________________ << 66 62 67 template<> << 63 ITImp(G4Molecule) 68 G4KDNode<G4Molecule>::~G4KDNode() { << 69 fPoint->SetNode(nullptr); << 70 } << 71 64 72 //____________________________________________ << 65 G4ThreadLocal G4Allocator<G4Molecule> *aMoleculeAllocator = 0; 73 66 74 G4Molecule* GetMolecule(const G4Track& track) 67 G4Molecule* GetMolecule(const G4Track& track) 75 { 68 { 76 return (G4Molecule*)(GetIT(track)); 69 return (G4Molecule*)(GetIT(track)); 77 } 70 } 78 71 79 //____________________________________________ << 80 << 81 G4Molecule* GetMolecule(const G4Track* track) 72 G4Molecule* GetMolecule(const G4Track* track) 82 { 73 { 83 return (G4Molecule*)(GetIT(track)); 74 return (G4Molecule*)(GetIT(track)); 84 } 75 } 85 76 86 //____________________________________________ << 87 << 88 G4Molecule* G4Molecule::GetMolecule(const G4Tr << 89 { << 90 return (G4Molecule*)(GetIT(track)); << 91 } << 92 << 93 //____________________________________________ << 94 << 95 void G4Molecule::Print() const 77 void G4Molecule::Print() const 96 { 78 { 97 G4cout << "The user track information is a << 79 G4cout<<"The user track information is a molecule"<<G4endl; 98 } 80 } 99 81 100 //____________________________________________ << 82 G4Molecule::G4Molecule(const G4Molecule& right) : 101 << 83 G4VUserTrackInformation("G4Molecule"), G4IT(right) 102 G4Molecule::G4Molecule(const G4Molecule& right << 103 : G4VUserTrackInformation("G4Molecule") << 104 , G4IT(right) << 105 { 84 { 106 fpMolecularConfiguration = right.fpMolecul << 85 fpMolecularConfiguration = right . fpMolecularConfiguration; 107 } 86 } 108 87 109 //____________________________________________ << 110 << 111 G4Molecule& G4Molecule::operator=(const G4Mole 88 G4Molecule& G4Molecule::operator=(const G4Molecule& right) 112 { 89 { 113 if (&right == this) return *this; << 90 if (&right==this) return *this; 114 fpMolecularConfiguration = right.fpMolecul << 91 fpMolecularConfiguration = right . fpMolecularConfiguration; 115 return *this; 92 return *this; 116 } 93 } 117 94 118 //____________________________________________ << 119 << 120 G4bool G4Molecule::operator==(const G4Molecule 95 G4bool G4Molecule::operator==(const G4Molecule& right) const 121 { 96 { 122 return fpMolecularConfiguration == right.f << 97 if(fpMolecularConfiguration==right.fpMolecularConfiguration) >> 98 { >> 99 return true; >> 100 } >> 101 return false; 123 } 102 } 124 103 125 //____________________________________________ << 126 << 127 G4bool G4Molecule::operator!=(const G4Molecule 104 G4bool G4Molecule::operator!=(const G4Molecule& right) const 128 { 105 { 129 return !(*this == right); 106 return !(*this == right); 130 } 107 } 131 108 132 //____________________________________________ << 109 //////////////////////////////////////////////////////////////////////// 133 /** The two methods below are the most called << 110 /// The two methods below are the most called of the simulation : 134 * compare molecules in the MoleculeStackMana << 111 /// compare molecules in the MoleculeStackManager or in 135 * the InteractionTable << 112 /// the InteractionTable 136 */ << 137 113 138 G4bool G4Molecule::operator<(const G4Molecule& 114 G4bool G4Molecule::operator<(const G4Molecule& right) const 139 { 115 { 140 return fpMolecularConfiguration < right.fp << 116 return fpMolecularConfiguration < right.fpMolecularConfiguration ; 141 } 117 } 142 118 143 //____________________________________________ << 119 //////////////////////////////////////////////////////////////////////// 144 << 120 /** Default molecule builder 145 G4Molecule::G4Molecule() << 121 */ 146 : G4VUserTrackInformation("G4Molecule") << 122 ////////////////////////// >> 123 G4Molecule::G4Molecule() : G4VUserTrackInformation("G4Molecule"), G4IT() >> 124 ////////////////////////// 147 { 125 { 148 fpMolecularConfiguration = nullptr; << 126 fpMolecularConfiguration = 0 ; 149 } 127 } 150 128 151 //____________________________________________ << 129 ////////////////////////// 152 << 153 G4Molecule::~G4Molecule() 130 G4Molecule::~G4Molecule() >> 131 ////////////////////////// 154 { 132 { 155 if (fpTrack != nullptr) << 133 if(fpTrack!=NULL) 156 { 134 { 157 if (G4VMoleculeCounter::Instance()->In << 135 if(G4MoleculeCounter::GetMoleculeCounter()->InUse()) 158 { 136 { 159 G4VMoleculeCounter::Instance()-> << 137 G4MoleculeCounter::GetMoleculeCounter()->RemoveAMoleculeAtTime(*this, 160 RemoveAMoleculeAtTime(fpMolecu << 138 fpTrack->GetGlobalTime()); 161 fpTrack- << 162 &(fpTrac << 163 } 139 } 164 fpTrack = nullptr; << 140 fpTrack = 0; 165 } 141 } 166 fpMolecularConfiguration = nullptr; << 142 fpMolecularConfiguration = 0; 167 } 143 } 168 144 169 //____________________________________________ << 170 /** Build a molecule at ground state according 145 /** Build a molecule at ground state according to a given 171 * G4MoleculeDefinition that can be obtained 146 * G4MoleculeDefinition that can be obtained from G4GenericMoleculeManager 172 */ 147 */ 173 G4Molecule::G4Molecule(G4MoleculeDefinition* p << 148 ////////////////////////// 174 : G4VUserTrackInformation("G4Molecule") << 149 G4Molecule::G4Molecule(G4MoleculeDefinition * moleculeDefinition) : >> 150 G4VUserTrackInformation("G4Molecule"), G4IT() >> 151 ////////////////////////// 175 { 152 { 176 fpMolecularConfiguration = G4MolecularConf << 153 fpMolecularConfiguration = G4MolecularConfiguration::GetMolecularConfiguration(moleculeDefinition); 177 } 154 } 178 155 179 //____________________________________________ << 180 << 181 G4Molecule::G4Molecule(G4MoleculeDefinition* p << 182 { << 183 fpMolecularConfiguration = G4MolecularConf << 184 << 185 } << 186 << 187 //____________________________________________ << 188 /** Build a molecule at a specific excitation/ 156 /** Build a molecule at a specific excitation/ionisation state according 189 * to a ground state that can be obtained fro 157 * to a ground state that can be obtained from G4GenericMoleculeManager. 190 * Put 0 in the second option if this is a io 158 * Put 0 in the second option if this is a ionisation. 191 */ 159 */ 192 G4Molecule::G4Molecule(G4MoleculeDefinition* p << 160 ////////////////////////// 193 G4int OrbitalToFree, << 161 G4Molecule::G4Molecule(G4MoleculeDefinition * moleculeDefinition, G4int OrbitalToFree, G4int OrbitalToFill): 194 G4int OrbitalToFill) << 162 G4VUserTrackInformation("G4Molecule"), G4IT() 195 : G4VUserTrackInformation("G4Molecule") << 163 ////////////////////////// 196 { 164 { 197 if (pMoleculeDefinition->GetGroundStateEle << 165 G4ElectronOccupancy dynElectronOccupancy (*moleculeDefinition->GetGroundStateElectronOccupancy()); 198 { << 199 G4ElectronOccupancy dynElectronOccupan << 200 << 201 if (OrbitalToFill != 0) << 202 { << 203 dynElectronOccupancy.RemoveElectro << 204 dynElectronOccupancy.AddElectron(O << 205 // dynElectronOccupancy.DumpInfo() << 206 } << 207 << 208 if (OrbitalToFill == 0) << 209 { << 210 dynElectronOccupancy.RemoveElectro << 211 // dynElectronOccupancy.DumpInfo() << 212 } << 213 166 214 fpMolecularConfiguration = << 167 if (OrbitalToFill != 0) 215 G4MolecularConfiguration::GetOrCre << 168 { 216 pMoleculeDefinition, dynElectr << 169 dynElectronOccupancy.RemoveElectron(OrbitalToFree-1,1); >> 170 dynElectronOccupancy.AddElectron(OrbitalToFill-1,1); >> 171 // dynElectronOccupancy.DumpInfo(); // DEBUG 217 } 172 } 218 else << 173 >> 174 if (OrbitalToFill == 0) 219 { 175 { 220 fpMolecularConfiguration = nullptr; << 176 dynElectronOccupancy.RemoveElectron(OrbitalToFree-1,1); 221 G4Exception( << 177 // dynElectronOccupancy.DumpInfo(); // DEBUG 222 "G4Molecule::G4Molecule(G4Molecule << 223 "G4int OrbitalToFree, G4int Orbita << 224 "G4Molecule_wrong_usage_of_constru << 225 FatalErrorInArgument, << 226 "If you want to use this construct << 227 "first defined with electron occup << 228 } 178 } >> 179 >> 180 fpMolecularConfiguration = G4MolecularConfiguration::GetMolecularConfiguration(moleculeDefinition, dynElectronOccupancy); 229 } 181 } 230 182 231 //____________________________________________ << 232 /** Specific builder for water molecules to be 183 /** Specific builder for water molecules to be used in Geant4-DNA, 233 * the last option Excitation is true if the m 184 * the last option Excitation is true if the molecule is excited, is 234 * false is the molecule is ionized. 185 * false is the molecule is ionized. 235 */ 186 */ 236 G4Molecule::G4Molecule(G4MoleculeDefinition* p << 237 G4int level, << 238 G4bool excitation) << 239 : G4VUserTrackInformation("G4Molecule") << 240 { << 241 if (pMoleculeDefinition->GetGroundStateEle << 242 { << 243 G4ElectronOccupancy dynElectronOccupan << 244 187 245 if (excitation) << 188 G4Molecule::G4Molecule(G4MoleculeDefinition * moleculeDefinition, G4int Level, G4bool Excitation): 246 { << 189 G4VUserTrackInformation("G4Molecule"), G4IT() 247 dynElectronOccupancy.RemoveElectro << 190 { 248 dynElectronOccupancy.AddElectron(5 << 191 G4ElectronOccupancy dynElectronOccupancy (*moleculeDefinition->GetGroundStateElectronOccupancy()); 249 // dynElectronOccupancy.DumpInfo() << 250 } << 251 else << 252 { << 253 dynElectronOccupancy.RemoveElectro << 254 // dynElectronOccupancy.DumpInfo() << 255 } << 256 192 257 fpMolecularConfiguration = G4Molecular << 193 if (Excitation == true) 258 dynElectronOccupancy); << 259 } << 260 else << 261 { 194 { 262 fpMolecularConfiguration = nullptr; << 195 dynElectronOccupancy.RemoveElectron(Level,1); 263 G4Exception( << 196 dynElectronOccupancy.AddElectron(5,1); 264 "G4Molecule::G4Molecule(G4Molecule << 197 // dynElectronOccupancy.DumpInfo(); // DEBUG 265 "G4int OrbitalToFree, G4int Orbita << 266 "G4Molecule_wrong_usage_of_constru << 267 FatalErrorInArgument, << 268 "If you want to use this construct << 269 "first defined with electron occup << 270 } 198 } 271 } << 272 199 273 //____________________________________________ << 200 if (Excitation == false) >> 201 { >> 202 dynElectronOccupancy.RemoveElectron(Level,1); >> 203 // dynElectronOccupancy.DumpInfo(); // DEBUG >> 204 } 274 205 275 G4Molecule::G4Molecule(const G4MolecularConfig << 206 fpMolecularConfiguration = G4MolecularConfiguration::GetMolecularConfiguration(moleculeDefinition, dynElectronOccupancy); 276 { << 277 fpMolecularConfiguration = pMolecularConfi << 278 } 207 } 279 208 280 //____________________________________________ << 209 void G4Molecule::SetElectronOccupancy(const G4ElectronOccupancy* occ) 281 << 282 void G4Molecule::SetElectronOccupancy(const G4 << 283 { 210 { 284 fpMolecularConfiguration = << 211 fpMolecularConfiguration = G4MolecularConfiguration::GetMolecularConfiguration(fpMolecularConfiguration->GetDefinition(), *occ); 285 G4MolecularConfiguration::GetOrCreateM << 286 << 287 } 212 } 288 213 289 //____________________________________________ << 214 /** Method used in Geant4-DNA to excite water molecules 290 << 215 */ 291 void G4Molecule::ExciteMolecule(G4int excitati << 216 void G4Molecule::ExciteMolecule(G4int ExcitedLevel) 292 { 217 { 293 fpMolecularConfiguration = fpMolecularConf << 218 fpMolecularConfiguration = fpMolecularConfiguration->ExciteMolecule(ExcitedLevel); 294 } 219 } 295 220 296 //____________________________________________ << 221 /** Method used in Geant4-DNA to ionize water molecules 297 << 222 */ 298 void G4Molecule::IonizeMolecule(G4int ionizati << 223 void G4Molecule::IonizeMolecule(G4int IonizedLevel) 299 { 224 { 300 fpMolecularConfiguration = fpMolecularConf << 225 fpMolecularConfiguration = fpMolecularConfiguration->IonizeMolecule(IonizedLevel); 301 } 226 } 302 227 303 //____________________________________________ << 304 << 305 void G4Molecule::AddElectron(G4int orbit, G4in 228 void G4Molecule::AddElectron(G4int orbit, G4int number) 306 { 229 { 307 fpMolecularConfiguration = fpMolecularConf << 230 fpMolecularConfiguration = fpMolecularConfiguration->AddElectron(orbit,number); 308 } 231 } 309 232 310 //____________________________________________ << 233 void G4Molecule::RemoveElectron(G4int orbit,G4int number) 311 << 312 void G4Molecule::RemoveElectron(G4int orbit, G << 313 { 234 { 314 fpMolecularConfiguration = << 235 fpMolecularConfiguration = fpMolecularConfiguration->RemoveElectron(orbit,number); 315 fpMolecularConfiguration->RemoveElectr << 316 } 236 } 317 237 318 //____________________________________________ << 238 void G4Molecule::MoveOneElectron(G4int orbitToFree,G4int orbitToFill) 319 << 320 void G4Molecule::MoveOneElectron(G4int orbitTo << 321 { 239 { 322 fpMolecularConfiguration = << 240 fpMolecularConfiguration = fpMolecularConfiguration->MoveOneElectron(orbitToFree,orbitToFill); 323 fpMolecularConfiguration->MoveOneElect << 324 } 241 } 325 242 326 //____________________________________________ << 327 << 328 const G4String& G4Molecule::GetName() const 243 const G4String& G4Molecule::GetName() const 329 { 244 { 330 return fpMolecularConfiguration->GetName() 245 return fpMolecularConfiguration->GetName(); 331 } 246 } 332 247 333 //____________________________________________ << 334 << 335 const G4String& G4Molecule::GetFormatedName() << 336 { << 337 return fpMolecularConfiguration->GetFormat << 338 } << 339 << 340 //____________________________________________ << 341 << 342 G4int G4Molecule::GetAtomsNumber() const 248 G4int G4Molecule::GetAtomsNumber() const 343 { 249 { 344 return fpMolecularConfiguration->GetAtomsN 250 return fpMolecularConfiguration->GetAtomsNumber(); 345 } 251 } 346 252 347 //____________________________________________ << 348 << 349 G4double G4Molecule::GetNbElectrons() const 253 G4double G4Molecule::GetNbElectrons() const 350 { 254 { 351 return fpMolecularConfiguration->GetNbElec 255 return fpMolecularConfiguration->GetNbElectrons(); 352 } 256 } 353 257 354 //____________________________________________ << 355 << 356 void G4Molecule::PrintState() const 258 void G4Molecule::PrintState() const 357 { 259 { 358 fpMolecularConfiguration->PrintState(); 260 fpMolecularConfiguration->PrintState(); 359 } 261 } 360 262 361 //____________________________________________ << 263 G4Track * G4Molecule::BuildTrack(G4double globalTime, const G4ThreeVector& Position) 362 << 363 G4Track* G4Molecule::BuildTrack(G4double globa << 364 const G4Three << 365 { 264 { 366 if (fpTrack != nullptr) << 265 if(fpTrack != 0) 367 { 266 { 368 G4Exception("G4Molecule::BuildTrack", << 267 G4Exception("G4Molecule::BuildTrack","Molecule001", 369 "A track was already assig << 268 FatalErrorInArgument,"A track was already assigned to this molecule"); 370 } 269 } 371 270 372 // Kinetic Values 271 // Kinetic Values 373 // Set a random direction to the molecule 272 // Set a random direction to the molecule 374 G4double costheta = (2 * G4UniformRand() - << 273 G4double costheta = (2*G4UniformRand()-1); 375 G4double theta = acos(costheta); << 274 G4double theta = acos (costheta); 376 G4double phi = 2 * pi * G4UniformRand(); << 275 G4double phi = 2*pi*G4UniformRand(); 377 276 378 G4double xMomentum = cos(phi) * sin(theta) << 277 G4double xMomentum = cos(phi)* sin(theta); 379 G4double yMomentum = sin(theta) * sin(phi) << 278 G4double yMomentum = sin(theta)*sin(phi); 380 G4double zMomentum = costheta; 279 G4double zMomentum = costheta; 381 280 382 G4ThreeVector MomentumDirection(xMomentum, 281 G4ThreeVector MomentumDirection(xMomentum, yMomentum, zMomentum); 383 G4double KineticEnergy = GetKineticEnergy( 282 G4double KineticEnergy = GetKineticEnergy(); 384 283 385 auto dynamicParticle = new G4DynamicParti << 284 G4DynamicParticle* dynamicParticle = new G4DynamicParticle(fpMolecularConfiguration->GetDefinition(), 386 fpMolecularConfiguration->GetDefinitio << 285 MomentumDirection, 387 KineticEnergy); << 286 KineticEnergy); 388 287 389 if (G4VMoleculeCounter::Instance()->InUse( << 288 if(G4MoleculeCounter::GetMoleculeCounter()->InUse()) 390 { << 289 G4MoleculeCounter::GetMoleculeCounter()->AddAMoleculeAtTime(*this,globalTime); 391 G4VMoleculeCounter::Instance()-> << 392 AddAMoleculeAtTime(fpMolecularConf << 393 globalTime, << 394 &(fpTrack->GetP << 395 } << 396 290 397 //Set the Track 291 //Set the Track 398 fpTrack = new G4Track(dynamicParticle, glo << 292 fpTrack = new G4Track(dynamicParticle, globalTime, Position); 399 fpTrack->SetUserInformation(this); << 293 fpTrack -> SetUserInformation (this); 400 294 401 return fpTrack; 295 return fpTrack; 402 } 296 } 403 297 404 //____________________________________________ << 405 << 406 G4double G4Molecule::GetKineticEnergy() const 298 G4double G4Molecule::GetKineticEnergy() const 407 { 299 { 408 //// 300 //// 409 // Ideal Gaz case 301 // Ideal Gaz case 410 double v = GetDiffusionVelocity(); 302 double v = GetDiffusionVelocity(); 411 double E = (fpMolecularConfiguration->GetM << 303 double E = (fpMolecularConfiguration->GetMass()/(c_squared))*(v*v)/2.; 412 //// 304 //// 413 return E; 305 return E; 414 } 306 } 415 307 416 //____________________________________________ << 417 << 418 G4double G4Molecule::GetDiffusionVelocity() co 308 G4double G4Molecule::GetDiffusionVelocity() const 419 { 309 { 420 double moleculeMass = fpMolecularConfigura << 310 double moleculeMass = fpMolecularConfiguration->GetMass()/(c_squared); 421 311 422 //// 312 //// 423 // Different possibilities 313 // Different possibilities 424 //// 314 //// 425 // Ideal Gaz case : Maxwell Boltzmann Dist 315 // Ideal Gaz case : Maxwell Boltzmann Distribution 426 // double sigma = k_Boltzmann * fgTempe 316 // double sigma = k_Boltzmann * fgTemperature / mass; 427 // return G4RandGauss::shoot( 0, sigma 317 // return G4RandGauss::shoot( 0, sigma ); 428 //// 318 //// 429 // Ideal Gaz case : mean velocity from equ 319 // Ideal Gaz case : mean velocity from equipartition theorem 430 return sqrt(3 * k_Boltzmann * << 320 return sqrt(3*k_Boltzmann*fgTemperature/moleculeMass); 431 G4MolecularConfiguration::GetG << 432 //// 321 //// 433 // Using this approximation for liquid is 322 // Using this approximation for liquid is wrong 434 // However the brownian process avoid taki 323 // However the brownian process avoid taking 435 // care of energy consideration and plays 324 // care of energy consideration and plays only 436 // with positions 325 // with positions 437 } 326 } 438 327 439 //____________________________________________ << 440 << 441 // added - to be transformed in a "Decay metho 328 // added - to be transformed in a "Decay method" 442 const vector<const G4MolecularDissociationChan << 329 const vector <const G4MolecularDecayChannel*>* G4Molecule::GetDecayChannel() const 443 G4Molecule::GetDissociationChannels() const << 444 { << 445 return fpMolecularConfiguration->GetDissoc << 446 } << 447 << 448 //____________________________________________ << 449 << 450 G4int G4Molecule::GetFakeParticleID() const << 451 { 330 { 452 return fpMolecularConfiguration->GetFakePa << 331 return fpMolecularConfiguration->GetDecayChannel(); 453 } 332 } 454 333 455 //____________________________________________ << 456 << 457 G4int G4Molecule::GetMoleculeID() const 334 G4int G4Molecule::GetMoleculeID() const 458 { 335 { 459 return fpMolecularConfiguration->GetMolecu 336 return fpMolecularConfiguration->GetMoleculeID(); 460 } 337 } 461 338 462 //____________________________________________ << 339 void G4Molecule::SetDecayTime(G4double dynDecayTime) >> 340 { >> 341 fpMolecularConfiguration->SetDecayTime(dynDecayTime); >> 342 } 463 343 464 G4double G4Molecule::GetDecayTime() const 344 G4double G4Molecule::GetDecayTime() const 465 { 345 { 466 return fpMolecularConfiguration->GetDecayT 346 return fpMolecularConfiguration->GetDecayTime(); 467 } 347 } 468 348 469 //____________________________________________ << 349 void G4Molecule::SetVanDerVaalsRadius(G4double dynVanDerVaalsRadius) >> 350 { >> 351 fpMolecularConfiguration->SetVanDerVaalsRadius(dynVanDerVaalsRadius); >> 352 } 470 353 471 G4double G4Molecule::GetVanDerVaalsRadius() co 354 G4double G4Molecule::GetVanDerVaalsRadius() const 472 { 355 { 473 return fpMolecularConfiguration->GetVanDer 356 return fpMolecularConfiguration->GetVanDerVaalsRadius(); 474 } 357 } 475 358 476 //____________________________________________ << 477 << 478 G4int G4Molecule::GetCharge() const 359 G4int G4Molecule::GetCharge() const 479 { 360 { 480 return fpMolecularConfiguration->GetCharge << 361 return fpMolecularConfiguration->GetCharge() ; 481 } 362 } 482 363 483 //____________________________________________ << 364 void G4Molecule::SetMass(G4double aMass) >> 365 { >> 366 fpMolecularConfiguration->SetMass(aMass); >> 367 } 484 368 485 G4double G4Molecule::GetMass() const 369 G4double G4Molecule::GetMass() const 486 { 370 { 487 return fpMolecularConfiguration->GetMass() 371 return fpMolecularConfiguration->GetMass(); 488 } 372 } 489 373 490 //____________________________________________ << 491 << 492 const G4ElectronOccupancy* G4Molecule::GetElec 374 const G4ElectronOccupancy* G4Molecule::GetElectronOccupancy() const 493 { 375 { 494 return fpMolecularConfiguration->GetElectr 376 return fpMolecularConfiguration->GetElectronOccupancy(); 495 } 377 } 496 378 497 //____________________________________________ << 498 << 499 const G4MoleculeDefinition* G4Molecule::GetDef 379 const G4MoleculeDefinition* G4Molecule::GetDefinition() const 500 { 380 { 501 return fpMolecularConfiguration->GetDefini 381 return fpMolecularConfiguration->GetDefinition(); 502 } 382 } 503 383 504 //____________________________________________ << 384 void G4Molecule::SetDiffusionCoefficient(G4double dynDiffusionCoefficient) 505 << 506 G4double G4Molecule::GetDiffusionCoefficient() << 507 { 385 { 508 return fpMolecularConfiguration->GetDiffus << 386 fpMolecularConfiguration->SetDiffusionCoefficient(dynDiffusionCoefficient); 509 } 387 } 510 388 511 //____________________________________________ << 389 G4double G4Molecule::GetDiffusionCoefficient() const 512 << 513 G4double G4Molecule::GetDiffusionCoefficient(c << 514 d << 515 { 390 { 516 return fpMolecularConfiguration->GetDiffus << 391 return fpMolecularConfiguration->GetDiffusionCoefficient(); 517 << 518 } 392 } 519 393 520 //____________________________________________ << 394 G4MolecularConfiguration* G4Molecule::GetMolecularConfiguration() const 521 << 522 const G4MolecularConfiguration* G4Molecule::Ge << 523 { 395 { 524 return fpMolecularConfiguration; << 396 return fpMolecularConfiguration ; 525 } 397 } 526 398 527 //____________________________________________ << 399 void G4Molecule::SetGlobalTemperature(G4double temperature) 528 << 529 const G4String& G4Molecule::GetLabel() const << 530 { 400 { 531 return fpMolecularConfiguration->GetLabel( << 401 fgTemperature = temperature; 532 } 402 } 533 403 534 //____________________________________________ << 404 G4double G4Molecule::GetGlobalTemperature() 535 << 536 void G4Molecule::ChangeConfigurationToLabel(co << 537 { 405 { 538 // TODO check fpMolecularConfiguration alr << 406 return fgTemperature; 539 // and new one as well << 540 // TODO notify for stack change << 541 fpMolecularConfiguration = G4MolecularConf << 542 fpMolecularConfiguration->GetDefinitio << 543 << 544 assert(fpMolecularConfiguration != nullptr << 545 } 407 } 546 408