G4CascadeInterface.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
// 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
// 20100414  M. Kelsey -- Check for K0L/K0S before using G4InuclElemPart::type
// 20100418  M. Kelsey -- Reference output particle lists via const-ref, use
//      const_iterator for both.
// 20100428  M. Kelsey -- Use G4InuclParticleNames enum
// 20100429  M. Kelsey -- Change "case gamma:" to "case photon:"
// 20100517  M. Kelsey -- Follow new ctors for G4*Collider family.
// 20100520  M. Kelsey -- Simplify collision loop, move momentum rotations to
//      G4CollisionOutput, copy G4DynamicParticle directly from
//      G4InuclParticle, no switch-block required.
// 20100615  M. Kelsey -- Bug fix: For K0's need ekin in GEANT4 units
// 20100617  M. Kelsey -- Rename "debug_" preprocessor flag to G4CASCADE_DEBUG,
//      and "BERTDEV" to "G4CASCADE_COULOMB_DEV"
// 20100617  M. Kelsey -- Make G4InuclCollider a local data member
// 20100618  M. Kelsey -- Deploy energy-conservation test on final state, with
//      preprocessor flag G4CASCADE_SKIP_ECONS to skip test.
// 20100620  M. Kelsey -- Use new energy-conservation pseudo-collider
// 20100621  M. Kelsey -- Fix compiler warning from GCC 4.5
// 20100624  M. Kelsey -- Fix cascade loop to check nTries every time (had
//      allowed for infinite loop on E-violation); dump event data
//      to output if E-violation exceeds maxTries; use CheckBalance
//      for baryon and charge conservation.
// 20100701  M. Kelsey -- Pass verbosity through to G4CollisionOutput
// 20100714  M. Kelsey -- Report number of iterations before success
// 20100720  M. Kelsey -- Use G4CASCADE_SKIP_ECONS flag for reporting
// 20100723  M. Kelsey -- Move G4CollisionOutput to .hh file for reuse
// 20100914  M. Kelsey -- Migrate to integer A and Z
// 20100916  M. Kelsey -- Simplify ApplyYourself() by encapsulating code blocks
//      into numerous functions; make data-member colliders pointers;
//      provide support for projectile nucleus
// 20100919  M. Kelsey -- Fix incorrect logic in retryInelasticNucleus()
// 20100922  M. Kelsey -- Add functions to select de-excitation method
// 20100924  M. Kelsey -- Migrate to "OutgoingNuclei" names in CollisionOutput 
// 20110224  M. Kelsey -- Add createTarget() for use with Propagate(); split
//      conservation law messages to separate function; begin to add
//      infrastructure code to Propagate.  Move verbose
//      setting to .cc file, and apply to all member objects.
// 20110301  M. Kelsey -- Add copyPreviousCascade() for use with Propagate()  
//      along with new buffers and related particle-conversion  
//      functions.  Encapulate buffer deletion in clear().  Add some
//      diagnostic messages.
// 20110302  M. Kelsey -- Redo diagnostics inside G4CASCADE_DEBUG_INTERFACE
// 20110304  M. Kelsey -- Drop conversion of Propagate() arguments; pass
//      directly to collider for processing.  Rename makeReactionProduct
//      to makeDynamicParticle.
// 20110316  M. Kelsey -- Move kaon-mixing for type-code into G4InuclParticle;
//      add placeholders to capture and use bullet in Propagte
// 20110327  G. Folger -- Set up for E/p checking by G4HadronicProcess in ctor
// 20110328  M. Kelsey -- Modify balance() initialization to match Gunter's
// 20110404  M. Kelsey -- Get primary projectile from base class (ref-03)
// 20110502  M. Kelsey -- Add interface to capture random seeds for user
// 20110719  M. Kelsey -- Use trivialise() in case maximum retries are reached
// 20110720  M. Kelsey -- Discard elastic-cut array (no longer needed),
//      discard local "theFinalState" (in base as "theParticleChange"),
//      Modify createBullet() to set null pointer if bullet unusable,
//      return empty final-state on failures.
//      Fix charge violation report before throwing exception.
// 20110722  M. Kelsey -- In makeDynamicParticle(), allow invalid type codes
//      in order to process, e.g., resonances from Propagate() input
// 20110728  M. Kelsey -- Per V.Ivantchenko, change NoInteraction to return
//      zero particles, but set kinetic energy from projectile.
// 20110801  M. Kelsey -- Make bullet, target point to local buffers, no delete
// 20110802  M. Kelsey -- Use new decay handler for Propagate interface
// 20110922  M. Kelsey -- Follow migration of G4InuclParticle::print(), use
//      G4ExceptionDescription for reporting before throwing exception
// 20120125  M. Kelsey -- In retryInelasticProton() check for empty output
// 20120525  M. Kelsey -- In NoInteraction, check for Ekin<0., set to zero;
//      use SetEnergyChange(0.) explicitly for good final states.
// 20120822  M. Kelsey -- Move envvars to G4CascadeParameters.
 
