| 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