ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4FissionFragmentGenerator.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file G4FissionFragmentGenerator.cc
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 /*
27  * File: G4FissionFragmentGenerator.cc
28  * Author: B. Wendt (wendbryc@isu.edu)
29  *
30  * Created on May 11, 2011, 12:04 PM
31  */
32 
33 #include <iostream>
34 #include <vector>
35 
36 #include "G4Ions.hh"
37 #include "globals.hh"
38 #include "G4HadFinalState.hh"
39 #include "G4Neutron.hh"
40 
41 #include "G4FFGDebuggingMacros.hh"
42 #include "G4FFGDefaultValues.hh"
43 // Use a few select constant of CLHEP namespace
44 using CLHEP::eV;
45 using CLHEP::keV;
46 using CLHEP::MeV;
47 using CLHEP::GeV;
48 #include "G4FFGEnumerations.hh"
49 #include "G4FPYNormalFragmentDist.hh"
50 #include "G4FPYBiasedLightFragmentDist.hh"
51 #include "G4FissionFragmentGenerator.hh"
52 #include "G4TableTemplate.hh"
53 
54 G4FissionFragmentGenerator::
55 G4FissionFragmentGenerator( void )
56 {
57  // Set the default verbosity
58  Verbosity_ = G4FFGDefaultValues::Verbosity;
59 
60  // Initialize the class
61  Initialize();
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;
89 
90  // No data class has been created yet
91  YieldData_ = NULL;
92  IsReconstructionNeeded_ = TRUE;
93 
94 G4FFG_FUNCTIONLEAVE__
95 }
96 
97 G4DynamicParticleVector* G4FissionFragmentGenerator::
98 G4GenerateFission( void )
99 {
100 G4FFG_FUNCTIONENTER__
101 
102  const G4HadProjectile Projectile(G4DynamicParticle(G4Neutron::Neutron(),
103  G4ThreeVector(0, 0, 0),
104  G4FFGDefaultValues::ThermalNeutronEnergy));
105 
106  // Call the overloaded function and generate 1 fission
107  std::vector< G4DynamicParticleVector* > FissionEvent = G4GenerateFission(1, Projectile);
108  G4DynamicParticleVector* Container = FissionEvent[0];
109 
110 G4FFG_FUNCTIONLEAVE__
111  return Container;
112 }
113 
114 G4DynamicParticleVector* G4FissionFragmentGenerator::
115 G4GenerateFission( const G4HadProjectile& Projectile )
116 {
117 G4FFG_FUNCTIONENTER__
118 
119  // Call the overloaded function and generate 1 fission
120  std::vector< G4DynamicParticleVector* > FissionEvent = G4GenerateFission(1, Projectile);
121  G4DynamicParticleVector* const Container = FissionEvent[0];
122 
123 G4FFG_FUNCTIONLEAVE__
124  return Container;
125 }
126 
127 const std::vector< G4DynamicParticleVector* > G4FissionFragmentGenerator::
128 G4GenerateFission( G4long NumberOfFissions,
129  const G4HadProjectile& Projectile )
130 {
131 G4FFG_FUNCTIONENTER__
132 
133 
134  //TK Modified 131107
135  //std::vector< G4DynamicParticleVector* > FissionEvents(NumberOfFissions);
136  std::vector< G4DynamicParticleVector* > FissionEvents(0);
137 
138  if(Projectile.GetDefinition() == G4Neutron::Neutron())
139  {
140  if(IsReconstructionNeeded_ == TRUE)
141  {
142  // TODO Eliminate potential need for restructuring during run phase
143  //InitializeFissionProductYieldClass();
144  }
145 
146  for(G4long i = 0; i < NumberOfFissions; i++)
147  {
148  FissionEvents.push_back(YieldData_->G4GetFission());
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);
155  }
156 
157 G4FFG_FUNCTIONLEAVE__
158  return FissionEvents;
159 }
160 
161 G4Ions* G4FissionFragmentGenerator::
162 G4GenerateFissionProduct( void )
163 {
164 G4FFG_FUNCTIONENTER__
165 
166  if(IsReconstructionNeeded_ == TRUE)
167  {
168  // TODO Eliminate potential need for restructuring during run phase
169  //InitializeFissionProductYieldClass();
170  }
171 
172  G4Ions* Product = YieldData_->G4GetFissionProduct();
173 
174 G4FFG_FUNCTIONLEAVE__
175  return Product;
176 }
177 
178 G4double G4FissionFragmentGenerator::
179 G4GetAlphaProduction( void )
180 {
181 G4FFG_FUNCTIONENTER__
182 
183 G4FFG_FUNCTIONLEAVE__
184  return AlphaProduction_;
185 }
186 
187 G4double G4FissionFragmentGenerator::
188 G4GetTernaryProbability( void )
189 {
190 G4FFG_FUNCTIONENTER__
191 
192 G4FFG_FUNCTIONLEAVE__
193  return TernaryProbability_;
194 }
195 
196 G4FFGEnumerations::FissionCause G4FissionFragmentGenerator::
197 G4GetCause( void )
198 {
199 G4FFG_FUNCTIONENTER__
200 
201 G4FFG_FUNCTIONLEAVE__
202  return Cause_;
203 }
204 
205 G4double G4FissionFragmentGenerator::
206 G4GetIncidentEnergy( void )
207 {
208 G4FFG_FUNCTIONENTER__
209 
210 G4FFG_FUNCTIONLEAVE__
211  return IncidentEnergy_;
212 }
213 
214 G4int G4FissionFragmentGenerator::
215 G4GetIsotope( void )
216 {
217 G4FFG_FUNCTIONENTER__
218 
219 G4FFG_FUNCTIONLEAVE__
220  return Isotope_;
221 }
222 
223 G4FFGEnumerations::MetaState G4FissionFragmentGenerator::
224 G4GetMetaState( void )
225 {
226 G4FFG_FUNCTIONENTER__
227 
228 G4FFG_FUNCTIONLEAVE__
229  return MetaState_;
230 }
231 
232 G4FFGEnumerations::FissionSamplingScheme G4FissionFragmentGenerator::
233 G4GetSamplingScheme( void )
234 {
235 G4FFG_FUNCTIONENTER__
236 
237 G4FFG_FUNCTIONLEAVE__
238  return SamplingScheme_;
239 }
240 
241 G4FFGEnumerations::YieldType G4FissionFragmentGenerator::
242 G4GetYieldType()
243 {
244 G4FFG_FUNCTIONENTER__
245 
246 G4FFG_FUNCTIONLEAVE__
247  return YieldType_;
248 }
249 
250 G4int G4FissionFragmentGenerator::
251 G4MakeIsotopeCode(G4int Z, G4int A, G4int M)
252 {
253  // Sanity check;
254  A %= 1000;
255  Z %= 1000;
256  M %= 10;
257 
258  return (A + Z * 1000) * 10 + M;
259 }
260 
261 void G4FissionFragmentGenerator::
262 G4SetAlphaProduction( G4double WhatAlphaProduction )
263 {
264 G4FFG_FUNCTIONENTER__
265 
266  AlphaProduction_ = WhatAlphaProduction;
267  if(YieldData_ != NULL)
268  {
269  YieldData_->G4SetAlphaProduction(AlphaProduction_);
270  }
271 
272  if(Verbosity_ & G4FFGEnumerations::UPDATES)
273  {
274  G4FFG_SPACING__
275  G4FFG_LOCATION__
276 
277  G4cout << " -- Alpha production set to " << AlphaProduction_ << G4endl;
278  }
279 
280 G4FFG_FUNCTIONLEAVE__
281 }
282 
283 void G4FissionFragmentGenerator::
284 G4SetTernaryProbability( G4double WhatTernaryProbability )
285 {
286 G4FFG_FUNCTIONENTER__
287 
288  TernaryProbability_ = WhatTernaryProbability;
289  if(YieldData_ != NULL)
290  {
291  YieldData_->G4SetTernaryProbability(TernaryProbability_);
292  }
293 
294  if(Verbosity_ & G4FFGEnumerations::UPDATES)
295  {
296  G4FFG_SPACING__
297  G4FFG_LOCATION__
298 
299  G4cout << " -- Ternary fission probability set to " << TernaryProbability_ << G4endl;
300  }
301 
302 G4FFG_FUNCTIONLEAVE__
303 }
304 
305 void G4FissionFragmentGenerator::
306 G4SetCause( G4FFGEnumerations::FissionCause WhichCause )
307 {
308 G4FFG_FUNCTIONENTER__
309 
310  G4bool IsValidCause = (WhichCause == G4FFGEnumerations::SPONTANEOUS
311  || WhichCause == G4FFGEnumerations::NEUTRON_INDUCED );
312  G4bool IsSameCause = (Cause_ == WhichCause);
313 
314  if(!IsSameCause && IsValidCause)
315  {
316  Cause_ = WhichCause;
317  if(Cause_ == G4FFGEnumerations::SPONTANEOUS)
318  {
319  IncidentEnergy_ = 0;
320  }
321  IsReconstructionNeeded_ = TRUE;
322  }
323 
324  if(Verbosity_ != G4FFGEnumerations::SILENT)
325  {
326  G4String CauseString;
327  switch(WhichCause)
328  {
329  case G4FFGEnumerations::SPONTANEOUS:
330  CauseString = "SPONTANEOUS";
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;
341  }
342 
343  if(Verbosity_ & G4FFGEnumerations::WARNING)
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;
370  }
371  }
372 
373 G4FFG_FUNCTIONLEAVE__
374 }
375 
376 void G4FissionFragmentGenerator::
377 G4SetIncidentEnergy( G4double WhatIncidentEnergy )
378 {
379 G4FFG_FUNCTIONENTER__
380 
381  if(Cause_ != G4FFGEnumerations::SPONTANEOUS)
382  {
383  IncidentEnergy_ = WhatIncidentEnergy;
384  if(YieldData_ != NULL)
385  {
386  YieldData_->G4SetEnergy(IncidentEnergy_);
387  }
388  }
389 
390  if(Verbosity_ != G4FFGEnumerations::SILENT)
391  {
392  std::ostringstream EnergyString;
393  if(IncidentEnergy_ / GeV > 1)
394  {
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  }
434  }
435 
436 G4FFG_FUNCTIONLEAVE__
437 }
438 
439 void G4FissionFragmentGenerator::
440 G4SetIsotope( G4int WhichIsotope )
441 {
442 G4FFG_FUNCTIONENTER__
443 
444  G4bool IsSameIsotope = (Isotope_ == WhichIsotope);
445 
446  if(!IsSameIsotope)
447  {
448  Isotope_ = WhichIsotope;
449  IsReconstructionNeeded_ = TRUE;
450  }
451 
452  if(Verbosity_ != G4FFGEnumerations::SILENT)
453  {
454  if(Verbosity_ & G4FFGEnumerations::WARNING)
455  {
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  }
478  }
479 
480 G4FFG_FUNCTIONLEAVE__
481 }
482 
483 void G4FissionFragmentGenerator::
484 G4SetMetaState( G4FFGEnumerations::MetaState WhichMetaState )
485 {
486 G4FFG_FUNCTIONENTER__
487 
488  G4bool IsValidMetaState = (WhichMetaState >= G4FFGEnumerations::MetaStateFirst
489  && WhichMetaState <= G4FFGEnumerations::MetaStateLast);
490  G4bool IsSameMetaState = (MetaState_ == WhichMetaState);
491 
492  if(!IsSameMetaState && IsValidMetaState)
493  {
494  MetaState_ = WhichMetaState;
495  IsReconstructionNeeded_ = TRUE;
496  }
497 
498  if(Verbosity_ != G4FFGEnumerations::SILENT)
499  {
500  G4String MetaName;
501  switch(MetaState_)
502  {
503  case G4FFGEnumerations::GROUND_STATE:
504  MetaName = "GROUND_STATE";
505  break;
506 
507  case G4FFGEnumerations::META_1:
508  MetaName = "META_1";
509  break;
510 
511  case G4FFGEnumerations::META_2:
512  MetaName = "META_2";
513  break;
514  }
515 
516  if(Verbosity_ & G4FFGEnumerations::WARNING)
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;
544  }
545  }
546 
547 G4FFG_FUNCTIONLEAVE__
548 }
549 
550 void G4FissionFragmentGenerator
551 ::G4SetSamplingScheme(G4FFGEnumerations::FissionSamplingScheme NewScheme)
552 {
553 G4FFG_FUNCTIONENTER__
554 
555  G4bool IsValidScheme = (NewScheme >= G4FFGEnumerations::FissionSamplingSchemeFirst
556  && NewScheme <= G4FFGEnumerations::FissionSamplingSchemeLast);
557  G4bool IsSameScheme = (NewScheme == SamplingScheme_);
558 
559  if(!IsSameScheme && IsValidScheme)
560  {
561  SamplingScheme_ = NewScheme;
562  IsReconstructionNeeded_ = TRUE;
563  }
564 
565  if(Verbosity_ != G4FFGEnumerations::SILENT)
566  {
567  G4String SchemeString;
568  switch(SamplingScheme_)
569  {
570  case G4FFGEnumerations::NORMAL:
571  SchemeString = "NORMAL";
572  break;
573 
574  case G4FFGEnumerations::LIGHT_FRAGMENT:
575  SchemeString = "LIGHT_FRAGMENT";
576  break;
577 
578  default:
579  SchemeString = "UNSUPPORTED";
580  break;
581  }
582 
583  if(Verbosity_ & G4FFGEnumerations::WARNING)
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;
610  }
611  }
612 
613 G4FFG_FUNCTIONLEAVE__
614 }
615 
616 void G4FissionFragmentGenerator::
617 G4SetYieldType(G4FFGEnumerations::YieldType WhichYieldType)
618 {
619 G4FFG_FUNCTIONENTER__
620 
621  G4bool IsValidYieldType = (WhichYieldType == G4FFGEnumerations::INDEPENDENT
622  ||WhichYieldType == G4FFGEnumerations::CUMULATIVE);
623  G4bool IsSameYieldType = (YieldType_ == WhichYieldType);
624 
625  if(!IsSameYieldType && IsValidYieldType)
626  {
627  YieldType_ = WhichYieldType;
628  IsReconstructionNeeded_ = TRUE;
629  }
630 
631  if(Verbosity_ != G4FFGEnumerations::SILENT)
632  {
633  G4String YieldString;
634  switch((int)YieldType_)
635  {
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;
647  }
648 
649  if(Verbosity_ & G4FFGEnumerations::WARNING)
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;
676  }
677  }
678 
679 G4FFG_FUNCTIONLEAVE__
680 }
681 
682 void G4FissionFragmentGenerator::
683 G4SetVerbosity(G4int Verbosity)
684 {
685 G4FFG_FUNCTIONENTER__
686 
687  Verbosity_ = Verbosity;
688 
689  if(YieldData_ != NULL)
690  {
691  YieldData_->G4SetVerbosity(Verbosity_);
692  }
693 
694 G4FFG_FUNCTIONLEAVE__
695 }
696 
697 bool G4FissionFragmentGenerator::
698 InitializeFissionProductYieldClass( std::istringstream& dataStream )
699 {
700 G4FFG_FUNCTIONENTER__
701 
702  if(YieldData_ != NULL)
703  {
704  delete YieldData_;
705 
706  if(Verbosity_ & G4FFGEnumerations::UPDATES)
707  {
708  G4FFG_SPACING__
709  G4FFG_LOCATION__
710 
711  G4cout << " -- Old yield data class deleted." << G4endl;
712  }
713  }
714 
715  try
716  {
717  if(SamplingScheme_ == G4FFGEnumerations::NORMAL)
718  {
719  YieldData_ = new G4FPYNormalFragmentDist(Isotope_,
720  MetaState_,
721  Cause_,
722  YieldType_,
723  Verbosity_,
724  dataStream);
725  } else
726  {
727  YieldData_ = new G4FPYBiasedLightFragmentDist(Isotope_,
728  MetaState_,
729  Cause_,
730  YieldType_,
731  Verbosity_,
732  dataStream);
733  }
734 
735  if(AlphaProduction_ != 0 && TernaryProbability_ != 0)
736  {
737  YieldData_->G4SetTernaryProbability(TernaryProbability_);
738  YieldData_->G4SetAlphaProduction(AlphaProduction_);
739  }
740 
741  if(Verbosity_ & G4FFGEnumerations::UPDATES)
742  {
743  G4FFG_SPACING__
744  G4FFG_LOCATION__
745 
746  G4cout << " -- Yield data class constructed with defined values." << G4endl;
747  }
748  } catch (std::exception& e)
749  {
750  YieldData_ = NULL;
751  }
752 
753  IsReconstructionNeeded_ = FALSE;
754 
755 G4FFG_FUNCTIONLEAVE__
756  return YieldData_;
757 }
758 
759 G4FissionFragmentGenerator::
760 ~G4FissionFragmentGenerator()
761 {
762 G4FFG_FUNCTIONENTER__
763 
764  delete YieldData_;
765 
766 G4FFG_FUNCTIONLEAVE__
767 }