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 /* 26 /* 27 * File: G4FissionFragmentGenerator.cc 27 * File: G4FissionFragmentGenerator.cc 28 * Author: B. Wendt (wendbryc@isu.edu) 28 * Author: B. Wendt (wendbryc@isu.edu) 29 * 29 * 30 * Created on May 11, 2011, 12:04 PM 30 * Created on May 11, 2011, 12:04 PM 31 */ 31 */ >> 32 >> 33 #include <iostream> >> 34 #include <vector> 32 35 33 #include "G4FFGDebuggingMacros.hh" << 34 #include "G4FFGDefaultValues.hh" << 35 #include "G4HadFinalState.hh" << 36 #include "G4Ions.hh" 36 #include "G4Ions.hh" 37 #include "G4Neutron.hh" << 38 #include "globals.hh" 37 #include "globals.hh" >> 38 #include "G4HadFinalState.hh" >> 39 #include "G4Neutron.hh" 39 40 40 #include <iostream> << 41 #include "G4FFGDebuggingMacros.hh" 41 #include <vector> << 42 #include "G4FFGDefaultValues.hh" 42 // Use a few select constant of CLHEP namespac << 43 // Use a few select constant of CLHEP namespace 43 using CLHEP::eV; 44 using CLHEP::eV; 44 using CLHEP::GeV; << 45 using CLHEP::keV; 45 using CLHEP::keV; 46 using CLHEP::MeV; 46 using CLHEP::MeV; >> 47 using CLHEP::GeV; 47 #include "G4FFGEnumerations.hh" 48 #include "G4FFGEnumerations.hh" 48 #include "G4FPYBiasedLightFragmentDist.hh" << 49 #include "G4FPYNormalFragmentDist.hh" 49 #include "G4FPYNormalFragmentDist.hh" >> 50 #include "G4FPYBiasedLightFragmentDist.hh" 50 #include "G4FissionFragmentGenerator.hh" 51 #include "G4FissionFragmentGenerator.hh" 51 #include "G4TableTemplate.hh" 52 #include "G4TableTemplate.hh" 52 53 53 G4FissionFragmentGenerator::G4FissionFragmentG << 54 G4FissionFragmentGenerator:: >> 55 G4FissionFragmentGenerator( void ) 54 { 56 { 55 // Set the default verbosity << 57 // Set the default verbosity 56 Verbosity_ = G4FFGDefaultValues::Verbosity; << 58 Verbosity_ = G4FFGDefaultValues::Verbosity; 57 << 59 58 // Initialize the class << 60 // Initialize the class 59 Initialize(); << 61 Initialize(); 60 } << 62 } >> 63 >> 64 G4FissionFragmentGenerator:: >> 65 G4FissionFragmentGenerator( G4int Verbosity ) >> 66 { >> 67 // Set the verbosity >> 68 Verbosity_ = Verbosity; >> 69 >> 70 // Initialize the class >> 71 Initialize(); >> 72 } >> 73 >> 74 void G4FissionFragmentGenerator:: >> 75 Initialize( void ) >> 76 { >> 77 G4FFG_FUNCTIONENTER__ >> 78 >> 79 // Initialize the class descriptor variables to the default values. These >> 80 // will be used unless the user redefines them. >> 81 Isotope_ = G4FFGDefaultValues::Isotope; >> 82 MetaState_ = G4FFGDefaultValues::MetaState; >> 83 Cause_ = G4FFGDefaultValues::FissionCause; >> 84 IncidentEnergy_ = G4FFGDefaultValues::ThermalNeutronEnergy; >> 85 YieldType_ = G4FFGDefaultValues::YieldType; >> 86 TernaryProbability_ = G4FFGDefaultValues::TernaryProbability; >> 87 AlphaProduction_ = G4FFGDefaultValues::AlphaProduction; >> 88 SamplingScheme_ = G4FFGDefaultValues::SamplingScheme; 61 89 62 G4FissionFragmentGenerator::G4FissionFragmentG << 90 // No data class has been created yet 63 { << 91 YieldData_ = NULL; 64 // Set the verbosity << 92 IsReconstructionNeeded_ = TRUE; 65 Verbosity_ = Verbosity; << 66 93 67 // Initialize the class << 94 G4FFG_FUNCTIONLEAVE__ 68 Initialize(); << 69 } 95 } 70 96 71 void G4FissionFragmentGenerator::Initialize() << 97 G4DynamicParticleVector* G4FissionFragmentGenerator:: >> 98 G4GenerateFission( void ) 72 { 99 { 73 G4FFG_FUNCTIONENTER__ << 100 G4FFG_FUNCTIONENTER__ 74 101 75 // Initialize the class descriptor variables << 102 const G4HadProjectile Projectile(G4DynamicParticle(G4Neutron::Neutron(), 76 // will be used unless the user redefines th << 103 G4ThreeVector(0, 0, 0), 77 Isotope_ = G4FFGDefaultValues::Isotope; << 104 G4FFGDefaultValues::ThermalNeutronEnergy)); 78 MetaState_ = G4FFGDefaultValues::MetaState; << 79 Cause_ = G4FFGDefaultValues::FissionCause; << 80 IncidentEnergy_ = G4FFGDefaultValues::Therma << 81 YieldType_ = G4FFGDefaultValues::YieldType; << 82 TernaryProbability_ = G4FFGDefaultValues::Te << 83 AlphaProduction_ = G4FFGDefaultValues::Alpha << 84 SamplingScheme_ = G4FFGDefaultValues::Sampli << 85 105 86 // No data class has been created yet << 106 // Call the overloaded function and generate 1 fission 87 YieldData_ = nullptr; << 107 std::vector< G4DynamicParticleVector* > FissionEvent = G4GenerateFission(1, Projectile); 88 IsReconstructionNeeded_ = TRUE; << 108 G4DynamicParticleVector* Container = FissionEvent[0]; 89 109 90 G4FFG_FUNCTIONLEAVE__ << 110 G4FFG_FUNCTIONLEAVE__ >> 111 return Container; 91 } 112 } 92 113 93 G4DynamicParticleVector* G4FissionFragmentGene << 114 G4DynamicParticleVector* G4FissionFragmentGenerator:: >> 115 G4GenerateFission( const G4HadProjectile& Projectile ) 94 { 116 { 95 G4FFG_FUNCTIONENTER__ << 117 G4FFG_FUNCTIONENTER__ 96 << 97 const G4HadProjectile Projectile(G4DynamicPa << 98 << 99 118 100 // Call the overloaded function and generate << 119 // Call the overloaded function and generate 1 fission 101 std::vector<G4DynamicParticleVector*> Fissio << 120 std::vector< G4DynamicParticleVector* > FissionEvent = G4GenerateFission(1, Projectile); 102 G4DynamicParticleVector* Container = Fission << 121 G4DynamicParticleVector* const Container = FissionEvent[0]; 103 122 104 G4FFG_FUNCTIONLEAVE__ << 123 G4FFG_FUNCTIONLEAVE__ 105 return Container; << 124 return Container; 106 } 125 } 107 126 108 G4DynamicParticleVector* << 127 const std::vector< G4DynamicParticleVector* > G4FissionFragmentGenerator:: 109 G4FissionFragmentGenerator::G4GenerateFission( << 128 G4GenerateFission( G4long NumberOfFissions, >> 129 const G4HadProjectile& Projectile ) 110 { 130 { 111 G4FFG_FUNCTIONENTER__ << 131 G4FFG_FUNCTIONENTER__ 112 132 113 // Call the overloaded function and generate << 114 std::vector<G4DynamicParticleVector*> Fissio << 115 G4DynamicParticleVector* const Container = F << 116 133 117 G4FFG_FUNCTIONLEAVE__ << 134 //TK Modified 131107 118 return Container; << 135 //std::vector< G4DynamicParticleVector* > FissionEvents(NumberOfFissions); 119 } << 136 std::vector< G4DynamicParticleVector* > FissionEvents(0); 120 << 121 const std::vector<G4DynamicParticleVector*> << 122 G4FissionFragmentGenerator::G4GenerateFission( << 123 << 124 { << 125 G4FFG_FUNCTIONENTER__ << 126 137 127 // TK Modified 131107 << 138 if(Projectile.GetDefinition() == G4Neutron::Neutron()) 128 // std::vector< G4DynamicParticleVector* > F << 139 { 129 std::vector<G4DynamicParticleVector*> Fissio << 140 if(IsReconstructionNeeded_ == TRUE) 130 << 141 { 131 if (Projectile.GetDefinition() == G4Neutron: << 142 // TODO Eliminate potential need for restructuring during run phase 132 if (static_cast<int>(IsReconstructionNeede << 143 //InitializeFissionProductYieldClass(); 133 // TODO Eliminate potential need for res << 144 } 134 // InitializeFissionProductYieldClass(); << 135 } << 136 145 137 for (G4long i = 0; i < NumberOfFissions; i << 146 for(G4long i = 0; i < NumberOfFissions; i++) 138 FissionEvents.push_back(YieldData_->G4Ge << 147 { 139 // FIXME Use particle momentum in balanc << 148 FissionEvents.push_back(YieldData_->G4GetFission()); 140 // FissionEvents.push_back(YieldData_->G << 149 // FIXME Use particle momentum in balance equation >> 150 // FissionEvents.push_back(YieldData_->G4GetFission(Projectile.Get4Momentum())); >> 151 } >> 152 } else >> 153 { >> 154 FissionEvents.push_back(NULL); 141 } 155 } 142 } << 143 else { << 144 FissionEvents.push_back(nullptr); << 145 } << 146 156 147 G4FFG_FUNCTIONLEAVE__ << 157 G4FFG_FUNCTIONLEAVE__ 148 return FissionEvents; << 158 return FissionEvents; 149 } 159 } 150 160 151 G4Ions* G4FissionFragmentGenerator::G4Generate << 161 G4Ions* G4FissionFragmentGenerator:: >> 162 G4GenerateFissionProduct( void ) 152 { 163 { 153 G4FFG_FUNCTIONENTER__ << 164 G4FFG_FUNCTIONENTER__ 154 << 155 if (static_cast<int>(IsReconstructionNeeded_ << 156 // TODO Eliminate potential need for restr << 157 // InitializeFissionProductYieldClass(); << 158 } << 159 165 160 G4Ions* Product = YieldData_->G4GetFissionPr << 166 if(IsReconstructionNeeded_ == TRUE) >> 167 { >> 168 // TODO Eliminate potential need for restructuring during run phase >> 169 //InitializeFissionProductYieldClass(); >> 170 } >> 171 >> 172 G4Ions* Product = YieldData_->G4GetFissionProduct(); 161 173 162 G4FFG_FUNCTIONLEAVE__ << 174 G4FFG_FUNCTIONLEAVE__ 163 return Product; << 175 return Product; 164 } 176 } 165 177 166 G4double G4FissionFragmentGenerator::G4GetAlph << 178 G4double G4FissionFragmentGenerator:: >> 179 G4GetAlphaProduction( void ) 167 { 180 { 168 G4FFG_FUNCTIONENTER__ << 181 G4FFG_FUNCTIONENTER__ 169 182 170 G4FFG_FUNCTIONLEAVE__ << 183 G4FFG_FUNCTIONLEAVE__ 171 return AlphaProduction_; << 184 return AlphaProduction_; 172 } 185 } 173 186 174 G4double G4FissionFragmentGenerator::G4GetTern << 187 G4double G4FissionFragmentGenerator:: >> 188 G4GetTernaryProbability( void ) 175 { 189 { 176 G4FFG_FUNCTIONENTER__ << 190 G4FFG_FUNCTIONENTER__ 177 191 178 G4FFG_FUNCTIONLEAVE__ << 192 G4FFG_FUNCTIONLEAVE__ 179 return TernaryProbability_; << 193 return TernaryProbability_; 180 } 194 } 181 195 182 G4FFGEnumerations::FissionCause G4FissionFragm << 196 G4FFGEnumerations::FissionCause G4FissionFragmentGenerator:: >> 197 G4GetCause( void ) 183 { 198 { 184 G4FFG_FUNCTIONENTER__ << 199 G4FFG_FUNCTIONENTER__ 185 200 186 G4FFG_FUNCTIONLEAVE__ << 201 G4FFG_FUNCTIONLEAVE__ 187 return Cause_; << 202 return Cause_; 188 } 203 } 189 204 190 G4double G4FissionFragmentGenerator::G4GetInci << 205 G4double G4FissionFragmentGenerator:: >> 206 G4GetIncidentEnergy( void ) 191 { 207 { 192 G4FFG_FUNCTIONENTER__ << 208 G4FFG_FUNCTIONENTER__ 193 209 194 G4FFG_FUNCTIONLEAVE__ << 210 G4FFG_FUNCTIONLEAVE__ 195 return IncidentEnergy_; << 211 return IncidentEnergy_; 196 } 212 } 197 213 198 G4int G4FissionFragmentGenerator::G4GetIsotope << 214 G4int G4FissionFragmentGenerator:: >> 215 G4GetIsotope( void ) 199 { 216 { 200 G4FFG_FUNCTIONENTER__ << 217 G4FFG_FUNCTIONENTER__ 201 218 202 G4FFG_FUNCTIONLEAVE__ << 219 G4FFG_FUNCTIONLEAVE__ 203 return Isotope_; << 220 return Isotope_; 204 } 221 } 205 222 206 G4FFGEnumerations::MetaState G4FissionFragment << 223 G4FFGEnumerations::MetaState G4FissionFragmentGenerator:: >> 224 G4GetMetaState( void ) 207 { 225 { 208 G4FFG_FUNCTIONENTER__ << 226 G4FFG_FUNCTIONENTER__ 209 227 210 G4FFG_FUNCTIONLEAVE__ << 228 G4FFG_FUNCTIONLEAVE__ 211 return MetaState_; << 229 return MetaState_; 212 } 230 } 213 231 214 G4FFGEnumerations::FissionSamplingScheme G4Fis << 232 G4FFGEnumerations::FissionSamplingScheme G4FissionFragmentGenerator:: >> 233 G4GetSamplingScheme( void ) 215 { 234 { 216 G4FFG_FUNCTIONENTER__ << 235 G4FFG_FUNCTIONENTER__ 217 236 218 G4FFG_FUNCTIONLEAVE__ << 237 G4FFG_FUNCTIONLEAVE__ 219 return SamplingScheme_; << 238 return SamplingScheme_; 220 } 239 } 221 240 222 G4FFGEnumerations::YieldType G4FissionFragment << 241 G4FFGEnumerations::YieldType G4FissionFragmentGenerator:: >> 242 G4GetYieldType() 223 { 243 { 224 G4FFG_FUNCTIONENTER__ << 244 G4FFG_FUNCTIONENTER__ 225 245 226 G4FFG_FUNCTIONLEAVE__ << 246 G4FFG_FUNCTIONLEAVE__ 227 return YieldType_; << 247 return YieldType_; 228 } 248 } 229 249 230 G4int G4FissionFragmentGenerator::G4MakeIsotop << 250 G4int G4FissionFragmentGenerator:: >> 251 G4MakeIsotopeCode(G4int Z, G4int A, G4int M) 231 { 252 { 232 // Sanity check; << 253 // Sanity check; 233 A %= 1000; << 254 A %= 1000; 234 Z %= 1000; << 255 Z %= 1000; 235 M %= 10; << 256 M %= 10; 236 257 237 return (A + Z * 1000) * 10 + M; << 258 return (A + Z * 1000) * 10 + M; 238 } 259 } 239 260 240 void G4FissionFragmentGenerator::G4SetAlphaPro << 261 void G4FissionFragmentGenerator:: >> 262 G4SetAlphaProduction( G4double WhatAlphaProduction ) 241 { 263 { 242 G4FFG_FUNCTIONENTER__ << 264 G4FFG_FUNCTIONENTER__ 243 265 244 AlphaProduction_ = WhatAlphaProduction; << 266 AlphaProduction_ = WhatAlphaProduction; 245 if (YieldData_ != nullptr) { << 267 if(YieldData_ != NULL) 246 YieldData_->G4SetAlphaProduction(AlphaProd << 268 { 247 } << 269 YieldData_->G4SetAlphaProduction(AlphaProduction_); 248 << 270 } 249 if ((Verbosity_ & G4FFGEnumerations::UPDATES << 250 G4FFG_SPACING__ << 251 G4FFG_LOCATION__ << 252 271 253 G4cout << " -- Alpha production set to " < << 272 if(Verbosity_ & G4FFGEnumerations::UPDATES) 254 } << 273 { >> 274 G4FFG_SPACING__ >> 275 G4FFG_LOCATION__ >> 276 >> 277 G4cout << " -- Alpha production set to " << AlphaProduction_ << G4endl; >> 278 } 255 279 256 G4FFG_FUNCTIONLEAVE__ << 280 G4FFG_FUNCTIONLEAVE__ 257 } 281 } 258 282 259 void G4FissionFragmentGenerator::G4SetTernaryP << 283 void G4FissionFragmentGenerator:: >> 284 G4SetTernaryProbability( G4double WhatTernaryProbability ) 260 { 285 { 261 G4FFG_FUNCTIONENTER__ << 286 G4FFG_FUNCTIONENTER__ 262 287 263 TernaryProbability_ = WhatTernaryProbability << 288 TernaryProbability_ = WhatTernaryProbability; 264 if (YieldData_ != nullptr) { << 289 if(YieldData_ != NULL) 265 YieldData_->G4SetTernaryProbability(Ternar << 290 { 266 } << 291 YieldData_->G4SetTernaryProbability(TernaryProbability_); 267 << 292 } 268 if ((Verbosity_ & G4FFGEnumerations::UPDATES << 269 G4FFG_SPACING__ << 270 G4FFG_LOCATION__ << 271 293 272 G4cout << " -- Ternary fission probability << 294 if(Verbosity_ & G4FFGEnumerations::UPDATES) 273 } << 295 { >> 296 G4FFG_SPACING__ >> 297 G4FFG_LOCATION__ >> 298 >> 299 G4cout << " -- Ternary fission probability set to " << TernaryProbability_ << G4endl; >> 300 } 274 301 275 G4FFG_FUNCTIONLEAVE__ << 302 G4FFG_FUNCTIONLEAVE__ 276 } 303 } 277 304 278 void G4FissionFragmentGenerator::G4SetCause(G4 << 305 void G4FissionFragmentGenerator:: >> 306 G4SetCause( G4FFGEnumerations::FissionCause WhichCause ) 279 { 307 { 280 G4FFG_FUNCTIONENTER__ << 308 G4FFG_FUNCTIONENTER__ 281 309 282 G4bool IsValidCause = (WhichCause == G4FFGEn << 310 G4bool IsValidCause = (WhichCause == G4FFGEnumerations::SPONTANEOUS 283 || WhichCause == G4FF << 311 || WhichCause == G4FFGEnumerations::NEUTRON_INDUCED ); 284 G4bool IsSameCause = (Cause_ == WhichCause); << 312 G4bool IsSameCause = (Cause_ == WhichCause); 285 << 313 286 if (!IsSameCause && IsValidCause) { << 314 if(!IsSameCause && IsValidCause) 287 Cause_ = WhichCause; << 315 { 288 if (Cause_ == G4FFGEnumerations::SPONTANEO << 316 Cause_ = WhichCause; 289 IncidentEnergy_ = 0; << 317 if(Cause_ == G4FFGEnumerations::SPONTANEOUS) 290 } << 318 { 291 IsReconstructionNeeded_ = TRUE; << 319 IncidentEnergy_ = 0; 292 } << 320 } 293 << 321 IsReconstructionNeeded_ = TRUE; 294 if (Verbosity_ != G4FFGEnumerations::SILENT) << 295 G4String CauseString; << 296 switch (WhichCause) { << 297 case G4FFGEnumerations::SPONTANEOUS: << 298 CauseString = "SPONTANEOUS"; << 299 break; << 300 case G4FFGEnumerations::NEUTRON_INDUCED: << 301 CauseString = "NEUTRON_INDUCED"; << 302 break; << 303 case G4FFGEnumerations::PROTON_INDUCED: << 304 CauseString = "PROTON_INDUCED"; << 305 break; << 306 case G4FFGEnumerations::GAMMA_INDUCED: << 307 CauseString = "GAMMA_INDUCED"; << 308 break; << 309 } 322 } 310 << 323 311 if ((Verbosity_ & G4FFGEnumerations::WARNI << 324 if(Verbosity_ != G4FFGEnumerations::SILENT) 312 G4FFG_SPACING__ << 325 { 313 G4FFG_LOCATION__ << 326 G4String CauseString; 314 << 327 switch(WhichCause) 315 if (IsValidCause) { << 328 { 316 if (IsSameCause && YieldData_ != nullp << 329 case G4FFGEnumerations::SPONTANEOUS: 317 G4cout << " -- Already set to use " << 330 CauseString = "SPONTANEOUS"; 318 << " as the fission cause. Yi << 331 break; >> 332 case G4FFGEnumerations::NEUTRON_INDUCED: >> 333 CauseString = "NEUTRON_INDUCED"; >> 334 break; >> 335 case G4FFGEnumerations::PROTON_INDUCED: >> 336 CauseString = "PROTON_INDUCED"; >> 337 break; >> 338 case G4FFGEnumerations::GAMMA_INDUCED: >> 339 CauseString = "GAMMA_INDUCED"; >> 340 break; 319 } 341 } 320 else if (YieldData_ == nullptr) { << 342 321 G4cout << " -- Yield data class not << 343 if(Verbosity_ & G4FFGEnumerations::WARNING) 322 << " will be applied when it << 344 { >> 345 G4FFG_SPACING__ >> 346 G4FFG_LOCATION__ >> 347 >> 348 if(IsValidCause) >> 349 { >> 350 if(IsSameCause && YieldData_ != NULL) >> 351 { >> 352 G4cout << " -- Already set to use " << CauseString << " as the fission cause. Yield data class will not be reconstructed." << G4endl; >> 353 } else if(YieldData_ == NULL) >> 354 { >> 355 G4cout << " -- Yield data class not yet constructed. " << CauseString << " will be applied when it is constructed." << G4endl; >> 356 } >> 357 } else >> 358 { >> 359 G4cout << " -- Invalid cause of fission" << G4endl; >> 360 } >> 361 } >> 362 >> 363 if((Verbosity_ & G4FFGEnumerations::UPDATES) >> 364 && IsValidCause) >> 365 { >> 366 G4FFG_SPACING__ >> 367 G4FFG_LOCATION__ >> 368 >> 369 G4cout << " -- Fission cause set to " << CauseString << "." << G4endl; 323 } 370 } 324 } << 325 else { << 326 G4cout << " -- Invalid cause of fissio << 327 } << 328 } << 329 << 330 if (((Verbosity_ & G4FFGEnumerations::UPDA << 331 G4FFG_SPACING__ << 332 G4FFG_LOCATION__ << 333 << 334 G4cout << " -- Fission cause set to " << << 335 } 371 } 336 } << 337 372 338 G4FFG_FUNCTIONLEAVE__ << 373 G4FFG_FUNCTIONLEAVE__ 339 } 374 } 340 375 341 void G4FissionFragmentGenerator::G4SetIncident << 376 void G4FissionFragmentGenerator:: >> 377 G4SetIncidentEnergy( G4double WhatIncidentEnergy ) 342 { 378 { 343 G4FFG_FUNCTIONENTER__ << 379 G4FFG_FUNCTIONENTER__ 344 << 345 if (Cause_ != G4FFGEnumerations::SPONTANEOUS << 346 IncidentEnergy_ = WhatIncidentEnergy; << 347 if (YieldData_ != nullptr) { << 348 YieldData_->G4SetEnergy(IncidentEnergy_) << 349 } << 350 } << 351 << 352 if (Verbosity_ != G4FFGEnumerations::SILENT) << 353 std::ostringstream EnergyString; << 354 if (IncidentEnergy_ / GeV > 1) { << 355 EnergyString << IncidentEnergy_ / GeV << << 356 } << 357 else if (IncidentEnergy_ / MeV > 1) { << 358 EnergyString << IncidentEnergy_ / MeV << << 359 } << 360 else if (IncidentEnergy_ / keV > 1) { << 361 EnergyString << IncidentEnergy_ / keV << << 362 } << 363 else { << 364 EnergyString << IncidentEnergy_ / eV << << 365 } << 366 380 367 if (((Verbosity_ & G4FFGEnumerations::ENER << 381 if(Cause_ != G4FFGEnumerations::SPONTANEOUS) 368 || ((Verbosity_ & G4FFGEnumerations::W << 369 { 382 { 370 if (Cause_ == G4FFGEnumerations::SPONTAN << 383 IncidentEnergy_ = WhatIncidentEnergy; 371 G4FFG_SPACING__ << 384 if(YieldData_ != NULL) 372 G4FFG_LOCATION__ << 385 { 373 << 386 YieldData_->G4SetEnergy(IncidentEnergy_); 374 G4cout << " -- Cannot set a non-zero e << 387 } 375 } << 376 else if (YieldData_ == nullptr) { << 377 G4FFG_SPACING__ << 378 G4FFG_LOCATION__ << 379 << 380 G4cout << " -- Yield data class not ye << 381 << " will be applied when it is << 382 } << 383 } 388 } 384 << 389 385 if (((Verbosity_ & G4FFGEnumerations::ENER << 390 if(Verbosity_ != G4FFGEnumerations::SILENT) 386 || ((Verbosity_ & G4FFGEnumerations::U << 387 { 391 { 388 G4FFG_SPACING__ << 392 std::ostringstream EnergyString; 389 G4FFG_LOCATION__ << 393 if(IncidentEnergy_ / GeV > 1) 390 << 394 { 391 G4cout << " -- Incident neutron energy s << 395 EnergyString << IncidentEnergy_ / GeV << " GeV"; >> 396 } else if(IncidentEnergy_ / MeV > 1) >> 397 { >> 398 EnergyString << IncidentEnergy_ / MeV << " MeV"; >> 399 } else if(IncidentEnergy_ / keV > 1) >> 400 { >> 401 EnergyString << IncidentEnergy_ / keV << " keV"; >> 402 } else >> 403 { >> 404 EnergyString << IncidentEnergy_ / eV << " eV"; >> 405 } >> 406 >> 407 if(Verbosity_ & G4FFGEnumerations::ENERGY_INFO >> 408 || Verbosity_ & G4FFGEnumerations::WARNING) >> 409 { >> 410 if(Cause_ == G4FFGEnumerations::SPONTANEOUS && IncidentEnergy_ != 0) >> 411 { >> 412 G4FFG_SPACING__ >> 413 G4FFG_LOCATION__ >> 414 >> 415 G4cout << " -- Cannot set a non-zero energy for spontaneous fission" << G4endl; >> 416 } else if(YieldData_ == NULL) >> 417 { >> 418 G4FFG_SPACING__ >> 419 G4FFG_LOCATION__ >> 420 >> 421 G4cout << " -- Yield data class not yet constructed. " << EnergyString.str() << " will be applied when it is constructed." << G4endl; >> 422 >> 423 } >> 424 } >> 425 >> 426 if(Verbosity_ & G4FFGEnumerations::ENERGY_INFO >> 427 || Verbosity_ & G4FFGEnumerations::UPDATES) >> 428 { >> 429 G4FFG_SPACING__ >> 430 G4FFG_LOCATION__ >> 431 >> 432 G4cout << " -- Incident neutron energy set to " << EnergyString.str() << "." << G4endl; >> 433 } 392 } 434 } 393 } << 394 435 395 G4FFG_FUNCTIONLEAVE__ << 436 G4FFG_FUNCTIONLEAVE__ 396 } 437 } 397 438 398 void G4FissionFragmentGenerator::G4SetIsotope( << 439 void G4FissionFragmentGenerator:: >> 440 G4SetIsotope( G4int WhichIsotope ) 399 { 441 { 400 G4FFG_FUNCTIONENTER__ << 442 G4FFG_FUNCTIONENTER__ 401 443 402 G4bool IsSameIsotope = (Isotope_ == WhichIso << 444 G4bool IsSameIsotope = (Isotope_ == WhichIsotope); 403 << 404 if (!IsSameIsotope) { << 405 Isotope_ = WhichIsotope; << 406 IsReconstructionNeeded_ = TRUE; << 407 } << 408 << 409 if (Verbosity_ != G4FFGEnumerations::SILENT) << 410 if ((Verbosity_ & G4FFGEnumerations::WARNI << 411 if (IsSameIsotope && YieldData_ != nullp << 412 G4FFG_SPACING__ << 413 G4FFG_LOCATION__ << 414 445 415 G4cout << " -- Isotope " << Isotope_ << 446 if(!IsSameIsotope) 416 << " already in use. Yield data << 447 { 417 } << 448 Isotope_ = WhichIsotope; 418 else if (YieldData_ == nullptr) { << 449 IsReconstructionNeeded_ = TRUE; 419 G4FFG_SPACING__ << 420 G4FFG_LOCATION__ << 421 << 422 G4cout << " -- Yield data class not ye << 423 << Isotope_ << " when it is con << 424 } << 425 } 450 } 426 << 451 427 if ((Verbosity_ & G4FFGEnumerations::UPDAT << 452 if(Verbosity_ != G4FFGEnumerations::SILENT) 428 G4FFG_SPACING__ << 453 { 429 G4FFG_LOCATION__ << 454 if(Verbosity_ & G4FFGEnumerations::WARNING) 430 << 455 { 431 G4cout << " -- Isotope set to " << Isoto << 456 if(IsSameIsotope && YieldData_ != NULL) >> 457 { >> 458 G4FFG_SPACING__ >> 459 G4FFG_LOCATION__ >> 460 >> 461 G4cout << " -- Isotope " << Isotope_ << " already in use. Yield data class will not be reconstructed." << G4endl; >> 462 } else if(YieldData_ == NULL) >> 463 { >> 464 G4FFG_SPACING__ >> 465 G4FFG_LOCATION__ >> 466 >> 467 G4cout << " -- Yield data class not yet constructed. The isotope will be set to " << Isotope_ << " when it is constructed." << G4endl; >> 468 } >> 469 } >> 470 >> 471 if(Verbosity_ & G4FFGEnumerations::UPDATES) >> 472 { >> 473 G4FFG_SPACING__ >> 474 G4FFG_LOCATION__ >> 475 >> 476 G4cout << " -- Isotope set to " << Isotope_ << "." << G4endl; >> 477 } 432 } 478 } 433 } << 434 479 435 G4FFG_FUNCTIONLEAVE__ << 480 G4FFG_FUNCTIONLEAVE__ 436 } 481 } 437 482 438 void G4FissionFragmentGenerator::G4SetMetaStat << 483 void G4FissionFragmentGenerator:: >> 484 G4SetMetaState( G4FFGEnumerations::MetaState WhichMetaState ) 439 { 485 { 440 G4FFG_FUNCTIONENTER__ << 486 G4FFG_FUNCTIONENTER__ 441 487 442 G4bool IsValidMetaState = (WhichMetaState >= << 488 G4bool IsValidMetaState = (WhichMetaState >= G4FFGEnumerations::MetaStateFirst 443 && WhichMetaState << 489 && WhichMetaState <= G4FFGEnumerations::MetaStateLast); 444 G4bool IsSameMetaState = (MetaState_ == Whic << 490 G4bool IsSameMetaState = (MetaState_ == WhichMetaState); 445 << 491 446 if (!IsSameMetaState && IsValidMetaState) { << 492 if(!IsSameMetaState && IsValidMetaState) 447 MetaState_ = WhichMetaState; << 493 { 448 IsReconstructionNeeded_ = TRUE; << 494 MetaState_ = WhichMetaState; 449 } << 495 IsReconstructionNeeded_ = TRUE; 450 << 451 if (Verbosity_ != G4FFGEnumerations::SILENT) << 452 G4String MetaName; << 453 switch (MetaState_) { << 454 case G4FFGEnumerations::GROUND_STATE: << 455 MetaName = "GROUND_STATE"; << 456 break; << 457 << 458 case G4FFGEnumerations::META_1: << 459 MetaName = "META_1"; << 460 break; << 461 << 462 case G4FFGEnumerations::META_2: << 463 MetaName = "META_2"; << 464 break; << 465 } 496 } 466 << 497 467 if ((Verbosity_ & G4FFGEnumerations::WARNI << 498 if(Verbosity_ != G4FFGEnumerations::SILENT) 468 G4FFG_SPACING__ << 499 { 469 G4FFG_LOCATION__ << 500 G4String MetaName; 470 << 501 switch(MetaState_) 471 std::ostringstream Temp; << 502 { 472 if (IsValidMetaState) { << 503 case G4FFGEnumerations::GROUND_STATE: 473 if (IsSameMetaState && YieldData_ != n << 504 MetaName = "GROUND_STATE"; 474 G4cout << " -- Already set to use " << 505 break; 475 << " as the metastable state. << 506 476 << G4endl; << 507 case G4FFGEnumerations::META_1: >> 508 MetaName = "META_1"; >> 509 break; >> 510 >> 511 case G4FFGEnumerations::META_2: >> 512 MetaName = "META_2"; >> 513 break; 477 } 514 } 478 else if (YieldData_ == nullptr) { << 515 479 G4cout << " -- Yield data class not << 516 if(Verbosity_ & G4FFGEnumerations::WARNING) 480 << " will be applied when it << 517 { >> 518 G4FFG_SPACING__ >> 519 G4FFG_LOCATION__ >> 520 >> 521 std::ostringstream Temp; >> 522 if(IsValidMetaState) >> 523 { >> 524 if(IsSameMetaState && YieldData_ != NULL) >> 525 { >> 526 G4cout << " -- Already set to use " << MetaName << " as the metastable state. Yield data class will not be reconstructed" << G4endl; >> 527 } else if(YieldData_ == NULL) >> 528 { >> 529 G4cout << " -- Yield data class not yet constructed. " << MetaName << " will be applied when it is constructed." << G4endl; >> 530 } >> 531 } else >> 532 { >> 533 G4cout << " -- Invalid metastable state." << G4endl; >> 534 } >> 535 } >> 536 >> 537 if(Verbosity_ & G4FFGEnumerations::UPDATES >> 538 && IsValidMetaState) >> 539 { >> 540 G4FFG_SPACING__ >> 541 G4FFG_LOCATION__ >> 542 >> 543 G4cout << " -- Metastable state set to " << MetaName << "." << G4endl; 481 } 544 } 482 } << 483 else { << 484 G4cout << " -- Invalid metastable stat << 485 } << 486 } << 487 << 488 if (((Verbosity_ & G4FFGEnumerations::UPDA << 489 G4FFG_SPACING__ << 490 G4FFG_LOCATION__ << 491 << 492 G4cout << " -- Metastable state set to " << 493 } 545 } 494 } << 495 546 496 G4FFG_FUNCTIONLEAVE__ << 547 G4FFG_FUNCTIONLEAVE__ 497 } 548 } 498 549 499 void G4FissionFragmentGenerator ::G4SetSamplin << 550 void G4FissionFragmentGenerator 500 G4FFGEnumerations::FissionSamplingScheme New << 551 ::G4SetSamplingScheme(G4FFGEnumerations::FissionSamplingScheme NewScheme) 501 { 552 { 502 G4FFG_FUNCTIONENTER__ << 553 G4FFG_FUNCTIONENTER__ 503 554 504 G4bool IsValidScheme = (NewScheme >= G4FFGEn << 555 G4bool IsValidScheme = (NewScheme >= G4FFGEnumerations::FissionSamplingSchemeFirst 505 && NewScheme <= G4FF << 556 && NewScheme <= G4FFGEnumerations::FissionSamplingSchemeLast); 506 G4bool IsSameScheme = (NewScheme == Sampling << 557 G4bool IsSameScheme = (NewScheme == SamplingScheme_); 507 558 508 if (!IsSameScheme && IsValidScheme) { << 559 if(!IsSameScheme && IsValidScheme) 509 SamplingScheme_ = NewScheme; << 560 { 510 IsReconstructionNeeded_ = TRUE; << 561 SamplingScheme_ = NewScheme; 511 } << 562 IsReconstructionNeeded_ = TRUE; 512 << 513 if (Verbosity_ != G4FFGEnumerations::SILENT) << 514 G4String SchemeString; << 515 switch (SamplingScheme_) { << 516 case G4FFGEnumerations::NORMAL: << 517 SchemeString = "NORMAL"; << 518 break; << 519 << 520 case G4FFGEnumerations::LIGHT_FRAGMENT: << 521 SchemeString = "LIGHT_FRAGMENT"; << 522 break; << 523 << 524 default: << 525 SchemeString = "UNSUPPORTED"; << 526 break; << 527 } 563 } 528 << 564 529 if ((Verbosity_ & G4FFGEnumerations::WARNI << 565 if(Verbosity_ != G4FFGEnumerations::SILENT) 530 G4FFG_SPACING__ << 566 { 531 G4FFG_LOCATION__ << 567 G4String SchemeString; 532 << 568 switch(SamplingScheme_) 533 if (IsValidScheme) { << 569 { 534 if (IsSameScheme && YieldData_ != null << 570 case G4FFGEnumerations::NORMAL: 535 G4cout << " -- Already set to use " << 571 SchemeString = "NORMAL"; 536 << " as the sampling scheme. << 572 break; 537 << G4endl; << 573 >> 574 case G4FFGEnumerations::LIGHT_FRAGMENT: >> 575 SchemeString = "LIGHT_FRAGMENT"; >> 576 break; >> 577 >> 578 default: >> 579 SchemeString = "UNSUPPORTED"; >> 580 break; 538 } 581 } 539 else if (YieldData_ == nullptr) { << 582 540 G4cout << " -- Yield data class not << 583 if(Verbosity_ & G4FFGEnumerations::WARNING) 541 << " will be applied when it << 584 { >> 585 G4FFG_SPACING__ >> 586 G4FFG_LOCATION__ >> 587 >> 588 if(IsValidScheme) >> 589 { >> 590 if(IsSameScheme && YieldData_ != NULL) >> 591 { >> 592 G4cout << " -- Already set to use " << SchemeString << " as the sampling scheme. Yield data class will not be reconstructed." << G4endl; >> 593 } else if(YieldData_ == NULL) >> 594 { >> 595 G4cout << " -- Yield data class not yet constructed. " << SchemeString << " will be applied when it is constructed." << G4endl; >> 596 } >> 597 } else >> 598 { >> 599 G4cout << " -- Invalid sampling scheme." << G4endl; >> 600 } >> 601 } >> 602 >> 603 if((Verbosity_ & G4FFGEnumerations::UPDATES) >> 604 && IsValidScheme) >> 605 { >> 606 G4FFG_SPACING__ >> 607 G4FFG_LOCATION__ >> 608 >> 609 G4cout << " -- Sampling scheme set to " << SchemeString << "." << G4endl; 542 } 610 } 543 } << 544 else { << 545 G4cout << " -- Invalid sampling scheme << 546 } << 547 } << 548 << 549 if (((Verbosity_ & G4FFGEnumerations::UPDA << 550 G4FFG_SPACING__ << 551 G4FFG_LOCATION__ << 552 << 553 G4cout << " -- Sampling scheme set to " << 554 } 611 } 555 } << 556 612 557 G4FFG_FUNCTIONLEAVE__ << 613 G4FFG_FUNCTIONLEAVE__ 558 } 614 } 559 615 560 void G4FissionFragmentGenerator::G4SetYieldTyp << 616 void G4FissionFragmentGenerator:: >> 617 G4SetYieldType(G4FFGEnumerations::YieldType WhichYieldType) 561 { 618 { 562 G4FFG_FUNCTIONENTER__ << 619 G4FFG_FUNCTIONENTER__ 563 << 564 G4bool IsValidYieldType = (WhichYieldType == << 565 || WhichYieldType << 566 G4bool IsSameYieldType = (YieldType_ == Whic << 567 << 568 if (!IsSameYieldType && IsValidYieldType) { << 569 YieldType_ = WhichYieldType; << 570 IsReconstructionNeeded_ = TRUE; << 571 } << 572 << 573 if (Verbosity_ != G4FFGEnumerations::SILENT) << 574 G4String YieldString; << 575 switch ((int)YieldType_) { << 576 case G4FFGEnumerations::INDEPENDENT: << 577 YieldString = "INDEPENDENT"; << 578 break; << 579 620 580 case G4FFGEnumerations::SPONTANEOUS: << 621 G4bool IsValidYieldType = (WhichYieldType == G4FFGEnumerations::INDEPENDENT 581 YieldString = "SPONTANEOUS"; << 622 ||WhichYieldType == G4FFGEnumerations::CUMULATIVE); 582 break; << 623 G4bool IsSameYieldType = (YieldType_ == WhichYieldType); 583 624 584 default: << 625 if(!IsSameYieldType && IsValidYieldType) 585 YieldString = "UNSUPPORTED"; << 626 { 586 break; << 627 YieldType_ = WhichYieldType; >> 628 IsReconstructionNeeded_ = TRUE; 587 } 629 } 588 << 630 589 if ((Verbosity_ & G4FFGEnumerations::WARNI << 631 if(Verbosity_ != G4FFGEnumerations::SILENT) 590 G4FFG_SPACING__ << 632 { 591 G4FFG_LOCATION__ << 633 G4String YieldString; 592 << 634 switch((int)YieldType_) 593 if (IsValidYieldType) { << 635 { 594 if (IsSameYieldType && YieldData_ != n << 636 case G4FFGEnumerations::INDEPENDENT: >> 637 YieldString = "INDEPENDENT"; >> 638 break; >> 639 >> 640 case G4FFGEnumerations::SPONTANEOUS: >> 641 YieldString = "SPONTANEOUS"; >> 642 break; >> 643 >> 644 default: >> 645 YieldString = "UNSUPPORTED"; >> 646 break; 595 } 647 } 596 else if (YieldData_ == nullptr) { << 648 597 G4cout << " -- Yield data class not << 649 if(Verbosity_ & G4FFGEnumerations::WARNING) 598 << " will be applied when it << 650 { >> 651 G4FFG_SPACING__ >> 652 G4FFG_LOCATION__ >> 653 >> 654 if(IsValidYieldType) >> 655 { >> 656 >> 657 if(IsSameYieldType && YieldData_ != NULL) >> 658 { >> 659 } else if(YieldData_ == NULL) >> 660 { >> 661 G4cout << " -- Yield data class not yet constructed. Yield type " << YieldString << " will be applied when it is constructed." << G4endl; >> 662 } >> 663 } else >> 664 { >> 665 G4cout << " -- Invalid yield type." << G4endl; >> 666 } >> 667 } >> 668 >> 669 if((Verbosity_ & G4FFGEnumerations::UPDATES) >> 670 && IsValidYieldType) >> 671 { >> 672 G4FFG_SPACING__ >> 673 G4FFG_LOCATION__ >> 674 >> 675 G4cout << " -- Yield type set to " << YieldString << G4endl; 599 } 676 } 600 } << 601 else { << 602 G4cout << " -- Invalid yield type." << << 603 } << 604 } << 605 << 606 if (((Verbosity_ & G4FFGEnumerations::UPDA << 607 G4FFG_SPACING__ << 608 G4FFG_LOCATION__ << 609 << 610 G4cout << " -- Yield type set to " << Yi << 611 } 677 } 612 } << 613 678 614 G4FFG_FUNCTIONLEAVE__ << 679 G4FFG_FUNCTIONLEAVE__ 615 } 680 } 616 681 617 void G4FissionFragmentGenerator::G4SetVerbosit << 682 void G4FissionFragmentGenerator:: >> 683 G4SetVerbosity(G4int Verbosity) 618 { 684 { 619 G4FFG_FUNCTIONENTER__ << 685 G4FFG_FUNCTIONENTER__ 620 << 621 Verbosity_ = Verbosity; << 622 686 623 if (YieldData_ != nullptr) { << 687 Verbosity_ = Verbosity; 624 YieldData_->G4SetVerbosity(Verbosity_); << 688 625 } << 689 if(YieldData_ != NULL) >> 690 { >> 691 YieldData_->G4SetVerbosity(Verbosity_); >> 692 } 626 693 627 G4FFG_FUNCTIONLEAVE__ << 694 G4FFG_FUNCTIONLEAVE__ 628 } 695 } 629 696 630 bool G4FissionFragmentGenerator::InitializeFis << 697 bool G4FissionFragmentGenerator:: >> 698 InitializeFissionProductYieldClass( std::istringstream& dataStream ) 631 { 699 { 632 G4FFG_FUNCTIONENTER__ << 700 G4FFG_FUNCTIONENTER__ 633 701 634 if (YieldData_ != nullptr) { << 702 if(YieldData_ != NULL) 635 delete YieldData_; << 703 { 636 << 704 delete YieldData_; 637 if ((Verbosity_ & G4FFGEnumerations::UPDAT << 705 638 G4FFG_SPACING__ << 706 if(Verbosity_ & G4FFGEnumerations::UPDATES) 639 G4FFG_LOCATION__ << 707 { 640 << 708 G4FFG_SPACING__ 641 G4cout << " -- Old yield data class dele << 709 G4FFG_LOCATION__ >> 710 >> 711 G4cout << " -- Old yield data class deleted." << G4endl; >> 712 } 642 } 713 } 643 } << 644 714 645 try { << 715 try 646 if (SamplingScheme_ == G4FFGEnumerations:: << 716 { 647 YieldData_ = new G4FPYNormalFragmentDist << 717 if(SamplingScheme_ == G4FFGEnumerations::NORMAL) 648 << 718 { 649 } << 719 YieldData_ = new G4FPYNormalFragmentDist(Isotope_, 650 else { << 720 MetaState_, 651 YieldData_ = new G4FPYBiasedLightFragmen << 721 Cause_, 652 << 722 YieldType_, 653 } << 723 Verbosity_, >> 724 dataStream); >> 725 } else >> 726 { >> 727 YieldData_ = new G4FPYBiasedLightFragmentDist(Isotope_, >> 728 MetaState_, >> 729 Cause_, >> 730 YieldType_, >> 731 Verbosity_, >> 732 dataStream); >> 733 } 654 734 655 if (AlphaProduction_ != 0 && TernaryProbab << 735 if(AlphaProduction_ != 0 && TernaryProbability_ != 0) 656 YieldData_->G4SetTernaryProbability(Tern << 736 { 657 YieldData_->G4SetAlphaProduction(AlphaPr << 737 YieldData_->G4SetTernaryProbability(TernaryProbability_); 658 } << 738 YieldData_->G4SetAlphaProduction(AlphaProduction_); >> 739 } 659 740 660 if ((Verbosity_ & G4FFGEnumerations::UPDAT << 741 if(Verbosity_ & G4FFGEnumerations::UPDATES) 661 G4FFG_SPACING__ << 742 { 662 G4FFG_LOCATION__ << 743 G4FFG_SPACING__ >> 744 G4FFG_LOCATION__ 663 745 664 G4cout << " -- Yield data class construc << 746 G4cout << " -- Yield data class constructed with defined values." << G4endl; >> 747 } >> 748 } catch (std::exception& e) >> 749 { >> 750 YieldData_ = NULL; 665 } 751 } 666 } << 667 catch (std::exception& e) { << 668 YieldData_ = nullptr; << 669 } << 670 752 671 IsReconstructionNeeded_ = FALSE; << 753 IsReconstructionNeeded_ = FALSE; 672 754 673 G4FFG_FUNCTIONLEAVE__ << 755 G4FFG_FUNCTIONLEAVE__ 674 return YieldData_ != nullptr; << 756 return YieldData_; 675 } 757 } 676 758 677 G4FissionFragmentGenerator::~G4FissionFragment << 759 G4FissionFragmentGenerator:: >> 760 ~G4FissionFragmentGenerator() 678 { 761 { 679 G4FFG_FUNCTIONENTER__ << 762 G4FFG_FUNCTIONENTER__ 680 763 681 delete YieldData_; << 764 delete YieldData_; 682 765 683 G4FFG_FUNCTIONLEAVE__ << 766 G4FFG_FUNCTIONLEAVE__ 684 } 767 } 685 768