Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/hadronic/models/particle_hp/src/G4FissionFragmentGenerator.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /processes/hadronic/models/particle_hp/src/G4FissionFragmentGenerator.cc (Version 11.3.0) and /processes/hadronic/models/particle_hp/src/G4FissionFragmentGenerator.cc (Version 10.6.p3)


  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