Changeset 1340 for trunk/source/processes/hadronic/models/cascade

trunk/source/processes/hadronic/models/cascade/History

-              r1337
+              r1340
 $Id: History,v 1.91 2010/06/11 17:07:23 mkelsey Exp $
+$Id: History,v 1.203 2010/10/22 20:41:05 mkelsey Exp $
 -------------------------------------------------------------------
 …
      ---------------------------------------------------------------
+June 2010 Michael Keley (hadr-casc-V09-03-43)
+------------------------------------------------
+October 2010 Michael Kelsey (hadr-casc-V09-03-84)
+----------------------------------------------------
+- G4WatcherGun.cc: Change first numeric argument to G4NuclWatcher to int.
+NOTE:  Only this change is include in tag.
+October 2010 Michael Kelsey (kelsey-20101020b)
+-------------------------------------------------
+- G4NucleiModel:  Add scaling factors ("units") for nuclear radii and
+  cross-sections, in order to adapt calculations to the literature.
+October 2010 Michael Kelsey (kelsey-20101020a)
+-------------------------------------------------
+- G4NucleiModel:  Re-activate changes in worthToPropagate() to use existing
+  nuclear potential values for kaons and hyperons to decide on trapping.
+October 2010 Michael Kelsey (kelsey-20101020)
+------------------------------------------------
+- G4NucleiModel:  Clean up some bugs in refactoring generateModel().  Back
+  out changes (28 Sep) in worthToPropagate() in order to compare refactored
+  to production code.
+October 2010 Michael Kelsey (hadr-casc-V09-03-83)
+----------------------------------------------------
+- G4CascadParticle.cc:  Remove debugging output left in by accident.
+NOTE:  Tag does not include reorganization of G4NucleiModel (5 Oct 2010)
+October 2010 Michael Kelsey
+------------------------------
+G4FissionStore, G4FissionConfiguration: Undo migration to integer A and Z.
+October 2010 Michael Kelsey
+------------------------------
+Clean up CoVerity software analysis reports (three are ignored from obsolete
+code):
+        G4Analyser.cc
+        G4CascadeCheckBalance.cc
+        G4CascadeInterpolator.icc
+        G4CascadeSampler.icc
+        G4CollisionOutput.cc
+        G4ElementaryParticleCollider.cc
+        G4InuclCollider.cc
+        G4NuclWatcher.cc
+        G4NucleiModel.hh,cc
+        G4RegionModel.cc
+October 2010 Michael Kelsey
+------------------------------
+- G4NucleiModel.cc:  Fix misspelled "G4doulbe" -> G4double.
+Pick up several missed bits of the "integer A and Z migration," mostly in
+test and diagnostic code:
+        G4Analyser.hh,cc
+        G4FissionConfiguration.hh
+        G4FissionStore.hh,cc
+        G4NuclWatcher.hh,cc
+October 2010 Michael Kelsey (hadr-casc-V09-03-82)
+----------------------------------------------------
+- G4CascadParticle.cc:  Add protection in getPathToTheNextZone() so that d2
+  is always computed non-negative.  Avoids 10^-5 FPEs.
+October 2010 Michael Kelsey
+------------------------------
+- G4NucleiModel:  Major reorganization of generateModel() code.
+) Rename integration functions from "volNumInt[1]" to "zoneIntegralxxx"
+     with "xxx" = "WoodsSaxon" or "Gaussian".
+) Move hardwired constants out to static data members, give clear names.
+) Split function into separate pieces to set binding energies, zone
+     radii, volume/density values, and potential heights.
+) Within new functions, simplify if-cascades where possible, eliminate
+     duplicated code.
+) Move std::vector<> buffers out to data members.
+  Also, modify worthToPropagate() to use non-nucleon potential heights to
+  terminate propagation.  Previously, non-nucleons could never fail, as the
+  "getFermiKinetic" always returned zero.
+September 2010 Michael Kelsey (hadr-casc-V09-03-81)
+------------------------------------------------------
+- G4BigBanger:  Missed some integer A/Z migrations, which caused a bus error
+  in test47.
+September 2010 Michael Kelsey (hadr-casc-V09-03-80)
+------------------------------------------------------
+- G4VCascadeDeexcitation.hh:  NEW abstract base class for post-cascade
+  processing.  Some common activities will be implemented here from the two
+  actual modules.
+- G4CascadeDeexcitation, G4PreCompoundDeexcitation:  Use new base class
+  above, reorganize code in collide() to use new deExcite(G4Fragment*) where
+  appropriate.
+- G4InuclCascader.hh:  Reference new base class for de-excitation modules.
+September 2010 Michael Kelsey
+--------------------------------
+- G4CascadeColliderBase:  Add explosion(G4Fragment*) and explosion(A,Z,Eexc).
+  Move implementation to latter, and write others as call-throughs.  Add
+  Z==0 condition for explosion, regardless of A.
+- G4EquilibriumEvaporator.hh:  Remove explosion(G4InuclNuclei*), as
+  unnecessary.  Existing explosion(A,Z,E) now overrides base class.
+- G4CollisionOutput:  Add function to process G4ReactionProducts from
+  PreCompound.
+- G4PreCompoundDeexcitation.cc:  Move G4ReactionProducts loop to
+  G4CollisionOutput.
+September 2010 Michael Kelsey
+--------------------------------
+- G4IntraNucleiCascader.cc:  Minor shuffle of post-cascade recoil checking,
+  in preparation for moving fragment construction and processing away.
+- G4CollisionOutput.cc:  Replace names "TargetFragment*" and "NucleiFragment*"
+  with "OutgoingNuclei" and "OutgoingNucleus" for consistency with
+  "OutgoingParticles" names.  This affects the following source files, all
+  of which are modified to match (using |sed|):
+        cascade/include/G4Analyser.hh
+        cascade/include/G4CollisionOutput.hh
+        cascade/src/G4Analyser.cc
+        cascade/src/G4CascadeCheckBalance.cc
+        cascade/src/G4CascadeDeexcitation.cc
+        cascade/src/G4CascadeInterface.cc
+        cascade/src/G4CollisionOutput.cc
+        cascade/src/G4EquilibriumEvaporator.cc
+        cascade/src/G4Fissioner.cc
+        cascade/src/G4IntraNucleiCascader.cc
+        cascade/src/G4InuclCollider.cc
+        cascade/src/G4InuclEvaporation.cc
+        cascade/src/G4NonEquilibriumEvaporator.cc
+        cascade/src/G4PreCompoundDeexcitation.cc
+- G4CollisionOutput:  Add new G4Fragment data member, with get() and add()
+  accessors.  This fragment is *not* used by setOnShell() or by any of the
+  event-total calculations.  It will be filled by G4IntraNucleiCascader for
+  use by de-excitation modules.  Include G4Fragment in diagnostic output if
+  not empty.
+- G4CascadeRecoilMaker.cc:  Remove G4Fragment::SetExcitationEnergy() call.
+- G4InuclNuclei:  Add new constructor to create from G4Fragment input, and
+  new makeG4Fragment() to spit out a G4Fragment.  Also provide a casting
+  operator for the latter.
+September 2010 Michael Kelsey (hadr-casc-V09-03-79)
+------------------------------------------------------
+Fix numerous compilation warnings on Linux (not seen on MacOSX) left over
+from migration to integer A and Z (-73 tag).
+        G4BigBanger.cc
+        G4CascadeCheckBalance.hh
+        G4CascadeColliderBase.cc
+        G4CascadeRecoilMaker.cc
+        G4EquilibriumEvaporator.hh,cc
+        G4ExitonConfiguration.hh
+        G4Fissioner.cc
+        G4InuclCollider.cc
+        G4NonEquilibriumEvaporator.cc
+        G4NucleiModel.cc
+- G4PreCompoundDeexcitation.cc:  Drop "G4int" casts as no longer required.
+September 2010 Michael Kelsey (hadr-casc-V09-03-78)
+------------------------------------------------------
+- G4CascadeInterface, G4InuclCollider:  change user selection function name
+  to usePreCompoundDeexcitation(), per Julia Yarba.
+- G4PreCompoundCascadeInterface.hh,.cc, G4PreCompountInuclCollider.hh,.cc:
+  REMOVE THESE CLASSES.  These were copied and modified versions of the
+  standard versions, in order to test the new pre-compound de-excitation.
+  That has been integrated with runtime flags, so the parallel versions are
+  not required.
+September 2010 Michael Kelsey
+--------------------------------
+- G4InuclElementaryParticle.cc:  Drop warning message when converting
+  G4ParticleDefinition to type code.
+- G4CascadeInterface:  Add functions for user selection of which
+  post-cascade module to use for de-excitation of the residual nucleus.
+  These call through to the equivalent G4InuclCollider functions.
+- G4InuclCollider:  Add functions for user selection of which
+  post-cascade module to use for de-excitation of the residual nucleus.
+  These delete and re-instantiate the appropriate de-excitation "collider".
+- G4PreCompoundDeexcitation:  Remove convertFragment() function, remove
+  pass-by-value std::vector<> from getDeExcitedFragments() (use data member
+  instead).  Clean up some obsolete code usage.
+- G4CascadeRecoilMaker:  Change fragment-making interface:
+  makeRecoilNuclei() now returns G4InuclNuclei* for standard Bertini colliders.
+  makeRecoilFragment() returns G4Fragment* for external PreCompound models.
+  addExcitonConfiguration() sets local copy of excitons, needed in order to
+    call the individual G4Fragment->Setxxx() functions.
+- G4IntraNucleiCascader.cc:  Follow renaming RecoilMaker::makeRecoilNuclei(),
+  use new addExcitonConfiguration().
+- G4CascadeRecoilMaker:  Change fragment-making interface:
+  makeRecoilNuclei() now returns G4InuclNuclei*.
+  makeRecoilFragment() returns G4Fragment*.
+  addExcitonConfiguration() sets local copy of excitons, needed in order to
+    call the individual G4Fragment->Setxxx() functions.
+- G4IntraNucleiCascader.cc:  Follow renaming RecoilMaker::makeRecoilNuclei(),
+  use new addExcitonConfiguration().
+September 2010 Michael Kelsey
+--------------------------------
+- G4CascadeMomentum.hh:  This should have been removed from the package long
+  ago.  Apologies for the oversight.
+September 2010 Julia Yarba
+-----------------------------
+Added 1st prototype of interface between Bartini cascade and PreCompound model
+(post-cascade de-excitation).
+Changes only to:
+/geant4/source/processes/hadronic/models/cascade/cascade
+New developments are those G4PreCompound* classes; the GNUmakefile adapted to
+include necessary links.
+The PreComp wrapper is G4PreCompundDeexcitation class.
+The logic, loops, conditions, etc., in the event processing are the same as in
+the "native" Bertini code. I actually copied it over from G4CascadeInterface,
+and started from there.
+However, there're a few technical changes that I'd like to mention.
+. G4PreCompoundInterface inherits directly from G4HadronicInteraction.
+I felt that we'd not need G4VIntra..., because its only advantage is a pointer
+(and related access methods) to G4VPreCompoundModel.
+This has now moved to the de-excitation wrapper.
+. In the Collider itself, I've made the data member to be
+ G4CascadeColliderBase* theDeexcitation
+This way, it can be transparently set to the native one or the PreComp one
+(both inherit from G4CascadeColliderBase).
+. There's a setDeExcitation(...) methond in the collider, and also in the interface
+(which will pass it down to the collider).
+September 2010 Michael Kelsey (hadr-casc-V09-03-77)
+------------------------------------------------------
+- G4CascadeInterface.cc:  Bug fix to logic in retryInelasticNucleus()
+September 2010 Michael Kelsey (hadr-casc-V09-03-76)
+------------------------------------------------------
+- G4CascadeInterface:  Add support to pass nucleus projectiles into
+  collider.  Not tested or guaranteed to work, but G4IntraNucleiCascader is
+  supposed to deal with them.
+September 2010 Michael Kelsey
+--------------------------------
+- G4CascadeInterface:  Extensive reorganization, moving most
+  functionality out of ApplyYourself and into small member functions.
+  Complicated end-of-loop conditions encapsulated.  Data members made into
+  pointers to hide dependences from outside world.
+September 2010 Michael Kelsey (hadr-casc-V09-03-75)
+------------------------------------------------------
+- G4CascadeInterface.cc:  Add parentheses in end-of-while block to fix
+  compilation warning in GCC 4.3.
+- G4IntraNucleiCascader.cc:  In decayTrappedParticle(), check for photon
+  daughters and put them directly onto output list.
+September 2010 Michael Kelsey
+--------------------------------
+- G4CascadParticle.hh:  Make getGeneration() const.
+- G4CascadeDeexcitation.hh:  Fix compiler warning about order of data members.
+- G4IntraNucleiCascader:  Intercept hyperons which are "trapped" in nuclear
+  potential, and decay them immediately to produce usable secondaries.  This
+  resolves problem with sub-MeV final-state hyperons (reported by A. Dotti),
+  but is not entire correct.  Properly, the hyperon should be incorporated
+  into a hypernucleus fragment.
+- G4InuclElementaryParticle.hh:  Add hyperon() identification function, and
+  constructor to take G4DynamicParticle directly.
+- G4InuclParticle.hh, G4InuclNuclei.hh:  Add constructor to take
+  G4DynamicParticle directly.
+September 2010 Michael Kelsey (hadr-casc-V09-03-74)
+------------------------------------------------------
+- G4CascadeDeexcitation:  NEW collider to handle post-cascade processing of
+  nuclear fragment.  Encapsulates BigBanger and Evaporators.  Eventually
+  will have alternative (configurable or #ifdef) implementation using G4
+  external "pre-compound" models instead of Bertini factories.
+- G4InuclCollider:  Remove post-cascade colliders (BigBanger, Evaporators),
+  replace with new G4CascadeDeexcitation.
+- G4LorentzConverter:  Move construtor implementations to .cc file, and make
+  sure all constructors have initializers for all data members.
+September 2010 Michael Kelsey (hadr-casc-V09-03-73)
+------------------------------------------------------
+Migrate to integer A and Z values for nuclear configurations.  Includes both
+explicit arguments for G4InuclNuclei, and function arguments, computational
+parameters involved in nuclear configurations, breakup, etc.
+        G4CascadeCheckBalance.cc
+        G4CascadeInterface.cc
+        G4CascadeRecoilMaker.hh
+        G4Fissioner.hh,cc
+        G4InuclEvaporation.cc
+        G4InuclNuclei.hh,cc
+        G4InuclSpecialFunctions.hh
+        G4NonEquilibriumEvaporator.hh,cc
+        G4NucleiModel.hh,cc
+        G4PreCompoundCascadeInterface.cc
+        bindingEnergy.cc
+        bindingEnergyAsymptotic.cc
+        nuclearLevelDensity.cc
+        paraMaker.cc
+- G4InuclSpecialFunctions.hh:  Eliminate bindingEnergy functions which are
+  no longer used, along with their .cc files:
+        bindingEnergyKummel
+        bindingEnergyExact
+Migration validated using 100 events (20 GeV pi+ on lead) with verbose==4.
+Entire log files (9.6M lines, 433 MB) identical before and after migration.
+September 2010 Michael Kelsey
+--------------------------------
+- G4InuclElementaryParticle:  Move printParticle() implementation to .cc,
+  and add printing of particle name to output.
+- G4InuclNuclei.cc:  Move base-class printing to first line of output, to
+  match G4InuclEP.
+September 2010 Michael Kelsey (hadr-casc-V09-03-72)
+------------------------------------------------------
+- G4CascadeRecoilMaker:  Add new goodNucleus() function with functionality
+  from G4IntraNucleiCascader::goodCase().  Add parameter to set "rounding
+  tolerance" for small/negative mass differences.  Drop getRecoilFragment()
+  in favor of user calling makeRecoilFragment() directly (instead of doing
+  it collide()), which returns a non-const pointer.
+- G4IntraNucleiCascader: Remove previously introduced getResidualMass() and
+  makeResidualFragment() functions, along with G4InuclNuclei object.
+  Replace with new RecoilMaker utility.  Move goodCase() to RecoilMaker, and
+  begin to simplify end-of-cascade processing.
+- G4ExitonConfiguration.hh:  Add function to reset values to zero.
+- G4InuclNuclei:  Add function to zero out exciton configuration, and use
+  it in fill() functions.
+September 2010 Michael Kelsey
+-------------------------------
+- G4CascadeCheckBalance:  Add new collide() interface to take lists of both
+  G4InuclElementaryParticles and G4CascadParticles; supports use by
+  G4IntraNucleiCascader and G4CascadeRecoilMaker.
+- G4CascadeRecoilMaker:  NEW pseudo-Collider class to compute the nuclear
+  recoil kinematics of a cascade, either in process or completed.  To be
+  used by G4IntraNucleiCascader; uses G4CascadeCheckBalance to do work.
+September 2010 Michael Kelsey (hadr-casc-V09-03-71)
+-----------------------------------------------------
+- G4NucleiModel:  Add protections in generateInteractionPartners() so that
+  nucleon and quasideuteron interactions are only selected if there are
+  "enough" nucleons of the necessary type still available (xxxNumberCurrent).
+- G4InuclNuclei:  Add fill() functions which overwrite the entire particle
+  structure, with same argument lists as constructors.  Will be used mainly
+  by G4IntraNucleiCascader::makeResidualFragment().
+- G4IntraNucleiCascader:  Hide non-physical nucleus message behind verbose
+  flag.  Add function and data member to build recoil nucleus (fragment) at
+  end of every iteration; will eventually replace functionality of
+  getResidualMass().
+September 2010 Michael Kelsey (hadr-casc-V09-03-70)
+-----------------------------------------------------
+- G4NucleiModel.cc:  Restore hadr-casc-V09-03-68 revision 1.71, and remove
+  the two resize(3) actions.
+NOTE:  The exercise below has (finally) resolve the cross-section
+discrepancy reported by Sunanda Banerjee back in July.  It turns out that my
+use of "resize(3)" to pre-allocate the qdeutron and acsec buffers on each
+interaction was incorrect.  This doesn't just reserve memory, it fills the
+vectors with three elements, so that subsequent push_back()'s fill [3], [4],
+etc.
+September 2010 Michael Kelsey
+-------------------------------
+- G4NucleiModel.cc: Reverted to hadr-casc-V09-03-38 revision 1.45, and
+  interface changes incorporated.  See NOTE below from 28 July 2010.
+  Cross-section changes have not been resolved or validated.  Since -38
+  revision has better data/MC matching (ratio near 1), it is restored as the
+  baseline version, and changes will be re-done incrementally.
+  Each increment after (0) is tagged "kelsey-20100902x", x=a,b,c,d etc.
+)  Implement new ctor and generateModel() calls
+            Make cross-section tables statically initialized
+            Include absorptionCrossSection definition
+)  Use lookup tables for cross-sections, and new interpolator
+            Change CHC_CHECK to G4CASCADE_DEBUG_CHARGE
+)  Use this package's bindingEnergy() function
+)  Update diagnostic messages and verbosity levels;
+            Add missing initializers to all constructors;
+            Use data-member buffer for G4CollisionOutput
+)  Use generateWithRandomAngles() everywhere appropriate;
+            Collapse if-cascades to use if-return where possible
+)  Make generateModel() re-usable with data-member buffers
+)  Energy-momentum conservation checking;
+            Implement generateNucleonMomentum;
+            Remove extraneous semicolons and blank lines
+)  Use local variables in passFermi();
+            Fix some minor LorentzVector calculations;
+            Use generateNucleonMomentum() for quasi-deuterons
+)  Use data-member buffers for quasideuterons, coords, mom.
+)  Use enum labels for quasideuteron codes
+) Restore Dennis' improved potential (6-zone) calculations
+August 2010 Michael Kelsey (hadr-casc-V09-03-69)
+--------------------------------------------------
+- G4CascadeData:  Add name data member and optional ctor argument, use
+  when printing tables.
+- G4CascadeFunctions.icc:  Pretty-up printing output using name string.
+- G4Cascade*Channel.cc:  Add name string to data() ctor, use central part of
+  class name, e.g., "PiMinusP" for G4CascadePiMinusPChannel.
+- G4ElementaryParticleCollider.cc:  Add printing of all final-state tables,
+  one time only, protected by G4CASCADE_DEBUG_SAMPLER.
+- GNUmakefile:  Add G4CASCADE_DEBUG_SAMPLER preprocessor flag.
+August 2010 Michael Kelsey (hadr-casc-V09-03-68)
+--------------------------------------------------
+- G4CascadeData.hh: Add print() and printXsec() functions to dump tables.
+- G4CascadeData.icc:  Move implementations out of G4CascadeData.hh file.
+- G4CascadeFunctions.hh,icc: Add printTable() to dump tables.
+- G4CascadeInterpolator.hh,icc: Add printBins() to dump energy bin edges.
+- G4CascadeSampler.hh,icc: Add print() to call through to interpolator.
+NOTE:  This should be the last set of functional changes for a while.
+Sunanda Bannerjee reported substantial changes in validation plots for the
+Bertini cascade between 4.9.3-ref-05 (hadr-casc-V09-03-23-01) and
+.9.3-ref-06/4.9.4-beta-01 (hadr-casc-V09-03-43).
+July 2010 Michael Kelsey (hadr-casc-V09-03-67)
+-------------------------------------------------
+- G4NucleiModel.cc:  Set deuteron arrays to fixed length (3).  Add A/Z
+  values to generateModel diagnostic message.
+- G4EquilibriumEvaporator.cc:  Change some fixed length std::vector<> to
+  simple C arrays.
+- G4Fissioner.cc:  Move G4FissionStore to class data member for reuse.
+- G4FissionStore:  Add ::clear() function to support reuse, move addConfig()
+  implementation to .cc file.
+- G4IntraNucleiCascader:  Move G4NucleiModel to class-level data member
+  (pointer) so it can be reused across collisions.
+July 2010 Michael Kelsey
+---------------------------
+- G4Analyzer.cc:  Use const-refs for particle lists.
+- G4BigBanger, G4ElementaryParticleCollider:  Move std::vector<> buffers to
+  .hh file to allow reuse.
+- G4NucleiModel.cc:  Simplify buffers used in generateModel() to reduce
+  G4double allocations.
+July 2010 Michael Kelsey (hadr-casc-V09-03-66)
+-------------------------------------------------
+- G4CascadeInterface:  Move G4CollisionOutput to .hh file for reuse between
+  events.
+- G4IntraNucleiCascader:  Move buffers for cascade output to .hh file, so
+  they can be reused between events.
+- G4NucleiModel:  Move G4CollisionOutput to .hh file for reuse; use
+  references for bullet and target args to G4EPCollider.
+July 2010 Michael Kelsey (hadr-casc-V09-03-65)
+-------------------------------------------------
+- GNUmakefile:  Add new G4CASCADE_CHECK_ECONS to turn off all of the
+  internal conservation checks (reduce std::vector<> memory churn!).
+- G4CascadeColliderBase.cc:  Use G4CASCADE_CHECK_ECONS to set the default
+  value of "doConservationChecks": true if defined, false if not defined.
+  This is done with #ifdef-else-endif block, NOT some fancy macro.
+- G4CascadeInterface.cc:  Use G4CASCADE_SKIP_ECONS to toggle reporting
+  violations before end of loop (don't need to call balance.okay() twice!).
+- G4ElementaryParticleCollider.cc:  Put verbosity check before call to
+  validateOutput() to avoid unnecessary vector manipulations.
+- G4IntraNucleiCascader.cc:  Set doConservationChecks = true
+  unconditionally; used to reject bad cascades.
+- G4NucleiModel.cc:  Use G4CASCADE_CHECK_ECONS to hide balance.collide().
+July 2010 Michael Kelsey (hadr-casc-V09-03-64)
+-------------------------------------------------
+- G4CascadeColliderBase: Make G4CascadeCheckBalance a pointer member, move
+  ctor and dtor to .cc file.  Change balance tolerances to 1 per mil and 1
+  MeV.
+- G4InuclCollder:  Make all colliders pointer members.
+- G4IntraNucleiCascader:  Make EPCollider a pointer member, and call
+  G4CollisionOutput::setOnShell() to balance energy-momentum for null fragments.
+- G4InuclNuclei.cc:  Preserve momentum magnitude when setting excitation
+  energy by setting mass and kinetic energy.
+July 2010 Michael Kelsey (hadr-casc-V09-03-63)
+-------------------------------------------------
+- G4CascadeCheckBalance.cc:  Change zero-tolerance to 10 keV (1e-5) from
+keV (1e-6).
+- G4CollisionOutput.hh:  Fix capitalization of "numberOfOutgoingParticles".
+- G4EquilibriumEvaporator.cc:  Remove duplicate EEXS setting.
+- G4InuclNuclei:  Change implementation of setExitationEnergy() to adjust
+  mass while keeping momentum vector constant.  Currently done with
+  "expensive" LorentzVector manipuation.  Should be done by recomputing
+  kinetic energy given new mass value.
+- G4NonEquilibriumEvaporator.cc:  Modify particle-creation block to work as
+  G4EquilibriumEvaporator now does.  Simplify some if-blocks.
+July 2010 Michael Kelsey (hadr-casc-V09-03-62)
+-------------------------------------------------
+- G4CollisionOutput:  Add interfaces to handle G4CascadParticles.
+- G4IntraNucleiCascader:  Eliminate local "inter_case" data member and
+  function.  Use base class G4InteractionCase directly.  Add functionality
+  to test for conservation and recoil before exiting "itry" loop, and redo
+  cascade if unbalanced recoil fragment.
+- G4{PreCompound}InuclCollider.cc:  Drop "setInteractionCase()" function.
+July 2010 Michael Kelsey (hadr-casc-V09-03-61)
+-------------------------------------------------
+- G4CollisionOutput:  New ::add() function to combine two objects.  New
+  accessors to get total charge and baryon number.
+- G4CascadeCheckBalance:  Make tempOutput data member, for thread-safety,
+  rather than static variables.  Use new G4CollisionOutput accessors.
+- G4IntraNucleiCascader.cc:  Move local output buffers outside while loop,
+  use std::vector<>::insert() for copying.
+- G4InuclCollider.cc:  Use new G4CollisionOutput::add() interface.
+- G4NucleiModel.cc:  Hide conservation checks behind verbose>2.  Otherwise
+  log files get too big
+July 2010 Michael Kelsey (hadr-casc-V09-03-60)
+-------------------------------------------------
+- G4CascadeCheckBalance:  Add layer of protection in relativeX() (check
+  initial values) to avoid divide-by-zero errors.  Add another interface to
+  accept list of G4CascadParticles, for use with G4NucleiModel.  Add check
+  of momentum direction balance, not just magnitudes.
+- G4IntraNucleiCascader.cc:  Rearrange end-of-loop if-blocks to allow for
+  conservation checking prior to return.  Add reporting of both too-low and
+  too-high residual energy (at verbose=2) for single-nucleon fragments.
+- G4InuclCollider.cc:  Remove re-named conservation checks, now all done by
+  colliders themselves.
+- G4InuclParticle.hh:  Add setKineticEnergy() function to simplify handling
+  of some kinematics.
+- G4NucleiModel:  Add G4InuclNuclei data member (created in generateModel()),
+  for use with conservation checks.  Do check at end of generateParticleFate().
+July 2010 Michael Kelsey (hadr-casc-V09-03-59)
+-------------------------------------------------
+- G4InuclNuclei:  Use G4DynamicParticle::theDynamicalMass to carry around
+  excitation energy (== theDynamicalMass-thePDGMass).  This allows
+  excitation to be changed on the fly, with all kinematics handled
+  correctly.  It also allows ONLY the ground state nucleus to be created as
+  a G4Ions object (whether global or private), reducing the number of such
+  objects by a factor of thousands.
+July 2010 Michael Kelsey (hadr-casc-V09-03-58)
+-------------------------------------------------
+- G4CollisionOutput.cc:  For initial four-momentum adjustment, skip over
+  particles which would acquire negative energy after "correction."
+- G4ElementaryParticleCollider.cc: Bug fix for two-body final states.
+  Kinematics should not require "rescaling."  That was driven by states
+  which were kinematically forbidden, with m1+m2 > etot_scm (e.g., pi0 p ->
+  pi+ n with just 5 MeV kinetic energy).  Now those states are caught and
+  rejected.
+- G4CascadeInterface.cc, G4InuclCollider.cc:  Improve diagnostics reporting
+  number of retries.
+- G4EquilibriumEvaporator.cc:  When computing residual excitation
+  (EEXS_new), original thrown energy, S, should be used, not reboosted
+  particle after recoil.  Simplify evaporation kinematics to conserve
+  four-momentum automatically (PEX -= mom).
+July 2010 Michael Kelsey (hadr-casc-V09-03-57)
+-------------------------------------------------
+- G4CascadeColliderBase: New subclass of G4VCascadeCollider, which takes
+  over all of its concrete functionality, and adds conservation checker
+  (G4CascadeCheckBalance) as data member.  Wrapper functions and control
+  flag allow colliders to user it transparently.
+- G4VCascadeCollider:  Move concrete functionality to new base class.
+- All colliders:  Change base class to new G4CascadeColliderBase.  Remove
+  local copies of conservation-checker, using new base function instead.
+        cascade/include/G4BigBanger.hh
+        cascade/include/G4ElementaryParticleCollider.hh
+        cascade/include/G4EquilibriumEvaporator.hh
+        cascade/include/G4EvaporationInuclCollider.hh
+        cascade/include/G4Fissioner.hh
+        cascade/include/G4IntraNucleiCascader.hh
+        cascade/include/G4InuclCollider.hh
+        cascade/include/G4NonEquilibriumEvaporator.hh
+        cascade/include/G4PreCompoundInuclCollider.hh
+        cascade/src/G4BigBanger.cc
+        cascade/src/G4ElementaryParticleCollider.cc
+        cascade/src/G4EquilibriumEvaporator.cc
+        cascade/src/G4EvaporationInuclCollider.cc
+        cascade/src/G4Fissioner.cc
+        cascade/src/G4IntraNucleiCascader.cc
+        cascade/src/G4InuclCollider.cc
+        cascade/src/G4NonEquilibriumEvaporator.cc
+        cascade/src/G4PreCompoundInuclCollider.cc
+- G4EquilibriumEvaporator:  Use new functionality (above) to turn off
+  conservation checks when evaporating fission products.
+- G4CascadeInterface.cc:  Report number of retries in verbose messages.
+- G4IntraNucleiCascader.cc:  Remove sanity check on afin/zfin vs. model.
+July 2010 Michael Kelsey (hadr-casc-V09-03-56)
+-------------------------------------------------
+- G4CascadeCheckBalance:  Add zero protection (needed for momentum ratio)
+  using a static tolerance parameter.
+- G4EquilibriumEvaporator.cc:  Add dumping of G4CollisionOutput before exit,
+  some fixes for "PEX" adjustments as EEXS changes.
+- G4NonEquilibriumEvaporator.cc:  Add conservation checking, dump of output,
+  some fixes for "PEX" adjustments as EEXS changes.
+- G4Fissioner.cc:  Add conservation checking, remove addition of excitation
+  energy to input nucleus mass, since already included.
+July 2010 Michael Kelsey
+---------------------------
+- G4CascadeCheckBalance.cc:  Hide violation reports behind verbose == 1.
+- G4ElementaryParticleCollider.cc:  Bump ::collide() message to verbose > 1.
+- G4EquilibriumEvaporator.cc:  Add conservation checking, collapse if-cascades
+  by doing failure tests and exits up front, add sanity check on eex_real.
+- G4IntraNucleiCascader.cc:  Add diagnostic messages and some FIXME
+  comments, validate afin/zfin against G4NucleiModel result.
+- G4InuclCollider.cc:  Move conservation check outside verbosity flag.  This
+  adds to CPU usage, so may need #ifdef protection later.  Adjust a few
+  verbosity levels.
+- G4LorentzConvertor.cc:  Bump all diagnostic messages to verbose > 2.
+- G4NucleiModel.cc:  Simplify main if-block to put failure up front; add
+  debugging messages when decrementing proton or neutron counts.
+July 2010 Michael Kelsey
+---------------------------
+- G4CascadeCheckBalance:  Add ctor argument with name of parent class; use
+  this name when reporting results.  Add interface for nuclear fragment
+  list.  Allow parent class name to be changed dynamically.
+- G4BigBanger.cc, G4CascadeInterface.cc, G4ElementaryParticleCollider.cc,
+  G4InuclCollider.cc, G4NucleiModel.cc:  Pass name to G4CascadeCheckBalance.
+- G4Fissioner.cc:  Use G4CascadeCheckBalance to test energy conservation.
+- G4InuclNuclei.hh:  Add model ID as optional ctor argument.
+- G4InuclCollider.cc:  Move balance checks on evaporators outside verbosity.
+  Adjust name of G4CascadeCheckBalance for clear reporting.
+- G4VCascadeCollider.hh:  Add protected function to change name dynamically.
+July 2010 Dennis Wright (hadr-casc-V09-03-55)
+-----------------------------------------------
+- G4IntraNucleiCascader.cc: add to final particle list those cascade
+  particles which were formerly abandoned at cascade termination;
+- G4IntraNucleiCascader.cc: allow meson excitons to pass out of nucleus
+  since they are not proper excitons, and would be lost otherwise
+July 2010 Dennis Wright (hadr-casc-V09-03-54)
+-----------------------------------------------
+- tag changes up to now
+July 2010 Michael Kelsey
+--------------------------
+- G4BigBanger.cc:  Moving "generateMomentumModules()" inside loop.  For
+  three-body decays, the angles are not ajustable (so always fails).
+- G4CascadeInterface.cc:  Set verbosity on G4CollisionOutput.
+- G4EquilibriumEvaporator.cc:  Simplify if-cascades to reduce nesting (test
+  for errors and exit up front, rather than in else-blocks).
+- G4InuclCollider.cc:  Set verbosity on G4CollisionOutput.
+- G4IntraNucleiCascader.cc:  Throw away casacde which leaves "negative energy
+  recoil" (i.e. rest-frame energy of recoil less than mass of nucleus or
+  nucleon).
+July 2010 Michael Kelsey
+--------------------------
+- G4InuclCollider.cc:  Used wrong input target for conservation-law checking
+  subsequent to G4EquilibriumEvaporator.
+- G4EquilibriumEvaporator.cc, G4NonEquilibriumEvaporator.cc:  Handle
+  excitation energy differently with new G4InuclNuclei interface.  Compute
+  updated values correctly, by taking nuclear mass difference then
+  subtracting energy of evaporated particle.
+- G4InuclNuclei:  Reorganization to properly incorporate excited states.
+  Excitation energy included in mass in all cases.  setExcitationEnergy() now
+  replaces G4PartDefn pointer with new excited state.  getNucleiMass() takes
+  (optional) excitation, calls G4NucleiProperties to get mass value.  For
+  weird fragments, multiple isomers allowed, assigned unique non-standard
+  PDG codes.  Include particle name in printout (now in .cc file).
+- G4CollisionOutput.cc:  Do not include nuclear excitation energy in output
+  sum; now included with nuclear mass automatically (and properly).
+- G4CascadeCheckBalance.cc:  Do not include nucler excitation energy in input
+  sum; now inluded with nuclear mass automatically (and properly).
+- G4IntraNucleiCascader.cc:  For recoil nuclear fragments, treat excitation
+  energy properly: compute as difference between recoil "mass" (recoil-frame
+  energy) and ground-state A/Z mass, and pass into G4InuclNuclei ctor.
+  After the cascade, add some recoil energy checks to deal with both
+  floating-point round-off, and quasi-elastic scatters (which change the
+  bullet direction, and leave the nucleus with "missing" energy).
+- G4BigBanger.cc:  Simplify boost to "target" nucleus, using "boostVector"
+  instead of G4LorentzConvertor machinery.
+June 2010 Michael Kelsey
+---------------------------
+- G4BigBanger.cc:  Improve handling of excitation energy as part of nuclear
+  mass, deal with two-body explosion properly (x=0.5, not random).  Some
+  tweaks to diagnostic messages.
+- G4CascadeCheckBalance:  Add excitation energy to total energy for bullet
+  and target nuclei.  This is done in G4CollisionOutput for secondaries.  It
+  is NOT relativistically correct (should add to mass, not energy), but is
+  consistent.
+- G4CollisionOutput.cc:  Use "getExitationEnergyInGeV()" instead of "0.001*".
+- G4IntraNucleiCascader.cc:  More diagnostic messages, improve the afin/zfin
+  sanity check by requiring A>=Z.
+June 2010 Michael Kelsey
+---------------------------
+- G4CascadeCheckBalance:  Report violations on G4cerr always, regardless
+  of verbosity level.  Add collide(...,<vector>) interface to allow use
+  from within G4ElementaryParticleCollider.
+- G4ElementaryParticleCollider.cc:  Add conservation checks within ::collide().
+- G4IntraNucleiCascader.cc:  Add more diagnostic messages.  Test for
+  negative values of afin, zfin, and try again.  Set round-off limit (1e-6),
+  and test nuclear recoil energy for bound (setting to zero) before doing
+  energy-violation test.
+- G4InuclNuclei.cc:  Abort job if passed negative Z or A argument.
+June 2010 Michael Kelsey
+---------------------------
+- G4BigBanger.cc:  Missed one instance of GetBindingEnergy().
+June 2010 Dennis Wright
+--------------------------
+- G4InuclNuclei:  Fix bug in calculation of PDG code.
+June 2010 Michael Kelsey (hadr-casc-V09-03-53)
+-------------------------------------------------
+- G4ElementaryParticleCollider.cc:  MAJOR BUG FIX:  Three different places
+  in generating N-body momenta had incorrect "recoil" calculations.  The
+  Nth four-vector was computed as simply -total, which produced negative
+  energy states (obviously).  The correct calculation should have been
+  N = G4LV(0,0,0,etot) - (total) in each instance.
+June 2010 Michael Kelsey (hadr-casc-V09-03-52)
+-------------------------------------------------
+- G4CascadeCheckBalance.cc:  Bug fixes to limit checks; should be using
+  std::abs(), or negative violations don't get caught!  Also did some
+  cleanup for compiler warnings see on Linux.
+June 2010 Michael Kelsey
+---------------------------
+- G4CascadeInterface.cc:  Fix infinite-loop bug with energy-violation; must
+  check for (nTries>maxTries) outside parenthetical, with balance.okay()
+  inside.  Do conservation checks all the time, not just with flag set.  If
+  e-violation is "infinite loop", dump last generated event and abort job.
+- G4CascadeCheckBalance:  Add checks on baryon number, charge, and kinetic
+  energy.  "Global" sanity check (::okay() function) does not include K.E.
+June 2010 Michael Kelsey (hadr-casc-V09-03-51)
+-------------------------------------------------
+- bindingEnergy.cc:  Replace entire function with call-through to
+  G4NucleiProperties.  Copy test for valid A/Z from there, and return
+. directly on failure; suppresses warning message in 9.4-beta.
+- G4EquilibriumEvaporator.cc, G4Fissioner.cc, G4IntraNucleiCascader.cc
+  G4InuclNuclei.cc, G4NonEquilibriumEvaporator.cc, G4NucleiModel.cc
+  G4VCascadeCollider.cc:  Restore calls to local "bindingEnergy()" to
+  get wrapper function above; suppresses warning messages in 9.4-beta.
+- G4NucleiModel.cc:  Make class re-usable (had been assumed in -47 tag, but
+  was not true!), by clearing all parameter vectors in generateModel().
+  Values of A,Z are tested first, and previous data kept if same nucleus is
+  being modelled.
+June 2010 Michael Kelsey
+---------------------------
+- G4CascadeInterface.cc:  Minor fix to rationalize version jumpings.
+- G4NucleiModel.cc:  Fix bug in partners list termination mods below, and
+  remove reflection-recoil from boundaryTransition().
+June 2010 Michael Kelsey (MHK-20100621)
+------------------------------------------
+- G4CascadeInterface.cc:  Bring MHK-20100620 version back to HEAD, make same
+  parenthesis fix for GCC 4.5 compilation.
+- G4IntraNucleiCascader.cc:  Bug fix nuclear recoil kinematics introduced in
+  MHK-20100620.
+- G4NucleiModel.cc:  Bring MHK-20100620 version back to HEAD, apply ctor
+  argument fix.  Eliminate creating temporaries for terminal "partners" on
+  list; default ctor will take care of it.  Hide negative path-length report
+  behind verbose flag, and don't return an empty list.
+  Add block of code in ::boundaryTransition() which recoils the nucleus when
+  the secondary is reflected off the potential, to balance the momentum
+  transfer.  This is implemented by computing the boost for the full nucleus
+  using the computed three-momentum transfer, and applying that boost to the
+  secondary.
+June 2010 Michael Kelsey (hadr-casc-V09-03-50)
+-------------------------------------------------
+- G4IntraNucleiCascader.cc:  Restore G4NucleiModel as local data member.
+  Not well designed for reuse.
+June 2010 Michael Kelsey (hadr-casc-V09-03-49)
+-------------------------------------------------
+NOTE:  Changes below were version jumped into V09-03-48.  Tag above ONLY
+       includes these two changes!
+- G4CascadeInterface.cc:  Add parentheses in main iteration loop to support
+  mixed && and || (reported by gcc-4.5).
+- G4NucleiModel.cc:  Fix mistake in passing ctor args to generateModel().
+June 2010 Michael Kelsey (MHK-20100620)
+------------------------------------------
+- G4CascadeCheckBalance:  New utility class to do energy and momentum
+  conservation testing.  Implemented as a "collider" to resue interface.
+- G4CascadeInterface.cc:  Use new G4CascadeCheckBalance for energy
+  conservation.
+- G4CollisionOutput:  Add setVerboseLevel() function, diagnostic reports in
+  ::setOnShell(), and collapse if-cascades to use "if (!xxx) return" instead
+  of multiple nestings.
+- G4ElementaryParticleCollider.cc: Collapse if-cascade to use "if (!xxx)
+  return" instead of multiple nestings.
+- G4IntraNucleiCascader.cc:  Improve diagnostic messages, change some G4cout
+  to G4cerr.
+- G4InuclCollider:  Make output buffers data members to reduce churn;
+  simplify if-cascades to use "if (!xxx) return" instead of nesting; add
+  energy-conservation checks at each stage of cascade.
+- G4NucleiModel.cc:  Improve diagnostics, collapse if-cascades to use "if
+  (!xxx) return" instead of multiple nestings.
+June 2010 Michael Kelsey (hadr-casc-V09-03-48)
+-------------------------------------------------
+- G4CascadeInterface.cc:  Add check on energy conservation between initial
+  and final states; more than 5% imbalance triggers repeat generation of
+  cascade.  This check may be disabled with flag G4CASCADE_SKIP_ECONS.  Also
+  did some minor cleanup of the code.
+- cascade/GNUmakefile:  Add support for new flag above.
+June 2010 Michael Kelsey (hadr-casc-V09-03-47)
+-------------------------------------------------
+- G4CascadeInterface, G4PreCompoundCascadeInterface:  Make G4InuclCollider a
+  local data member, pass verbosity to it in ::ApplyYourself().
+- G4InuclCollider, G4ElementaryParticleCollider, G4IntraNucleiCascader,
+  G4EquilibriumEvaporator, G4BigBanger: Make all sub-colliders local data
+  members, pass verbosity to each of them.
+- G4NucleiModel:  Add ctors and generateModel() signatures so both can do
+  particle or A/Z initialization.  Add setVerboseLevel() function.
+June 2010 Michael Kelsey (hadr-casc-V09-03-46)
+-------------------------------------------------
+- cascade/GNUmakefile: Add series of "ifneq (,...)" blocks to map
+  environment variables for debugging onto "-D..." compiler flags:
+        G4CASCADE_COULOMB_DEV
+        G4CASCADE_DEBUG_CHARGE
+        G4CASCADE_DEBUG_INTERFACE
+        G4CASCADE_DEBUG_SORT
+        G4CASCADE_WATCHER_HIGHZ
+- G4CascadeInterface.cc: Replace preprocessor flags "debug_G4...Interface"
+  with G4CASCADE_DEBUG_INTERFACE, and "BERTDEV" with G4CASCADE_COULOMB_DEV.
+  Fix bug with information access in debugging block.
+- G4EquilibriumEvaporator.cc, G4IntraNucleiCascader.cc,
+  G4NonEquilibriumEvaporator.cc:  Eliminate preprocessor flag RUN and all
+  code contained in "#else" blocks.
+- G4LorentzConverter.cc:  Add diagnostic output with different levels:  All
+  " >>>" entry messages done for verboseLevel >= 1; all numeric reports for
+  verboseLevel > 2.
+- G4NucleiModel: Replace preprocessor flag "CHC_CHECK" with
+  G4CASCADE_DEBUG_CHARGE.
+- G4PreCompoundCascadeInterface.cc: Replace preprocessor flag
+  "debug_G4...Interface" with G4CASCADE_DEBUG_INTERFACE.  Fix bug with
+  information access in debugging block.
+- G4WatcherGun.cc: Replace preprocessor flag "PB" with G4CASCADE_WATCHER_HIGHZ.
+June 2010 Michael Kelsey
+---------------------------
+- G4CascadeInterface.hh:  Add setVerboseLevel() function.
+- G4IntraNucleiCascader.cc:  Add reporting of momentum content for residual
+  nuclear fragment, list of final-state particles, some cleanup of momentum
+  balancing code.
+- G4LorentzConvertor:  Add reporting of bullet and target four-vectors.
+- G4NucleiModel.cc:  Add diagnostic output for partner-list generation,
+  replace one random-angle code block with generateWithRandomAngles().
+June 2010 Michael Kelsey (hadr-casc-V09-03-45)
+-------------------------------------------------
+- G4CascadeInterface.cc, G4PreCompoundCascadeInterface.cc:  When converting
+  output particles from K0/K0bar to K0S/K0L, convert kinetic energy from
+  Bertini internal units (GeV) to GEANT4 units (MeV).
+- G4VCascadeCollider:  Make two separate ctors, name and name+verbose, with
+  no default values.  All subclasses *must* provide a literal name string.
+June 2010 Michael Kelsey (hadr-casc-V09-03-44)
+-------------------------------------------------
+- G4CascadeT33piNChannel.cc:  Swapped 8-body final state tables for pipP
+  vs. pimN.
+June 2010 Michael Kelsey (hadr-casc-V09-03-43)
+-------------------------------------------------
 - G4CascadeData.hh:  Equally trivial fix for compiler warking on Intel ICC
   for index[] array bounds in ::initialize().  Dimension array as [9], and

trunk/source/processes/hadronic/models/cascade/cascade/GNUmakefile

-              r819
+              r1340
 # $Id: GNUmakefile,v 1.9 2007/05/20 12:01:26 miheikki Exp $
+# $Id: GNUmakefile,v 1.15 2010/09/23 05:02:14 mkelsey Exp $
 # -----------------------------------------------------------
 # GNUmakefile for hadronic library.  Gabriele Cosmo, 18/9/96.
+#
+# Map user environment/GMake variables onto preprocessor debugging flags
+#
+# 20100922 J. Yarba -- Add include directories for pre-compound model
 # -----------------------------------------------------------
 name := G4hadronic_bert_cascade
+ifdef G4CASCADE_COULOMB_DEV
+  CPPFLAGS += -DG4CASCADE_COULOMB_DEV=1
+endif
+ifdef G4CASCADE_DEBUG_CHARGE
+  CPPFLAGS += -DG4CASCADE_DEBUG_CHARGE=1
+endif
+ifdef G4CASCADE_DEBUG_INTERFACE
+  CPPFLAGS += -DG4CASCADE_DEBUG_INTERFACE=1
+endif
+ifdef G4CASCADE_DEBUG_SAMPLER
+  CPPFLAGS += -DG4CASCADE_DEBUG_SAMPLER=1
+endif
+ifdef G4CASCADE_DEBUG_SORT
+  CPPFLAGS += -DG4CASCADE_DEBUG_SORT=1
+endif
+ifdef G4CASCADE_WATCHER_HIGHZ
+  CPPFLAGS += -DG4CASCADE_WATCHER_HIGHZ=1
+endif
+ifdef G4CASCADE_SKIP_ECONS
+  CPPFLAGS += -DG4CASCADE_SKIP_ECONS=1
+endif
+ifdef G4CASCADE_CHECK_ECONS
+  CPPFLAGS += -DG4CASCADE_CHECK_ECONS=1
+endif
 ifndef G4INSTALL
   G4INSTALL = ../../../../../..
 endif
 include $(G4INSTALL)/config/architecture.gmk
 …
             -I$(G4BASE)/processes/hadronic/models/management/include \
             -I$(G4BASE)/processes/hadronic/models/util/include \
+            -I$(G4BASE)/processes/hadronic/models/pre_equilibrium/exciton_model/include/ \
+            -I$(G4BASE)/processes/hadronic/models/de_excitation/multifragmentation/include/ \
+            -I$(G4BASE)/processes/hadronic/models/de_excitation/fermi_breakup/include/ \
+            -I$(G4BASE)/processes/hadronic/models/de_excitation/photon_evaporation/include/ \
+            -I$(G4BASE)/processes/hadronic/models/de_excitation/management/include/ \
             -I$(G4BASE)/processes/hadronic/models/de_excitation/evaporation/include/ \
+            -I$(G4BASE)/processes/hadronic/models/de_excitation/handler/include/ \
+            -I$(G4BASE)/processes/hadronic/models/de_excitation/util/include/ \
             -I$(G4BASE)/processes/hadronic/models/cascade/cascade/include \
             -I$(G4BASE)/processes/hadronic/models/cascade/utils/include \

trunk/source/processes/hadronic/models/cascade/cascade/include/G4Analyser.hh

-              r819
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4Analyser.hh,v 1.10 2010/10/14 20:55:10 mkelsey Exp $
 //
+// 20101010  M. Kelsey -- Migrate to integer A and Z
 #ifndef G4ANALYSER_HH
 #define G4ANALYSER_HH
 …
   G4Analyser();
+  void setInelCsec(G4double csec,
+                   G4bool withn);
+  void setInelCsec(G4double csec, G4bool withn);
   void setWatchers(const std::vector<G4NuclWatcher>& watchers);
+  void try_watchers(G4double a,
+                    G4double z,
+                    G4bool if_nucl);
+  void try_watchers(G4int a, G4int z, G4bool if_nucl);
   void analyse(const G4CollisionOutput& output);
   void printResults();
 …
   G4double averagePionKinEnergy;
   G4double averageExitationEnergy;
   G4double averageNucleiFragments;
+  G4double averageOutgoingNuclei;
   G4double fissy_prob;
   G4double averagePionPl;

trunk/source/processes/hadronic/models/cascade/cascade/include/G4BigBanger.hh

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4BigBanger.hh,v 1.14 2010/06/25 09:41:48 gunter Exp $
 // GEANT4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4BigBanger.hh,v 1.17 2010/09/28 20:15:00 mkelsey Exp $
+// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100315  M. Kelsey -- Remove "using" directive and unnecessary #includes.
 …
 // 20100517  M. Kelsey -- Inherit from common base class
 // 20100519  M. Kelsey -- Get rid of proton and neutron masses as arguments!
+// 20100714  M. Kelsey -- Switch to new G4CascadeColliderBase class
+// 20100726  M. Kelsey -- Move std::vector<> buffer to .hh file
+// 20100928  M. Kelsey -- Migrate to integer A and Z
 #ifndef G4BIG_BANGER_HH
 #define G4BIG_BANGER_HH
 #include "G4VCascadeCollider.hh"
+#include "G4CascadeColliderBase.hh"
 #include "G4InuclElementaryParticle.hh"
 #include <vector>
 …
 class G4BigBanger : public G4VCascadeCollider {
+class G4BigBanger : public G4CascadeColliderBase {
 public:
   G4BigBanger();
 …
 private:
   void generateBangInSCM(G4double etot, G4double a, G4double z);
+  void generateBangInSCM(G4double etot, G4int a, G4int z);
   void generateMomentumModules(G4double etot, G4double a, G4double z);
+  void generateMomentumModules(G4double etot, G4int a, G4int z);
+  G4double xProbability(G4double x,
+                        G4int ia) const;
+  G4double xProbability(G4double x, G4int a) const;
   G4double maxProbability(G4double a) const;
+  G4double maxProbability(G4int a) const;
+  G4double generateX(G4int ia,
+                     G4double a,
+                     G4double promax) const;
+  G4double generateX(G4int ia, G4double promax) const;
   // Buffers for big-bang results
   std::vector<G4InuclElementaryParticle> particles;
   std::vector<G4double> momModules;
+  std::vector<G4LorentzVector> scm_momentums;
 };

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadParticle.hh

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4CascadParticle.hh,v 1.15 2010/06/25 09:41:50 gunter Exp $
 // Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4CascadParticle.hh,v 1.16 2010/09/16 05:21:00 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100112  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
 // 20100126  M. Kelsey -- Replace vector<G4Double> position with G4ThreeVector,
 //              move ::print() to .cc file, fix uninitialized data members
+// 20100915  M. Kelsey -- Make getGeneration() const
 #ifndef G4CASCAD_PARTICLE_HH
 …
   void print() const;
   G4int getGeneration() {
+  G4int getGeneration() const {
     return generation;
+  }

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeChannel.hh,v 1.7 2010/06/25 09:41:52 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100514 M. Kelsey -- All functionality removed except quantum-number

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeData.hh

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4CascadeData.hh,v 1.7 2010/06/25 09:41:54 gunter Exp $
 // GEANT4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4CascadeData.hh,v 1.10 2010/08/04 05:28:24 mkelsey Exp $
+// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100507  M. Kelsey -- Use template arguments to dimension const-refs
 …
 // 20100611  M. Kelsey -- Work around Intel ICC compiler warning about
 //              index[] subscripts out of range.  Dimension to full [9].
+// 20100803  M. Kelsey -- Add printing function for debugging, split
+//              implementation code to .icc file.  Add name argument.
 #ifndef G4_CASCADE_DATA_HH
 …
 #include "globals.hh"
 #include "G4CascadeSampler.hh"          /* To get number of energy bins */
+#include "G4String.hh"
 template <int NE,int N2,int N3,int N4,int N5,int N6,int N7,int N8=0,int N9=0>
 …
   static const G4int empty9bfs[1][9];
+  const G4String name;                  // For diagnostic purposes
   G4int maxMultiplicity() const { return NM+1; }  // Used by G4CascadeFunctions
+  void print(G4int mult=-1) const;      // Dump multiplicty tables (-1 == all)
+  void printXsec(const G4double (&xsec)[NE]) const;
   // Constructor for kaon/hyperon channels, with multiplicity <= 7
 …
                 const G4int (&the4bfs)[N4][4], const G4int (&the5bfs)[N5][5],
                 const G4int (&the6bfs)[N6][6], const G4int (&the7bfs)[N7][7],
+                const G4double (&xsec)[NXS][NE])
+                const G4double (&xsec)[NXS][NE],
+                const G4String& aName="G4CascadeData")
     : x2bfs(the2bfs), x3bfs(the3bfs), x4bfs(the4bfs), x5bfs(the5bfs),
       x6bfs(the6bfs), x7bfs(the7bfs), x8bfs(empty8bfs), x9bfs(empty9bfs),
       crossSections(xsec), tot(sum) { initialize(); }
+      crossSections(xsec), tot(sum), name(aName) { initialize(); }
   // Constructor for kaon/hyperon channels, with multiplicity <= 7 and inclusive
 …
                 const G4int (&the4bfs)[N4][4], const G4int (&the5bfs)[N5][5],
                 const G4int (&the6bfs)[N6][6], const G4int (&the7bfs)[N7][7],
+                const G4double (&xsec)[NXS][NE], const G4double (&theTot)[NE])
+                const G4double (&xsec)[NXS][NE], const G4double (&theTot)[NE],
+                const G4String& aName="G4CascadeData")
     : x2bfs(the2bfs), x3bfs(the3bfs), x4bfs(the4bfs), x5bfs(the5bfs),
       x6bfs(the6bfs), x7bfs(the7bfs), x8bfs(empty8bfs), x9bfs(empty9bfs),
       crossSections(xsec), tot(theTot) { initialize(); }
+      crossSections(xsec), tot(theTot), name(aName) { initialize(); }
   // Constructor for pion/nuleon channels, with multiplicity > 7
 …
                 const G4int (&the6bfs)[N6][6], const G4int (&the7bfs)[N7][7],
                 const G4int (&the8bfs)[N8D][8], const G4int (&the9bfs)[N9D][9],
+                const G4double (&xsec)[NXS][NE])
+                const G4double (&xsec)[NXS][NE],
+                const G4String& aName="G4CascadeData")
     : x2bfs(the2bfs), x3bfs(the3bfs), x4bfs(the4bfs), x5bfs(the5bfs),
       x6bfs(the6bfs), x7bfs(the7bfs), x8bfs(the8bfs), x9bfs(the9bfs),
       crossSections(xsec), tot(sum) { initialize(); }
+      crossSections(xsec), tot(sum), name(aName) { initialize(); }
   // Constructor for pion/nuleon channels, with multiplicity > 7 and inclusive
 …
                 const G4int (&the6bfs)[N6][6], const G4int (&the7bfs)[N7][7],
                 const G4int (&the8bfs)[N8D][8], const G4int (&the9bfs)[N9D][9],
+                const G4double (&xsec)[NXS][NE], const G4double (&theTot)[NE])
+                const G4double (&xsec)[NXS][NE], const G4double (&theTot)[NE],
+                const G4String& aName="G4CascadeData")
     : x2bfs(the2bfs), x3bfs(the3bfs), x4bfs(the4bfs), x5bfs(the5bfs),
       x6bfs(the6bfs), x7bfs(the7bfs), x8bfs(the8bfs), x9bfs(the9bfs),
+      crossSections(xsec), tot(theTot) { initialize(); }
+      crossSections(xsec), tot(theTot), name(aName) { initialize(); }
   void initialize();                    // Fill summed arrays from input
 };
-template <int NE,int N2,int N3,int N4,int N5,int N6,int N7,int N8,int N9> inline
-void G4CascadeData<NE,N2,N3,N4,N5,N6,N7,N8,N9>::initialize() {
-  // Initialize index offsets for cross-section array (can't do globally)
-  index[0] = 0;   index[1] = N02; index[2] = N23; index[3] = N24;
-  index[4] = N25; index[5] = N26; index[6] = N27; index[7] = N28;
-  index[8] = N29;
-  // Initialize multiplicity array
-  for (G4int m = 0; m < NM; m++) {
-    G4int start = index[m];
-    G4int stop = index[m+1];
-    for (G4int k = 0; k < NE; k++) {
-      multiplicities[m][k] = 0.0;
-      for (G4int i = start; i < stop; i++) {
-        multiplicities[m][k] += crossSections[i][k];
+      }
+    }
+  }
-  // Initialize total cross section array
-  for (G4int k = 0; k < NE; k++) {
-    sum[k] = 0.0;
-    for (G4int m = 0; m < NM; m++) {
-      sum[k] += multiplicities[m][k];
+    }
+  }
+}
 // Dummy arrays for use when optional template arguments are skipped
 …
 const G4int G4CascadeData<NE,N2,N3,N4,N5,N6,N7,N8,N9>::empty9bfs[1][9] = {{0}};
+// GCC and other compilers require template implementations here
+#include "G4CascadeData.icc"
 #endif

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeFunctions.hh

-              r1337
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+//
+// $Id: G4CascadeFunctions.hh,v 1.6 2010/06/25 09:41:56 gunter Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4CascadeFunctions.hh,v 1.7 2010/08/03 23:09:36 mkelsey Exp $
+// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100407  M. Kelsey -- Return particle types std::vector<> by const ref,
 …
 //              which Sampler is used.  Move implementations to .icc file.
 // 20100511  M. Kelsey -- Pass "kinds" buffer as input to getOutputPartTypes
+// 20100803  M. Kelsey -- Add printing function for debugging
 #ifndef G4_CASCADE_FUNCTIONS_HH
 …
   getOutgoingParticleTypes(std::vector<G4int>& kinds, G4int mult, G4double ke);
+  static void printTable();
 private:
   G4CascadeFunctions() : SAMP() {}

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeFunctions.icc

-              r1337
+              r1340
+#ifndef G4_CASCADE_FUNCTIONS_ICC
+#define G4_CASCADE_FUNCTIONS_ICC
 //
 // ********************************************************************
 …
 // ********************************************************************
 //
 // $Id: G4CascadeFunctions.icc,v 1.3 2010/06/25 09:41:58 gunter Exp $
 // GEANT4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4CascadeFunctions.icc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
+// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100512  M. Kelsey -- Pass std::vector<> buffer as argument to
 //              getOutgoingPartTypes().
+// 20100803  M. Kelsey -- Add printing function for debugging
+// 20100804  M. Kelsey -- Pretty up printing function
 #ifndef G4_CASCADE_FUNCTIONS_ICC
 #define G4_CASCADE_FUNCTIONS_ICC
+#include "G4CascadeFunctions.hh"
+#include "globals.hh"
 …
+// Generate list of final state particles
 template <class DATA, class SAMP> inline
 void G4CascadeFunctions<DATA,SAMP>::
 …
 #endif
   // Identify final-state array to be copies
+  // Identify final-state array to be copied
   const G4int* chan = 0;
   if (mult == 2) chan = DATA::data.x2bfs[channel];
 …
+}
+// Dump lookup tables, including interpolation bins, to log file
+template <class DATA, class SAMP> inline
+void G4CascadeFunctions<DATA,SAMP>::printTable() {
+  G4cout << " ---------- " << DATA::data.name << " ----------" << G4endl;
+  instance.print();
+  DATA::data.print();
+  G4cout << " ------------------------------" << G4endl;
+}
 #endif  /* G4_CASCADE_FUNCTIONS_ICC */

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeInterface.hh

-              r1315
+              r1340
 // ********************************************************************
 //
 // $Id: G4CascadeInterface.hh,v 1.16 2010/05/21 18:07:30 mkelsey Exp $
+// $Id: G4CascadeInterface.hh,v 1.23 2010/09/23 18:13:32 mkelsey Exp $
 // Defines an interface to Bertini (BERT) cascade
 // based on INUCL  intra-nuclear transport.models
 …
 // 20100405  M. Kelsey -- Fix constness of op== and op!=
 // 20100519  M. Kelsey -- Remove Collider data members
+// 20100617  M. Kelsey -- Make G4InuclCollider a local data member
+// 20100723  M. Kelsey -- Move G4CollisionOutput here for reuse
+// 20100916  M. Kelsey -- Add functions to encapsulate ApplyYourself() actions,
+//              make colliders pointers (don't expose dependencies)
+// 20100922  M. Kelsey -- Add functions to select de-excitation method
 #ifndef G4CASCADEINTERFACE_H
 …
 #include "G4FragmentVector.hh"
 #include "G4KineticTrackVector.hh"
+#include "G4LorentzRotation.hh"
 #include "G4Nucleon.hh"
 #include "G4Nucleus.hh"
 …
 #include "G4ReactionProduct.hh"
 #include "G4ReactionProductVector.hh"
+class G4InuclCollider;
+class G4InuclParticle;
+class G4CollisionOutput;
+class G4CascadeCheckBalance;
+class G4V3DNucleus;
 …
                                  G4Nucleus& theNucleus);
+  void setVerboseLevel(G4int verbose) { verboseLevel = verbose; }
+  // Select betweeen different post-cascade de-excitation models
+  void useCascadeDeexcitation();
+  void usePreCompoundDeexcitation();
+protected:
+  // Convert input projectile and target to Bertini internal types
+  void createBullet(const G4HadProjectile& aTrack);
+  void createTarget(G4Nucleus& theNucleus);
+  // Evaluate whether any outgoing particles penetrated Coulomb barrier
+  G4bool coulombBarrierViolation() const;
+  // Conditions for rejecting cascade attempt
+  G4bool retryInelasticProton() const;
+  G4bool retryInelasticNucleus() const;
+  // Fill sparse array with minimum momenta for inelastic on hydrogen
+  void initializeElasticCuts();
+  // Transfer Bertini internal final state to hadronics interface
+  void copyOutputToHadronicResult();
+  // Terminate job because of energy/momentum/etc. violations
+  void throwNonConservationFailure();
 private:
   G4int operator==(const G4CascadeInterface& right) const {
 …
+  }
+  static const G4int maximumTries;      // Number of iterations for inelastic
+  G4double cutElastic[32];              // Bullet momenta for hydrogen target
   G4int verboseLevel;
+  G4int numberOfTries;
+private:
+  G4HadFinalState theResult;
+  G4HadFinalState theResult;
+  G4InuclCollider* collider;
+  G4CascadeCheckBalance* balance;
+  G4InuclParticle* bullet;
+  G4InuclParticle* target;
+  G4CollisionOutput* output;
+  G4LorentzRotation bulletInLabFrame;
 };

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeInterpolator.hh

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4CascadeInterpolator.hh,v 1.2 2010/06/25 09:42:00 gunter Exp $
 // GEANT4 tag $Name: geant4-09-04-beta-01 $
+// $Id: G4CascadeInterpolator.hh,v 1.3 2010/08/03 23:09:36 mkelsey Exp $
+// GEANT4 tag $Name: hadr-casc-V09-03-85 $
 //
 // Author:  Michael Kelsey <kelsey@slac.stanford.edu>
 …
 // is the bin index, and the fractional part is, obviously, the
 // fractional part.
+//
+// 20100803  M. Kelsey -- Add printBins() function for debugging
 #ifndef G4CASCADE_INTERPOLATOR_HH
 …
   G4double interpolate(const G4double (&yb)[nBins]) const;
+  void printBins() const;       // Show bin edges for debugging purposes
 private:
   const G4double (&xBins)[nBins];

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeInterpolator.icc

-              r1337
+              r1340
+#ifndef G4CASCADE_INTERPOLATOR_ICC
+#define G4CASCADE_INTERPOLATOR_ICC
 //
 // ********************************************************************
 …
 // ********************************************************************
 //
 // $Id: G4CascadeInterpolator.icc,v 1.6 2010/06/25 09:42:02 gunter Exp $
 // GEANT4 tag $Name: geant4-09-04-beta-01 $
+// $Id: G4CascadeInterpolator.icc,v 1.8 2010/10/19 19:48:00 mkelsey Exp $
+// GEANT4 tag $Name: hadr-casc-V09-03-85 $
 //
 // Author:  Michael Kelsey <kelsey@slac.stanford.edu>
 …
 // 20100520  M. Kelsey -- Second bug fix:  Loop in bin search should start at
 //              i=1, not i=0 (since i-1 is the key).
+// 20100803  M. Kelsey -- Add printBins() function for debugging
+// 20101019  M. Kelsey -- CoVerity reports: recursive #include, index overrun
+#include "globals.hh"
 #include "G4CascadeInterpolator.hh"
+#include <iomanip>
 …
   } else {                              // Assume nBins small; linear search
     int i;
     for (i=1; i<nBins && x>xBins[i]; i++) {;}   // Stops when x within bin i-1
+    for (i=1; i<last && x>xBins[i]; i++) {;}    // Stops when x within bin i-1
     xindex = i-1;
     xbin = xBins[i] - xBins[i-1];
 …
   return (i==last) ? yb[last] : (yb[i] + frac*(yb[i+1]-yb[i]));
+}
+// Print bin edges for debugging
+template <int NBINS>
+void G4CascadeInterpolator<NBINS>::printBins() const {
+  G4cout << " G4CascadeInterpolator<" << NBINS << "> : " << G4endl;
+  for (G4int k=0; k<NBINS; k++) {
+    G4cout << " " << std::setw(5) << xBins[k];
+    if ((k+1)%12 == 0) G4cout << G4endl;
+  }
+  G4cout << G4endl;
+}
+#endif  /* G4CASCADE_INTERPOLATOR_ICC */

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeKminusNChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeKminusNChannel.hh,v 1.7 2010/06/25 09:42:04 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100507 M. Kelsey -- Remove redundant total-bins template argument

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeKminusPChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeKminusPChannel.hh,v 1.7 2010/06/25 09:42:06 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100507 M. Kelsey -- Remove redundant total-bins template argument

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeKplusNChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeKplusNChannel.hh,v 1.7 2010/06/25 09:42:08 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100507 M. Kelsey -- Remove redundant total-bins template argument

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeKplusPChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeKplusPChannel.hh,v 1.7 2010/06/25 09:42:10 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100507 M. Kelsey -- Remove redundant total-bins template argument

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeKzeroBarNChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeKzeroBarNChannel.hh,v 1.7 2010/06/25 09:42:12 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100507 M. Kelsey -- Remove redundant total-bins template argument

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeKzeroBarPChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeKzeroBarPChannel.hh,v 1.7 2010/06/25 09:42:14 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100507 M. Kelsey -- Remove redundant total-bins template argument

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeKzeroNChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeKzeroNChannel.hh,v 1.7 2010/06/25 09:42:16 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100507 M. Kelsey -- Remove redundant total-bins template argument

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeKzeroPChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeKzeroPChannel.hh,v 1.7 2010/06/25 09:42:18 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100507 M. Kelsey -- Remove redundant total-bins template argument

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeLambdaNChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeLambdaNChannel.hh,v 1.7 2010/06/25 09:42:20 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100507 M. Kelsey -- Remove redundant total-bins template argument

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeLambdaPChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeLambdaPChannel.hh,v 1.7 2010/06/25 09:42:22 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100507 M. Kelsey -- Remove redundant total-bins template argument

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeNNChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeNNChannel.hh,v 1.3 2010/06/25 09:42:24 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28
29	29	#ifndef G4_CASCADE_NN_CHANNEL_HH

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeNPChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeNPChannel.hh,v 1.3 2010/06/25 09:42:26 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28
29	29	#ifndef G4_CASCADE_NP_CHANNEL_HH

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadePPChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadePPChannel.hh,v 1.3 2010/06/25 09:42:28 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28
29	29	#ifndef G4_CASCADE_PP_CHANNEL_HH

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadePiMinusNChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadePiMinusNChannel.hh,v 1.3 2010/06/25 09:42:30 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28
29	29	#ifndef G4_CASCADE_PIMINUSN_CHANNEL_HH

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadePiMinusPChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadePiMinusPChannel.hh,v 1.3 2010/06/25 09:42:32 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28
29	29	#ifndef G4_CASCADE_PIMINUSP_CHANNEL_HH

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadePiPlusNChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadePiPlusNChannel.hh,v 1.3 2010/06/25 09:42:34 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28
29	29	#ifndef G4_CASCADE_PIPLUSN_CHANNEL_HH

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadePiPlusPChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadePiPlusPChannel.hh,v 1.3 2010/06/25 09:42:36 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28
29	29	#ifndef G4_CASCADE_PIPLUSP_CHANNEL_HH

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadePiZeroNChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadePiZeroNChannel.hh,v 1.3 2010/06/25 09:42:38 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28
29	29	#ifndef G4_CASCADE_PIZERON_CHANNEL_HH

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadePiZeroPChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadePiZeroPChannel.hh,v 1.3 2010/06/25 09:42:40 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28
29	29	#ifndef G4_CASCADE_PIZEROP_CHANNEL_HH

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeSampler.hh

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4CascadeSampler.hh,v 1.3 2010/06/25 09:42:42 gunter Exp $
 // GEANT4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4CascadeSampler.hh,v 1.4 2010/08/03 23:09:36 mkelsey Exp $
+// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100506  M. Kelsey -- Move functionality of G4CascadeChannel here,
 …
 // 20100512  M. Kelsey -- Make this templated on energy and multiplicity
 //              binning, as base to new sampler.
+// 20100803  M. Kelsey -- Add print function for debugging.
 #ifndef G4_CASCADE_SAMPLER_HH
 …
                       const G4double xsec[][energyBins]) const;
+  virtual void print() const;
 private:
   // Optional start/stop arguments default to inclusive arrays

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeSampler.icc

-              r1337
+              r1340
+#ifndef G4CASCADE_SAMPLER_ICC
+#define G4CASCADE_SAMPLER_ICC
 //
 // ********************************************************************
 …
 // ********************************************************************
 //
 // $Id: G4CascadeSampler.icc,v 1.3 2010/06/25 09:42:44 gunter Exp $
 // GEANT4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4CascadeSampler.icc,v 1.5 2010/10/19 19:48:01 mkelsey Exp $
+// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100506 M. Kelsey -- Move functionity of G4CascadeChannel here,
 //              use as base class to G4CascadeFunctions<T>.
 // 20100512 M. Kelsey -- Move implementation to .icc with templating
+// 20100803 M. Kelsey -- Add print function for debugging.
+// 20101019  M. Kelsey -- CoVerity report: recursive #include
 #include "G4CascadeSampler.hh"
 …
   return 0;     // Is this right?  Shouldn't it return maximum, not minimum?
+}
+template <int NBINS, int NMULT> inline
+void G4CascadeSampler<NBINS,NMULT>::print() const {
+  interpolator.printBins();
+}
+#endif  /* G4CASCADE_SAMPLER_ICC */

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeSigmaMinusNChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeSigmaMinusNChannel.hh,v 1.7 2010/06/25 09:42:46 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100507 M. Kelsey -- Remove redundant total-bins template argument

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeSigmaMinusPChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeSigmaMinusPChannel.hh,v 1.7 2010/06/25 09:42:48 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100507 M. Kelsey -- Remove redundant total-bins template argument

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeSigmaPlusNChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeSigmaPlusNChannel.hh,v 1.7 2010/06/25 09:42:50 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100507 M. Kelsey -- Remove redundant total-bins template argument

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeSigmaPlusPChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeSigmaPlusPChannel.hh,v 1.7 2010/06/25 09:42:52 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100507 M. Kelsey -- Remove redundant total-bins template argument

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeSigmaZeroNChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeSigmaZeroNChannel.hh,v 1.7 2010/06/25 09:42:54 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100507 M. Kelsey -- Remove redundant total-bins template argument

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeSigmaZeroPChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeSigmaZeroPChannel.hh,v 1.7 2010/06/25 09:42:56 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100507 M. Kelsey -- Remove redundant total-bins template argument

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeXiMinusNChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeXiMinusNChannel.hh,v 1.7 2010/06/25 09:42:58 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100507 M. Kelsey -- Remove redundant total-bins template argument

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeXiMinusPChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeXiMinusPChannel.hh,v 1.7 2010/06/25 09:43:00 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100507 M. Kelsey -- Remove redundant total-bins template argument

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeXiZeroNChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeXiZeroNChannel.hh,v 1.7 2010/06/25 09:43:02 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100507 M. Kelsey -- Remove redundant total-bins template argument

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CascadeXiZeroPChannel.hh

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeXiZeroPChannel.hh,v 1.7 2010/06/25 09:43:04 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100507 M. Kelsey -- Remove redundant total-bins template argument

trunk/source/processes/hadronic/models/cascade/cascade/include/G4CollisionOutput.hh

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4CollisionOutput.hh,v 1.20.2.1 2010/06/25 09:43:06 gunter Exp $
 // Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4CollisionOutput.hh,v 1.29 2010/09/26 04:06:03 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
 …
 // 20100418  M. Kelsey -- Add function to boost output lists to lab frame
 // 20100520  M. Kelsey -- Add function to rotate Z axis, from G4Casc.Interface
+// 20100620  M. Kelsey -- Add setVerboseLevel() function
+// 20100715  M. Kelsey -- Add total charge and baryon number functions, and a
+//              combined "add()" function to put two of these together.
+// 20100716  M. Kelsey -- Add interface to handle G4CascadParticles
+// 20100924  M. Kelsey -- Use "OutgoingNuclei" name consistently, replacing
+//              old "TargetFragment".  Add new (reusable) G4Fragment buffer
+//              and access functions for initial post-cascade processing.
+//              Move implementation of add() to .cc file.
+// 20100925  M. Kelsey -- Add function to process G4ReactionProduct list
 #ifndef G4COLLISION_OUTPUT_HH
 #define G4COLLISION_OUTPUT_HH
+#include "G4Fragment.hh"
 #include "G4InuclElementaryParticle.hh"
 #include "G4InuclNuclei.hh"
 #include "G4LorentzRotation.hh"
+#include "G4ReactionProductVector.hh"
 #include <algorithm>
 #include <vector>
+class G4CascadParticle;
 class G4LorentzConvertor;
 class G4CollisionOutput {
 public:
   G4CollisionOutput();
   G4CollisionOutput& operator=(const G4CollisionOutput& right);
+  void reset();
+  void setVerboseLevel(G4int verbose) { verboseLevel = verbose; };
+  // ===== Accumulate contents of lists =====
+  void reset();         // Empties lists for new event
+  void add(const G4CollisionOutput& right);     // Merge complete objects
   void addOutgoingParticle(const G4InuclElementaryParticle& particle) {
 …
   void addOutgoingParticles(const std::vector<G4InuclElementaryParticle>& particles);
   void addTargetFragment(const G4InuclNuclei& nuclei) {
     nucleiFragments.push_back(nuclei);
+  void addOutgoingNucleus(const G4InuclNuclei& nuclei) {
+    outgoingNuclei.push_back(nuclei);
   };
   void addTargetFragments(const std::vector<G4InuclNuclei>& nuclea);
+  void addOutgoingNuclei(const std::vector<G4InuclNuclei>& nuclea);
+  // These are primarily for G4IntraNucleiCascader internal checks
+  void addOutgoingParticle(const G4CascadParticle& cparticle);
+  void addOutgoingParticles(const std::vector<G4CascadParticle>& cparticles);
+  void addOutgoingParticles(const G4ReactionProductVector* rproducts);
+  // Special buffer for initial, possible unstable fragment from cascade
+  void addRecoilFragment(const G4Fragment* aFragment) {
+    if (aFragment) addRecoilFragment(*aFragment);
+  }
+  void addRecoilFragment(const G4Fragment& aFragment) {
+    theRecoilFragment = aFragment;
+  }
+  // ===== Access contents of lists =====
+  G4int numberOfOutgoingParticles() const { return outgoingParticles.size(); }
   const std::vector<G4InuclElementaryParticle>& getOutgoingParticles() const {
     return outgoingParticles;
   };
+  G4int numberOfNucleiFragments() const {
+    return nucleiFragments.size();
+  };
+  G4int numberOfOutgoingNuclei() const { return outgoingNuclei.size(); };
   const std::vector<G4InuclNuclei>& getNucleiFragments() const {
     return nucleiFragments;
+  const std::vector<G4InuclNuclei>& getOutgoingNuclei() const {
+    return outgoingNuclei;
   };
+  const G4Fragment& getRecoilFragment() const { return theRecoilFragment; }
+  // ===== Get event totals for conservation checking, recoil, etc. ======
   G4LorentzVector getTotalOutputMomentum() const;
+  G4int getTotalCharge() const;                 // NOTE:  No fractional charges!
+  G4int getTotalBaryonNumber() const;
   void printCollisionOutput() const;
+  // ===== Manipulate final-state particles for kinematics =====
   void boostToLabFrame(const G4LorentzConvertor& convertor);
   void rotateEvent(const G4LorentzRotation& rotate);
+  void trivialise(G4InuclParticle* bullet,
+                  G4InuclParticle* target);
+  void setOnShell(G4InuclParticle* bullet,
+                  G4InuclParticle* target);
+  void trivialise(G4InuclParticle* bullet, G4InuclParticle* target);
+  void setOnShell(G4InuclParticle* bullet, G4InuclParticle* target);
   void setRemainingExitationEnergy();
+  double getRemainingExitationEnergy() const {
+    return eex_rest;
+  };
+  G4bool acceptable() const {
+    return on_shell;
+  };
+  double getRemainingExitationEnergy() const { return eex_rest; };
+  G4bool acceptable() const { return on_shell; };
 private:
   G4int verboseLevel;
   std::vector<G4InuclElementaryParticle> outgoingParticles;
+  std::vector<G4InuclNuclei> nucleiFragments;
+  G4double eex_rest;
+  std::vector<G4InuclNuclei> outgoingNuclei;
+  G4Fragment theRecoilFragment;
+  G4double eex_rest;            // Used by setOnShell() for kinematics
   std::pair<std::pair<G4int,G4int>, G4int> selectPairToTune(G4double de) const;
   G4bool on_shell;
 };

trunk/source/processes/hadronic/models/cascade/cascade/include/G4Dineutron.hh

r1337	r1340
25	25	//
26	26	// $Id: G4Dineutron.hh,v 1.4 2010/06/25 09:43:08 gunter Exp $
27		// GEANT4 tag $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// ------------------------------------------------------------

trunk/source/processes/hadronic/models/cascade/cascade/include/G4Diproton.hh

r1337	r1340
25	25	//
26	26	// $Id: G4Diproton.hh,v 1.4 2010/06/25 09:43:10 gunter Exp $
27		// GEANT4 tag $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// ------------------------------------------------------------

trunk/source/processes/hadronic/models/cascade/cascade/include/G4ElementaryParticleCollider.hh

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4ElementaryParticleCollider.hh,v 1.32 2010/06/25 09:43:12 gunter Exp $
 // Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4ElementaryParticleCollider.hh,v 1.35 2010/08/04 05:28:24 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
 …
 //              particle-types selector to all modes, not just strangeness.
 // 20100517  M. Kelsey -- Inherit from common base class, make arrays static
+// 20100714  M. Kelsey -- Switch to new G4CascadeColliderBase class
+// 20100726  M. Kelsey -- Move remaining std::vector<> buffers here
+// 20100804  M. Kelsey -- Add printFinalStateTables() function.
 #ifndef G4ELEMENTARY_PARTICLE_COLLIDER_HH
 #define G4ELEMENTARY_PARTICLE_COLLIDER_HH
 #include "G4VCascadeCollider.hh"
+#include "G4CascadeColliderBase.hh"
 #include "G4InuclElementaryParticle.hh"
 #include "G4LorentzVector.hh"
 …
 class G4ElementaryParticleCollider : public G4VCascadeCollider {
+class G4ElementaryParticleCollider : public G4CascadeColliderBase {
 public:
   G4ElementaryParticleCollider();
 …
                              G4double pmod) const;
+  void printFinalStateTables() const;
   // Internal buffers for lists of secondaries
   std::vector<G4InuclElementaryParticle> particles;
+  std::vector<G4LorentzVector> scm_momentums;
   std::vector<G4double> modules;
+  std::vector<G4double> masses2;
   std::vector<G4int> particle_kinds;

trunk/source/processes/hadronic/models/cascade/cascade/include/G4EquilibriumEvaporator.hh

-              r1337
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+//
+// $Id: G4EquilibriumEvaporator.hh,v 1.11.2.1 2010/06/25 09:43:14 gunter Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4EquilibriumEvaporator.hh,v 1.15 2010/09/26 04:06:03 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
 …
 //              simple data members.  Rename timeToBigBang() to override
 //              base explosion().
+// 20100714  M. Kelsey -- Switch to new G4CascadeColliderBase class
+// 20100923  M. Kelsey -- Migrate to integer A and Z
+// 20100925  M. Kelsey -- Remove no longer necessary explosion() interface
 #ifndef G4EQUILIBRIUM_EVAPORATOR_HH
 #define G4EQUILIBRIUM_EVAPORATOR_HH
+#include "G4VCascadeCollider.hh"
+#include "G4CascadeColliderBase.hh"
+#include "G4Fissioner.hh"
+#include "G4BigBanger.hh"
 class G4CollisionOutput;
-class G4Fissioner;
-class G4BigBanger;
 class G4InuclParticle;
 class G4EquilibriumEvaporator : public G4VCascadeCollider {
+class G4EquilibriumEvaporator : public G4CascadeColliderBase {
 public:
   G4EquilibriumEvaporator();
 …
 private:
   // Replace base class verision
+  virtual G4bool explosion(G4InuclNuclei*) const { return false; }
+  virtual G4bool explosion(G4double a,
+                           G4double z,
+                           G4double e) const;
+  virtual G4bool explosion(G4int a, G4int z, G4double e) const;
+  G4bool goodRemnant(G4double a,
+                     G4double z) const;
+  // FIXME:  Need to redeclare and call through base-class polymorphisms
+  virtual G4bool explosion(G4InuclNuclei* target) const {
+    return G4CascadeColliderBase::explosion(target);
+  }
+  G4double getE0(G4double A) const;
+  virtual G4bool explosion(G4Fragment* target) const {
+    return G4CascadeColliderBase::explosion(target);
+  }
+  G4double getPARLEVDEN(G4double A,
+                        G4double Z) const;
+  G4bool goodRemnant(G4int a, G4int z) const;
+  G4double getE0(G4int A) const;
+  G4double getPARLEVDEN(G4int A, G4int Z) const;
+  G4double getQF(G4double x, G4double x2, G4int a, G4int z, G4double e) const;
+  G4double getAF(G4double x, G4int a, G4int z, G4double e) const;
+  G4double getQF(G4double x,
+                 G4double x2,
+                 G4double a,
+                 G4double z,
+                 G4double e) const;
+  G4double getAF(G4double x,
+                 G4double a,
+                 G4double z,
+                 G4double e) const;
+  G4Fissioner* theFissioner;
+  G4BigBanger* theBigBanger;
+  G4Fissioner theFissioner;
+  G4BigBanger theBigBanger;
 };

trunk/source/processes/hadronic/models/cascade/cascade/include/G4EvaporationInuclCollider.hh

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4EvaporationInuclCollider.hh,v 1.5 2010/05/21 17:56:34 mkelsey Exp $
 // GEANT4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4EvaporationInuclCollider.hh,v 1.6 2010/07/14 15:41:12 mkelsey Exp $
+// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100315  M. Kelsey -- Remove "using" directive and unnecessary #includes.
 …
 // 20100517  M. Kelsey -- Inherit from common base class, make other colliders
 //              simple data members
+// 20100714  M. Kelsey -- Switch to new G4CascadeColliderBase class
 #ifndef G4EVAPORATIONINUCL_COLLIDER_HH
 #define G4EVAPORATIONINUCL_COLLIDER_HH
 #include "G4VCascadeCollider.hh"
+#include "G4CascadeColliderBase.hh"
 class G4InuclParticle;
 …
 class G4BigBanger;
 class G4EvaporationInuclCollider : public G4VCascadeCollider {
+class G4EvaporationInuclCollider : public G4CascadeColliderBase {
 public:
   G4EvaporationInuclCollider();

trunk/source/processes/hadronic/models/cascade/cascade/include/G4ExitonConfiguration.hh

-              r819
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4ExitonConfiguration.hh,v 1.7 2010/09/24 06:26:06 mkelsey Exp $
 //
+// 20100909  Add function to reset values to zero
+// 20100924  Migrate to integer A and Z
 #ifndef G4EXITON_CONFIGURATION_HH
 #define G4EXITON_CONFIGURATION_HH
 class G4ExitonConfiguration {
+public:
+  G4ExitonConfiguration()
+    : protonQuasiParticles(0), neutronQuasiParticles(0),
+      protonHoles(0), neutronHoles(0) {}
+public:
+  G4ExitonConfiguration(G4int qpp, G4int qnp, G4int qph, G4int qnh)
+    : protonQuasiParticles(qpp), neutronQuasiParticles(qnp),
+      protonHoles(qph), neutronHoles(qnh) {}
+  G4ExitonConfiguration() {
+    protonQuasiParticles = 0.0;
+    neutronQuasiParticles = 0.0;
+    protonHoles = 0.0;
+    neutronHoles = 0.0;
+  };
+  void clear() {
+    protonQuasiParticles = neutronQuasiParticles = 0;
+    protonHoles = neutronHoles = 0;
+  }
-  G4ExitonConfiguration(G4double qpp,
-                        G4double qnp,
-                        G4double qph,
-                        G4double qnh)
-    : protonQuasiParticles(qpp),
-    neutronQuasiParticles(qnp),
-    protonHoles(qph),
-    neutronHoles(qnh) {
-  };
   void incrementQP(G4int ip) {
+    if(ip < 3) {
+      if(ip == 1) {
+        protonQuasiParticles += 1.0;
+      }
+      else if(ip == 2) {
+        neutronQuasiParticles += 1.0;
+      };
+    };
+  };
+    if (ip == 1) protonQuasiParticles++;
+    else if (ip == 2) neutronQuasiParticles++;
+  }
   void incrementHoles(G4int ip) {
+    if(ip < 3) {
+      if(ip == 1) {
+        protonHoles += 1.0;
+      }
+      else if(ip == 2) {
+        neutronHoles += 1.0;
+      };
+    };
+  };
+    if (ip == 1) protonHoles++;
+    else if (ip == 2) neutronHoles++;
+  }
   void print() const {
 …
            << " neutron particles " << neutronQuasiParticles << " holes "
            << neutronHoles << G4endl;
   };
+  }
+  G4double protonQuasiParticles;
+  G4double neutronQuasiParticles;
+  G4double protonHoles;
+  G4double neutronHoles;
+  G4int protonQuasiParticles;
+  G4int neutronQuasiParticles;
+  G4int protonHoles;
+  G4int neutronHoles;
 };

trunk/source/processes/hadronic/models/cascade/cascade/include/G4FissionStore.hh

-              r819
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4FissionStore.hh,v 1.11 2010/10/19 21:33:58 mkelsey Exp $
 //
+// 20100728  Move ::addConfig() to .cc file, add setVerboseLevel(), clear()
 #ifndef G4FISSION_STORE_HH
 #define G4FISSION_STORE_HH
 #include "G4FissionConfiguration.hh"
 #include <vector>
 class G4FissionStore {
 public:
   G4FissionStore();
+  void addConfig(G4double a,
+                 G4double z,
+                 G4double ez,
+                 G4double ek,
+                 G4double ev) {
+    G4FissionConfiguration config(a, z, ez, ek, ev);
+    configurations.push_back(config);
+    // config.print();
+  };
+  void setVerboseLevel(G4int verbose=1) { verboseLevel = verbose; }
+  G4int size() const {
+    return configurations.size();
+  };
+  void addConfig(G4double a, G4double z, G4double ez, G4double ek, G4double ev);
+  void clear() { configurations.clear(); }
+  G4int size() const { return configurations.size(); }
   G4FissionConfiguration generateConfiguration(G4double amax,
 …
 private:
   G4int verboseLevel;
   std::vector<G4FissionConfiguration> configurations;
 };

trunk/source/processes/hadronic/models/cascade/cascade/include/G4Fissioner.hh

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4Fissioner.hh,v 1.13 2010/06/25 09:43:16 gunter Exp $
 // GEANT4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4Fissioner.hh,v 1.16 2010/09/14 17:51:36 mkelsey Exp $
+// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100315  M. Kelsey -- Remove "using" directive and unnecessary #includes.
 // 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
 // 20100517  M. Kelsey -- Inherit from common base class
+// 20100714  M. Kelsey -- Switch to new G4CascadeColliderBase class
+// 20100728  M. Kelsey -- Move G4FissionStore to data member and reuse
+// 20100914  M. Kelsey -- Migrate to integer A and Z
 #ifndef G4FISSIONER_HH
 #define G4FISSIONER_HH
+#include "G4VCascadeCollider.hh"
+#include "G4CascadeColliderBase.hh"
+#include "G4FissionStore.hh"
 #include <vector>
 …
 class G4Fissioner : public G4VCascadeCollider {
+class G4Fissioner : public G4CascadeColliderBase {
 public:
   G4Fissioner();
 …
 private:
+  G4double getC2(G4double A1,
+                 G4double A2,
+  G4FissionStore fissionStore;
+  G4double getC2(G4int A1,
+                 G4int A2,
                  G4double X3,
                  G4double X4,
                  G4double R12) const;
   G4double getZopt(G4double A1,
                    G4double A2,
                    G4double ZT,
+  G4double getZopt(G4int A1,
+                   G4int A2,
+                   G4int ZT,
                    G4double X3,
                    G4double X4,
 …
                              std::vector<G4double>& ED,
                              G4double& VC,
                              G4double AF,
                              G4double AS,
                              G4double ZF,
                              G4double ZS,
+                             G4int AF,
+                             G4int AS,
+                             G4int ZF,
+                             G4int ZS,
                              std::vector<G4double>& AL1,
                              std::vector<G4double>& BET1,

trunk/source/processes/hadronic/models/cascade/cascade/include/G4InteractionCase.hh

r1337	r1340
25	25	//
26	26	// $Id: G4InteractionCase.hh,v 1.12 2010/06/25 09:43:18 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100518 M. Kelsey -- Why use std::pair<> at all? Never exported; just

trunk/source/processes/hadronic/models/cascade/cascade/include/G4IntraNucleiCascader.hh

-              r1337
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+//
+// $Id: G4IntraNucleiCascader.hh,v 1.10.2.1 2010/06/25 09:43:20 gunter Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4IntraNucleiCascader.hh,v 1.21 2010/09/16 05:21:00 mkelsey Exp $
+// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100315  M. Kelsey -- Remove "using" directory and unnecessary #includes.
 …
 // 20100517  M. Kelsey -- Inherit from common base class, make other colliders
 //              simple data members
+// 20100617  M. Kelsey -- Make G4NucleiModel a data member, instead of
+//              creating and deleting on every cycle.
+// 20100623  M. Kelsey -- Undo change from 0617.  G4NucleiModel not reusable.
+// 20100714  M. Kelsey -- Switch to new G4CascadeColliderBase class
+// 20100716  M. Kelsey -- Eliminate inter_case; use base-class functionality,
+//              add function to compute recoil nuclear mass on the fly
+// 20100720  M. Kelsey -- Make EPCollider pointer member
+// 20100722  M. Kelsey -- Move cascade output buffers to .hh file
+// 20100728  M. Kelsey -- Move G4NucleiModel here, as pointer member
+// 20100907  M. Kelsey -- Add new "makeResidualFragment" to create
+//              G4InuclNuclei at current stage of cascade
+// 20100909  M. Kelsey -- Drop makeResidualFragment(), getResidualMass() and
+//              local G4InuclNuclei object, replace with new RecoilMaker.
+//              Move goodCase() to RecoilMaker.
+// 20100916  M. Kelsey -- Add functions to handle trapped particles, and to
+//              decay hyperons.
 #ifndef G4INTRA_NUCLEI_CASCADER_HH
 #define G4INTRA_NUCLEI_CASCADER_HH
+#include "G4VCascadeCollider.hh"
+#include "G4CascadeColliderBase.hh"
+#include "G4CollisionOutput.hh"
+#include <vector>
+class G4CascadParticle;
+class G4CascadeRecoilMaker;
 class G4CollisionOutput;
 class G4ElementaryParticleCollider;
+class G4InuclElementaryParticle;
 class G4InuclParticle;
+class G4NucleiModel;
 class G4IntraNucleiCascader : public G4VCascadeCollider {
+class G4IntraNucleiCascader : public G4CascadeColliderBase {
 public:
   G4IntraNucleiCascader();
 …
                G4CollisionOutput& output);
+  // FIXME:  This should come from (or be determined by) G4InteractionCase
+  void setInteractionCase(G4int intcase) {
+    inter_case = intcase;
+  };
+protected:
+  void processTrappedParticle(const G4CascadParticle& trapped);
+  void decayTrappedParticle(const G4CascadParticle& trapped);
 private:
+  G4NucleiModel* model;
   G4ElementaryParticleCollider* theElementaryParticleCollider;
+  G4CascadeRecoilMaker* theRecoilMaker;
+  // FIXME:  This should come from (or be determined by) G4InteractionCase
+  G4int inter_case;
+  G4bool goodCase(G4double a, G4double z, G4double eexs, G4double ein) const;
+  // Buffers for collecting result of cascade (reset on each iteration)
+  G4CollisionOutput output;
+  std::vector<G4CascadParticle> cascad_particles;
+  std::vector<G4CascadParticle> new_cascad_particles;
+  std::vector<G4InuclElementaryParticle> output_particles;
+  G4ExitonConfiguration theExitonConfiguration;
 };

trunk/source/processes/hadronic/models/cascade/cascade/include/G4InuclCollider.hh

-              r1337
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+//
+// $Id: G4InuclCollider.hh,v 1.13.2.1 2010/06/25 09:43:22 gunter Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4InuclCollider.hh,v 1.21 2010/09/27 04:03:43 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
 // 20100517  M. Kelsey -- Inherit from common base class, make other colliders
 //              simple data members
+// 20100620  M. Kelsey -- Move output buffers here to reduce memory churn
+// 20100714  M. Kelsey -- Switch to new G4CascadeColliderBase class
+// 20100720  M. Kelsey -- Make all the collders pointer members (to reducde
+//              external compile dependences).
+// 20100915  M. Kelsey -- Move de-excitation colliders to G4CascadeDeexcitation
+// 20100922  M. Kelsey -- Add functions to select de-excitation method, change
+//              "theDeexcitation" to be a base-class pointer for switching
+// 20100926  M. Kelsey -- Use new intermediate base class for de-exciations.
 #ifndef G4INUCL_COLLIDER_HH
 #define G4INUCL_COLLIDER_HH
+#include "G4VCascadeCollider.hh"
+#include "G4CascadeColliderBase.hh"
+#include "G4CollisionOutput.hh"
+class G4BigBanger;
+class G4CollisionOutput;
+class G4InuclParticle;
 class G4ElementaryParticleCollider;
-class G4EquilibriumEvaporator;
 class G4IntraNucleiCascader;
+class G4InuclParticle;
+class G4NonEquilibriumEvaporator;
+class G4VCascadeDeexcitation;
+class G4InuclCollider : public G4VCascadeCollider {
+class G4InuclCollider : public G4CascadeColliderBase {
 public:
   G4InuclCollider();
   virtual ~G4InuclCollider();
   void collide(G4InuclParticle* bullet, G4InuclParticle* target,
+               G4CollisionOutput& output);
+               G4CollisionOutput& globalOutput);
+  // Select betweeen different post-cascade de-excitation models
+  void useCascadeDeexcitation();
+  void usePreCompoundDeexcitation();
 private:
   G4ElementaryParticleCollider* theElementaryParticleCollider;
   G4IntraNucleiCascader* theIntraNucleiCascader;
+  G4NonEquilibriumEvaporator* theNonEquilibriumEvaporator;
+  G4EquilibriumEvaporator* theEquilibriumEvaporator;
+  G4BigBanger* theBigBanger;
+  G4VCascadeDeexcitation* theDeexcitation;      // User switchable!
+  G4CollisionOutput output;             // Secondaries from main cascade
+  G4CollisionOutput DEXoutput;          // Secondaries from de-excitation
 };

trunk/source/processes/hadronic/models/cascade/cascade/include/G4InuclElementaryParticle.hh

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4InuclElementaryParticle.hh,v 1.23 2010/06/25 09:43:24 gunter Exp $
 // Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4InuclElementaryParticle.hh,v 1.25 2010/09/16 05:21:00 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
 // 20100409  M. Kelsey -- Drop unused string argument from ctors.
 // 20100429  M. Kelsey -- Change "photon()" to "isPhoton()", use enum names
+// 20100914  M. Kelsey -- Move printout to .cc file
+// 20100915  M. Kelsey -- Add hyperon() identification function, ctor for
+//              G4DynamicParticle
 #ifndef G4INUCL_ELEMENTARY_PARTICLE_HH
 …
   explicit G4InuclElementaryParticle(G4int type)
     : G4InuclParticle(makeDefinition(type)), generation(0) {}
+  G4InuclElementaryParticle(const G4DynamicParticle& dynPart, G4int model=0)
+    : G4InuclParticle(dynPart), generation(0) {
+    setModel(model);
+  }
   G4InuclElementaryParticle(const G4LorentzVector& mom,
 …
+  }
+  G4bool hyperon() const {
+    return (baryon() && getStrangeness() != 0.);
+  }
   G4bool quasi_deutron() const { return (type() > 100); }
+  G4double getStrangeness() const { return getStrangeness(type()); }
   G4bool valid() const { return type()>0; }
+  virtual void printParticle() const {
+    G4InuclParticle::printParticle();
+    G4cout << " Particle: type " << type() << " mass " << getMass()
+           << " ekin " << getKineticEnergy() << G4endl;
+  }
+  virtual void printParticle() const;
   void setGeneration(G4int gen) { generation = gen; }

trunk/source/processes/hadronic/models/cascade/cascade/include/G4InuclNuclei.hh

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4InuclNuclei.hh,v 1.17 2010/06/25 09:43:26 gunter Exp $
 // Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4InuclNuclei.hh,v 1.27 2010/09/25 04:35:02 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100112  Michael Kelsey -- Replace G4CascadeMomentum with G4LorentzVector
 …
 // 20100319  M. Kelsey -- Remove "using" directory and unnecessary #includes.
 // 20100409  M. Kelsey -- Drop unused string argument from ctors.
+// 20100630  M. Kelsey -- Add excitation energy as optional public ctor arg,
+//           remove excitation energy data member (part of G4Ions).  Add
+//           excitation energy to "getNucleiMass()" function, move print to .cc
+// 20100711  M. Kelsey -- Add optional model ID to constructors
+// 20100714  M. Kelsey -- Use G4DynamicParticle::theDynamicalMass to deal with
+//           excitation energy without instantianting "infinite" G4PartDefns.
+// 20100719  M. Kelsey -- Move setExitationEnergy implementation to .cc file.
+// 20100906  M. Kelsey -- Add fill() functions to rewrite contents
+// 20100909  M. Kelsey -- Add function to discard exciton configuration
+// 20100914  M. Kelsey -- Use integers for A and Z
+// 20100915  M. Kelsey -- Add constructor to copy G4DynamicParticle input
+// 20100924  M. Kelsey -- Add constructor to copy G4Fragment input, and output
+//              functions to create G4Fragment.
 #ifndef G4INUCL_NUCLEI_HH
 …
 #include "G4InuclParticle.hh"
+#include "G4LorentzVector.hh"
 #include "G4ExitonConfiguration.hh"
+class G4Fragment;
 class G4ParticleDefinition;
 class G4InuclNuclei : public G4InuclParticle {
 …
   G4InuclNuclei() : G4InuclParticle() {}
+  G4InuclNuclei(G4double a, G4double z)
+    : G4InuclParticle(makeDefinition(a,z)),
+      exitationEnergy(0.0) {}
+  G4InuclNuclei(const G4DynamicParticle& dynPart, G4int model=0)
+    : G4InuclParticle(dynPart) {
+    setModel(model);
+  }
+  G4InuclNuclei(const G4LorentzVector& mom, G4double a, G4double z)
+    : G4InuclParticle(makeDefinition(a,z), mom),
+      exitationEnergy(0.0) {}
+  G4InuclNuclei(G4int a, G4int z, G4double exc=0., G4int model=0)
+    : G4InuclParticle(makeDefinition(a,z)) {
+    setExitationEnergy(exc);
+    setModel(model);
+  }
+  G4InuclNuclei(G4double ekin, G4double a, G4double z)
+    : G4InuclParticle(makeDefinition(a,z), ekin),
+      exitationEnergy(0.0) {}
+  G4InuclNuclei(const G4LorentzVector& mom, G4int a, G4int z,
+                G4double exc=0., G4int model=0)
+    : G4InuclParticle(makeDefinition(a,z), mom) {
+    setExitationEnergy(exc);
+    setModel(model);
+  }
+  G4InuclNuclei(G4double ekin, G4int a, G4int z, G4double exc,
+                G4int model=0)
+    : G4InuclParticle(makeDefinition(a,z), ekin) {
+    setExitationEnergy(exc);
+    setModel(model);
+  }
+  G4InuclNuclei(const G4Fragment& aFragment, G4int model=0);
   virtual ~G4InuclNuclei() {}
 …
   // Copy and assignment constructors for use with std::vector<>
   G4InuclNuclei(const G4InuclNuclei& right)
     : G4InuclParticle(right), exitationEnergy(right.exitationEnergy),
+    : G4InuclParticle(right),
       theExitonConfiguration(right.theExitonConfiguration) {}
   G4InuclNuclei& operator=(const G4InuclNuclei& right);
+  void setExitationEnergy(G4double e) { exitationEnergy = e; }
+  // Overwrite data structure (avoids creating/copying temporaries)
+  void fill(G4int a, G4int z, G4double exc=0., G4int model=0) {
+    fill(0., a, z, exc, model);
+  }
+  void fill(const G4LorentzVector& mom, G4int a, G4int z,
+            G4double exc=0., G4int model=0);
+  void fill(G4double ekin, G4int a, G4int z, G4double exc,
+            G4int model=0);
+  // Excitation energy is stored as dynamical mass of particle
+  void setExitationEnergy(G4double e);
   void setExitonConfiguration(const G4ExitonConfiguration& config) {
 …
+  }
   G4double getA() const { return getDefinition()->GetAtomicMass(); }
+  void clearExitonConfiguration() { theExitonConfiguration.clear(); }
+  G4double getZ() const { return getDefinition()->GetAtomicNumber(); }
+  G4int getA() const { return getDefinition()->GetAtomicMass(); }
+  G4int getZ() const { return getDefinition()->GetAtomicNumber(); }
+  G4double getExitationEnergy() const { return exitationEnergy; }
+  G4double getNucleiMass() const {
+    return getDefinition()->GetPDGMass()*MeV/GeV;       // From G4 to Bertini
+  }
   G4double getExitationEnergyInGeV() const {
     return 0.001 * exitationEnergy;
+  G4double getExitationEnergy() const {
+    return (getMass()-getNucleiMass())*GeV/MeV;         // Always in MeV
+  }
+  G4double getExitationEnergyInGeV() const { return getExitationEnergy()/GeV; }
   const G4ExitonConfiguration& getExitonConfiguration() const {
 …
+  }
   static G4double getNucleiMass(G4double a, G4double z);
+  static G4double getNucleiMass(G4int a, G4int z, G4double exc=0.);
   virtual void printParticle() const {
+    G4cout << " A " << getA() << " Z " << getZ() << " mass "
+           << getMass() << " Eex (MeV) " << exitationEnergy << G4endl;
     G4InuclParticle::printParticle();
+  }
+  virtual void printParticle() const;
+  // Convert contents to G4Fragment for use outside package
+  G4Fragment makeG4Fragment() const;
+  operator G4Fragment() const;
 protected:
   // Convert nuclear configuration to standard GEANT4 pointer
+  static G4ParticleDefinition*
+  makeDefinition(G4double a, G4double z, G4double exc=0.);
+  static G4ParticleDefinition*
+  makeNuclearFragment(G4double a, G4double z, G4double exc=0.);
+  static G4ParticleDefinition* makeDefinition(G4int a, G4int z);
+  static G4ParticleDefinition* makeNuclearFragment(G4int a, G4int z);
 private:
-  G4double exitationEnergy;
   G4ExitonConfiguration theExitonConfiguration;
 };

trunk/source/processes/hadronic/models/cascade/cascade/include/G4InuclParticle.hh

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4InuclParticle.hh,v 1.20 2010/06/25 09:43:28 gunter Exp $
 // Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4InuclParticle.hh,v 1.22 2010/09/16 05:21:00 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100112  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
 // 20100409  M. Kelsey -- Drop unused string argument from ctors.
 // 20100519  M. Kelsey -- Add public access to G4DynamicParticle content
+// 20100715  M. Kelsey -- Add setKineticEnergy() function
+// 20100915  M. Kelsey -- Add constructor to copy G4DynamicParticle input
 #ifndef G4INUCL_PARTICLE_HH
 …
 public:
   G4InuclParticle() : modelId(0) {}
+  explicit G4InuclParticle(const G4DynamicParticle& dynPart)
+    : pDP(dynPart), modelId(0) {}
   explicit G4InuclParticle(const G4LorentzVector& mom) : modelId(0) {
 …
   // These are call-throughs to G4DynamicParticle
   void setMomentum(const G4LorentzVector& mom);
+  void setKineticEnergy(G4double ekin) { pDP.SetKineticEnergy(ekin*GeV/MeV); }
   void setMass(G4double mass) { pDP.SetMass(mass*GeV/MeV); }

trunk/source/processes/hadronic/models/cascade/cascade/include/G4InuclParticleNames.hh

r1337	r1340
25	25	//
26	26	// $Id: G4InuclParticleNames.hh,v 1.3 2010/06/25 09:43:30 gunter Exp $
27		// Geant4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// Geant4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// Defines enums to map G4InuclElementaryParticle type codes to human

trunk/source/processes/hadronic/models/cascade/cascade/include/G4InuclSpecialFunctions.hh

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4InuclSpecialFunctions.hh,v 1.17 2010/06/25 09:43:32 gunter Exp $
 // Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4InuclSpecialFunctions.hh,v 1.18 2010/09/14 17:51:36 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
 …
 //              cbrt() cube-root function (in math.h, but not in <math>!)
 // 20100412  M. Kelsey -- Modify paraMaker[Truncated] to take buffer as argument
+// 20100914  M. Kelsey -- Migrate to integer A and Z.  Discard unused binding
+//              energy functions
 #ifndef G4INUCL_SPECIAL_FUNC_HH
 …
 namespace G4InuclSpecialFunctions {
+  G4double bindingEnergy(G4int A, G4int Z);
   G4double bindingEnergyExact(G4double A,
                               G4double Z);
+  // NOTE:  Used only by G4Fissioner
+  G4double bindingEnergyAsymptotic(G4int A, G4int Z);
+  G4double bindingEnergyKummel(G4double A,
+                               G4double Z);
+  G4double bindingEnergy(G4double A,
+                         G4double Z);
+  G4double bindingEnergyAsymptotic(G4double A,
+                                   G4double Z);
+  G4double FermiEnergy(G4double A,
+                       G4double Z,
+                       G4int ntype);
+  G4double FermiEnergy(G4int A, G4int Z, G4int ntype);
+  // NOTE:  Passing Z as double here, to be used as interpolation argument
   void paraMaker(G4double Z, std::pair<std::vector<G4double>, std::vector<G4double> >& parms);
   void paraMakerTruncated(G4double Z, std::pair<G4double, G4double>& parms);
   G4double getAL(G4double A);
+  G4double getAL(G4int A);
   G4double csNN(G4double e);
 …
   std::pair<G4double, G4double> randomCOS_SIN();
   G4double nucleiLevelDensity(G4double a);
+  G4double nucleiLevelDensity(G4int A);
   // Optional mass argument will be used to fill G4LorentzVector correctly

trunk/source/processes/hadronic/models/cascade/cascade/include/G4KaonHypSampler.hh

r1337	r1340
25	25	//
26	26	// $Id: G4KaonHypSampler.hh,v 1.2 2010/06/25 09:43:34 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100512 M. Kelsey -- Replaces (old, untemplated) G4CascadeSampler

trunk/source/processes/hadronic/models/cascade/cascade/include/G4LorentzConvertor.hh

-              r1337
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+//
+// $Id: G4LorentzConvertor.hh,v 1.15.2.1 2010/06/25 09:43:36 gunter Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4LorentzConvertor.hh,v 1.17 2010/09/15 20:16:16 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100108  Michael Kelsey -- Use G4LorentzVector internally
 …
 // 20100126  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
 // 20100519  M. Kelsey -- Add interfaces to pass G4InuclParticles directly
+// 20100616  M. Kelsey -- Report bullet and target four-momenta when set
+// 20100915  M. Kelsey -- Move constructors to .cc file, add initializers
 #ifndef G4LORENTZ_CONVERTOR_HH
 …
 class G4LorentzConvertor {
 public:
   G4LorentzConvertor();
   G4LorentzConvertor(const G4LorentzVector& bmom, G4double bmass,
+                     const G4LorentzVector& tmom, G4double tmass) {
+    setBullet(bmom, bmass);
+    setTarget(tmom, tmass);
+  }
+                     const G4LorentzVector& tmom, G4double tmass);
   G4LorentzConvertor(const G4InuclParticle* bullet,
+                     const G4InuclParticle* target) {
+    setBullet(bullet);
+    setTarget(target);
+  }
+                     const G4InuclParticle* target);
   void setVerbose(G4int vb=0) { verboseLevel = vb; }
 …
   // Use correct four-vectors as input
+  void setBullet(const G4LorentzVector& bmom) { bullet_mom = bmom; }
+  void setTarget(const G4LorentzVector& bmom) { target_mom = bmom; }
+  void setBullet(const G4LorentzVector& bmom) {
+    bullet_mom = bmom;
+    if (verboseLevel > 3) printBullet();
+  }
+  // NOTE:  These functions "repair" input 4-vectors using specified mass
+  void setTarget(const G4LorentzVector& bmom) {
+    target_mom = bmom;
+    if (verboseLevel > 3) printTarget();
+  }
+  // These functions "repair" input 4-vectors using specified mass
   void setBullet(const G4LorentzVector& bmom, G4double bmass) {
     bullet_mom.setVectM(bmom.vect(), bmass);
+    //  G4cout << " bullet: e " << bullet_mom.e() << " mass "
+    //         << bullet_mom.m() << G4endl;
+  };
+    if (verboseLevel > 3) printBullet();
+  }
   void setTarget(const G4LorentzVector& tmom, G4double tmass) {
     target_mom.setVectM(tmom.vect(), tmass);
+    //  G4cout << " target: e " << target_mom.e() << " mass "
+    //         << target_mom.m() << G4endl;
+  };
+    if (verboseLevel > 3) printTarget();
+  }
   void toTheCenterOfMass();
 …
   G4bool trivial() const { return degenerated; }
+  // Reporting functions for diagnostics
+  void printBullet() const;
+  void printTarget() const;
 private:
   static const G4double small;

trunk/source/processes/hadronic/models/cascade/cascade/include/G4NonEquilibriumEvaporator.hh

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4NonEquilibriumEvaporator.hh,v 1.11 2010/06/25 09:43:38 gunter Exp $
 // GEANT4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4NonEquilibriumEvaporator.hh,v 1.13 2010/09/14 17:51:36 mkelsey Exp $
+// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100315  M. Kelsey -- Remove "using" directive and unnecessary #includes.
 // 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
 // 20100517  M. Kelsey -- Inherit from common base class
+// 20100714  M. Kelsey -- Switch to new G4CascadeColliderBase class
+// 20100914  M. Kelsey -- Migrate to integer A and Z
 #ifndef G4NON_EQUILIBRIUM_EVAPORATOR_HH
 #define G4NON_EQUILIBRIUM_EVAPORATOR_HH
 #include "G4VCascadeCollider.hh"
+#include "G4CascadeColliderBase.hh"
 class G4CollisionOutput;
 class G4InuclParticle;
 class G4NonEquilibriumEvaporator : public G4VCascadeCollider {
+class G4NonEquilibriumEvaporator : public G4CascadeColliderBase {
 public:
   G4NonEquilibriumEvaporator();
 …
 private:
   G4double getMatrixElement(G4double A) const;
   G4double getE0(G4double A) const;
   G4double getParLev(G4double A, G4double Z) const;
+  G4double getMatrixElement(G4int A) const;
+  G4double getE0(G4int A) const;
+  G4double getParLev(G4int A, G4int Z) const;
 };

trunk/source/processes/hadronic/models/cascade/cascade/include/G4NuclWatcher.hh

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4NuclWatcher.hh,v 1.14 2010/06/25 09:43:40 gunter Exp $
 // Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4NuclWatcher.hh,v 1.15 2010/10/14 20:55:10 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100202  M. Kelsey -- Move most code into .cc file
 // 20100405  M. Kelsey -- Pass const-ref std::vector<>
+// 20101010  M. Kelsey -- Migrate to integer A and Z
 #ifndef G4NUCL_WATCHER_HH
 …
 class G4NuclWatcher {
 public:
   G4NuclWatcher(G4double z,
+  G4NuclWatcher(G4int z,
                 const std::vector<G4double>& expa,
                 const std::vector<G4double>& expcs,
 …
   ~G4NuclWatcher() {}
   void watch(G4double a, G4double z);
+  void watch(G4int a, G4int z);
   void setInuclCs(G4double csec, G4int nev);
 …
 private:
   G4double nuclz;
+  G4int nuclz;
   G4double izotop_chsq;
   G4double average_ratio;

trunk/source/processes/hadronic/models/cascade/cascade/include/G4NucleiModel.hh

-              r1337
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+//
+// $Id: G4NucleiModel.hh,v 1.25.2.1 2010/06/25 09:43:42 gunter Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4NucleiModel.hh,v 1.30 2010/09/14 17:51:36 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-03-ref-09 $
 //
 // 20100319  M. Kelsey -- Remove "using" directory and unnecessary #includes,
 …
 //              absorptionCrossSection() from SpecialFunc.
 // 20100520  M. Kelsey -- Add function to separate momentum from nucleon
+// 20100617  M. Kelsey -- Add setVerboseLevel() function, add generateModel()
+//              with particle input, and ctor with A/Z input.
+// 20100715  M. Kelsey -- Add G4InuclNuclei object for use with balance checks
+// 20100723  M. Kelsey -- Move G4CollisionOutput buffer, along with all
+//              std::vector<> buffers, here for reuse
+// 20100914  M. Kelsey -- Migrate to integer A and Z
 #ifndef G4NUCLEI_MODEL_HH
 …
 #include "G4InuclElementaryParticle.hh"
 #include "G4CascadParticle.hh"
+#include "G4CollisionOutput.hh"
 #include <algorithm>
 #include <vector>
 …
 class G4NucleiModel {
 public:
   G4NucleiModel();
+  G4NucleiModel(G4InuclNuclei* nuclei);
+  void generateModel(G4double a, G4double z);
+  G4NucleiModel(G4int a, G4int z);
+  explicit G4NucleiModel(G4InuclNuclei* nuclei);
+  ~G4NucleiModel() {}
+  void setVerboseLevel(G4int verbose) { verboseLevel = verbose; }
+  void generateModel(G4InuclNuclei* nuclei);
+  void generateModel(G4int a, G4int z);
   void reset() {
 …
+  }
   void printModel() const;
   G4double getDensity(G4int ip, G4int izone) const {
 …
   G4double getNumberOfNeutrons() const {
+  G4int getNumberOfNeutrons() const {
     return neutronNumberCurrent;
+  }
   G4double getNumberOfProtons() const {
+  G4int getNumberOfProtons() const {
     return protonNumberCurrent;
+  }
 …
   G4double getRatio(G4int ip) const;
+  // Buffers for processing interactions on each cycle
   std::vector<G4CascadParticle> outgoing_cparticles;    // Return buffer
+  G4CollisionOutput EPCoutput;          // For N-body inelastic collisions
+  std::vector<G4InuclElementaryParticle> qdeutrons;     // For h+(NN) trials
+  std::vector<G4double> acsecs;
+  std::vector<G4ThreeVector> coordinates;       // for initializeCascad()
+  std::vector<G4LorentzVector> momentums;
+  std::vector<G4InuclElementaryParticle> raw_particles;
   std::vector<std::vector<G4double> > nucleon_densities;
   std::vector<std::vector<G4double> > zone_potentials;
   std::vector<std::vector<G4double> > fermi_momenta;
   std::vector<G4double> zone_radii;
   std::vector<G4double> binding_energies;
   G4double nuclei_radius;
   G4int number_of_zones;
+  G4double A;
+  G4double Z;
+  G4double neutronNumber;
+  G4double protonNumber;
+  G4double neutronNumberCurrent;
+  G4double protonNumberCurrent;
+  G4int A;
+  G4int Z;
+  G4InuclNuclei* theNucleus;
+  G4int neutronNumber;
+  G4int protonNumber;
+  G4int neutronNumberCurrent;
+  G4int protonNumberCurrent;
   G4int current_nucl1;

trunk/source/processes/hadronic/models/cascade/cascade/include/G4ParticleLargerBeta.hh

r1337	r1340
25	25	//
26	26	// $Id: G4ParticleLargerBeta.hh,v 1.7 2010/06/25 09:43:44 gunter Exp $
27		// Geant4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// Geant4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100112 M. Kelsey -- Add additional operator() which uses pointers,

trunk/source/processes/hadronic/models/cascade/cascade/include/G4ParticleLargerEkin.hh

r1337	r1340
25	25	//
26	26	// $Id: G4ParticleLargerEkin.hh,v 1.12 2010/06/25 09:43:46 gunter Exp $
27		// Geant4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// Geant4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// Implements a reverse sorting: std::sort expects a less-than operator

trunk/source/processes/hadronic/models/cascade/cascade/include/G4PionNucSampler.hh

r1337	r1340
25	25	//
26	26	// $Id: G4PionNucSampler.hh,v 1.2 2010/06/25 09:43:48 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100512 M. Kelsey -- Replaces G4FinalStateSampler

trunk/source/processes/hadronic/models/cascade/cascade/include/G4UnboundPN.hh

r1337	r1340
25	25	//
26	26	// $Id: G4UnboundPN.hh,v 1.4 2010/06/25 09:43:52 gunter Exp $
27		// GEANT4 tag $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// ------------------------------------------------------------

trunk/source/processes/hadronic/models/cascade/cascade/include/G4VCascadeCollider.hh

-              r1337
+              r1340
+#ifndef G4V_CASCADE_COLLIDER_HH
+#define G4V_CASCADE_COLLIDER_HH
 //
 // ********************************************************************
 …
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4VCascadeCollider.hh,v 1.4 2010/07/14 15:41:12 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
+// $Id: G4VCascadeCollider.hh,v 1.1.2.1 2010/06/25 09:43:54 gunter Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-01 $
+#ifndef G4V_CASCADE_COLLIDER_HH
+#define G4V_CASCADE_COLLIDER_HH
+// 20100615  M. Kelsey -- Split constructor to have verbose separately
+// 20100711  M. Kelsey -- Allow name to be changed after ctor, by self
+// 20100714  M. Kelsey -- Move concrete functions to G4CascadeColliderBase
 #include "globals.hh"
-#include "G4InteractionCase.hh"
-class G4InuclNuclei;
 class G4InuclParticle;
 class G4CollisionOutput;
 …
 class G4VCascadeCollider {
 public:
   G4VCascadeCollider(const char* name="G4VCascadeCollider", G4int verbose=0);
+  G4VCascadeCollider(const char* name, G4int verbose=0);
   virtual ~G4VCascadeCollider() {}
 …
   const char* theName;
   G4int verboseLevel;
-  G4InteractionCase interCase;          // Determine bullet vs. target
+  // Decide whether to use G4ElementaryParticleCollider or not
+  virtual G4bool useEPCollider(G4InuclParticle* bullet,
+                               G4InuclParticle* target) const;
+  // Decide whether to use G4BigBanger or not
+  virtual G4bool explosion(G4InuclNuclei* target) const;
+  // Decide whether to use G4IntraNuclearCascader or not
+  virtual G4bool inelasticInteractionPossible(G4InuclParticle* bullet,
+                                              G4InuclParticle* target,
+                                              G4double ekin) const;
+  virtual void setName(const char* name) { theName = name; }
 };

trunk/source/processes/hadronic/models/cascade/cascade/include/G4WatcherGun.hh

r1337	r1340
25	25	//
26	26	// $Id: G4WatcherGun.hh,v 1.10 2010/06/25 09:43:56 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100407 M. Kelsey -- Return const-ref to avoid copy overhead.

trunk/source/processes/hadronic/models/cascade/cascade/src/G4Analyser.cc

-              r1315
+              r1340
 // ********************************************************************
 //
+// $Id: G4Analyser.cc,v 1.24 2010/10/19 19:48:15 mkelsey Exp $
+//
+// 20100726  M. Kelsey -- Use references for fetched lists
+// 20101010  M. Kelsey -- Migrate to integer A and Z
+// 20101019  M. Kelsey -- CoVerity report, unitialized constructor
 #include "G4Analyser.hh"
 #include <cmath>
 …
 G4Analyser::G4Analyser()
+  :verboseLevel(0)  {
+  : verboseLevel(0), eventNumber(0.0), averageMultiplicity(0.0),
+    averageProtonNumber(0.0), averageNeutronNumber(0.0),
+    averagePionNumber(0.0),  averageNucleonKinEnergy(0.0),
+    averageProtonKinEnergy(0.0), averageNeutronKinEnergy(0.0),
+    averagePionKinEnergy(0.0), averageExitationEnergy(0.0),
+    averageOutgoingNuclei(0.0), fissy_prob(0.0), averagePionPl(0.0),
+    averagePionMin(0.0), averagePion0(0.0), averageA(0.0), averageZ(0.0),
+    inel_csec(0.0), withNuclei(false) {
   if (verboseLevel > 3) {
     G4cout << " >>> G4Analyser::G4Analyser" << G4endl;
+  }
+  eventNumber = 0.0;
+  averageMultiplicity = 0.0;
+  averageNucleonKinEnergy = 0.0;
+  averageProtonKinEnergy = 0.0;
+  averageNeutronKinEnergy = 0.0;
+  averagePionKinEnergy = 0.0;
+  averageProtonNumber = 0.0;
+  averageNeutronNumber = 0.0;
+  averagePionNumber = 0.0;
+  averageExitationEnergy = 0.0;
+  averageNucleiFragments = 0.0;
+  averagePionPl = 0.0;
+  averagePionMin = 0.0;
+  averagePion0 = 0.0;
+  averageA = 0.0;
+  averageZ = 0.0;
+  withNuclei = false;
+  fissy_prob = 0.0;
+}
+void G4Analyser::setInelCsec(G4double csec,
+                             G4bool withn) {
+}
+void G4Analyser::setInelCsec(G4double csec, G4bool withn) {
   if (verboseLevel > 3) {
 …
+}
+void G4Analyser::try_watchers(G4double a,
+                              G4double z,
+                              G4bool if_nucl) {
+void G4Analyser::try_watchers(G4int a, G4int z, G4bool if_nucl) {
   if (verboseLevel > 3) {
 …
   if (withNuclei) {
     std::vector<G4InuclNuclei> nucleus = output.getNucleiFragments();
+    const std::vector<G4InuclNuclei>& nucleus = output.getOutgoingNuclei();
     //    if (nucleus.size() >= 0) {
     if (nucleus.size() > 0) {
       G4int nbig = 0;
       averageNucleiFragments += nucleus.size();
+      averageOutgoingNuclei += nucleus.size();
       for (G4int in = 0; in < G4int(nucleus.size()); in++) {
         averageExitationEnergy += nucleus[in].getExitationEnergy();
         G4double a = nucleus[in].getA();
         G4double z = nucleus[in].getZ();
+        G4int a = nucleus[in].getA();
+        G4int z = nucleus[in].getZ();
         if (in == 0) {
 …
         };
         if (a > 10.0) nbig++;
+        if (a > 10) nbig++;
         try_watchers(a, z, true);
       };
 …
       if (nbig > 1) fissy_prob += 1.0;
       eventNumber += 1.0;
+      std::vector<G4InuclElementaryParticle> particles = output.getOutgoingParticles();
+      const std::vector<G4InuclElementaryParticle>& particles =
+        output.getOutgoingParticles();
       averageMultiplicity += particles.size();
       for (G4int i = 0; i < G4int(particles.size()); i++) {
         G4double ap = 0.0;
         G4double zp = 0.0;
+        G4int ap = 0;
+        G4int zp = 0;
         if (particles[i].nucleon()) {
 …
           if (particles[i].type() == 1) {
             zp = 1.0;
             ap = 1.0;
+            zp = 1;
+            ap = 1;
             averageProtonNumber += 1.0;
             averageProtonKinEnergy += particles[i].getKineticEnergy();
           } else {
             ap = 1.0;
             zp = 0.0;
+            ap = 1;
+            zp = 0;
             averageNeutronNumber += 1.0;
             averageNeutronKinEnergy += particles[i].getKineticEnergy();
 …
           averagePionKinEnergy += particles[i].getKineticEnergy();
           averagePionNumber += 1.0;
           ap = 0.0;
+          ap = 0;
           if (particles[i].type() == 3) {
             zp = 1.0;
+            zp = 1;
             averagePionPl += 1.0;
           } else if (particles[i].type() == 5) {
             zp = -1.0;
+            zp = -1;
             averagePionMin += 1.0;
           } else if (particles[i].type() == 7) {
             zp = 0.0;
+            zp = 0;
             averagePion0 += 1.0;
           };
 …
   } else {
     eventNumber += 1.0;
+    std::vector<G4InuclElementaryParticle> particles = output.getOutgoingParticles();
+    const std::vector<G4InuclElementaryParticle>& particles =
+      output.getOutgoingParticles();
     averageMultiplicity += particles.size();
 …
     G4cout
       << " average Exitation Energy " <<
       averageExitationEnergy / averageNucleiFragments << G4endl
       << " average num of fragments " << averageNucleiFragments / eventNumber << G4endl;
+      averageExitationEnergy / averageOutgoingNuclei << G4endl
+      << " average num of fragments " << averageOutgoingNuclei / eventNumber << G4endl;
     G4cout << " fission prob. " << fissy_prob / eventNumber << " c.sec " <<
       inel_csec * fissy_prob / eventNumber << G4endl;
 …
       << " average Z " << averageZ / eventNumber << G4endl
       << " average Exitation Energy " <<
       averageExitationEnergy / averageNucleiFragments << G4endl
       << " average num of fragments " << averageNucleiFragments / eventNumber << G4endl;
+      averageExitationEnergy / averageOutgoingNuclei << G4endl
+      << " average num of fragments " << averageOutgoingNuclei / eventNumber << G4endl;
     G4cout << " fission prob. " << fissy_prob / eventNumber << " c.sec " <<
       inel_csec * fissy_prob / eventNumber << G4endl;

trunk/source/processes/hadronic/models/cascade/cascade/src/G4BigBanger.cc

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4BigBanger.cc,v 1.30 2010/06/25 09:43:58 gunter Exp $
 // Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4BigBanger.cc,v 1.40 2010/09/28 20:15:00 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
 …
 // 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
 // 20100517  M. Kelsey -- Inherit from common base class, clean up code
+// 20100628  M. Kelsey -- Use old "bindingEnergy" fn as wrapper, add balance
+//              checking after bang.
+// 20100630  M. Kelsey -- Just do simple boost for target, instead of using
+//              G4LorentzConverter with dummy bullet.
+// 20100701  M. Kelsey -- Re-throw momentum list, not just angles!
+// 20100714  M. Kelsey -- Move conservation checking to base class
+// 20100726  M. Kelsey -- Move std::vector<> buffer to .hh file
+// 20100923  M. Kelsey -- Migrate to integer A and Z
 #include "G4BigBanger.hh"
 …
 #include "G4InuclSpecialFunctions.hh"
 #include "G4ParticleLargerEkin.hh"
-#include "G4LorentzConvertor.hh"
-#include "G4HadTmpUtil.hh"
-#include "G4NucleiProperties.hh"
 #include <algorithm>
 …
 typedef std::vector<G4InuclElementaryParticle>::iterator particleIterator;
 G4BigBanger::G4BigBanger() : G4VCascadeCollider("G4BigBanger") {}
+G4BigBanger::G4BigBanger() : G4CascadeColliderBase("G4BigBanger") {}
 void
 …
                      G4CollisionOutput& output) {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4BigBanger::collide" << G4endl;
+  }
+  if (verboseLevel) G4cout << " >>> G4BigBanger::collide" << G4endl;
   // primitive explosion model A -> nucleons to prevent too exotic evaporation
-  const G4double small_ekin = 1.0e-6;
-  G4LorentzVector totscm;
-  G4LorentzVector totlab;
   G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target);
 …
+  }
+  G4double A = nuclei_target->getA();
+  G4double Z = nuclei_target->getZ();
+  G4int A = nuclei_target->getA();
+  G4int Z = nuclei_target->getZ();
   G4LorentzVector PEX = nuclei_target->getMomentum();
   G4double EEXS = nuclei_target->getExitationEnergy();
+  G4InuclElementaryParticle dummy(small_ekin, 1);
+  G4LorentzConvertor toTheNucleiSystemRestFrame;
+  toTheNucleiSystemRestFrame.setBullet(dummy);
+  toTheNucleiSystemRestFrame.setTarget(nuclei_target);
+  toTheNucleiSystemRestFrame.toTheTargetRestFrame();
+  G4double etot = (EEXS - G4NucleiProperties::GetBindingEnergy(G4lrint(A), G4lrint(Z) ) ) * MeV/GeV;  // To Bertini units
+  G4ThreeVector toTheLabFrame = PEX.boostVector();      // From rest to lab
+  // This "should" be difference between E-target and sum of m(nucleons)
+  G4double etot = (EEXS - bindingEnergy(A,Z)) * MeV/GeV;  // To Bertini units
   if (etot < 0.0) etot = 0.0;
 …
     G4cout << " BigBanger: target " << G4endl;
     nuclei_target->printParticle();
+    G4cout << " BigBanger: a " << A << " z " << Z << " eexs " << EEXS << " etot " <<
+      etot << " nm " << nuclei_target->getMass() << G4endl;
+  }
+    G4cout << " etot " << etot << G4endl;
+  }
+  if (verboseLevel > 3) {
+    G4LorentzVector PEXrest = PEX;
+    PEXrest.boost(-toTheLabFrame);
+    G4cout << " target rest frame: px " << PEXrest.px() << " py "
+           << PEXrest.py() << " pz " << PEXrest.pz() << " E " << PEXrest.e()
+           << G4endl;
+  }
   generateBangInSCM(etot, A, Z);
 …
+  }
+  if(!particles.empty()) { // convert back to Lab
+    particleIterator ipart;
+    for(ipart = particles.begin(); ipart != particles.end(); ipart++) {
+      if (verboseLevel > 2) {
+        totscm += ipart->getMomentum();
+      }
+      G4LorentzVector mom =
+        toTheNucleiSystemRestFrame.backToTheLab(ipart->getMomentum());
+      ipart->setMomentum(mom);
+      if (verboseLevel > 2) {
+        mom = ipart->getMomentum();
+        totlab += mom;
+      }
+    }
+    std::sort(particles.begin(), particles.end(), G4ParticleLargerEkin());
+    if (verboseLevel > 2) {
+      G4cout << " In SCM: total outgoing momentum " << G4endl
+             << " E " << totscm.e() << " px " << totscm.x()
+             << " py " << totscm.y() << " pz " << totscm.z() << G4endl;
+      G4cout << " In Lab: mom cons " << G4endl
+             << " E " << PEX.e() + 0.001 * EEXS - totlab.e()
+             << " px " << PEX.x() - totlab.x()
+             << " py " << PEX.y() - totlab.y()
+             << " pz " << PEX.z() - totlab.z() << G4endl;
+    }
+  if (particles.empty()) {      // No bang!  Don't know why...
+    G4cerr << " >>> G4BigBanger unable to process fragment "
+           << nuclei_target->getDefinition()->GetParticleName() << G4endl;
+    // FIXME:  This will violate baryon number, momentum, energy, etc.
+    return;
+  }
+  // convert back to Lab
+  G4LorentzVector totscm;
+  G4LorentzVector totlab;
+  if (verboseLevel > 2) G4cout << " BigBanger: boosting to lab" << G4endl;
+  particleIterator ipart;
+  for(ipart = particles.begin(); ipart != particles.end(); ipart++) {
+    G4LorentzVector mom = ipart->getMomentum();
+    if (verboseLevel > 2) totscm += mom;
+    mom.boost(toTheLabFrame);
+    if (verboseLevel > 2) totlab += mom;
+    ipart->setMomentum(mom);
+    if (verboseLevel > 2) ipart->printParticle();
+  }
+  std::sort(particles.begin(), particles.end(), G4ParticleLargerEkin());
+  validateOutput(0, target, particles);         // Checks <vector> directly
+  if (verboseLevel > 2) {
+    G4cout << " In SCM: total outgoing momentum " << G4endl
+           << " E " << totscm.e() << " px " << totscm.x()
+           << " py " << totscm.y() << " pz " << totscm.z() << G4endl;
+    G4cout << " In Lab: mom cons " << G4endl
+           << " E " << PEX.e() - totlab.e()     // PEX now includes EEXS
+           << " px " << PEX.x() - totlab.x()
+           << " py " << PEX.y() - totlab.y()
+           << " pz " << PEX.z() - totlab.z() << G4endl;
+  }
   output.addOutgoingParticles(particles);
-  return;
+}
 void G4BigBanger::generateBangInSCM(G4double etot, G4double a, G4double z) {
+void G4BigBanger::generateBangInSCM(G4double etot, G4int a, G4int z) {
   if (verboseLevel > 3) {
     G4cout << " >>> G4BigBanger::generateBangInSCM" << G4endl;
+  }
-  // Proton and neutron masses
-  const G4double mp = G4InuclElementaryParticle::getParticleMass(1);
-  const G4double mn = G4InuclElementaryParticle::getParticleMass(2);
   const G4double ang_cut = 0.9999;
   const G4int itry_max = 1000;
+  G4int ia = int(a + 0.1);
+  G4int iz = int(z + 0.1);
+  if (verboseLevel > 2) {
+    G4cout << " ia " << ia << " iz " << iz << G4endl;
+  if (verboseLevel > 2) {
+    G4cout << " a " << a << " z " << z << G4endl;
+  }
   particles.clear();    // Reset output vector before filling
+  if(ia == 1) {
+    // abnormal situation
+    G4double m = iz > 0 ? mp : mn;
+    G4double pmod = std::sqrt((etot + 2.0 * m) * etot);
+    G4LorentzVector mom = generateWithRandomAngles(pmod, m);
+    G4int knd = iz > 0 ? 1 : 2;
+    particles.push_back(G4InuclElementaryParticle(mom, knd, 8)); // modelId included
+  if (a == 1) {         // Special -- bare nucleon doesn't really "explode"
+    G4int knd = (z>0) ? 1 : 2;
+    particles.push_back(G4InuclElementaryParticle(knd)); // zero momentum
     return;
   };
+  }
+  generateMomentumModules(etot, a, z);
+  // NOTE:  If distribution fails, need to regenerate magnitudes and angles!
+  //*** generateMomentumModules(etot, a, z);
+  scm_momentums.reserve(a);
+  G4LorentzVector tot_mom;
   G4bool bad = true;
   G4int itry = 0;
   while(bad && itry < itry_max) {
     itry++;
     std::vector<G4LorentzVector> scm_momentums;
+    G4LorentzVector tot_mom;
     if(ia == 2) {
       // FIXME:  This isn't actually a correct four-vector, wrong mass!
+    scm_momentums.clear();
+    generateMomentumModules(etot, a, z);
+    if (a == 2) {
+      // This is only a three-vector, not a four-vector
       G4LorentzVector mom = generateWithRandomAngles(momModules[0]);
-      tot_mom += mom;
       scm_momentums.push_back(mom);
+      G4LorentzVector mom1 = -mom;
+      scm_momentums.push_back(mom1);
+      scm_momentums.push_back(-mom);    // Only safe since three-vector!
       bad = false;
     } else {
+      for(G4int i = 0; i < ia - 2; i++) {
+        // FIXME:  This isn't actually a correct four-vector, wrong mass!
+      tot_mom *= 0.;            // Easy way to reset accumulator
+      for(G4int i = 0; i < a-2; i++) {          // All but last two are thrown
+      // This is only a three-vector, not a four-vector
         G4LorentzVector mom = generateWithRandomAngles(momModules[i]);
+        scm_momentums.push_back(mom);
         tot_mom += mom;
-        scm_momentums.push_back(mom);
       };
       //                handle last two
       G4double tot_mod = tot_mom.rho();
+      G4double ct = -0.5 * (tot_mod * tot_mod + momModules[ia - 2] * momModules[ia - 2] -
+                            momModules[ia - 1] * momModules[ia - 1]) / tot_mod / momModules[ia - 2];
+      if (verboseLevel > 2) {
+        G4cout << " ct last " << ct << G4endl;
+      }
+      G4double ct = -0.5*(tot_mod*tot_mod + momModules[a-2]*momModules[a-2]
+                          - momModules[a-1]*momModules[a-1]) / tot_mod
+        / momModules[a-2];
+      if (verboseLevel > 2) G4cout << " ct last " << ct << G4endl;
       if(std::fabs(ct) < ang_cut) {
+        // FIXME:  These are not actually four-vectors, just three-momenta
+        G4LorentzVector mom2 = generateWithFixedTheta(ct, momModules[ia - 2]);
+        //       rotate to the normal system
+        // This is only a three-vector, not a four-vector
+        G4LorentzVector mom2 = generateWithFixedTheta(ct, momModules[a - 2]);
+        // rotate to the normal system
         G4LorentzVector apr = tot_mom/tot_mod;
         G4double a_tr = std::sqrt(apr.x()*apr.x() + apr.y()*apr.y());
 …
         scm_momentums.push_back(mom);
+        //               and the last one
+        G4LorentzVector mom1= - mom - tot_mom;
+        // and the last one (again, not actually a four-vector!)
+        G4LorentzVector mom1 = -mom - tot_mom;
         scm_momentums.push_back(mom1);
         bad = false;
       };
     };
     if(!bad) {
+      for(G4int i = 0; i < ia; i++) {
+        G4int knd = i < iz ? 1 : 2;
         particles.push_back(G4InuclElementaryParticle(scm_momentums[i], knd, 8));
       };
+      } // if (abs(ct) < ang_cut)
+    }   // (a > 2)
+  }     // while (bad && itry<itry_max)
+  if (!bad) {
+    for(G4int i = 0; i < a; i++) {
+      G4int knd = i < z ? 1 : 2;
+      particles.push_back(G4InuclElementaryParticle(scm_momentums[i], knd, 8));
     };
+  };
+  if (verboseLevel > 2) {
+    if(itry == itry_max) G4cout << " BigBanger -> can not generate bang " << G4endl;
+  };
+  if (verboseLevel > 2) {
+    if (itry == itry_max) G4cout << " BigBanger -> can not generate bang " << G4endl;
+  }
 …
+}
 void G4BigBanger::generateMomentumModules(G4double etot, G4double a, G4double z) {
+void G4BigBanger::generateMomentumModules(G4double etot, G4int a, G4int z) {
   if (verboseLevel > 3) {
     G4cout << " >>> G4BigBanger::generateMomentumModules" << G4endl;
 …
   momModules.clear();           // Reset buffer for filling
-  G4int ia = G4int(a + 0.1);
-  G4int iz = G4int(z + 0.1);
   G4double xtot = 0.0;
+  G4double promax = maxProbability(a);
+  G4int i;
+  for(i = 0; i < ia; i++) {
+    G4double x = generateX(ia, a, promax);
+    if (verboseLevel > 2) {
+      G4cout << " i " << i << " x " << x << G4endl;
+  if (a > 2) {                  // For "large" nuclei, energy is distributed
+    G4double promax = maxProbability(a);
+    for(G4int i = 0; i < a; i++) {
+      G4double x = generateX(a, promax);
+      if (verboseLevel > 2) {
+        G4cout << " i " << i << " x " << x << G4endl;
+      }
+      momModules.push_back(x);
+      xtot += x;
+    }
+    momModules.push_back(x);
+    xtot += x;
+  };
+  for(i = 0; i < ia; i++) {
+    G4double m = i < iz ? mp : mn;
+  } else {                      // Two-body case is special, must be 50%
+    xtot = 1.;
+    momModules.push_back(0.5);
+    momModules.push_back(0.5);
+  }
+  for(G4int i = 0; i < a; i++) {
+    G4double m = i < z ? mp : mn;
     momModules[i] = momModules[i] * etot / xtot;
 …
+}
+G4double G4BigBanger::xProbability(G4double x, G4int ia) const {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4BigBanger::xProbability" << G4endl;
+  }
+  G4int ihalf = ia / 2;
+G4double G4BigBanger::xProbability(G4double x, G4int a) const {
+  if (verboseLevel > 3) G4cout << " >>> G4BigBanger::xProbability" << G4endl;
   G4double ekpr = 0.0;
 …
     ekpr = x * x;
     if(2 * ihalf == ia) { // even A
       ekpr *= std::sqrt(1.0 - x) * std::pow((1.0 - x), G4int(G4double(3 * ia - 6) / 2.0));
+    if (a%2 == 0) { // even A
+      ekpr *= std::sqrt(1.0 - x) * std::pow((1.0 - x), (3*a-6)/2);
+    }
     else {
       ekpr *= std::pow((1.0 - x), G4int(G4double(3 * ia - 5) / 2.0));
+      ekpr *= std::pow((1.0 - x), (3*a-5)/2);
     };
   };
 …
+}
+G4double G4BigBanger::maxProbability(G4double a) const {
+G4double G4BigBanger::maxProbability(G4int a) const {
   if (verboseLevel > 3) {
     G4cout << " >>> G4BigBanger::maxProbability" << G4endl;
+  }
+  return xProbability(1.0 / (a - 1.0) / 1.5, G4int(a + 0.1));
+}
+G4double G4BigBanger::generateX(G4int ia,
+                                G4double a,
+                                G4double promax) const {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4BigBanger::generateX" << G4endl;
+  }
+  return xProbability(2./3./(a-1.0), a);
+}
+G4double G4BigBanger::generateX(G4int a, G4double promax) const {
+  if (verboseLevel > 3) G4cout << " >>> G4BigBanger::generateX" << G4endl;
   const G4int itry_max = 1000;
 …
     x = inuclRndm();
     if(xProbability(x, ia) >= promax * inuclRndm()) return x;
+    if(xProbability(x, a) >= promax * inuclRndm()) return x;
   };
   if (verboseLevel > 2) {

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadParticle.cc

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4CascadParticle.cc,v 1.15 2010/06/25 09:44:00 gunter Exp $
 // Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4CascadParticle.cc,v 1.18 2010/10/20 14:34:26 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100112  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
 // 20100114  M. Kelsey -- Replace vector<G4Double> position with G4ThreeVector
+// 20101012  M. Kelsey -- Check for negative d2 in getPathToTheNextZone()
 #include "G4CascadParticle.hh"
 …
                                                 G4double rz_out) {
   if (verboseLevel > 3) {
+    G4cout << " >>> G4CascadParticle::getPathToTheNextZone" << G4endl;
+    G4cout << " >>> G4CascadParticle::getPathToTheNextZone rz_in " << rz_in
+           << " rz_out " << rz_out << G4endl;
+  }
 …
   G4double ds;
   G4double d2;
+  if (verboseLevel > 3) {
+    G4cout << " current_zone " << current_zone << " rr " << rr
+           << " rp " << rp << " pp " << pp << " ra " << ra << G4endl;
+  }
   if (current_zone == 0 || rp > 0.0) {
     d2 = rz_out * rz_out - ra;
+    ds = 1.0;
+    movingIn = false;
+    if (d2 > 0.0) {
+      ds = 1.0;
+      movingIn = false;
+    } else {
+      d2 = rz_in * rz_in - ra;
+      ds = -1.0;
+      movingIn = true;
+    }
   } else {
     d2 = rz_in * rz_in - ra;
 …
+    }
+  }
+  if (verboseLevel > 3) G4cout << " ds " << ds << " d2 " << d2 << G4endl;
   path = ds * std::sqrt(d2) - rp / pp;

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeChannel.cc

r1337	r1340
25	25	//
26	26	// $Id: G4CascadeChannel.cc,v 1.8 2010/06/25 09:44:02 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100514 M. Kelsey -- All functionality removed except quantum-number

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeInterface.cc

-              r1337
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+//
+// $Id: G4CascadeInterface.cc,v 1.77.2.1 2010/06/25 09:44:04 gunter Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4CascadeInterface.cc,v 1.104 2010/09/24 21:09:01 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
 …
 //              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
 #include "G4CascadeInterface.hh"
 #include "globals.hh"
+#include "G4CascadeCheckBalance.hh"
 #include "G4CollisionOutput.hh"
 #include "G4DynamicParticle.hh"
+#include "G4HadronicException.hh"
 #include "G4InuclCollider.hh"
 #include "G4InuclElementaryParticle.hh"
 …
 #include "G4InuclParticle.hh"
 #include "G4InuclParticleNames.hh"
+#include "G4KaonZeroLong.hh"
 #include "G4KaonZeroShort.hh"
-#include "G4KaonZeroLong.hh"
-#include "G4LorentzRotation.hh"
 #include "G4Nucleus.hh"
 #include "G4ParticleDefinition.hh"
 #include "G4Track.hh"
 #include "G4V3DNucleus.hh"
+#include <cmath>
 using namespace G4InuclParticleNames;
-//#define BERTDEV 1  // A flag to activate a development version of Bertini cascade
 typedef std::vector<G4InuclElementaryParticle>::const_iterator particleIterator;
 typedef std::vector<G4InuclNuclei>::const_iterator nucleiIterator;
+G4CascadeInterface::G4CascadeInterface(const G4String& nam)
+  :G4VIntraNuclearTransportModel(nam), verboseLevel(0)
+{
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4CascadeInterface::G4CascadeInterface" << G4endl;
+  }
+}
+G4CascadeInterface::~G4CascadeInterface()
+{}
+G4ReactionProductVector* G4CascadeInterface::Propagate(G4KineticTrackVector* ,
+                                                       G4V3DNucleus* ) {
+// Maximum number of iterations allowed for inelastic collision attempts
+const G4int G4CascadeInterface::maximumTries = 100;
+// Constructor and destrutor
+G4CascadeInterface::G4CascadeInterface(const G4String& name)
+  : G4VIntraNuclearTransportModel(name),
+    verboseLevel(0), numberOfTries(0),
+    collider(new G4InuclCollider),
+    balance(new G4CascadeCheckBalance(0.05, 0.1, name)),
+    bullet(0), target(0), output(new G4CollisionOutput) {
+  initializeElasticCuts();
+}
+G4CascadeInterface::~G4CascadeInterface() {
+  delete collider; collider=0;
+  delete balance; balance=0;
+  delete bullet; bullet=0;
+  delete target; target=0;
+  delete output; output=0;
+}
+// Fill sparse array with minimum momenta for inelastic on hydrogen
+void G4CascadeInterface::initializeElasticCuts() {
+  cutElastic[proton   ]   = 1.0;        // Bertini uses GeV for everything
+  cutElastic[neutron  ]   = 1.0;
+  cutElastic[pionPlus ]   = 0.6;
+  cutElastic[pionMinus]   = 0.2;
+  cutElastic[pionZero ]   = 0.2;
+  cutElastic[kaonPlus ]   = 0.5;
+  cutElastic[kaonMinus]   = 0.5;
+  cutElastic[kaonZero]    = 0.5;
+  cutElastic[kaonZeroBar] = 0.5;
+  cutElastic[lambda]      = 1.0;
+  cutElastic[sigmaPlus]   = 1.0;
+  cutElastic[sigmaZero]   = 1.0;
+  cutElastic[sigmaMinus]  = 1.0;
+  cutElastic[xiZero]      = 1.0;
+  cutElastic[xiMinus]     = 1.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();
+}
+// Main Actions
+G4ReactionProductVector*
+G4CascadeInterface::Propagate(G4KineticTrackVector*, G4V3DNucleus* ) {
   return 0;
+}
+// #define debug_G4CascadeInterface
+G4HadFinalState* G4CascadeInterface::ApplyYourself(const G4HadProjectile& aTrack,
+                                                     G4Nucleus& theNucleus) {
+#ifdef debug_G4CascadeInterface
+G4HadFinalState*
+G4CascadeInterface::ApplyYourself(const G4HadProjectile& aTrack,
+                                  G4Nucleus& theNucleus) {
+  if (verboseLevel)
+    G4cout << " >>> G4CascadeInterface::ApplyYourself" << G4endl;
+#ifdef G4CASCADE_DEBUG_INTERFACE
   static G4int counter(0);
   counter++;
+  G4cerr << "Reaction number "<< counter << " "<<aTrack.GetDynamicParticle()->GetDefinition()->GetParticleName()<<" "<< aTrack.GetDynamicParticle()->GetKineticEnergy()<<G4endl;
+  G4cerr << "Reaction number "<< counter << " "
+         << aTrack.GetDefinition()->GetParticleName() << " "
+         << aTrack.GetKineticEnergy() << G4endl;
 #endif
   theResult.Clear();
-  if (verboseLevel > 3) {
-    G4cout << " >>> G4CascadeInterface::ApplyYourself" << G4endl;
-  };
-  G4double eInit     = 0.0;
-  G4double eTot      = 0.0;
-  G4double sumBaryon = 0.0;
-  G4double sumEnergy = 0.0;
   // Make conversion between native Geant4 and Bertini cascade classes.
   // NOTE: Geant4 units are MeV = 1 and GeV = 1000. Cascade code by default use GeV = 1.
+  G4int bulletType;
+  if (aTrack.GetDefinition() == G4KaonZeroLong::KaonZeroLong() ||
+      aTrack.GetDefinition() == G4KaonZeroShort::KaonZeroShort() )
+    bulletType = (G4UniformRand() > 0.5) ? kaonZero : kaonZeroBar;
+  else
+    bulletType = G4InuclElementaryParticle::type(aTrack.GetDefinition());
+  // Code momentum and energy.
+  G4LorentzVector projectileMomentum = aTrack.Get4Momentum();
+  G4LorentzRotation toZ;
+  toZ.rotateZ(-projectileMomentum.phi());
+  toZ.rotateY(-projectileMomentum.theta());
+  G4LorentzRotation toLabFrame = toZ.inverse();
+  G4LorentzVector momentumBullet(0., 0., aTrack.GetTotalMomentum()/GeV,
+                                 aTrack.GetTotalEnergy()/GeV);
+  G4InuclElementaryParticle* bullet =
+    new G4InuclElementaryParticle(momentumBullet, bulletType);
+  sumEnergy = bullet->getKineticEnergy(); // In GeV
+  sumBaryon += bullet->baryon();        // Returns baryon number (0, 1, or 2)
+  // Set target
+  G4InuclNuclei*   target  = 0;
+  G4InuclParticle* targetH = 0;
+  G4double theNucleusA = theNucleus.GetN();
+  if ( G4int(theNucleusA) != 1 ) {
+    target  = new G4InuclNuclei(theNucleusA, theNucleus.GetZ());
+    eInit = bullet->getEnergy() + target->getEnergy();
+    sumBaryon += theNucleusA;
+    if (verboseLevel > 2) {
+      G4cout << "Bullet:  " << G4endl;
+      bullet->printParticle();
+    }
+    if (verboseLevel > 2) {
+      G4cout << "Target:  " << G4endl;
+      target->printParticle();
+    }
+  }
+  G4CollisionOutput output;
+  createBullet(aTrack);
+  createTarget(theNucleus);
+  if (verboseLevel > 2) {
+    G4cout << "Bullet:  " << G4endl;
+    bullet->printParticle();
+    G4cout << "Target:  " << G4endl;
+    target->printParticle();
+  }
   // Colliders initialisation
+  G4InuclCollider* collider = new G4InuclCollider;
+  G4int  maxTries = 100; // maximum tries for inelastic collision to avoid infinite loop
+  G4int  nTries   = 0;  // try counter
+#ifdef BERTDEV
+  G4int coulombOK =0;  // flag for correct Coulomb barrier
+#endif
+  if (G4int(theNucleusA) == 1) { // special treatment for target H(1,1) (proton)
+  collider->setVerboseLevel(verboseLevel);
+  balance->setVerboseLevel(verboseLevel);
+  output->setVerboseLevel(verboseLevel);
+  numberOfTries = 0;
+  // special treatment for target H(1,1) (proton)
+  if (theNucleus.GetA_asInt() == 1) {
+    G4int btype = dynamic_cast<G4InuclElementaryParticle*>(bullet)->type();
+    if (bullet->getMomModule() <= cutElastic[btype]) {
+      collider->collide(bullet, target, *output);       // Only elastic
+    } else {
+      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(retryInelasticProton());
+    }
+  } else {                      // treat all other targets excepet H(1,1)
+    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 (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 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
+  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;
+    targetH = new G4InuclElementaryParticle(proton);
+    G4float cutElastic[32];
+    cutElastic[proton   ] = 1.0; // GeV
+    cutElastic[neutron  ] = 1.0;
+    cutElastic[pionPlus ] = 0.6;
+    cutElastic[pionMinus] = 0.2;
+    cutElastic[pionZero ] = 0.2;
+    cutElastic[kaonPlus ] = 0.5;
+    cutElastic[kaonMinus] = 0.5;
+    cutElastic[kaonZero] = 0.5;
+    cutElastic[kaonZeroBar] = 0.5;
+    cutElastic[lambda] = 1.0;
+    cutElastic[sigmaPlus] = 1.0;
+    cutElastic[sigmaZero] = 1.0;
+    cutElastic[sigmaMinus] = 1.0;
+    cutElastic[xiZero] = 1.0;
+    cutElastic[xiMinus] = 1.0;
+    if (momentumBullet.z() > cutElastic[bulletType]) { // inelastic collision possible
+      do {   // we try to create inelastic interaction
+        output.reset();
+        collider->collide(bullet, targetH, output);
+        nTries++;
+      } while(
+              (nTries < maxTries) &&
+              (output.getOutgoingParticles().size() == 2 && // elastic: bullet + p = H(1,1) coming out
+               (output.getOutgoingParticles().begin()->type() == bulletType ||
+                output.getOutgoingParticles().begin()->type() == proton)
+               )
+              );
+    } else { // only elastic collision is energetically possible
+      collider->collide(bullet, targetH, output);
+    }
+    sumBaryon += 1;
+    eInit = bullet->getEnergy() + targetH->getEnergy();
+    if (verboseLevel > 2) {
+      G4cout << "Target:  " << G4endl;
+      targetH->printParticle();
+    }
+  } else {  // treat all other targets excepet H(1,1)
+    do { // we try to create inelastic interaction
+#ifdef BERTDEV
+      coulombOK=0;  // by default coulomb analysis is OK
+#endif
+      output.reset();
+      collider->collide(bullet, target, output);
+      nTries++;
+#ifdef BERTDEV
+      G4double coulumbBarrier = 8.7 * MeV;
+      const std::vector<G4InuclElementaryParticle>& p= output.getOutgoingParticles();
+      if(!p.empty()) {
+        for(    particleIterator ipart = p.begin(); ipart != p.end(); ipart++) {
+          if (ipart->type() == proton) {
+            G4double e = ipart->getKineticEnergy()*GeV;
+            if (e < coulumbBarrier) coulombOK= 1; // If event with coulomb barrier violation detected -> retry
+            //            G4cout << "///AH "<< e << "" << coulumbBarrier <<G4endl;
+          }
+        }
+      }
+#endif
+    } while(
+            (nTries < maxTries) &&  // conditions for next try
+            (output.getOutgoingParticles().size()!=0) &&
+#ifdef BERTDEV
+            (coulombOK==1) &&
+            ((output.getOutgoingParticles().size() + output.getNucleiFragments().size()) > 2.5)
+#else
+            ((output.getOutgoingParticles().size() + output.getNucleiFragments().size()) < 2.5) &&
+            (output.getOutgoingParticles().begin()->type()==bullet->type())
+#endif
+             );
+  }
+  if (verboseLevel > 1) {
+    G4cout << " Cascade output: " << G4endl;
+    output.printCollisionOutput();
+  }
+  // Rotate event to put Z axis along original projectile direction
+  output.rotateEvent(toLabFrame);
+  // Convert cascade data to use hadronics interface
+  const std::vector<G4InuclNuclei>& nucleiFragments = output.getNucleiFragments();
+  const std::vector<G4InuclElementaryParticle>& particles = output.getOutgoingParticles();
+    if (balance->deltaKE() > 5.0e-5 ) {         // 0.05 MeV
+      G4cerr << "FATAL ERROR: kinetic energy created  "
+             << balance->deltaKE() * GeV << " MeV" << G4endl;
+    }
+  }
+  delete bullet; bullet=0;
+  delete target; target=0;
+  return &theResult;
+}
+// Convert input projectile to Bertini internal object
+void 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) {
+    if (trkDef == G4KaonZeroLong::KaonZeroLong() ||
+        trkDef == G4KaonZeroShort::KaonZeroShort() )
+      bulletType = (G4UniformRand() > 0.5) ? kaonZero : kaonZeroBar;
+    else
+      bulletType = G4InuclElementaryParticle::type(trkDef);
+  } else {
+    bulletA = trkDef->GetAtomicMass();
+    bulletZ = trkDef->GetAtomicNumber();
+  }
+  // Code momentum and energy -- Bertini wants z-axis and GeV units
+  G4LorentzVector projectileMomentum = aTrack.Get4Momentum()/GeV;
+  // Rrotation/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)
+    bullet = new G4InuclElementaryParticle(momentumBullet, bulletType);
+  else
+    bullet = new G4InuclNuclei(momentumBullet, bulletA, bulletZ);
+  return;
+}
+// Convert input nuclear target to Bertini internal object
+void G4CascadeInterface::createTarget(G4Nucleus& theNucleus) {
+  G4int theNucleusA = theNucleus.GetA_asInt();
+  G4int theNucleusZ = theNucleus.GetZ_asInt();
+  if (theNucleusA == 1)
+    target = new G4InuclElementaryParticle((theNucleusZ==1)?proton:neutron);
+  else
+    target = new G4InuclNuclei(theNucleusA, theNucleusZ);
+  return;
+}
+// Transfer Bertini internal final state to hadronics interface
+void G4CascadeInterface::copyOutputToHadronicResult() {
+  const std::vector<G4InuclNuclei>& outgoingNuclei = output->getOutgoingNuclei();
+  const std::vector<G4InuclElementaryParticle>& particles = output->getOutgoingParticles();
   theResult.SetStatusChange(stopAndKill);
 …
   // Get outcoming particles
   G4DynamicParticle* cascadeParticle = 0;
   if (!particles.empty()) {
     particleIterator ipart = particles.begin();
 …
       G4int outgoingType = ipart->type();
-      eTot += ipart->getEnergy();
-      sumBaryon -= ipart->baryon();
-      sumEnergy -= ipart->getKineticEnergy();
       if (!ipart->valid() || ipart->quasi_deutron()) {
         G4cerr << " ERROR: G4CascadeInterface::Propagate incompatible"
+        G4cerr << " ERROR: G4CascadeInterface::ApplyYourself incompatible"
                << " particle type " << outgoingType << G4endl;
         continue;
 …
       if (outgoingType == kaonZero || outgoingType == kaonZeroBar) {
         G4ThreeVector momDir = ipart->getMomentum().vect().unit();
         G4double ekin = ipart->getKineticEnergy();
+        G4double ekin = ipart->getKineticEnergy()*GeV;  // Bertini -> G4 units
         G4ParticleDefinition* pd = G4KaonZeroShort::Definition();
 …
   // get nuclei fragments
   G4DynamicParticle * aFragment = 0;
+  if (!nucleiFragments.empty()) {
+    nucleiIterator ifrag = nucleiFragments.begin();
+    for (; ifrag != nucleiFragments.end(); ifrag++) {
+      eTot += ifrag->getEnergy();
+      sumBaryon -= ifrag->getA();
+      sumEnergy -= ifrag->getKineticEnergy();
+      // hpw @@@ ==> Should be zero: G4double fragmentExitation = ifrag->getExitationEnergyInGeV();
+  if (!outgoingNuclei.empty()) {
+    nucleiIterator ifrag = outgoingNuclei.begin();
+    for (; ifrag != outgoingNuclei.end(); ifrag++) {
       if (verboseLevel > 2) {
         G4cout << " Nuclei fragment: " << G4endl;
 …
+    }
+  }
+  // Report violations of energy, baryon conservation
+  if (verboseLevel > 2) {
+    if (sumBaryon != 0) {
+      G4cout << "ERROR: no baryon number conservation, sum of baryons = "
+             << sumBaryon << G4endl;
+    }
+    if (sumEnergy > 0.01 ) {
+      G4cout << "Kinetic energy conservation violated by "
+             << sumEnergy << " GeV" << G4endl;
+    }
+    G4cout << "Total energy conservation at level ~"
+           << (eInit - eTot) * GeV << " MeV" << G4endl;
+    if (sumEnergy < -5.0e-5 ) { // 0.05 MeV
+      G4cout << "FATAL ERROR: energy created  "
+             << sumEnergy * GeV << " MeV" << G4endl;
+    }
+  }
+  delete bullet;
+  delete collider;
+  if(target != 0) delete target;
+  if(targetH != 0) delete targetH;
+  return &theResult;
+}
+}
+// 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();
+  return ( (numberOfTries < maximumTries) &&
+           (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();
+  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
+void G4CascadeInterface::throwNonConservationFailure() {
+  G4cerr << " >>> G4CascadeInterface::ApplyYourself()\n has non-conserving"
+         << " cascade after " << numberOfTries << " attempts." << G4endl;
+  G4String throwMsg = "G4CascadeInterface::ApplyYourself() - ";
+  if (!balance->energyOkay()) {
+    throwMsg += "Energy";
+    G4cerr << " Energy conservation violated by " << balance->deltaE()
+           << " GeV (" << balance->relativeE() << ")" << G4endl;
+  }
+  if (!balance->momentumOkay()) {
+    throwMsg += "Momentum";
+    G4cerr << " Momentum conservation violated by " << balance->deltaP()
+           << " GeV/c (" << balance->relativeP() << ")" << G4endl;
+  }
+  if (!balance->baryonOkay()) {
+    throwMsg += "Baryon number";
+    G4cerr << " Baryon number violated by " << balance->deltaB() << G4endl;
+  }
+  if (!balance->chargeOkay()) {
+    throwMsg += "Charge";
+    G4cerr << " Charge conservation violated by " << balance->deltaB()
+           << G4endl;
+  }
+  G4cout << "\n Final event output, for debugging:"
+         << "\n Bullet:  " << G4endl;
+  bullet->printParticle();
+  G4cout << "\n Target:  " << G4endl;
+  target->printParticle();
+  output->printCollisionOutput();
+  throwMsg += " non-conservation. More info in output.";
+  throw G4HadronicException(__FILE__, __LINE__, throwMsg);   // Job ends here!
+}

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeKminusNChannel.cc

-              r1315
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeKminusNChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
 //
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadeKminusNChannel.hh"
 …
 G4CascadeKminusNChannelData::data(kmn2bfs, kmn3bfs, kmn4bfs,
                                   kmn5bfs, kmn6bfs, kmn7bfs,
                                   kmnCrossSections);
+                                  kmnCrossSections, "KminusN");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeKminusPChannel.cc

-              r1315
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeKminusPChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
 //
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadeKminusPChannel.hh"
 …
 G4CascadeKminusPChannelData::data(kmp2bfs, kmp3bfs, kmp4bfs,
                                   kmp5bfs, kmp6bfs, kmp7bfs,
                                   kmpCrossSections);
+                                  kmpCrossSections, "KminusP");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeKplusNChannel.cc

-              r1315
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeKplusNChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
 //
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadeKplusNChannel.hh"
 …
 G4CascadeKplusNChannelData::data(kpn2bfs, kpn3bfs, kpn4bfs,
                                  kpn5bfs, kpn6bfs, kpn7bfs,
                                  kpnCrossSections);
+                                 kpnCrossSections, "KplusN");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeKplusPChannel.cc

-              r1315
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeKplusPChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
 //
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadeKplusPChannel.hh"
 …
 G4CascadeKplusPChannelData::data(kpp2bfs, kpp3bfs, kpp4bfs,
                                  kpp5bfs, kpp6bfs, kpp7bfs,
                                  kppCrossSections);
+                                 kppCrossSections, "KplusP");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeKzeroBarNChannel.cc

-              r1337
+              r1340
 // ********************************************************************
 //
+// $Id: G4CascadeKzeroBarNChannel.cc,v 1.6 2010/06/25 09:44:06 gunter Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4CascadeKzeroBarNChannel.cc,v 1.7 2010/08/04 05:28:24 mkelsey Exp $
+// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
+//
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadeKzeroBarNChannel.hh"
 …
 G4CascadeKzeroBarNChannelData::data(kzbn2bfs, kzbn3bfs, kzbn4bfs,
                                     kzbn5bfs, kzbn6bfs, kzbn7bfs,
                                     kzbnCrossSections);
+                                    kzbnCrossSections, "KzeroBarN");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeKzeroBarPChannel.cc

-              r1315
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeKzeroBarPChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
 //
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadeKzeroBarPChannel.hh"
 …
 G4CascadeKzeroBarPChannelData::data(kzbp2bfs, kzbp3bfs, kzbp4bfs,
                                     kzbp5bfs, kzbp6bfs, kzbp7bfs,
                                     kzbpCrossSections);
+                                    kzbpCrossSections, "KzeroBarP");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeKzeroNChannel.cc

-              r1315
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeKzeroNChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
 //
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadeKzeroNChannel.hh"
 …
 G4CascadeKzeroNChannelData::data(k0n2bfs, k0n3bfs, k0n4bfs,
                                  k0n5bfs, k0n6bfs, k0n7bfs,
                                  k0nCrossSections);
+                                 k0nCrossSections, "KzeroN");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeKzeroPChannel.cc

-              r1315
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeKzeroPChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
 //
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadeKzeroPChannel.hh"
 …
 G4CascadeKzeroPChannelData::data(k0p2bfs, k0p3bfs, k0p4bfs,
                                  k0p5bfs, k0p6bfs, k0p7bfs,
                                  k0pCrossSections);
+                                 k0pCrossSections, "KzeroP");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeLambdaNChannel.cc

-              r1315
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeLambdaNChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
 //
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadeLambdaNChannel.hh"
 …
 G4CascadeLambdaNChannelData::data(ln2bfs, ln3bfs, ln4bfs,
                                   ln5bfs, ln6bfs, ln7bfs,
                                   lnCrossSections);
+                                  lnCrossSections, "LambdaN");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeLambdaPChannel.cc

-              r1315
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeLambdaPChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
 //
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadeLambdaPChannel.hh"
 …
 G4CascadeLambdaPChannelData::data(lp2bfs, lp3bfs, lp4bfs,
                                   lp5bfs, lp6bfs, lp7bfs,
                                   lpCrossSections);
+                                  lpCrossSections, "LambdaP");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeSigmaMinusNChannel.cc

-              r1315
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeSigmaMinusNChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
 //
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadeSigmaMinusNChannel.hh"
 …
 G4CascadeSigmaMinusNChannelData::data(smn2bfs, smn3bfs, smn4bfs,
                                       smn5bfs, smn6bfs, smn7bfs,
                                       smnCrossSections);
+                                      smnCrossSections, "SigmaMinusN");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeSigmaMinusPChannel.cc

-              r1315
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeSigmaMinusPChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
 //
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadeSigmaMinusPChannel.hh"
 …
 G4CascadeSigmaMinusPChannelData::data(smp2bfs, smp3bfs, smp4bfs,
                                       smp5bfs, smp6bfs, smp7bfs,
                                       smpCrossSections);
+                                      smpCrossSections, "SigmaMinusP");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeSigmaPlusNChannel.cc

-              r1315
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeSigmaPlusNChannel.cc,v 1.6 2010/08/04 05:28:24 mkelsey Exp $
 //
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadeSigmaPlusNChannel.hh"
 …
 G4CascadeSigmaPlusNChannelData::data(spn2bfs, spn3bfs, spn4bfs,
                                      spn5bfs, spn6bfs, spn7bfs,
                                      spnCrossSections);
+                                     spnCrossSections, "SigmaPlusN");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeSigmaPlusPChannel.cc

-              r1315
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeSigmaPlusPChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
 //
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadeSigmaPlusPChannel.hh"
 …
 G4CascadeSigmaPlusPChannelData::data(spp2bfs, spp3bfs, spp4bfs,
                                      spp5bfs, spp6bfs, spp7bfs,
                                      sppCrossSections);
+                                     sppCrossSections, "SigmaPlusP");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeSigmaZeroNChannel.cc

-              r1315
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeSigmaZeroNChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
 //
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadeSigmaZeroNChannel.hh"
 …
 G4CascadeSigmaZeroNChannelData::data(s0n2bfs, s0n3bfs, s0n4bfs,
                                      s0n5bfs, s0n6bfs, s0n7bfs,
                                      s0nCrossSections);
+                                     s0nCrossSections, "SigmaZeroN");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeSigmaZeroPChannel.cc

-              r1315
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeSigmaZeroPChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
 //
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadeSigmaZeroPChannel.hh"
 …
 G4CascadeSigmaZeroPChannelData::data(s0p2bfs, s0p3bfs, s0p4bfs,
                                      s0p5bfs, s0p6bfs, s0p7bfs,
                                      s0pCrossSections);
+                                     s0pCrossSections, "SigmaZeroP");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeT0npChannel.cc

-              r1337
+              r1340
 // ********************************************************************
 //
+// $Id: G4CascadeT0npChannel.cc,v 1.2 2010/06/25 09:44:08 gunter Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4CascadeT0npChannel.cc,v 1.3 2010/08/04 05:28:24 mkelsey Exp $
+// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
+//
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadeNPChannel.hh"
 …
 G4CascadeNPChannelData::data_t
 G4CascadeNPChannelData::data(np2bfs, np3bfs, np4bfs, np5bfs, np6bfs, np7bfs,
+                             np8bfs, np9bfs, npCrossSections, npTotXSec);
+                             np8bfs, np9bfs, npCrossSections, npTotXSec,
+                             "NeutronProton");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeT11pizNChannel.cc

-              r1337
+              r1340
 // ********************************************************************
 //
+// $Id: G4CascadeT11pizNChannel.cc,v 1.2 2010/06/25 09:44:10 gunter Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4CascadeT11pizNChannel.cc,v 1.3 2010/08/04 05:28:24 mkelsey Exp $
+// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
+//
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadePiZeroPChannel.hh"
 …
                                   pizP5bfs, pizP6bfs, pizP7bfs,
                                   pizP8bfs, pizP9bfs, pizPCrossSections,
                                   pizPtotXSec);
+                                  pizPtotXSec, "PiZeroP");
 G4CascadePiZeroNChannelData::data_t
 …
                                   pizN5bfs, pizN6bfs, pizN7bfs,
                                   pizN8bfs, pizN9bfs, pizPCrossSections,
                                   pizPtotXSec);
+                                  pizPtotXSec, "PiZeroN");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeT1NNChannel.cc

-              r1337
+              r1340
 // ********************************************************************
 //
+// $Id: G4CascadeT1NNChannel.cc,v 1.2 2010/06/25 09:44:12 gunter Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4CascadeT1NNChannel.cc,v 1.3 2010/08/04 05:28:24 mkelsey Exp $
+// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
+//
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadePPChannel.hh"
 …
 G4CascadePPChannelData::data_t
 G4CascadePPChannelData::data(pp2bfs, pp3bfs, pp4bfs, pp5bfs, pp6bfs, pp7bfs,
+                             pp8bfs, pp9bfs, ppCrossSections, ppTotXSec);
+                             pp8bfs, pp9bfs, ppCrossSections, ppTotXSec,
+                             "ProtonProton");
 G4CascadeNNChannelData::data_t
 G4CascadeNNChannelData::data(nn2bfs, nn3bfs, nn4bfs, nn5bfs, nn6bfs, nn7bfs,
+                             nn8bfs, nn9bfs, ppCrossSections, ppTotXSec);
+                             nn8bfs, nn9bfs, ppCrossSections, ppTotXSec,
+                             "NeutronNeutron");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeT31piNChannel.cc

-              r1337
+              r1340
 // ********************************************************************
 //
+// $Id: G4CascadeT31piNChannel.cc,v 1.2 2010/06/25 09:44:14 gunter Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4CascadeT31piNChannel.cc,v 1.3 2010/08/04 05:28:24 mkelsey Exp $
+// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
+//
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadePiMinusPChannel.hh"
 …
                                    pimP5bfs, pimP6bfs, pimP7bfs,
                                    pimP8bfs, pimP9bfs, pimPCrossSections,
                                    pimPtotXSec);
+                                   pimPtotXSec, "PiMinusP");
 G4CascadePiPlusNChannelData::data_t
 …
                                   pipN5bfs, pipN6bfs, pipN7bfs,
                                   pipN8bfs, pipN9bfs, pimPCrossSections,
                                   pimPtotXSec);
+                                  pimPtotXSec, "PiPlusN");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeT33piNChannel.cc

-              r1337
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeT33piNChannel.cc,v 1.3 2010/08/04 05:28:24 mkelsey Exp $
+// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // $Id: G4CascadeT33piNChannel.cc,v 1.1.2.1 2010/06/25 09:44:16 gunter Exp $
 // GEANT4 tag: $Name: geant4-09-04-beta-01 $
+// 20100612  M. Kelsey -- BUG FIX:  Swapped eight-body channel final-states
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadePiPlusPChannel.hh"
 …
   static const G4int pipP8bfs[7][8] =
    {{pim,neu,pip,pip,pip,pim,pim,pim}, {pim,neu,pip,pip,pim,pim,pi0,pi0},
     {pim,neu,pip,pim,pi0,pi0,pi0,pi0}, {pim,neu,pi0,pi0,pi0,pi0,pi0,pi0},
     {pim,pro,pip,pip,pim,pim,pim,pi0}, {pim,pro,pip,pim,pim,pi0,pi0,pi0},
     {pim,pro,pim,pi0,pi0,pi0,pi0,pi0}};
+   {{pip,pro,pip,pip,pip,pim,pim,pim}, {pip,pro,pip,pip,pim,pim,pi0,pi0},
+    {pip,pro,pip,pim,pi0,pi0,pi0,pi0}, {pip,pro,pi0,pi0,pi0,pi0,pi0,pi0},
+    {pip,neu,pip,pip,pip,pim,pim,pi0}, {pip,neu,pip,pip,pim,pi0,pi0,pi0},
+    {pip,neu,pip,pi0,pi0,pi0,pi0,pi0}};
   static const G4int pipP9bfs[8][9] =
 …
   static const G4int pimN8bfs[7][8] =
    {{pip,pro,pip,pip,pip,pim,pim,pim}, {pip,pro,pip,pip,pim,pim,pi0,pi0},
     {pip,pro,pip,pim,pi0,pi0,pi0,pi0}, {pip,pro,pi0,pi0,pi0,pi0,pi0,pi0},
     {pip,neu,pip,pip,pip,pim,pim,pi0}, {pip,neu,pip,pip,pim,pi0,pi0,pi0},
     {pip,neu,pip,pi0,pi0,pi0,pi0,pi0}};
+   {{pim,neu,pip,pip,pip,pim,pim,pim}, {pim,neu,pip,pip,pim,pim,pi0,pi0},
+    {pim,neu,pip,pim,pi0,pi0,pi0,pi0}, {pim,neu,pi0,pi0,pi0,pi0,pi0,pi0},
+    {pim,pro,pip,pip,pim,pim,pim,pi0}, {pim,pro,pip,pim,pim,pi0,pi0,pi0},
+    {pim,pro,pim,pi0,pi0,pi0,pi0,pi0}};
   static const G4int pimN9bfs[8][9] =
 …
                                   pipP5bfs, pipP6bfs, pipP7bfs,
                                   pipP8bfs, pipP9bfs, pipPCrossSections,
                                   pipPtotXSec);
+                                  pipPtotXSec, "PiPlusP");
 G4CascadePiMinusNChannelData::data_t
 …
                                    pimN5bfs, pimN6bfs, pimN7bfs,
                                    pimN8bfs, pimN9bfs, pipPCrossSections,
                                    pipPtotXSec);
+                                   pipPtotXSec, "PiMinusN");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeXiMinusNChannel.cc

-              r1315
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeXiMinusNChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
 //
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadeXiMinusNChannel.hh"
 …
 G4CascadeXiMinusNChannelData::data(xmn2bfs, xmn3bfs, xmn4bfs,
                                    xmn5bfs, xmn6bfs, xmn7bfs,
                                    xmnCrossSections);
+                                   xmnCrossSections, "XiMinusN");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeXiMinusPChannel.cc

-              r1315
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeXiMinusPChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
 //
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadeXiMinusPChannel.hh"
 …
 G4CascadeXiMinusPChannelData::data(xmp2bfs, xmp3bfs, xmp4bfs,
                                    xmp5bfs, xmp6bfs, xmp7bfs,
                                    xmpCrossSections);
+                                   xmpCrossSections, "XiMinusP");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeXiZeroNChannel.cc

-              r1315
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeXiZeroNChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
 //
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadeXiZeroNChannel.hh"
 …
 G4CascadeXiZeroNChannelData::data(x0n2bfs, x0n3bfs, x0n4bfs,
                                   x0n5bfs, x0n6bfs, x0n7bfs,
                                   x0nCrossSections);
+                                  x0nCrossSections, "XiZeroN");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CascadeXiZeroPChannel.cc

-              r1315
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeXiZeroPChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
 //
+// 20100804  M. Kelsey -- Add name string to ctor
 #include "G4CascadeXiZeroPChannel.hh"
 …
 G4CascadeXiZeroPChannelData::data(x0p2bfs, x0p3bfs, x0p4bfs,
                                   x0p5bfs, x0p6bfs, x0p7bfs,
                                   x0pCrossSections);
+                                  x0pCrossSections, "XiZeroP");

trunk/source/processes/hadronic/models/cascade/cascade/src/G4CollisionOutput.cc

-              r1337
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+//
+// $Id: G4CollisionOutput.cc,v 1.23.2.1 2010/06/25 09:44:18 gunter Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4CollisionOutput.cc,v 1.37 2010/10/19 19:48:34 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
 …
 // 20100418  M. Kelsey -- Add function to boost output lists to lab frame
 // 20100520  M. Kelsey -- Add function to rotate Z axis, from G4Casc.Interface
+// 20100620  M. Kelsey -- Add some diagnostics in setOnShell, simplify if's
+// 20100630  M. Kelsey -- Use "getExcitationEnergyInGeV()" instead of ".001*"
+// 20100701  M. Kelsey -- G4InuclNuclei now includes excitation energy as part
+//              of the reported mass and four-vector.
+// 20100714  M. Kelsey -- Modify setOnShell() to avoid creating particles
+//              with negative kinetic energy.
+// 20100715  M. Kelsey -- Add total charge and baryon number functions, and a
+//              combined "add()" function to put two of these together
+// 20100924  M. Kelsey -- Use "OutgoingNuclei" name consistently, replacing
+//              old "TargetFragment".  Add new (reusable) G4Fragment buffer
+//              and access functions for initial post-cascade processing.
+//              Move implementation of add() to .cc file.
+// 20101019  M. Kelsey -- CoVerity report: unitialized constructor
 #include "G4CollisionOutput.hh"
+#include "G4CascadParticle.hh"
 #include "G4ParticleLargerEkin.hh"
 #include "G4LorentzConvertor.hh"
 #include "G4LorentzRotation.hh"
+#include "G4ReactionProductVector.hh"
+#include "G4ReactionProduct.hh"
 #include <algorithm>
 …
 G4CollisionOutput::G4CollisionOutput()
+  : verboseLevel(0) {
+  if (verboseLevel > 3)
+  : verboseLevel(0), eex_rest(0), on_shell(false) {
+  if (verboseLevel > 1)
     G4cout << " >>> G4CollisionOutput::G4CollisionOutput" << G4endl;
+}
 …
     verboseLevel = right.verboseLevel;
     outgoingParticles = right.outgoingParticles;
+    nucleiFragments = right.nucleiFragments;
+    outgoingNuclei = right.outgoingNuclei;
+    theRecoilFragment = right.theRecoilFragment;
     eex_rest = right.eex_rest;
     on_shell = right.on_shell;
 …
 void G4CollisionOutput::reset() {
   nucleiFragments.clear();
+  outgoingNuclei.clear();
   outgoingParticles.clear();
+}
+  static const G4Fragment emptyFragment;        // Default ctor is all zeros
+  theRecoilFragment = emptyFragment;
+}
+// Merge two complete objects
+void G4CollisionOutput::add(const G4CollisionOutput& right) {
+  addOutgoingParticles(right.outgoingParticles);
+  addOutgoingNuclei(right.outgoingNuclei);
+  theRecoilFragment = right.theRecoilFragment;
+}
+// Append to lists
 void G4CollisionOutput::addOutgoingParticles(const std::vector<G4InuclElementaryParticle>& particles) {
 …
+}
+void G4CollisionOutput::addTargetFragments(const std::vector<G4InuclNuclei>& nuclea) {
+  nucleiFragments.insert(nucleiFragments.end(), nuclea.begin(), nuclea.end());
+void G4CollisionOutput::addOutgoingNuclei(const std::vector<G4InuclNuclei>& nuclea) {
+  outgoingNuclei.insert(outgoingNuclei.end(), nuclea.begin(), nuclea.end());
+}
+// These are primarily for G4IntraNucleiCascader internal checks
+void G4CollisionOutput::addOutgoingParticle(const G4CascadParticle& cparticle) {
+  addOutgoingParticle(cparticle.getParticle());
+}
+void G4CollisionOutput::addOutgoingParticles(const std::vector<G4CascadParticle>& cparticles) {
+  for (unsigned i=0; i<cparticles.size(); i++)
+    addOutgoingParticle(cparticles[i].getParticle());
+}
+// This comes from PreCompound de-excitation, both particles and nuclei
+void G4CollisionOutput::addOutgoingParticles(const G4ReactionProductVector* rproducts) {
+  if (!rproducts) return;               // Sanity check, no error if null
+  G4ReactionProductVector::const_iterator j;
+  for (j=rproducts->begin(); j!=rproducts->end(); ++j) {
+    G4ParticleDefinition* pd = (*j)->GetDefinition();
+    // FIXME:  This is expensive and unnecessary copying!
+    G4DynamicParticle aFragment(pd, (*j)->GetMomentum());
+    // Nucleons and nuclei are jumbled together in the list
+    if (G4InuclElementaryParticle::type(pd)) {
+      addOutgoingParticle(G4InuclElementaryParticle(aFragment, 9));
+    } else {
+      addOutgoingNucleus(G4InuclNuclei(aFragment, 9));
+    }
+  }
+}
 G4LorentzVector G4CollisionOutput::getTotalOutputMomentum() const {
+  if (verboseLevel > 1)
+    G4cout << " >>> G4CollisionOutput::getTotalOutputMomentum" << G4endl;
   G4LorentzVector tot_mom;
-  double eex_r = 0.0;
   G4int i(0);
   for(i = 0; i < G4int(outgoingParticles.size()); i++) {
+  for(i=0; i < G4int(outgoingParticles.size()); i++) {
     tot_mom += outgoingParticles[i].getMomentum();
+  }
+  for(i = 0; i < G4int(nucleiFragments.size()); i++) {
+    tot_mom += nucleiFragments[i].getMomentum();
+    eex_r += 0.001 * nucleiFragments[i].getExitationEnergy();
+  }
+  tot_mom.setE(tot_mom.e() + eex_r);
+  for(i=0; i < G4int(outgoingNuclei.size()); i++) {
+    tot_mom += outgoingNuclei[i].getMomentum();
+  }
   return tot_mom;
+}
+G4int G4CollisionOutput::getTotalCharge() const {
+  if (verboseLevel > 1)
+    G4cout << " >>> G4CollisionOutput::getTotalCharge" << G4endl;
+  G4int charge = 0;
+  G4int i(0);
+  for(i=0; i < G4int(outgoingParticles.size()); i++) {
+    charge += G4int(outgoingParticles[i].getCharge());
+  }
+  for(i=0; i < G4int(outgoingNuclei.size()); i++) {
+    charge += G4int(outgoingNuclei[i].getCharge());
+  }
+  return charge;
+}
+G4int G4CollisionOutput::getTotalBaryonNumber() const {
+  if (verboseLevel > 1)
+    G4cout << " >>> G4CollisionOutput::getTotalBaryonNumber" << G4endl;
+  G4int baryon = 0;
+  G4int i(0);
+  for(i=0; i < G4int(outgoingParticles.size()); i++) {
+    baryon += outgoingParticles[i].baryon();
+  }
+  for(i=0; i < G4int(outgoingNuclei.size()); i++) {
+    baryon += G4int(outgoingNuclei[i].getA());
+  }
+  return baryon;
+}
 void G4CollisionOutput::printCollisionOutput() const {
+  G4cout << " Output: " << G4endl
+         << " Outgoing Particles: " << outgoingParticles.size() << G4endl;
   G4int i(0);
+  G4cout << " Output: " << G4endl
+         << " Outgoing Particles: " << outgoingParticles.size() << G4endl;
+  for(i = 0; i < G4int(outgoingParticles.size()); i++)
+  for(i=0; i < G4int(outgoingParticles.size()); i++)
     outgoingParticles[i].printParticle();
+  G4cout << " Nuclei fragments: " << nucleiFragments.size() << G4endl;
+  for(i = 0; i < G4int(nucleiFragments.size()); i++)
+    nucleiFragments[i].printParticle();
+  G4cout << " Outgoing Nuclei: " << outgoingNuclei.size() << G4endl;
+  for(i=0; i < G4int(outgoingNuclei.size()); i++)
+    outgoingNuclei[i].printParticle();
+  if (theRecoilFragment.GetA() > 0) {
+    G4cout << theRecoilFragment << G4endl;
+  }
+}
 …
 void G4CollisionOutput::boostToLabFrame(const G4LorentzConvertor& convertor) {
+  if (verboseLevel > 1)
+    G4cout << " >>> G4CollisionOutput::boostToLabFrame" << G4endl;
   G4bool withReflection = convertor.reflectionNeeded();
 …
+  }
   if (!nucleiFragments.empty()) {
     nucleiIterator inuc = nucleiFragments.begin();
+  if (!outgoingNuclei.empty()) {
+    nucleiIterator inuc = outgoingNuclei.begin();
     for (; inuc != nucleiFragments.end(); inuc++) {
+    for (; inuc != outgoingNuclei.end(); inuc++) {
       G4LorentzVector mom = inuc->getMomentum();
 …
 void G4CollisionOutput::rotateEvent(const G4LorentzRotation& rotate) {
+  if (verboseLevel > 1)
+    G4cout << " >>> G4CollisionOutput::rotateEvent" << G4endl;
   particleIterator ipart = outgoingParticles.begin();
   for(; ipart != outgoingParticles.end(); ipart++)
     ipart->setMomentum(ipart->getMomentum()*=rotate);
   nucleiIterator inuc = nucleiFragments.begin();
   for (; inuc != nucleiFragments.end(); inuc++)
+  nucleiIterator inuc = outgoingNuclei.begin();
+  for (; inuc != outgoingNuclei.end(); inuc++)
     inuc->setMomentum(inuc->getMomentum()*=rotate);
+}
 …
 void G4CollisionOutput::trivialise(G4InuclParticle* bullet,
                                    G4InuclParticle* target) {
+  if (verboseLevel > 1)
+    G4cout << " >>> G4CollisionOutput::trivialize" << G4endl;
   if (G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target)) {
     nucleiFragments.push_back(*nuclei_target);
+    outgoingNuclei.push_back(*nuclei_target);
   } else {
     G4InuclElementaryParticle* particle =
 …
   if (G4InuclNuclei* nuclei_bullet = dynamic_cast<G4InuclNuclei*>(bullet)) {
     nucleiFragments.push_back(*nuclei_bullet);
+    outgoingNuclei.push_back(*nuclei_bullet);
   } else {
     G4InuclElementaryParticle* particle =
 …
 void G4CollisionOutput::setOnShell(G4InuclParticle* bullet,
                                    G4InuclParticle* target) {
+  if (verboseLevel > 3) {
+  if (verboseLevel > 1)
     G4cout << " >>> G4CollisionOutput::setOnShell" << G4endl;
+  }
+  const G4double accuracy = 0.00001; // momentum concerves at the level of 1 eV
+  const G4double accuracy = 0.00001; // momentum concerves at the level of 10 keV
   on_shell = false;
 …
   G4LorentzVector out_mom = getTotalOutputMomentum();
-  G4LorentzVector mon_non_cons;
   if(verboseLevel > 2){
     G4cout << " bullet momentum = " << ini_mom.e() <<", "<< ini_mom.x() <<", "<< ini_mom.y()<<", "<< ini_mom.z()<<G4endl;
 …
+  }
   mon_non_cons = ini_mom - out_mom;
+  G4LorentzVector mon_non_cons = ini_mom - out_mom;
   G4double pnc = mon_non_cons.rho();
+  G4double enc = mon_non_cons.e();
   setRemainingExitationEnergy();
 …
     printCollisionOutput();
     G4cout << " momentum non conservation: " << G4endl
+           << " e " << mon_non_cons.e()
+           << " p " << pnc << G4endl;
+           << " e " << enc << " p " << pnc << G4endl;
     G4cout << " remaining exitation " << eex_rest << G4endl;
+  }
+  if(std::fabs(mon_non_cons.e()) > accuracy || pnc > accuracy) { // renormalization
+    G4int npart = outgoingParticles.size();
+    if(npart > 0) {
+      G4LorentzVector last_mom = outgoingParticles[npart - 1].getMomentum();
+      last_mom += mon_non_cons;
+      outgoingParticles[npart - 1].setMomentum(last_mom);
+    }
+    else {
+      G4int nnuc = nucleiFragments.size();
+      if(nnuc > 0) {
+        G4LorentzVector last_mom = nucleiFragments[nnuc - 1].getMomentum();
+        last_mom += mon_non_cons;
+        nucleiFragments[nnuc - 1].setMomentum(last_mom);
+        nucleiFragments[nnuc - 1].setEnergy();
+  if(std::fabs(enc) <= accuracy && pnc <= accuracy) {
+    on_shell = true;
+    return;
+  }
+  // Adjust "last" particle's four-momentum to balance event
+  // ONLY adjust particles with sufficient e or p to remain physical!
+  if (verboseLevel > 2) G4cout << " re-balancing four-momenta" << G4endl;
+  G4int npart = outgoingParticles.size();
+  G4int nnuc = outgoingNuclei.size();
+  if (npart > 0) {
+    for (G4int ip=npart-1; ip>=0; ip--) {
+      if (outgoingParticles[ip].getKineticEnergy()+enc > 0.) {
+        G4LorentzVector last_mom = outgoingParticles[ip].getMomentum();
+        last_mom += mon_non_cons;
+        outgoingParticles[ip].setMomentum(last_mom);
+        break;
+      }
+    }
+  } else if (nnuc > 0) {
+    for (G4int in=nnuc-1; in>=0; in--) {
+      if (outgoingNuclei[in].getKineticEnergy()+enc > 0.) {
+        G4LorentzVector last_mom = outgoingNuclei[in].getMomentum();
+        last_mom += mon_non_cons;
+        outgoingNuclei[in].setMomentum(last_mom);
+        break;
+      }
+    }
+  }
+  out_mom = getTotalOutputMomentum();
+  mon_non_cons = ini_mom - out_mom;
+  pnc = mon_non_cons.rho();
+  enc = mon_non_cons.e();
+  if(verboseLevel > 2){
+    printCollisionOutput();
+    G4cout << " momentum non conservation after (1): " << G4endl
+           << " e " << enc << " p " << pnc << G4endl;
+  }
+  // Can energy be balanced just with nuclear excitation?
+  G4bool need_hard_tuning = true;
+  G4double encMeV = mon_non_cons.e() / GeV;     // Excitation below is in MeV
+  if (outgoingNuclei.size() > 0) {
+    for (G4int i=0; i < G4int(outgoingNuclei.size()); i++) {
+      G4double eex = outgoingNuclei[i].getExitationEnergy();
+      if(eex > 0.0 && eex + encMeV >= 0.0) {
+        outgoingNuclei[i].setExitationEnergy(eex+encMeV);
+        need_hard_tuning = false;
+        break;
+      }
+    }
+    if (need_hard_tuning && encMeV > 0.) {
+      outgoingNuclei[0].setExitationEnergy(encMeV);
+      need_hard_tuning = false;
+    }
+  }
+  if (!need_hard_tuning) {
+    on_shell = true;
+    return;
+  }
+  // Momentum (hard) tuning required for energy conservation
+  if (verboseLevel > 2)
+    G4cout << " trying hard (particle-pair) tuning" << G4endl;
+  std::pair<std::pair<G4int, G4int>, G4int> tune_par = selectPairToTune(mon_non_cons.e());
+  std::pair<G4int, G4int> tune_particles = tune_par.first;
+  G4int mom_ind = tune_par.second;
+  if(verboseLevel > 2) {
+    G4cout << " p1 " << tune_particles.first << " p2 " << tune_particles.second
+           << " ind " << mom_ind << G4endl;
+  }
+  G4bool tuning_possible =
+    (tune_particles.first >= 0 && tune_particles.second >= 0 &&
+     mom_ind >= G4LorentzVector::X);
+  if (!tuning_possible) {
+    if (verboseLevel > 2) G4cout << " tuning impossible " << G4endl;
+    return;
+  }
+  G4LorentzVector mom1 = outgoingParticles[tune_particles.first].getMomentum();
+  G4LorentzVector mom2 = outgoingParticles[tune_particles.second].getMomentum();
+  G4double newE12 = mom1.e() + mom2.e() + mon_non_cons.e();
+  G4double R = 0.5 * (newE12 * newE12 + mom2.e() * mom2.e() - mom1.e() * mom1.e()) / newE12;
+  G4double Q = -(mom1[mom_ind] + mom2[mom_ind]) / newE12;
+  G4double UDQ = 1.0 / (Q * Q - 1.0);
+  G4double W = (R * Q + mom2[mom_ind]) * UDQ;
+  G4double V = (mom2.e() * mom2.e() - R * R) * UDQ;
+  G4double DET = W * W + V;
+  if (DET < 0.0) {
+    if (verboseLevel > 2) G4cout << " DET < 0 " << G4endl;
+    return;
+  }
+  // Tuning allowed only for non-negative determinant
+  G4double x1 = -(W + std::sqrt(DET));
+  G4double x2 = -(W - std::sqrt(DET));
+  // choose the appropriate solution
+  G4bool xset = false;
+  G4double x = 0.0;
+  if(mon_non_cons.e() > 0.0) { // x has to be > 0.0
+    if(x1 > 0.0) {
+      if(R + Q * x1 >= 0.0) {
+        x = x1;
+        xset = true;
       };
+    };
+    out_mom = getTotalOutputMomentum();
+    mon_non_cons = ini_mom - out_mom;
+    pnc = mon_non_cons.rho();
+    if(verboseLevel > 2){
+      printCollisionOutput();
+      G4cout << " momentum non conservation after (1): " << G4endl
+             << " e " << mon_non_cons.e() << " p " << pnc << G4endl;
+    }
+    G4bool need_hard_tuning = true;
+    if(nucleiFragments.size() > 0) {
+      for(G4int i = 0; i < G4int(nucleiFragments.size()); i++) {
+        G4double eex = nucleiFragments[i].getExitationEnergyInGeV();
+        if(eex > 0.0 && eex + mon_non_cons.e() >= 0.0) {
+          nucleiFragments[i].setExitationEnergy(1000.0 * (eex + mon_non_cons.e()));
+          need_hard_tuning = false;
+          break;
+        };
+      };
+      if(need_hard_tuning && mon_non_cons.e() > 0.) {
+        nucleiFragments[0].setExitationEnergy(1000.0 * mon_non_cons.e());
+        need_hard_tuning = false;
+    };
+    if(!xset && x2 > 0.0) {
+      if(R + Q * x2 >= 0.0) {
+        x = x2;
+        xset = true;
       };
     };
+    if(need_hard_tuning) {
+      std::pair<std::pair<G4int, G4int>, G4int> tune_par = selectPairToTune(mon_non_cons.e());
+      std::pair<G4int, G4int> tune_particles = tune_par.first;
+      G4int mom_ind = tune_par.second;
+      if(verboseLevel > 2) {
+        G4cout << " p1 " << tune_particles.first << " p2 " << tune_particles.second
+               << " ind " << mom_ind << G4endl;
+      }
+      if(tune_particles.first >= 0 && tune_particles.second >= 0 &&
+         mom_ind >= G4LorentzVector::X) { // tunning possible
+        G4LorentzVector mom1 = outgoingParticles[tune_particles.first].getMomentum();
+        G4LorentzVector mom2 = outgoingParticles[tune_particles.second].getMomentum();
+        G4double newE12 = mom1.e() + mom2.e() + mon_non_cons.e();
+        G4double R = 0.5 * (newE12 * newE12 + mom2.e() * mom2.e() - mom1.e() * mom1.e()) / newE12;
+        G4double Q = -(mom1[mom_ind] + mom2[mom_ind]) / newE12;
+        G4double UDQ = 1.0 / (Q * Q - 1.0);
+        G4double W = (R * Q + mom2[mom_ind]) * UDQ;
+        G4double V = (mom2.e() * mom2.e() - R * R) * UDQ;
+        G4double DET = W * W + V;
+        if(DET > 0.0) {
+          G4double x1 = -(W + std::sqrt(DET));
+          G4double x2 = -(W - std::sqrt(DET));
+          // choose the appropriate solution
+          G4bool xset = false;
+          G4double x = 0.0;
+          if(mon_non_cons.e() > 0.0) { // x has to be > 0.0
+            if(x1 > 0.0) {
+              if(R + Q * x1 >= 0.0) {
+                x = x1;
+                xset = true;
+              };
+            };
+            if(!xset && x2 > 0.0) {
+              if(R + Q * x2 >= 0.0) {
+                x = x2;
+                xset = true;
+              };
+            };
+          }
+          else {
+            if(x1 < 0.0) {
+              if(R + Q * x1 >= 0.) {
+                x = x1;
+                xset = true;
+              };
+            };
+            if(!xset && x2 < 0.0) {
+              if(R + Q * x2 >= 0.0) {
+                x = x2;
+                xset = true;
+              };
+            };
+          }     // if(mon_non_cons.e() > 0.0)
+          if(xset) { // retune momentums
+            mom1[mom_ind] += x;
+            mom2[mom_ind] -= x;
+            outgoingParticles[tune_particles.first ].setMomentum(mom1);
+            outgoingParticles[tune_particles.second].setMomentum(mom2);
+            out_mom = getTotalOutputMomentum();
+            std::sort(outgoingParticles.begin(), outgoingParticles.end(), G4ParticleLargerEkin());
+            mon_non_cons = ini_mom - out_mom;
+            pnc = mon_non_cons.rho();
+            if(verboseLevel > 2){
+              G4cout << " momentum non conservation tuning: " << G4endl
+                     << " e " << mon_non_cons.e() << " p " << pnc << G4endl;
+            }
+            if(std::fabs(mon_non_cons.e()) < accuracy || pnc < accuracy) on_shell = true;
+          }
+          else {
+            if(verboseLevel > 2){
+              G4cout << " no appropriate solution found " << G4endl;
+            }
+          }     // if(xset)
+        }
+        else {
+          if(verboseLevel > 2){
+            G4cout << " DET < 0 " << G4endl;
+          }
+        }       // if(DET > 0.0)
+      }
+      else {
+        if(verboseLevel > 2){
+          G4cout << " tuning impossible " << G4endl;
+        }
+      } // if (<tuning-possible>)
+    }
+    else {
+      on_shell = true;
+    }   // if(need_hard_tuning)
+  }
+  else {
+    on_shell = true;
+  };    // if (<renormalization>)
+}
+  } else {
+    if(x1 < 0.0) {
+      if(R + Q * x1 >= 0.) {
+        x = x1;
+        xset = true;
+      };
+    };
+    if(!xset && x2 < 0.0) {
+      if(R + Q * x2 >= 0.0) {
+        x = x2;
+        xset = true;
+      };
+    };
+  }     // if(mon_non_cons.e() > 0.0)
+  if(!xset) {
+    if(verboseLevel > 2)
+      G4cout << " no appropriate solution found " << G4endl;
+    return;
+  }     // if(xset)
+  // retune momentums
+  mom1[mom_ind] += x;
+  mom2[mom_ind] -= x;
+  outgoingParticles[tune_particles.first ].setMomentum(mom1);
+  outgoingParticles[tune_particles.second].setMomentum(mom2);
+  out_mom = getTotalOutputMomentum();
+  std::sort(outgoingParticles.begin(), outgoingParticles.end(), G4ParticleLargerEkin());
+  mon_non_cons = ini_mom - out_mom;
+  pnc = mon_non_cons.rho();
+  enc = mon_non_cons.e();
+  on_shell = (std::fabs(enc) < accuracy || pnc < accuracy);
+  if(verboseLevel > 2) {
+    G4cout << " momentum non conservation tuning: " << G4endl
+           << " e " << enc << " p " << pnc
+           << (on_shell?" success":" FAILURE") << G4endl;
+  }
+}
 void G4CollisionOutput::setRemainingExitationEnergy() {
   eex_rest = 0.0;
   for(G4int i = 0; i < G4int(nucleiFragments.size()); i++)
     eex_rest += 0.001 * nucleiFragments[i].getExitationEnergy();
+  for(G4int i=0; i < G4int(outgoingNuclei.size()); i++)
+    eex_rest += outgoingNuclei[i].getExitationEnergyInGeV();
+}
 …
 std::pair<std::pair<G4int, G4int>, G4int>
 G4CollisionOutput::selectPairToTune(G4double de) const {
   if (verboseLevel > 3) {
+  if (verboseLevel > 2)
     G4cout << " >>> G4CollisionOutput::selectPairToTune" << G4endl;
+  }
   std::pair<G4int, G4int> tup(-1, -1);
 …
   G4double p2;
   for (G4int i = 0; i < G4int(outgoingParticles.size()) - 1; i++) {
+  for (G4int i = 0; i < G4int(outgoingParticles.size())-1; i++) {
     G4LorentzVector mom1 = outgoingParticles[i].getMomentum();

trunk/source/processes/hadronic/models/cascade/cascade/src/G4Dineutron.cc

r1337	r1340
25	25	//
26	26	// $Id: G4Dineutron.cc,v 1.5 2010/06/25 09:44:20 gunter Exp $
27		// GEANT4 tag $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// ------------------------------------------------------------

trunk/source/processes/hadronic/models/cascade/cascade/src/G4Diproton.cc

r1337	r1340
25	25	//
26	26	// $Id: G4Diproton.cc,v 1.5 2010/06/25 09:44:22 gunter Exp $
27		// GEANT4 tag $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// ------------------------------------------------------------

trunk/source/processes/hadronic/models/cascade/cascade/src/G4ElementaryParticleCollider.cc

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4ElementaryParticleCollider.cc,v 1.64.2.1 2010/06/25 09:44:24 gunter Exp $
 // Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4ElementaryParticleCollider.cc,v 1.75 2010/10/19 19:48:35 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
 …
 // 20100517  M. Kelsey -- Inherit from common base class, make arrays static
 // 20100519  M. Kelsey -- Use G4InteractionCase to compute "is" values.
+// 20100625  M. Kelsey -- Two bugs in n-body momentum, last particle recoil
+// 20100713  M. Kelsey -- Bump collide start message up to verbose > 1
+// 20100714  M. Kelsey -- Move conservation checking to base class
+// 20100714  M. Kelsey -- Add sanity check for two-body final state, to ensure
+//              that final state total mass is below etot_scm; also compute
+//              kinematics without "rescaling" (which led to non-conservation)
+// 20100726  M. Kelsey -- Move remaining std::vector<> buffers to .hh file
+// 20100804  M. Kelsey -- Add printing of final-state tables, protected by
+//              G4CASCADE_DEBUG_SAMPLER preprocessor flag
+// 20101019  M. Kelsey -- CoVerity report: check dynamic_cast<> for null
 #include "G4ElementaryParticleCollider.hh"
 …
 G4ElementaryParticleCollider::G4ElementaryParticleCollider()
   : G4VCascadeCollider("G4ElementaryParticleCollider") {}
+  : G4CascadeColliderBase("G4ElementaryParticleCollider") {}
 …
                                       G4CollisionOutput& output)
+{
+  if (verboseLevel > 1)
+    G4cout << " >>> G4ElementaryParticleCollider::collide" << G4endl;
   if (!useEPCollider(bullet,target)) {          // Sanity check
     G4cerr << " ElementaryParticleCollider -> can collide only particle with particle "
 …
+  }
+#ifdef G4CASCADE_DEBUG_SAMPLER
+  static G4bool doPrintTables = true;   // Once and only once per job
+  if (doPrintTables) {
+    printFinalStateTables();            // For diagnostic reporting
+    doPrintTables = false;
+  }
+#endif
   interCase.set(bullet, target);        // To identify kind of collision
+  if (verboseLevel > 1) {
+    bullet->printParticle();
+    target->printParticle();
+  }
   G4InuclElementaryParticle* particle1 =
 …
     dynamic_cast<G4InuclElementaryParticle*>(target);
+  if (!particle1 || !particle2) {       // Redundant with useEPCollider()
+    G4cerr << " ElementaryParticleCollider -> can collide only particle with particle "
+           << G4endl;
+    return;
+  }
   if (particle1->isPhoton() || particle2->isPhoton()) {
     G4cout << " ElementaryParticleCollider -> cannot collide photons "
+    G4cerr << " ElementaryParticleCollider -> cannot collide photons "
            << G4endl;
+  } else {
+    return;
+  }
   // Generate nucleon or pion collision with nucleon
   // or pion with quasi-deuteron
+    if (particle1->nucleon() || particle2->nucleon()) { // ok
+      G4LorentzConvertor convertToSCM;
+      if(particle2->nucleon()) {
+        convertToSCM.setBullet(particle1);
+        convertToSCM.setTarget(particle2);
+  if (particle1->nucleon() || particle2->nucleon()) { // ok
+    G4LorentzConvertor convertToSCM;
+    if(particle2->nucleon()) {
+      convertToSCM.setBullet(particle1);
+      convertToSCM.setTarget(particle2);
+    } else {
+      convertToSCM.setBullet(particle2);
+      convertToSCM.setTarget(particle1);
+    };
+    convertToSCM.setVerbose(verboseLevel);
+    convertToSCM.toTheCenterOfMass();
+    G4double ekin = convertToSCM.getKinEnergyInTheTRS();
+    G4double etot_scm = convertToSCM.getTotalSCMEnergy();
+    G4double pscm = convertToSCM.getSCMMomentum();
+    generateSCMfinalState(ekin, etot_scm, pscm, particle1, particle2,
+                          &convertToSCM);
+    if(!particles.empty()) { // convert back to Lab
+      G4LorentzVector mom;              // Buffer to avoid memory churn
+      particleIterator ipart;
+      for(ipart = particles.begin(); ipart != particles.end(); ipart++) {
+        mom = convertToSCM.backToTheLab(ipart->getMomentum());
+        ipart->setMomentum(mom);
+      };
+      // Check conservation in mutlibody final state
+      if (verboseLevel && !validateOutput(bullet, target, particles)) {
+        G4cout << " incoming particles: " << G4endl;
+        particle1->printParticle();
+        particle2->printParticle();
+        G4cout << " outgoing particles: " << G4endl;
+        for(ipart = particles.begin(); ipart != particles.end(); ipart++)
+          ipart->printParticle();
+        G4cout << " <<< Non-conservation in G4ElementaryParticleCollider"
+               << G4endl;
+      }
+      std::sort(particles.begin(), particles.end(), G4ParticleLargerEkin());
+      output.addOutgoingParticles(particles);
+    };
+  } else {
+    if(particle1->quasi_deutron() || particle2->quasi_deutron()) {
+      if(particle1->pion() || particle2->pion()) {
+        G4LorentzConvertor convertToSCM;
+        if(particle1->pion()) {
+          convertToSCM.setBullet(particle1);
+          convertToSCM.setTarget(particle2);
+        } else {
+          convertToSCM.setBullet(particle2);
+          convertToSCM.setTarget(particle1);
+        };
+        convertToSCM.toTheCenterOfMass();
+        G4double etot_scm = convertToSCM.getTotalSCMEnergy();
+        generateSCMpionAbsorption(etot_scm, particle1, particle2);
+        if(!particles.empty()) { // convert back to Lab
+          G4LorentzVector mom;  // Buffer to avoid memory churn
+          particleIterator ipart;
+          for(ipart = particles.begin(); ipart != particles.end(); ipart++) {
+            mom = convertToSCM.backToTheLab(ipart->getMomentum());
+            ipart->setMomentum(mom);
+          };
+          validateOutput(bullet, target, particles);    // Check conservation
+          std::sort(particles.begin(), particles.end(), G4ParticleLargerEkin());
+          output.addOutgoingParticles(particles);
+        };
       } else {
+        convertToSCM.setBullet(particle2);
+        convertToSCM.setTarget(particle1);
+      };
+      convertToSCM.toTheCenterOfMass();
+      G4double ekin = convertToSCM.getKinEnergyInTheTRS();
+      G4double etot_scm = convertToSCM.getTotalSCMEnergy();
+      G4double pscm = convertToSCM.getSCMMomentum();
+      generateSCMfinalState(ekin, etot_scm, pscm, particle1, particle2,
+                            &convertToSCM);
+      if(verboseLevel > 2){
+        G4cout << " particles " << particles.size() << G4endl;
+        for(G4int i = 0; i < G4int(particles.size()); i++)
+          particles[i].printParticle();
+      }
+      if(!particles.empty()) { // convert back to Lab
+        G4LorentzVector mom;            // Buffer to avoid memory churn
+        particleIterator ipart;
+        for(ipart = particles.begin(); ipart != particles.end(); ipart++) {
+          mom = convertToSCM.backToTheLab(ipart->getMomentum());
+          ipart->setMomentum(mom);
+        };
+        std::sort(particles.begin(), particles.end(), G4ParticleLargerEkin());
+        output.addOutgoingParticles(particles);
+        G4cerr << " ElementaryParticleCollider -> can only collide pions with deuterons "
+               << G4endl;
       };
     } else {
+      if(particle1->quasi_deutron() || particle2->quasi_deutron()) {
+        if(particle1->pion() || particle2->pion()) {
+          G4LorentzConvertor convertToSCM;
+          if(particle1->pion()) {
+            convertToSCM.setBullet(particle1);
+            convertToSCM.setTarget(particle2);
+          } else {
+            convertToSCM.setBullet(particle2);
+            convertToSCM.setTarget(particle1);
+          };
+          convertToSCM.toTheCenterOfMass();
+          G4double etot_scm = convertToSCM.getTotalSCMEnergy();
+          generateSCMpionAbsorption(etot_scm, particle1, particle2);
+          if(!particles.empty()) { // convert back to Lab
+            G4LorentzVector mom;        // Buffer to avoid memory churn
+            particleIterator ipart;
+            for(ipart = particles.begin(); ipart != particles.end(); ipart++) {
+              mom = convertToSCM.backToTheLab(ipart->getMomentum());
+              ipart->setMomentum(mom);
+            };
+            std::sort(particles.begin(), particles.end(), G4ParticleLargerEkin());
+            output.addOutgoingParticles(particles);
+          };
+        } else {
+          G4cout << " ElementaryParticleCollider -> can only collide pions with deuterons "
+                 << G4endl;
+        };
+      } else {
+        G4cout << " ElementaryParticleCollider -> can only collide something with nucleon or deuteron "
+               << G4endl;
+      };
+    };
+  }
+      G4cerr << " ElementaryParticleCollider -> can only collide something with nucleon or deuteron "
+             << G4endl;
+    };
+  };
+}
 …
   G4bool generate = true;
-  particles.clear();            // Initialize buffers for this event
-  particle_kinds.clear();
   while (generate) {
+    if(multiplicity == 0) {
+      multiplicity = generateMultiplicity(is, ekin);
+    } else {
+      multiplicity = generateMultiplicity(is, ekin);
+      particle_kinds.clear();
+    }
+    particles.clear();          // Initialize buffers for this event
+    particle_kinds.clear();
     // Generate list of final-state particles
+    multiplicity = generateMultiplicity(is, ekin);
     generateOutgoingPartTypes(is, multiplicity, ekin);
     if (particle_kinds.empty()) continue;
-    // G4cout << " Particle kinds = " ;
-    // for (G4int i = 0; i < multiplicity; i++) G4cout << particle_kinds[i] << " , " ;
-    // G4cout << G4endl;
     if (multiplicity == 2) {
 …
       G4int kw = (finaltype != is) ? 2 : 1;
+      G4double pmod = pscm;     // May need to rescale momentum
+      if (kw == 2) {
+      G4double pmod = pscm;     // Elastic scattering preserves CM momentum
+      if (kw == 2) {            // Non-elastic needs new CM momentum value
         G4double m1 = dummy.getParticleMass(particle_kinds[0]);
-        m1 *= m1;
         G4double m2 = dummy.getParticleMass(particle_kinds[1]);
+        m2 *= m2;
+        G4double a = 0.5 * (etot_scm * etot_scm - m1 - m2);
+        G4double em = a * a - m1 * m2;
+        if (em > 0) {           //  It is possible to rescale
+          pmod = std::sqrt( em / (m1 + m2 + 2.0 * a));
+        if (etot_scm < m1+m2) {         // Can't produce final state
+          if (verboseLevel > 2) {
+            G4cerr << " bad final state " << particle_kinds[0]
+                   << " , " << particle_kinds[1] << " etot_scm " << etot_scm
+                   << " < m1+m2 " << m1+m2 << " , but ekin " << ekin << G4endl;
+          }
+          continue;
+        }
+        G4double ecm_sq = etot_scm*etot_scm;
+        G4double msumsq = m1+m2; msumsq *= msumsq;
+        G4double mdifsq = m1-m2; mdifsq *= mdifsq;
+        G4double a = (ecm_sq - msumsq) * (ecm_sq - mdifsq);
+        pmod = std::sqrt(a)/(2.*etot_scm);
+      }
       G4LorentzVector mom = sampleCMmomentumFor2to2(is, kw, ekin, pmod);
       if (verboseLevel > 3){
+      if (verboseLevel > 3) {
         G4cout << " Particle kinds = " << particle_kinds[0] << " , "
                << particle_kinds[1] << G4endl
+               << " pscm " << pscm << " pmod " << pmod << G4endl
                << " before rotation px " << mom.x() << " py " << mom.y()
                << " pz " << mom.z() << G4endl;
 …
           " pz " << mom.z() << G4endl;
+      }
       G4LorentzVector mom1 = -mom;
+      G4LorentzVector mom1(-mom.vect(), mom.e());
       particles.push_back(G4InuclElementaryParticle(mom, particle_kinds[0], 3));
 …
             G4LorentzVector mom1 = generateWithFixedTheta(ct, modules[0]);
             mom1 = toSCM->rotate(mom3, mom1);
+            G4LorentzVector mom2 = -(mom3 + mom1);
+            // Second particle recoils off 1 & 3
+            G4LorentzVector mom2(etot_scm);
+            mom2 -= mom1+mom3;
             bad = false;
 …
         } else { // multiplicity > 3
           // generate first mult - 2 momentums
-          std::vector<G4LorentzVector> scm_momentums;
           G4LorentzVector tot_mom;
+          scm_momentums.clear();
           for (G4int i = 0; i < multiplicity - 2; i++) {
 …
             scm_momentums.push_back(mom);
+            // and the last one
+            G4LorentzVector mom1 = -(mom+tot_mom);
+            // Last particle recoils off everything else
+            G4LorentzVector mom1(etot_scm);
+            mom1 -= mom+tot_mom;
             scm_momentums.push_back(mom1);
 …
   // FIXME:  Code below wants to set modules[i] directly.  Bad practice
   modules.clear();                      // Initialize buffer for this attempt
+  modules.insert(modules.begin(), mult, 0.);
+  std::vector<G4double> masses2(mult);
+  modules.resize(mult,0.);
+  masses2.clear();
+  masses2.resize(mult,0.);              // Allows direct [i] setting
   for (G4int i = 0; i < mult; i++) {
 …
   return;
+}
+// Dump lookup tables for N-body final states
+void G4ElementaryParticleCollider::printFinalStateTables() const {
+  G4CascadeKminusNChannel::printTable();
+  G4CascadeKminusPChannel::printTable();
+  G4CascadeKplusNChannel::printTable();
+  G4CascadeKplusPChannel::printTable();
+  G4CascadeKzeroBarNChannel::printTable();
+  G4CascadeKzeroBarPChannel::printTable();
+  G4CascadeKzeroNChannel::printTable();
+  G4CascadeKzeroPChannel::printTable();
+  G4CascadeLambdaNChannel::printTable();
+  G4CascadeLambdaPChannel::printTable();
+  G4CascadeNNChannel::printTable();
+  G4CascadeNPChannel::printTable();
+  G4CascadePPChannel::printTable();
+  G4CascadePiMinusNChannel::printTable();
+  G4CascadePiMinusPChannel::printTable();
+  G4CascadePiPlusNChannel::printTable();
+  G4CascadePiPlusPChannel::printTable();
+  G4CascadePiZeroNChannel::printTable();
+  G4CascadePiZeroPChannel::printTable();
+  G4CascadeSigmaMinusNChannel::printTable();
+  G4CascadeSigmaMinusPChannel::printTable();
+  G4CascadeSigmaPlusNChannel::printTable();
+  G4CascadeSigmaPlusPChannel::printTable();
+  G4CascadeSigmaZeroNChannel::printTable();
+  G4CascadeSigmaZeroPChannel::printTable();
+  G4CascadeXiMinusNChannel::printTable();
+  G4CascadeXiMinusPChannel::printTable();
+  G4CascadeXiZeroNChannel::printTable();
+  G4CascadeXiZeroPChannel::printTable();
+}

trunk/source/processes/hadronic/models/cascade/cascade/src/G4EquilibriumEvaporator.cc

-              r1337
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+//
+// $Id: G4EquilibriumEvaporator.cc,v 1.32.2.1 2010/06/25 09:44:26 gunter Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4EquilibriumEvaporator.cc,v 1.48 2010/09/24 20:51:05 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
 …
 //              simple data members.  Rename timeToBigBang() to override
 //              base explosion().
+#define RUN
+// 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
 #include "G4EquilibriumEvaporator.hh"
 #include "G4BigBanger.hh"
+#include "G4CascadeInterpolator.hh"
 #include "G4CollisionOutput.hh"
-#include "G4CascadeInterpolator.hh"
 #include "G4Fissioner.hh"
-#include "G4HadTmpUtil.hh"
 #include "G4InuclNuclei.hh"
 #include "G4InuclSpecialFunctions.hh"
 #include "G4LorentzConvertor.hh"
 #include "G4LorentzVector.hh"
-#include "G4NucleiProperties.hh"
 #include "G4ThreeVector.hh"
 …
 G4EquilibriumEvaporator::G4EquilibriumEvaporator()
+  : G4VCascadeCollider("G4EquilibriumEvaporator"),
+    theFissioner(new G4Fissioner),
+    theBigBanger(new G4BigBanger) {}
+G4EquilibriumEvaporator::~G4EquilibriumEvaporator() {
+  delete theFissioner;
+  delete theBigBanger;
+}
+  : G4CascadeColliderBase("G4EquilibriumEvaporator") {}
+G4EquilibriumEvaporator::~G4EquilibriumEvaporator() {}
 …
                                       G4InuclParticle* target,
                                       G4CollisionOutput& output) {
   if (verboseLevel > 3) {
+  if (verboseLevel) {
     G4cout << " >>> G4EquilibriumEvaporator::collide" << G4endl;
+  }
 …
+  }
+  if (verboseLevel > 1) {
+    G4cout << " evaporating target: " << G4endl;
+    target->printParticle();
+  }
+  theFissioner.setVerboseLevel(verboseLevel);
+  theBigBanger.setVerboseLevel(verboseLevel);
   // simple implementation of the equilibium evaporation a la Dostrowski
   const G4double huge_num = 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 G4double AN[6] = { 1.0, 1.0, 2.0, 3.0, 3.0, 4.0 };
   const G4double Q[6] = { 0.0, 1.0, 1.0, 1.0, 2.0, 2.0 };
+  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;
-#ifdef RUN
   const G4double cut_off_energy = 0.1;
-#else
-  const G4double cut_off_energy = 100000.0;
-#endif
   const G4double BF = 0.0242;
 …
   const G4int itry_gam_max = 100;
+  std::vector<G4double> W(8);
+  std::vector<G4double> A1(6);
+  std::vector<G4double> Z1(6);
+  std::vector<G4double> u(6);
+  std::vector<G4double> V(6);
+  std::vector<G4double> TM(6);
+  G4double coul_coeff;
+    G4double A = nuclei_target->getA();
+    G4double Z = nuclei_target->getZ();
+    G4LorentzVector PEX = nuclei_target->getMomentum();
+    G4double EEXS = nuclei_target->getExitationEnergy();
+  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, 1);
+  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;
+  // Buffer for parameter sets
+  std::pair<std::vector<G4double>, std::vector<G4double> > parms;
+  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, 6);
+      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];
+      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];
+      };
+    };
+    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 << " wn " << W[0] << " wp " << W[1] << " wd " << W[2] << G4endl
+             << " wh3 " << W[3] << " wt " << W[4] << " whe4 " << W[5] << G4endl
+             << " wfi " << 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);
+      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;
+        };
+        G4double S(0);
+        while (itry < itry_max) {
+          itry++;
+          S = EEXS * inuclRndm();
+          G4double 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)
+          G4InuclElementaryParticle particle(mom, 10, 6);
+          output.addOutgoingParticle(particle);
+          if (verboseLevel > 3) particle.printParticle();
+          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();
+      G4double S1 = 0.0;
+      for (G4int i = 0; i < 7; i++) {   // Select evaporation scenario
+        S1 += W[i];
+        if (SL <= S1) {
+          icase = i;
+          break;
+        };
+      };
+      if (icase < 6) { // particle or light nuclei escape
+        if (verboseLevel > 2)
+          G4cout << " particle/light-ion escape ?" << 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 (EPR > 0.0 && S > V[icase]) { // real escape
+            if (verboseLevel > 2)
+              G4cout << " escape itry1 " << itry1 << " icase "
+                     << icase << " S (MeV) " << S << G4endl;
+            if (S < EEXS) {             // Valid evaporate
+              S /= GeV;                         // Convert to Bertini units
+              if (icase < 2) {  // particle escape
+                G4int ptype = 2 - icase;
+                if (verboseLevel > 2)
+                  G4cout << " particle " << ptype << " escape" << G4endl;
+                G4InuclElementaryParticle particle(ptype);
+                particle.setModel(6);
+                // generate particle momentum
+                G4double mass = particle.getMass();
+                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];
+                particle.setMomentum(mom);
+                output.addOutgoingParticle(particle);
+                if (verboseLevel > 3) particle.printParticle();
+                ppout += mom;
+                bad = false;
+              } else {  // if (icase < 2)
+                if (verboseLevel > 2) {
+                  G4cout << " nucleus A " << AN[icase] << " Z " << Q[icase]
+                         << " escape icase " << icase << G4endl;
+                }
+                G4InuclNuclei nuclei(AN[icase], Q[icase]);
+                nuclei.setModel(6);
+                G4double mass = nuclei.getMass();
+                // 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];
+                nuclei.setMomentum(mom);
+                output.addOutgoingNucleus(nuclei);
+                if (verboseLevel > 3) nuclei.printParticle();
+                ppout += mom;
+                bad = false;
+              }         // if (icase < 2)
+            }           // if (S < EEXS)
+          }             // if (EPR > 0.0 ...
+        }               // while (itry1 ...
+        if (itry1 == itry_max || bad) try_again = false;
+      } else {  // if (icase < 6)
+        G4InuclNuclei nuclei(A, Z, EEXS);
+        nuclei.setModel(6);
+        if (verboseLevel > 2) {
+          G4cout << " fission: A " << A << " Z " << Z << " eexs " << EEXS
+                 << " Wn " << W[0] << " Wf " << W[6] << G4endl;
+        }
+        // Catch fission output separately for verification
+        G4CollisionOutput foutput;
+        theFissioner.collide(0, &nuclei, foutput);
+        if (foutput.getOutgoingNuclei().size() == 2) { // fission o'k
+          if (verboseLevel > 2) G4cout << " fission done in eql" << G4endl;
+          // Move fission fragments to lab frame for processing
+          foutput.boostToLabFrame(toTheNucleiSystemRestFrame);
+          // Now evaporate the fission fragments individually
+          G4bool prevDoChecks = doConservationChecks;   // Turn off checking
+          setConservationChecks(false);
+          std::vector<G4InuclNuclei> nuclea = foutput.getOutgoingNuclei();
+          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) {
       if (EEXS < 0.0) G4cout << " after noeq: eexs " << EEXS << G4endl;
+      G4cout << " ! itry_global " << itry_global_max << G4endl;
+    }
+    G4InuclElementaryParticle dummy(small_ekin, 1);
+    G4LorentzConvertor toTheNucleiSystemRestFrame;
+    toTheNucleiSystemRestFrame.setBullet(dummy);
+    G4LorentzVector ppout;
+    if (explosion(A, Z, EEXS)) {
+      if (verboseLevel > 3) {
+        G4cout << " big bang in eql start " << G4endl;
+      }
+      theBigBanger->collide(0, target, output);
+      return;
+    } else {
+      if (A >= 100.0) {
+        coul_coeff = 1.4;
+      } else {
+        coul_coeff = 1.2;
+      };
+      G4InuclNuclei dummy_nuc;
+      G4double EEXS_new;
+      G4LorentzVector pin = PEX;
+      pin.setE(pin.e() + 0.001 * EEXS);
+      G4bool try_again = true;
+      G4bool fission_open = true;
+      G4double nuc_mass;
+      G4int itry_global = 0;
+      // Buffer for parameter sets
+      std::pair<std::vector<G4double>, std::vector<G4double> > parms;
+      while (try_again && itry_global < itry_global_max) {
+        itry_global++;
+        if (verboseLevel > 2){
+          G4cout << " A " << A << " Z " << Z << " EEXS " << EEXS << G4endl;
+        }
+        nuc_mass = dummy_nuc.getNucleiMass(A, Z);
+        PEX.setVectM(PEX.vect(), nuc_mass);
+        toTheNucleiSystemRestFrame.setTarget(PEX, nuc_mass);
+        toTheNucleiSystemRestFrame.toTheTargetRestFrame();
+        if (explosion(A, Z, EEXS)) { // big bang
+          if (verboseLevel > 2){
+            G4cout << " big bang in eql step " << G4endl;
+          }
+          G4InuclNuclei nuclei(PEX, A, Z);
+          nuclei.setModel(6);
+          nuclei.setExitationEnergy(EEXS);
+          theBigBanger->collide(0, &nuclei, output);
+          return;
+        } else { // normal chain
+          if (EEXS > cut_off_energy) {
+            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);
+            G4double DM0 = G4NucleiProperties::GetBindingEnergy(G4lrint(A), G4lrint(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];
+              TM[i] = -0.1;
+              if (goodRemnant(A1[i], Z1[i])) {
+                //              G4double QB = DM0 - bindingEnergy(A1[i], Z1[i]) - Q1[i];
+                G4double QB = DM0 - G4NucleiProperties::GetBindingEnergy(G4lrint(A1[i]), G4lrint(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];
+              };
+            };
+            G4double ue = 2.0 * std::sqrt(u1 * EEXS);
+            G4double prob_sum = 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] = W[0] * std::exp(TM1);
+              prob_sum += W[0];
+            } else {
+              W[0] = 0.0;
+            };
+            for (i = 1; i < 6; i++) {
+              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] = W[i] * std::exp(TM1);
+                prob_sum += W[i];
+              } else {
+                W[i] = 0.0;
+              };
+            };
+            // 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 << " wn = " << W[0] << " , wp = " << W[1] << " , wd = " << W[2] << G4endl
+                     << " wh3 " << W[3] << " wt " << W[4] << " whe4 " << W[5] << G4endl
+                     << " wfi " << 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);
+              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;
+                };
+                G4double S(0);
+                while (itry < itry_max) {
+                  itry++;
+                  S = EEXS * inuclRndm();
+                  G4double X1 = (S*S*S*S) * std::exp((EEXS - S) / T00);
+                  if (X1 > FMAX * inuclRndm()) break;
+                };
+                if (itry < itry_max) {
+                  // new photon escape
+                  G4InuclElementaryParticle particle(10);
+                  particle.setModel(6);
+                  G4double pmod = 0.001 * S;
+                  G4LorentzVector mom = generateWithRandomAngles(pmod, 0.);
+                  G4LorentzVector ex_mom;
+                  ex_mom.setVectM(-mom.vect(), nuc_mass);
+                  mom = toTheNucleiSystemRestFrame.backToTheLab(mom);
+                  ex_mom = toTheNucleiSystemRestFrame.backToTheLab(ex_mom);
+                  EEXS_new = 1000.0 * (PEX.e() + 0.001 * EEXS -
+                                       mom.e() - ex_mom.e());
+                  if (EEXS_new > 0.0) { // everything ok
+                    PEX = ex_mom;
+                    EEXS = EEXS_new;
+                    particle.setMomentum(mom);
+                    output.addOutgoingParticle(particle);
+                    ppout += mom;
+                  } else {
+                    if (itry_gam == itry_gam_max) try_again = false;
+                  };
+                } else {
+                  try_again = false;
+                };
+              };
+              try_again = false;
+            } else {
+              G4double SL = prob_sum * inuclRndm();
+              G4double S1 = 0.0;
+              for (G4int i = 0; i < 7; i++) {
+                S1 += W[i];
+                if (SL <= S1) {
+                  icase = i;
+                  break;
+                };
+              };
+              if (icase < 6) { // particle or light nuclei escape
+                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 (EPR > 0.0 && S > V[icase]) { // real escape
+                    S = 0.001 * S;
+                    if (icase < 2) { // particle escape
+                      G4int ptype = 2 - icase;
+                      G4InuclElementaryParticle particle(ptype);
+                      particle.setModel(6);
+                      G4double mass = particle.getMass();
+                      // generate particle momentum
+                      G4double pmod = std::sqrt((2.0 * mass + S) * S);
+                      G4LorentzVector mom = generateWithRandomAngles(pmod, mass);
+                      G4double new_nuc_mass =
+                        dummy_nuc.getNucleiMass(A1[icase], Z1[icase]);
+                      G4LorentzVector ex_mom;
+                      ex_mom.setVectM(-mom.vect(), new_nuc_mass);
+                      mom = toTheNucleiSystemRestFrame.backToTheLab(mom);
+                      ex_mom = toTheNucleiSystemRestFrame.backToTheLab(ex_mom);
+                      EEXS_new = 1000.0 * (PEX.e() + 0.001 * EEXS -
+                                           mom.e() - ex_mom.e());
+                      if (EEXS_new > 0.0) { // everything ok
+                        PEX = ex_mom;
+                        EEXS = EEXS_new;
+                        A = A1[icase];
+                        Z = Z1[icase];
+                        particle.setMomentum(mom);
+                        output.addOutgoingParticle(particle);
+                        ppout += mom;
+                        bad = false;
+                      };
+                    } else {
+                      G4InuclNuclei nuclei(AN[icase], Q[icase]);
+                      nuclei.setModel(6);
+                      G4double mass = nuclei.getMass();
+                      // generate particle momentum
+                      G4double pmod = std::sqrt((2.0 * mass + S) * S);
+                      G4LorentzVector mom = generateWithRandomAngles(pmod,mass);
+                      G4double new_nuc_mass =
+                        dummy_nuc.getNucleiMass(A1[icase], Z1[icase]);
+                      G4LorentzVector ex_mom;
+                      ex_mom.setVectM(-mom.vect(), new_nuc_mass);
+                      mom = toTheNucleiSystemRestFrame.backToTheLab(mom);
+                      ex_mom = toTheNucleiSystemRestFrame.backToTheLab(ex_mom);
+                      EEXS_new = 1000.0 * (PEX.e() + 0.001 * EEXS -
+                                           mom.e() - ex_mom.e());
+                      if (EEXS_new > 0.0) { // everything ok
+                        PEX = ex_mom;
+                        EEXS = EEXS_new;
+                        A = A1[icase];
+                        Z = Z1[icase];
+                        ppout += mom;
+                        nuclei.setExitationEnergy(0.0);
+                        nuclei.setMomentum(mom);
+                        output.addTargetFragment(nuclei);
+                        bad = false;
+                      };
+                    };
+                  };
+                };
+                if (itry1 == itry_max || bad)  try_again = false;
+              } else { // fission
+                G4InuclNuclei nuclei(A, Z);
+                nuclei.setModel(6);
+                nuclei.setExitationEnergy(EEXS);
+                if (verboseLevel > 2){
+                  G4cout << " fission: A " << A << " Z " << Z << " eexs " << EEXS <<
+                    " Wn " << W[0] << " Wf " << W[6] << G4endl;
+                }
+                // Catch fission output separately for verification
+                G4CollisionOutput foutput;
+                theFissioner->collide(0, &nuclei, foutput);
+                if (foutput.getNucleiFragments().size() == 2) { // fission o'k
+                  // Copy fragment list and convert back to the lab
+                  std::vector<G4InuclNuclei> nuclea(foutput.getNucleiFragments());
+                  G4LorentzVector mom;
+                  for(G4int i = 0; i < 2; i++) {
+                    mom = toTheNucleiSystemRestFrame.backToTheLab(nuclea[i].getMomentum());
+                    nuclea[i].setMomentum(mom);
+                  }
+                  this->collide(0, &nuclea[0], output);
+                  this->collide(0, &nuclea[1], output);
+                  return;
+                } else { // fission forbidden now
+                  fission_open = false;
+                };
+              };
+            };
+          } else {
+            try_again = false;
+          };
+        };
+      };
+      // 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;
+      G4InuclNuclei nuclei(pnuc, A, Z);
+      nuclei.setModel(6);
+      pnuc = nuclei.getMomentum();
+      G4double eout = pnuc.e() + ppout.e();
+      G4double eex_real = 1000.0 * (pin.e() - eout);
+      nuclei.setExitationEnergy(eex_real);
+      output.addTargetFragment(nuclei);
+    }
+  }
+  G4LorentzVector pnuc = pin - ppout;
+  G4InuclNuclei nuclei(pnuc, A, Z, EEXS, 6);
+  /***** THIS SHOULD NOT BE NECESSARY IF EEXS WAS COMPUTED RIGHT
+  pnuc = nuclei.getMomentum();
+  G4double eout = pnuc.e() + ppout.e();
+  G4double eex_real = 1000.0 * (pin.e() - eout);
+  nuclei.setExitationEnergy(eex_real);
+  *****/
+  if (verboseLevel > 3) {
+    G4cout << " remaining nucleus " << G4endl;
+    nuclei.printParticle();
+  }
+  output.addOutgoingNucleus(nuclei);
+  validateOutput(0, target, output);            // Check energy conservation
   return;
+}
 G4bool G4EquilibriumEvaporator::explosion(G4double a,
                                           G4double z,
+G4bool G4EquilibriumEvaporator::explosion(G4int a,
+                                          G4int z,
                                           G4double e) const {
   if (verboseLevel > 3) {
 …
   // Different criteria from base class, since nucleus more "agitated"
   G4bool bigb = (!(a >= 12 && z >= 6.0 && z < 3.0 * (a - z)) &&
                  (e >= be_cut * G4NucleiProperties::GetBindingEnergy(G4lrint(a), G4lrint(z)))
+  G4bool bigb = (!(a >= 12 && z >= 0 && z < 3*(a-z)) &&
+                 (e >= be_cut * bindingEnergy(a,z))
                  );
 …
+}
 G4bool G4EquilibriumEvaporator::goodRemnant(G4double a,
                                             G4double z) const {
+G4bool G4EquilibriumEvaporator::goodRemnant(G4int a,
+                                            G4int z) const {
   if (verboseLevel > 3) {
     G4cout << " >>> G4EquilibriumEvaporator::goodRemnant" << G4endl;
+  }
   return a > 1.0 && z > 0.0 && a > z;
+  return a > 1 && z > 0 && a > z;
+}
 G4double G4EquilibriumEvaporator::getQF(G4double x,
                                         G4double x2,
                                         G4double a,
                                         G4double ,
+                                        G4int a,
+                                        G4int /*z*/,
                                         G4double ) const {
   if (verboseLevel > 3) {
 …
 G4double G4EquilibriumEvaporator::getAF(G4double ,
                                         G4double ,
                                         G4double ,
+                                        G4int /*a*/,
+                                        G4int /*z*/,
                                         G4double e) const {
 …
+}
 G4double G4EquilibriumEvaporator::getPARLEVDEN(G4double ,
                                                G4double ) const {
+G4double G4EquilibriumEvaporator::getPARLEVDEN(G4int /*a*/,
+                                               G4int /*z*/) const {
   if (verboseLevel > 3) {
 …
+}
 G4double G4EquilibriumEvaporator::getE0(G4double ) const {
+G4double G4EquilibriumEvaporator::getE0(G4int /*a*/) const {
   if (verboseLevel > 3) {

trunk/source/processes/hadronic/models/cascade/cascade/src/G4EvaporationInuclCollider.cc

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4EvaporationInuclCollider.cc,v 1.11 2010/06/25 09:44:28 gunter Exp $
 // Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4EvaporationInuclCollider.cc,v 1.12 2010/07/14 15:41:13 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
 …
 // 20100517  M. Kelsey -- Inherit from common base class, make other colliders
 //              simple data members.  Eliminate unnecessary G4InuclNuclei ctor.
+// 20100714  M. Kelsey -- Switch to new G4CascadeColliderBase class
 #include "G4EvaporationInuclCollider.hh"
 …
 G4EvaporationInuclCollider::G4EvaporationInuclCollider()
   : G4VCascadeCollider("G4EvaporationInuclCollider"),
+  : G4CascadeColliderBase("G4EvaporationInuclCollider"),
     theEquilibriumEvaporator(new G4EquilibriumEvaporator) {}

trunk/source/processes/hadronic/models/cascade/cascade/src/G4FissionStore.cc

-              r1315
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4FissionStore.cc,v 1.16 2010/10/19 21:33:58 mkelsey Exp $
 //
+// 20100728  Move ::addConfig() implementation to .cc file
 #include "G4FissionStore.hh"
+#include "G4FissionConfiguration.hh"
 #include <cmath>
+G4FissionStore::G4FissionStore()
+  : verboseLevel(0){
+G4FissionStore::G4FissionStore() : verboseLevel(0) {
+  if (verboseLevel > 1)
+    G4cout << " >>> G4FissionStore::G4FissionStore" << G4endl;
+}
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4FissionStore::G4FissionStore" << G4endl;
+  }
+void G4FissionStore::addConfig(G4double a, G4double z, G4double ez,
+                               G4double ek, G4double ev) {
+  G4FissionConfiguration config(a, z, ez, ek, ev);
+  configurations.push_back(config);
+  if (verboseLevel > 2) config.print();
+}
 G4FissionConfiguration G4FissionStore::generateConfiguration(G4double amax,
                                                              G4double rand) const {
+  if (verboseLevel > 3) {
+  if (verboseLevel > 1)
     G4cout << " >>> G4FissionStore::generateConfiguration" << G4endl;
+  }
   const G4double small = -30.0;
   G4double totProb = 0.0;
   std::vector<G4double> probs(configurations.size());
+  std::vector<G4double> probs(size());
+// G4cout << " amax " << amax << " ic " << configurations.size() << G4endl;
+  if (verboseLevel > 3)
+    G4cout << " amax " << amax << " ic " << size() << G4endl;
   for (G4int i = 0; i < G4int(configurations.size()); i++) {
+  for (G4int i = 0; i < size(); i++) {
     G4double ez = configurations[i].ezet;
     G4double pr = ez - amax;
 …
   G4int igen = 0;
   while (probs[igen] <= st && igen < G4int(configurations.size())) igen++;
+  while (probs[igen] <= st && igen < size()) igen++;
 // G4cout << " igen " << igen << G4endl;
+  if (verboseLevel > 3) G4cout << " igen " << igen << G4endl;
   return configurations[igen];

trunk/source/processes/hadronic/models/cascade/cascade/src/G4Fissioner.cc

-              r1337
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+//
+// $Id: G4Fissioner.cc,v 1.28.2.1 2010/06/25 09:44:30 gunter Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4Fissioner.cc,v 1.37 2010/09/24 20:51:05 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
 …
 // 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
 // 20100517  M. Kelsey -- Inherit from common base class
+// 20100622  M. Kelsey -- Use local "bindingEnergy()" to call through
+// 20100711  M. Kelsey -- Add energy-conservation checking, reduce if-cascades
+// 20100713  M. Kelsey -- Don't add excitation energy to mass (already there)
+// 20100714  M. Kelsey -- Move conservation checking to base class
+// 20100728  M. Kelsey -- Make fixed arrays static, move G4FissionStore to data
+//              member and reuse
+// 20100914  M. Kelsey -- Migrate to integer A and Z
 #include "G4Fissioner.hh"
 #include "G4CollisionOutput.hh"
+#include "G4HadTmpUtil.hh"
 #include "G4InuclNuclei.hh"
 #include "G4InuclParticle.hh"
 #include "G4FissionStore.hh"
 #include "G4FissionConfiguration.hh"
-#include "G4NucleiProperties.hh"
-#include "G4HadTmpUtil.hh"
 #include "G4InuclSpecialFunctions.hh"
 …
 G4Fissioner::G4Fissioner() : G4VCascadeCollider("G4Fissioner") {}
+G4Fissioner::G4Fissioner() : G4CascadeColliderBase("G4Fissioner") {}
 void G4Fissioner::collide(G4InuclParticle* /*bullet*/,
                           G4InuclParticle* target,
                           G4CollisionOutput& output) {
   if (verboseLevel > 3) {
+  if (verboseLevel) {
     G4cout << " >>> G4Fissioner::collide" << G4endl;
+  }
 …
   //  const G4int itry_max = 1000;
+  if (G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target)) {
+    if (verboseLevel > 3) {
+      G4cout << " Fissioner input " << G4endl;
+      nuclei_target->printParticle();
+    }
+    G4double A = nuclei_target->getA();
+    G4double Z = nuclei_target->getZ();
+    G4double EEXS = nuclei_target->getExitationEnergy();
+    G4double mass_in = nuclei_target->getMass();
+    G4double e_in = mass_in + 0.001 * EEXS;
+    G4double PARA = 0.055 * G4cbrt(A*A) * (G4cbrt(A - Z) + G4cbrt(Z));
+    G4double TEM = std::sqrt(EEXS / PARA);
+    G4double TETA = 0.494 * G4cbrt(A) * TEM;
+    TETA = TETA / std::sinh(TETA);
+    if (A < 246.0) PARA += (nucleiLevelDensity(A) - PARA) * TETA;
+    G4double A1 = G4int(A / 2.0 + 1.1);
+    G4double Z1;
+    G4double A2 = A - A1;
+    G4double ALMA = -1000.0;
+    //    G4double DM1 = bindingEnergy(A, Z);
+    G4double DM1 = G4NucleiProperties::GetBindingEnergy(G4lrint(A), G4lrint(Z));
+    G4double EVV = EEXS - DM1;
+    G4double DM2 = bindingEnergyAsymptotic(A, Z);
+    G4double DTEM = (A < 220.0 ? 0.5 : 1.15);
+    TEM += DTEM;
+    std::vector<G4double> AL1(2, -0.15);
+    std::vector<G4double> BET1(2, 0.05);
+    G4FissionStore fissionStore;
+    G4double R12 = G4cbrt(A1) + G4cbrt(A2);
+    for (G4int i = 0; i < 50 && A1 > 30.0; i++) {
+      A1 -= 1.0;
+      A2 = A - A1;
+      G4double X3 = 1.0 / G4cbrt(A1);
+      G4double X4 = 1.0 / G4cbrt(A2);
+      Z1 = G4int(getZopt(A1, A2, Z, X3, X4, R12)) - 1.0;
+      std::vector<G4double> EDEF1(2);
+      G4double Z2 = Z - Z1;
+      G4double VPOT, VCOUL;
+      potentialMinimization(VPOT, EDEF1, VCOUL, A1, A2, Z1, Z2, AL1, BET1, R12);
+      //      G4double DM3 = bindingEnergy(A1, Z1);
+      G4double DM3 = G4NucleiProperties::GetBindingEnergy(G4lrint(A1), G4lrint(Z1));
+      G4double DM4 = bindingEnergyAsymptotic(A1, Z1);
+      //      G4double DM5 = bindingEnergy(A2, Z2);
+      G4double DM5 = G4NucleiProperties::GetBindingEnergy(G4lrint(A2), G4lrint(Z2));
+      G4double DM6 = bindingEnergyAsymptotic(A2, Z2);
+      G4double DMT1 = DM4 + DM6 - DM2;
+      G4double DMT = DM3 + DM5 - DM1;
+      G4double EZL = EEXS + DMT - VPOT;
+  G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target);
+  if (!nuclei_target) {
+    G4cerr << " >>> G4Fissioner -> target is not nuclei " << G4endl;
+    return;
+  }
+  if (verboseLevel > 1) {
+    G4cout << " Fissioner input " << G4endl;
+    nuclei_target->printParticle();
+  }
+  // Initialize buffer for fission possibilities
+  fissionStore.setVerboseLevel(verboseLevel);
+  fissionStore.clear();
+  G4int A = nuclei_target->getA();
+  G4int Z = nuclei_target->getZ();
+  G4double EEXS = nuclei_target->getExitationEnergy();
+  G4double mass_in = nuclei_target->getMass();
+  G4double e_in = mass_in; /**** + 0.001 * EEXS; ****/  // Mass includes EEXS
+  G4double PARA = 0.055 * G4cbrt(A*A) * (G4cbrt(A-Z) + G4cbrt(Z));
+  G4double TEM = std::sqrt(EEXS / PARA);
+  G4double TETA = 0.494 * G4cbrt(A) * TEM;
+  TETA = TETA / std::sinh(TETA);
+  if (A < 246) PARA += (nucleiLevelDensity(A) - PARA) * TETA;
+  G4int A1 = A/2 + 1;
+  G4int Z1;
+  G4int A2 = A - A1;
+  G4double ALMA = -1000.0;
+  G4double DM1 = bindingEnergy(A,Z);
+  G4double EVV = EEXS - DM1;
+  G4double DM2 = bindingEnergyAsymptotic(A, Z);
+  G4double DTEM = (A < 220 ? 0.5 : 1.15);
+  TEM += DTEM;
+  static std::vector<G4double> AL1(2, -0.15);
+  static std::vector<G4double> BET1(2, 0.05);
+  G4double R12 = G4cbrt(A1) + G4cbrt(A2);
+  for (G4int i = 0; i < 50 && A1 > 30; i++) {
+    A1--;
+    A2 = A - A1;
+    G4double X3 = 1.0 / G4cbrt(A1);
+    G4double X4 = 1.0 / G4cbrt(A2);
+    Z1 = G4lrint(getZopt(A1, A2, Z, X3, X4, R12) - 1.);
+    std::vector<G4double> EDEF1(2);
+    G4int Z2 = Z - Z1;
+    G4double VPOT, VCOUL;
+      if(EZL > 0.0) { // generate fluctuations
+        //  faster, using randomGauss
+        G4double C1 = std::sqrt(getC2(A1, A2, X3, X4, R12) / TEM);
+        G4double DZ = randomGauss(C1);
+        DZ = DZ > 0.0 ? G4int(DZ + 0.5) : -G4int(std::fabs(DZ - 0.5));
+        Z1 += DZ;
+        Z2 -= DZ;
+        G4double DEfin = randomGauss(TEM);
+        G4double EZ = (DMT1 + (DMT - DMT1) * TETA - VPOT + DEfin) / TEM;
+        if (EZ >= ALMA) ALMA = EZ;
+        G4double EK = VCOUL + DEfin + 0.5 * TEM;
+        //      G4double EV = EVV + bindingEnergy(A1, Z1) + bindingEnergy(A2, Z2) - EK;
+        G4double EV = EVV
+                    + G4NucleiProperties::GetBindingEnergy(G4lrint(A1), G4lrint(Z1))
+                    + G4NucleiProperties::GetBindingEnergy(G4lrint(A2), G4lrint(Z2))
+                    - EK;
+        if (EV > 0.0) fissionStore.addConfig(A1, Z1, EZ, EK, EV);
+      };
+    };
+    G4int store_size = fissionStore.size();
+    if (store_size > 0) {
+      G4FissionConfiguration config =
+        fissionStore.generateConfiguration(ALMA, inuclRndm());
+      A1 = config.afirst;
+      A2 = A - A1;
+      Z1 = config.zfirst;
+      G4double Z2 = Z - Z1;
+      G4InuclNuclei nuclei1(A1, Z1);
+      nuclei1.setModel(7); // sign in the modelId (=G4Fissioner)
+      G4InuclNuclei nuclei2(A2, Z2);
+      nuclei2.setModel(7);
+      G4double mass1 = nuclei1.getMass();
+      G4double mass2 = nuclei2.getMass();
+      G4double EK = config.ekin;
+      G4double pmod = std::sqrt(0.001 * EK * mass1 * mass2 / mass_in);
+      G4LorentzVector mom1 = generateWithRandomAngles(pmod, mass1);
+      G4LorentzVector mom2; mom2.setVectM(-mom1.vect(), mass2);
+      G4double e_out = mom1.e() + mom2.e();
+      G4double EV = 1000.0 * (e_in - e_out) / A;
+      if (EV > 0.0) {
+        G4double EEXS1 = EV*A1;
+        G4double EEXS2 = EV*A2;
+        G4InuclNuclei nuclei1(mom1, A1, Z1);
+        nuclei1.setModel(7);
+        nuclei1.setExitationEnergy(EEXS1);
+        nuclei1.setEnergy();
+        output.addTargetFragment(nuclei1);
+        G4InuclNuclei nuclei2(mom2, A2, Z2);
+        nuclei2.setModel(7);
+        nuclei2.setExitationEnergy(EEXS2);
+        nuclei2.setEnergy();
+        output.addTargetFragment(nuclei2);
+        if (verboseLevel > 3) {
+          nuclei1.printParticle();
+          nuclei2.printParticle();
+        }
+      };
+    };
+  } else {
+    G4cout << " Fissioner -> target is not nuclei " << G4endl;
+  };
+  return;
+    potentialMinimization(VPOT, EDEF1, VCOUL, A1, A2, Z1, Z2, AL1, BET1, R12);
+    G4double DM3 = bindingEnergy(A1,Z1);
+    G4double DM4 = bindingEnergyAsymptotic(A1, Z1);
+    G4double DM5 = bindingEnergy(A2,Z2);
+    G4double DM6 = bindingEnergyAsymptotic(A2, Z2);
+    G4double DMT1 = DM4 + DM6 - DM2;
+    G4double DMT = DM3 + DM5 - DM1;
+    G4double EZL = EEXS + DMT - VPOT;
+    if(EZL > 0.0) { // generate fluctuations
+      //  faster, using randomGauss
+      G4double C1 = std::sqrt(getC2(A1, A2, X3, X4, R12) / TEM);
+      G4double DZ = randomGauss(C1);
+      DZ = DZ > 0.0 ? DZ + 0.5 : -std::fabs(DZ - 0.5);
+      Z1 += G4int(DZ);
+      Z2 -= G4int(DZ);
+      G4double DEfin = randomGauss(TEM);
+      G4double EZ = (DMT1 + (DMT - DMT1) * TETA - VPOT + DEfin) / TEM;
+      if (EZ >= ALMA) ALMA = EZ;
+      G4double EK = VCOUL + DEfin + 0.5 * TEM;
+      G4double EV = EVV + bindingEnergy(A1,Z1) + bindingEnergy(A2,Z2) - EK;
+      if (EV > 0.0) fissionStore.addConfig(A1, Z1, EZ, EK, EV);
+    };
+  };
+  G4int store_size = fissionStore.size();
+  if (store_size == 0) return;          // No fission products
+  G4FissionConfiguration config =
+    fissionStore.generateConfiguration(ALMA, inuclRndm());
+  A1 = G4int(config.afirst);
+  A2 = A - A1;
+  Z1 = G4int(config.zfirst);
+  G4int Z2 = Z - Z1;
+  G4double mass1 = G4InuclNuclei::getNucleiMass(A1,Z1);
+  G4double mass2 = G4InuclNuclei::getNucleiMass(A2,Z2);
+  G4double EK = config.ekin;
+  G4double pmod = std::sqrt(0.001 * EK * mass1 * mass2 / mass_in);
+  G4LorentzVector mom1 = generateWithRandomAngles(pmod, mass1);
+  G4LorentzVector mom2; mom2.setVectM(-mom1.vect(), mass2);
+  G4double e_out = mom1.e() + mom2.e();
+  G4double EV = 1000.0 * (e_in - e_out) / A;
+  if (EV <= 0.0) return;                // No fission energy
+  G4double EEXS1 = EV*A1;
+  G4double EEXS2 = EV*A2;
+  G4InuclNuclei nuclei1(mom1, A1, Z1, EEXS1, 7);
+  G4InuclNuclei nuclei2(mom2, A2, Z2, EEXS2, 7);
+  // Pass only last two nuclear fragments
+  static std::vector<G4InuclNuclei> frags(2);           // Always the same size!
+  frags[0] = nuclei1;
+  frags[1] = nuclei2;
+  validateOutput(0, target, frags);             // Check energy conservation
+  output.addOutgoingNuclei(frags);
+}
 G4double G4Fissioner::getC2(G4double A1,
                             G4double A2,
+G4double G4Fissioner::getC2(G4int A1,
+                            G4int A2,
                             G4double X3,
                             G4double X4,
 …
+}
 G4double G4Fissioner::getZopt(G4double A1,
                               G4double A2,
                               G4double ZT,
+G4double G4Fissioner::getZopt(G4int A1,
+                              G4int A2,
+                              G4int ZT,
                               G4double X3,
                               G4double X4,
 …
                                         std::vector<G4double> & ED,
                                         G4double& VC,
                                         G4double AF,
                                         G4double AS,
                                         G4double ZF,
                                         G4double ZS,
+                                        G4int AF,
+                                        G4int AS,
+                                        G4int ZF,
+                                        G4int ZS,
                                         std::vector<G4double>& AL1,
                                         std::vector<G4double>& BET1,
 …
   const G4double DS1 = 0.3;
   const G4double DS2 = 1.0 / DS1 / DS1;
+  G4double A1[2];
+  A1[0] = AF;
+  A1[1] = AS;
+  G4double Z1[2];
+  Z1[0] = ZF;
+  Z1[1] = ZS;
+  G4int A1[2] = { AF, AS };
+  G4int Z1[2] = { ZF, ZS };
   G4double D = 1.01844 * ZF * ZS;
   G4double D0 = 1.0e-3 * D;

trunk/source/processes/hadronic/models/cascade/cascade/src/G4InteractionCase.cc

r1337	r1340
25	25	//
26	26	// $Id: G4InteractionCase.cc,v 1.2 2010/06/25 09:44:32 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100518 M. Kelsey -- Move code from Colliders' "bulletTargetSetter()"

trunk/source/processes/hadronic/models/cascade/cascade/src/G4IntraNucleiCascader.cc

-              r1337
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+//
+// $Id: G4IntraNucleiCascader.cc,v 1.35.2.1 2010/06/25 09:44:34 gunter Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4IntraNucleiCascader.cc,v 1.68 2010/09/25 06:44:30 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
 …
 // 20100517  M. Kelsey -- Inherit from common base class, make other colliders
 //              simple data members
+// 20100616  M. Kelsey -- Add reporting of final residual particle
+// 20100617  M. Kelsey -- Remove "RUN" preprocessor flag and all "#else" code,
+//              pass verbosity to collider.  Make G4NucleiModel a data member,
+//              instead of creating and deleting on every cycle.
+// 20100620  M. Kelsey -- Improved diagnostic messages.  Simplify kinematics
+//              of recoil nucleus.
+// 20100622  M. Kelsey -- Use local "bindingEnergy()" to call through.
+// 20100623  M. Kelsey -- Undo G4NucleiModel change from 0617.  Does not work
+//              properly across multiple interactions.
+// 20100627  M. Kelsey -- Protect recoil nucleus energy from floating roundoff
+//              by setting small +ve or -ve values to zero.
+// 20100701  M. Kelsey -- Let excitation energy be handled by G4InuclNuclei,
+//              allow for ground-state recoil (goodCase == true for Eex==0.)
+// 20100702  M. Kelsey -- Negative energy recoil should be rejected
+// 20100706  D. Wright -- Copy "abandoned" cparticles to output list, copy
+//              mesonic "excitons" to output list; should be absorbed, fix up
+//              diagnostic messages.
+// 20100713  M. Kelsey -- Add more diagnostics for Dennis' changes.
+// 20100714  M. Kelsey -- Switch to new G4CascadeColliderBase class, remove
+//              sanity check on afin/zfin (not valid).
+// 20100715  M. Kelsey -- Add diagnostic for ekin_in vs. actual ekin; reduce
+//              KE across Coulomb barrier.  Rearrange end-of-loop if blocks,
+//              add conservation check at end.
+// 20100716  M. Kelsey -- Eliminate inter_case; use base-class functionality.
+//              Add minimum-fragment requirement for recoil, in order to
+//              allow for momentum balancing
+// 20100720  M. Kelsey -- Make EPCollider pointer member
+// 20100721  M. Kelsey -- Turn on conservation checks unconditionally (override
+//              new G4CASCADE_CHECK_ECONS setting
+// 20100722  M. Kelsey -- Move cascade output buffers to .hh file
+// 20100728  M. Kelsey -- Make G4NucleiModel data member for persistence,
+//              delete colliders in destructor
+// 20100906  M. Kelsey -- Hide "non-physical fragment" behind verbose flag
+// 20100907  M. Kelsey -- Add makeResidualFragment function to create object
+// 20100909  M. Kelsey -- Remove all local "fragment" stuff, use RecoilMaker.
+//              move goodCase() to RecoilMaker.
+// 20100910  M. Kelsey -- Use RecoilMaker::makeRecoilFragment().
+// 20100915  M. Kelsey -- Define functions to deal with trapped particles,
+//              move the exciton container to a data member
+// 20100916  M. Kelsey -- Put decay photons directly onto output list
+// 20100921  M. Kelsey -- Migrate to RecoilMaker::makeRecoilNuclei().
+// 20100924  M. Kelsey -- Minor shuffling of post-cascade recoil building.
+//              Create G4Fragment for recoil and store in output.
 #include "G4IntraNucleiCascader.hh"
-#define RUN
 #include "G4CascadParticle.hh"
+#include "G4CascadeRecoilMaker.hh"
+#include "G4ElementaryParticleCollider.hh"
 #include "G4CollisionOutput.hh"
+#include "G4ElementaryParticleCollider.hh"
+#include "G4DecayTable.hh"
+#include "G4DecayProducts.hh"
 #include "G4HadTmpUtil.hh"
 #include "G4InuclElementaryParticle.hh"
 #include "G4InuclNuclei.hh"
 #include "G4InuclSpecialFunctions.hh"
+#include "G4LorentzConvertor.hh"
 #include "G4NucleiModel.hh"
-#include "G4NucleiProperties.hh"
 #include "G4ParticleLargerEkin.hh"
 #include "Randomize.hh"
 …
 G4IntraNucleiCascader::G4IntraNucleiCascader()
+  : G4VCascadeCollider("G4IntraNucleiCascader"),
+    theElementaryParticleCollider(new G4ElementaryParticleCollider) {}
+  : G4CascadeColliderBase("G4IntraNucleiCascader"),
+    model(new G4NucleiModel),
+    theElementaryParticleCollider(new G4ElementaryParticleCollider),
+    theRecoilMaker(new G4CascadeRecoilMaker) {}
 G4IntraNucleiCascader::~G4IntraNucleiCascader() {
+  delete model;
   delete theElementaryParticleCollider;
+  delete theRecoilMaker;
+}
 …
 void G4IntraNucleiCascader::collide(G4InuclParticle* bullet,
                                     G4InuclParticle* target,
+                                    G4CollisionOutput& output) {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4IntraNucleiCascader::collide inter_case " << inter_case
+           << G4endl;
+  }
+                                    G4CollisionOutput& globalOutput) {
+  if (verboseLevel) G4cout << " >>> G4IntraNucleiCascader::collide " << G4endl;
   const G4int itry_max = 1000;
   const G4int reflection_cut = 500;
+  //  const G4double eexs_cut = 0.0001;
+  const G4double small_ekin = 0.001*MeV;        // Tolerance for round-off zero
+  const G4double quasielast_cut = 1*MeV;        // To recover elastic scatters
+  // Configure processing modules
+  model->setVerboseLevel(verboseLevel);
+  theElementaryParticleCollider->setVerboseLevel(verboseLevel);
+  theRecoilMaker->setVerboseLevel(verboseLevel);
+  theRecoilMaker->setTolerance(small_ekin);
+  // Energy/momentum conservation usually requires a recoiling nuclear fragment
+  // This cut will be increased on each "itry" if momentum could not balance.
+  G4double minimum_recoil_A = 0.;               // Nuclear fragment required
   if (verboseLevel > 3) {
 …
+  }
-#ifdef RUN
   G4InuclNuclei* tnuclei = dynamic_cast<G4InuclNuclei*>(target);
+  if (!tnuclei) {
+    if (verboseLevel)
+      G4cerr << " Target is not a nucleus.  Abandoning." << G4endl;
+    return;
+  }
+  interCase.set(bullet,target);         // Classify collision type
+  model->generateModel(tnuclei);
+  G4double coulombBarrier = 0.00126*tnuclei->getZ()/
+                                      (1.+G4cbrt(tnuclei->getA()));
+  G4LorentzVector momentum_in = bullet->getMomentum() + target->getMomentum();
+  if (verboseLevel > 3) {
+    model->printModel();
+    G4cout << " intitial momentum  E " << momentum_in.e() << " Px "
+           << momentum_in.x() << " Py " << momentum_in.y() << " Pz "
+           << momentum_in.z() << G4endl;
+  }
+  // Bullet may be nucleus or simple particle
   G4InuclNuclei* bnuclei = dynamic_cast<G4InuclNuclei*>(bullet);
   G4InuclElementaryParticle* bparticle =
                           dynamic_cast<G4InuclElementaryParticle*>(bullet);
-  G4NucleiModel model(tnuclei);
-  G4double coulombBarrier = 0.00126*tnuclei->getZ()/
-                                      (1.+G4cbrt(tnuclei->getA()));
-  G4LorentzVector momentum_in = bullet->getMomentum();
-  momentum_in.setE(momentum_in.e()+tnuclei->getMass());
-  G4double ekin_in;
-  if (verboseLevel > 3) {
-    model.printModel();
-    G4cout << " intitial momentum  E " << momentum_in.e() << " Px "
-           << momentum_in.x() << " Py " << momentum_in.y() << " Pz "
-           << momentum_in.z() << G4endl;
+  }
   G4int itry = 0;
   while (itry < itry_max) {
     itry++;
+    model.reset();
+    std::vector<G4CascadParticle> cascad_particles;
+    G4ExitonConfiguration theExitonConfiguration;
+    std::vector<G4InuclElementaryParticle> output_particles;
+    G4double afin = tnuclei->getA();
+    G4double zfin = tnuclei->getZ();
+    if (inter_case == 1) { // particle with nuclei
+      ekin_in = bparticle->getKineticEnergy();
+      zfin += bparticle->getCharge();
+      if (bparticle->baryon()) afin += 1.0;
+      cascad_particles.push_back(model.initializeCascad(bparticle));
+    } else { // nuclei with nuclei
+      ekin_in = bnuclei->getKineticEnergy();
+      G4double ab = bnuclei->getA();
+      G4double zb = bnuclei->getZ();
+      afin += ab;
+      zfin += zb;
+    if (verboseLevel > 2) {
+      G4cout << " itry " << itry << " inter_case " << interCase.code()
+             << G4endl;
+    }
+    model->reset();                     // Start new cascade process
+    output.reset();
+    cascad_particles.clear();
+    output_particles.clear();
+    theExitonConfiguration.clear();
+    if (interCase.hadNucleus()) {               // particle with nuclei
+      if (verboseLevel > 3)
+        G4cout << " bparticle charge " << bparticle->getCharge()
+               << " baryon number " << bparticle->baryon() << G4endl;
+      cascad_particles.push_back(model->initializeCascad(bparticle));
+    } else {                            // nuclei with nuclei
+      G4int ab = bnuclei->getA();
+      G4int zb = bnuclei->getZ();
       G4NucleiModel::modelLists all_particles;    // Buffer to receive lists
       model.initializeCascad(bnuclei, tnuclei, all_particles);
+      model->initializeCascad(bnuclei, tnuclei, all_particles);
       cascad_particles = all_particles.first;
+      for (G4int ip = 0; ip < G4int(all_particles.second.size()); ip++)
+        output_particles.push_back(all_particles.second[ip]);
+      output_particles.insert(output_particles.end(),
+                              all_particles.second.begin(),
+                              all_particles.second.end());
       if (cascad_particles.size() == 0) { // compound nuclei
-        G4int ia = G4int(ab + 0.5);
-        G4int iz = G4int(zb + 0.5);
         G4int i;
         for (i = 0; i < ia; i++) {
           G4int knd = i < iz ? 1 : 2;
+        for (i = 0; i < ab; i++) {
+          G4int knd = i < zb ? 1 : 2;
           theExitonConfiguration.incrementQP(knd);
         };
         G4int ihn = G4int(2.0 * (ab - zb) * inuclRndm() + 0.5);
         G4int ihz = G4int(2.0 * zb * inuclRndm() + 0.5);
+        G4int ihn = G4int(2 * (ab-zb) * inuclRndm() + 0.5);
+        G4int ihz = G4int(2 * zb * inuclRndm() + 0.5);
         for (i = 0; i < ihn; i++) theExitonConfiguration.incrementHoles(2);
         for (i = 0; i < ihz; i++) theExitonConfiguration.incrementHoles(1);
       };
     };
     std::vector<G4CascadParticle> new_cascad_particles;
+      }
+    }   // if (interCase ...
+    new_cascad_particles.clear();
     G4int iloop = 0;
     while (!cascad_particles.empty() && !model.empty()) {
+    while (!cascad_particles.empty() && !model->empty()) {
       iloop++;
+      if (verboseLevel > 3) {
+        G4cout << " Number of cparticles " << cascad_particles.size() << G4endl;
+      if (verboseLevel > 2) {
+        G4cout << " Iteration " << iloop << ": Number of cparticles "
+               << cascad_particles.size() << " last one: " << G4endl;
         cascad_particles.back().print();
+      }
       new_cascad_particles = model.generateParticleFate(cascad_particles.back(),
+      new_cascad_particles = model->generateParticleFate(cascad_particles.back(),
                                                         theElementaryParticleCollider);
       if (verboseLevel > 2) {
+        G4cout << " ew particles " << new_cascad_particles.size() << G4endl;
+      }
+        G4cout << " After generate fate: New particles "
+               << new_cascad_particles.size() << G4endl
+               << " Discarding last cparticle from list " << G4endl;
+      }
+      cascad_particles.pop_back();
       // handle the result of a new step
       if (new_cascad_particles.size() == 1) { // last particle goes without interaction
+        cascad_particles.pop_back();
+        if (model.stillInside(new_cascad_particles[0])) { // particle survives
+          if (verboseLevel > 3) {
+            G4cout << " still inside " << G4endl;
+          }
+          if (new_cascad_particles[0].getNumberOfReflections() < reflection_cut &&
+             model.worthToPropagate(new_cascad_particles[0])) { // it's ok
+            if (verboseLevel > 3) {
+              G4cout << " survives " << G4endl;
+            }
+            cascad_particles.push_back(new_cascad_particles[0]);
+          } else { // it becomes an exiton
+            if (verboseLevel > 3) {
+              G4cout << " becomes an exiton " << G4endl;
+            }
+            theExitonConfiguration.incrementQP(new_cascad_particles[0].getParticle().type());
+          };
+        const G4CascadParticle& currentCParticle = new_cascad_particles[0];
+        if (model->stillInside(currentCParticle)) {
+          if (verboseLevel > 3)
+            G4cout << " particle still inside nucleus " << G4endl;
+          if (currentCParticle.getNumberOfReflections() < reflection_cut &&
+              model->worthToPropagate(currentCParticle)) {
+            if (verboseLevel > 3) G4cout << " continue reflections " << G4endl;
+            cascad_particles.push_back(currentCParticle);
+          } else {
+            processTrappedParticle(currentCParticle);
+          }     // reflection or exciton
         } else { // particle about to leave nucleus - check for Coulomb barrier
+          if (verboseLevel > 3) {
+            G4cout << " Goes out " << G4endl;
+            new_cascad_particles[0].print();
+          }
+          G4InuclElementaryParticle currentParticle = new_cascad_particles[0].getParticle();
+          if (verboseLevel > 3) G4cout << " possible escape " << G4endl;
+          const G4InuclElementaryParticle& currentParticle =
+            currentCParticle.getParticle();
           G4double KE = currentParticle.getKineticEnergy();
           G4double mass = currentParticle.getMass();
           G4double Q = currentParticle.getCharge();
+          if (verboseLevel > 3)
+            G4cout << " KE " << KE << " barrier " << Q*coulombBarrier << G4endl;
           if (KE < Q*coulombBarrier) {
             // Calculate barrier penetration
             G4double CBP = 0.0;
             // if (KE > 0.0001) CBP = std::exp(-0.00126*tnuclei->getZ()*0.25*
             //   (1./KE - 1./coulombBarrier));
 …
             if (G4UniformRand() < CBP) {
+              if (verboseLevel > 3) {
+                G4cout << " tunneled " << G4endl;
+                currentParticle.printParticle();
+              }
+              // Tunnelling through barrier leaves KE unchanged
               output_particles.push_back(currentParticle);
             } else {
               theExitonConfiguration.incrementQP(currentParticle.type());
+              processTrappedParticle(currentCParticle);
+            }
           } else {
+            if (verboseLevel > 3) G4cout << " Goes out " << G4endl;
             output_particles.push_back(currentParticle);
+            /*****
+            // Adjust kinetic energy by height of potential (+ve or -ve)
+            G4double newKE = KE - Q*coulombBarrier;
+            output_particles.back().setKineticEnergy(newKE);
+            *****/
+            if (verboseLevel > 3) output_particles.back().printParticle();
+          }
+        }
       } else { // interaction
+        cascad_particles.pop_back();
+        for (G4int i = 0; i < G4int(new_cascad_particles.size()); i++)
+          cascad_particles.push_back(new_cascad_particles[i]);
+        std::pair<G4int, G4int> holes = model.getTypesOfNucleonsInvolved();
+        if (verboseLevel > 3)
+          G4cout << " interacted, adding new to list " << G4endl;
+        cascad_particles.insert(cascad_particles.end(),
+                                new_cascad_particles.begin(),
+                                new_cascad_particles.end());
+        std::pair<G4int, G4int> holes = model->getTypesOfNucleonsInvolved();
+        if (verboseLevel > 3)
+          G4cout << " adding new exciton holes " << holes.first << ","
+                 << holes.second << G4endl;
         theExitonConfiguration.incrementHoles(holes.first);
+        if (holes.second > 0) theExitonConfiguration.incrementHoles(holes.second);
+      };
+    };
+        if (holes.second > 0)
+          theExitonConfiguration.incrementHoles(holes.second);
+      }         // if (new_cascad_particles ...
+      // Evaluate nuclear residue
+      theRecoilMaker->collide(bullet,target,output_particles,cascad_particles);
+      G4double aresid = theRecoilMaker->getRecoilA();
+      if (verboseLevel > 2) {
+        G4cout << " cparticles remaining " << cascad_particles.size()
+               << " nucleus (model) has "
+               << model->getNumberOfNeutrons() << " n, "
+               << model->getNumberOfProtons() << " p "
+               << " residual fragment A " << aresid << G4endl;
+      }
+      if (aresid <= minimum_recoil_A) break;    // Must have minimum fragment
+    }           // while cascade-list and model
+    // Add left-over cascade particles to output
+    for (G4int i = 0; i < G4int(cascad_particles.size()); i++)
+      output_particles.push_back(cascad_particles[i].getParticle());
     // Cascade is finished. Check if it's OK.
     if (verboseLevel > 3) {
       G4cout << " Cascade finished  " << G4endl
              << " output_particles  " << output_particles.size() <<  G4endl;
+    }
+    G4LorentzVector momentum_out;
+    particleIterator ipart;
+    for (ipart = output_particles.begin(); ipart != output_particles.end(); ipart++) {
+      momentum_out += ipart->getMomentum();
+      zfin -= ipart->getCharge();
+      if (ipart->baryon()) afin -= 1.0;
+    };
+      particleIterator ipart = output_particles.begin();
+      for (; ipart != output_particles.end(); ipart++) {
+        ipart->printParticle();
+        G4cout << "  charge " << ipart->getCharge() << " baryon number "
+               << ipart->baryon() << G4endl;
+      }
+    }
+    // Use last created recoil fragment instead of re-constructing
+    G4int afin = theRecoilMaker->getRecoilA();
+    G4int zfin = theRecoilMaker->getRecoilZ();
+    // Sanity check before proceeding
+    if (!theRecoilMaker->goodFragment() && !theRecoilMaker->wholeEvent()) {
+      if (verboseLevel > 1)
+        G4cerr << " Recoil nucleus is not physical: A=" << afin << " Z="
+               << zfin << G4endl;
+      continue;                         // Discard event and try again
+    }
+    const G4LorentzVector& presid = theRecoilMaker->getRecoilMomentum();
+    if (verboseLevel > 1) {
+      G4cout << "  afin " << afin << " zfin " << zfin <<  G4endl;
+    }
+    if (afin == 0) break;               // Whole event fragmented, exit
+    if (afin == 1) {                    // Add bare nucleon to particle list
+      G4int last_type = (zfin==1) ? 1 : 2;      // proton=1, neutron=2
+      G4double mass = G4InuclElementaryParticle::getParticleMass(last_type);
+      G4double mres = presid.m();
+      // Check for sensible kinematics
+      if (mres-mass < -small_ekin) {            // Insufficient recoil energy
+        if (verboseLevel > 2) G4cerr << " unphysical recoil nucleon" << G4endl;
+        continue;
+      }
+      if (mres-mass > small_ekin) {             // Too much extra energy
+        if (verboseLevel > 2)
+          G4cerr << " extra energy with recoil nucleon" << G4endl;
+        // FIXME:  For now, we add the nucleon as unbalanced, and let
+        //         "SetOnShell" fudge things.  This should be abandoned.
+      }
+      G4InuclElementaryParticle last_particle(presid, last_type, 4);
+      if (verboseLevel > 3) {
+        G4cout << " adding recoiling nucleon to output list" << G4endl;
+        last_particle.printParticle();
+      }
+      output_particles.push_back(last_particle);
+    }
+    // Process recoil fragment for consistency, exit or reject
+    if (output_particles.size() == 1) {
+      G4double Eex = theRecoilMaker->getRecoilExcitation();
+      if (std::abs(Eex) < quasielast_cut) {
+        if (verboseLevel > 3) {
+          G4cout << " quasi-elastic scatter with " << Eex << " MeV recoil"
+                 << G4endl;
+        }
+        theRecoilMaker->setRecoilExcitation(Eex=0.);
+        if (verboseLevel > 3) {
+          G4cout << " Eex reset to " << theRecoilMaker->getRecoilExcitation()
+                 << G4endl;
+        }
+      }
+    }
+    if (theRecoilMaker->goodNucleus()) {
+      theRecoilMaker->addExcitonConfiguration(theExitonConfiguration);
+      G4Fragment* recoilFrag = theRecoilMaker->makeRecoilFragment();
+      if (!recoilFrag) {
+        G4cerr << "Got null pointer for recoil fragment!" << G4endl;
+        continue;
+      }
+      output.addRecoilFragment(*recoilFrag);
+      // TEMPORARY:  Add both frag and nuclei, for code validation
+      G4InuclNuclei* recoilNucl = theRecoilMaker->makeRecoilNuclei(4);
+      if (!recoilFrag) {
+        G4cerr << "Got null pointer for recoil nucleus!" << G4endl;
+        continue;
+      }
+      output.addOutgoingNucleus(*recoilNucl);
+      if (verboseLevel > 2)
+        G4cout << " adding recoil nucleus/fragment to output list" << G4endl;
+    }
+    // Put final-state particle in "leading order" for return
+    std::sort(output_particles.begin(), output_particles.end(), G4ParticleLargerEkin());
+    output.addOutgoingParticles(output_particles);
+    // Adjust final state without fragment to balance momentum and energy
+    if (afin <= 1) {
+      output.setVerboseLevel(verboseLevel);
+      output.setOnShell(bullet, target);
+      output.setVerboseLevel(0);
+      if (output.acceptable()) break;
+    } else if (theRecoilMaker->goodNucleus()) break;
+    // Cascade not physically reasonable
+    if (afin <= minimum_recoil_A && minimum_recoil_A < tnuclei->getA()) {
+      ++minimum_recoil_A;
+      if (verboseLevel > 3) {
+        G4cout << " minimum recoil fragment increased to A " << minimum_recoil_A
+               << G4endl;
+      }
+    }
+  }     // while (itry < itry_max)
+  // Cascade completed, for good or ill
+  if (itry == itry_max) {
     if (verboseLevel > 3) {
+      G4cout << "  afin " << afin << " zfin " << zfin <<  G4endl;
+    }
+    if (afin > 1.0) {
+      G4InuclNuclei outgoing_nuclei(afin, zfin);
+      G4double mass = outgoing_nuclei.getMass();
+      momentum_out.setE(momentum_out.e()+mass);
+      momentum_out = momentum_in - momentum_out;
+      if (verboseLevel > 3) {
+        G4cout << "  Eex + Ekin " << momentum_out.e()  <<  G4endl;
+      }
+      if (momentum_out.e() > 0.0) { // Eex + Ekin > 0.0
+        G4double pnuc = momentum_out.vect().mag2();
+        G4double ekin = std::sqrt(mass * mass + pnuc) - mass;
+        G4double Eex = 1000.0 * (momentum_out.e() - ekin);
+        if (verboseLevel > 3) {
+          G4cout << "  Eex  " << Eex  <<  G4endl;
+        }
+        if (goodCase(afin, zfin, Eex, ekin_in)) { // ok, exitation energy > cut
+          std::sort(output_particles.begin(), output_particles.end(), G4ParticleLargerEkin());
+          output.addOutgoingParticles(output_particles);
+          outgoing_nuclei.setMomentum(momentum_out);
+          outgoing_nuclei.setExitationEnergy(Eex);
+          outgoing_nuclei.setExitonConfiguration(theExitonConfiguration);
+          output.addTargetFragment(outgoing_nuclei);
+          return;
+        };
+      };
+    } else { // special case, when one has no nuclei after the cascad
+      if (afin == 1.0) { // recoiling nucleon
+        momentum_out = momentum_in - momentum_out;
+        G4InuclElementaryParticle  last_particle;
+        if (zfin == 1.0) { // recoiling proton
+          last_particle.setType(1);
+        } else { // neutron
+          last_particle.setType(2);
+        };
+        last_particle.setMomentum(momentum_out);
+        output_particles.push_back(last_particle);
+      };
+      std::sort(output_particles.begin(), output_particles.end(), G4ParticleLargerEkin());
+      output.addOutgoingParticles(output_particles);
+      return;
+    };
+  };
+#else
+  // special branch to avoid the cascad generation but to get the input for evaporation etc
+  G4LorentzVector momentum_out;
+  G4InuclNuclei outgoing_nuclei(169, 69);
+  outgoing_nuclei.setMomentum(momentum_out);
+  outgoing_nuclei.setExitationEnergy(150.0);
+  G4ExitonConfiguration theExitonConfiguration(3.0, 3.0, 5.0, 6.0);
+  outgoing_nuclei.setExitonConfiguration(theExitonConfiguration);
+  output.addTargetFragment(outgoing_nuclei);
+  return;
+  /*
+    G4InuclElementaryParticle* bparticle = dynamic_cast<G4InuclElementaryParticle*>
+    (bullet);
+    G4InuclNuclei* tnuclei = dynamic_cast<G4InuclNuclei*>(target);
+    output.addOutgoingParticle(*bparticle);
+    output.addTargetFragment(*tnuclei);
+    return;
+  */
+#endif
+  if (verboseLevel > 3) {
+    G4cout << " IntraNucleiCascader-> no inelastic interaction after " << itry_max << " attempts "
+           << G4endl;
+  }
+  output.trivialise(bullet, target);
+      G4cout << " IntraNucleiCascader-> no inelastic interaction after "
+             << itry_max << " attempts " << G4endl;
+    }
+    output.trivialise(bullet, target);
+  } else if (verboseLevel) {
+    G4cout << " IntraNucleiCascader output after trials " << itry << G4endl;
+  }
+  // Copy final generated cascade to output buffer for return
+  globalOutput.add(output);
   return;
+}
+G4bool G4IntraNucleiCascader::goodCase(G4double a,
+                                       G4double z,
+                                       G4double eexs,
+                                       G4double ein) const {
+// Convert particles which cannot escape into excitons (or eject/decay them)
+void G4IntraNucleiCascader::
+processTrappedParticle(const G4CascadParticle& trapped) {
+  const G4InuclElementaryParticle& trappedP = trapped.getParticle();
+  G4int xtype = trappedP.type();
+  if (verboseLevel > 3) G4cout << " exciton of type " << xtype << G4endl;
+  if (trappedP.nucleon()) {     // normal exciton (proton or neutron)
+    theExitonConfiguration.incrementQP(xtype);
+    return;
+  }
+  if (trappedP.hyperon()) {     // Not nucleon, so must be hyperon
+    decayTrappedParticle(trapped);
+    return;
+  }
+  // non-standard exciton; release it
+  // FIXME: this is a meson, so need to absorb it
   if (verboseLevel > 3) {
+    G4cout << " >>> G4IntraNucleiCascader::goodCase" << G4endl;
+  }
+  const G4double eexs_cut = 0.0001;
+  const G4double reason_cut = 7.0;
+  const G4double ediv_cut = 5.0;
+  G4bool good = false;
+  if (eexs > eexs_cut) {
+    G4double eexs_max0z = 1000.0 * ein / ediv_cut;
+    //    G4double dm = bindingEnergy(a, z);
+    G4double dm = G4NucleiProperties::GetBindingEnergy(G4lrint(a), G4lrint(z));
+    G4double eexs_max = eexs_max0z > reason_cut*dm ? eexs_max0z : reason_cut * dm;
+    if(eexs < eexs_max) good = true;
+    if (verboseLevel > 3) {
+      G4cout << " eexs " << eexs << " max " << eexs_max << " dm " << dm << G4endl;
+    }
+  };
+  return good;
+    G4cout << " non-standard should be absorbed, now released" << G4endl;
+    trapped.print();
+  }
+  output_particles.push_back(trappedP);
+}
+// Decay unstable trapped particles, and add secondaries to processing list
+void G4IntraNucleiCascader::
+decayTrappedParticle(const G4CascadParticle& trapped) {
+  if (verboseLevel > 3)
+    G4cout << " unstable must be decayed in flight" << G4endl;
+  const G4InuclElementaryParticle& trappedP = trapped.getParticle();
+  G4DecayTable* unstable = trappedP.getDefinition()->GetDecayTable();
+  if (!unstable) {                      // No decay table; cannot decay!
+    if (verboseLevel > 3)
+      G4cerr << " no decay table!  Releasing trapped particle" << G4endl;
+    output_particles.push_back(trappedP);
+    return;
+  }
+  // Get secondaries from decay in particle's rest frame
+  G4DecayProducts* daughters = unstable->SelectADecayChannel()->DecayIt();
+  if (!daughters) {                     // No final state; cannot decay!
+    if (verboseLevel > 3)
+      G4cerr << " no daughters from trapped particle decay" << G4endl;
+    output_particles.push_back(trappedP);
+    return;
+  }
+  if (verboseLevel > 3) daughters->DumpInfo();
+  // Convert secondaries to lab frame
+  G4double decayEnergy = trappedP.getEnergy();
+  G4ThreeVector decayDir = trappedP.getMomentum().vect().unit();
+  daughters->Boost(decayEnergy, decayDir);
+  // Put all the secondaries onto the list for propagation
+  const G4ThreeVector& decayPos = trapped.getPosition();
+  G4int zone = trapped.getCurrentZone();
+  G4int gen = trapped.getGeneration()+1;
+  for (G4int i=0; i<daughters->entries(); i++) {
+    G4DynamicParticle* idaug = (*daughters)[i];
+    G4InuclElementaryParticle idaugEP(*idaug, 4);
+    // Only hadronic secondaries can be propagated; photons escape
+    if (idaugEP.isPhoton()) output_particles.push_back(idaugEP);
+    else {
+      G4CascadParticle idaugCP(idaugEP, decayPos, zone, 0., gen);
+      cascad_particles.push_back(idaugCP);
+    }
+  }
+}

trunk/source/processes/hadronic/models/cascade/cascade/src/G4InuclCollider.cc

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4InuclCollider.cc,v 1.30.2.1 2010/06/25 09:44:36 gunter Exp $
 // Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4InuclCollider.cc,v 1.51 2010/10/19 19:48:39 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
 …
 // 20100517  M. Kelsey -- Inherit from common base class, make other colliders
 //              simple data members, consolidate code
+// 20100620  M. Kelsey -- Reorganize top level if-blocks to reduce nesting,
+//              use new four-vector conservation check.
+// 20100701  M. Kelsey -- Bug fix energy-conservation after equilibrium evap,
+//              pass verbosity through to G4CollisionOutput
+// 20100714  M. Kelsey -- Move conservation checking to base class, report
+//              number of iterations at end
+// 20100715  M. Kelsey -- Remove all the "Before xxx" and "After xxx"
+//              conservation checks, as the colliders now all do so.  Move
+//              local buffers outside while() loop, use new "combined add()"
+//              interface for copying local buffers to global.
+// 20100716  M. Kelsey -- Drop G4IntraNucleiCascader::setInteractionCase()
+// 20100720  M. Kelsey -- Make all the collders pointer members (to reducde
+//              external compile dependences).
+// 20100915  M. Kelsey -- Move post-cascade colliders to G4CascadeDeexcitation,
+//              simplify operational code somewhat
+// 20100922  M. Kelsey -- Add functions to select de-excitation method;
+//              default is G4CascadeDeexcitation (i.e., built-in modules)
+// 20100924  M. Kelsey -- Migrate to integer A and Z
+// 20101019  M. Kelsey -- CoVerity report: check dynamic_cast<> for null
 #include "G4InuclCollider.hh"
+#include "G4BigBanger.hh"
+#include "G4CascadeDeexcitation.hh"
+#include "G4PreCompoundDeexcitation.hh"
 #include "G4CollisionOutput.hh"
 #include "G4ElementaryParticleCollider.hh"
-#include "G4EquilibriumEvaporator.hh"
 #include "G4IntraNucleiCascader.hh"
 #include "G4InuclElementaryParticle.hh"
+#include "G4InuclNuclei.hh"
 #include "G4LorentzConvertor.hh"
-#include "G4NonEquilibriumEvaporator.hh"
 G4InuclCollider::G4InuclCollider()
   : G4VCascadeCollider("G4InuclCollider"),
+  : G4CascadeColliderBase("G4InuclCollider"),
     theElementaryParticleCollider(new G4ElementaryParticleCollider),
     theIntraNucleiCascader(new G4IntraNucleiCascader),
+    theNonEquilibriumEvaporator(new G4NonEquilibriumEvaporator),
+    theEquilibriumEvaporator(new G4EquilibriumEvaporator),
+    theBigBanger(new G4BigBanger) {}
+    theDeexcitation(new G4CascadeDeexcitation) {}
 G4InuclCollider::~G4InuclCollider() {
   delete theElementaryParticleCollider;
   delete theIntraNucleiCascader;
+  delete theNonEquilibriumEvaporator;
+  delete theEquilibriumEvaporator;
+  delete theBigBanger;
+}
+  delete theDeexcitation;
+}
+// Select post-cascade processing (default will be CascadeDeexcitation)
+void G4InuclCollider::useCascadeDeexcitation() {
+  delete theDeexcitation;
+  theDeexcitation = new G4CascadeDeexcitation;
+}
+void G4InuclCollider::usePreCompoundDeexcitation() {
+  delete theDeexcitation;
+  theDeexcitation = new G4PreCompoundDeexcitation;
+}
+// Main action
 void G4InuclCollider::collide(G4InuclParticle* bullet, G4InuclParticle* target,
                               G4CollisionOutput& globalOutput) {
+  if (verboseLevel) G4cout << " >>> G4InuclCollider::collide" << G4endl;
+  // Initialize colliders verbosity
+  theElementaryParticleCollider->setVerboseLevel(verboseLevel);
+  theIntraNucleiCascader->setVerboseLevel(verboseLevel);
+  theDeexcitation->setVerboseLevel(verboseLevel);
+  output.setVerboseLevel(verboseLevel);
+  DEXoutput.setVerboseLevel(verboseLevel);
+  const G4int itry_max = 1000;
+  // Particle-on-particle collision; no nucleus involved
+  if (useEPCollider(bullet,target)) {
+    if (verboseLevel > 2)
+      G4cout << " InuclCollider -> particle on particle collision" << G4endl;
+    theElementaryParticleCollider->collide(bullet, target, globalOutput);
+    return;
+  }
+  interCase.set(bullet,target);         // Classify collision type
+  if (verboseLevel > 2) {
+    G4cout << " InuclCollider -> inter case " << interCase.code() << G4endl;
+  }
+  if (!interCase.valid()) {
+    if (verboseLevel > 1)
+      G4cerr << " InuclCollider -> no collision possible " << G4endl;
+    globalOutput.trivialise(bullet, target);
+    return;
+  }
+  // Target must be a nucleus
+  G4InuclNuclei* ntarget = dynamic_cast<G4InuclNuclei*>(interCase.getTarget());
+  if (!ntarget) {
+    G4cerr << " InuclCollider -> ERROR target is not a nucleus " << G4endl;
+    globalOutput.trivialise(bullet, target);
+    return;
+  }
+  G4int btype = 0;
+  G4int ab = 0;
+  G4int zb = 0;
+  if (interCase.hadNucleus()) {         // particle with nuclei
+    G4InuclElementaryParticle* pbullet =
+      dynamic_cast<G4InuclElementaryParticle*>(interCase.getBullet());
+    if (!pbullet) {
+      G4cerr << " InuclCollider -> ERROR bullet is not a hadron " << G4endl;
+      globalOutput.trivialise(bullet, target);
+      return;
+    } else if (pbullet->isPhoton()) {
+      G4cerr << " InuclCollider -> can not collide with photon " << G4endl;
+      globalOutput.trivialise(bullet, target);
+      return;
+    } else {
+      btype = pbullet->type();
+    }
+  } else {                              // nuclei with nuclei
+    G4InuclNuclei* nbullet =
+      dynamic_cast<G4InuclNuclei*>(interCase.getBullet());
+    if (!nbullet) {
+      G4cerr << " InuclCollider -> ERROR bullet is not a nucleus " << G4endl;
+      globalOutput.trivialise(bullet, target);
+      return;
+    }
+    ab = nbullet->getA();
+    zb = nbullet->getZ();
+  }
+  G4LorentzConvertor convertToTargetRestFrame(bullet, ntarget);
+  G4double ekin = convertToTargetRestFrame.getKinEnergyInTheTRS();
+  if (verboseLevel > 3) G4cout << " ekin in trs " << ekin << G4endl;
+  if (!inelasticInteractionPossible(bullet, target, ekin)) {
+    if (verboseLevel > 3)
+      G4cout << " InuclCollider -> inelastic interaction is impossible\n"
+             << " due to the coulomb barirer " << G4endl;
+    globalOutput.trivialise(bullet, target);
+    return;
+  }
+  // Generate interaction secondaries in rest frame of target nucleus
+  convertToTargetRestFrame.toTheTargetRestFrame();
   if (verboseLevel > 3) {
+    G4cout << " >>> G4InuclCollider::collide" << G4endl;
+  }
+  const G4int itry_max = 1000;
+  if (useEPCollider(bullet,target)) {
+    if (verboseLevel > 2) {
+      bullet->printParticle();
+      target->printParticle();
+    G4cout << " degenerated? " << convertToTargetRestFrame.trivial()
+           << G4endl;
+  }
+  G4LorentzVector bmom;                 // Bullet is along local Z
+  bmom.setZ(convertToTargetRestFrame.getTRSMomentum());
+  // Need to make copy of bullet with momentum realigned
+  G4InuclParticle* zbullet = 0;
+  if (interCase.hadNucleus())
+    zbullet = new G4InuclElementaryParticle(bmom, btype);
+  else
+    zbullet = new G4InuclNuclei(bmom, ab, zb);
+  G4int itry = 0;
+  while (itry < itry_max) {
+    itry++;
+    if (verboseLevel > 2)
+      G4cout << " IntraNucleiCascader itry " << itry << G4endl;
+    globalOutput.reset();               // Clear buffers for this attempt
+    output.reset();
+    DEXoutput.reset();
+    theIntraNucleiCascader->collide(zbullet, target, output);
+    if (verboseLevel > 1) G4cout << " After Cascade " << G4endl;
+    // FIXME:  The code below still does too much copying!  Would rather
+    //         remove initial fragment from list (or get it a different way)
+    DEXoutput.addOutgoingParticles(output.getOutgoingParticles());
+    if (output.numberOfOutgoingNuclei() == 1) { // Residual fragment
+      // FIXME:  Making a copy here because of constness issues
+      G4InuclNuclei recoil_nucleus = output.getOutgoingNuclei()[0];
+      theDeexcitation->collide(0, &recoil_nucleus, DEXoutput);
+    }
+    theElementaryParticleCollider->collide(bullet, target, globalOutput);
+  } else { // needs to call all machinery
+    G4LorentzConvertor convertToTargetRestFrame;
+    interCase.set(bullet,target);
+    if (interCase.valid()) { // ok
+      G4InuclNuclei* ntarget =
+        dynamic_cast<G4InuclNuclei*>(interCase.getTarget());
+      convertToTargetRestFrame.setTarget(ntarget);
+      G4int btype = 0;
+      G4double ab = 0.0;
+      G4double zb = 0.0;
+      G4double at = ntarget->getA();
+      G4double zt = ntarget->getZ();
+      if (interCase.hadNucleus()) { // particle with nuclei
+        G4InuclElementaryParticle* pbullet =
+          dynamic_cast<G4InuclElementaryParticle*>(interCase.getBullet());
+        if (pbullet->isPhoton()) {
+          G4cerr << " InuclCollider -> can not collide with photon " << G4endl;
+          globalOutput.trivialise(bullet, target);
+          return;
+        } else {
+          convertToTargetRestFrame.setBullet(pbullet);
+          btype = pbullet->type();
+        };
+      } else { // nuclei with nuclei
+        G4InuclNuclei* nbullet =
+          dynamic_cast<G4InuclNuclei*>(interCase.getBullet());
+        convertToTargetRestFrame.setBullet(nbullet);
+        ab = nbullet->getA();
+        zb = nbullet->getZ();
+      };
+      G4double ekin = convertToTargetRestFrame.getKinEnergyInTheTRS();
+      if (verboseLevel > 3) {
+        G4cout << " ekin in trs " << ekin << G4endl;
+      }
+      if (inelasticInteractionPossible(bullet, target, ekin)) {
+        convertToTargetRestFrame.toTheTargetRestFrame();
+        if (verboseLevel > 3) {
+          G4cout << " degenerated? " << convertToTargetRestFrame.trivial() << G4endl;
+        }
+        G4LorentzVector bmom;
+        bmom.setZ(convertToTargetRestFrame.getTRSMomentum());
+        G4InuclNuclei ntarget(at, zt);          // Default is at rest
+        theIntraNucleiCascader->setInteractionCase(interCase.code());
+        G4bool bad = true;
+        G4int itry = 0;
+        G4CollisionOutput TRFoutput;
+        G4CollisionOutput output;
+        while (bad && itry < itry_max) {
+          itry++;
+          output.reset();       // Clear buffers for this attempt
+          TRFoutput.reset();
+          if (interCase.hadNucleus()) {
+            G4InuclElementaryParticle pbullet(bmom, btype);
+            theIntraNucleiCascader->collide(&pbullet, &ntarget, output);
+          } else {
+            G4InuclNuclei nbullet(bmom, ab, zb);
+            theIntraNucleiCascader->collide(&nbullet, &ntarget, output);
+          };
+          if (verboseLevel > 3) {
+            G4cout << " After Cascade " << G4endl;
+            output.printCollisionOutput();
+          }
+          // the rest, if any
+          // FIXME:  The code below still does too much copying!
+          TRFoutput.addOutgoingParticles(output.getOutgoingParticles());
+          if (output.numberOfNucleiFragments() == 1) { // there is smth. after
+            G4InuclNuclei cascad_rec_nuclei = output.getNucleiFragments()[0];
+            if (explosion(&cascad_rec_nuclei)) {
+              if (verboseLevel > 3) {
+                G4cout << " big bang after cascade " << G4endl;
+              };
+              theBigBanger->collide(0,&cascad_rec_nuclei, TRFoutput);
+            } else {
+              output.reset();
+              theNonEquilibriumEvaporator->collide(0, &cascad_rec_nuclei, output);
+              if (verboseLevel > 3) {
+                G4cout << " After NonEquilibriumEvaporator " << G4endl;
+                output.printCollisionOutput();
+              };
+              TRFoutput.addOutgoingParticles(output.getOutgoingParticles());
+              G4InuclNuclei exiton_rec_nuclei = output.getNucleiFragments()[0];
+              output.reset();
+              theEquilibriumEvaporator->collide(0, &exiton_rec_nuclei, output);
+              if (verboseLevel > 3) {
+                G4cout << " After EquilibriumEvaporator " << G4endl;
+                output.printCollisionOutput();
+              };
+              TRFoutput.addOutgoingParticles(output.getOutgoingParticles());
+              TRFoutput.addTargetFragments(output.getNucleiFragments());
+            };
+          };
+          // convert to the LAB
+          TRFoutput.boostToLabFrame(convertToTargetRestFrame);
+          globalOutput.addOutgoingParticles(TRFoutput.getOutgoingParticles());
+          globalOutput.addTargetFragments(TRFoutput.getNucleiFragments());
+          globalOutput.setOnShell(bullet, target);
+          if (globalOutput.acceptable()) return;
+          globalOutput.reset();         // Clear and try again
+        };
+        if (verboseLevel > 3) {
+          G4cout << " InuclCollider -> can not generate acceptable inter. after "
+                 << itry_max << " attempts " << G4endl;
+        }
+      } else {
+        if (verboseLevel > 3) {
+          G4cout << " InuclCollider -> inelastic interaction is impossible " << G4endl
+                 << " due to the coulomb barirer " << G4endl;
+        }
+      }
+      globalOutput.trivialise(bullet, target);
+      return;
+    } else {
+      if (verboseLevel > 3) {
+        G4cout << " InuclCollider -> inter case " << interCase.code() << G4endl;
+      };
+    };
+  };
+    if (verboseLevel > 2)
+      G4cout << " itry " << itry << " finished, moving to lab frame" << G4endl;
+    // convert to the LAB frame and add to final result
+    DEXoutput.boostToLabFrame(convertToTargetRestFrame);
+    globalOutput.add(DEXoutput);
+    // Adjust final state particles to balance momentum and energy
+    // FIXME:  This should no longer be necessary!
+    globalOutput.setOnShell(bullet, target);
+    if (globalOutput.acceptable()) {
+      if (verboseLevel)
+        G4cout << " InuclCollider output after trials " << itry << G4endl;
+      return;
+    }
+  }     // while (itry < itry_max)
+  if (verboseLevel) {
+    G4cout << " InuclCollider -> can not generate acceptable inter. after "
+           << itry_max << " attempts " << G4endl;
+  }
+  globalOutput.trivialise(bullet, target);
   return;
+}

trunk/source/processes/hadronic/models/cascade/cascade/src/G4InuclElementaryParticle.cc

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4InuclElementaryParticle.cc,v 1.7 2010/06/25 09:44:38 gunter Exp $
 // Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4InuclElementaryParticle.cc,v 1.10 2010/09/23 05:33:56 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100428  M. Kelsey -- Use G4InuclParticleNames enums instead of numbers,
 //              add Omega and antinucleons.
 // 20100429  M. Kelsey -- Change "case gamma:" to "case photon:"
+// 20100923  M. Kelsey -- Drop "uups" message when converting G4PartDef to code
 #include "G4InuclElementaryParticle.hh"
 …
   if (pd == G4Dineutron::Definition())    return dineutron; // Bertini class!
+  G4cerr << " uups, unknown G4ParticleDefinition type" << G4endl;
+  return 0;
+  return 0;     // Unknown objects return zero (e.g., nuclei)
+}
 …
   return pd ? pd->GetPDGMass()*MeV/GeV : 0.0;   // From G4 to Bertini units
+}
+// Print particle parameters
+void G4InuclElementaryParticle::printParticle() const {
+  G4InuclParticle::printParticle();
+  G4cout << " Particle: " << getDefinition()->GetParticleName()
+         << " type " << type() << " mass " << getMass()
+         << " ekin " << getKineticEnergy() << G4endl;
+}

trunk/source/processes/hadronic/models/cascade/cascade/src/G4InuclEvaporation.cc

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4InuclEvaporation.cc,v 1.19 2010/06/25 09:44:40 gunter Exp $
 // Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4InuclEvaporation.cc,v 1.22 2010/09/24 21:09:01 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
 …
 //              G4CollisionOutput, copy G4DynamicParticle directly from
 //              G4InuclParticle, no switch-block required.  Fix scaling factors.
+// 20100914  M. Kelsey -- Migrate to integer A and Z
+// 20100924  M. Kelsey -- Migrate to "OutgoingNuclei" names in CollisionOutput
+#include "G4InuclEvaporation.hh"
 #include <numeric>
 #include "G4IonTable.hh"
 …
 #include "G4DynamicParticleVector.hh"
 #include "G4EvaporationInuclCollider.hh"
-#include "G4InuclEvaporation.hh"
 #include "G4InuclNuclei.hh"
 #include "G4Track.hh"
 …
+  }
   G4double A = theNucleus.GetA();
   G4double Z = theNucleus.GetZ();
+  G4int A = theNucleus.GetA_asInt();
+  G4int Z = theNucleus.GetZ_asInt();
   G4double mTar  = G4NucleiProperties::GetNuclearMass(A, Z); // Mass of the target nucleus
 …
   evaporator->collide(0, nucleus, output);
   const std::vector<G4InuclNuclei>& nucleiFragments = output.getNucleiFragments();
+  const std::vector<G4InuclNuclei>& outgoingNuclei = output.getOutgoingNuclei();
   const std::vector<G4InuclElementaryParticle>& particles = output.getOutgoingParticles();
 …
+  }
   //  G4cout << "# fragments " << output.getNucleiFragments().size() << G4endl;
+  //  G4cout << "# fragments " << output.getOutgoingNuclei().size() << G4endl;
   i=1;
   if (!nucleiFragments.empty()) {
     nucleiIterator ifrag = nucleiFragments.begin();
     for (; ifrag != nucleiFragments.end(); ifrag++) {
+  if (!outgoingNuclei.empty()) {
+    nucleiIterator ifrag = outgoingNuclei.begin();
+    for (; ifrag != outgoingNuclei.end(); ifrag++) {
       if (verboseLevel > 2) {
         G4cout << " Nuclei fragment: " << i << G4endl; i++;
 …
       G4LorentzVector vlab = ifrag->getMomentum().boost(boostToLab);
       G4int A = G4int(ifrag->getA());
       G4int Z = G4int(ifrag->getZ());
+      G4int A = ifrag->getA();
+      G4int Z = ifrag->getZ();
       if (verboseLevel > 2) {
         G4cout << "boosted v" << vlab << G4endl;

trunk/source/processes/hadronic/models/cascade/cascade/src/G4InuclNuclei.cc

-              r1337
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+//
+// $Id: G4InuclNuclei.cc,v 1.8.2.1 2010/06/25 09:44:42 gunter Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4InuclNuclei.cc,v 1.22 2010/09/25 06:44:30 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100301  M. Kelsey -- Add function to create unphysical nuclei for use
 …
 // 20100319  M. Kelsey -- Add information message to makeNuclearFragment().
 //           Use new GetBindingEnergy() function instead of bindingEnergy().
+// 20100622  M. Kelsey -- Use local "bindingEnergy()" function to call through.
+// 20100627  M. Kelsey -- Test for non-physical fragments and abort job.
+// 20100630  M. Kelsey -- Use excitation energy in G4Ions
+// 20100714  M. Kelsey -- Use G4DynamicParticle::theDynamicalMass to deal with
+//           excitation energy without instantianting "infinite" G4PartDefns.
+// 20100719  M. Kelsey -- Change excitation energy without altering momentum
+// 20100906  M. Kelsey -- Add fill() functions to rewrite contents
+// 20100910  M. Kelsey -- Add clearExitonConfiguration() to fill() functions
+// 20100914  M. Kelsey -- Make printout symmetric with G4InuclElemPart,
+//              migrate to integer A and Z
+// 20100924  M. Kelsey -- Add constructor to copy G4Fragment input, and output
+//              functions to create G4Fragment
 #include "G4InuclNuclei.hh"
+#include "G4Fragment.hh"
+#include "G4HadronicException.hh"
 #include "G4InuclSpecialFunctions.hh"
 #include "G4Ions.hh"
+#include "G4IonTable.hh"
+#include "G4NucleiProperties.hh"
 #include "G4ParticleDefinition.hh"
 #include "G4ParticleTable.hh"
-#include "G4HadTmpUtil.hh"
-#include "G4NucleiProperties.hh"
 #include <assert.h>
 #include <sstream>
 …
+// Convert contents from (via constructor) and to G4Fragment
+G4InuclNuclei::G4InuclNuclei(const G4Fragment& aFragment, G4int model)
+  : G4InuclParticle(makeDefinition(aFragment.GetA_asInt(),
+                                   aFragment.GetZ_asInt()),
+                    aFragment.GetMomentum()/GeV) {      // Bertini units
+  setExitationEnergy(aFragment.GetExcitationEnergy());
+  setModel(model);
+  // Exciton configuration must be set by hand
+  theExitonConfiguration.protonQuasiParticles = aFragment.GetNumberOfCharged();
+  theExitonConfiguration.neutronQuasiParticles =
+    aFragment.GetNumberOfCharged() - aFragment.GetNumberOfCharged();
+  // Split hole count evenly between protons and neutrons (arbitrary!)
+  theExitonConfiguration.protonHoles = aFragment.GetNumberOfHoles()/2;
+  theExitonConfiguration.neutronHoles =
+    aFragment.GetNumberOfHoles() - theExitonConfiguration.protonHoles;
+}
+// FIXME:  Should we have a local buffer and return by const-reference instead?
+G4Fragment G4InuclNuclei::makeG4Fragment() const {
+  G4Fragment frag(getA(), getZ(), getMomentum()*GeV);   // From Bertini units
+  // Note:  exciton configuration has to be set piece by piece
+  frag.SetNumberOfHoles(theExitonConfiguration.protonHoles
+                        + theExitonConfiguration.neutronHoles);
+  frag.SetNumberOfParticles(theExitonConfiguration.protonQuasiParticles
+                            + theExitonConfiguration.neutronQuasiParticles);
+  frag.SetNumberOfCharged(theExitonConfiguration.protonQuasiParticles);
+  return frag;
+}
+G4InuclNuclei::operator G4Fragment() const {
+  return makeG4Fragment();
+}
+// Overwrite data structure (avoids creating/copying temporaries)
+void G4InuclNuclei::fill(const G4LorentzVector& mom, G4int a, G4int z,
+                         G4double exc, G4int model) {
+  setDefinition(makeDefinition(a,z));
+  setMomentum(mom);
+  setExitationEnergy(exc);
+  clearExitonConfiguration();
+  setModel(model);
+}
+void G4InuclNuclei::fill(G4double ekin, G4int a, G4int z, G4double exc,
+                         G4int model) {
+  setDefinition(makeDefinition(a,z));
+  setKineticEnergy(ekin);
+  setExitationEnergy(exc);
+  clearExitonConfiguration();
+  setModel(model);
+}
+// Change excitation energy while keeping momentum vector constant
+void G4InuclNuclei::setExitationEnergy(G4double e) {
+  G4double ekin = getKineticEnergy();           // Current kinetic energy
+  G4double emass = getNucleiMass() + e*MeV/GeV; // From Bertini to G4 units
+  // Directly compute new kinetic energy from old
+  G4double ekin_new = std::sqrt(emass*emass + ekin*(2.*getMass()+ekin)) - emass;
+  setMass(emass);              // Momentum is computed from mass and Ekin
+  setKineticEnergy(ekin_new);
+}
 // Convert nuclear configuration to standard GEANT4 pointer
 …
 //        G4ParticleTable::GetIon() uses (Z,A)!
+G4ParticleDefinition*
+G4InuclNuclei::makeDefinition(G4double a, G4double z, G4double exc) {
+G4ParticleDefinition* G4InuclNuclei::makeDefinition(G4int a, G4int z) {
   G4ParticleTable* pTable = G4ParticleTable::GetParticleTable();
   G4ParticleDefinition *pd = pTable->GetIon(G4int(z), G4int(a), exc);
+  G4ParticleDefinition *pd = pTable->GetIon(z, a, 0.);
   // SPECIAL CASE:  Non-physical nuclear fragment, for final-state return
+  if (!pd) pd = makeNuclearFragment(a,z,exc);
+  return pd;
+}
+  if (!pd) pd = makeNuclearFragment(a,z);
+  return pd;            // This could return a null pointer if above fails
+}
+// Creates a non-standard excited nucleus
 // Creates a non-physical pseudo-nucleus, for return as final-state fragment
 …
 G4ParticleDefinition*
+G4InuclNuclei::makeNuclearFragment(G4double a, G4double z, G4double exc) {
+  G4int na=G4int(a), nz=G4int(z), nn=na-nz;     // # nucleon, proton, neutron
+  // See G4IonTable.hh::GetNucleusEncoding for explanation
+  G4int code = ((100+nz)*1000 + na)*10 + (exc>0.)?1:0;
+G4InuclNuclei::makeNuclearFragment(G4int a, G4int z) {
+  if (a<=0 || z<0 || a<z) {
+    G4cerr << " >>> G4InuclNuclei::makeNuclearFragment() called with"
+           << " impossible arguments A=" << a << " Z=" << z << G4endl;
+    throw G4HadronicException(__FILE__, __LINE__,
+                              "G4InuclNuclei impossible A/Z arguments");
+  }
+  G4int code = G4IonTable::GetNucleusEncoding(z, a);
   // Use local lookup table (see G4IonTable.hh) to maintain singletons
   // NOTE:  G4ParticleDefinitions don't need to be explicitly deleted
   //        (see comments in G4IonTable.cc::~G4IonTable)
+  // If correct nucleus already created return it
   static std::map<G4int, G4ParticleDefinition*> fragmentList;
   if (fragmentList.find(code) != fragmentList.end()) return fragmentList[code];
   // Name string follows format in G4IonTable.cc::GetIonName(Z,A,E)
+  std::stringstream zstr, astr, estr;
+  zstr << nz;
+  astr << na;
+  estr << G4int(1000*exc+0.5);  // keV in integer form
+  std::stringstream zstr, astr;
+  zstr << z;
+  astr << a;
   G4String name = "Z" + zstr.str() + "A" + astr.str();
+  if (exc>0.) name += "["+estr.str()+"]";
+  // Simple minded mass calculation use constants in CLHEP (all in MeV)
+  G4double mass = nz*proton_mass_c2 + nn*neutron_mass_c2
+    + G4NucleiProperties::GetBindingEnergy(G4lrint(a),G4lrint(z)) + exc;
+  G4double mass = getNucleiMass(a,z) *GeV/MeV;  // From Bertini to GEANT4 units
   //    Arguments for constructor are as follows
   //               name             mass          width         charge
 …
   //             stable         lifetime    decay table
   //             shortlived      subType    anti_encoding Excitation-energy
   G4cout << " >>> G4InuclNuclei creating temporary fragment for evaporation "
          << "with non-standard PDGencoding." << G4endl;
   G4Ions* fragPD = new G4Ions(name,       mass, 0., z*eplus,
 ,          +1,   0,
+,          +1,   0,
 ,          0,    0,
                               "nucleus",  0,    na, code,
+                              "nucleus",  0,    a, code,
                               true,       0.,   0,
                               true, "generic",  0,  exc);
+                              true, "generic",  0,  0.);
   fragPD->SetAntiPDGEncoding(0);
+  fragmentList[code] = fragPD;          // Store in table for next lookup
+  return fragPD;
+}
+G4double G4InuclNuclei::getNucleiMass(G4double a, G4double z) {
+  G4ParticleDefinition* pd = makeDefinition(a,z);
+  return pd ? pd->GetPDGMass()*MeV/GeV : 0.;    // From G4 to Bertini units
+  return (fragmentList[code] = fragPD);     // Store in table for next lookup
+}
+G4double G4InuclNuclei::getNucleiMass(G4int a, G4int z, G4double exc) {
+  // Simple minded mass calculation use constants in CLHEP (all in MeV)
+  G4double mass = G4NucleiProperties::GetNuclearMass(a,z) + exc;
+  return mass*MeV/GeV;          // Convert from GEANT4 to Bertini units
+}
 // Assignment operator for use with std::sort()
 G4InuclNuclei& G4InuclNuclei::operator=(const G4InuclNuclei& right) {
-  exitationEnergy = right.exitationEnergy;
   theExitonConfiguration = right.theExitonConfiguration;
   G4InuclParticle::operator=(right);
   return *this;
+}
+// Dump particle properties for diagnostics
+void G4InuclNuclei::printParticle() const {
+  G4InuclParticle::printParticle();
+  G4cout << " Nucleus: " << getDefinition()->GetParticleName()
+         << " A " << getA() << " Z " << getZ() << " mass " << getMass()
+         << " Eex (MeV) " << getExitationEnergy() << G4endl;
+}

trunk/source/processes/hadronic/models/cascade/cascade/src/G4InuclParticle.cc

r1337	r1340
25	25	//
26	26	// $Id: G4InuclParticle.cc,v 1.7 2010/06/25 09:44:44 gunter Exp $
27		// Geant4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// Geant4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100409 M. Kelsey -- Drop unused string argument from ctors.

trunk/source/processes/hadronic/models/cascade/cascade/src/G4InuclSpecialFunctions.cc

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4InuclSpecialFunctions.cc,v 1.20 2010/06/25 09:44:46 gunter Exp $
 // Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4InuclSpecialFunctions.cc,v 1.21 2010/09/14 17:51:36 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
+// 20100914  M. Kelsey -- Migrate to integer A and Z.  Discard pointless
+//              verbosity.
 #include "G4InuclSpecialFunctions.hh"
 …
 #include <cmath>
-G4double G4InuclSpecialFunctions::getAL(G4double A) {
-  G4int verboseLevel = 2;
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4InuclSpecialFunctions::getAL" << G4endl;
+  }
+G4double G4InuclSpecialFunctions::getAL(G4int A) {
   return 0.76 + 2.2 / G4cbrt(A);
+}
 G4double G4InuclSpecialFunctions::csNN(G4double e) {
-  G4int verboseLevel = 2;
-  if (verboseLevel > 3) {
-    G4cout << " >>> G4InuclSpecialFunctions::csNN" << G4endl;
+  }
   G4double snn;
   if (e < 40.0) {
     snn = -1174.8 / (e * e) + 3088.5 / e + 5.3107;
   } else {
     snn = 93074.0 / (e * e) - 11.148 / e + 22.429;
   };
+  }
   return snn;
 …
 G4double G4InuclSpecialFunctions::csPN(G4double e) {
-  G4int verboseLevel = 2;
-  if (verboseLevel > 3) {
-    G4cout << " >>> G4InuclSpecialFunctions::csPN" << G4endl;
+  }
   G4double spn;
   if (e < 40.0) {
     spn = -5057.4 / (e * e) + 9069.2 / e + 6.9466;
   } else {
     spn = 239380.0 / (e * e) + 1802.0 / e + 27.147;
   };
+  }
   return spn;
+}
+G4double G4InuclSpecialFunctions::FermiEnergy(G4double A, G4double Z, G4int ntype) {
+  // calculates the nuclei Fermi energy for 0 - neutron and 1 - proton
+  G4int verboseLevel = 2;
+// calculates the nuclei Fermi energy for 0 - neutron and 1 - proton
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4InuclSpecialFunctions::FermiEnergy" << G4endl;
+  }
+G4double G4InuclSpecialFunctions::FermiEnergy(G4int A, G4int Z, G4int ntype) {
   const G4double C = 55.4;
   G4double arg = (ntype==0) ? (A-Z)/A : Z/A;
+  G4double arg = (ntype==0) ? G4double(A-Z)/A : G4double(Z)/A;
   return C * G4cbrt(arg*arg);   // 2/3 power
 …
 G4double G4InuclSpecialFunctions::inuclRndm() {
-  G4int verboseLevel = 2;
-  if (verboseLevel > 3) {
-    G4cout << " >>> G4InuclSpecialFunctions::inuclRndm" << G4endl;
+  }
   G4double rnd = G4UniformRand();
   return rnd;
+}
 G4double G4InuclSpecialFunctions::randomGauss(G4double sigma) {
-  G4int verboseLevel = 2;
-  if (verboseLevel > 3) {
-    G4cout << " >>> G4InuclSpecialFunctions::randomGauss" << G4endl;
+  }
   const G4double eps = 1.0e-6;
   const G4double twopi = 6.2831854;
 …
 G4double G4InuclSpecialFunctions::randomPHI() {
-  G4int verboseLevel = 2;
-  if (verboseLevel > 3) {
-    G4cout << " >>> G4InuclSpecialFunctions::randomPHI" << G4endl;
+  }
   const G4double twopi = 6.2831853;
   return twopi * inuclRndm();
+}
 std::pair<G4double, G4double> G4InuclSpecialFunctions::randomCOS_SIN() {
-  G4int verboseLevel = 2;
-  if (verboseLevel > 3) {
-    G4cout << " >>> G4InuclSpecialFunctions::randomCOS_SIN" << G4endl;
+  }
   G4double CT = 1.0 - 2.0 * inuclRndm();
   return std::pair<G4double, G4double>(CT, std::sqrt(1.0 - CT * CT));
+  return std::pair<G4double, G4double>(CT, std::sqrt(1.0 - CT*CT));
+}
 …
 G4InuclSpecialFunctions::generateWithFixedTheta(G4double ct, G4double p,
                                                 G4double m) {
-  const G4int verboseLevel = 0;
-  if (verboseLevel > 3) {
-    G4cout << " >>> G4InuclSpecialFunctions::generateWithFixedTheta" << G4endl;
+  }
   G4double phi = randomPHI();
   G4double pt = p * std::sqrt(std::fabs(1.0 - ct * ct));

trunk/source/processes/hadronic/models/cascade/cascade/src/G4KaonHypSampler.cc

r1337	r1340
25	25	//
26	26	// $Id: G4KaonHypSampler.cc,v 1.2 2010/06/25 09:44:48 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100512 M. Kelsey -- Replaces (old, untemplated) G4CascadeSampler

trunk/source/processes/hadronic/models/cascade/cascade/src/G4LorentzConvertor.cc

-              r1337
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+//
+// $Id: G4LorentzConvertor.cc,v 1.23.2.1 2010/06/25 09:44:50 gunter Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4LorentzConvertor.cc,v 1.29 2010/09/15 20:16:16 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100108  Michael Kelsey -- Use G4LorentzVector internally
 …
 // 20100409  M. Kelsey -- Protect std::sqrt(ga) against round-off negatives
 // 20100519  M. Kelsey -- Add interfaces to pass G4InuclParticles directly
+// 20100617  M. Kelsey -- Add more diagnostic messages with multiple levels
+// 20100713  M. Kelsey -- All diagnostic messages should be verbose > 1
 #include "G4LorentzConvertor.hh"
 …
 G4LorentzConvertor::G4LorentzConvertor()
   : verboseLevel(0), degenerated(false) {
   if (verboseLevel > 3) {
+  : verboseLevel(0), velocity(0.), gamma(0.), v2(0.), ecm_tot(0.),
+    ga(0.), gb(0.), gbpp(0.), gapp(0.), degenerated(false) {
+  if (verboseLevel)
     G4cout << " >>> G4LorentzConvertor::G4LorentzConvertor" << G4endl;
+  }
+}
+G4LorentzConvertor::
+G4LorentzConvertor(const G4LorentzVector& bmom, G4double bmass,
+                   const G4LorentzVector& tmom, G4double tmass)
+  : verboseLevel(0), velocity(0.), gamma(0.), v2(0.), ecm_tot(0.),
+    ga(0.), gb(0.), gbpp(0.), gapp(0.), degenerated(false) {
+  setBullet(bmom, bmass);
+  setTarget(tmom, tmass);
+}
+G4LorentzConvertor::
+G4LorentzConvertor(const G4InuclParticle* bullet,
+                   const G4InuclParticle* target)
+  : verboseLevel(0), velocity(0.), gamma(0.), v2(0.), ecm_tot(0.),
+    ga(0.), gb(0.), gbpp(0.), gapp(0.), degenerated(false) {
+  setBullet(bullet);
+  setTarget(target);
+}
 …
+}
 // Boost bullet and target four-vectors into destired frame
 void G4LorentzConvertor::toTheCenterOfMass() {
   if (verboseLevel > 3) {
+  if (verboseLevel > 2)
     G4cout << " >>> G4LorentzConvertor::toTheCenterOfMass" << G4endl;
+  }
   G4LorentzVector cm4v = target_mom + bullet_mom;
   velocity = cm4v.boostVector();
+  if (verboseLevel > 3)
+    G4cout << " boost " << velocity.x() << " " << velocity.y() << " "
+           << velocity.z() << G4endl;
   // "SCM" is reverse target momentum in the CM frame
 …
   if (verboseLevel > 3)
+    G4cout << " i 1 pscm(i) " << scm_momentum.x() << G4endl
+           << " i 2 pscm(i) " << scm_momentum.y() << G4endl
+           << " i 3 pscm(i) " << scm_momentum.z() << G4endl;
+    G4cout << " pscm " << scm_momentum.x() << " " << scm_momentum.y()
+           << " " << scm_momentum.z() << G4endl;
   // Compute kinematic quantities for rotate() functions
   v2 = velocity.mag2();
-  gamma = cm4v.e()/cm4v.m();
   ecm_tot = cm4v.m();
+  gamma = cm4v.e()/ecm_tot;
   G4double pscm = scm_momentum.rho();
   G4double pa   = scm_momentum.vect().mag2();
+  G4double pa   = pscm*pscm;
   G4double pb   = scm_momentum.vect().dot(velocity);
 …
   degenerated = (ga < small);
   if (degenerated && verboseLevel > 3)
     G4cout << " degenerated case " << G4endl;
+  if (degenerated && verboseLevel > 2)
+    G4cout << " degenerated case (already in CM frame) " << G4endl;
   if (verboseLevel > 3) {
 …
 void G4LorentzConvertor::toTheTargetRestFrame() {
   if (verboseLevel > 3) {
+  if (verboseLevel > 2)
     G4cout << " >>> G4LorentzConvertor::toTheTargetRestFrame" << G4endl;
+  }
   velocity = target_mom.boostVector();
+  if (verboseLevel > 3)
+    G4cout << " boost " << velocity.x() << " " << velocity.y() << " "
+           << velocity.z() << G4endl;
   // "SCM" is bullet momentum in the target's frame
 …
   if (verboseLevel > 3)
+    G4cout << " rf: i 1 pscm(i) " << scm_momentum.x() << G4endl
+           << " rf: i 2 pscm(i) " << scm_momentum.y() << G4endl
+           << " rf: i 3 pscm(i) " << scm_momentum.z() << G4endl;
+    G4cout << " pseudo-pscm " << scm_momentum.x() << " " << scm_momentum.y()
+           << " " << scm_momentum.z() << G4endl;
   // Compute kinematic quantities for rotate() functions
 …
   G4double pscm = scm_momentum.rho();
   G4double pa   = scm_momentum.vect().mag2();
+  G4double pa   = pscm*pscm;
   G4double pb   = velocity.dot(scm_momentum.vect());
 …
   degenerated = (ga < small);
+  if (degenerated && verboseLevel > 3)
+    G4cout << " degenerated case " << G4endl;
+  if (degenerated && verboseLevel > 2)
+    G4cout << " degenerated case (already in target frame) " << G4endl;
+  if (verboseLevel > 3) {
+    G4cout << " ga " << ga << " v2 " << v2 << " pb " << pb
+           << " pb * pb / pa " << pb * pb / pa << G4endl;
+  }
+}
 G4LorentzVector
 G4LorentzConvertor::backToTheLab(const G4LorentzVector& mom) const {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4LorentzConvertor::backToTheLab" << G4endl
+           << " at rest: px " << mom.x() << " py " << mom.y() << " pz "
+  if (verboseLevel > 2)
+    G4cout << " >>> G4LorentzConvertor::backToTheLab" << G4endl;
+  if (verboseLevel > 3)
+    G4cout << " at rest: px " << mom.x() << " py " << mom.y() << " pz "
            << mom.z() << " e " << mom.e() << G4endl
            << " v2 " << v2 << G4endl;
+  }
   G4LorentzVector mom1 = mom;
 …
 G4double G4LorentzConvertor::getKinEnergyInTheTRS() const {
+  if (verboseLevel > 2)
+    G4cout << " >>> G4LorentzConvertor::getKinEnergyInTheTRS" << G4endl;
   G4double pv = bullet_mom.vect().dot(target_mom.vect());
 …
 G4double G4LorentzConvertor::getTRSMomentum() const {
+  if (verboseLevel > 2)
+    G4cout << " >>> G4LorentzConvertor::getTRSMomentum" << G4endl;
   G4LorentzVector bmom = bullet_mom;
   bmom.boost(-target_mom.boostVector());
 …
 G4LorentzVector G4LorentzConvertor::rotate(const G4LorentzVector& mom) const {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4LorentzConvertor::rotate(G4LorentzVector)" << G4endl
+           << " ga " << ga << " gbpp " << gbpp << " gapp " << gapp << G4endl
+  if (verboseLevel > 2)
+    G4cout << " >>> G4LorentzConvertor::rotate(G4LorentzVector)" << G4endl;
+  if (verboseLevel > 3) {
+    G4cout << " ga " << ga << " gbpp " << gbpp << " gapp " << gapp << G4endl
            << " degenerated " << degenerated << G4endl
            << " before rotation: px " << mom.x() << " py " << mom.y()
 …
   G4LorentzVector mom_rot = mom;
   if (!degenerated) {
+    if (verboseLevel > 2)
+      G4cout << " rotating to align with reference z axis " << G4endl;
     G4ThreeVector vscm = velocity - gbpp*scm_momentum.vect();
     G4ThreeVector vxcm = scm_momentum.vect().cross(velocity);
 …
 G4LorentzVector G4LorentzConvertor::rotate(const G4LorentzVector& mom1,
                                            const G4LorentzVector& mom) const {
   if (verboseLevel > 3) {
+  if (verboseLevel > 2)
     G4cout << " >>> G4LorentzConvertor::rotate(G4LorentzVector,G4LorentzVector)"
+           << G4endl
+           << " before rotation: px " << mom.x() << " py " << mom.y()
+           << G4endl;
+  if (verboseLevel > 3) {
+    G4cout << " before rotation: px " << mom.x() << " py " << mom.y()
            << " pz " << mom.z() << G4endl;
+  }
 …
   if (ga1 > small) {
     ga1 = std::sqrt(ga1);
     G4double gb1 = pv / pp;
     pp = std::sqrt(pp);
     G4double ga1pp = ga1 * pp;
 …
+    }
+    if (verboseLevel > 2)
+      G4cout << " rotating to align with first z axis " << G4endl;
     G4ThreeVector vmom1 = velocity - gb1*mom1;
     G4ThreeVector vxm1  = mom1.vect().cross(velocity);
 …
 G4bool G4LorentzConvertor::reflectionNeeded() const {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4LorentzConvertor::reflectionNeeded: v2 = " << v2
+           << " SCM z = " << scm_momentum.z() << " degenerated? "
+           << degenerated << G4endl;
+  if (verboseLevel > 2)
+    G4cout << " >>> G4LorentzConvertor::reflectionNeeded (query)" << G4endl;
+  if (verboseLevel > 3) {
+    G4cout << " v2 = " << v2 << " SCM z = " << scm_momentum.z()
+           << " degenerated? " << degenerated << G4endl;
+  }
 …
     throw G4HadronicException(__FILE__, __LINE__, "G4LorentzConvertor::reflectionNeeded - return value undefined");
+  return (v2>=small && (!degenerated || scm_momentum.z() < 0.0));
+}
+  if (verboseLevel > 2) {
+    G4cout << " reflection across XY is"
+           << ((v2>=small && (!degenerated || scm_momentum.z()<0.0))?"":" NOT")
+           << " needed" << G4endl;
+  }
+  return (v2>=small && (!degenerated || scm_momentum.z()<0.0));
+}
+// Reporting functions for diagnostics
+void G4LorentzConvertor::printBullet() const {
+  G4cout << " G4LC bullet: px " << bullet_mom.px() << " py " << bullet_mom.py()
+         << " pz " << bullet_mom.pz() << " e " << bullet_mom.e()
+         << " mass " << bullet_mom.m() << G4endl;
+  }
+void G4LorentzConvertor::printTarget() const {
+  G4cout << " G4LC target: px " << target_mom.px() << " py " << target_mom.py()
+         << " pz " << target_mom.pz() << " e " << target_mom.e()
+         << " mass " << target_mom.m() << G4endl;
+}

trunk/source/processes/hadronic/models/cascade/cascade/src/G4NonEquilibriumEvaporator.cc

-              r1337
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+//
+// $Id: G4NonEquilibriumEvaporator.cc,v 1.29.2.1 2010/06/25 09:44:52 gunter Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4NonEquilibriumEvaporator.cc,v 1.40 2010/09/24 20:51:05 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
 …
 // 20100413  M. Kelsey -- Pass buffers to paraMaker[Truncated]
 // 20100517  M. Kelsey -- Inherit from common base class
+#define RUN
+#include <cmath>
+// 20100617  M. Kelsey -- Remove "RUN" preprocessor flag and all "#else" code
+// 20100622  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)
+// 20100713  M. Kelsey -- Add conservation checking, diagnostic messages.
+// 20100714  M. Kelsey -- Move conservation checking to base class
+// 20100719  M. Kelsey -- Simplify EEXS calculations with particle evaporation.
+// 20100724  M. Kelsey -- Replace std::vector<> D with trivial D[3] array.
+// 20100914  M. Kelsey -- Migrate to integer A and Z: this involves replacing
+//              a number of G4double terms with G4int, with consequent casts.
 #include "G4NonEquilibriumEvaporator.hh"
 #include "G4CollisionOutput.hh"
 …
 #include "G4InuclSpecialFunctions.hh"
 #include "G4LorentzConvertor.hh"
+#include "G4NucleiProperties.hh"
+#include "G4HadTmpUtil.hh"
+#include <cmath>
 using namespace G4InuclSpecialFunctions;
 …
 G4NonEquilibriumEvaporator::G4NonEquilibriumEvaporator()
   : G4VCascadeCollider("G4NonEquilibriumEvaporator") {}
+  : G4CascadeColliderBase("G4NonEquilibriumEvaporator") {}
 …
                                          G4CollisionOutput& output) {
   if (verboseLevel > 3) {
+  if (verboseLevel) {
     G4cout << " >>> G4NonEquilibriumEvaporator::collide" << G4endl;
+  }
 …
+  }
+  const G4double a_cut = 5.0;
+  const G4double z_cut = 3.0;
+#ifdef RUN
+  if (verboseLevel > 2) {
+    G4cout << " evaporating target: " << G4endl;
+    target->printParticle();
+  }
+  const G4int a_cut = 5;
+  const G4int z_cut = 3;
   const G4double eexs_cut = 0.1;
-#else
-  const G4double eexs_cut = 100000.0;
-#endif
   const G4double coul_coeff = 1.4;
 …
   const G4double width_cut = 0.005;
+    G4double A = nuclei_target->getA();
+    G4double Z = nuclei_target->getZ();
+    G4LorentzVector PEX = nuclei_target->getMomentum();
+    G4LorentzVector pin = PEX;
+    G4double EEXS = nuclei_target->getExitationEnergy();
+    pin.setE(pin.e() + 0.001 * EEXS);
+    G4InuclNuclei dummy_nuc;
+    G4ExitonConfiguration config = nuclei_target->getExitonConfiguration();
+    G4double QPP = config.protonQuasiParticles;
+    G4double QNP = config.neutronQuasiParticles;
+    G4double QPH = config.protonHoles;
+    G4double QNH = config.neutronHoles;
+    G4double QP = QPP + QNP;
+    G4double QH = QPH + QNH;
+    G4double QEX = QP + QH;
+    G4InuclElementaryParticle dummy(small_ekin, 1);
+    G4LorentzConvertor toTheExitonSystemRestFrame;
+    toTheExitonSystemRestFrame.setBullet(dummy);
+    G4double EFN = FermiEnergy(A, Z, 0);
+    G4double EFP = FermiEnergy(A, Z, 1);
+    G4double AR = A - QP;
+    G4double ZR = Z - QPP;
+    G4int NEX = G4int(QEX + 0.5);
+    G4LorentzVector ppout;
+    G4bool try_again = (NEX > 0);
+    // Buffer for parameter sets
+    std::pair<G4double, G4double> parms;
+    while (try_again) {
+      if (A >= a_cut && Z >= z_cut && EEXS > eexs_cut) { // ok
+        if (verboseLevel > 2) {
+          G4cout << " A " << A << " Z " << Z << " EEXS " << EEXS << G4endl;
+        }
+        // update exiton system
+        G4double nuc_mass = dummy_nuc.getNucleiMass(A, Z);
+        PEX.setVectM(PEX.vect(), nuc_mass);
+        toTheExitonSystemRestFrame.setTarget(PEX, nuc_mass);
+        toTheExitonSystemRestFrame.toTheTargetRestFrame();
+        G4double MEL = getMatrixElement(A);
+        G4double E0 = getE0(A);
+        G4double PL = getParLev(A, Z);
+        G4double parlev = PL / A;
+        G4double EG = PL * EEXS;
+        if (QEX < std::sqrt(2.0 * EG)) { // ok
+          paraMakerTruncated(Z, parms);
+          const G4double& AK1 = parms.first;
+          const G4double& CPA1 = parms.second;
+          G4double VP = coul_coeff * Z * AK1 / (G4cbrt(A - 1.0) + 1.0) /
+            (1.0 + EEXS / E0);
+          //      G4double DM1 = bindingEnergy(A, Z);
+          //      G4double BN = DM1 - bindingEnergy(A - 1.0, Z);
+          //      G4double BP = DM1 - bindingEnergy(A - 1.0, Z - 1.0);
+          G4double DM1 = G4NucleiProperties::GetBindingEnergy(G4lrint(A), G4lrint(Z));
+          G4double BN = DM1 - G4NucleiProperties::GetBindingEnergy(G4lrint(A-1.0), G4lrint(Z));
+          G4double BP = DM1 - G4NucleiProperties::GetBindingEnergy(G4lrint(A-1.0), G4lrint(Z-1.0));
+          G4double EMN = EEXS - BN;
+          G4double EMP = EEXS - BP - VP * A / (A - 1.0);
+          G4double ESP = 0.0;
+  G4int A = nuclei_target->getA();
+  G4int Z = nuclei_target->getZ();
+  G4LorentzVector PEX = nuclei_target->getMomentum();
+  G4LorentzVector pin = PEX;            // Save original four-vector for later
+  G4double EEXS = nuclei_target->getExitationEnergy();
+  G4ExitonConfiguration config = nuclei_target->getExitonConfiguration();
+  G4int QPP = config.protonQuasiParticles;
+  G4int QNP = config.neutronQuasiParticles;
+  G4int QPH = config.protonHoles;
+  G4int QNH = config.neutronHoles;
+  G4int QP = QPP + QNP;
+  G4int QH = QPH + QNH;
+  G4int QEX = QP + QH;
+  G4InuclElementaryParticle dummy(small_ekin, 1);
+  G4LorentzConvertor toTheExitonSystemRestFrame;
+  //*** toTheExitonSystemRestFrame.setVerbose(verboseLevel);
+  toTheExitonSystemRestFrame.setBullet(dummy);
+  G4double EFN = FermiEnergy(A, Z, 0);
+  G4double EFP = FermiEnergy(A, Z, 1);
+  G4int AR = A - QP;
+  G4int ZR = Z - QPP;
+  G4int NEX = QEX;
+  G4LorentzVector ppout;
+  G4bool try_again = (NEX > 0);
+  // Buffer for parameter sets
+  std::pair<G4double, G4double> parms;
+  while (try_again) {
+    if (A >= a_cut && Z >= z_cut && EEXS > eexs_cut) { // ok
+      // update exiton system (include excitation energy!)
+      G4double nuc_mass = G4InuclNuclei::getNucleiMass(A, Z, EEXS);
+      PEX.setVectM(PEX.vect(), nuc_mass);
+      toTheExitonSystemRestFrame.setTarget(PEX);
+      toTheExitonSystemRestFrame.toTheTargetRestFrame();
+      if (verboseLevel > 2) {
+        G4cout << " A " << A << " Z " << Z << " mass " << nuc_mass
+               << " EEXS " << EEXS << G4endl;
+      }
+      G4double MEL = getMatrixElement(A);
+      G4double E0 = getE0(A);
+      G4double PL = getParLev(A, Z);
+      G4double parlev = PL / A;
+      G4double EG = PL * EEXS;
+      if (QEX < std::sqrt(2.0 * EG)) { // ok
+        if (verboseLevel > 3)
+          G4cout << " QEX " << QEX << " < sqrt(2*EG) " << std::sqrt(2.*EG)
+                 << G4endl;
+          if (EMN > eexs_cut) { // ok
+            G4int icase = 0;
+        paraMakerTruncated(Z, parms);
+        const G4double& AK1 = parms.first;
+        const G4double& CPA1 = parms.second;
+        G4double VP = coul_coeff * Z * AK1 / (G4cbrt(A-1) + 1.0) /
+          (1.0 + EEXS / E0);
+        G4double DM1 = bindingEnergy(A,Z);
+        G4double BN = DM1 - bindingEnergy(A-1,Z);
+        G4double BP = DM1 - bindingEnergy(A-1,Z-1);
+        G4double EMN = EEXS - BN;
+        G4double EMP = EEXS - BP - VP * A / (A-1);
+        G4double ESP = 0.0;
+        if (EMN > eexs_cut) { // ok
+          G4int icase = 0;
             if (NEX > 1) {
               G4double APH = 0.25 * (QP * QP + QH * QH + QP - 3.0 * QH);
               G4double APH1 = APH + 0.5 * (QP + QH);
               ESP = EEXS / QEX;
               G4double MELE = MEL / ESP / (A*A*A);
               if (ESP > 15.0) {
                 MELE *= std::sqrt(15.0 / ESP);
               } else if(ESP < 7.0) {
                 MELE *= std::sqrt(ESP / 7.0);
                 if (ESP < 2.0) MELE *= std::sqrt(ESP / 2.0);
               };
+          if (NEX > 1) {
+            G4double APH = 0.25 * (QP * QP + QH * QH + QP - 3 * QH);
+            G4double APH1 = APH + 0.5 * (QP + QH);
+            ESP = EEXS / QEX;
+            G4double MELE = MEL / ESP / (A*A*A);
+            if (ESP > 15.0) {
+              MELE *= std::sqrt(15.0 / ESP);
+            } else if(ESP < 7.0) {
+              MELE *= std::sqrt(ESP / 7.0);
+              if (ESP < 2.0) MELE *= std::sqrt(ESP / 2.0);
+            };
               G4double F1 = EG - APH;
               G4double F2 = EG - APH1;
+            G4double F1 = EG - APH;
+            G4double F2 = EG - APH1;
+              if (F1 > 0.0 && F2 > 0.0) {
+                G4double F = F2 / F1;
+                G4double M1 = 2.77 * MELE * PL;
+                std::vector<G4double> D(3, 0.0);
+                D[0] = M1 * F2 * F2 * std::pow(F, NEX - 1) / (QEX + 1.0);
+                if (D[0] > 0.0) {
+                  if (NEX >= 2) {
+                    D[1] = 0.0462 / parlev / G4cbrt(A) * QP * EEXS / QEX;
+                    if (EMP > eexs_cut)
+                      D[2] = D[1] * std::pow(EMP / EEXS, NEX) * (1.0 + CPA1);
+                    D[1] *= std::pow(EMN / EEXS, NEX) * getAL(A);
+                    if (QNP < 1.0) D[1] = 0.0;
+                    if (QPP < 1.0) D[2] = 0.0;
+                    try_again = NEX > 1 && (D[1] > width_cut * D[0] ||
+                                            D[2] > width_cut * D[0]);
+                    if (try_again) {
+                      G4double D5 = D[0] + D[1] + D[2];
+                      G4double SL = D5 * inuclRndm();
+                      G4double S1 = 0.;
+                      for (G4int i = 0; i < 3; i++) {
+                        S1 += D[i];
+                        if (SL <= S1) {
+                          icase = i;
+                          break;
+                        };
+            if (F1 > 0.0 && F2 > 0.0) {
+              G4double F = F2 / F1;
+              G4double M1 = 2.77 * MELE * PL;
+              G4double D[3] = { 0., 0., 0. };
+              D[0] = M1 * F2 * F2 * std::pow(F, NEX-1) / (QEX+1);
+              if (D[0] > 0.0) {
+                if (NEX >= 2) {
+                  D[1] = 0.0462 / parlev / G4cbrt(A) * QP * EEXS / QEX;
+                  if (EMP > eexs_cut)
+                    D[2] = D[1] * std::pow(EMP / EEXS, NEX) * (1.0 + CPA1);
+                  D[1] *= std::pow(EMN / EEXS, NEX) * getAL(A);
+                  if (QNP < 1) D[1] = 0.0;
+                  if (QPP < 1) D[2] = 0.0;
+                  try_again = NEX > 1 && (D[1] > width_cut * D[0] ||
+                                          D[2] > width_cut * D[0]);
+                  if (try_again) {
+                    G4double D5 = D[0] + D[1] + D[2];
+                    G4double SL = D5 * inuclRndm();
+                    G4double S1 = 0.;
+                    for (G4int i = 0; i < 3; i++) {
+                      S1 += D[i];
+                      if (SL <= S1) {
+                        icase = i;
+                        break;
                       };
+                    };
+                  };
+                    };
+                  };
+                };
+              } else try_again = false;
+            } else try_again = false;
+          }
+          if (try_again) {
+            if (icase > 0) { // N -> N - 1 with particle escape
+              if (verboseLevel > 3)
+                G4cout << " try_again icase " << icase << G4endl;
+              G4double V = 0.0;
+              G4int ptype = 0;
+              G4double B = 0.0;
+              if (A < 3.0) try_again = false;
+              if (try_again) {
+                if (icase == 1) { // neutron escape
+                  if (QNP < 1) {
+                    icase = 0;
+                  } else {
+                    B = BN;
+                    V = 0.0;
+                    ptype = 2;
+                  };
+                } else { // proton esape
+                  if (QPP < 1) {
+                    icase = 0;
+                  } else {
+                    B = BP;
+                    V = VP;
+                    ptype = 1;
+                    if (Z-1 < 1) try_again = false;
+                  };
+                };
+                if (try_again && icase != 0) {
+                  G4double EB = EEXS - B;
+                  G4double E = EB - V * A / (A-1);
+                  if (E < 0.0) icase = 0;
+                  else {
+                    G4double E1 = EB - V;
+                    G4double EEXS_new = -1.;
+                    G4double EPART = 0.0;
+                    G4int itry1 = 0;
+                    G4bool bad = true;
+                    while (itry1 < itry_max && icase > 0 && bad) {
+                      itry1++;
+                      G4int itry = 0;
+                      while (EEXS_new < 0.0 && itry < itry_max) {
+                        itry++;
+                        G4double R = inuclRndm();
+                        G4double X;
+                        if (NEX == 2) {
+                          X = 1.0 - std::sqrt(R);
+                        } else {
+                          G4double QEX2 = 1.0 / QEX;
+                          G4double QEX1 = 1.0 / (QEX-1);
+                          X = std::pow(0.5 * R, QEX2);
+                          for (G4int i = 0; i < 1000; i++) {
+                            G4double DX = X * QEX1 *
+                              (1.0 + QEX2 * X * (1.0 - R / std::pow(X, NEX)) / (1.0 - X));
+                            X -= DX;
+                            if (std::fabs(DX / X) < 0.01) break;
+                          };
+                        };
+                        EPART = EB - X * E1;
+                        EEXS_new = EB - EPART * A / (A-1);
+                      } // while (EEXS_new < 0.0...
+                      if (itry == itry_max || EEXS_new < 0.0) {
+                        icase = 0;
+                        continue;
+                      }
+                      if (verboseLevel > 2)
+                        G4cout << " particle " << ptype << " escape " << G4endl;
+                      EPART /= GeV;             // From MeV to GeV
+                      G4InuclElementaryParticle particle(ptype);
+                      particle.setModel(5);
+                      // generate particle momentum
+                      G4double mass = particle.getMass();
+                      G4double pmod = std::sqrt(EPART * (2.0 * mass + EPART));
+                      G4LorentzVector mom = generateWithRandomAngles(pmod,mass);
+                      // Push evaporated paricle into current rest frame
+                      mom = toTheExitonSystemRestFrame.backToTheLab(mom);
+                      // Adjust quasiparticle and nucleon counts
+                      G4int QPP_new = QPP;
+                      G4int QNP_new = QNP;
+                      G4int A_new = A-1;
+                      G4int Z_new = Z;
+                      if (ptype == 1) {
+                        QPP_new--;
+                        Z_new--;
+                      };
+                      if (ptype == 2) QNP_new--;
+                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;
+                }
+                      // New excitation energy depends on residual nuclear state
+                      G4double mass_new = G4InuclNuclei::getNucleiMass(A_new, Z_new);
+                      G4double EEXS_new = ((PEX-mom).m() - mass_new)*GeV;
+                      if (EEXS_new < 0.) continue;      // Sanity check for new nucleus
+                      if (verboseLevel > 3)
+                        G4cout << " EEXS_new " << EEXS_new << G4endl;
+                      PEX -= mom;
+                      EEXS = EEXS_new;
+                      A = A_new;
+                      Z = Z_new;
+                      NEX--;
+                      QEX--;
+                      QP--;
+                      QPP = QPP_new;
+                      QNP = QNP_new;
+                      particle.setMomentum(mom);
+                      output.addOutgoingParticle(particle);
+                      if (verboseLevel > 3) particle.printParticle();
+                      ppout += mom;
+                      if (verboseLevel > 3) {
+                        G4cout << " ppout px " << ppout.px() << " py " << ppout.py()
+                               << " pz " << ppout.pz() << " E " << ppout.e() << G4endl;
+                      }
+                      bad = false;
+                    }           // while (itry1<itry_max && icase>0
+                    if (itry1 == itry_max) icase = 0;
+                  }     // if (E < 0.) [else]
+                }       // if (try_again && icase != 0)
+              }         // if (try_again)
+            }           // if (icase > 0)
+            if (icase == 0 && try_again) { // N -> N + 2
+              G4double TNN = 1.6 * EFN + ESP;
+              G4double TNP = 1.6 * EFP + ESP;
+              G4double XNUN = 1.0 / (1.6 + ESP / EFN);
+              G4double XNUP = 1.0 / (1.6 + ESP / EFP);
+              G4double SNN1 = csNN(TNP) * XNUP;
+              G4double SNN2 = csNN(TNN) * XNUN;
+              G4double SPN1 = csPN(TNP) * XNUP;
+              G4double SPN2 = csPN(TNN) * XNUN;
+              G4double PP = (QPP * SNN1 + QNP * SPN1) * ZR;
+              G4double PN = (QPP * SPN2 + QNP * SNN2) * (AR - ZR);
+              G4double PW = PP + PN;
+              NEX += 2;
+              QEX += 2;
+              QP++;
+              QH++;
+              AR--;
+              if (AR > 1) {
+                G4double SL = PW * inuclRndm();
+                if (SL > PP) {
+                  QNP++;
+                  QNH++;
                 } else {
+                  try_again = false;
+                };
+              } else {
+                try_again = false;
+              };
+            };
+            if (try_again) {
+              if (icase > 0) { // N -> N - 1 with particle escape
+                G4double V = 0.0;
+                G4int ptype = 0;
+                G4double B = 0.0;
+                if (A < 3.0) try_again = false;
+                if (try_again) {
+                  if (icase == 1) { // neutron escape
+                    if (QNP < 1.0) {
+                      icase = 0;
+                    } else {
+                      B = BN;
+                      V = 0.0;
+                      ptype = 2;
+                    };
+                  } else { // proton esape
+                    if (QPP < 1.0) {
+                      icase = 0;
+                    } else {
+                      B = BP;
+                      V = VP;
+                      ptype = 1;
+                      if (Z - 1.0 < 1.0) try_again = false;
+                    };
+                  };
+                  if (try_again && icase != 0) {
+                    G4double EB = EEXS - B;
+                    G4double E = EB - V * A / (A - 1.0);
+                    if (E < 0.0) {
+                      icase = 0;
+                    } else {
+                      G4double E1 = EB - V;
+                      G4double EEXS_new = -1.;
+                      G4double EPART = 0.0;
+                      G4int itry1 = 0;
+                      G4bool bad = true;
+                      while (itry1 < itry_max && icase > 0 && bad) {
+                        itry1++;
+                        G4int itry = 0;
+                        while (EEXS_new < 0.0 && itry < itry_max) {
+                          itry++;
+                          G4double R = inuclRndm();
+                          G4double X;
+                          if (NEX == 2) {
+                            X = 1.0 - std::sqrt(R);
+                          } else {
+                            G4double QEX2 = 1.0 / QEX;
+                            G4double QEX1 = 1.0 / (QEX - 1.0);
+                            X = std::pow(0.5 * R, QEX2);
+                            for (G4int i = 0; i < 1000; i++) {
+                              G4double DX = X * QEX1 *
+                                (1.0 + QEX2 * X * (1.0 - R / std::pow(X, NEX)) / (1.0 - X));
+                              X -= DX;
+                              if (std::fabs(DX / X) < 0.01) break;
+                            };
+                          };
+                          EPART = EB - X * E1;
+                          EEXS_new = EB - EPART * A / (A - 1.0);
+                        };
+                        if (itry == itry_max || EEXS_new < 0.0) {
+                          icase = 0;
+                        } else { // real escape
+                          G4InuclElementaryParticle particle(ptype);
+                          particle.setModel(5);
+                          G4double mass = particle.getMass();
+                          EPART *= 0.001; // to the GeV
+                          // generate particle momentum
+                          G4double pmod = std::sqrt(EPART * (2.0 * mass + EPART));
+                          G4LorentzVector mom = generateWithRandomAngles(pmod,mass);
+                          G4LorentzVector mom_at_rest;
+                          G4double QPP_new = QPP;
+                          G4double Z_new = Z;
+                          if (ptype == 1) {
+                            QPP_new -= 1.;
+                            Z_new -= 1.0;
+                          };
+                          G4double QNP_new = QNP;
+                          if (ptype == 2) QNP_new -= 1.0;
+                          G4double A_new = A - 1.0;
+                          G4double new_exiton_mass =
+                            dummy_nuc.getNucleiMass(A_new, Z_new);
+                          mom_at_rest.setVectM(-mom.vect(), new_exiton_mass);
+                          G4LorentzVector part_mom =
+                            toTheExitonSystemRestFrame.backToTheLab(mom);
+                          part_mom.setVectM(part_mom.vect(), mass);
+                          G4LorentzVector ex_mom =
+                            toTheExitonSystemRestFrame.backToTheLab(mom_at_rest);
+                          ex_mom.setVectM(ex_mom.vect(), new_exiton_mass);
+                          //             check energy conservation and set new exitation energy
+                          EEXS_new = 1000.0 * (PEX.e() + 0.001 * EEXS -
+                                               part_mom.e() - ex_mom.e());
+                          if (EEXS_new > 0.0) { // everything ok
+                            particle.setMomentum(part_mom);
+                            output.addOutgoingParticle(particle);
+                            ppout += part_mom;
+                            A = A_new;
+                            Z = Z_new;
+                            PEX = ex_mom;
+                            EEXS = EEXS_new;
+                            NEX -= 1;
+                            QEX -= 1;
+                            QP -= 1.0;
+                            QPP = QPP_new;
+                            QNP = QNP_new;
+                            bad = false;
+                          };
+                        };
+                      };
+                      if (itry1 == itry_max) icase = 0;
+                    };
+                  };
+                };
+              };
+              if (icase == 0 && try_again) { // N -> N + 2
+                G4double TNN = 1.6 * EFN + ESP;
+                G4double TNP = 1.6 * EFP + ESP;
+                G4double XNUN = 1.0 / (1.6 + ESP / EFN);
+                G4double XNUP = 1.0 / (1.6 + ESP / EFP);
+                G4double SNN1 = csNN(TNP) * XNUP;
+                G4double SNN2 = csNN(TNN) * XNUN;
+                G4double SPN1 = csPN(TNP) * XNUP;
+                G4double SPN2 = csPN(TNN) * XNUN;
+                G4double PP = (QPP * SNN1 + QNP * SPN1) * ZR;
+                G4double PN = (QPP * SPN2 + QNP * SNN2) * (AR - ZR);
+                G4double PW = PP + PN;
+                NEX += 2;
+                QEX += 2.0;
+                QP += 1.0;
+                QH += 1.0;
+                AR -= 1.0;
+                if (AR > 1.0) {
+                  G4double SL = PW * inuclRndm();
+                  if (SL > PP) {
+                    QNP += 1.0;
+                    QNH += 1.0;
+                  } else {
+                    QPP += 1.0;
+                    QPH += 1.0;
+                    ZR -= 1.0;
+                    if (ZR < 2.0) try_again = false;
+                  };
+                } else {
+                  try_again = false;
+                };
+              };
+            };
+          } else {
+            try_again = false;
+          };
+        } else {
+          try_again = false;
+        };
+      } else {
+        try_again = false;
+      };
+    };
+    // everything finished, set output nuclei
+    // the exitation energy has to be re-set properly for the energy
+    // conservation
+                  QPP++;
+                  QPH++;
+                  ZR--;
+                  if (ZR < 2) try_again = false;
+                }
+              } else try_again = false;
+            }   // if (icase==0 && try_again)
+          }     // if (try_again)
+        } else try_again = false;       // if (EMN > eexs_cut)
+      } else try_again = false;         // if (QEX < sqrg(2*EG)
+    } else try_again = false;           // if (A > a_cut ...
+  }             // while (try_again)
+  // everything finished, set output nuclei
+  if (output.numberOfOutgoingParticles() == 0) {
+    output.addOutgoingNucleus(*nuclei_target);
+  } else {
     G4LorentzVector pnuc = pin - ppout;
+    G4InuclNuclei nuclei(pnuc, A, Z);
+    nuclei.setModel(5);
+    nuclei.setEnergy();
+    pnuc = nuclei.getMomentum();
+    G4double eout = pnuc.e() + ppout.e();
+    G4double eex_real = 1000.0 * (pin.e() - eout);
+    nuclei.setExitationEnergy(eex_real);
+    output.addTargetFragment(nuclei);
+    G4InuclNuclei nuclei(pnuc, A, Z, EEXS, 5);
+    if (verboseLevel > 3) {
+      G4cout << " remaining nucleus " << G4endl;
+      nuclei.printParticle();
+    }
+    output.addOutgoingNucleus(nuclei);
+  }
+  validateOutput(0, target, output);    // Check energy conservation, etc.
   return;
+}
 G4double G4NonEquilibriumEvaporator::getMatrixElement(G4double A) const {
+G4double G4NonEquilibriumEvaporator::getMatrixElement(G4int A) const {
   if (verboseLevel > 3) {
 …
   G4double me;
+  if (A > 150.0) {
+    me = 100.0;
+  } else if(A > 20.0) {
+    me = 140.0;
+  } else {
+    me = 70.0;
+  };
+  if (A > 150) me = 100.0;
+  else if (A > 20) me = 140.0;
+  else me = 70.0;
   return me;
+}
+G4double G4NonEquilibriumEvaporator::getE0(G4double ) const {
+G4double G4NonEquilibriumEvaporator::getE0(G4int ) const {
   if (verboseLevel > 3) {
     G4cout << " >>> G4NonEquilibriumEvaporator::getEO" << G4endl;
 …
+}
 G4double G4NonEquilibriumEvaporator::getParLev(G4double A,
                                                G4double ) const {
+G4double G4NonEquilibriumEvaporator::getParLev(G4int A,
+                                               G4int ) const {
   if (verboseLevel > 3) {

trunk/source/processes/hadronic/models/cascade/cascade/src/G4NuclWatcher.cc

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4NuclWatcher.cc,v 1.3 2010/06/25 09:44:54 gunter Exp $
 // Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4NuclWatcher.cc,v 1.5 2010/10/19 19:48:57 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100202  M. Kelsey -- Move most code here from .hh file, clean up
 // 20100405  M. Kelsey -- Pass const-ref std::vector<>
+// 20101010  M. Kelsey -- Migrate to integer A and Z
+// 20101019  M. Kelsey -- CoVerity report: "!true" should be "!here"
 #include "G4NuclWatcher.hh"
 …
 #include <cmath>
 G4NuclWatcher::G4NuclWatcher(G4double z,
+G4NuclWatcher::G4NuclWatcher(G4int z,
                              const std::vector<G4double>& expa,
                              const std::vector<G4double>& expcs,
 …
     exper_err(experr), checkable(check), nucleable(nucl) {}
 void G4NuclWatcher::watch(G4double a, G4double z) {
+void G4NuclWatcher::watch(G4int a, G4int z) {
   const G4double small = 0.001;
   if (std::fabs(z-nuclz) >= small) return;
+  if (std::abs(z-nuclz) >= small) return;
   G4bool here = false;          // Increment specified nucleus count
   G4int  simulatedAsSize = simulated_as.size();
   for (G4int i = 0; i<simulatedAsSize && !true; i++) {
     if (std::fabs(simulated_as[i] - a) < small) {
+  for (G4int i = 0; i<simulatedAsSize && !here; i++) {
+    if (std::abs(simulated_as[i] - a) < small) {
       simulated_cs[i] += 1.0;
       here = true;              // Terminates loop

trunk/source/processes/hadronic/models/cascade/cascade/src/G4NucleiModel.cc

-              r1337
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+//
+// $Id: G4NucleiModel.cc,v 1.48.2.1 2010/06/25 09:44:56 gunter Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4NucleiModel.cc,v 1.87 2010/09/24 06:26:06 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-03-ref-09 $
 //
 // 20100112  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
 …
 //              calculations.  use G4Cascade*Channel for total xsec in pi-N
 //              N-N channels.  Move absorptionCrossSection() from SpecialFunc.
+//#define CHC_CHECK
+// 20100610  M. Kelsey -- Replace another random-angle code block; add some
+//              diagnostic output for partner-list production.
+// 20100617  M. Kelsey -- Replace preprocessor flag CHC_CHECK with
+//              G4CASCADE_DEBUG_CHARGE
+// 20100620  M. Kelsey -- Improve error message on empty partners list, add
+//              four-momentum checking after EPCollider
+// 20100621  M. Kelsey -- In boundaryTransition() account for momentum transfer
+//              to secondary by boosting into recoil nucleus "rest" frame.
+//              Don't need temporaries to create dummy "partners" for list.
+// 20100622  M. Kelsey -- Restore use of "bindingEnergy()" function name, which
+//              is now a wrapper for G4NucleiProperties::GetBindingEnergy().
+// 20100623  M. Kelsey -- Eliminate some temporaries terminating partner-list,
+//              discard recoil boost for now. Initialize all data
+//              members in ctors.  Allow generateModel() to be called
+//              mutliple times, by clearing vectors each time through;
+//              avoid extra work by returning if A and Z are same as
+//              before.
+// 20100628  M. Kelsey -- Two momentum-recoil bugs; don't subtract energies!
+// 20100715  M. Kelsey -- Make G4InuclNuclei in generateModel(), use for
+//              balance checking (only verbose>2) in generateParticleFate().
+// 20100721  M. Kelsey -- Use new G4CASCADE_CHECK_ECONS for conservation checks
+// 20100723  M. Kelsey -- Move G4CollisionOutput buffer to .hh for reuse
+// 20100726  M. Kelsey -- Preallocate arrays with number_of_zones dimension.
+// 20100902  M. Kelsey -- Remove resize(3) directives from qdeutron/acsecs
+// 20100907  M. Kelsey -- Limit interaction targets based on current nucleon
+//              counts (e.g., no pp if protonNumberCurrent < 2!)
+// 20100914  M. Kelsey -- Migrate to integer A and Z
 #include "G4NucleiModel.hh"
+#include "G4CascadeCheckBalance.hh"
 #include "G4CascadeInterpolator.hh"
 #include "G4CascadeNNChannel.hh"
 …
 #include "G4LorentzConvertor.hh"
 #include "G4Neutron.hh"
-#include "G4NucleiProperties.hh"
 #include "G4Proton.hh"
 …
 using namespace G4InuclSpecialFunctions;
 typedef std::vector<G4InuclElementaryParticle>::iterator particleIterator;
+G4NucleiModel::G4NucleiModel() : verboseLevel(0) {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4NucleiModel::G4NucleiModel" << G4endl;
+  }
+}
+G4NucleiModel::G4NucleiModel(G4InuclNuclei* nuclei) : verboseLevel(0) {
+G4NucleiModel::G4NucleiModel()
+  : verboseLevel(0), A(0), Z(0), theNucleus(0),
+    neutronNumber(0), protonNumber(0),
+    neutronNumberCurrent(0), protonNumberCurrent(0), current_nucl1(0),
+    current_nucl2(0) {}
+G4NucleiModel::G4NucleiModel(G4int a, G4int z)
+  : verboseLevel(0), A(0), Z(0), theNucleus(0),
+    neutronNumber(0), protonNumber(0),
+    neutronNumberCurrent(0), protonNumberCurrent(0), current_nucl1(0),
+    current_nucl2(0) {
+  generateModel(a,z);
+}
+G4NucleiModel::G4NucleiModel(G4InuclNuclei* nuclei)
+  : verboseLevel(0), A(0), Z(0), theNucleus(0),
+    neutronNumber(0), protonNumber(0),
+    neutronNumberCurrent(0), protonNumberCurrent(0), current_nucl1(0),
+    current_nucl2(0) {
+  generateModel(nuclei);
+}
+void
+G4NucleiModel::generateModel(G4InuclNuclei* nuclei) {
   generateModel(nuclei->getA(), nuclei->getZ());
+}
 …
 void
+G4NucleiModel::generateModel(G4double a, G4double z) {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4NucleiModel::generateModel" << G4endl;
+G4NucleiModel::generateModel(G4int a, G4int z) {
+  if (verboseLevel) {
+    G4cout << " >>> G4NucleiModel::generateModel A " << a << " Z " << z
+           << G4endl;
+  }
 …
   const G4double pion_vp = 0.007; // in GeV
   const G4double pion_vp_small = 0.007;
   const G4double radForSmall = 8.0; // fermi
   const G4double piTimes4thirds = 4.189; // 4 Pi/3
+  const G4double radForSmall = 8.0;     // Units 0.f fm?  R_p = 0.8768 fm
+  const G4double piTimes4thirds = 4.189; // 4 Pi/3      FIXME!
   const G4double mproton = G4Proton::Definition()->GetPDGMass() / GeV;
   const G4double mneutron = G4Neutron::Definition()->GetPDGMass() / GeV;
 …
   const G4double alfa6[6] = { 0.9, 0.6, 0.4, 0.2, 0.1, 0.05 };
+  // If model already built, just return; otherwise intialize everything
+  if (a == A && z == Z) {
+    if (verboseLevel > 1)
+      G4cout << " model already generated for A=" << a << ", Z=" << z << G4endl;
+    reset();            // Zeros out neutron/proton evaporates
+    return;
+  }
   A = a;
   Z = z;
+  delete theNucleus;
+  theNucleus = new G4InuclNuclei(A,Z);          // For conservation checking
   neutronNumber = a - z;
   protonNumber = z;
+  neutronNumberCurrent = neutronNumber;
+  protonNumberCurrent = protonNumber;
+// Set binding energies
+//  G4double dm = bindingEnergy(a, z);
+  G4double dm = G4NucleiProperties::GetBindingEnergy(G4lrint(a), G4lrint(z));
+  binding_energies.push_back(0.001 * std::fabs(G4NucleiProperties::GetBindingEnergy(G4lrint(a-1), G4lrint(z-1)) - dm)); // for P
+  binding_energies.push_back(0.001 * std::fabs(G4NucleiProperties::GetBindingEnergy(G4lrint(a-1), G4lrint(z)) - dm)); // for N
+  reset();
+  // Clear all parameters arrays for reloading
+  binding_energies.clear();
+  nucleon_densities.clear();
+  zone_potentials.clear();
+  fermi_momenta.clear();
+  zone_radii.clear();
+  // Set binding energies
+  G4double dm = bindingEnergy(a,z);
+  binding_energies.push_back(0.001 * std::fabs(bindingEnergy(a-1,z-1)-dm)); // for P
+  binding_energies.push_back(0.001 * std::fabs(bindingEnergy(a-1,z)-dm));   // for N
   G4double CU = cuu*G4cbrt(a); // half-density radius * 2.8197
 …
   G4double CU2 = 0.0;
+  if (a > 4.5) {
+    std::vector<G4double> ur;
+  // This will be used to pre-allocate lots of arrays below
+  number_of_zones = (a < 5) ? 1 : (a < 100) ? 3 : 6;
+  // Buffers used for zone-by-zone calculations
+  G4double ur[7];
+  G4double v[6];
+  G4double v1[6];
+  // These are passed into nested vectors, so can't be made C arrays
+  std::vector<G4double> rod(number_of_zones);
+  std::vector<G4double> pf(number_of_zones);
+  std::vector<G4double> vz(number_of_zones);
+  if (a > 4) {
     G4int icase = 0;
+    if (a > 99.5) {
+      number_of_zones = 6;
+      ur.push_back(-D1);
+    if (a > 99) {
+      ur[0] = -D1;
       for (G4int i = 0; i < number_of_zones; i++) {
         G4double y = std::log((1.0 + D) / alfa6[i] - 1.0);
         zone_radii.push_back(CU + AU * y);
         ur.push_back(y);
+        ur[i+1] = y;
+      }
+    } else if (a > 11.5) {
+      number_of_zones = 3;
+      ur.push_back(-D1);
+    } else if (a > 11) {
+      ur[0] = -D1;
       for (G4int i = 0; i < number_of_zones; i++) {
         G4double y = std::log((1.0 + D)/alfa3[i] - 1.0);
         zone_radii.push_back(CU + AU * y);
         ur.push_back(y);
+        ur[i+1] = y;
+      }
     } else {
-      number_of_zones = 3;
       icase = 1;
-      ur.push_back(0.0);
       G4double CU1 = CU * CU;
       CU2 = std::sqrt(CU1 * (1.0 - 1.0 / a) + 6.4);
+      ur[0] = 0.0;
       for (G4int i = 0; i < number_of_zones; i++) {
         G4double y = std::sqrt(-std::log(alfa3[i]));
         zone_radii.push_back(CU2 * y);
         ur.push_back(y);
+        ur[i+1] = y;
+      }
+    }
     G4double tot_vol = 0.0;
-    std::vector<G4double> v;
-    std::vector<G4double> v1;
     G4int i(0);
     for (i = 0; i < number_of_zones; i++) {
 …
       if (icase == 0) {
+        v0 = volNumInt(ur[i], ur[i + 1], CU, D1);
+        v0 = volNumInt(ur[i], ur[i+1], CU, D1);
       } else {
         v0 = volNumInt1(ur[i], ur[i + 1], CU2);
       };
+        v0 = volNumInt1(ur[i], ur[i+1], CU2);
+      }
       v.push_back(v0);
+      v[i] = v0;
       tot_vol += v0;
 …
       if (i > 0) v0 -= zone_radii[i-1]*zone_radii[i-1]*zone_radii[i-1];
       v1.push_back(v0);
+      v1[i] = v0;
+    }
     // Protons
     G4double dd0 = z/tot_vol/piTimes4thirds;
     std::vector<G4double> rod;
     std::vector<G4double> pf;
     std::vector<G4double> vz;
+    G4double dd0 = G4double(z)/tot_vol/piTimes4thirds;
+    rod.clear();
+    pf.clear();
+    vz.clear();
     for (i = 0; i < number_of_zones; i++) {
 …
     // Neutrons
     dd0 = (a - z)/tot_vol/piTimes4thirds;
+    dd0 = G4double(a-z)/tot_vol/piTimes4thirds;
     rod.clear();
     pf.clear();
 …
       pf.push_back(pff);
       vz.push_back(0.5 * pff * pff / mneutron + binding_energies[1]);
     };
+    }
     nucleon_densities.push_back(rod);
 …
     // pion stuff (primitive)
     std::vector<G4double> vp(number_of_zones, pion_vp);
+    const std::vector<G4double> vp(number_of_zones, pion_vp);
     zone_potentials.push_back(vp);
     // kaon potential (primitive)
     std::vector<G4double> kp(number_of_zones, -0.015);
+    const std::vector<G4double> kp(number_of_zones, -0.015);
     zone_potentials.push_back(kp);
     // hyperon potential (primitive)
     std::vector<G4double> hp(number_of_zones, 0.03);
+    const std::vector<G4double> hp(number_of_zones, 0.03);
     zone_potentials.push_back(hp);
   } else { // a < 5
-    number_of_zones = 1;
     G4double smallRad = radForSmall;
     if (a == 4) smallRad *= 0.7;
 …
     // proton
-    std::vector<G4double> rod;
-    std::vector<G4double> pf;
-    std::vector<G4double> vz;
     for (G4int i = 0; i < number_of_zones; i++) {
       G4double rd = vol*z;
 …
     // pion (primitive)
     std::vector<G4double> vp(number_of_zones, pion_vp_small);
+    const std::vector<G4double> vp(number_of_zones, pion_vp_small);
     zone_potentials.push_back(vp);
     // kaon potential (primitive)
     std::vector<G4double> kp(number_of_zones, -0.015);
+    const std::vector<G4double> kp(number_of_zones, -0.015);
     zone_potentials.push_back(kp);
     // hyperon potential (primitive)
     std::vector<G4double> hp(number_of_zones, 0.03);
+    const std::vector<G4double> hp(number_of_zones, 0.03);
     zone_potentials.push_back(hp);
+  }
   nuclei_radius = zone_radii[zone_radii.size() - 1];
-  /*
-  // Print nuclear radii and densities
-  G4cout << " For A = " << a << " zone radii = ";
-  for (G4int i = 0; i < number_of_zones; i++) G4cout << zone_radii[i] << "  ";
-  G4cout << "  " << G4endl;
-  G4cout << " proton densities: ";
-  for (G4int i = 0; i < number_of_zones; i++)
-     G4cout << nucleon_densities[0][i] << "  ";
-  G4cout << G4endl;
-  G4cout << " neutron densities: ";
-  for (G4int i = 0; i < number_of_zones; i++)
-     G4cout << nucleon_densities[1][i] << "  ";
-  G4cout << G4endl;
-  G4cout << " protons per shell " ;
-  G4double rinner = 0.0;
-  G4double router = 0.0;
-  G4double shellVolume = 0.0;
-  for (G4int i = 0; i < number_of_zones; i++) {  // loop over zones
-    router = zone_radii[i];
-    shellVolume = piTimes4thirds*(router*router*router - rinner*rinner*rinner);
-    G4cout << G4lrint(shellVolume*nucleon_densities[0][i]) << "  ";
-    rinner = router;
+  }
-  G4cout << G4endl;
-  G4cout << " neutrons per shell " ;
-  rinner = 0.0;
-  router = 0.0;
-  shellVolume = 0.0;
-  for (G4int i = 0; i < number_of_zones; i++) {  // loop over zones
-    router = zone_radii[i];
-    shellVolume = piTimes4thirds*(router*router*router - rinner*rinner*rinner);
-    G4cout << G4lrint(shellVolume*nucleon_densities[1][i]) << "  ";
-    rinner = router;
+  }
-  G4cout << G4endl;
-  */
+}
 …
 G4NucleiModel::volNumInt(G4double r1, G4double r2,
                          G4double, G4double d1) const {
+  if (verboseLevel > 3) {
+  if (verboseLevel > 1) {
     G4cout << " >>> G4NucleiModel::volNumInt" << G4endl;
+  }
 …
       r += dr1;
       fi += r * (r + d2) / (1.0 + std::exp(r));
     };
+    }
     fun = 0.5 * fun1 + fi * dr;
 …
 G4NucleiModel::volNumInt1(G4double r1, G4double r2,
                           G4double cu2) const {
   if (verboseLevel > 3) {
+  if (verboseLevel > 1) {
     G4cout << " >>> G4NucleiModel::volNumInt1" << G4endl;
+  }
 …
 void G4NucleiModel::printModel() const {
+  if (verboseLevel > 3) {
+  if (verboseLevel > 1) {
     G4cout << " >>> G4NucleiModel::printModel" << G4endl;
+  }
   G4cout << " nuclei model for A " << A << " Z " << Z << G4endl
          << " proton binding energy " << binding_energies[0] <<
     " neutron binding energy " << binding_energies[1] << G4endl
          << " Nculei radius " << nuclei_radius << " number of zones " <<
     number_of_zones << G4endl;
+         << " proton binding energy " << binding_energies[0]
+         << " neutron binding energy " << binding_energies[1] << G4endl
+         << " Nuclei radius " << nuclei_radius << " number of zones "
+         << number_of_zones << G4endl;
   for (G4int i = 0; i < number_of_zones; i++)
     G4cout << " zone " << i+1 << " radius " << zone_radii[i] << G4endl
            << " protons: density " << getDensity(1,i) << " PF " <<
 …
 G4InuclElementaryParticle
 G4NucleiModel::generateNucleon(G4int type, G4int zone) const {
   if (verboseLevel > 3) {
+  if (verboseLevel > 1) {
     G4cout << " >>> G4NucleiModel::generateNucleon" << G4endl;
+  }
 …
 G4NucleiModel::generateQuasiDeutron(G4int type1, G4int type2,
                                     G4int zone) const {
+  if (verboseLevel > 3) {
+  if (verboseLevel > 1) {
     G4cout << " >>> G4NucleiModel::generateQuasiDeutron" << G4endl;
+  }
 …
 void
 G4NucleiModel::generateInteractionPartners(G4CascadParticle& cparticle) {
   if (verboseLevel > 3) {
+  if (verboseLevel > 1) {
     G4cout << " >>> G4NucleiModel::generateInteractionPartners" << G4endl;
+  }
   const G4double pi4by3 = 4.1887903; // 4 Pi / 3
+  const G4double pi4by3 = 4.1887903; // 4 Pi / 3        FIXME!
   const G4double small = 1.0e-10;
   const G4double huge_num = 50.0;
 …
     r_in = zone_radii[zone - 1];
     r_out = zone_radii[zone];
   };
+  }
   G4double path = cparticle.getPathToTheNextZone(r_in, r_out);
   if (verboseLevel > 2){
+  if (verboseLevel > 2) {
     G4cout << " r_in " << r_in << " r_out " << r_out << " path " << path << G4endl;
+  }
+  if (path < -small) { // something wrong
+  if (path < -small) {                  // something wrong
+    G4cerr << " generateInteractionPartners-> negative path length" << G4endl;
     return;
+  } else if (std::fabs(path) < small) { // just on the boundary
+    path = 0.0;
+    G4InuclElementaryParticle particle; // Dummy -- no type or momentum
+    thePartners.push_back(partner(particle, path));
+  } else { // normal case
+    G4LorentzConvertor dummy_convertor;
+    dummy_convertor.setBullet(pmom, pmass);
+    for (G4int ip = 1; ip < 3; ip++) {
+      G4InuclElementaryParticle particle = generateNucleon(ip, zone);
+      dummy_convertor.setTarget(particle.getMomentum(), particle.getMass());
+  }
+  if (std::fabs(path) < small) {        // just on the boundary
+    if (verboseLevel > 3)
+      G4cout << " generateInteractionPartners-> zero path" << G4endl;
+    thePartners.push_back(partner());   // Dummy list terminator with zero path
+    return;
+  }
+  G4LorentzConvertor dummy_convertor;
+  dummy_convertor.setBullet(pmom, pmass);
+  for (G4int ip = 1; ip < 3; ip++) {
+    // Only process nucleons which remain active in target
+    if (ip==1 && protonNumberCurrent < 1) continue;
+    if (ip==2 && neutronNumberCurrent < 1) continue;
+    // All nucleons are assumed to be at rest when colliding
+    G4InuclElementaryParticle particle = generateNucleon(ip, zone);
+    dummy_convertor.setTarget(particle.getMomentum(), particle.getMass());
+    G4double ekin = dummy_convertor.getKinEnergyInTheTRS();
+    G4double csec = totalCrossSection(ekin, ptype * ip);
+    if(verboseLevel > 2) {
+      G4cout << " ip " << ip << " ekin " << ekin << " csec " << csec << G4endl;
+    }
+    G4double dens = nucleon_densities[ip - 1][zone];
+    G4double rat = getRatio(ip);
+    G4double pw = -path * dens * csec * rat;
+    if (pw < -huge_num) pw = -huge_num;
+    pw = 1.0 - std::exp(pw);
+    if (verboseLevel > 2) {
+      G4cout << " pw " << pw << " rat " << rat << G4endl;
+    }
+    G4double spath = path;
+    if (inuclRndm() < pw) {
+      spath = -1.0 / dens / csec / rat * std::log(1.0 - pw * inuclRndm());
+      if (cparticle.young(young_cut, spath)) spath = path;
+      if (verboseLevel > 2) {
+        G4cout << " ip " << ip << " spath " << spath << G4endl;
+      }
+    }
+    if (spath < path) {
+      if (verboseLevel > 3) {
+        G4cout << " adding partner[" << thePartners.size() << "]: ";
+        particle.printParticle();
+      }
+      thePartners.push_back(partner(particle, spath));
+    }
+  }
+  if (verboseLevel > 2) {
+    G4cout << " after nucleons " << thePartners.size() << " path " << path << G4endl;
+  }
+  if (cparticle.getParticle().pion()) { // absorption possible
+    if (verboseLevel > 2) {
+      G4cout << " trying quasi-deuterons with bullet: ";
+      cparticle.getParticle().printParticle();
+    }
+    // Initialize buffers for quasi-deuteron results
+    qdeutrons.clear();
+    acsecs.clear();
+    G4double tot_abs_csec = 0.0;
+    G4double abs_sec;
+    G4double vol = zone_radii[zone]*zone_radii[zone]*zone_radii[zone];
+    if (zone > 0) vol -= zone_radii[zone-1]*zone_radii[zone-1]*zone_radii[zone-1];
+    vol *= pi4by3;
+    G4double rat  = getRatio(1);
+    G4double rat1 = getRatio(2);
+    // FIXME:  Shouldn't be creating zero-cross-section states!
+    // Proton-proton state interacts with pi-, pi0 only
+    G4InuclElementaryParticle ppd = generateQuasiDeutron(1, 1, zone);
+    if (protonNumberCurrent < 2 || !(ptype == pi0 || ptype == pim)) {
+      abs_sec = 0.0;
+    } else {
+      dummy_convertor.setTarget(ppd.getMomentum(), ppd.getMass());
       G4double ekin = dummy_convertor.getKinEnergyInTheTRS();
+      // Total cross section converted from mb to fm**2
+      G4double csec = totalCrossSection(ekin, ptype * ip);
+      if(verboseLevel > 2){
+        G4cout << " ip " << ip << " ekin " << ekin << " csec " << csec << G4endl;
+      if (verboseLevel > 2) {
+        G4cout << " ptype=" << ptype << " using pp target" << G4endl;
+        ppd.printParticle();
+      }
+      G4double dens = nucleon_densities[ip - 1][zone];
+      G4double rat = getRatio(ip);
+      G4double pw = -path * dens * csec * rat;
+      if (pw < -huge_num) pw = -huge_num;
+      pw = 1.0 - std::exp(pw);
+      if (verboseLevel > 2){
+        G4cout << " pw " << pw << " rat " << rat << G4endl;
+      }
+      G4double spath = path;
+      if (inuclRndm() < pw) {
+        spath = -1.0 / dens / csec / rat * std::log(1.0 - pw * inuclRndm());
+        if (cparticle.young(young_cut, spath)) spath = path;
+        if (verboseLevel > 2){
+          G4cout << " ip " << ip << " spath " << spath << G4endl;
+        }
+      };
+      if (spath < path) thePartners.push_back(partner(particle, spath));
+    };
+    if (verboseLevel > 2){
+      G4cout << " after nucleons " << thePartners.size() << " path " << path << G4endl;
+    }
+    if (cparticle.getParticle().pion()) { // absorption possible
+      if (verboseLevel > 2) {
+        G4cout << " trying quasi-deuterons with bullet: ";
+        cparticle.getParticle().printParticle();
+      }
+      std::vector<G4InuclElementaryParticle> qdeutrons(3);
+      std::vector<G4double> acsecs(3);
+      G4double tot_abs_csec = 0.0;
+      G4double abs_sec;
+      G4double vol = zone_radii[zone]*zone_radii[zone]*zone_radii[zone];
+      if (zone > 0) vol -= zone_radii[zone-1]*zone_radii[zone-1]*zone_radii[zone-1];
+      vol *= pi4by3;
+      G4double rat  = getRatio(1);
+      G4double rat1 = getRatio(2);
+      G4InuclElementaryParticle ppd = generateQuasiDeutron(1, 1, zone);
+      if (ptype == 7 || ptype == 5) {
+        dummy_convertor.setTarget(ppd.getMomentum(), ppd.getMass());
+        G4double ekin = dummy_convertor.getKinEnergyInTheTRS();
+        if (verboseLevel > 2) {
+          G4cout << " ptype=" << ptype << " using pp target" << G4endl;
+          ppd.printParticle();
+        }
+        abs_sec = absorptionCrossSection(ekin, ptype);
+        abs_sec *= nucleon_densities[0][zone] * nucleon_densities[0][zone]*
+          rat * rat * vol;
+      } else {
+        abs_sec = 0.0;
+      };
+      // abs_sec = 0.0;
+      tot_abs_csec += abs_sec;
+      acsecs.push_back(abs_sec);
+      qdeutrons.push_back(ppd);
+      G4InuclElementaryParticle npd = generateQuasiDeutron(1, 2, zone);
+      abs_sec = absorptionCrossSection(ekin, ptype);
+      abs_sec *= nucleon_densities[0][zone] * nucleon_densities[0][zone]*
+        rat * rat * vol;
+    }
+    tot_abs_csec += abs_sec;
+    acsecs.push_back(abs_sec);
+    qdeutrons.push_back(ppd);
+    // Proton-neutron state interacts with any pion type
+    G4InuclElementaryParticle npd = generateQuasiDeutron(1, 2, zone);
+    if (protonNumberCurrent < 1 || neutronNumberCurrent < 1) {
+      abs_sec = 0.0;
+    } else {
       dummy_convertor.setTarget(npd.getMomentum(), npd.getMass());
       G4double ekin = dummy_convertor.getKinEnergyInTheTRS();
       if (verboseLevel > 2) {
         G4cout << " using np target" << G4endl;
         npd.printParticle();
+      }
       abs_sec = absorptionCrossSection(ekin, ptype);
       abs_sec *= pn_spec * nucleon_densities[0][zone] * nucleon_densities[1][zone] *
+        rat * rat1 * vol;
+      tot_abs_csec += abs_sec;
+      acsecs.push_back(abs_sec);
+      qdeutrons.push_back(npd);
+      G4InuclElementaryParticle nnd = generateQuasiDeutron(2, 2, zone);
+      if (ptype == 7 || ptype == 3) {
+        dummy_convertor.setTarget(nnd.getMomentum(), nnd.getMass());
+        G4double ekin = dummy_convertor.getKinEnergyInTheTRS();
+        if (verboseLevel > 2) {
+          G4cout << " ptype=" << ptype << " using nn target" << G4endl;
+          nnd.printParticle();
+        rat * rat1 * vol;
+    }
+    tot_abs_csec += abs_sec;
+    acsecs.push_back(abs_sec);
+    qdeutrons.push_back(npd);
+    // Neutron-neutron state interacts with pi+, pi0 only
+    G4InuclElementaryParticle nnd = generateQuasiDeutron(2, 2, zone);
+    if (neutronNumberCurrent < 2 || !(ptype == pi0 || ptype == pip)) {
+      abs_sec = 0.0;
+    } else {
+      dummy_convertor.setTarget(nnd.getMomentum(), nnd.getMass());
+      G4double ekin = dummy_convertor.getKinEnergyInTheTRS();
+      if (verboseLevel > 2) {
+        G4cout << " ptype=" << ptype << " using nn target" << G4endl;
+        nnd.printParticle();
+      }
+      abs_sec = absorptionCrossSection(ekin, ptype);
+      abs_sec *= nucleon_densities[1][zone] * nucleon_densities[1][zone] *
+        rat1 * rat1 * vol;
+    }
+    tot_abs_csec += abs_sec;
+    acsecs.push_back(abs_sec);
+    qdeutrons.push_back(nnd);
+    // Select quasideuteron interaction from non-zero cross-section choices
+    if (verboseLevel > 2){
+      G4cout << " rod1 " << acsecs[0] << " rod2 " << acsecs[1]
+             << " rod3 " << acsecs[2] << G4endl;
+    }
+    if (tot_abs_csec > small) {
+      G4double pw = -path * tot_abs_csec;
+      if (pw < -huge_num) pw = -huge_num;
+      pw = 1.0 - std::exp(pw);
+      if (verboseLevel > 2){
+        G4cout << " pw " << pw << G4endl;
+      }
+      G4double apath = path;
+      if (inuclRndm() < pw)
+        apath = -1.0 / tot_abs_csec * std::log(1.0 - pw * inuclRndm());
+      if (cparticle.young(young_cut, apath)) apath = path;
+      if(verboseLevel > 2){
+        G4cout << " apath " << apath << " path " << path << G4endl;
+      }
+      if (apath < path) {       // choose the qdeutron
+        G4double sl = inuclRndm() * tot_abs_csec;
+        G4double as = 0.0;
+        for (G4int i = 0; i < 3; i++) {
+          as += acsecs[i];
+          if (sl < as) {
+            if (verboseLevel > 2) G4cout << " deut type " << i << G4endl;
+            thePartners.push_back(partner(qdeutrons[i], apath));
+            break;
+          }
+        }
+        abs_sec = absorptionCrossSection(ekin, ptype);
+        abs_sec *= nucleon_densities[1][zone] * nucleon_densities[1][zone] *
+          rat1 * rat1 * vol;
+      } else {
+        abs_sec = 0.0;
+      };
+      // abs_sec = 0.0;
+      tot_abs_csec += abs_sec;
+      acsecs.push_back(abs_sec);
+      qdeutrons.push_back(nnd);
+      if (verboseLevel > 2){
+        G4cout << " rod1 " << acsecs[0] << " rod2 " << acsecs[1]
+               << " rod3 " << acsecs[2] << G4endl;
+      }
+      if (tot_abs_csec > small) {
+        G4double pw = -path * tot_abs_csec;
+        if (pw < -huge_num) pw = -huge_num;
+        pw = 1.0 - std::exp(pw);
+        if (verboseLevel > 2){
+          G4cout << " pw " << pw << G4endl;
+        }
+        G4double apath = path;
+        if (inuclRndm() < pw)
+          apath = -1.0 / tot_abs_csec * std::log(1.0 - pw * inuclRndm());
+        if (cparticle.young(young_cut, apath)) apath = path;
+        if(verboseLevel > 2){
+          G4cout << " apath " << apath << " path " << path << G4endl;
+        }
+        if (apath < path) { // chose the qdeutron
+          G4double sl = inuclRndm() * tot_abs_csec;
+          G4double as = 0.0;
+          for (G4int i = 0; i < 3; i++) {
+            as += acsecs[i];
+            if (sl < as) {
+              if (verboseLevel > 2){
+                G4cout << " deut type " << i << G4endl;
+              }
+              thePartners.push_back(partner(qdeutrons[i], apath));
+              break;
+            };
+          };
+        };
+      };
+    };
+    if(verboseLevel > 2){
+      G4cout << " after deutrons " << thePartners.size() << G4endl;
+    }
+    if (thePartners.size() > 1) {               // Sort list by path length
+      std::sort(thePartners.begin(), thePartners.end(), sortPartners);
+    }
+    G4InuclElementaryParticle particle;         // Dummy for end of list
+    thePartners.push_back(partner(particle, path));
+  }
+  return;
+      }
+    }
+  }
+  if (verboseLevel > 2) {
+    G4cout << " after deuterons " << thePartners.size() << " partners"
+           << G4endl;
+  }
+  if (thePartners.size() > 1) {         // Sort list by path length
+    std::sort(thePartners.begin(), thePartners.end(), sortPartners);
+  }
+  G4InuclElementaryParticle particle;           // Total path at end of list
+  thePartners.push_back(partner(particle, path));
+}
 …
 G4NucleiModel::generateParticleFate(G4CascadParticle& cparticle,
                                     G4ElementaryParticleCollider* theElementaryParticleCollider) {
   if (verboseLevel > 3)
+  if (verboseLevel > 1)
     G4cout << " >>> G4NucleiModel::generateParticleFate" << G4endl;
+  if (verboseLevel > 2) {
+    G4cout << " cparticle: ";
+    cparticle.print();
+  }
+  // Create four-vector checking
+#ifdef G4CASCADE_CHECK_ECONS
+  G4CascadeCheckBalance balance(0.005, 0.01, "G4NucleiModel");  // Second arg is in GeV
+  balance.setVerboseLevel(verboseLevel);
+#endif
   outgoing_cparticles.clear();          // Clear return buffer for this event
   generateInteractionPartners(cparticle);       // Fills "thePartners" data
   if (thePartners.empty()) { // smth. is wrong -> needs special treatment
+    G4cout << " generateParticleFate-> can not be here " << G4endl;
+    G4cerr << " generateParticleFate-> got empty interaction-partners list "
+           << G4endl;
     return outgoing_cparticles;
+  }
+  G4int npart = thePartners.size();
+  if (npart == 1) { // cparticle is on the next zone entry
+    // need to go here if particle outside nucleus ?
+    //
+  G4int npart = thePartners.size();     // Last item is a total-path placeholder
+  if (npart == 1) {             // cparticle is on the next zone entry
     cparticle.propagateAlongThePath(thePartners[0].second);
     cparticle.incrementCurrentPath(thePartners[0].second);
 …
     outgoing_cparticles.push_back(cparticle);
     if (verboseLevel > 2){
+    if (verboseLevel > 2) {
       G4cout << " next zone " << G4endl;
       cparticle.print();
+    }
+  } else { // there are possible interactions
+  } else {                      // there are possible interactions
+    if (verboseLevel > 1)
+      G4cout << " processing " << npart-1 << " possible interactions" << G4endl;
     G4ThreeVector old_position = cparticle.getPosition();
+    G4InuclElementaryParticle bullet = cparticle.getParticle();
+    G4InuclElementaryParticle& bullet = cparticle.getParticle();
     G4bool no_interaction = true;
     G4int zone = cparticle.getCurrentZone();
+    G4CollisionOutput output;
+    for (G4int i = 0; i < npart - 1; i++) {
+    for (G4int i=0; i<npart-1; i++) {   // Last item is a total-path placeholder
       if (i > 0) cparticle.updatePosition(old_position);
       G4InuclElementaryParticle target = thePartners[i].first;
       if (verboseLevel > 2){
         if (target.quasi_deutron())
           G4cout << " try absorption: target " << target.type() << " bullet " <<
             bullet.type() << G4endl;
+      G4InuclElementaryParticle& target = thePartners[i].first;
+      if (verboseLevel > 3) {
+        if (target.quasi_deutron()) G4cout << " try absorption: ";
+        G4cout << " target " << target.type() << " bullet " << bullet.type()
+               << G4endl;
+      }
+      output.reset();
+      theElementaryParticleCollider->collide(&bullet, &target, output);
+      if (verboseLevel > 2) output.printCollisionOutput();
+      EPCoutput.reset();
+      theElementaryParticleCollider->collide(&bullet, &target, EPCoutput);
+      if (verboseLevel > 2) {
+        EPCoutput.printCollisionOutput();
+#ifdef G4CASCADE_CHECK_ECONS
+        balance.collide(&bullet, &target, EPCoutput);
+        balance.okay();         // Do checks, but ignore result
+#endif
+      }
       // Don't need to copy list, as "output" isn't changed again below
       const std::vector<G4InuclElementaryParticle>& outgoing_particles =
+        output.getOutgoingParticles();
+      if (passFermi(outgoing_particles, zone)) { // interaction
+        cparticle.propagateAlongThePath(thePartners[i].second);
+        G4ThreeVector new_position = cparticle.getPosition();
+        for (G4int ip = 0; ip < G4int(outgoing_particles.size()); ip++) {
+          G4CascadParticle temp(outgoing_particles[ip], new_position, zone, 0.0, 0);
+          outgoing_cparticles.push_back(temp);
+        }
+        no_interaction = false;
+        current_nucl1 = 0;
+        current_nucl2 = 0;
+#ifdef CHC_CHECK
+        EPCoutput.getOutgoingParticles();
+      if (!passFermi(outgoing_particles, zone)) continue; // Interaction fails
+      // Successful interaction, add results to output list
+      cparticle.propagateAlongThePath(thePartners[i].second);
+      G4ThreeVector new_position = cparticle.getPosition();
+      if (verboseLevel > 2)
+        G4cout << " adding " << outgoing_particles.size()
+               << " output particles" << G4endl;
+      for (G4int ip = 0; ip < G4int(outgoing_particles.size()); ip++) {
+        G4CascadParticle temp(outgoing_particles[ip], new_position, zone, 0.0, 0);
+        outgoing_cparticles.push_back(temp);
+      }
+      no_interaction = false;
+      current_nucl1 = 0;
+      current_nucl2 = 0;
+#ifdef G4CASCADE_DEBUG_CHARGE
+      {
         G4double out_charge = 0.0;
 …
           out_charge += outgoing_particles[ip].getCharge();
+        G4cout << " multiplicity " << outgoing_particles.size() <<
+          " bul type " << bullet.type() << " targ type " << target.type() <<
+          G4endl << " initial charge " << bullet.getCharge() + target.getCharge()
+        G4cout << " multiplicity " << outgoing_particles.size()
+               << " bul type " << bullet.type()
+               << " targ type " << target.type()
+               << "\n initial charge "
+               << bullet.getCharge() + target.getCharge()
                << " out charge " << out_charge << G4endl;
+      }
 #endif
+        if (verboseLevel > 2){
+          G4cout << " partner type " << target.type() << G4endl;
+        }
+        if (target.nucleon()) {
+          current_nucl1 = target.type();
+        } else {
+          if (verboseLevel > 2) G4cout << " good absorption " << G4endl;
+          current_nucl1 = (target.type() - 100) / 10;
+          current_nucl2 = target.type() - 100 - 10 * current_nucl1;
+        }
+        if (current_nucl1 == 1) {
+          protonNumberCurrent -= 1.0;
+        } else {
+          neutronNumberCurrent -= 1.0;
+        };
+        if (current_nucl2 == 1) {
+          protonNumberCurrent -= 1.0;
+        } else if(current_nucl2 == 2) {
+          neutronNumberCurrent -= 1.0;
+        };
+        break;
+      };
+    }  // loop over partners
+    if (no_interaction) { // still no interactions
+      if (verboseLevel > 2)
+        G4cout << " partner type " << target.type() << G4endl;
+      if (target.nucleon()) {
+        current_nucl1 = target.type();
+      } else {
+        if (verboseLevel > 2) G4cout << " good absorption " << G4endl;
+        current_nucl1 = (target.type() - 100) / 10;
+        current_nucl2 = target.type() - 100 - 10 * current_nucl1;
+      }
+      if (current_nucl1 == 1) {
+        if (verboseLevel > 3) G4cout << " decrement proton count" << G4endl;
+        protonNumberCurrent--;
+      } else {
+        if (verboseLevel > 3) G4cout << " decrement neutron count" << G4endl;
+        neutronNumberCurrent--;
+      }
+      if (current_nucl2 == 1) {
+        if (verboseLevel > 3) G4cout << " decrement proton count" << G4endl;
+        protonNumberCurrent--;
+      } else if (current_nucl2 == 2) {
+        if (verboseLevel > 3) G4cout << " decrement neutron count" << G4endl;
+        neutronNumberCurrent--;
+      }
+      break;
+    }           // loop over partners
+    if (no_interaction) {               // still no interactions
+      if (verboseLevel > 1) G4cout << " no interaction " << G4endl;
+      // For conservation checking (below), get particle before updating
+      static G4InuclElementaryParticle prescatCP;       // Avoid memory churn
+      prescatCP = cparticle.getParticle();
+      // Last "partner" is just a total-path placeholder
       cparticle.updatePosition(old_position);
       cparticle.propagateAlongThePath(thePartners[npart - 1].second);
       cparticle.incrementCurrentPath(thePartners[npart - 1].second);
+      cparticle.propagateAlongThePath(thePartners[npart-1].second);
+      cparticle.incrementCurrentPath(thePartners[npart-1].second);
       boundaryTransition(cparticle);
       outgoing_cparticles.push_back(cparticle);
+    };
+  };
+      // Check conservation for simple scattering (ignore target nucleus!)
+#ifdef G4CASCADE_CHECK_ECONS
+      if (verboseLevel > 2) {
+        balance.collide(&prescatCP, 0, outgoing_cparticles);
+        balance.okay();         // Report violations, but don't act on them
+      }
+#endif
+    }
+  }     // if (npart == 1) [else]
   return outgoing_cparticles;
 …
 G4bool G4NucleiModel::passFermi(const std::vector<G4InuclElementaryParticle>& particles,
                                 G4int zone) {
+  if (verboseLevel > 1) {
+    G4cout << " >>> G4NucleiModel::passFermi" << G4endl;
+  }
+  // Only check Fermi momenta for nucleons
+  for (G4int i = 0; i < G4int(particles.size()); i++) {
+    if (!particles[i].nucleon()) continue;
+    G4int type   = particles[i].type();
+    G4double mom = particles[i].getMomModule();
+    G4double pf  = fermi_momenta[type-1][zone];
+    if (verboseLevel > 2)
+      G4cout << " type " << type << " p " << mom << " pf " << pf << G4endl;
+    if (mom < pf) {
+        if (verboseLevel > 2) G4cout << " rejected by Fermi" << G4endl;
+        return false;
+    }
+  }
+  return true;
+}
+void G4NucleiModel::boundaryTransition(G4CascadParticle& cparticle) {
+  if (verboseLevel > 1) {
+    G4cout << " >>> G4NucleiModel::boundaryTransition" << G4endl;
+  }
+  G4int zone = cparticle.getCurrentZone();
+  if (cparticle.movingInsideNuclei() && zone == 0) {
+    G4cerr << " boundaryTransition-> in zone 0 " << G4endl;
+    return;
+  }
+  G4LorentzVector mom = cparticle.getMomentum();
+  G4ThreeVector pos = cparticle.getPosition();
+  G4int type = cparticle.getParticle().type();
+  G4double pr = pos.dot(mom.vect());
+  G4double r = pos.mag();
+  pr /= r;
+  G4int next_zone = cparticle.movingInsideNuclei() ? zone - 1 : zone + 1;
+  G4double dv = getPotential(type,zone) - getPotential(type, next_zone);
+  //    G4cout << "Potentials for type " << type << " = "
+  //           << getPotential(type,zone) << " , "
+  //       << getPotential(type,next_zone) << G4endl;
+  G4double qv = dv * dv - 2.0 * dv * mom.e() + pr * pr;
+  G4double p1r;
   if (verboseLevel > 3) {
+    G4cout << " >>> G4NucleiModel::passFermi" << G4endl;
+  }
+  for (G4int i = 0; i < G4int(particles.size()); i++) {
+    if (particles[i].nucleon()) {
+      if (verboseLevel > 2){
+        G4cout << " type " << particles[i].type() << " p " << particles[i].getMomModule()
+               << " pf " << fermi_momenta[particles[i].type() - 1][zone] << G4endl;
+      }
+      if (particles[i].getMomModule() < fermi_momenta[particles[i].type() - 1][zone]) {
+        if (verboseLevel > 2) {
+          G4cout << " rejected by fermi: type " << particles[i].type() <<
+            " p " << particles[i].getMomModule() << G4endl;
+        }
+        return false;
+      };
+    };
+  };
+  return true;
+}
+void G4NucleiModel::boundaryTransition(G4CascadParticle& cparticle) {
+    G4cout << " type " << type << " zone " << zone << " next " << next_zone
+           << " qv " << qv << " dv " << dv << G4endl;
+  }
+  if (qv <= 0.0) {      // reflection
+    if (verboseLevel > 3) G4cout << " reflects off boundary" << G4endl;
+    p1r = -pr;
+    cparticle.incrementReflectionCounter();
+  } else {              // transition
+    if (verboseLevel > 3) G4cout << " passes thru boundary" << G4endl;
+    p1r = std::sqrt(qv);
+    if(pr < 0.0) p1r = -p1r;
+    cparticle.updateZone(next_zone);
+    cparticle.resetReflection();
+  }
+  G4double prr = (p1r - pr) / r;
   if (verboseLevel > 3) {
+    G4cout << " >>> G4NucleiModel::boundaryTransition" << G4endl;
+  }
+  G4int zone = cparticle.getCurrentZone();
+  if (cparticle.movingInsideNuclei() && zone == 0) {
+    G4cout << " boundaryTransition-> in zone 0 " << G4endl;
+  } else {
+    G4LorentzVector mom = cparticle.getMomentum();
+    G4ThreeVector pos = cparticle.getPosition();
+    G4int type = cparticle.getParticle().type();
+    G4double pr = pos.dot(mom.vect());
+    G4double r = pos.mag();
+    pr /= r;
+    G4int next_zone = cparticle.movingInsideNuclei() ? zone - 1 : zone + 1;
+    G4double dv = getPotential(type,zone) - getPotential(type, next_zone);
+    //    G4cout << "Potentials for type " << type << " = "
+    //           << getPotential(type,zone) << " , "
+    //     << getPotential(type,next_zone) << G4endl;
+    G4double qv = dv * dv - 2.0 * dv * mom.e() + pr * pr;
+    G4double p1r;
+    if (verboseLevel > 2){
+      G4cout << " type " << type << " zone " << zone
+             << " next " << next_zone
+             << " qv " << qv << " dv " << dv << G4endl;
+    }
+    if(qv <= 0.0) { // reflection
+      p1r = -pr;
+      cparticle.incrementReflectionCounter();
+    } else { // transition
+      p1r = std::sqrt(qv);
+      if(pr < 0.0) p1r = -p1r;
+      cparticle.updateZone(next_zone);
+      cparticle.resetReflection();
+    };
+    G4double prr = (p1r - pr) / r;
+    mom.setVect(mom.vect() + pos*prr);
+    cparticle.updateParticleMomentum(mom);
+  };
+    G4cout << " prr " << prr << " delta px " << prr*pos.x() << " py "
+           << prr*pos.y()  << " pz " << prr*pos.z() << " mag "
+           << std::fabs(prr*r) << G4endl;
+  }
+  mom.setVect(mom.vect() + pos*prr);
+  cparticle.updateParticleMomentum(mom);
+}
 G4bool G4NucleiModel::worthToPropagate(const G4CascadParticle& cparticle) const {
+  if (verboseLevel > 3) {
+  if (verboseLevel > 1) {
     G4cout << " >>> G4NucleiModel::worthToPropagate" << G4endl;
+  }
 …
              << worth << G4endl;
+    }
   };
+  }
   return worth;
+}
 G4double G4NucleiModel::getRatio(G4int ip) const {
+  if (verboseLevel > 3) {
+  if (verboseLevel > 1) {
     G4cout << " >>> G4NucleiModel::getRatio" << G4endl;
+  }
-  G4double rat;
-  //  G4double ratm;
-  // Calculate number of protons and neutrons in local region
-  //  G4double Athird = G4cbrt(A);
-  //  G4double Nneut = Athird*(A-Z)/A;
-  //  G4double Nprot = Athird*Z/A;
-  // Reduce number of
   if (ip == 1) {
+    if (verboseLevel > 2) {
+      G4cout << " current " << protonNumberCurrent << " inp " << protonNumber
+             << G4endl;
+    }
+    return G4double(protonNumberCurrent)/G4double(protonNumber);
+  }
+  if (ip == 2) {
     if (verboseLevel > 2){
+      G4cout << " current " << protonNumberCurrent << " inp " << protonNumber << G4endl;
+    }
+    rat = protonNumberCurrent/protonNumber;
+    // Calculate ratio modified for local region
+    //    G4double deltaP = protonNumber - protonNumberCurrent;
+    //    G4cout << " deltaP = " << deltaP << G4endl;
+    //    ratm = std::max(0.0, (Nprot - deltaP)/Nprot);
+  } else {
+    if (verboseLevel > 2){
+      G4cout << " current " << neutronNumberCurrent << " inp " << neutronNumber << G4endl;
+    }
+    rat = neutronNumberCurrent/neutronNumber;
+    // Calculate ratio modified for local region
+    //    G4double deltaN = neutronNumber - neutronNumberCurrent;
+    //   G4cout << " deltaN = " << deltaN << G4endl;
+    //    ratm = std::max(0.0, (Nneut - deltaN)/Nneut);
+  }
+  //  G4cout << " get ratio: ratm =  " << ratm << G4endl;
+  return rat;
+  //  return ratm;
+}
+G4CascadParticle G4NucleiModel::initializeCascad(G4InuclElementaryParticle* particle) {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4NucleiModel::initializeCascad(G4InuclElementaryParticle* particle)" << G4endl;
+      G4cout << " current " << neutronNumberCurrent << " inp " << neutronNumber
+             << G4endl;
+    }
+    return G4double(neutronNumberCurrent)/G4double(neutronNumber);
+  }
+  return 0.;
+}
+G4CascadParticle
+G4NucleiModel::initializeCascad(G4InuclElementaryParticle* particle) {
+  if (verboseLevel > 1) {
+    G4cout << " >>> G4NucleiModel::initializeCascad(particle)" << G4endl;
+  }
   const G4double large = 1000.0;
+  G4double s1 = std::sqrt(inuclRndm());
+  G4double phi = randomPHI();
+  G4double rz = nuclei_radius * s1;
+  G4ThreeVector pos(rz*std::cos(phi), rz*std::sin(phi),
+                    -nuclei_radius*std::sqrt(1.0 - s1*s1));
+  // FIXME:  Previous version generated random sin(theta), then used -cos(theta)
+  //         Using generateWithRandomAngles changes result!
+  // G4ThreeVector pos = generateWithRandomAngles(nuclei_radius).vect();
+  G4double costh = std::sqrt(1.0 - inuclRndm());
+  G4ThreeVector pos = generateWithFixedTheta(-costh, nuclei_radius);
   G4CascadParticle cpart(*particle, pos, number_of_zones, large, 0);
 …
                                      G4InuclNuclei* target,
                                      modelLists& output) {
   if (verboseLevel > 3) {
     G4cout << " >>> G4NucleiModel::initializeCascad(G4InuclNuclei* bullet, G4InuclNuclei* target)" << G4endl;
+  if (verboseLevel) {
+    G4cout << " >>> G4NucleiModel::initializeCascad(bullet,target,output)"
+           << G4endl;
+  }
 …
   // first decide whether it will be cascad or compound final nuclei
   G4double ab = bullet->getA();
   G4double zb = bullet->getZ();
   G4double at = target->getA();
   G4double zt = target->getZ();
+  G4int ab = bullet->getA();
+  G4int zb = bullet->getZ();
+  G4int at = target->getA();
+  G4int zt = target->getZ();
   G4double massb = bullet->getMass();   // For creating LorentzVectors below
 …
   if (ab < max_a_for_cascad) {
     G4double benb = 0.001 * G4NucleiProperties::GetBindingEnergy(G4lrint(ab), G4lrint(zb)) / ab;
     G4double bent = 0.001 * G4NucleiProperties::GetBindingEnergy(G4lrint(at), G4lrint(zt)) / at;
+    G4double benb = 0.001 * bindingEnergy(ab,zb) / G4double(ab);
+    G4double bent = 0.001 * bindingEnergy(at,zt) / G4double(at);
     G4double ben = benb < bent ? bent : benb;
 …
       while (casparticles.size() == 0 && itryg < itry_max) {
         itryg++;
+        if(itryg > 0) particles.clear();
+        particles.clear();
         //    nucleons coordinates and momenta in nuclei rest frame
         std::vector<G4ThreeVector> coordinates;
         std::vector<G4LorentzVector> momentums;
+        coordinates.clear();
+        momentums.clear();
         if (ab < 3.0) { // deutron, simplest case
+        if (ab < 3) { // deuteron, simplest case
           G4double r = 2.214 - 3.4208 * std::log(1.0 - 0.981 * inuclRndm());
+          G4double s = 2.0 * inuclRndm() - 1.0;
+          G4double r1 = r * std::sqrt(1.0 - s * s);
+          G4double phi = randomPHI();
+          G4ThreeVector coord1(r1*std::cos(phi), r1*std::sin(phi), r*s);
+          G4ThreeVector coord1 = generateWithRandomAngles(r).vect();
           coordinates.push_back(coord1);
+          coord1 *= -1.;
+          coordinates.push_back(coord1);
+          coordinates.push_back(-coord1);
           G4double p = 0.0;
 …
             if (p * p / (p * p + 2079.36) / (p * p + 2079.36) > 1.2023e-4 * inuclRndm() &&
                p * r > 312.0) bad = false;
           };
+          }
           if (itry == itry_max)
 …
           momentums.push_back(-mom);
         } else {
-          G4int ia = int(ab + 0.5);
           G4ThreeVector coord1;
 …
           G4int itry = 0;
           if (ab < 4.0) { // a == 3
+          if (ab == 3) {
             while (badco && itry < itry_max) {
               if (itry > 0) coordinates.clear();
 …
+                    }
                     break;
                   };
                 };
+                  }
+                }
                 if (itry1 == itry_max) { // bad case
 …
                   coordinates.push_back(coord1);
                   break;
                 };
               };
+                }
+              }
               coord1 = -coordinates[0] - coordinates[1];
 …
                     break;
                   };
                 };
+                  }
+                }
                 if (large_dist) break;
               };
+              }
               if(!large_dist) badco = false;
             };
+            }
           } else { // a >= 4
 …
               G4int i(0);
               for (i = 0; i < ia-1; i++) {
+              for (i = 0; i < ab-1; i++) {
                 G4int itry1 = 0;
                 G4double s, u;
 …
                     break;
                   };
                 };
+                  }
+                }
                 if (itry1 == itry_max) { // bad case
 …
                   coordinates.push_back(coord1);
                   break;
                 };
               };
+                }
+              }
               coord1 *= 0.0;    // Cheap way to reset
               for(G4int j = 0; j < ia -1; j++) coord1 -= coordinates[j];
+              for(G4int j = 0; j < ab -1; j++) coord1 -= coordinates[j];
               coordinates.push_back(coord1);
 …
               G4bool large_dist = false;
               for (i = 0; i < ia-1; i++) {
                 for (G4int j = i+1; j < ia; j++) {
+              for (i = 0; i < ab-1; i++) {
+                for (G4int j = i+1; j < ab; j++) {
                   G4double r2 = (coordinates[i]-coordinates[j]).mag2();
 …
                     break;
                   };
                 };
+                  }
+                }
                 if (large_dist) break;
               };
+              }
               if (!large_dist) badco = false;
             };
           };
+            }
+          }
           if(badco) {
 …
             G4LorentzVector mom;
             //G4bool badp = True;
+            G4int i(0);
+            for (i = 0; i < ia - 1; i++) {
+            for (G4int i = 0; i < ab - 1; i++) {
               G4int itry = 0;
 …
                   break;
                 };
               };
+                }
+              }
               if(itry == itry_max) {
 …
                 particles.clear();
                 return;
               };
             };
+              }
+            }
             // last momentum
             mom *= 0.;          // Cheap way to reset
+            for(G4int j=0; j< ia-1; j++) mom -= momentums[j];
+            mom.setE(bullet->getEnergy()+target->getEnergy());
+            for(G4int j=0; j< ab-1; j++) mom -= momentums[j];
             momentums.push_back(mom);
           };
+          }
+        }
 …
           if(rp > rb) rb = rp;
         };
+        }
         // nuclei i.p. as a whole
 …
         for (i = 0; i < G4int(coordinates.size()); i++) {
           coordinates[i] += global_pos;
         };
+        }
         // all nucleons at rest
+        std::vector<G4InuclElementaryParticle> raw_particles;
+        G4int ia = G4int(ab + 0.5);
+        G4int iz = G4int(zb + 0.5);
+        for (G4int ipa = 0; ipa < ia; ipa++) {
+          G4int knd = ipa < iz ? 1 : 2;
+        raw_particles.clear();
+        for (G4int ipa = 0; ipa < ab; ipa++) {
+          G4int knd = ipa < zb ? 1 : 2;
           raw_particles.push_back(G4InuclElementaryParticle(momentums[ipa], knd));
         };
+        }
         G4InuclElementaryParticle dummy(small_ekin, 1);
+        G4LorentzConvertor toTheBulletRestFrame;
+        toTheBulletRestFrame.setBullet(dummy.getMomentum(), dummy.getMass());
+        toTheBulletRestFrame.setTarget(bullet->getMomentum(),bullet->getMass());
+        G4LorentzConvertor toTheBulletRestFrame(&dummy, bullet);
         toTheBulletRestFrame.toTheTargetRestFrame();
 …
         for (ipart = raw_particles.begin(); ipart != raw_particles.end(); ipart++) {
           ipart->setMomentum(toTheBulletRestFrame.backToTheLab(ipart->getMomentum()));
         };
+        }
         // fill cascad particles and outgoing particles
 …
               if(t1 > 0.0) {
                 if(coordinates[ip].z() + mom.z() * t1 / pmod <= 0.0) tr = t1;
               };
+              }
               if(tr < 0.0 && t2 > 0.0) {
                 if(coordinates[ip].z() + mom.z() * t2 / pmod <= 0.0) tr = t2;
               };
+              }
             } else {
 …
                 if(coordinates[ip].z() + mom.z() * t2 / pmod <= 0.0) tr = t2;
               };
+              }
               if(tr < 0.0 && t1 > 0.0) {
                 if(coordinates[ip].z() + mom.z() * t1 / pmod <= 0.0) tr = t1;
               };
             };
           };
+              }
+            }
+          }
           if(tr >= 0.0) { // cascad particle
             coordinates[ip] += mom*tr / pmod;
+            coordinates[ip] += mom.vect()*tr / pmod;
             casparticles.push_back(G4CascadParticle(raw_particles[ip],
                                                     coordinates[ip],
 …
           } else {
             particles.push_back(raw_particles[ip]);
           };
         };
       };
+          }
+        }
+      }
       if(casparticles.size() == 0) {
 …
         G4cout << " can not generate proper distribution for " << itry_max
                << " steps " << G4endl;
       };
     };
   };
+      }
+    }
+  }
   if(verboseLevel > 2){
 …
   } else if (ke < 1.0) {
     csec = 3.6735 * (1.0-ke)*(1.0-ke);
   };
+  }
   if (csec < 0.0) csec = 0.0;

trunk/source/processes/hadronic/models/cascade/cascade/src/G4PionNucSampler.cc

r1337	r1340
25	25	//
26	26	// $Id: G4PionNucSampler.cc,v 1.2 2010/06/25 09:44:58 gunter Exp $
27		// GEANT4 tag: $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// 20100512 M. Kelsey -- Replaces (old, untemplated) G4FinalStateSampler

trunk/source/processes/hadronic/models/cascade/cascade/src/G4RegionModel.cc

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: G4RegionModel.cc,v 1.17 2010/06/25 09:45:04 gunter Exp $
 // Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: G4RegionModel.cc,v 1.18 2010/10/19 19:49:12 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100319  M. Kelsey -- Eliminate unnecessary use of std::pow()
+// 20101019  M. Kelsey -- CoVerity report: unitialized constructor
 #include "G4RegionModel.hh"
 …
 const G4double G4RegionModel::BE = 7;
+G4RegionModel::G4RegionModel(const G4int numberOfLayers, const G4int A, const G4int Z)
+G4RegionModel::G4RegionModel(const G4int numberOfLayers,
+                             const G4int A, const G4int Z)
+  : massNumber(A), protonNumber(Z)
+{
   //count the radiuses, densities and fermi momenta with A and Z

trunk/source/processes/hadronic/models/cascade/cascade/src/G4UnboundPN.cc

r1337	r1340
25	25	//
26	26	// $Id: G4UnboundPN.cc,v 1.5 2010/06/25 09:45:06 gunter Exp $
27		// GEANT4 tag $Name: ~~geant4-09-04-beta-01~~ $
	27	// GEANT4 tag $Name: hadr-casc-V09-03-85 $
28	28	//
29	29	// ------------------------------------------------------------

trunk/source/processes/hadronic/models/cascade/cascade/src/G4VCascadeCollider.cc

-              r1337
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4VCascadeCollider.cc,v 1.4 2010/07/14 15:41:13 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
+// $Id: G4VCascadeCollider.cc,v 1.1.2.1 2010/06/25 09:45:08 gunter Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-01 $
+// 20100615  M. Kelsey -- Split constructor to have verbose separately
+// 20100623  M. Kelsey -- Use old bindingEnergy() wrapper (now returns
+//              G4NucleiProperties::GetBindingEnergy()).
+// 20100714  M. Kelsey -- Move concrete functions to G4CascadeColliderBase
 #include "G4VCascadeCollider.hh"
-#include "G4HadTmpUtil.hh"
-#include "G4InteractionCase.hh"
-#include "G4InuclElementaryParticle.hh"
-#include "G4InuclNuclei.hh"
-#include "G4InuclSpecialFunctions.hh"
-#include "G4NucleiProperties.hh"
 #include "G4ios.hh"
-using namespace G4InuclSpecialFunctions;
 …
 G4VCascadeCollider::G4VCascadeCollider(const char* name, G4int verbose)
   : theName(name), verboseLevel(verbose) {
   if (verbose > 3) G4cout << " >>> " << theName << " ctor " << G4endl;
+  if (verboseLevel) G4cout << " >>> " << theName << " ctor " << G4endl;
+}
-// Both bullet and target must be hadrons or leptons for this to work
-G4bool G4VCascadeCollider::useEPCollider(G4InuclParticle* bullet,
-                                         G4InuclParticle* target) const {
-  return (dynamic_cast<G4InuclElementaryParticle*>(bullet) &&
-          dynamic_cast<G4InuclElementaryParticle*>(target));
+}
-// Decide wether nuclear fragment is candidate for G4BigBanger
-G4bool G4VCascadeCollider::explosion(G4InuclNuclei* target) const {
-  if (verboseLevel > 3) {
-    G4cout << " >>> " << theName << "::explosion" << G4endl;
+  }
-  const G4double a_cut = 20.0;
-  const G4double be_cut = 3.0;
-  G4double a = target->getA();
-  G4double z = target->getZ();
-  G4double eexs = target->getExitationEnergy();
-  // Only small fragments with high excitations can explode
-  G4bool explo = ((a <= a_cut) &&
-                  (eexs >= be_cut * G4NucleiProperties::GetBindingEnergy(G4lrint(a), G4lrint(z)))
-                  );
-  return explo;
+}
-// Decide whether bullet-target interaction is candidate for cascade
-G4bool
-G4VCascadeCollider::inelasticInteractionPossible(G4InuclParticle* bullet,
-                                                 G4InuclParticle* target,
-                                                 G4double ekin) const {
-  if (verboseLevel > 3) {
-    G4cout << " >>> " << theName << "::inelasticInteractionPossible" << G4endl;
+  }
-  // If hadron-hadron collision, defer to ElementaryParticleCollider
-  if (useEPCollider(bullet, target)) return true;
-  // See which one of the two (or both) is a nucleus, get properties
-  // FIXME:  Should set a = baryon() for both, but that's not in base
-  G4InuclNuclei* nuclei_bullet = dynamic_cast<G4InuclNuclei*>(bullet);
-  G4double ab = nuclei_bullet ? nuclei_bullet->getA() : 1;      // FIXME
-  G4double zb = nuclei_bullet ? nuclei_bullet->getZ() : bullet->getCharge();
-  G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target);
-  G4double at = nuclei_target ? nuclei_target->getA() : 1;      // FIXME
-  G4double zt = nuclei_target ? nuclei_target->getZ() : target->getCharge();
-  // VCOL (Coulomb barrier) used for testing if elastic collision necessary
-  const G4double coeff = 0.001 * 1.2;
-  G4double VCOL = coeff * zt * zb / (G4cbrt(at) + G4cbrt(ab));
-  G4bool possible = true;       // Force inelastic; should be (ekin >= VCOL)
-  if (verboseLevel > 3) {
-    G4cout << " VCOL: " << VCOL << " ekin: " << ekin << " inelastic possible: "
-           << possible << G4endl;
+  }
-  return possible;
+}

trunk/source/processes/hadronic/models/cascade/cascade/src/G4WatcherGun.cc

-              r1337
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4WatcherGun.cc,v 1.15 2010/10/22 20:41:05 mkelsey Exp $
+// GEANT4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // $Id: G4WatcherGun.cc,v 1.13.2.1 2010/06/25 09:45:10 gunter Exp $
 // GEANT4 tag: $Name: geant4-09-04-beta-01 $
+// To include numerous high-Z watchers (e.g., for proton-lead collisions)
+// set the preprocessor flag G4CASCADE_WATCHER_HIGHZ
 //
 // 20100407  M. Kelsey -- Replace std::vector<>::resize(0) with ::clear(),
 //              and create vectors pre-sized to maximum needed.
+//#define PB
+//
 #include "G4WatcherGun.hh"
 …
   cs.push_back(217.4);
   errs.push_back(1.22);
   watchers.push_back(G4NuclWatcher(0.0, as, cs, errs, false, false));
+  watchers.push_back(G4NuclWatcher(0, as, cs, errs, false, false));
   // Z = 1
 …
   cs.push_back(338.6);
   errs.push_back(3.1);
   watchers.push_back(G4NuclWatcher(1.0, as, cs, errs, false, false));
+  watchers.push_back(G4NuclWatcher(1, as, cs, errs, false, false));
   // Z = 1
 …
   cs.push_back(338.6);
   errs.push_back(3.1);
   watchers.push_back(G4NuclWatcher(1.0, as, cs, errs, false, true));
+  watchers.push_back(G4NuclWatcher(1, as, cs, errs, false, true));
   // Z = -1
 …
   cs.push_back(198.3);
   errs.push_back(1.0);
   watchers.push_back(G4NuclWatcher(-1.0, as, cs, errs, false, false));
+  watchers.push_back(G4NuclWatcher(-1, as, cs, errs, false, false));
   // Z = 2
 …
   cs.push_back(781.0);
   errs.push_back(5.0);
   watchers.push_back(G4NuclWatcher(2.0, as, cs, errs, false, true));
 #ifdef PB
+  watchers.push_back(G4NuclWatcher(2, as, cs, errs, false, true));
+#ifdef G4CASCADE_WATCHER_HIGHZ
   // Z = 22
   // watchers for pb208 + 1 GeV p
 …
   cs.push_back(0.06);
   errs.push_back(0.023);
   watchers.push_back(G4NuclWatcher(22.0, as, cs, errs, false, true));
+  watchers.push_back(G4NuclWatcher(22, as, cs, errs, false, true));
   // Z = 23
 …
   cs.push_back(0.05);
   errs.push_back(0.012);
   watchers.push_back(G4NuclWatcher(23.0, as, cs, errs, false, true));
+  watchers.push_back(G4NuclWatcher(23, as, cs, errs, false, true));
   // Z = 24
 …
   cs.push_back(0.092);
   errs.push_back(0.011);
   watchers.push_back(G4NuclWatcher(24.0, as, cs, errs, true, true));
+  watchers.push_back(G4NuclWatcher(24, as, cs, errs, true, true));
   // Z = 25
 …
   cs.push_back(0.051);
   errs.push_back(0.015);
   watchers.push_back(G4NuclWatcher(25.0, as, cs, errs, false, true));
+  watchers.push_back(G4NuclWatcher(25, as, cs, errs, false, true));
   // Z = 26
 …
   cs.push_back(0.09);
   errs.push_back(0.014);
   watchers.push_back(G4NuclWatcher(26.0, as, cs, errs, false, true));
+  watchers.push_back(G4NuclWatcher(26, as, cs, errs, false, true));
   // Z = 27
 …
   cs.push_back(0.108);
   errs.push_back(0.046);
   watchers.push_back(G4NuclWatcher(27.0, as, cs, errs, false, true));
+  watchers.push_back(G4NuclWatcher(27, as, cs, errs, false, true));
   // Z = 28
 …
   cs.push_back(0.054);
   errs.push_back(0.036);
   watchers.push_back(G4NuclWatcher(28.0, as, cs, errs, true, true));
+  watchers.push_back(G4NuclWatcher(28, as, cs, errs, true, true));
   // Z = 29
 …
   cs.push_back(0.041);
   errs.push_back(0.024);
   watchers.push_back(G4NuclWatcher(29.0, as, cs, errs, false, true));
+  watchers.push_back(G4NuclWatcher(29, as, cs, errs, false, true));
   // Z = 30
 …
   cs.push_back(0.082);
   errs.push_back(0.034);
   watchers.push_back(G4NuclWatcher(30.0, as, cs, errs, false, true));
+  watchers.push_back(G4NuclWatcher(30, as, cs, errs, false, true));
   // Z = 31
 …
   cs.push_back(0.061);
   errs.push_back(0.014);
   watchers.push_back(G4NuclWatcher(31.0, as, cs, errs, true, true));
+  watchers.push_back(G4NuclWatcher(31, as, cs, errs, true, true));
   // Z = 32
 …
   cs.push_back(0.04);
   errs.push_back(0.018);
   watchers.push_back(G4NuclWatcher(32.0, as, cs, errs, false, true));
+  watchers.push_back(G4NuclWatcher(32, as, cs, errs, false, true));
   // Z = 33
 …
   cs.push_back(0.023);
   errs.push_back(0.01);
   watchers.push_back(G4NuclWatcher(33.0, as, cs, errs, false, true));
+  watchers.push_back(G4NuclWatcher(33, as, cs, errs, false, true));
   // Z = 34
 …
   cs.push_back(0.045);
   errs.push_back(0.012);
   watchers.push_back(G4NuclWatcher(34.0, as, cs, errs, false, true));
+  watchers.push_back(G4NuclWatcher(34, as, cs, errs, false, true));
   // Z = 35
 …
   cs.push_back(0.033);
   errs.push_back(0.02);
   watchers.push_back(G4NuclWatcher(35.0, as, cs, errs, false, true));
+  watchers.push_back(G4NuclWatcher(35, as, cs, errs, false, true));
   // spallation part
 …
   cs.push_back(0.023);
   errs.push_back(0.016);
   watchers.push_back(G4NuclWatcher(61.0, as, cs, errs, true, true));
+  watchers.push_back(G4NuclWatcher(61, as, cs, errs, true, true));
   // Z = 69
 …
   cs.push_back(0.014);
   errs.push_back(0.01);
   watchers.push_back(G4NuclWatcher(69.0, as, cs, errs, true, true));
+  watchers.push_back(G4NuclWatcher(69, as, cs, errs, true, true));
   // Z = 73
 …
   cs.push_back(0.016);
   errs.push_back(0.009);
   watchers.push_back(G4NuclWatcher(73.0, as, cs, errs, true, true));
+  watchers.push_back(G4NuclWatcher(73, as, cs, errs, true, true));
   // Z = 77
 …
   cs.push_back(0.037);
   errs.push_back(0.019);
   watchers.push_back(G4NuclWatcher(77.0, as, cs, errs, true, true));
+  watchers.push_back(G4NuclWatcher(77, as, cs, errs, true, true));
   // Z = 81
 …
   cs.push_back(17.525);
   errs.push_back(0.526);
   watchers.push_back(G4NuclWatcher(81.0, as, cs, errs, true, true));
+  watchers.push_back(G4NuclWatcher(81, as, cs, errs, true, true));
   // Z = 82
 …
   cs.push_back(63.653);
   errs.push_back(9.573);
   watchers.push_back(G4NuclWatcher(82.0, as, cs, errs, true, true));
+  watchers.push_back(G4NuclWatcher(82, as, cs, errs, true, true));
 #else
 …
   cs.push_back(0.003);
   errs.push_back(0.001);
   watchers.push_back(G4NuclWatcher(80.0, as, cs, errs, true, true));
+  watchers.push_back(G4NuclWatcher(80, as, cs, errs, true, true));
   // Z = 77
 …
   cs.push_back(3.54);
   errs.push_back(0.45);
   watchers.push_back(G4NuclWatcher(77.0, as, cs, errs, true, true));
+  watchers.push_back(G4NuclWatcher(77, as, cs, errs, true, true));
   // Z = 73
 …
   cs.push_back(0.01);
   errs.push_back(0.008);
   watchers.push_back(G4NuclWatcher(73.0, as, cs, errs, true, true));
+  watchers.push_back(G4NuclWatcher(73, as, cs, errs, true, true));
   // Z = 61
 …
   cs.push_back(0.02);
   errs.push_back(0.003);
   watchers.push_back(G4NuclWatcher(61.0, as, cs, errs, true, true));
+  watchers.push_back(G4NuclWatcher(61, as, cs, errs, true, true));
   // Z = 79
 …
   cs.push_back(0.36);
   errs.push_back(0.05);
   watchers.push_back(G4NuclWatcher(79.0, as, cs, errs, true, true));
+  watchers.push_back(G4NuclWatcher(79, as, cs, errs, true, true));
   // Z = 78
 …
   cs.push_back(5.49);
   errs.push_back(0.7);
   watchers.push_back(G4NuclWatcher(78.0, as, cs, errs, true, true));
+  watchers.push_back(G4NuclWatcher(78, as, cs, errs, true, true));
   // Z = 72
 …
   cs.push_back(0.14);
   errs.push_back(0.02);
   watchers.push_back(G4NuclWatcher(72.0, as, cs, errs, true, true));
+  watchers.push_back(G4NuclWatcher(72, as, cs, errs, true, true));
   // Z = 66
 …
   cs.push_back(0.55);
   errs.push_back(0.1);
   watchers.push_back(G4NuclWatcher(66.0, as, cs, errs, true, true));
+  watchers.push_back(G4NuclWatcher(66, as, cs, errs, true, true));
   // Z = 65
 …
   errs.push_back(0.1);
   watchers.push_back(G4NuclWatcher(65.0, as, cs, errs, true, true));
+  watchers.push_back(G4NuclWatcher(65, as, cs, errs, true, true));
 #endif

trunk/source/processes/hadronic/models/cascade/cascade/src/bindingEnergy.cc

-              r819
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: bindingEnergy.cc,v 1.10 2010/09/14 17:51:36 mkelsey Exp $
 //
+// 20100622 M. Kelsey -- Replace all functionally with call-through to
+//              G4NucleiProperties.  Check for valid A/Z and return zero
+//              without warning message.
+// 20100914 M. Kelsey -- Migrate to integer A and Z
 #include "G4InuclSpecialFunctions.hh"
+#include "G4NucleiProperties.hh"
-G4double G4InuclSpecialFunctions::bindingEnergy(G4double A, G4double Z) {
-  G4int verboseLevel = 2;
   if (verboseLevel > 3) {
     G4cout << " >>> G4InuclSpecialFunctions::bindingEnergy" << G4endl;
+  }
+G4double G4InuclSpecialFunctions::bindingEnergy(G4int A, G4int Z) {
+  // NOTE:  Test condition copied from G4NucleiProperties.cc; not encapsulated
+  if (A < 1 || Z < 0 || Z > A) return 0.;
+  // calculates the nuclei binding energy using Kummel or exact or asymptotic
+  // high temperature
+  G4double DM;
+  G4double AN = A - Z;
+  if (AN < 0.1 || Z < 0.1) {
+    DM = 0.0;
+  } else {
+    if (A <= 256.0) {
+      if (AN >= 20. && Z >= 20) {
+        if (Z < 1.7 * AN && Z > 0.3 * AN) { // standard
+          DM = bindingEnergyKummel(A, Z);
+        } else { // bad case
+          DM = bindingEnergyAsymptotic(A, Z);
+        };
+      } else {
+        if (A > 60.0 || Z > 21) { // bad case
+          DM = bindingEnergyAsymptotic(A, Z);
+        } else { // exact case
+          DM = bindingEnergyExact(A, Z);
+        };
+      };
+    } else {
+      DM = bindingEnergyAsymptotic(A, Z);
+    };
+  };
+  // G4cout << " A " << A << " Z " << Z << " DM " << DM << G4endl;
+  return DM;
+  return G4NucleiProperties::GetBindingEnergy(A, Z);
+}

trunk/source/processes/hadronic/models/cascade/cascade/src/bindingEnergyAsymptotic.cc

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: bindingEnergyAsymptotic.cc,v 1.12 2010/06/25 09:45:12 gunter Exp $
 // Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: bindingEnergyAsymptotic.cc,v 1.13 2010/09/14 17:51:36 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100202  M. Kelsey -- Eliminate unnecessary use of std::pow()
+// 20100914  M. Kelsey -- Migrate to integer A and Z; discard unused verbose
 #include "G4InuclSpecialFunctions.hh"
+G4double G4InuclSpecialFunctions::bindingEnergyAsymptotic(G4double A,
+                                                          G4double Z) {
+  G4int verboseLevel = 2;
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4InuclSpecialFunctions::bindingEnergyAsymptotic" << G4endl;
+  }
+G4double G4InuclSpecialFunctions::bindingEnergyAsymptotic(G4int A, G4int Z) {
   // calculates the nuclei binding energy
   // using smooth liquid high energy formula
   G4double X = (1.0 - 2.0 * Z / A) * (1.0 - 2.0 * Z / A);
+  G4double X = (1.0 - 2.0*Z/A); X *= X;
   G4double X1 = G4cbrt(A);
   G4double X2 = X1 * X1;
   G4double X3 = 1.0 / X1;
   G4double X4 = 1.0 / X2;
+  G4double X5 = (1.0 - 0.62025 * X4); X5 *= X5;
   G4double DM = 17.035 * (1.0 - 1.846 * X) * A -
+.8357 * (1.0 - 1.712 * X) * X2 *
+    ((1.0  -0.62025 * X4) * (1.0 - 0.62025 * X4)) -
+.779 * Z * (Z - 1.0) * X3 *
+.8357 * (1.0 - 1.712 * X) * X2 * X5 -
+.779 * Z * (Z - 1) * X3 *
     (1.0 - 1.5849 * X4 + 1.2273 / A + 1.5772 * X4 * X4) +
 .4328 * G4cbrt(Z*Z*Z*Z) * X3 *

trunk/source/processes/hadronic/models/cascade/cascade/src/nucleiLevelDensity.cc

-              r819
+              r1340
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: nucleiLevelDensity.cc,v 1.8 2010/09/14 17:51:36 mkelsey Exp $
 //
+// 20100914  M. Kelsey -- Migrate to integer A and Z; simplify code
 #include "G4InuclSpecialFunctions.hh"
-G4double G4InuclSpecialFunctions::nucleiLevelDensity(G4double a) {
-  G4int verboseLevel = 2;
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4InuclSpecialFunctions::nucleiLevelDensity" << G4endl;
+  }
+G4double G4InuclSpecialFunctions::nucleiLevelDensity(G4int a) {
   const G4double NLD[226] = {
     // 20 - 29
 …
 .87, 30.25, 30.5, 29.8, 29.17, 28.67};
+  G4int ia = G4int(a + 0.1) - 20;
+  if (ia > 0) {
+    return NLD[ia];
+  } else {
+    return 0.1 * a;
+  };
+  return (a>=20) ? NLD[a-20] : 0.1*a;
+}

trunk/source/processes/hadronic/models/cascade/cascade/src/paraMaker.cc

-              r1337
+              r1340
 // ********************************************************************
 //
 // $Id: paraMaker.cc,v 1.18 2010/06/25 09:45:16 gunter Exp $
 // Geant4 tag: $Name: geant4-09-04-beta-01 $
+// $Id: paraMaker.cc,v 1.19 2010/09/14 17:51:36 mkelsey Exp $
+// Geant4 tag: $Name: hadr-casc-V09-03-85 $
 //
 // 20100412  M. Kelsey -- Modify paraMaker[Truncated] to take buffer as argument
 …
 // 20100517  M. Kelsey -- Use G4CascadeInterpolator, which handles boundaries
 // 20100601  M. Kelsey -- Bug fix from Gunter Folger; resize(6,0.), not clear()
+// 20100914  M. Kelsey -- Migrate to integer A and Z
 #include "G4InuclSpecialFunctions.hh"

Context Navigation

Legend:

Download in other formats: