G4EquilibriumEvaporator.cc

Go to the documentation of this file.

//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
// $Id$
//
// 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
// 20100308  M. Kelsey -- Bug fix for setting masses of evaporating nuclei
// 20100319  M. Kelsey -- Use new generateWithRandomAngles for theta,phi stuff;
//      eliminate some unnecessary std::pow()
// 20100319  M. Kelsey -- Bug fix in new GetBindingEnergy() use right after
//      goodRemnant() -- Q1 should be outside call.
// 20100412  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
// 20100413  M. Kelsey -- Pass buffers to paraMaker[Truncated]
// 20100419  M. Kelsey -- Handle fission output list via const-ref
// 20100517  M. Kelsey -- Use G4CascadeInterpolator for QFF
// 20100520  M. Kelsey -- Inherit from common base class, make other colliders
//      simple data members.  Rename timeToBigBang() to override
//      base explosion().
// 20100617  M. Kelsey -- Remove "RUN" preprocessor flag and all "#else" code,
//      pass verbosity to colliders.
// 20100620  M. Kelsey -- Use local "bindingEnergy()" function to call through.
// 20100701  M. Kelsey -- Don't need to add excitation to nuclear mass; compute
//      new excitation energies properly (mass differences)
// 20100702  M. Kelsey -- Simplify if-cascades, indentation
// 20100712  M. Kelsey -- Add conservation checking
// 20100714  M. Kelsey -- Move conservation checking to base class.  Use
//      _generated_ evaporate energy (S) to adjust EEXS directly,
//      and test for S < EEXS before any particle generation; shift
//      nucleus momentum (PEX) by evaporate momentum directly
// 20100719  M. Kelsey -- Remove duplicative EESX_new calculation.
// 20100923  M. Kelsey -- Migrate to integer A and Z
// 20110214  M. Kelsey -- Follow G4InuclParticle::Model enumerator migration
// 20110728  M. Kelsey -- Fix Coverity #22951: check for "icase = -1" after
//      loop which is supposed to set it.  Otherwise indexing is wrong.
// 20110801  M. Kelsey -- Move "parms" buffer to data member, allocate in
//      constructor.
// 20110809  M. Kelsey -- Move "foutput" to data member, get list by reference;
//      create final-state particles within "push_back" to avoid
//      creation of temporaries.
// 20110922  M. Kelsey -- Follow G4InuclParticle::print(ostream&) migration
// 20111007  M. Kelsey -- Add G4InuclParticleNames, replace hardcoded numbers
// 20120608  M. Kelsey -- Fix variable-name "shadowing" compiler warnings.
// 20121009  M. Kelsey -- Improve debugging output
 
#include "G4EquilibriumEvaporator.hh"
#include "G4SystemOfUnits.hh"
#include "G4BigBanger.hh"
#include "G4CascadeInterpolator.hh"
#include "G4CollisionOutput.hh"
#include "G4Fissioner.hh"
#include "G4InuclNuclei.hh"
#include "G4InuclSpecialFunctions.hh"
#include "G4InuclParticleNames.hh"
#include "G4LorentzConvertor.hh"
#include "G4LorentzVector.hh"
#include "G4ThreeVector.hh"
 
using namespace G4InuclParticleNames;
using namespace G4InuclSpecialFunctions;
 
 
G4EquilibriumEvaporator::G4EquilibriumEvaporator()
  : G4CascadeColliderBase("G4EquilibriumEvaporator") {
  parms.first.resize(6,0.);
  parms.second.resize(6,0.);
}
 
G4EquilibriumEvaporator::~G4EquilibriumEvaporator() {}
 
 
void G4EquilibriumEvaporator::collide(G4InuclParticle* /*bullet*/,
                      G4InuclParticle* target,
                      G4CollisionOutput& output) {
  if (verboseLevel) {
    G4cout << " >>> G4EquilibriumEvaporator::collide" << G4endl;
  }
 
  // Sanity check
  G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target);
  if (!nuclei_target) {
    G4cerr << " EquilibriumEvaporator -> target is not nuclei " << G4endl;    
    return;
  }
 
  if (verboseLevel>1) G4cout << " evaporating target: \n" << *target << G4endl;
 
  theFissioner.setVerboseLevel(verboseLevel);
  theBigBanger.setVerboseLevel(verboseLevel);
 
  // simple implementation of the equilibium evaporation a la Dostrowski
  const G4double huge_num = 50.0;
  const G4double small = -50.0;
  const G4double prob_cut_off = 1.0e-15;
  const G4double Q1[6] = { 0.0, 0.0, 2.23, 8.49, 7.72, 28.3 };
  const G4int AN[6] = { 1, 1, 2, 3, 3, 4 };
  const G4int Q[6] =  { 0, 1, 1, 1, 2, 2 };
  const G4double G[6] = { 2.0, 2.0, 6.0, 6.0, 6.0, 4.0 };
  const G4double BE = 0.0063;
  const G4double fisssion_cut = 1000.0;
  const G4double cut_off_energy = 0.1;
 
  const G4double BF = 0.0242;
  const G4int itry_max = 1000;
  const G4int itry_global_max = 1000;
  const G4double small_ekin = 1.0e-6;
  const G4int itry_gam_max = 100;
 
  G4double W[8], u[6], V[6], TM[6];
  G4int A1[6], Z1[6];
 
  G4int A = nuclei_target->getA();
  G4int Z = nuclei_target->getZ();
  G4LorentzVector PEX = nuclei_target->getMomentum();
  G4double EEXS = nuclei_target->getExitationEnergy();
  
  if (verboseLevel > 3) G4cout << " after noeq: eexs " << EEXS << G4endl;
 
  G4InuclElementaryParticle dummy(small_ekin, proton);
  G4LorentzConvertor toTheNucleiSystemRestFrame;
  //*** toTheNucleiSystemRestFrame.setVerbose(verboseLevel);
  toTheNucleiSystemRestFrame.setBullet(dummy);
 
  G4LorentzVector ppout;
  
  // See if fragment should just be dispersed
  if (explosion(A, Z, EEXS)) {
    if (verboseLevel > 1) G4cout << " big bang in eql start " << G4endl;
    theBigBanger.collide(0, target, output);
 
    validateOutput(0, target, output);      // Check energy conservation
    return;
  }
 
  // If nucleus is in ground state, no evaporation
  if (EEXS < cut_off_energy) {
    if (verboseLevel > 1) G4cout << " no energy for evaporation" << G4endl;
    output.addOutgoingNucleus(*nuclei_target);
 
    validateOutput(0, target, output);      // Check energy conservation
    return;
  }
 
  // Initialize evaporation attempts
  G4double coul_coeff = (A >= 100.0) ? 1.4 : 1.2;
   
  G4LorentzVector pin = PEX;    // Save original target for testing
    
  G4bool try_again = true;  
  G4bool fission_open = true;
  G4int itry_global = 0;
    
  while (try_again && itry_global < itry_global_max) {
    itry_global++;
 
    // Set rest frame of current (recoiling) nucleus
    toTheNucleiSystemRestFrame.setTarget(PEX);
    toTheNucleiSystemRestFrame.toTheTargetRestFrame();
      
    if (verboseLevel > 2) {
      G4double nuc_mass = G4InuclNuclei::getNucleiMass(A, Z, EEXS);
      G4cout << " A " << A << " Z " << Z << " mass " << nuc_mass
         << " EEXS " << EEXS << G4endl;
    }
      
    if (explosion(A, Z, EEXS)) {            // big bang
      if (verboseLevel > 2) 
    G4cout << " big bang in eql step " << itry_global << G4endl;
 
      G4InuclNuclei nuclei(PEX, A, Z, EEXS, G4InuclParticle::Equilib);        
      theBigBanger.collide(0, &nuclei, output);
 
      validateOutput(0, target, output);    // Check energy conservation
      return;   
    } 
 
    if (EEXS < cut_off_energy) {    // Evaporation not possible
      if (verboseLevel > 2)
    G4cout << " no energy for evaporation in eql step " << itry_global 
           << G4endl;
 
      try_again = false;
      break;
    }
 
    // Normal evaporation chain
    G4double E0 = getE0(A);
    G4double parlev = getPARLEVDEN(A, Z);
    G4double u1 = parlev * A;
 
    paraMaker(Z, parms);
    const std::vector<G4double>& AK = parms.first;
    const std::vector<G4double>& CPA = parms.second;
 
    G4double DM0 = bindingEnergy(A,Z);
    G4int i(0);
 
    for (i = 0; i < 6; i++) {
      A1[i] = A - AN[i];
      Z1[i] = Z - Q[i];
      u[i] = parlev * A1[i];
      V[i] = 0.0;
      TM[i] = -0.1;
 
      if (goodRemnant(A1[i], Z1[i])) {
    G4double QB = DM0 - bindingEnergy(A1[i],Z1[i]) - Q1[i];
    V[i] = coul_coeff * Z * Q[i] * AK[i] / (1.0 + EEXS / E0) /
      (G4cbrt(A1[i]) + G4cbrt(AN[i]));
    TM[i] = EEXS - QB - V[i] * A / A1[i];
    if (verboseLevel > 3) {
      G4cout << " i=" << i << " : QB " << QB << " u " << u[i]
         << " V " << V[i] << " TM " << TM[i] << G4endl;
    }
      }
    }
      
    G4double ue = 2.0 * std::sqrt(u1 * EEXS);
    G4double prob_sum = 0.0;
 
    W[0] = 0.0;
    if (TM[0] > cut_off_energy) {
      G4double AL = getAL(A);
      W[0] = BE * G4cbrt(A1[0]*A1[0]) * G[0] * AL;
      G4double TM1 = 2.0 * std::sqrt(u[0] * TM[0]) - ue;
 
      if (TM1 > huge_num) TM1 = huge_num;
      else if (TM1 < small) TM1 = small;
 
      W[0] *= std::exp(TM1);
      prob_sum += W[0];
    }
      
    for (i = 1; i < 6; i++) {
      W[i] = 0.0;
      if (TM[i] > cut_off_energy) {
    W[i] = BE * G4cbrt(A1[i]*A1[i]) * G[i] * (1.0 + CPA[i]);
    G4double TM1 = 2.0 * std::sqrt(u[i] * TM[i]) - ue;
 
    if (TM1 > huge_num) TM1 = huge_num;
    else if (TM1 < small) TM1 = small;
 
    W[i] *= std::exp(TM1);
    prob_sum += W[i];
      }
    }
 
    // fisson part
    W[6] = 0.0;
    if (A >= 100.0 && fission_open) {
      G4double X2 = Z * Z / A;
      G4double X1 = 1.0 - 2.0 * Z / A; 
      G4double X = 0.019316 * X2 / (1.0 - 1.79 * X1 * X1);
      G4double EF = EEXS - getQF(X, X2, A, Z, EEXS);
      
      if (EF > 0.0) {
    G4double AF = u1 * getAF(X, A, Z, EEXS);
    G4double TM1 = 2.0 * std::sqrt(AF * EF) - ue;
 
    if (TM1 > huge_num) TM1 = huge_num;
    else if (TM1 < small) TM1 = small;
 
    W[6] = BF * std::exp(TM1);
    if (W[6] > fisssion_cut*W[0]) W[6] = fisssion_cut*W[0];          
 
    prob_sum += W[6];
      }
    } 
 
    // again time to decide what next
    if (verboseLevel > 2) {
      G4cout << " Evaporation probabilities: sum = " << prob_sum
         << "\n\t n " << W[0] << " p " << W[1] << " d " << W[2]
         << " He3 " << W[3] << "\n\t t " << W[4] << " alpha " << W[5]
         << " fission " << W[6] << G4endl;
    }
 
    G4int icase = -1;
 
    if (prob_sum < prob_cut_off) {      // photon emission chain
      G4double UCR0 = 2.5 + 150.0 / A;
      G4double T00 = 1.0 / (std::sqrt(u1 / UCR0) - 1.25 / UCR0);
 
      if (verboseLevel > 3)
    G4cout << " UCR0 " << UCR0 << " T00 " << T00 << G4endl;
 
      G4int itry_gam = 0;
      while (EEXS > cut_off_energy && try_again) {
    itry_gam++;
    G4int itry = 0;
    G4double T04 = 4.0 * T00;
    G4double FMAX;
 
    if (T04 < EEXS) {
      FMAX = (T04*T04*T04*T04) * std::exp((EEXS - T04) / T00);
    } else {
      FMAX = EEXS*EEXS*EEXS*EEXS;
    }; 
 
    if (verboseLevel > 3)
      G4cout << " T04 " << T04 << " FMAX (EEXS^4) " << FMAX << G4endl;
 
    G4double S(0), X1(0);
    while (itry < itry_max) {
      itry++;
      S = EEXS * inuclRndm();
      X1 = (S*S*S*S) * std::exp((EEXS - S) / T00);
 
      if (X1 > FMAX * inuclRndm()) break;
    };
 
    if (itry == itry_max) {     // Maximum attempts exceeded
      try_again = false;
      break;
    }
 
    if (verboseLevel > 2) G4cout << " photon escape ?" << G4endl;
 
    if (S < EEXS) {     // Valid evaporate
      S /= GeV;             // Convert to Bertini units
 
      G4double pmod = S;
      G4LorentzVector mom = generateWithRandomAngles(pmod, 0.);
 
      // Push evaporated particle into current rest frame
      mom = toTheNucleiSystemRestFrame.backToTheLab(mom);
 
      if (verboseLevel > 3) {
        G4cout << " nucleus   px " << PEX.px() << " py " << PEX.py()
           << " pz " << PEX.pz() << " E " << PEX.e() << G4endl
           << " evaporate px " << mom.px() << " py " << mom.py()
           << " pz " << mom.pz() << " E " << mom.e() << G4endl;
      }
 
      PEX -= mom;           // Remaining four-momentum
      EEXS -= S*GeV;        // New excitation energy (in MeV)
 
      // NOTE:  In-situ construction will be optimized away (no copying)
      output.addOutgoingParticle(G4InuclElementaryParticle(mom, photon,
                     G4InuclParticle::Equilib));
      
      if (verboseLevel > 3)
        G4cout << output.getOutgoingParticles().back() << G4endl;
      
      ppout += mom;
    } else {
      if (itry_gam == itry_gam_max) try_again = false;
    }
      }     // while (EEXS > cut_off
      try_again = false;
    } else {            // if (prob_sum < prob_cut_off)
      G4double SL = prob_sum * inuclRndm();
      if (verboseLevel > 3) G4cout << " random SL " << SL << G4endl;
 
      G4double S1 = 0.0;
      for (i = 0; i < 7; i++) { // Select evaporation scenario
    S1 += W[i];
    if (SL <= S1) {
      icase = i;
      break;
    };
      };
 
      if (icase < 0) continue;  // Failed to choose scenario, try again
 
      if (icase < 6) { // particle or light nuclei escape
    if (verboseLevel > 2) {
      G4cout << " particle/light-ion escape ("
         << (icase==0 ? "neutron" : icase==1 ? "proton" :
             icase==2 ? "deuteron" : icase==3 ? "He3" :
             icase==4 ? "triton" : icase==5 ? "alpha" : "ERROR!")
         << ")?" << G4endl;
    }
 
    G4double uc = 2.0 * std::sqrt(u[icase] * TM[icase]);
    G4double ur = (uc > huge_num ? std::exp(huge_num) : std::exp(uc));
    G4double d1 = 1.0 / ur;
    G4double d2 = 1.0 / (ur - 1.0);     
    G4int itry1 = 0;
    G4bool bad = true;
 
    while (itry1 < itry_max && bad) {
      itry1++; 
      G4int itry = 0;
      G4double EPR = -1.0;
      G4double S = 0.0;
 
      while (itry < itry_max && EPR < 0.0) {
        itry++;
        G4double uu = uc + std::log((1.0 - d1) * inuclRndm() + d2);
        S = 0.5 * (uc * uc - uu * uu) / u[icase];
        EPR = TM[icase] - S * A / (A - 1.0) + V[icase];
      }; 
 
      if (verboseLevel > 3) {
        G4cout << " EPR " << EPR << " V " << V[icase]
           << " S " << S << " EEXS " << EEXS << G4endl;
      }
 
      if (EPR > 0.0 && S > V[icase] && S < EEXS) {  // real escape
        if (verboseLevel > 2)
          G4cout << " escape itry1 " << itry1 << " icase "
             << icase << " S (MeV) " << S << G4endl;
 
        S /= GeV;               // Convert to Bertini units
 
        if (icase < 2) {    // particle escape
          G4int ptype = 2 - icase;
          if (verboseLevel > 2)
        G4cout << " particle " << ptype << " escape" << G4endl;
          
          // generate particle momentum
          G4double mass =
        G4InuclElementaryParticle::getParticleMass(ptype);
          
          G4double pmod = std::sqrt((2.0 * mass + S) * S);
          G4LorentzVector mom = generateWithRandomAngles(pmod, mass);
          
          // Push evaporated particle into current rest frame
          mom = toTheNucleiSystemRestFrame.backToTheLab(mom);
          
          if (verboseLevel > 2) {
        G4cout << " nucleus   px " << PEX.px() << " py " << PEX.py()
               << " pz " << PEX.pz() << " E " << PEX.e() << G4endl
               << " evaporate px " << mom.px() << " py " << mom.py()
               << " pz " << mom.pz() << " E " << mom.e() << G4endl;
          }
          
          // New excitation energy depends on residual nuclear state
          G4double mass_new =
        G4InuclNuclei::getNucleiMass(A1[icase],Z1[icase]);
          
          G4double EEXS_new = ((PEX-mom).m() - mass_new)*GeV;
          if (EEXS_new < 0.0) continue; // Sanity check for new nucleus
          
          PEX -= mom;       // Remaining four-momentum
          EEXS = EEXS_new;
          
          A = A1[icase];
          Z = Z1[icase];          
          
          // NOTE:  In-situ construction optimizes away (no copying)
          output.addOutgoingParticle(G4InuclElementaryParticle(mom,
                     ptype, G4InuclParticle::Equilib));
          
          if (verboseLevel > 3)
        G4cout << output.getOutgoingParticles().back() << G4endl;
          
          ppout += mom;
          bad = false;
        } else {    // if (icase < 2)
          if (verboseLevel > 2) {
        G4cout << " nucleus A " << AN[icase] << " Z " << Q[icase]
               << " escape icase " << icase << G4endl;
          }
          
          G4double mass =
        G4InuclNuclei::getNucleiMass(AN[icase],Q[icase]);
          
          // generate particle momentum
          G4double pmod = std::sqrt((2.0 * mass + S) * S);
          G4LorentzVector mom = generateWithRandomAngles(pmod,mass);
          
          // Push evaporated particle into current rest frame
          mom = toTheNucleiSystemRestFrame.backToTheLab(mom);
          
          if (verboseLevel > 2) {
        G4cout << " nucleus   px " << PEX.px() << " py " << PEX.py()
               << " pz " << PEX.pz() << " E " << PEX.e() << G4endl
               << " evaporate px " << mom.px() << " py " << mom.py()
               << " pz " << mom.pz() << " E " << mom.e() << G4endl;
          }
          
          // New excitation energy depends on residual nuclear state
          G4double mass_new =
        G4InuclNuclei::getNucleiMass(A1[icase],Z1[icase]);
          
          G4double EEXS_new = ((PEX-mom).m() - mass_new)*GeV;
          if (EEXS_new < 0.0) continue; // Sanity check for new nucleus
          
          PEX -= mom;       // Remaining four-momentum
          EEXS = EEXS_new;
          
          A = A1[icase];
          Z = Z1[icase];
          
          // NOTE:  In-situ constructor optimizes away (no copying)
          output.addOutgoingNucleus(G4InuclNuclei(mom,
                        AN[icase], Q[icase], 0.*GeV, 
                        G4InuclParticle::Equilib));
          
          if (verboseLevel > 3) 
        G4cout << output.getOutgoingNuclei().back() << G4endl;
          
          ppout += mom;
          bad = false;
        }       // if (icase < 2)
      }     // if (EPR > 0.0 ...
    }       // while (itry1 ...
 
    if (itry1 == itry_max || bad) try_again = false;
      } else {  // if (icase < 6)
    G4InuclNuclei nuclei(A, Z, EEXS, G4InuclParticle::Equilib);        
 
    if (verboseLevel > 2) {
      G4cout << " fission: A " << A << " Z " << Z << " eexs " << EEXS
         << " Wn " << W[0] << " Wf " << W[6] << G4endl;
    }
 
    // Catch fission output separately for verification
    fission_output.reset();
    theFissioner.collide(0, &nuclei, fission_output);
 
    std::vector<G4InuclNuclei>& nuclea = fission_output.getOutgoingNuclei();
    if (nuclea.size() == 2) {       // fission ok
      if (verboseLevel > 2) G4cout << " fission done in eql" << G4endl;
 
      // Move fission fragments to lab frame for processing
      fission_output.boostToLabFrame(toTheNucleiSystemRestFrame);
 
      // Now evaporate the fission fragments individually
      G4bool prevDoChecks = doConservationChecks;   // Turn off checking
      setConservationChecks(false);
 
      this->collide(0, &nuclea[0], output);
      this->collide(0, &nuclea[1], output);
 
      setConservationChecks(prevDoChecks);  // Restore previous flag value
      validateOutput(0, target, output);    // Check energy conservation
      return;
    } else { // fission forbidden now
      fission_open = false;
    }
      }     // End of fission case
    }       // if (prob_sum < prob_cut_off)
  }     // while (try_again
 
  // this time it's final nuclei
 
  if (itry_global == itry_global_max) {
    if (verboseLevel > 3) {
      G4cout << " ! itry_global " << itry_global_max << G4endl;
    }
  }
 
  G4LorentzVector pnuc = pin - ppout;
 
  // NOTE:  In-situ constructor will be optimized away (no copying)
  output.addOutgoingNucleus(G4InuclNuclei(pnuc, A, Z, EEXS,
                      G4InuclParticle::Equilib));
 
  if (verboseLevel > 3) {
    G4cout << " remaining nucleus \n" << output.getOutgoingNuclei().back()
       << G4endl;
  }
 
 
  validateOutput(0, target, output);        // Check energy conservation
  return;
}            
 
G4bool G4EquilibriumEvaporator::explosion(G4int a, 
                      G4int z, 
                      G4double e) const {
  if (verboseLevel > 3) {
    G4cout << " >>> G4EquilibriumEvaporator::explosion? ";
  }
 
  const G4double be_cut = 3.0;
 
  // Different criteria from base class, since nucleus more "agitated"
  G4bool bigb = (!(a >= 12 && z >= 0 && z < 3*(a-z)) &&
         (e >= be_cut * bindingEnergy(a,z))
         );
 
  if (verboseLevel > 3) G4cout << bigb << G4endl;
 
  return bigb;
}
 
G4bool G4EquilibriumEvaporator::goodRemnant(G4int a, 
                        G4int z) const {
  if (verboseLevel > 3) {
    G4cout << " >>> G4EquilibriumEvaporator::goodRemnant(" << a << "," << z
       << ")? " << (a>1 && z>0 && a>z) << G4endl;
  }
 
  return a > 1 && z > 0 && a > z;
}
 
G4double G4EquilibriumEvaporator::getQF(G4double x, 
                    G4double x2, 
                    G4int a,
                    G4int /*z*/, 
                    G4double ) const {
  if (verboseLevel > 3) {
    G4cout << " >>> G4EquilibriumEvaporator::getQF ";
  }
  
  static const G4double QFREP[72] = {  
    //     TL201 *     *   *    *
    //      1    2     3   4    5
    22.5, 22.0, 21.0, 21.0, 20.0,
    //     BI209 BI207 PO210 AT213 *    TH234
    //      6     7    8     9     10   11
    20.6, 20.6, 18.6, 15.8, 13.5, 6.5,
    //     TH233 TH232 TH231 TH230 TX229 PA233 PA232 PA231 PA230 U240
    //     12    13    14    15    16    17    18    19    20    21
    6.65, 6.22, 6.27, 6.5,  6.7,  6.2,  6.25, 5.9,  6.1,  5.75,
    //     U239 U238 U237  U236 U235 U234 U233 U232 U231
    //     22   23   24    25   26   27   28   29   30
    6.46, 5.7, 6.28, 5.8, 6.15, 5.6, 5.8, 5.2, 5.8,
    //     NP238 NP237 NP236 NP235 PU245 NP234  PU244 NP233
    //     31    32    33    34    35    36     37    38
    6.2 , 5.9 , 5.9,  6.0,  5.8,  5.7,   5.4,  5.4,
    //     PU242 PU241 PU240 PU239 PU238 AM247 PU236 AM245 AM244 AM243
    //     39    40    41    42    43    44    45    46    47    48
    5.6,  6.1,  5.57, 6.3,  5.5,  5.8,  4.7,  6.2,  6.4,  6.2,
    //     AM242 AM241 AM240 CM250 AM239 CM249 CM248 CM247 CM246
    //     49    50    51    52    53    54    55    56    57
    6.5,  6.2,  6.5,  5.3,  6.4,  5.7,  5.7,  6.2,  5.7,
    //     CM245 CM244 CM243 CM242 CM241 BK250 CM240
    //     58    59    60    61    62    63    64
    6.3,  5.8,  6.7,  5.8,  6.6,  6.1,  4.3,
    //     BK249 CF252 CF250 CF248 CF246 ES254 ES253 FM254
    //     65    66    67    68    69    70    71    72
    6.2,  3.8,  5.6,  4.0,  4.0,  4.2,  4.2,  3.5 };
     
  static const G4double XREP[72] = {
    //      1      2     3      4      5
    0.6761, 0.677, 0.6788, 0.6803, 0.685,
    //      6     7     8     9     10     11
    0.6889, 0.6914, 0.6991, 0.7068, 0.725, 0.7391,
    //     12  13    14   15   16    17  18    19    20    21
    0.74, 0.741, 0.742, 0.743, 0.744, 0.7509, 0.752, 0.7531, 0.7543, 0.7548,
    //     22    23    24
    0.7557, 0.7566, 0.7576,
    //      25     26   27    28    29   30   31    32     33    34
    0.7587, 0.7597, 0.7608, 0.762, 0.7632, 0.7644, 0.7675, 0.7686, 0.7697, 0.7709,
    //      35    36    37    38    39   40    41
    0.7714, 0.7721, 0.7723, 0.7733, 0.7743, 0.7753, 0.7764,
    //      42    43    44    45    46    47    48   49
    0.7775, 0.7786, 0.7801, 0.781, 0.7821, 0.7831, 0.7842, 0.7852,
    //     50     51    52    53    54    55    56    57    58
    0.7864, 0.7875, 0.7880, 0.7887, 0.7889, 0.7899, 0.7909, 0.7919, 0.7930,
    //      59    60    61    62    63    64
    0.7941, 0.7953, 0.7965, 0.7977, 0.7987, 0.7989,
    //      65    66    67    68    69    70    71    72
    0.7997, 0.8075, 0.8097, 0.8119, 0.8143, 0.8164, 0.8174, 0.8274 };
 
  const G4double G0 = 20.4;
  const G4double XMIN = 0.6761;
  const G4double XMAX = 0.8274;
 
  G4double QFF = 0.0;
 
  if (x < XMIN || x > XMAX) {
    G4double X1 = 1.0 - 0.02 * x2;
    G4double FX = (0.73 + (3.33 * X1 - 0.66) * X1) * (X1*X1*X1);
 
    QFF = G0 * FX * G4cbrt(a*a);
  } else {
    static G4CascadeInterpolator<72> interp(XREP);  // Only need one!
    QFF = interp.interpolate(x, QFREP);
  }
 
  if (QFF < 0.0) QFF = 0.0;
 
  if (verboseLevel>3) G4cout << " returns " << QFF << G4endl;
 
  return QFF; 
}
 
G4double G4EquilibriumEvaporator::getAF(G4double , 
                    G4int /*a*/, 
                    G4int /*z*/, 
                    G4double e) const {
 
  if (verboseLevel > 3) {
    G4cout << " >>> G4EquilibriumEvaporator::getAF" << G4endl;
  }
 
  // ugly parameterisation to fit the experimental fission cs for Hg - Bi nuclei
  G4double AF = 1.285 * (1.0 - e / 1100.0);
 
  if(AF < 1.06) AF = 1.06;
  // if(AF < 1.08) AF = 1.08;
 
  return AF;
}   
 
G4double G4EquilibriumEvaporator::getPARLEVDEN(G4int /*a*/, 
                           G4int /*z*/) const {
 
  if (verboseLevel > 3) {
    G4cout << " >>> G4EquilibriumEvaporator::getPARLEVDEN" << G4endl;
  }
 
  const G4double par = 0.125;
 
  return par;
}
 
G4double G4EquilibriumEvaporator::getE0(G4int /*a*/) const {
 
  if (verboseLevel > 3) {
    G4cout << " >>> G4EquilibriumEvaporator::getE0" << G4endl;
  }
 
  const G4double e0 = 200.0;   
 
  return e0;   
}