#include <cmath>
#include <iostream>
 
#include "G4CascadeInterface.hh"
#include "globals.hh"
#include "G4SystemOfUnits.hh"
#include "G4CascadeChannelTables.hh"
#include "G4CascadeCheckBalance.hh"
#include "G4CascadeParameters.hh"
#include "G4CollisionOutput.hh"
#include "G4DecayKineticTracks.hh"
#include "G4DynamicParticle.hh"
#include "G4HadronicException.hh"
#include "G4InuclCollider.hh"
#include "G4InuclElementaryParticle.hh"
#include "G4InuclNuclei.hh"
#include "G4InuclParticle.hh"
#include "G4InuclParticleNames.hh"
#include "G4KaonZeroLong.hh"
#include "G4KaonZeroShort.hh"
#include "G4KineticTrack.hh"
#include "G4KineticTrackVector.hh"
#include "G4Nucleus.hh"
#include "G4ParticleDefinition.hh"
#include "G4ReactionProductVector.hh"
#include "G4Track.hh"
#include "G4V3DNucleus.hh"
 
using namespace G4InuclParticleNames;
 
typedef std::vector<G4InuclElementaryParticle>::const_iterator particleIterator;
typedef std::vector<G4InuclNuclei>::const_iterator nucleiIterator;
 
 
// Filename to capture random seed, if specified by user at runtime
 
const G4String G4CascadeInterface::randomFile = G4CascadeParameters::randomFile();
 
// Maximum number of iterations allowed for inelastic collision attempts
 
const G4int G4CascadeInterface::maximumTries = 20;
 
 
// Constructor and destrutor
 
G4CascadeInterface::G4CascadeInterface(const G4String& name)
  : G4VIntraNuclearTransportModel(name), numberOfTries(0),
    collider(new G4InuclCollider), balance(new G4CascadeCheckBalance(name)),
    bullet(0), target(0), output(new G4CollisionOutput) {
  SetEnergyMomentumCheckLevels(5*perCent, 10*MeV);
  balance->setLimits(5*perCent, 10*MeV/GeV);    // Bertini internal units
  // Description();                                // Model description
 
  this->SetVerboseLevel(G4CascadeParameters::verbose());
  if (G4CascadeParameters::usePreCompound()) usePreCompoundDeexcitation();
}
 
 
G4CascadeInterface::~G4CascadeInterface() {
  clear();
  delete collider; collider=0;
  delete balance; balance=0;
  delete output; output=0;
}
 
void G4CascadeInterface::ModelDescription(std::ostream& outFile) const
{
  outFile << "The Bertini-style cascade implements the inelastic scattering\n"
          << "of hadrons by nuclei.  Nucleons, pions, kaons and hyperons\n"
          << "from 0 to 15 GeV may be used as projectiles in this model.\n"
          << "Final state hadrons are produced by a classical cascade\n"
          << "consisting of individual hadron-nucleon scatterings which use\n"
          << "free-space partial cross sections, corrected for various\n"
          << "nuclear medium effects.  The target nucleus is modeled as a\n"
          << "set of 1, 3 or 6 spherical shells, in which scattered hadrons\n"
          << "travel in straight lines until they are reflected from or\n"
          << "transmitted through shell boundaries.\n";
}
 
void G4CascadeInterface::DumpConfiguration(std::ostream& outFile) const {
  G4CascadeParameters::DumpConfiguration(outFile);
}
 
 
void G4CascadeInterface::clear() {
  bullet=0;
  target=0;
}
 
 
// Select post-cascade processing (default will be CascadeDeexcitation)
// NOTE:  Currently just calls through to Collider, in future will do something
 
void G4CascadeInterface::useCascadeDeexcitation() {
  collider->useCascadeDeexcitation();
}
 
void G4CascadeInterface::usePreCompoundDeexcitation() {
  collider->usePreCompoundDeexcitation();
}
 
 
// Apply verbosity to all member objects (overrides base class version)
 
void G4CascadeInterface::SetVerboseLevel(G4int verbose) {
  G4HadronicInteraction::SetVerboseLevel(verbose);
  collider->setVerboseLevel(verbose);
  balance->setVerboseLevel(verbose);
  output->setVerboseLevel(verbose);
}
 
 
// Test whether inputs are valid for this model
 
G4bool G4CascadeInterface::IsApplicable(const G4HadProjectile& aTrack,
                    G4Nucleus& /* theNucleus */) {
  return IsApplicable(aTrack.GetDefinition());  
}
 
G4bool G4CascadeInterface::IsApplicable(const G4ParticleDefinition* aPD) const {
  if (aPD->GetAtomicMass() > 1) return true;        // Nuclei are okay
 
  // Valid particle and have interactions available
  G4int type = G4InuclElementaryParticle::type(aPD);
  return (type>0 && G4CascadeChannelTables::GetTable(type));
}
 
 
// Main Actions
 
G4HadFinalState* 
G4CascadeInterface::ApplyYourself(const G4HadProjectile& aTrack, 
                  G4Nucleus& theNucleus) {
  if (verboseLevel)
    G4cout << " >>> G4CascadeInterface::ApplyYourself" << G4endl;
 
  if (aTrack.GetKineticEnergy() < 0.) {
    G4cerr << " >>> G4CascadeInterface got negative-energy track: "
       << aTrack.GetDefinition()->GetParticleName() << " Ekin = "
       << aTrack.GetKineticEnergy() << G4endl;
  }
 
#ifdef G4CASCADE_DEBUG_INTERFACE
  static G4int counter(0);
  counter++;
  G4cerr << "Reaction number "<< counter << " "
     << aTrack.GetDefinition()->GetParticleName() << " "
     << aTrack.GetKineticEnergy() << " MeV" << G4endl;
#endif
 
  if (!randomFile.empty()) {        // User requested random-seed capture
    if (verboseLevel>1) 
      G4cout << " Saving random engine state to " << randomFile << G4endl;
    CLHEP::HepRandom::saveEngineStatus(randomFile);
  }
 
  theParticleChange.Clear();
  clear();
 
  // Abort processing if no interaction is possible
  if (!IsApplicable(aTrack, theNucleus)) {
    if (verboseLevel) G4cerr << " No interaction possible " << G4endl;
    return NoInteraction(aTrack, theNucleus);
  }
 
  // Make conversion between native Geant4 and Bertini cascade classes.
  if (!createBullet(aTrack)) {
    if (verboseLevel) G4cerr << " Unable to create usable bullet" << G4endl;
    return NoInteraction(aTrack, theNucleus);
  }
 
  if (!createTarget(theNucleus)) {
    if (verboseLevel) G4cerr << " Unable to create usable target" << G4endl;
    return NoInteraction(aTrack, theNucleus);
  }
 
  // Different retry conditions for proton target vs. nucleus
  const G4bool isHydrogen = (theNucleus.GetA_asInt() == 1);
 
  numberOfTries = 0;
  do {              // we try to create inelastic interaction
    if (verboseLevel > 1)
      G4cout << " Generating cascade attempt " << numberOfTries << G4endl;
    
    output->reset();
    collider->collide(bullet, target, *output);
    balance->collide(bullet, target, *output);
    
    numberOfTries++;
  } while ( isHydrogen ? retryInelasticProton() : retryInelasticNucleus() );
 
  // Null event if unsuccessful
  if (numberOfTries >= maximumTries) {
    if (verboseLevel) 
      G4cout << " Cascade aborted after trials " << numberOfTries << G4endl;
    return NoInteraction(aTrack, theNucleus);
  }
 
  // Abort job if energy or momentum are not conserved
  if (!balance->okay()) {
    throwNonConservationFailure();
    return NoInteraction(aTrack, theNucleus);
  }
 
  // Successful cascade -- clean up and return
  if (verboseLevel) {
    G4cout << " Cascade output after trials " << numberOfTries << G4endl;
    if (verboseLevel > 1) output->printCollisionOutput();
  }
 
  // Rotate event to put Z axis along original projectile direction
  output->rotateEvent(bulletInLabFrame);
 
  copyOutputToHadronicResult();
 
  // Report violations of conservation laws in original frame
  checkFinalResult();
 
  // Clean up and return final result;
  clear();
  return &theParticleChange;
}
 
G4ReactionProductVector* 
G4CascadeInterface::Propagate(G4KineticTrackVector* theSecondaries,
                  G4V3DNucleus* theNucleus) {
  if (verboseLevel) G4cout << " >>> G4CascadeInterface::Propagate" << G4endl;
 
#ifdef G4CASCADE_DEBUG_INTERFACE
  if (verboseLevel>1) {
    G4cout << " G4V3DNucleus A " << theNucleus->GetMassNumber()
       << " Z " << theNucleus->GetCharge()
       << "\n " << theSecondaries->size() << " secondaries:" << G4endl;
    for (size_t i=0; i<theSecondaries->size(); i++) {
      G4KineticTrack* kt = (*theSecondaries)[i];
      G4cout << " " << i << ": " << kt->GetDefinition()->GetParticleName() 
         << " p " << kt->Get4Momentum() << " @ " << kt->GetPosition()
         << " t " << kt->GetFormationTime() << G4endl;
    }
  }
#endif
 
  if (!randomFile.empty()) {        // User requested random-seed capture
    if (verboseLevel>1) 
      G4cout << " Saving random engine state to " << randomFile << G4endl;
    CLHEP::HepRandom::saveEngineStatus(randomFile);
  }
 
  theParticleChange.Clear();
  clear();
 
  // Process input secondaries list to eliminate resonances
  G4DecayKineticTracks decay(theSecondaries);
 
  // NOTE:  Requires 9.4-ref-03 mods to base class and G4TheoFSGenerator
  const G4HadProjectile* projectile = GetPrimaryProjectile();
  if (projectile) createBullet(*projectile);
 
  if (!createTarget(theNucleus)) {
    if (verboseLevel) G4cerr << " Unable to create usable target" << G4endl;
    return 0;   // FIXME:  This will cause a segfault later
  }
 
  numberOfTries = 0;
  do {
    if (verboseLevel > 1)
      G4cout << " Generating rescatter attempt " << numberOfTries << G4endl;
 
    output->reset();
    collider->rescatter(bullet, theSecondaries, theNucleus, *output);
    balance->collide(bullet, target, *output);
 
    numberOfTries++;
    // FIXME:  retry checks will SEGFAULT until we can define the bullet!
  } while (retryInelasticNucleus());
 
  // Check whether repeated attempts have all failed; report and exit
  if (numberOfTries >= maximumTries && !balance->okay()) {
    throwNonConservationFailure();  // This terminates the job
  }
 
  // Successful cascade -- clean up and return
  if (verboseLevel) {
    G4cout << " Cascade rescatter after trials " << numberOfTries << G4endl;
    if (verboseLevel > 1) output->printCollisionOutput();
  }
 
  // Does calling code take ownership?  I hope so!
  G4ReactionProductVector* propResult = copyOutputToReactionProducts();
 
  // Clean up and and return final result
  clear();
  return propResult;
}
 
 
// Replicate input particles onto output
 
G4HadFinalState* 
G4CascadeInterface::NoInteraction(const G4HadProjectile& aTrack,
                  G4Nucleus& /*theNucleus*/) {
  if (verboseLevel) 
    G4cout << " >>> G4CascadeInterface::NoInteraction" << G4endl;
 
  theParticleChange.Clear();
  theParticleChange.SetStatusChange(isAlive);
 
  G4double ekin = aTrack.GetKineticEnergy()>0. ? aTrack.GetKineticEnergy() : 0.;
  theParticleChange.SetEnergyChange(ekin);  // Protect against rounding
 
  return &theParticleChange;
}
 
 
// Convert input projectile to Bertini internal object
 
G4bool G4CascadeInterface::createBullet(const G4HadProjectile& aTrack) {
  const G4ParticleDefinition* trkDef = aTrack.GetDefinition();
 
  G4int bulletType = 0;         // For elementary particles
  G4int bulletA = 0, bulletZ = 0;   // For nucleus projectile
 
  if (trkDef->GetAtomicMass() <= 1) {
    bulletType = G4InuclElementaryParticle::type(trkDef);
  } else {
    bulletA = trkDef->GetAtomicMass();
    bulletZ = trkDef->GetAtomicNumber();
  }
 
  if (0 == bulletType && 0 == bulletA*bulletZ) {
    if (verboseLevel) {
      G4cerr << " G4CascadeInterface: " << trkDef->GetParticleName()
         << " not usable as bullet." << G4endl;
    }
    bullet = 0;
    return false;
  }
 
  // Code momentum and energy -- Bertini wants z-axis and GeV units
  G4LorentzVector projectileMomentum = aTrack.Get4Momentum()/GeV;
  
  // Rotation/boost to get from z-axis back to original frame
  bulletInLabFrame = G4LorentzRotation::IDENTITY;   // Initialize
  bulletInLabFrame.rotateZ(-projectileMomentum.phi());
  bulletInLabFrame.rotateY(-projectileMomentum.theta());
  bulletInLabFrame.invert();
  
  G4LorentzVector momentumBullet(0., 0., projectileMomentum.rho(),
                 projectileMomentum.e());
 
  if (bulletType > 0) {
    hadronBullet.fill(momentumBullet, bulletType);
    bullet = &hadronBullet;
  } else {
    nucleusBullet.fill(momentumBullet, bulletA, bulletZ);
    bullet = &nucleusBullet;
  }
 
  if (verboseLevel > 2) G4cout << "Bullet:  \n" << *bullet << G4endl;  
 
  return true;
}
 
 
// Convert input nuclear target to Bertini internal object
 
G4bool G4CascadeInterface::createTarget(G4Nucleus& theNucleus) {
  return createTarget(theNucleus.GetA_asInt(), theNucleus.GetZ_asInt());
}
 
G4bool G4CascadeInterface::createTarget(G4V3DNucleus* theNucleus) {
  return createTarget(theNucleus->GetMassNumber(), theNucleus->GetCharge());
}
 
G4bool G4CascadeInterface::createTarget(G4int A, G4int Z) {
  if (A > 1) {
    nucleusTarget.fill(A, Z);
    target = &nucleusTarget;
  } else {
    hadronTarget.fill(0., (Z=1?proton:neutron));
    target = &hadronTarget;
  }
 
  if (verboseLevel > 2) G4cout << "Target:  \n" << *target << G4endl;
 
  return true;      // Right now, target never fails
}
 
 
// Convert Bertini particle to output (G4DynamicParticle)
 
G4DynamicParticle* G4CascadeInterface::
makeDynamicParticle(const G4InuclElementaryParticle& iep) const {
  G4int outgoingType = iep.type();
  
  if (iep.quasi_deutron()) {
    G4cerr << " ERROR: G4CascadeInterface incompatible particle type "
       << outgoingType << G4endl;
    return 0;
  }
  
  // Copy local G4DynPart to public output (handle kaon mixing specially)
  if (outgoingType == kaonZero || outgoingType == kaonZeroBar) {
    G4ThreeVector momDir = iep.getMomentum().vect().unit();
    G4double ekin = iep.getKineticEnergy()*GeV; // Bertini -> G4 units
    
    G4ParticleDefinition* pd = G4KaonZeroShort::Definition();
    if (G4UniformRand() > 0.5) pd = G4KaonZeroLong::Definition();
    
    return new G4DynamicParticle(pd, momDir, ekin);
  } else {
    return new G4DynamicParticle(iep.getDynamicParticle());
  }
  
  return 0; // Should never get here!
}
 
G4DynamicParticle* 
G4CascadeInterface::makeDynamicParticle(const G4InuclNuclei& inuc) const {
  if (verboseLevel > 2) {
    G4cout << " Nuclei fragment: \n" << inuc << G4endl;
  }
  
  // Copy local G4DynPart to public output 
  return new G4DynamicParticle(inuc.getDynamicParticle());
}
 
 
// Transfer Bertini internal final state to hadronics interface
 
void G4CascadeInterface::copyOutputToHadronicResult() {
  if (verboseLevel > 1)
    G4cout << " >>> G4CascadeInterface::copyOutputToHadronicResult" << G4endl;
 
  const std::vector<G4InuclNuclei>& outgoingNuclei = output->getOutgoingNuclei();
  const std::vector<G4InuclElementaryParticle>& particles = output->getOutgoingParticles();
 
  theParticleChange.SetStatusChange(stopAndKill);
  theParticleChange.SetEnergyChange(0.);
 
  // Get outcoming particles
  if (!particles.empty()) { 
    particleIterator ipart = particles.begin();
    for (; ipart != particles.end(); ipart++) {
      theParticleChange.AddSecondary(makeDynamicParticle(*ipart));
    }
  }
 
  // get nuclei fragments
  if (!outgoingNuclei.empty()) { 
    nucleiIterator ifrag = outgoingNuclei.begin();
    for (; ifrag != outgoingNuclei.end(); ifrag++) {
      theParticleChange.AddSecondary(makeDynamicParticle(*ifrag)); 
    }
  }
}
 
G4ReactionProductVector* G4CascadeInterface::copyOutputToReactionProducts() {
  if (verboseLevel > 1)
    G4cout << " >>> G4CascadeInterface::copyOutputToReactionProducts" << G4endl;
 
  const std::vector<G4InuclElementaryParticle>& particles = output->getOutgoingParticles();
  const std::vector<G4InuclNuclei>& fragments = output->getOutgoingNuclei();
 
  G4ReactionProductVector* propResult = new G4ReactionProductVector;
 
  G4ReactionProduct* rp = 0;    // Buffers to create outgoing tracks
  G4DynamicParticle* dp = 0;
 
  // Get outcoming particles
  if (!particles.empty()) { 
    particleIterator ipart = particles.begin();
    for (; ipart != particles.end(); ipart++) {
      rp = new G4ReactionProduct;
      dp = makeDynamicParticle(*ipart);
      (*rp) = (*dp);        // This does all the necessary copying
      propResult->push_back(rp);
      delete dp;
    }
  }
 
  // get nuclei fragments
  if (!fragments.empty()) { 
    nucleiIterator ifrag = fragments.begin();
    for (; ifrag != fragments.end(); ifrag++) {
      rp = new G4ReactionProduct;
      dp = makeDynamicParticle(*ifrag);
      (*rp) = (*dp);        // This does all the necessary copying
      propResult->push_back(rp);
      delete dp;
    }
  }
 
  return propResult;
}
 
 
// Report violations of conservation laws in original frame
 
void G4CascadeInterface::checkFinalResult() {
  balance->collide(bullet, target, *output);
 
  if (verboseLevel > 2) {
    if (!balance->baryonOkay()) {
      G4cerr << "ERROR: no baryon number conservation, sum of baryons = "
             << balance->deltaB() << G4endl;
    }
 
    if (!balance->chargeOkay()) {
      G4cerr << "ERROR: no charge conservation, sum of charges = "
         << balance->deltaQ() << G4endl;
    }
 
    if (std::abs(balance->deltaKE()) > 0.01 ) { // GeV
      G4cerr << "Kinetic energy conservation violated by "
         << balance->deltaKE() << " GeV" << G4endl;
    }
 
    G4double eInit = bullet->getEnergy() + target->getEnergy();
    G4double eFinal = eInit + balance->deltaE();
 
    G4cout << "Initial energy " << eInit << " final energy " << eFinal
       << "\nTotal energy conservation at level "
       << balance->deltaE() * GeV << " MeV" << G4endl;
    
    if (balance->deltaKE() > 5.0e-5 ) {     // 0.05 MeV
      G4cerr << "FATAL ERROR: kinetic energy created  "
             << balance->deltaKE() * GeV << " MeV" << G4endl;
    }
  }
}
 
 
// Evaluate whether any outgoing particles penetrated Coulomb barrier
 
G4bool G4CascadeInterface::coulombBarrierViolation() const {
  G4bool violated = false;          // by default coulomb analysis is OK
 
  const G4double coulumbBarrier = 8.7 * MeV/GeV;    // Bertini uses GeV
 
  const std::vector<G4InuclElementaryParticle>& p =
    output->getOutgoingParticles();
 
  for (particleIterator ipart=p.begin(); ipart != p.end(); ipart++) {
    if (ipart->type() == proton) {
      violated |= (ipart->getKineticEnergy() < coulumbBarrier);
    }
  }
 
  return violated;
}
 
// Check whether inelastic collision on proton failed
 
G4bool G4CascadeInterface::retryInelasticProton() const {
  const std::vector<G4InuclElementaryParticle>& out =
    output->getOutgoingParticles();
 
#ifdef G4CASCADE_DEBUG_INTERFACE
  // Report on all retry conditions, in order of return logic
  G4cout << " retryInelasticProton: number of Tries "
     << ((numberOfTries < maximumTries) ? "RETRY (t)" : "EXIT (f)")
     << "\n retryInelasticProton: AND collision type ";
  if (out.empty()) G4cout << "FAILED" << G4endl;
  else {
    G4cout << (out.size() == 2 ? "ELASTIC (t)" : "INELASTIC (f)")
       << "\n retryInelasticProton: AND Leading particles bullet "
       << (out.size() >= 2 &&
           (out[0].getDefinition() == bullet->getDefinition() ||
        out[1].getDefinition() == bullet->getDefinition())
           ? "YES (t)" : "NO (f)")
       << G4endl;
  }
#endif
 
  return ( (numberOfTries < maximumTries) &&
       (out.empty() ||
        (out.size() == 2 &&
         (out[0].getDefinition() == bullet->getDefinition() ||
          out[1].getDefinition() == bullet->getDefinition())))
       );
}
 
// Check whether generic inelastic collision failed
// NOTE:  some conditions are set by compiler flags
 
G4bool G4CascadeInterface::retryInelasticNucleus() const {
  // Quantities necessary for conditional block below
  G4int npart = output->numberOfOutgoingParticles();
  G4int nfrag = output->numberOfOutgoingNuclei();
 
  const G4ParticleDefinition* firstOut = (npart == 0) ? 0 :
    output->getOutgoingParticles().begin()->getDefinition();
 
#ifdef G4CASCADE_DEBUG_INTERFACE
  // Report on all retry conditions, in order of return logic
  G4cout << " retryInelasticNucleus: numberOfTries "
     << ((numberOfTries < maximumTries) ? "RETRY (t)" : "EXIT (f)")
     << "\n retryInelasticNucleus: AND outputParticles "
     << ((npart != 0) ? "NON-ZERO (t)" : "EMPTY (f)")
#ifdef G4CASCADE_COULOMB_DEV
     << "\n retryInelasticNucleus: AND coulombBarrier (COULOMB_DEV) "
     << (coulombBarrierViolation() ? "VIOLATED (t)" : "PASSED (f)")
     << "\n retryInelasticNucleus: AND collision type (COULOMB_DEV) "
     << ((npart+nfrag > 2) ? "INELASTIC (t)" : "ELASTIC (f)")
#else
     << "\n retryInelasticNucleus: AND collsion type "
     << ((npart+nfrag < 3) ? "ELASTIC (t)" : "INELASTIC (f)")
     << "\n retryInelasticNucleus: AND Leading particle bullet "
     << ((firstOut == bullet->getDefinition()) ? "YES (t)" : "NO (f)")
#endif
     << "\n retryInelasticNucleus: OR conservation "
     << (!balance->okay() ? "FAILED (t)" : "PASSED (f)")
     << G4endl;
#endif
 
  return ( ((numberOfTries < maximumTries) &&
        (npart != 0) &&
#ifdef G4CASCADE_COULOMB_DEV
        (coulombBarrierViolation() && npart+nfrag > 2)
#else
        (npart+nfrag < 3 && firstOut == bullet->getDefinition())
#endif
        )
#ifndef G4CASCADE_SKIP_ECONS
       || (!balance->okay())
#endif
       );
}
 
 
// Terminate job in case of persistent non-conservation
// FIXME:  Need to migrate to G4ExceptionDescription
 
void G4CascadeInterface::throwNonConservationFailure() {
  // NOTE:  Once G4HadronicException is changed, use the following line!
  // G4ExceptionDescription errInfo;
  std::ostream& errInfo = G4cerr;
 
  errInfo << " >>> G4CascadeInterface has non-conserving"
      << " cascade after " << numberOfTries << " attempts." << G4endl;
 
  G4String throwMsg = "G4CascadeInterface - ";
  if (!balance->energyOkay()) {
    throwMsg += "Energy";
    errInfo << " Energy conservation violated by " << balance->deltaE()
        << " GeV (" << balance->relativeE() << ")" << G4endl;
  }
  
  if (!balance->momentumOkay()) {
    throwMsg += "Momentum";
    errInfo << " Momentum conservation violated by " << balance->deltaP()
        << " GeV/c (" << balance->relativeP() << ")" << G4endl;
  }
  
  if (!balance->baryonOkay()) {
    throwMsg += "Baryon number";
    errInfo << " Baryon number violated by " << balance->deltaB() << G4endl;
  }
  
  if (!balance->chargeOkay()) {
    throwMsg += "Charge";
    errInfo << " Charge conservation violated by " << balance->deltaQ()
        << G4endl;
  }
 
  errInfo << " Final event output, for debugging:\n"
     << " Bullet:  \n" << *bullet << G4endl
     << " Target:  \n" << *target << G4endl;
  output->printCollisionOutput(errInfo);
  
  throwMsg += " non-conservation. More info in output.";
  throw G4HadronicException(__FILE__, __LINE__, throwMsg);   // Job ends here!
}