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

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

-              r1228
+              r1315
+$Id: History,v 1.90 2010/06/08 06:34:43 stesting Exp $
 -------------------------------------------------------------------
 …
      * Please list in reverse chronological order (last date on top)
      ---------------------------------------------------------------
+June 2010 Gunter Folger  (hadr-casc-V09-03-42)
+-  trivial fix for compiler warning on gcc43 on empty body in for(...) in
+    cascade/include/G4CascadeInterpolator.icc:67
+June 2010 Michael Kelsey (hadr-casc-V09-03-41)
+-------------------------------------------------
+- paraMaker.cc:  Fix vector initialization for Windows crash.
+May 2010 Dennis Wright (hadr-casc-V09-03-40)
+-----------------------------------------------
+- G4NucleiModel: remove conversion to fm, and conversion of cross
+  sections to fm**2
+May 2010 Michael Kelsey (hadr-casc-V09-03-39)
+------------------------------------------------
+Final tag for inclusion in GEANT 4.9.4-beta.  Will be validated internal and
+included in global Hadronics tag.
+- G4CascadeSampler.icc:  Activate time-saving checks on single bins.
+- G4ElementaryParticleCollider.cc:  Remove special case for nucleon elastic
+  scattering.
+May 2010 Michael Kelsey (kelsey-20100521c)
+---------------------------------------------
+- G4CascadeInterface, G4PreCompoundCascadeInterface, G4InuclEvaporation:
+  Simplify code: fetch G4DynamicParticle out of outgoing G4InuclParticles,
+  rather than creating new ones.  Remove all of the *Collider data members
+  (instantiated within G4InuclCollider).  Move final state rotations to
+  G4CollisionOutput.
+- G4InuclParticle:  Provide accessor to return G4DynamicParticle.
+- G4CollisionOutput:  Add function to apply LorentzRotation to both lists;
+  used by G4CascadeInterface.
+- G4ElementaryParticleCollider:  Avoid memory churn with G4LorentzVector
+  temporaries.
+May 2010 Michael Kelsey (kelsey-20100521b)
+---------------------------------------------
+- G4VCascadeCollider:  New base class for all Colliders.  Carries
+  verboseLevel data member and set-function.  ::collide() is pure virtual.
+  Additional protected member functions will be defined to include all code
+  shared across multiple Colliders.
+- Migrate all of the "Collider" factories to use new base class, removing
+  common member functions, and replace passed-in sibling colliders with
+  local data members (pointers for now).  Since none of these classes have
+  persistent (state preserving) data members, the cost of more than one
+  instantiation is minimal.
+        G4BigBanger
+        G4ElementaryParticleCollider
+        G4EquilibriumEvaporator
+        G4EvaporationInuclCollider
+        G4Fissioner
+        G4IntraNucleiCascader
+        G4InuclCollider
+        G4NonEquilibriumEvaporator
+        G4PreCompoundInuclCollider
+- G4CascadeInterface.cc, G4InuclEvaporation.cc,
+  G4PreCompoundCascadeInterface.cc:  Remove siblings from constructors for
+  the Colliders.
+- G4InteractionCase.hh:  Eliminate unnecessary copying of std::pair<>'s, use
+  initializers in ctors, add clear() function to reset to 0-0-0.  Move
+  evaluation of bullet vs. target to new set() function, replacing separate
+  bulletTargetSetter() in the colliders.  Add boolean accessors to avoid
+  hard-coding inter_case values.  Change code numbers so nucleus collisions
+  are negative, and positive codes refer to the "is" or "rtype" numbers.
+- G4ElementaryParticleCollider.cc:  Use G4InteractionCase to compute "is",
+  instead of hardwiring the meaning.
+- G4Collider.hh:  Remove empty and never-used file.
+- G4EvaporationInuclCollider.cc:  Eliminate unnecessary creation of
+  duplicate G4InuclNuclei: pass input through to G4EquilibriumEvaporator.
+- G4LorentzConvertor:  Add interfaces to pass G4InuclParticles directly.
+May 2010 Michael Kelsey (kelsey-20100521a)
+---------------------------------------------
+Replace hand-coded interpolation of arrays with use of G4CascadeInterpolator.
+In all cases, local arrays are replaced with static const, and the
+interpolator object itself is declared static, to reduce memory churn.
+        G4NucleiModel::totalCrossSection()
+        G4EquilibriumEvaporator::getQF()
+        G4InuclSpecialFunctions::paraMaker[Truncated]() (in paraMaker.cc)
+- G4CascadSpecialFunctions:  Remove. totalCrossSection() redundant with
+  G4NucleiModel.  Move absorptionCrossSection() to G4NucleiModel.
+- G4CascadeInterpolator.icc:  Bug fix to catch special case of exact upper
+  bin edge (occurs when !doExtrapolation).  If index == last + 0., just
+  return upper edge value, without calculation.
+- G4NucleiModel.cc:  Use G4Cascade{Pi*}Channel and G4Cascade{NN,NP,PP}Channel
+  classes to get total cross-sections for pi-N and N-N scattering.  Arrays
+  for kaon and hyperon scattering should be migrated as well, once binning
+  is resolved.  Move absorptionCrossSection() here from SpecialFunctions.
+May 2010 Michael Kelsey (kelsey-20100521)
+--------------------------------------------
+- G4CascadeInterpolator.icc:  Two bug fixes involving values at array edges.
+May 2010 Michael Kelsey, Dennis Wright
+-----------------------------------------
+- G4BertiniData.hh,.cc:  Remove unused and unnecessary class.
+- G4NucleiModel.cc: convert nuclear radii to fm and cross sections to
+    fm**2.  Use six-zone model for A > 99, and make alpha a 1-zone
+    nucleus.
+- G4CascadSpecialFunctions: convert pion absorption cross sections from
+    mb to fm**2, correct spelling of method absorptionCrossSection
+May 2010 Michael Kelsey (hadr-casc-V09-03-38)
+------------------------------------------------
+- paraMaker.cc (G4InuclSpecialFunctions::paraMaker[Truncated]):  Upper edge
+  of interpolation array not properly handled.  Should be "if (Z >= 70.0)".
+  This affects G4NonEquilibriumEvaporator output.
+May 2010 Michael Kelsey (hadr-casc-V09-03-37)
+------------------------------------------------
+Bug fixes for compiler warnings (not seen on MacOSX, even with g++ -Wall)
+- G4CascadeData.hh: Dummy arrays needed double-braces for initialization.
+- G4CascadeInterpolator.icc: Extraneous decimal point in "for (i=0.;".
+- G4CascadeKzeroBarNChannel.cc:  Left three "old" arrays in place during
+  conversion.
+May 2010 Michael Kelsey (hadr-casc-V09-03-36)
+------------------------------------------------
+Remove obsolete files following reorganization of two-body scattering
+lookup tables.
+        G4CascadeElasticInterface.hh,.cc
+        G4ElasticCascadeInterface.hh,.cc
+        G4FinalStateSampler.hh,.cc
+        G4NucleonSampler.hh,.cc
+        G4PionSampler.hh,.cc
+- G4CascadeChannel.hh,.cc:  All functionality removed, replaced with
+  namespace containing only getQnums and CheckQnums validation functions.
+May 2010 Michael Kelsey (hadr-casc-V09-03-35)
+------------------------------------------------
+Replace independent parallel samplers with templated base class and single
+implementation.  This completes the reorganization of the channel tables.
+- G4CascadeSampler:  Redefine as templated base, taking binning array as
+  constructor argument.  Move implementation file from .cc to .icc.
+  NOTE:  G4CascadeSampler.cc is removed, since not consistent with new .hh.
+- G4PionNucSampler:  Subclass of G4CascadeSampler<30>, replaces
+  G4FinalStateSampler, using bins array from there.
+- G4KaonNucSampler:  Sublcass of G4CascadeSampler<31>, replaces previous
+  G4CascadeSampler, using bins array from there.
+- G4Cascade*Channel.hh:  Change all typedefs to pass appropriate of two new
+  samplers in template.
+- G4ElementaryParticleCollider.cc: Replace long "if (is==)"-cascades with
+  switch blocks.  Move all getOutgoing calls (for pions and nucleons) into
+  one function, and call it from outside multiplicity checks.  Use
+  G4CascadeInterpolator for angular distributions.  Set modelID=3 in all
+  G4InuclParticle constructions.
+May 2010 Michael Kelsey (hadr-casc-V09-03-34)
+------------------------------------------------
+Extract lookup tables from G4PionSampler and G4NucleonSampler into
+individual "classes" defined and initialized with G4CascadeData.
+- G4CascadePi{Plus,Minus,Zero}{P,N}Channel.hh: Six new typedefs defined as
+  with the existing G4CascadeXXXChannel, to replace G4PionSampler.
+- G4CascadeT33piNChannel.cc: Lookup tables for both PiPlusP and PiMinusN,
+  implemented as with existing G4CascadeXXXChannel, from G4PionSampler.cc.
+- G4CascadeT31piNChannel.cc: Lookup tables for both PiMinusP and PiPlusN,
+  implemented as with existing G4CascadeXXXChannel, from G4PionSampler.cc
+- G4CascadeT11pizNChannel.cc: Lookup tables for both PiZeroP and PiZeroN,
+  implemented as with existing G4CascadeXXXChannel, from G4PionSampler.cc
+- G4Cascade{PP,NP,NN}Channel.hh: Three new typedefs defined as with the
+  existing G4CascadeXXXChannel, to replace G4NucleonSampler.
+- G4CascadeT1NNChannel.cc: Lookup tables for both p-p and n-n scattering,
+  implemented as with existing G4CascadeXXXChannel, from G4NucleonSampler.cc
+- G4CascadeT0npChannel.cc: Lookup tables for p-n scattering, implemented as
+  with existing G4CascadeXXXChannel, from G4NucleonSampler.cc
+- G4CascadeFunctions.hh, .icc: Pass std::vector as non-const argument to
+  getOutgoingParticleTypes() instead of returning internal buffer.
+- G4CascadeSampler.cc, G4FinalStateSampler.cc:  Add some checks in
+  findFinalStateIndex, fillSigmaBuffer, and sampleFlat(), such that
+  single-entry ranges don't go through the analysis, just return index 0.
+- G4ElementaryParticleCollider.cc: Follow change to getOutgoingParticleTypes()
+  in generateStrangeChannelPartTypes().  Replace all uses of G4PionSampler
+  and G4NucleonSampler with new channel "classes".
+May 2010 Michael Kelsey (hadr-casc-V09-03-33)
+------------------------------------------------
+Continue consolidation of two-body collision lookup tables.  Unify
+interfaces between pion/nucleon and kaon/hyperon samplers.
+- G4CascadeData: Many changes to support use as data class for both
+  kaon/hyperon and pion/nucleon tables (migration will be next tag):
+) Add new first argument to template with number of bins in energy
+     interpolation.  This replaces the (temporary) use of
+     G4CascadeSampler::energyBins within the class definition.
+) Add two additional template arguments, N8 and N9, with default values
+     of zero.  These will be used by the pion/nucleon tables, but not by the
+     existing kaon/hyperon tables.
+) Define additional arrays for 8- and 9-body final states, using
+     conditional dimensioning (e.g., if N8==0, use [1]).  Define second
+-body constructor to accept and initialize the new arrays.
+) Eliminate static intialization of index[], moving it into
+     initialize().  Template specialization can't be used with data!
+) Add separate "sum" (summed N-body cross-sections) and "tot" arrays
+     (measured inclusive xsec).  Latter is a const-ref, initialized to "sum"
+     if not provided as ctor argument, with two new ctors as needed.
+) Add accessor to return maximum multiplicity (NM+1).
+- G4CascadeFunctions.hh:  Add second template argument to specify which
+  "final state sampler" is the base class.  Use both T::data.tot and
+  T::data.sum in GetMultiplicity(), to support sum/tot comparisons in
+  pion/nucleon channels.  Extend GetOutputParticleTypes() to support up to
+  multiplicity 9.
+- G4CascadeFunctions.icc:  Implementations of template class functions.
+- G4CascadeXXXChannel.hh: Add "31," as initial template argument for Data.
+  Add G4CascadeSampler as second template argument in G4CascadeXXXChannel
+  typedef.
+May 2010 Michael Kelsey (hadr-casc-V09-03-32)
+------------------------------------------------
+Continue revisions to two-body collision lookup tables.  Make the kaon and
+hyperon channels compatible with the pion/nucleon samplers, before the next
+stage of unifying the structure.
+- G4CascadeSampler: NEW class, parallel to G4FinalStateSampler but with a
+  different energy binning.  Used as base class to G4CascadeFunctions<T>,
+  from which the cross-section and other arrays are passed.  Implement
+  findMultiplicity (cf. G4CascadeFunctions::getMultiplicity) to return the
+  true value, not the array index.
+  This class replaces functionality of G4CascadeChannel, which is redundant.
+- G4CascadeChannel: Remove all interpolation code, leaving only getQnums().
+- G4CascadeFunctions:  Inherit from G4CascadeSampler for interpolations,
+  except for final-state extraction (where FS type arrays are dealt with
+  locally, not passed).  Public static functions rely on private instantiated
+  version of class to do work, so that G4CascadeSampler gets instantiated.
+- G4CascadeData: Remove final template argument (total number of indices),
+  as redundant with simple sum of multplicity indices.  Use template args to
+  dimension data member arrays (const references), and to statically
+  initialize the start-stop index table.  Make large cross-sections table
+  G4double, not G4float.  Define ctor to pass in array refs for initialization.
+  Reduce index array to single dimension (start=index[i], stop=index[i+1]).
+- G4CascadeXXXChannel:  All of the initial-state channel "classes"
+  (typedef names) modified to follow G4CascadeData rewrite.  In .cc file,
+  the explicit lookup tables are static, and passed by const-ref to
+  G4CascadeData.  The "initializer" struct is dropped; with the static
+  "data" object initialized by ctor here.
+- G4ElementaryParticleCollider.cc:  In ::generateMultiplicity(), eliminate
+  extra "+2" and "-2" applied to local "mul" variables.  With change above,
+  all functions return return true multiplicity, not array index.
+- G4FinalStateSampler:  Add findFinalStateIndex() function, to make
+  interface match G4CascadeSampler exactly.  Reduce index array to single
+  dimension.
+- G4PionSampler.cc, G4NucleonSampler.cc:  Use new findFinalStateIndex()
+  function in GetFSPartTypesXXX() functions.  Reduce index array to single
+  dimension (start=index[i], stop=index[i+1]).
+May 2010 Michael Kelsey (hadr-casc-V09-03-31)
+------------------------------------------------
+Begin revisions to two-body collision lookup tables.  This will be a major
+reorganization, splitting the G4PionSampler and G4NucleonSampler into
+separate little "classes" (typedefs) for each initial state, in the same way
+that the kaon and hyperon states are done now.  The underlying templated and
+base classes will be unified across all of the channels.
+- G4CascadeInterpolator: NEW class to encapsulate interpolation procedure.
+  Uses C-style arrays passed by dimensioned reference, to allow compile-time
+  array bounds checking.  Template argument is array dimension, and array of
+  energy bins is saved by ctor.  User array to be interpolated is passed as
+  function argument.  Last value interpolated, along with result, is saved,
+  to allow fast multiple interpolations.
+  This class is substantially more lightweight than G4PhysicsVector.
+- G4FinalStateSampler: Replace manual interpolation with G4CascadeInterpolator.
+  Remove redundant sampleFlat(...) function with argument.  Rename member
+  functions in anticipation of merging with G4CascadeFunctions.
+- G4PionSampler.cc, G4NucleonSampler.cc: Follow use of G4CascadeInterpolator
+  above, and drop local caching of interpolation results.  Reduce offset
+  list for cross-sections to one dimension (start=index[i], stop=index[i+1]).
+May 2010 Michael Kelsey (hadr-casc-V09-03-30)
+------------------------------------------------
+Bug fixes in the two-body scattering code.
+- G4PionSampler.cc, G4NucleonSampler.cc:  Fix long-standing bug with offset
+  indices computed for cross-section tables.  XXXindex[m][0] (start) and
+  XXXindex[m][1] (stop) are computed in initChannels() as [start,stop]
+  inclusive range (i.e., "for (i=start; i<=stop; i++)"), but used with
+  G4FinalStateSampler::fillSigmaBuffer (and its predecessor code) as
+  [start,stop) exclusive range (i.e., normal C style "for (i=start; i<stop;
+  i++)").  This is fixed by properly setting XXXindex[m-1][1] =
+  XXXindex[m][0], and using the ranges consistently in initChannels().
+- G4ElementaryParticleCollider.cc:  In the six pion-nucleon scatters, the
+  two-body final state is incorrectly tested for charge-exchange.  All the
+  if statements check whether "particle_kinds[0]" is the initial nucleon,
+  but the outgoing baryon actually appears in particle_kinds[1].  Replace
+  the individual tests with the use of "finaltype", moved out of the
+  strangeness if-block.
+May 2010 Michael Kelsey (hadr-casc-V09-03-29, hadr-casc-V09-03-23-01)
+------------------------------------------------------------------------
+- G4Diproton.cc, G4Dineutron.cc, G4UnboundPN.cc:  After creating instance
+  of these "internal" particles, remove the pointer from G4ParticleTable.
+  This avoids an issue with the FTFP de-excitation code, which occasionally
+  picks up the diproton and puts it onto a final-state particle list.
+These three changes, and nothing else, are "backported" on top of -23 for
+continued validation tests.
+Apr 2010 Dennis Wright (hadr-casc-V09-03-28)
+-----------------------------------------------
+- G4ElementaryParticleCollider:
+    improved pi-nucleon two-body angular distributions, and made
+    sampling of CM angle faster.  As a result, the methods
+    getElasticCase and adjustIntervalForElastic were made redundant
+    and removed.  Also removed array containing old angular distribution
+    parameters.
+    Now use nucleon-nucleon angular distributions for hyperon-nucleon
+    scattering, and pi-nucleon dsitributions for kaon-nucleon scattering
+    (until specific kaon distributions are added).
+Apr 2010 Michael Kelsey (hadr-casc-V09-03-27)
+------------------------------------------------
+- G4InuclPartcleNames.hh:  Long name "gamma" conflicts with math function.
+  Change back to "photon".
+- G4InuclElementaryParticle.cc, G4InuclEvaporation.cc,
+  G4NonEquilibriumEvaporator.cc, G4NucleiModel.cc, G4NucleonSampler.cc,
+  G4PionSampler.cc, G4PreCompoundCascadeInterface.cc,
+  G4PreCompoundInuclCollider.cc:  Replace "gamma" with "photon".
+- G4InuclElementaryParticle.hh:  Change "photon()" to "isPhoton()" to avoid
+  conflicts with names enum.  Use names enum internally as well.
+- G4ElementaryParticleCollider.cc, G4InuclCollider.cc,
+  G4PreCompoundInuclCollider.cc:  Change "photon()" to "isPhoton()".
+Apr 2010 Michael Kelsey (hadr-casc-V09-03-26)
+------------------------------------------------
+All changes below within "cascade/" subdirectory:
+- G4InuclParticleNames.hh:  Define enums for particle type codes, using both
+  "long" and "short" names copied from existing duplicated enums.  One
+  change is that "kp" and "km" are replaced by "kpl" and "kmi" respectively,
+  since "km" conflicts with GEANT4 "kilometers" unit.  Deploy in classes:
+        include/G4FinalStateSampler.hh
+        src/G4CascadeElasticInterface.cc
+        src/G4CascadeInterface.cc
+        src/G4ElasticCascadeInterface.cc
+        src/G4ElementaryParticleCollider.cc
+        src/G4InuclElementaryParticle.cc
+        src/G4InuclEvaporation.cc
+        src/G4NucleonSampler.cc
+        src/G4PionSampler.cc
+        src/G4PreCompoundCascadeInterface.cc
+- G4InuclElementaryParticle.cc:  Add Omega- and antinucleon partcles to lists.
+  No code uses these (yet).
+April 2010 Michael Kelsey (hadr-casc-V09-03-25)
+--------------------------------------------------
+Remove redundant classes, G4Ibertini and G4BertiniRegionModel.
+April 2010 Michael Kelsey (hadr-casc-V09-03-24)
+--------------------------------------------------
+- G4NucleiModel.hh,cc:  Eliminate last remaining hardwired baryon masses.
+April 2010 Michael Kelsey (hadr-casc-V09-03-23)
+--------------------------------------------------
+Final revisions to access std::vector<particle> via const-references:
+        G4CascadeInterface.cc
+        G4EquilibriumEvaporator.cc
+        G4IBertini.cc
+        G4InuclCollier.cc
+        G4NucleiModel.cc
+        G4PreCompoundCascadeInterface.cc
+- G4CollisionOutput:  Add new function to boost output lists to lab frame.
+April 2010 Michael Kelsey (hadr-casc-V09-03-22)
+--------------------------------------------------
+- G4CascadeInterface.cc, G4IBertini.cc, G4PreCompoundCascadeInterface.cc:
+  In ::ApplyYourself(), do the check on K0L/K0S _before_ passing G4PartDefn
+  to G4InuclElemPart::type().  This avoids unnecessary warning message.
+April 2010 Michael Kelsey (temporary: kelsey-memClean3)
+----------------------------------------------------------
+All changes below within "cascade/" subdirectory:
+- G4FinalStateSampler: Replace "sigma" argument for sampling with data
+  member, add functions to fill sigma buffer by passing in array references.
+  Provide typedef for interpolator, and function to apply interpolation.
+- G4PionSampler, G4NucleonSampler:  Follow changes to base class,
+  eliminating much of the copy-and-paste code blocks via function calls.
+  Replace G4float arrays with G4double, to support passing into functions.
+April 2010 Michael Kelsey (hadr-casc-V09-03-21)
+--------------------------------------------------
+All changes below within "cascade/" subdirectory:
+- G4InuclSpecialFunctions.hh, paraMaker.cc, paraMakerTruncated.cc:  Drop
+  return-by-value from paraMaker() and paraMakerTruncated().  Add second
+  argument with non-const reference to output buffer for return.
+- G4EquilibriumEvaporator.cc:  Follow changes above to paraMaker(), use
+  references to address parms.first and parms.second, instead of copying.
+- G4NonEquilibriumEvaporator.cc:  Follow changes above to
+  paraMakerTruncaed(), use references to address parms.first and
+  parms.second, instead of copying.
+- G4Dineutron, G4Diproton, G4UnboundPN:  Inherit from G4VShortLivedParticle,
+  per Kurashige.  Thought it would eliminate G4ElectronOccupancy churn, but
+  did not.
+April 2010 Michael Kelsey (hadr-casc-V09-03-20)
+--------------------------------------------------
+All changes below within "cascade/" subdirectory:
+- G4NucleiModel: Move function implementations from .hh to .cc.  Replace
+  manual sorting (inefficient O(N^2)) with std::sort() and simple
+  "less-than" function for std::pair<> "partners".
+- G4CollisionOutput: Move function implementations from .hh to .cc.  Use
+  std::vevtor<>::insert() to add vectors together.
+- Replace return-by-value G4CollisionOutput with non-const reference buffer
+  passed into xxx::collide(), in the following classes:
+        G4BigBanger
+        G4CascadeElasticInterface
+        G4CascadeInterface
+        G4ElasticCascadeInterface
+        G4ElementaryParticleCollider
+        G4EquilibriumEvaporator
+        G4EvaporationInuclCollider
+        G4Fissioner
+        G4IBertini
+        G4IntraNucleiCascader
+        G4InuclCollider
+        G4InuclEvaporation
+        G4NonEquilibriumEvaporator
+        G4NucleiModel
+        G4PreCompoundCascadeInterface
+        G4PreCompoundInuclCollider
+  Note that some places where internal G4CollisionOutput buffers are being
+  used (and their contents appended to the global output) have not been
+  cleaned up yet.  These will require some rearrangement of the algorithms,
+  or/and elimination of debugging output.
+April 2010 Michael Kelsey (hadr-casc-V09-03-16-01)
+-----------------------------------------------------
+This modification is included in a pseudo-patch of hadr-casc-V09-03-16,
+without brining in any of the -17 through -19 modifications.
+- G4LorentzVector.cc:  Protect two instances of sqrt() against tiny negative
+  arguments (due to tiny-tiny subtractions).
+April 2010 Michael Kelsey (hadr-casc-V09-03-19)
+--------------------------------------------------
+All changes below within "cascade/" subdirectory:
+- G4InuclParticle, G4InuclElementaryParticle, G4InuclNuclei:  Eliminate
+  unused G4String ctor argument, introduced in hadr-casc-V09-03-01.  Causes
+  a lot of pointless memory churn.
+- G4BigBanger.cc:  Fix type conversion warning I introduced by mistake.
+April 2010 Michael Kelsey (hadr-casc-V09-03-18)
+--------------------------------------------------
+All changes below within "cascade/" subdirectory:
+- G4PionSampler, G4NucleonSampler: For all ::GetFSPartTypes*() functions,
+  eliminate return-by-value std::vector<>, and pass in non-const reference
+  for filling in situ.  Buffer is cleared.
+- G4ElementaryParticleCollider.cc:  Follow changes above for Sampler calls.
+April 2010 Michael Kelsey (hadr-casc-V09-03-17)
+--------------------------------------------------
+All changes below within "cascade/" subdirectory:
+Replace return-by-value std::vector<> with either const-ref returns, or
+with use of an internal buffer which can be reused, to reduce memory
+churn due to copying, allocation, and resizing.
+- G4BigBanger:  Create data buffer for lists of secondaries and momenta.
+  Fill buffers in ::generateBangInSCM() and ::generateMomentumModules(),
+  which are now non-const.  Reference buffers in ::collide().
+- G4CascadeFunctions::getOutgoingParticleTypes():  Make "kinds" a static
+  variable (buffer), and return it by const-ref.
+- G4ElementaryParticleCollider:  Eliminate return-by-value std::vector<>
+  on the functions listed below, by creating data buffers for particles,
+  momenta, and particle types.  The functions become non-const and void:
+  ::generateSCMfinalState(), ::generateMomModules()
+  ::generateStrangeChannelPartTypes(), ::generateSCMpionAbsorption()
+  Also, in ::generateStrangeChannelPartTypes(), use a switch statement
+  instead of the long cascade of if-else-else.
+- G4NucleiModel: Several member functions have different modifications:
+  ::initializeCascad(bullet,target) -- Replace return value with a passed-in
+        (non-const reference) buffer to be filled.  The calling code can
+        pass in a data member, local variable, or whatever.
+  ::generateParticleFate() -- Replace local "thePartners" variable with data
+        member, filled below.  Move "outgouing_cparticles" to data member
+        (fix the spelling!), and return by const-ref.
+  ::generateInteractionPartners() -- Eliminate return value; fill data
+        member instead, to be used by ::generateParticleFate().
+- G4IntraNucleiCascader.cc:  Follow changes to initializeCascad() above.
+- G4NucleonSampler, G4PionSampler: ** DON'T KNOW WHAT TO DO HERE **
+- G4WatcherGun:  Return const-ref to list of watchers, instead of copy.
+Replace all uses of std::vector<>::resize(0) with ::clear().  The former
+causes deallocation/reallocation/resizing cycles, while clear() just removes
+content, preserving the allocated buffer.
+        include/G4CollisionOutput.hh
+        src/G4ElementaryParticleCollider.cc
+        src/G4NucleiModel.cc
+        src/G4WatcherGun.cc
+April 2010 Dennis Wright (hadr-casc-V09-03-16)
+-------------------------------------------------
+- fix negative energy bug in G4BigBanger, and switch to using
+  G4NucleiProperties::GetBindingEnergy
+April 2010 Michael Kelsey (hadr-casc-V09-03-15)
+--------------------------------------------------
+All changes below within "cascade/" subdirectory:
+) Systematically replace pass-by-value function arguments with const-refs.
+This is the first step in reducing unnecessary memory churn, to be followed
+by replacing return-by-value std::vector<> with non-const argument buffers.
+        include/G4CascadeChannel.hh
+        include/G4FinalStateSampler.hh
+        include/G4InuclEvaporation.hh
+        include/G4NuclWatcher.hh
+        src/G4CascadeChannel.cc
+        src/G4FinalStateSampler.cc
+        src/G4InuclEvaporation.cc
+        src/G4NuclWatcher.cc
+) Fix constness on some operator== and operator!= definitions.
+        include/G4CascadeElasticInterface.hh
+        include/G4CascadeInterface.hh
+        include/G4ElasticCascadeInterface.hh
+        include/G4IBertini.hh
+        include/G4PreCompoundCascadeInterface.hh
+Apr 2010 Michael Kelsey (hadr-casc-V09-03-14)
+------------------------------------------------
+- G4Dineutron.hh, G4Diproton.hh, G4UnboundPN.hh:
+  Reset static "theInstance" pointer to zero in (now virtual) destructor.
+- G4Dineutron.cc, G4Diproton.cc, G4UnboundPN.cc:
+  Implement constructor to do the G4Ions initialization, rather than in
+  ::Definition().  Drop use of G4ParticleTable; just monitor static pointer.
+  Set "ShortLived" flag in G4Ions initialization, to avoid interactions with
+  ProcessManager.
+- G4InuclNuclei.cc:  In ::makeNuclearFragment(), set "ShortLived" flag for
+  G4Ions, to avoid interactions with ProcessManager.
+Mar 2010 Dennis Wright (hadr-casc-V09-03-13)
+-----------------------------------------------
+- G4EquilibriumEvaporator.cc: remove line #include "G4types.hh"
+  (file doesn't exist)
+Mar 2010 Michael Kelsey (hadr-casc-V09-03-12)
+------------------------------------------------
+All changes below within "cascade/" subdirectory:
+- G4EquilibriumEvaporator.cc:  Move subtraction of Q1[i] outside new
+  GetBindingEnergy() call.
+- G4InuclNuclei.cc::makeNuclearFragment():  Add message warning users about
+  non-physical creation.  Use new GetBindingEnergy() function here as well
+  (V09-03-05 didn't have this function, so wasn't included in migration).
+Mar 2010 Michael Kelsey (hadr-casc-V09-03-11)
+------------------------------------------------
+All changes below within "cascade/" subdirectory:
+- G4InuclSpecialFunctions:  Two new functions:
+::generateWithRandomAngles() to encapsulate random-direction generation.
+  This function and existing generateWithFixedTheta() take optional mass
+  argument to produce proper four-vector.
+  Replace duplicated random angle code with new function above, and use new
+  optional mass argument where available:
+        G4BigBanger.cc
+        G4ElementaryParticleCollider.cc
+        G4EquilibriumEvaporator.cc
+        G4Fissioner.cc
+        G4NonEquilibriumEvaporator.cc
+        G4NucleiModel.cc
+::G4cbrt():  Define cube-root in terms of log and exp, rather than pow().
+  Note that "cbrt()" can't be used, as it conflicts with <math.h> on Linux.
+  Eliminate unnecessary uses of std::pow() with fixed arguments.  For
+  example, "pow(x,3)" -> "x*x*x", "pow(x,1/3)" -> G4cbrt(x):
+        G4BertiniRegionModel.cc
+        G4EquilibriumEvaporator.cc
+        G4EvaporationInuclCollider.cc
+        G4Fissioner.cc
+        G4IntraNucleiCascader.cc
+        G4InuclCollider.cc
+        G4NonEquilibriumEvaporator.cc
+        G4NucleiModel.cc
+        G4PreCompoundInuclCollider.cc
+        G4RegionModel.cc
+        bindingEnergyAsymptotic.cc
+        bindingEnergyKummel.cc
+  WARNING!  In G4IntraNucleiCascader.cc, the Coulomb barrier was calculated
+  using "std::pow(A, 0.333)", rather than the "exact" 1./3.  This leads to
+  per-mil differences in the value, and occasional differences in wheter an
+  outgoing particle tunnels through.  The new code is exact to double
+  precision, and therefore fixes a bug.
+- Move "using" directive from all .hh files to corresponding .cc, along with
+  some unnecessary #includes:
+        G4BigBanger.hh, .cc
+        G4ElementaryParticleCollider.hh, .cc
+        G4EquilibriumEvaporator.hh, .cc
+        G4EvaporationInuclCollider.hh, .cc
+        G4Fissioner.hh, .cc
+        G4IntraNucleiCascader.hh, .cc
+        G4InuclCollider.hh
+        G4InuclNuclei.hh
+        G4NonEquilibriumEvaporator.hh, .cc
+        G4NucleiModel.hh, .cc
+        G4PreCompoundInuclCollider.hh, .cc
+- G4NuclWatcher.hh and .cc (new):  Move implementation code from .hh to .cc.
+March 2010 Michael Kelsey (hadr-casc-V09-03-10)
+--------------------------------------------------
+All changes below within "cascade/" subdirectory:
+Missed one bug in repairs below, found when testing 4 GeV pi -> Pb.
+- G4Fissioner.cc:  Replace incorrect G4LorentzVector ctor arguments
+  (G4ThreeVector,m) with call to G4LV::setVectM().
+March 2010 Dennis Wright (hadr-casc-V09-03-09)
+-------------------------------------------------
+Fix warning in G4InuclNuclei.cc: G4Ions:G4Ions was being called with
+a double (a) in its 13th argument, when an integer is required.  Use
+G4lrint to convert.
+March 2010 Michael Kelsey (hadr-casc-V09-03-08)
+--------------------------------------------------
+All changes below within "cascade/" subdirectory:
+Fix bugs introduced during migration from G4CascadeMomentum to
+G4LorentzVector (see hadr-casc-V09-03-03).  With these bug fixes, 2000
+events generated with "ppi4GeV" test executable are equivalent to production
+output (GEANT 4.9.3), allowing for differences in hardwired nucleon masses.
+When compared with hadr-casc-V09-03-02 (which uses G4ParticleDefinition for
+all the particle masses) the 2000-event results are identical within
+floating point precision.
+- G4BigBanger.cc:  Line 72, fix unit conversion bug, GeV/MeV vs. MeV/GeV.
+  Replace incorrectly introduced cross-product with original vector
+  manipulation, written with G4LorentzVector accessors.
+- G4CollisionOutput::selectPairToTune(): Test on "i3>0" not appropriate with
+  G4LorentzVector indexing.  Replace with failure-test on "i3<0".  Also
+  simplify final if-cascade for readability.
+- G4EquilibriumEvaporator.cc:  Replace incorrect G4LorentzVector ctor
+  arguments (px,py,pz,m) with call to G4LV::setVectM().
+- G4IntraNuclearCascader.cc:  Replace leftover momentum_out[0] with .e().
+- G4InuclNuclei.cc,hh:  Add new function ::makeNuclearFragment(a,z,exc),
+  which "manually" construct a G4Ions object for cases where A/Z is not a
+  valid stable or unstable nucleus.  These unphysical objects are passed
+  back from G4IntraNuclearCascader.cc and immediately passed to G4BigBanger
+  for conversion to nucleons.  A future change should move this action into
+  G4INCascader and eliminate the need for unphysical nuclei.
+- G4LorentzConvertor::toTheTargetRestFrame():  Remove local declaration of
+  scm_momentum, restoring access to data member with that name.
+- G4NucleiModel::generateQuasiDeutron(): Undo consolidation of dmom with
+  local variables for each of the nucleon momenta.  Stack corruption led to
+  differences in unbound p-n state relative to pp and nn states.
+Minor updates:  Changed all the "verboseLevel()" initializers to (0), via a
+shell script.  This allows making the code uniformly verbose or quiet.
+        include/G4NucleiModel.hh
+        src/G4Analyser.cc
+        src/G4CollisionOutput.cc
+        src/G4ElementaryParticleCollider.cc
+        src/G4FissionStore.cc
+        src/G4Fissioner.cc
+        src/G4IntraNucleiCascader.cc
+        src/G4NonEquilibriumEvaporator.cc
+        src/G4NucleiModel.cc
+        src/G4WatcherGun.cc
+March 2010 Michael Kelsey (hadr-casc-V09-03-DO-NOT-USE)
+--------------------------------------------------
+All changes below within "cascade/" subdirectory:
+Restore version hadr-casc-V09-03-05 to HEAD of CVS in order to apply bug
+fixes and re-deploy migration from G4CascadeMomentum to G4LorentzVector.
+This reversion is tagged as a checkpoint only, and should not be used for
+testing or running (since it restores the known bugs in V09-03-03).
+The update to G4InteractionCase.hh by Gabriele Cosmo in hadr-casc-V09-03-07
+is not touched by this reversion!
+The following CVS commands were used to perform the reversion:
+        cvs update -j1.13 -j1.12 cascade/include/G4CascadParticle.hh
+        cvs update -j1.4 -j1.3 cascade/include/G4CascadeMomentum.hh
+        cvs update -j1.15 -j1.14 cascade/include/G4CollisionOutput.hh
+        cvs update -j1.23 -j1.22 cascade/include/G4ElementaryParticleCollider.hh
+        cvs update -j1.9 -j1.8 cascade/include/G4InuclCollider.hh
+        cvs update -j1.19 -j1.18 cascade/include/G4InuclElementaryParticle.hh
+        cvs update -j1.12 -j1.11 cascade/include/G4InuclNuclei.hh
+        cvs update -j1.16 -j1.15 cascade/include/G4InuclParticle.hh
+        cvs update -j1.13 -j1.12 cascade/include/G4InuclSpecialFunctions.hh
+        cvs update -j1.13 -j1.12 cascade/include/G4LorentzConvertor.hh
+        cvs update -j1.4 -j1.3 cascade/include/G4ParticleLargerBeta.hh
+        cvs update -j1.9 -j1.8 cascade/include/G4ParticleLargerEkin.hh
+        cvs update -j1.20 -j1.19 cascade/src/G4BigBanger.cc
+        cvs update -j1.13 -j1.12 cascade/src/G4CascadParticle.cc
+        cvs update -j1.6 -j1.5 cascade/src/G4CascadeElasticInterface.cc
+        cvs update -j1.68 -j1.67 cascade/src/G4CascadeInterface.cc
+        cvs update -j1.18 -j1.17 cascade/src/G4CollisionOutput.cc
+        cvs update -j1.7 -j1.6 cascade/src/G4ElasticCascadeInterface.cc
+        cvs update -j1.6 -j1.5 cascade/src/G4EvaporationInuclCollider.cc
+        cvs update -j1.5 -j1.4 cascade/src/G4IBertini.cc
+        cvs update -j1.3 -j1.2 cascade/src/G4InuclElementaryParticle.cc
+        cvs update -j1.10 -j1.9 cascade/src/G4InuclEvaporation.cc
+        cvs update -j1.3 -j1.2 cascade/src/G4InuclNuclei.cc
+        cvs update -j1.4 -j1.3 cascade/src/G4InuclParticle.cc
+        cvs update -j1.17 -j1.16 cascade/src/G4InuclSpecialFunctions.cc
+        cvs update -j1.19 -j1.18 cascade/src/G4LorentzConvertor.cc
+        cvs update -j1.5 -j1.4 cascade/src/G4PreCompoundCascadeInterface.cc
+        cvs update -j1.4 -j1.3 cascade/src/G4PreCompoundInuclCollider.cc
+Intermediate versions below had bindingEnergy changes from -05 re-applied
+        cvs update -j1.23 -j1.21 cascade/src/G4EquilibriumEvaporator.cc
+        cvs update -j1.22 -j1.20 cascade/src/G4Fissioner.cc
+        cvs update -j1.29 -j1.27 cascade/src/G4IntraNucleiCascader.cc
+        cvs update -j1.24 -j1.22 cascade/src/G4InuclCollider.cc
+        cvs update -j1.23 -j1.21 cascade/src/G4NonEquilibriumEvaporator.cc
+        cvs update -j1.38 -j1.36 cascade/src/G4NucleiModel.cc
+G4ElementaryParticleCollider::particleSCMmomentumFor2to2:  Restore new
+parametrization of elastic scattering added by D.Write in hadr-casc-V09-03-06
+        cvs update -j1.47 -j1.45 cascade/src/G4ElementaryParticleCollider.cc
+        + editing
+Mar 2010 Gabriele Cosmo (hadr-casc-V09-03-07)
+------------------------------------------------
+- Reinstated fix in G4InteractionCase.hh for initialisation in constructor to
+  allow for porting on C++0x Standard.
+Feb 2010 Dennis Wright (hadr-casc-V09-03-06)
+-----------------------------------------------
+- back out changes from tags V09-03-00 to V00-03-05 by restoring HEAD
+  to V09-02-11, and keeping the di-nucleon classes
+- replace Bertini method bindingEnergy() with
+  G4NucleiProperties::GetBindingEnergy() in classes
+  G4IntraNuclearCascader, G4InuclCollider, G4NucleiModel, G4EquilibriumModel,
+  G4NonEquilibriumModel, G4Fissioner.  Note that G4Fissioner still uses the
+  Bertini method bindingEnergyAsymptotic.
+- G4ElementaryParticleCollider::particleSCMmomentumFor2to2
+  replace original (incorrect) pp, pn, nn 2-body to 2-body scattering angular
+  distributions with a new parameterization of elastic scattering data using
+  the sum of two exponentials
+Feb 2010 Dennis Wright (hadr-casc-V09-03-05)
+-----------------------------------------------
+- replace all uses of bindingEnergy (local Bertini method) with the
+  Geant4 standard G4NucleiProperties::GetBindingEnergy(A,Z)
+  files modified:
+    G4IntraNucleiCascader.cc
+    G4InuclCollider.cc
+    G4NucleiModel.cc
+    G4EquilibriumEvaporator.cc
+    G4NonEquilibriumEvaporator.cc
+    G4Fissioner.cc
+- note that G4Fissioner still uses Bertini method bindingEnergyAsymptotic
+Jan 2010 Dennis Wright (hadr-casc-V09-03-04)
+-----------------------------------------------
+- fix unused variable warnings in G4InuclParticle.hh, .cc and
+  G4NonEquilibriumEvaporator.cc
+Jan 2010 Michael Kelsey (hadr-casc-V09-03-03)
+------------------------------------------------
+All changes below within "cascade/" subdirectory:
+- G4ParticleLargerBeta.hh:  Fix to use of CVS "Name" tag; no code changes.
+- G4CascadParticle: Replace the position std::vector<> with G4ThreeVector.
+- G4NucleiModel: Replace all std::vector<> coordinates with G4ThreeVector,
+  and use vector math for computations.
+Remove all use of G4CascadeMomentum (a simple container with a C-style
+four-element array) with G4LorentzVector.  This is a fairly invasive change,
+since G4CascMom was used for all of the three- and four-vector operations
+throughout the Bertini code:
+        include/G4CascadParticle.hh
+        include/G4CollisionOutput.hh
+        include/G4ElementaryParticleCollider.hh
+        include/G4InuclCollider.hh
+        include/G4InuclElementaryParticle.hh
+        include/G4InuclNuclei.hh
+        include/G4InuclParticle.hh
+        include/G4InuclSpecialFunctions.hh
+        include/G4LorentzConvertor.hh
+        src/G4BigBanger.cc
+        src/G4CascadParticle.cc
+        src/G4CascadeElasticInterface.cc
+        src/G4CascadeInterface.cc
+        src/G4CollisionOutput.cc
+        src/G4ElasticCascadeInterface.cc
+        src/G4ElementaryParticleCollider.cc
+        src/G4EquilibriumEvaporator.cc
+        src/G4EvaporationInuclCollider.cc
+        src/G4Fissioner.cc
+        src/G4IBertini.cc
+        src/G4IntraNucleiCascader.cc
+        src/G4InuclCollider.cc
+        src/G4InuclElementaryParticle.cc
+        src/G4InuclEvaporation.cc
+        src/G4InuclNuclei.cc
+        src/G4InuclParticle.cc
+        src/G4InuclSpecialFunctions.cc
+        src/G4LorentzConvertor.cc
+        src/G4NonEquilibriumEvaporator.cc
+        src/G4NucleiModel.cc
+        src/G4PreCompoundCascadeInterface.cc
+        src/G4PreCompoundInuclCollider.cc
+The new code is not yet entirely "correct," since Bertini also does a lot of
+operations by way of three-momentum, imposing masses (and hence energy
+conservation) separately, after the fact.
+Jan 2010 Gabriele Cosmo
+--------------------------
+- G4InteractionCase.hh:  Minor fix in initialisation in constructor to
+  allow for porting on C++0x Standard.
+Jan 2010 Michael Kelsey (hadr-casc-V09-03-02)
+------------------------------------------------
+- G4LorentzConvertor.hh:  Fix scm_momentum data member to be G4ThreeVector
+  (as used in previous versions) rather than G4LorentzVector.
+NOTE:  I have *retagged* cascade/include/G4LorentzConverter.hh and this
+       History file, rather than creating a new tag, since these are private
+       development only, not public releases.
+Jan 2010 Michael Kelsey (hadr-casc-V09-03-02)
+------------------------------------------------
+All changes below within "cascade/" subdirectory:
+- G4CascadeMomentum: Replace use of static G4LV variables within functions
+  with mutable data member of object; this does introduce more memory
+  thrashing, but the plan is to get rid of the whole thing anyway.  Improve
+  implicit casting and add assignment from G4LV.
+- G4LorentzConverter:  Change function signatures to accept G4LV as input,
+  using implicit cast to convert existing G4CascadeMomentum argument
+  passing.  Use G4LV internally throughout, again using implicit cast to
+  return G4CascMom values.  This substantially increases (temporarily!)
+  memory thrashing.  Simplify ::rotate() functions to use G4LV and
+  G4ThreeVec operations rather than array index gymnastics.  Move some
+  function implementations out of .hh file into .cc.
+- G4ParticleLargerEkin.hh: Fix use of CVS "Name" tag.  No code changes.
+Jan 2010 Michael Kelsey (hadr-casc-V09-03-01)
+------------------------------------------------
+All changes below within "cascade/" subdirectory:
+- G4ParticleLargerBeta, G4ParticleLargerEkin: Add additional operator()
+  which takes pointers (for future mods to reduce ctor/dtor cycling), and
+  fix ordering bug in beta sorting.  Add debugging printout togged with
+  preprocessor flag.
+- G4InuclParticle, G4InuclNuclei, G4InuclElementaryParticle:  Rewrite to
+  carry G4DynamicParticle data member, and to instantiate particle
+  properties via G4ParticleDefinition subclasses.  This is first stage in
+  eventually eliminating the G4InuclParticle stuff entirely in favor of
+  direct use of G4DynamicParticle for internal propagation.
+These changes have been testing using debugging output on the production
+(4.9.3) code compared to the above changes.  |diff| shows mostly identical
+results, with occasional ~1e-5 floating point differences.
+Jan 2010 Michael Kelsey (hadr-casc-V09-03-00)
+------------------------------------------------
+All changes below within "cascade/" subdirectory:
+- G4BertiniNuclearModel:  REMOVE this class from the HEAD, and hopefully all
+  future tags.  It is redundant with the G4NuclearModel class, and is not
+  used anywhere in the G4 distribtion; the latter is referenced in both
+  regular G4 code and in examples.
+- G4Diproton, G4Dineutron, G4UnboundPN:  New G4ParticleDefinition
+  subclasses, which implement the Bertini-specific dibaryon states.  These
+  are not used anywhere as yet, but will be used in future modifications to
+  the G4InuclParticle subclasses.
+- G4CascadeMomentum:  Add interface to create from and cast to
+  G4LorentzVector.  Will be used (in future) by G4InuclParticle modifications,
+  and provides a transition to eliminating this class entirely.
 Dec 2009 Dennis Wright (hadr-casc-V09-02-11)

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4BigBanger.hh,v 1.13 2010/05/21 17:56:34 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100315  M. Kelsey -- Remove "using" directive and unnecessary #includes.
+// 20100407  M. Kelsey -- Replace std::vector<> returns with data members.
+// 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
+// 20100517  M. Kelsey -- Inherit from common base class
+// 20100519  M. Kelsey -- Get rid of proton and neutron masses as arguments!
 #ifndef G4BIG_BANGER_HH
 #define G4BIG_BANGER_HH
 #include "G4Collider.hh"
+#include "G4VCascadeCollider.hh"
 #include "G4InuclElementaryParticle.hh"
+#include "G4InuclSpecialFunctions.hh"
+#include <vector>
+class G4CollisionOutput;
+using namespace G4InuclSpecialFunctions;
+class G4BigBanger : public G4VCascadeCollider {
+public:
+  G4BigBanger();
+  virtual ~G4BigBanger() {};
+class G4BigBanger {
+public:
+  G4BigBanger();
+  G4CollisionOutput collide(G4InuclParticle* bullet,
+                            G4InuclParticle* target);
+  void collide(G4InuclParticle* bullet, G4InuclParticle* target,
+               G4CollisionOutput& output);
 private:
+  void generateBangInSCM(G4double etot, G4double a, G4double z);
+G4int verboseLevel;
+  std::vector<G4InuclElementaryParticle> generateBangInSCM(G4double etot,
+                                                      G4double a,
+                                                      G4double z,
+                                                      G4double mp,
+                                                      G4double mn) const;
+  std::vector<G4double> generateMomentumModules(G4double etot,
+                                           G4double a,
+                                           G4double z,
+                                           G4double mp,
+                                           G4double mn) const;
+  void generateMomentumModules(G4double etot, G4double a, G4double z);
   G4double xProbability(G4double x,
 …
                      G4double promax) const;
+  // Buffers for big-bang results
+  std::vector<G4InuclElementaryParticle> particles;
+  std::vector<G4double> momModules;
 };
 #endif // G4BIG_BANGER_HH
+#endif /* G4BIG_BANGER_HH */

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

-              r1196
+              r1315
+#ifndef G4CASCAD_PARTICLE_HH
+#define G4CASCAD_PARTICLE_HH
 //
 // ********************************************************************
 …
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadParticle.hh,v 1.14 2010/03/16 22:10:26 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+#ifndef G4CASCAD_PARTICLE_HH
+#define G4CASCAD_PARTICLE_HH
+// 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
 #include "G4InuclElementaryParticle.hh"
+#include "G4LorentzVector.hh"
+#include "G4ThreeVector.hh"
 class G4CascadParticle {
 public:
+  // NOTE:  Default constructor does not make a functional object!
   G4CascadParticle();
   G4CascadParticle(const G4InuclElementaryParticle& particle,
                    const std::vector<G4double>& pos,
+                   const G4ThreeVector& pos,
                    G4int izone,
                    G4double cpath,
                    G4int gen)
+    : verboseLevel(0), theParticle(particle), position(pos),
+      current_zone(izone), current_path(cpath), movingIn(true),
+      reflectionCounter(0), reflected(false), generation(gen) {}
+    : theParticle(particle),
+    position(pos),
+    current_zone(izone),
+    current_path(cpath) {
+    current_path = cpath;
+    movingIn = true;
+    reflectionCounter = 0;
+    generation = gen;
+  };
+  void updateParticleMomentum(const G4LorentzVector& mom) {
+    theParticle.setMomentum(mom);
+  }
+  void updateParticleMomentum(const G4CascadeMomentum& mom) {
+    theParticle.setMomentum(mom);
+  };
+  void updatePosition(const std::vector<G4double>& pos) {
+  void updatePosition(const G4ThreeVector& pos) {
     position = pos;
   };
+  }
   void incrementReflectionCounter() {
     reflectionCounter++;
     reflected = true;
   };
+  }
   void resetReflection() {
     reflected = false;
   };
+  }
   void incrementCurrentPath(G4double npath) {
     current_path += npath;
   };
+  }
   void updateZone(G4int izone) {
     current_zone = izone;
   };
+  }
   G4bool movingInsideNuclei() const {
     return movingIn;
   };
+  }
   G4double getPathToTheNextZone(G4double rz_in,
                                 G4double rz_out);
   const G4CascadeMomentum& getMomentum() const {
+  G4LorentzVector getMomentum() const {         // Can't return ref; temporary
     return theParticle.getMomentum();
   };
+  }
   G4InuclElementaryParticle getParticle() const {
+  const G4InuclElementaryParticle& getParticle() const {
     return theParticle;
   };
+  }
+  const std::vector<G4double>& getPosition() const {
+  G4InuclElementaryParticle& getParticle() {
+    return theParticle;
+  }
+  const G4ThreeVector& getPosition() const {
     return position;
   };
+  }
   G4int getCurrentZone() const {
     return current_zone;
   };
+  }
   G4int getNumberOfReflections() const {
     return reflectionCounter;
   };
+  }
   G4bool young(G4double young_path_cut,
                G4double cpath) const {
+    if(current_path < 1000.0) {
+      return cpath < young_path_cut;
+    }
+    else {
+      return false;
+    };
+    // return current_path + cpath < young_path_cut;
+  };
+    return ((current_path < 1000.) && (cpath < young_path_cut));
+  }
   G4bool reflectedNow() const {
     return reflected;
   };
+  }
   void propagateAlongThePath(G4double path);
+  void print() const {
+    theParticle.printParticle();
+    G4cout << " zone " << current_zone << " current_path " << current_path
+           << " reflectionCounter " << reflectionCounter << G4endl
+           << " x " << position[0] << " y " << position[1]
+           << " z " << position[2] << G4endl;
+  };
+  void print() const;
   G4int getGeneration() {
 …
 private:
   G4int verboseLevel;
   G4InuclElementaryParticle theParticle;
   std::vector<G4double> position;
+  G4ThreeVector position;
   G4int current_zone;
   G4double current_path;

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeChannel.hh,v 1.6 2010/05/15 04:25:17 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100514  M. Kelsey -- All functionality removed except quantum-number
+//              validation functions.
 #ifndef G4_CASCADE_CHANNEL_HH
 #define G4_CASCADE_CHANNEL_HH
 #include "globals.hh"
+#include "G4FastVector.hh"
+#include "G4ReactionProduct.hh"
 #include <vector>
+class G4CascadeChannel {
+namespace G4CascadeChannel {
+  std::vector<G4int> getQnums(G4int type);
+public:
+  static std::pair<G4int, G4double> interpolateEnergy(G4double ke);
+  static G4int sampleFlat(std::vector<G4double> const& sigma);
+  static std::vector<G4int> getQnums(G4int type);
+private:
+  G4CascadeChannel(); // not implemented
+  static const double energyScale[31];
+};
+  void CheckQnums(const G4FastVector<G4ReactionProduct,256> &vec,
+                  G4int &vecLen,
+                  G4ReactionProduct &currentParticle,
+                  G4ReactionProduct &targetParticle,
+                  G4double Q, G4double B, G4double S);
+}
 #endif

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

-              r967
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeData.hh,v 1.5 2010/05/16 05:18:36 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100507  M. Kelsey -- Use template arguments to dimension const-refs
+//              to arrays,for use in passing to functions as dimensioned.
+//              Add two additional optional(!) template args for piN/NN.
+//              Add new data member "sum" to separate summed xsec values
+//              from measured inclusive (tot) cross-sections.  Add two
+//              ctors to pass inclusive xsec array as input (for piN/NN).
 #ifndef G4_CASCADE_DATA_HH
 #define G4_CASCADE_DATA_HH
 #include "globals.hh"
+#include "G4CascadeSampler.hh"          /* To get number of energy bins */
 template <int n2, int n3, int n4, int n5, int n6, int n7, int nxs>
+template <int NE,int N2,int N3,int N4,int N5,int N6,int N7,int N8=0,int N9=0>
 struct G4CascadeData
+{
+  G4double *  tot;
+  // NOTE: Need access to N2 by value to initialize index array
+  enum { N02=N2, N23=N2+N3, N24=N23+N4, N25=N24+N5, N26=N25+N6, N27=N26+N7,
+         N28=N27+N8, N29=N28+N9 };
+  typedef G4double multiplicities_t[31];
+  multiplicities_t * multiplicities;
+  enum { N8D=N8?N8:1, N9D=N9?N9:1 };    // SPECIAL: Can't dimension arrays [0]
+  typedef G4int index_t[2];
+  index_t const * index;
+  enum { NM=N9?8:N8?7:6, NXS=N29 };     // Multiplicity and cross-section bins
   typedef G4int x2bfs_t[2];
   x2bfs_t const * x2bfs;
+  G4int index[NM+1];                    // Start and stop indices to xsec's
+  G4double multiplicities[NM][NE];      // Multiplicity distributions
+  typedef G4int x3bfs_t[3];
+  x3bfs_t const * x3bfs;
+  const G4int (&x2bfs)[N2][2];          // Initialized from file-scope inputs
+  const G4int (&x3bfs)[N3][3];
+  const G4int (&x4bfs)[N4][4];
+  const G4int (&x5bfs)[N5][5];
+  const G4int (&x6bfs)[N6][6];
+  const G4int (&x7bfs)[N7][7];
+  const G4int (&x8bfs)[N8D][8];         // These may not be used if mult==7
+  const G4int (&x9bfs)[N9D][9];
+  const G4double (&crossSections)[NXS][NE];
   typedef G4int x4bfs_t[4];
   x4bfs_t const * x4bfs;
+  G4double sum[NE];                     // Summed cross-sections, computed
+  const G4double (&tot)[NE];            // Inclusive cross-sections (from input)
   typedef G4int x5bfs_t[5];
   x5bfs_t const * x5bfs;
+  static const G4int empty8bfs[1][8];   // For multiplicity==7 case
+  static const G4int empty9bfs[1][9];
+  typedef G4int x6bfs_t[6];
+  x6bfs_t const * x6bfs;
+  G4int maxMultiplicity() const { return NM+1; }  // Used by G4CascadeFunctions
+  typedef G4int x7bfs_t[7];
+  x7bfs_t const * x7bfs;
+  // Constructor for kaon/hyperon channels, with multiplicity <= 7
+  G4CascadeData(const G4int (&the2bfs)[N2][2], const G4int (&the3bfs)[N3][3],
+                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])
+    : x2bfs(the2bfs), x3bfs(the3bfs), x4bfs(the4bfs), x5bfs(the5bfs),
+      x6bfs(the6bfs), x7bfs(the7bfs), x8bfs(empty8bfs), x9bfs(empty9bfs),
+      crossSections(xsec), tot(sum) { initialize(); }
+  typedef G4float crossSections_t[31];
+  crossSections_t const * crossSections;
+  // Constructor for kaon/hyperon channels, with multiplicity <= 7 and inclusive
+  G4CascadeData(const G4int (&the2bfs)[N2][2], const G4int (&the3bfs)[N3][3],
+                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])
+    : x2bfs(the2bfs), x3bfs(the3bfs), x4bfs(the4bfs), x5bfs(the5bfs),
+      x6bfs(the6bfs), x7bfs(the7bfs), x8bfs(empty8bfs), x9bfs(empty9bfs),
+      crossSections(xsec), tot(theTot) { initialize(); }
+  void initialize();
+  // Constructor for pion/nuleon channels, with multiplicity > 7
+  G4CascadeData(const G4int (&the2bfs)[N2][2], const G4int (&the3bfs)[N3][3],
+                const G4int (&the4bfs)[N4][4], const G4int (&the5bfs)[N5][5],
+                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])
+    : x2bfs(the2bfs), x3bfs(the3bfs), x4bfs(the4bfs), x5bfs(the5bfs),
+      x6bfs(the6bfs), x7bfs(the7bfs), x8bfs(the8bfs), x9bfs(the9bfs),
+      crossSections(xsec), tot(sum) { initialize(); }
+//   G4double tot[31];
+//   G4double multiplicities[6][31];
+//   G4int index[6][2];
+//   G4int x2bfs[n2][2];
+//   G4int x3bfs[n3][3];
+//   G4int x4bfs[n4][4];
+//   G4int x5bfs[n5][5];
+//   G4int x6bfs[n6][6];
+//   G4int x7bfs[n7][7];
+//   G4float crossSections[nxs][31];
+  // Constructor for pion/nuleon channels, with multiplicity > 7 and inclusive
+  G4CascadeData(const G4int (&the2bfs)[N2][2], const G4int (&the3bfs)[N3][3],
+                const G4int (&the4bfs)[N4][4], const G4int (&the5bfs)[N5][5],
+                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])
+    : x2bfs(the2bfs), x3bfs(the3bfs), x4bfs(the4bfs), x5bfs(the5bfs),
+      x6bfs(the6bfs), x7bfs(the7bfs), x8bfs(the8bfs), x9bfs(the9bfs),
+      crossSections(xsec), tot(theTot) { initialize(); }
+  void initialize();                    // Fill summed arrays from input
 };
+template <int n2, int n3, int n4, int n5, int n6, int n7, int nxs>
+inline
+void
+G4CascadeData<n2, n3, n4, n5, n6, n7, nxs>::initialize()
+{
+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;
+  if (NM>6) index[7]=N28;
+  if (NM>7) index[8]=N29;
   // Initialize multiplicity array
+  for (G4int m = 0; m < 6; m++) {
+    G4int start = index[m][0];
+    G4int stop = index[m][1];
+    for (G4int k = 0; k < 31; k++) {
+  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++) {
 …
   // Initialize total cross section array
+  for (G4int k = 0; k < 31; k++) {
+    tot[k] = 0.0;
+    for (G4int m = 0; m < 6; m++) {
+      tot[k] += multiplicities[m][k];
+  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
+template <int NE,int N2,int N3,int N4,int N5,int N6,int N7,int N8,int N9>
+const G4int G4CascadeData<NE,N2,N3,N4,N5,N6,N7,N8,N9>::empty8bfs[1][8] = {{0}};
+template <int NE,int N2,int N3,int N4,int N5,int N6,int N7,int N8,int N9>
+const G4int G4CascadeData<NE,N2,N3,N4,N5,N6,N7,N8,N9>::empty9bfs[1][9] = {{0}};
 #endif

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

-              r967
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeFunctions.hh,v 1.5 2010/05/14 21:05:03 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100407  M. Kelsey -- Return particle types std::vector<> by const ref,
+//              using a static variable in the function as a buffer.
+// 20100505  M. Kelsey -- Use new interpolator class, drop std::pair<>, move
+//              sampleFlat(...) from G4CascadeChannel, move functionality
+//              to new base class, to allow data-member buffers.  Move
+//              function definitions to .icc file (needed with templating).
+// 20100510  M. Kelsey -- Use both summed and inclusive cross-sections for
+//              multiplicity, as done in G4{Pion,Nucleon}Sampler.  Support
+//              up to 9-body final states.  Add second argument specifying
+//              which Sampler is used.  Move implementations to .icc file.
+// 20100511  M. Kelsey -- Pass "kinds" buffer as input to getOutputPartTypes
 #ifndef G4_CASCADE_FUNCTIONS_HH
 #define G4_CASCADE_FUNCTIONS_HH
+#include "globals.hh"
+#include "Randomize.hh"
 #include <vector>
-#include "globals.hh"
-#include "G4CascadeChannel.hh"
+template <class T>
+class G4CascadeFunctions
+{
+template <class DATA, class SAMP>
+class G4CascadeFunctions : public SAMP {
 public:
+  static G4double getCrossSection(double ke);
+  static G4double getCrossSection(double ke) {
+    return instance.findCrossSection(ke, DATA::data.tot);
+  }
+  static G4double getCrossSectionSum(double ke) {
+    return instance.findCrossSection(ke, DATA::data.sum);
+  }
   static G4int getMultiplicity(G4double ke);
+  static std::vector<G4int> getOutgoingParticleTypes(G4int mult, G4double ke);
+  static void
+  getOutgoingParticleTypes(std::vector<G4int>& kinds, G4int mult, G4double ke);
+private:
+  G4CascadeFunctions() : SAMP() {}
+  static const G4CascadeFunctions<DATA,SAMP> instance;
 };
+template <class T>
+inline
+G4double
+G4CascadeFunctions<T>::getCrossSection(double ke)
+{
+  std::pair<G4int, G4double> epair = G4CascadeChannel::interpolateEnergy(ke);
+  G4int k = epair.first;
+  G4double fraction = epair.second;
+  return T::data.tot[k] + fraction*(T::data.tot[k+1] - T::data.tot[k]);
+}
+#include "G4CascadeFunctions.icc"
+template <class T>
+inline
+G4int
+G4CascadeFunctions<T>::getMultiplicity(G4double ke)
+{
+  G4double multint(0.0);
+  std::vector<G4double> sigma;
+  std::pair<G4int, G4double> epair = G4CascadeChannel::interpolateEnergy(ke);
+  G4int k = epair.first;
+  G4double fraction = epair.second;
+  for (G4int m = 0; m < 6; ++m)
+    {
+      multint = T::data.multiplicities[m][k]
+        + fraction * (T::data.multiplicities[m][k+1] - T::data.multiplicities[m][k]);
+      sigma.push_back(multint);
+    }
+  return G4CascadeChannel::sampleFlat(sigma);
+}
+template <class T>
+inline
+std::vector<G4int>
+G4CascadeFunctions<T>::getOutgoingParticleTypes(G4int mult, G4double ke)
+{
+  G4int i;
+  G4double sigint(0.);
+  std::vector<G4double> sigma;
+  std::pair<G4int, G4double> epair = G4CascadeChannel::interpolateEnergy(ke);
+  G4int k = epair.first;
+  G4double fraction = epair.second;
+  G4int start = T::data.index[mult-2][0];
+  G4int stop = T::data.index[mult-2][1];
+  for (i = start; i < stop; i++) {
+    sigint = T::data.crossSections[i][k]
+      + fraction*(T::data.crossSections[i][k+1] - T::data.crossSections[i][k]);
+    sigma.push_back(sigint);
+  }
+  G4int channel = G4CascadeChannel::sampleFlat(sigma);
+  std::vector<G4int> kinds;
+  if (mult == 2) {
+    for(i = 0; i < mult; i++) kinds.push_back(T::data.x2bfs[channel][i]);
+  } else if (mult == 3) {
+    for(i = 0; i < mult; i++) kinds.push_back(T::data.x3bfs[channel][i]);
+  } else if (mult == 4) {
+    for(i = 0; i < mult; i++) kinds.push_back(T::data.x4bfs[channel][i]);
+  } else if (mult == 5) {
+    for(i = 0; i < mult; i++) kinds.push_back(T::data.x5bfs[channel][i]);
+  } else if (mult == 6) {
+    for(i = 0; i < mult; i++) kinds.push_back(T::data.x6bfs[channel][i]);
+  } else if (mult == 7) {
+    for(i = 0; i < mult; i++) kinds.push_back(T::data.x7bfs[channel][i]);
+  } else {
+    G4cout << " Illegal multiplicity " << G4endl;
+  }
+  return kinds;
+}
+#endif
+#endif  /* G4_CASCADE_FUNCTIONS_HH */

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

-              r1196
+              r1315
 // ********************************************************************
 //
 // $Id: G4CascadeInterface.hh,v 1.14 2009/09/24 20:48:02 dennis Exp $
+// $Id: G4CascadeInterface.hh,v 1.16 2010/05/21 18:07:30 mkelsey Exp $
 // Defines an interface to Bertini (BERT) cascade
 // based on INUCL  intra-nuclear transport.models
 // with bullet hadron energy ~< 10 GeV
+//
+// 20100405  M. Kelsey -- Fix constness of op== and op!=
+// 20100519  M. Kelsey -- Remove Collider data members
 #ifndef G4CASCADEINTERFACE_H
 #define G4CASCADEINTERFACE_H 1
+#include "G4VIntraNuclearTransportModel.hh"
+#include "G4FragmentVector.hh"
+#include "G4KineticTrackVector.hh"
 #include "G4Nucleon.hh"
 #include "G4Nucleus.hh"
-#include "G4VIntraNuclearTransportModel.hh"
-#include "G4KineticTrackVector.hh"
-#include "G4FragmentVector.hh"
 #include "G4ParticleChange.hh"
+#include "G4ReactionProduct.hh"
 #include "G4ReactionProductVector.hh"
-#include "G4ReactionProduct.hh"
-#include "G4ElementaryParticleCollider.hh"
-#include "G4NonEquilibriumEvaporator.hh"
-#include "G4EquilibriumEvaporator.hh"
-#include "G4Fissioner.hh"
-#include "G4BigBanger.hh"
-#include "G4IntraNucleiCascader.hh"
 …
   virtual ~G4CascadeInterface();
+  G4ReactionProductVector* Propagate(G4KineticTrackVector* theSecondaries, G4V3DNucleus* theNucleus);
+  G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack, G4Nucleus& theNucleus);
+  G4ReactionProductVector* Propagate(G4KineticTrackVector* theSecondaries,
+                                     G4V3DNucleus* theNucleus);
+  G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                 G4Nucleus& theNucleus);
 private:
   G4int operator==(G4CascadeInterface& right) {
+  G4int operator==(const G4CascadeInterface& right) const {
     return (this == &right);
+  }
   G4int operator!=(G4CascadeInterface& right) {
+  G4int operator!=(const G4CascadeInterface& right) const {
     return (this != &right);
+  }
 …
 private:
-  G4ElementaryParticleCollider colep;
-  G4NonEquilibriumEvaporator noneq;
-  G4EquilibriumEvaporator eqil;
-  G4Fissioner fiss;
-  G4BigBanger bigb;
-  G4IntraNucleiCascader inc;
   G4HadFinalState theResult;
 };

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeKminusNChannel.hh,v 1.6 2010/05/15 00:55:01 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100507  M. Kelsey -- Remove redundant total-bins template argument
+// 20100510  M. Kelsey -- Add initial "31" template arg.  Add G4CascSampler
+//              to template for channel typedef
+// 20100514  M. Kelsey -- Replace G4CascadeSampler with G4KaonHypSampler.
 #ifndef G4_CASCADE_KMINUSN_CHANNEL_HH
 #define G4_CASCADE_KMINUSN_CHANNEL_HH
 #include "G4CascadeData.hh"
 #include "G4CascadeFunctions.hh"
+#include "G4KaonHypSampler.hh"
 struct G4CascadeKminusNChannelData {
   typedef G4CascadeData<5,15,28,42,20,11,121> data_t;
+  typedef G4CascadeData<31,5,15,28,42,20,11> data_t;
   static data_t data;
 };
+typedef G4CascadeFunctions<G4CascadeKminusNChannelData> G4CascadeKminusNChannel;
+typedef G4CascadeFunctions<G4CascadeKminusNChannelData,G4KaonHypSampler> G4CascadeKminusNChannel;
 #endif

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeKminusPChannel.hh,v 1.6 2010/05/15 00:55:01 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100507  M. Kelsey -- Remove redundant total-bins template argument
+// 20100510  M. Kelsey -- Add initial "31" template arg.  Add G4CascSampler
+//              to template for channel typedef
+// 20100514  M. Kelsey -- Replace G4CascadeSampler with G4KaonHypSampler.
 #ifndef G4_CASCADE_KMINUSP_CHANNEL_HH
 #define G4_CASCADE_KMINUSP_CHANNEL_HH
 …
 #include "G4CascadeData.hh"
 #include "G4CascadeFunctions.hh"
+#include "G4KaonHypSampler.hh"
 struct  G4CascadeKminusPChannelData {
   typedef G4CascadeData<8,20,34,48,22,16,148> data_t;
+  typedef G4CascadeData<31,8,20,34,48,22,16> data_t;
   static data_t data;
 };
 typedef G4CascadeFunctions<G4CascadeKminusPChannelData> G4CascadeKminusPChannel;
+typedef G4CascadeFunctions<G4CascadeKminusPChannelData,G4KaonHypSampler> G4CascadeKminusPChannel;
 #endif

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeKplusNChannel.hh,v 1.6 2010/05/15 00:55:01 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100507  M. Kelsey -- Remove redundant total-bins template argument
+// 20100510  M. Kelsey -- Add initial "31" template arg.  Add G4CascSampler
+//              to template for channel typedef
+// 20100514  M. Kelsey -- Replace G4CascadeSampler with G4KaonHypSampler.
 #ifndef G4_CASCADE_KPLUSN_CHANNEL_HH
 #define G4_CASCADE_KPLUSN_CHANNEL_HH
 …
 #include "G4CascadeData.hh"
 #include "G4CascadeFunctions.hh"
+#include "G4KaonHypSampler.hh"
 struct G4CascadeKplusNChannelData {
   typedef G4CascadeData<2,5,13,22,32,41,115> data_t;
+  typedef G4CascadeData<31,2,5,13,22,32,41> data_t;
   static data_t data;
 };
 typedef G4CascadeFunctions<G4CascadeKplusNChannelData> G4CascadeKplusNChannel;
+typedef G4CascadeFunctions<G4CascadeKplusNChannelData,G4KaonHypSampler> G4CascadeKplusNChannel;
 #endif

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeKplusPChannel.hh,v 1.6 2010/05/15 00:55:01 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100507  M. Kelsey -- Remove redundant total-bins template argument
+// 20100510  M. Kelsey -- Add initial "31" template arg.  Add G4CascSampler
+//              to template for channel typedef
+// 20100514  M. Kelsey -- Replace G4CascadeSampler with G4KaonHypSampler.
 #ifndef G4_CASCADE_KPLUSP_CHANNEL_HH
 #define G4_CASCADE_KPLUSP_CHANNEL_HH
 …
 #include "G4CascadeData.hh"
 #include "G4CascadeFunctions.hh"
+#include "G4KaonHypSampler.hh"
 struct G4CascadeKplusPChannelData {
   typedef G4CascadeData<1,4,10,19,28,38,100> data_t;
+  typedef G4CascadeData<31,1,4,10,19,28,38> data_t;
   static data_t data;
 };
 typedef G4CascadeFunctions<G4CascadeKplusPChannelData> G4CascadeKplusPChannel;
+typedef G4CascadeFunctions<G4CascadeKplusPChannelData,G4KaonHypSampler> G4CascadeKplusPChannel;
 #endif

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeKzeroBarNChannel.hh,v 1.6 2010/05/15 00:55:01 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100507  M. Kelsey -- Remove redundant total-bins template argument
+// 20100510  M. Kelsey -- Add initial "31" template arg.  Add G4CascSampler
+//              to template for channel typedef
+// 20100514  M. Kelsey -- Replace G4CascadeSampler with G4KaonHypSampler.
 #ifndef G4_CASCADE_KZEROBARN_CHANNEL_HH
 #define G4_CASCADE_KZEROBARN_CHANNEL_HH
 …
 #include "G4CascadeData.hh"
 #include "G4CascadeFunctions.hh"
+#include "G4KaonHypSampler.hh"
 struct G4CascadeKzeroBarNChannelData {
   typedef G4CascadeData<8,20,34,48,22,16,148> data_t;
+  typedef G4CascadeData<31,8,20,34,48,22,16> data_t;
   static data_t data;
 };
 typedef G4CascadeFunctions<G4CascadeKzeroBarNChannelData> G4CascadeKzeroBarNChannel;
+typedef G4CascadeFunctions<G4CascadeKzeroBarNChannelData,G4KaonHypSampler> G4CascadeKzeroBarNChannel;
 #endif

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeKzeroBarPChannel.hh,v 1.6 2010/05/15 00:55:01 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100507  M. Kelsey -- Remove redundant total-bins template argument
+// 20100510  M. Kelsey -- Add initial "31" template arg.  Add G4CascSampler
+//              to template for channel typedef
+// 20100514  M. Kelsey -- Replace G4CascadeSampler with G4KaonHypSampler.
 #ifndef G4_CASCADE_KZEROBARP_CHANNEL_HH
 #define G4_CASCADE_KZEROBARP_CHANNEL_HH
 …
 #include "G4CascadeData.hh"
 #include "G4CascadeFunctions.hh"
+#include "G4KaonHypSampler.hh"
 struct G4CascadeKzeroBarPChannelData {
   typedef G4CascadeData<5,15,28,42,20,11,121> data_t;
+  typedef G4CascadeData<31,5,15,28,42,20,11> data_t;
   static data_t data;
 };
 typedef G4CascadeFunctions<G4CascadeKzeroBarPChannelData> G4CascadeKzeroBarPChannel;
+typedef G4CascadeFunctions<G4CascadeKzeroBarPChannelData,G4KaonHypSampler> G4CascadeKzeroBarPChannel;
 #endif

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeKzeroNChannel.hh,v 1.6 2010/05/15 00:55:01 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100507  M. Kelsey -- Remove redundant total-bins template argument
+// 20100510  M. Kelsey -- Add initial "31" template arg.  Add G4CascSampler
+//              to template for channel typedef
+// 20100514  M. Kelsey -- Replace G4CascadeSampler with G4KaonHypSampler.
 #ifndef G4_CASCADE_KZERON_CHANNEL_HH
 #define G4_CASCADE_KZERON_CHANNEL_HH
 …
 #include "G4CascadeData.hh"
 #include "G4CascadeFunctions.hh"
+#include "G4KaonHypSampler.hh"
 struct G4CascadeKzeroNChannelData {
   typedef G4CascadeData<1,4,10,19,28,38,100> data_t;
+  typedef G4CascadeData<31,1,4,10,19,28,38> data_t;
   static data_t data;
 };
 typedef G4CascadeFunctions<G4CascadeKzeroNChannelData> G4CascadeKzeroNChannel;
+typedef G4CascadeFunctions<G4CascadeKzeroNChannelData,G4KaonHypSampler> G4CascadeKzeroNChannel;
 #endif

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeKzeroPChannel.hh,v 1.6 2010/05/15 00:55:01 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100507  M. Kelsey -- Remove redundant total-bins template argument
+// 20100510  M. Kelsey -- Add initial "31" template arg.  Add G4CascSampler
+//              to template for channel typedef
+// 20100514  M. Kelsey -- Replace G4CascadeSampler with G4KaonHypSampler.
 #ifndef G4_CASCADE_KZEROP_CHANNEL_HH
 #define G4_CASCADE_KZEROP_CHANNEL_HH
 …
 #include "G4CascadeData.hh"
 #include "G4CascadeFunctions.hh"
+#include "G4KaonHypSampler.hh"
 struct G4CascadeKzeroPChannelData {
   typedef G4CascadeData<2,5,13,22,32,41,115> data_t;
+  typedef G4CascadeData<31,2,5,13,22,32,41> data_t;
   static data_t data;
 };
 typedef G4CascadeFunctions<G4CascadeKzeroPChannelData> G4CascadeKzeroPChannel;
+typedef G4CascadeFunctions<G4CascadeKzeroPChannelData,G4KaonHypSampler> G4CascadeKzeroPChannel;
 #endif

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeLambdaNChannel.hh,v 1.6 2010/05/15 00:55:01 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100507  M. Kelsey -- Remove redundant total-bins template argument
+// 20100510  M. Kelsey -- Add initial "31" template arg.  Add G4CascSampler
+//              to template for channel typedef
+// 20100514  M. Kelsey -- Replace G4CascadeSampler with G4KaonHypSampler.
 #ifndef G4_CASCADE_LAMBDAN_CHANNEL_HH
 #define G4_CASCADE_LAMBDAN_CHANNEL_HH
 …
 #include "G4CascadeData.hh"
 #include "G4CascadeFunctions.hh"
+#include "G4KaonHypSampler.hh"
 struct G4CascadeLambdaNChannelData {
   typedef G4CascadeData<3,12,33,59,30,20,157> data_t;
+  typedef G4CascadeData<31,3,12,33,59,30,20> data_t;
   static data_t data;
 };
 typedef G4CascadeFunctions<G4CascadeLambdaNChannelData> G4CascadeLambdaNChannel;
+typedef G4CascadeFunctions<G4CascadeLambdaNChannelData,G4KaonHypSampler> G4CascadeLambdaNChannel;
 #endif

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeLambdaPChannel.hh,v 1.6 2010/05/15 00:55:01 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100507  M. Kelsey -- Remove redundant total-bins template argument
+// 20100510  M. Kelsey -- Add initial "31" template arg.  Add G4CascSampler
+//              to template for channel typedef
+// 20100514  M. Kelsey -- Replace G4CascadeSampler with G4KaonHypSampler.
 #ifndef G4_CASCADE_LAMBDAP_CHANNEL_HH
 #define G4_CASCADE_LAMBDAP_CHANNEL_HH
 …
 #include "G4CascadeData.hh"
 #include "G4CascadeFunctions.hh"
+#include "G4KaonHypSampler.hh"
 struct G4CascadeLambdaPChannelData {
   typedef G4CascadeData<3,12,33,59,30,20,157> data_t;
+  typedef G4CascadeData<31,3,12,33,59,30,20> data_t;
   static data_t data;
 };
 typedef G4CascadeFunctions<G4CascadeLambdaPChannelData> G4CascadeLambdaPChannel;
+typedef G4CascadeFunctions<G4CascadeLambdaPChannelData,G4KaonHypSampler> G4CascadeLambdaPChannel;
 #endif

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

-              r1228
+              r1315
 // ********************************************************************
 //
+// $Id: G4CascadeMomentum.hh,v 1.1 2008/09/22 10:06:32 gcosmo Exp $
+// GEANT4 tag $Name: geant4-09-03 $
+//
+// $Id: G4CascadeMomentum.hh,v 1.5 2010/03/16 22:10:26 mkelsey Exp $
+// GEANT4 tag $Name: geant4-09-04-beta-cand-01 $
 //
 // Class G4CascadeMomentum
 …
 // std::vector<double> in the cascade mode code, which causes
 // problems for performance due to excess memory allocations.
+//
+// NOTE:  The Bertini code does not pass legitimate four-vectors when
+//        creating new particles; the new getLV() function takes an
+//        optional mass argument (in Bertini units [GeV]) so that a
+//        valid G4LorentzVector can be returned.
+//
 // Author: Peter Elmer, Princeton University                  7-Aug-2008
+// Update: Michael Kelsey, SLAC (support G4LorentzVector)     8-Jan-2010
 // --------------------------------------------------------------------
 #ifndef G4CASCADE_MOMENTUM_HH
 …
 #include "G4Types.hh"
+#include "G4LorentzVector.hh"
+#include "G4ThreeVector.hh"
 class G4CascadeMomentum
+{
   public:
     G4CascadeMomentum() {for (int i=0; i<4; ++i) data_[i]=0.0;}
+    G4double& operator[](int i)
+    {
+    // WARNING!  This metric is (t,x,y,z), DIFFERENT FROM HepLV!
+    G4CascadeMomentum(const G4LorentzVector& lv) {
+      setLV(lv);
+    }
+    G4double& operator[](int i) {
       assert(i>=0 && i<4);
       return data_[i];
+    }
+    const G4double& operator[](int i) const
+    {
+    const G4double& operator[](int i) const {
       assert(i>=0 && i<4);
       return data_[i];
+    }
+    operator const G4LorentzVector&() const {
+      return getLV();                   // Casting can't do mass repairs
+    }
+    const G4LorentzVector& getLV(G4double mass=-1.) const {
+      if (mass>=0.) lv.setVectM(get3V(),mass);          // Force input mass!
+      else lv.set(data_[1],data_[2],data_[3],data_[0]);
+      return lv;
+    }
+    G4ThreeVector get3V() const {
+      return getLV().vect();
+    }
+    void setLV(const G4LorentzVector& lv) {
+      data_[0] = lv.t();                // NOTE DIFFERENT METRIC CONVENTION!
+      data_[1] = lv.x();
+      data_[2] = lv.y();
+      data_[3] = lv.z();
+    }
+    G4CascadeMomentum& operator=(const G4LorentzVector& lv) {
+      setLV(lv);
+      return *this;
+    }
   private:
+    G4double data_[4];
+    mutable G4LorentzVector lv;         // Buffer for conversion operations
+};
-    G4double data_[4];
-};
 #endif

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeSigmaMinusNChannel.hh,v 1.6 2010/05/15 00:55:01 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100507  M. Kelsey -- Remove redundant total-bins template argument
+// 20100510  M. Kelsey -- Add initial "31" template arg.  Add G4CascSampler
+//              to template for channel typedef
+// 20100514  M. Kelsey -- Replace G4CascadeSampler with G4KaonHypSampler.
 #ifndef G4_CASCADE_SIGMAMINUSN_CHANNEL_HH
 #define G4_CASCADE_SIGMAMINUSN_CHANNEL_HH
 …
 #include "G4CascadeData.hh"
 #include "G4CascadeFunctions.hh"
+#include "G4KaonHypSampler.hh"
 struct G4CascadeSigmaMinusNChannelData {
   typedef G4CascadeData<1,6,20,42,25,17,111> data_t;
+  typedef G4CascadeData<31,1,6,20,42,25,17> data_t;
   static data_t data;
 };
 typedef G4CascadeFunctions<G4CascadeSigmaMinusNChannelData> G4CascadeSigmaMinusNChannel;
+typedef G4CascadeFunctions<G4CascadeSigmaMinusNChannelData,G4KaonHypSampler> G4CascadeSigmaMinusNChannel;
 #endif

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeSigmaMinusPChannel.hh,v 1.6 2010/05/15 00:55:01 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100507  M. Kelsey -- Remove redundant total-bins template argument
+// 20100510  M. Kelsey -- Add initial "31" template arg.  Add G4CascSampler
+//              to template for channel typedef
+// 20100514  M. Kelsey -- Replace G4CascadeSampler with G4KaonHypSampler.
 #ifndef G4_CASCADE_SIGMAMINUSP_CHANNEL_HH
 #define G4_CASCADE_SIGMAMINUSP_CHANNEL_HH
 …
 #include "G4CascadeData.hh"
 #include "G4CascadeFunctions.hh"
+#include "G4KaonHypSampler.hh"
 struct G4CascadeSigmaMinusPChannelData {
   typedef G4CascadeData<3,12,33,59,30,20,157> data_t;
+  typedef G4CascadeData<31,3,12,33,59,30,20> data_t;
   static data_t data;
 };
 typedef G4CascadeFunctions<G4CascadeSigmaMinusPChannelData> G4CascadeSigmaMinusPChannel;
+typedef G4CascadeFunctions<G4CascadeSigmaMinusPChannelData,G4KaonHypSampler> G4CascadeSigmaMinusPChannel;
 #endif

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeSigmaPlusNChannel.hh,v 1.6 2010/05/15 00:55:01 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100507  M. Kelsey -- Remove redundant total-bins template argument
+// 20100510  M. Kelsey -- Add initial "31" template arg.  Add G4CascSampler
+//              to template for channel typedef
+// 20100514  M. Kelsey -- Replace G4CascadeSampler with G4KaonHypSampler.
 #ifndef G4_CASCADE_SIGMAPLUSN_CHANNEL_HH
 #define G4_CASCADE_SIGMAPLUSN_CHANNEL_HH
 …
 #include "G4CascadeData.hh"
 #include "G4CascadeFunctions.hh"
+#include "G4KaonHypSampler.hh"
 struct G4CascadeSigmaPlusNChannelData {
   typedef G4CascadeData<3,12,33,59,30,20,157> data_t;
+  typedef G4CascadeData<31,3,12,33,59,30,20> data_t;
   static data_t data;
 };
 typedef G4CascadeFunctions<G4CascadeSigmaPlusNChannelData> G4CascadeSigmaPlusNChannel;
+typedef G4CascadeFunctions<G4CascadeSigmaPlusNChannelData,G4KaonHypSampler> G4CascadeSigmaPlusNChannel;
 #endif

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeSigmaPlusPChannel.hh,v 1.6 2010/05/15 00:55:01 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100507  M. Kelsey -- Remove redundant total-bins template argument
+// 20100510  M. Kelsey -- Add initial "31" template arg.  Add G4CascSampler
+//              to template for channel typedef
+// 20100514  M. Kelsey -- Replace G4CascadeSampler with G4KaonHypSampler.
 #ifndef G4_CASCADE_SIGMAPLUSP_CHANNEL_HH
 #define G4_CASCADE_SIGMAPLUSP_CHANNEL_HH
 …
 #include "G4CascadeData.hh"
 #include "G4CascadeFunctions.hh"
+#include "G4KaonHypSampler.hh"
 struct G4CascadeSigmaPlusPChannelData {
   typedef G4CascadeData<1,6,20,42,25,17,111> data_t;
+  typedef G4CascadeData<31,1,6,20,42,25,17> data_t;
   static data_t data;
 };
 typedef G4CascadeFunctions<G4CascadeSigmaPlusPChannelData> G4CascadeSigmaPlusPChannel;
+typedef G4CascadeFunctions<G4CascadeSigmaPlusPChannelData,G4KaonHypSampler> G4CascadeSigmaPlusPChannel;
 #endif

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeSigmaZeroNChannel.hh,v 1.6 2010/05/15 00:55:01 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100507  M. Kelsey -- Remove redundant total-bins template argument
+// 20100510  M. Kelsey -- Add initial "31" template arg.  Add G4CascSampler
+//              to template for channel typedef
+// 20100514  M. Kelsey -- Replace G4CascadeSampler with G4KaonHypSampler.
 #ifndef G4_CASCADE_SIGMAZERON_CHANNEL_HH
 #define G4_CASCADE_SIGMAZERON_CHANNEL_HH
 …
 #include "G4CascadeData.hh"
 #include "G4CascadeFunctions.hh"
+#include "G4KaonHypSampler.hh"
 struct G4CascadeSigmaZeroNChannelData {
   typedef G4CascadeData<3,12,33,59,30,20,157> data_t;
+  typedef G4CascadeData<31,3,12,33,59,30,20> data_t;
   static data_t data;
 };
 typedef G4CascadeFunctions<G4CascadeSigmaZeroNChannelData> G4CascadeSigmaZeroNChannel;
+typedef G4CascadeFunctions<G4CascadeSigmaZeroNChannelData,G4KaonHypSampler> G4CascadeSigmaZeroNChannel;
 #endif

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeSigmaZeroPChannel.hh,v 1.6 2010/05/15 00:55:01 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100507  M. Kelsey -- Remove redundant total-bins template argument
+// 20100510  M. Kelsey -- Add initial "31" template arg.  Add G4CascSampler
+//              to template for channel typedef
+// 20100514  M. Kelsey -- Replace G4CascadeSampler with G4KaonHypSampler.
 #ifndef G4_CASCADE_SIGMAZEROP_CHANNEL_HH
 #define G4_CASCADE_SIGMAZEROP_CHANNEL_HH
 …
 #include "G4CascadeData.hh"
 #include "G4CascadeFunctions.hh"
+#include "G4KaonHypSampler.hh"
 struct G4CascadeSigmaZeroPChannelData {
   typedef G4CascadeData<3,12,33,59,30,20,157> data_t;
+  typedef G4CascadeData<31,3,12,33,59,30,20> data_t;
   static data_t data;
 };
 typedef G4CascadeFunctions<G4CascadeSigmaZeroPChannelData> G4CascadeSigmaZeroPChannel;
+typedef G4CascadeFunctions<G4CascadeSigmaZeroPChannelData,G4KaonHypSampler> G4CascadeSigmaZeroPChannel;
 #endif

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeXiMinusNChannel.hh,v 1.6 2010/05/15 00:55:01 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100507  M. Kelsey -- Remove redundant total-bins template argument
+// 20100510  M. Kelsey -- Add initial "31" template arg.  Add G4CascSampler
+//              to template for channel typedef
+// 20100514  M. Kelsey -- Replace G4CascadeSampler with G4KaonHypSampler.
 #ifndef G4_CASCADE_XIMINUSN_CHANNEL_HH
 #define G4_CASCADE_XIMINUSN_CHANNEL_HH
 …
 #include "G4CascadeData.hh"
 #include "G4CascadeFunctions.hh"
+#include "G4KaonHypSampler.hh"
 struct G4CascadeXiMinusNChannelData {
   typedef G4CascadeData<3,18,53,2,2,2,80> data_t;
+  typedef G4CascadeData<31,3,18,53,2,2,2> data_t;
   static data_t data;
 };
 typedef G4CascadeFunctions<G4CascadeXiMinusNChannelData> G4CascadeXiMinusNChannel;
+typedef G4CascadeFunctions<G4CascadeXiMinusNChannelData,G4KaonHypSampler> G4CascadeXiMinusNChannel;
 #endif

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeXiMinusPChannel.hh,v 1.6 2010/05/15 00:55:01 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100507  M. Kelsey -- Remove redundant total-bins template argument
+// 20100510  M. Kelsey -- Add initial "31" template arg.  Add G4CascSampler
+//              to template for channel typedef
+// 20100514  M. Kelsey -- Replace G4CascadeSampler with G4KaonHypSampler.
 #ifndef G4_CASCADE_XIMINUSP_CHANNEL_HH
 #define G4_CASCADE_XIMINUSP_CHANNEL_HH
 …
 #include "G4CascadeData.hh"
 #include "G4CascadeFunctions.hh"
+#include "G4KaonHypSampler.hh"
 struct G4CascadeXiMinusPChannelData {
   typedef G4CascadeData<6,24,4,4,4,4,46> data_t;
+  typedef G4CascadeData<31,6,24,4,4,4,4> data_t;
   static data_t data;
 };
 typedef G4CascadeFunctions<G4CascadeXiMinusPChannelData> G4CascadeXiMinusPChannel;
+typedef G4CascadeFunctions<G4CascadeXiMinusPChannelData,G4KaonHypSampler> G4CascadeXiMinusPChannel;
 #endif

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeXiZeroNChannel.hh,v 1.6 2010/05/15 00:55:01 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100507  M. Kelsey -- Remove redundant total-bins template argument
+// 20100510  M. Kelsey -- Add initial "31" template arg.  Add G4CascSampler
+//              to template for channel typedef
+// 20100514  M. Kelsey -- Replace G4CascadeSampler with G4KaonHypSampler.
 #ifndef G4_CASCADE_XIZERON_CHANNEL_HH
 #define G4_CASCADE_XIZERON_CHANNEL_HH
 …
 #include "G4CascadeData.hh"
 #include "G4CascadeFunctions.hh"
+#include "G4KaonHypSampler.hh"
 struct G4CascadeXiZeroNChannelData {
   typedef G4CascadeData<6,24,4,4,4,4,46> data_t;
+  typedef G4CascadeData<31,6,24,4,4,4,4> data_t;
   static data_t data;
 };
 typedef G4CascadeFunctions<G4CascadeXiZeroNChannelData> G4CascadeXiZeroNChannel;
+typedef G4CascadeFunctions<G4CascadeXiZeroNChannelData,G4KaonHypSampler> G4CascadeXiZeroNChannel;
 #endif

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeXiZeroPChannel.hh,v 1.6 2010/05/15 00:55:01 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100507  M. Kelsey -- Remove redundant total-bins template argument
+// 20100510  M. Kelsey -- Add initial "31" template arg.  Add G4CascSampler
+//              to template for channel typedef
+// 20100514  M. Kelsey -- Replace G4CascadeSampler with G4KaonHypSampler.
 #ifndef G4_CASCADE_XIZEROP_CHANNEL_HH
 #define G4_CASCADE_XIZEROP_CHANNEL_HH
 …
 #include "G4CascadeData.hh"
 #include "G4CascadeFunctions.hh"
+#include "G4KaonHypSampler.hh"
 struct G4CascadeXiZeroPChannelData {
   typedef G4CascadeData<3,18,53,2,2,2,80> data_t;
+  typedef G4CascadeData<31,3,18,53,2,2,2> data_t;
   static data_t data;
 };
 typedef G4CascadeFunctions<G4CascadeXiZeroPChannelData> G4CascadeXiZeroPChannel;
+typedef G4CascadeFunctions<G4CascadeXiZeroPChannelData,G4KaonHypSampler> G4CascadeXiZeroPChannel;
 #endif

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

-              r1196
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CollisionOutput.hh,v 1.20 2010/05/21 18:07:30 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
+// 20100407  M. Kelsey -- Replace ::resize(0) with ::clear()
+// 20100409  M. Kelsey -- Move function code to .cc files, not inlinable
+// 20100418  M. Kelsey -- Add function to boost output lists to lab frame
+// 20100520  M. Kelsey -- Add function to rotate Z axis, from G4Casc.Interface
 #ifndef G4COLLISION_OUTPUT_HH
 #define G4COLLISION_OUTPUT_HH
-#include <iostream>
 #include "G4InuclElementaryParticle.hh"
 #include "G4InuclNuclei.hh"
+#include "G4LorentzRotation.hh"
 #include <algorithm>
 #include <vector>
+class G4LorentzConvertor;
 class G4CollisionOutput {
 …
   G4CollisionOutput& operator=(const G4CollisionOutput& right);
+  void reset() {
+    nucleiFragments.resize(0);
+    outgoingParticles.resize(0);
+  };
+  void reset();
   void addOutgoingParticle(const G4InuclElementaryParticle& particle) {
     outgoingParticles.push_back(particle);
   };
+  }
+  void addOutgoingParticles(const std::vector<G4InuclElementaryParticle>& particles) {
+    for(G4int i = 0; i < G4int(particles.size()); i++)
+      outgoingParticles.push_back(particles[i]);
+  };
+  void addOutgoingParticles(const std::vector<G4InuclElementaryParticle>& particles);
   void addTargetFragment(const G4InuclNuclei& nuclei) {
 …
   };
+  void addTargetFragments(const std::vector<G4InuclNuclei>& nuclea) {
+    for(G4int i = 0; i < G4int(nuclea.size()); i++)
+      nucleiFragments.push_back(nuclea[i]);
+  };
+  void addTargetFragments(const std::vector<G4InuclNuclei>& nuclea);
   const std::vector<G4InuclElementaryParticle>& getOutgoingParticles() const {
 …
   };
+  G4CascadeMomentum getTotalOutputMomentum() const {
+    G4CascadeMomentum tot_mom;
+    double eex_r = 0.0;
+    G4int i(0);
+    for(i = 0; i < G4int(outgoingParticles.size()); i++) {
+      const G4CascadeMomentum& mom = outgoingParticles[i].getMomentum();
+      for(G4int j = 0; j < 4; j++) tot_mom[j] += mom[j];
+    };
+    for(i = 0; i < G4int(nucleiFragments.size()); i++) {
+      const G4CascadeMomentum& mom = nucleiFragments[i].getMomentum();
+      for(G4int j = 0; j < 4; j++) tot_mom[j] += mom[j];
+      eex_r += 0.001 * nucleiFragments[i].getExitationEnergy();
+    };
+    tot_mom[0] += eex_r;
+    return tot_mom;
+  };
+  G4LorentzVector getTotalOutputMomentum() const;
+  void printCollisionOutput() const {
+    G4cout << " Output: " << G4endl
+           << " Outgoing Particles: " << outgoingParticles.size() << G4endl;
+    G4int i(0);
+    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();
+    };
+  };
+  void printCollisionOutput() const;
+  void boostToLabFrame(const G4LorentzConvertor& convertor);
+  void rotateEvent(const G4LorentzRotation& rotate);
   void trivialise(G4InuclParticle* bullet,
+                  G4InuclParticle* target) {
+    if(G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target)) {
+      nucleiFragments.push_back(*nuclei_target);
+    }
+    else {
+      G4InuclElementaryParticle* particle =
+        dynamic_cast<G4InuclElementaryParticle*>(target);
+      outgoingParticles.push_back(*particle);
+    };
+    if(G4InuclNuclei* nuclei_bullet = dynamic_cast<G4InuclNuclei*>(bullet)) {
+      nucleiFragments.push_back(*nuclei_bullet);
+    }
+    else {
+      G4InuclElementaryParticle* particle =
+        dynamic_cast<G4InuclElementaryParticle*>(bullet);
+      outgoingParticles.push_back(*particle);
+    };
+  };
+                  G4InuclParticle* target);
   void setOnShell(G4InuclParticle* bullet,
                   G4InuclParticle* target);
+  void setRemainingExitationEnergy() {
+    eex_rest = 0.0;
+    for(G4int i = 0; i < G4int(nucleiFragments.size()); i++)
+      eex_rest += 0.001 * nucleiFragments[i].getExitationEnergy();
+  };
+  void setRemainingExitationEnergy();
   double getRemainingExitationEnergy() const {
 …
 private:
+G4int verboseLevel;
+  G4int verboseLevel;
   std::vector<G4InuclElementaryParticle> outgoingParticles;
   std::vector<G4InuclNuclei> nucleiFragments;
   G4double eex_rest;
   std::pair<std::pair<G4int, G4int>, G4int> selectPairToTune(G4double de) const;
+  std::pair<std::pair<G4int,G4int>, G4int> selectPairToTune(G4double de) const;
   G4bool on_shell;

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

-              r1196
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4ElementaryParticleCollider.hh,v 1.31 2010/05/21 17:56:34 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
+// 20100315  M. Kelsey -- Remove "using" directive and unnecessary #includes.
+// 20100407  M. Kelsey -- Eliminate return-by-value std::vector<> by creating
+//              three data buffers for particles, momenta, and particle types.
+//              The following functions now return void and are non-const:
+//                ::generateSCMfinalState()
+//                ::generateMomModules() (also remove input vector)
+//                ::generateStrangeChannelPartTypes()
+//                ::generateSCMpionAbsorption()
+// 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide(); merge
+//              public vs. private ::collide() functions.
+// 20100511  M. Kelsey -- Remove G4PionSampler and G4NucleonSampler.  Expand
+//              particle-types selector to all modes, not just strangeness.
+// 20100517  M. Kelsey -- Inherit from common base class, make arrays static
 #ifndef G4ELEMENTARY_PARTICLE_COLLIDER_HH
 #define G4ELEMENTARY_PARTICLE_COLLIDER_HH
 #include "G4Collider.hh"
+#include "G4VCascadeCollider.hh"
 #include "G4InuclElementaryParticle.hh"
+#include "G4InuclSpecialFunctions.hh"
+#include "G4CascadSpecialFunctions.hh"
+#include "G4LorentzConvertor.hh"
+#include "G4NucleonSampler.hh"
+#include "G4PionSampler.hh"
+#include "G4LorentzVector.hh"
+#include <vector>
+using namespace G4InuclSpecialFunctions;
+using namespace G4CascadSpecialFunctions;
+class G4LorentzConvertor;
+class G4CollisionOutput;
+class G4ElementaryParticleCollider {
+class G4ElementaryParticleCollider : public G4VCascadeCollider {
 public:
   G4ElementaryParticleCollider();
+  G4CollisionOutput collide(G4InuclParticle* bullet,
+                            G4InuclParticle* target);
+  virtual ~G4ElementaryParticleCollider() {};
+  void collide(G4InuclParticle* bullet, G4InuclParticle* target,
+               G4CollisionOutput& output);
 private:
-  G4int verboseLevel;
   void initializeArrays();
   G4int generateMultiplicity(G4int is, G4double ekin) const;
+  void collide(G4InuclElementaryParticle* bullet,
+               G4InuclElementaryParticle* target,
+               G4CollisionOutput& output);
+  void generateOutgoingPartTypes(G4int is, G4int mult, G4double ekin);
+  std::vector<G4InuclElementaryParticle>
+  generateSCMfinalState(G4double ekin, G4double etot_scm, G4double pscm,
+                        G4InuclElementaryParticle* particle1,
+                        G4InuclElementaryParticle* particle2,
+                        G4LorentzConvertor* toSCM) const;
+  void generateSCMfinalState(G4double ekin, G4double etot_scm, G4double pscm,
+                             G4InuclElementaryParticle* particle1,
+                             G4InuclElementaryParticle* particle2,
+                             G4LorentzConvertor* toSCM);
+  void generateSCMpionAbsorption(G4double etot_scm,
+                                 G4InuclElementaryParticle* particle1,
+                                 G4InuclElementaryParticle* particle2);
+  void generateMomModules(G4int mult, G4int is, G4double ekin,
+                          G4double etot_cm);
+  // Samples the CM momentum for elastic and charge exchange scattering
+  //
+  G4LorentzVector
+  sampleCMmomentumFor2to2(G4int is, G4int kw, G4double ekin,
+                          G4double pscm) const;
+  std::vector<G4double>
+  generateMomModules(const std::vector<G4int>& kinds, G4int mult,
+                     G4int is, G4double ekin, G4double etot_cm) const;
+  // Samples cos(theta) in the CM for elastic and charge exchange scattering
+  //
+  G4double sampleCMcosFor2to2(G4double pscm, G4double pFrac,
+                              G4double pA, G4double pC, G4double pCos) const;
+  G4CascadeMomentum
+  particleSCMmomentumFor2to2(G4int is, G4int kw, G4double ekin,
+                             G4double pscm) const;
+  G4int getElasticCase(G4int is, G4int kw, G4double ekin) const;
+  std::vector<G4int>
+  generateStrangeChannelPartTypes(G4int is, G4int mult,
+                                  G4double ekin) const;
+  G4double
+  getMomModuleFor2toMany(G4int is, G4int mult, G4int knd,
+                         G4double ekin) const;
+  G4double getMomModuleFor2toMany(G4int is, G4int mult, G4int knd,
+                                  G4double ekin) const;
   G4bool satisfyTriangle(const std::vector<G4double>& modules) const;
   G4CascadeMomentum
+  G4LorentzVector
   particleSCMmomentumFor2to3(G4int is, G4int knd, G4double ekin,
                              G4double pmod) const;
+  std::pair<G4double, G4double>
+  adjustIntervalForElastic(G4double ekin, G4double ak, G4double ae,
+                           G4int k, G4int l, const std::vector<G4double>& ssv,
+                           G4double st) const;
+  std::vector<G4InuclElementaryParticle>
+  generateSCMpionAbsorption(G4double etot_scm,
+                            G4InuclElementaryParticle* particle1,
+                            G4InuclElementaryParticle* particle2) const;
+  G4NucleonSampler nucSampler;
+  G4PionSampler piSampler;
+  // Internal buffers for lists of secondaries
+  std::vector<G4InuclElementaryParticle> particles;
+  std::vector<G4double> modules;
+  std::vector<G4int> particle_kinds;
   // Parameter arrays
+  G4double rmn[14][10][2];
+  G4double ang[4][4][13];
+  G4double abn[4][4][4];
+  static const G4double rmn[14][10][2];
+  static const G4double abn[4][4][4];
 };
 #endif // G4ELEMENTARY_PARTICLE_COLLIDER_HH
+#endif  /* G4ELEMENTARY_PARTICLE_COLLIDER_HH */

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4EquilibriumEvaporator.hh,v 1.11 2010/05/21 17:56:34 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
+// 20100517  M. Kelsey -- Inherit from common base class, make other colliders
+//              simple data members.  Rename timeToBigBang() to override
+//              base explosion().
 #ifndef G4EQUILIBRIUM_EVAPORATOR_HH
 #define G4EQUILIBRIUM_EVAPORATOR_HH
+#include "G4Collider.hh"
+#include "G4Fissioner.hh"
+#include "G4BigBanger.hh"
+#include "G4InuclSpecialFunctions.hh"
+#include "G4VCascadeCollider.hh"
+using namespace G4InuclSpecialFunctions;
+class G4CollisionOutput;
+class G4Fissioner;
+class G4BigBanger;
+class G4InuclParticle;
+class G4EquilibriumEvaporator {
+class G4EquilibriumEvaporator : public G4VCascadeCollider {
+public:
+  G4EquilibriumEvaporator();
+  virtual ~G4EquilibriumEvaporator();
+public:
+  G4EquilibriumEvaporator();
+  void setFissioner(G4Fissioner* fissioner) {
+    theFissioner = fissioner;
+  };
+  void setBigBanger(G4BigBanger* banger) {
+    theBigBanger = banger;
+  };
+  G4CollisionOutput collide(G4InuclParticle* bullet,
+                            G4InuclParticle* target);
+  void collide(G4InuclParticle* bullet, G4InuclParticle* target,
+               G4CollisionOutput& output);
 private:
+G4int verboseLevel;
+  // Replace base class verision
+  virtual G4bool explosion(G4InuclNuclei*) const { return false; }
+  virtual G4bool explosion(G4double a,
+                           G4double z,
+                           G4double e) const;
+  G4bool goodRemnant(G4double a,
+                     G4double z) const;
   G4double getE0(G4double A) const;
   G4double getPARLEVDEN(G4double A,
                         G4double Z) const;
-  G4bool timeToBigBang(G4double a,
-                       G4double z,
-                       G4double e) const;
-  G4bool goodRemnant(G4double a,
-                     G4double z) const;
   G4double getQF(G4double x,
 …
   G4Fissioner* theFissioner;
   G4BigBanger* theBigBanger;
 };
 #endif // G4EQUILIBRIUM_EVAPORATOR_HH
+#endif /* G4EQUILIBRIUM_EVAPORATOR_HH */

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

-              r962
+              r1315
 // ********************************************************************
 //
+// $Id: G4EvaporationInuclCollider.hh,v 1.2 2008/06/29 23:56:03 dennis Exp $
+// $Id: G4EvaporationInuclCollider.hh,v 1.5 2010/05/21 17:56:34 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
+//
+// 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, make other colliders
+//              simple data members
 #ifndef G4EVAPORATIONINUCL_COLLIDER_HH
 #define G4EVAPORATIONINUCL_COLLIDER_HH
 #include "G4Collider.hh"
+#include "G4VCascadeCollider.hh"
+#include "G4EquilibriumEvaporator.hh"
+#include "G4Fissioner.hh"
+#include "G4BigBanger.hh"
+class G4InuclParticle;
+class G4CollisionOutput;
+class G4EquilibriumEvaporator;
+class G4BigBanger;
+#include "G4ElementaryParticleCollider.hh"
+#include "G4InteractionCase.hh"
+#include "G4InuclNuclei.hh"
+#include "G4InuclSpecialFunctions.hh"
+#include "G4Analyser.hh"
+using namespace G4InuclSpecialFunctions;
+class G4EvaporationInuclCollider {
+class G4EvaporationInuclCollider : public G4VCascadeCollider {
 public:
   G4EvaporationInuclCollider();
+  G4EvaporationInuclCollider(G4EquilibriumEvaporator* eqevaporator, G4Fissioner* fissioner, G4BigBanger* bigbanger) {
+    setEquilibriumEvaporator(eqevaporator, fissioner, bigbanger);
+  };
+  void setEquilibriumEvaporator(G4EquilibriumEvaporator* eqevaporator, G4Fissioner* fissioner, G4BigBanger* bigbanger) {
+    theEquilibriumEvaporator = eqevaporator;
+    theEquilibriumEvaporator->setFissioner(fissioner);
+    theEquilibriumEvaporator->setBigBanger(bigbanger);
+  };
+  void setBigBanger(G4BigBanger* bigbanger) {
+    theBigBanger = bigbanger;
+  };
+  G4CollisionOutput collide(G4InuclParticle* bullet, G4InuclParticle* target);
+  void collide(G4InuclParticle* bullet, G4InuclParticle* target,
+               G4CollisionOutput& output);
 private:
-  G4int verboseLevel;
-  G4bool inelasticInteractionPossible(G4InuclParticle* bullet,
-                                      G4InuclParticle* target,
-                                      G4double ekin) const;
-  G4InteractionCase bulletTargetSetter(G4InuclParticle* bullet,
-                                       G4InuclParticle* target) const;
-  G4bool explosion(G4InuclNuclei* target) const;
   G4EquilibriumEvaporator* theEquilibriumEvaporator;
-  G4BigBanger* theBigBanger;
 };
 #endif // G4EVAPORATIONINUCL_COLLIDER_HH
+#endif /* G4EVAPORATIONINUCL_COLLIDER_HH */

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4Fissioner.hh,v 1.12 2010/05/21 17:56:34 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 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
 #ifndef G4FISSIONER_HH
 #define G4FISSIONER_HH
 #include "G4Collider.hh"
 #include "G4InuclSpecialFunctions.hh"
+#include "G4VCascadeCollider.hh"
+#include <vector>
+using namespace G4InuclSpecialFunctions;
+class G4CollisionOutput;
+class G4InuclParticle;
-class G4Fissioner {
+class G4Fissioner : public G4VCascadeCollider {
 public:
+  G4Fissioner();
+  virtual ~G4Fissioner() {}
+  G4Fissioner();
+  G4CollisionOutput collide(G4InuclParticle* bullet,
+                            G4InuclParticle* target);
+  void collide(G4InuclParticle* bullet, G4InuclParticle* target,
+               G4CollisionOutput& output);
 private:
-G4int verboseLevel;
   G4double getC2(G4double A1,
                  G4double A2,
 …
                              std::vector<G4double>& BET1,
                              G4double& R12) const;
 };
 #endif // G4FISSIONER_HH
+#endif /* G4FISSIONER_HH */

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

-              r819
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4InteractionCase.hh,v 1.11 2010/05/21 17:56:34 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100518  M. Kelsey -- Why use std::pair<> at all?  Never exported; just
+//              store pointers.  Add clear() function.  Move code from
+//              Colliders' "bulletTargetSetter()" to set().
 #ifndef G4INTERACTION_CASE_HH
 #define G4INTERACTION_CASE_HH
+//#ifndef G4INUCL_PARTICLE_HH
+#include "G4InuclParticle.hh"
+//#endif
+#include "globals.hh"
+#include <algorithm>
+class G4InuclParticle;
 class G4InteractionCase {
+public:
+  G4InteractionCase() : bullet(0), target(0), inter_case(0) {}
+public:
+  G4InteractionCase(G4InuclParticle* part1, G4InuclParticle* part2) {
+    set(part1, part2);
+  }
+  G4InteractionCase() {
+    bultag = std::pair<G4InuclParticle*, G4InuclParticle*>(0, 0);
+  void set(G4InuclParticle* part1, G4InuclParticle* part2);
+  void clear() {
+    bullet = target = 0;
     inter_case = 0;
   };
+  }
+  G4InteractionCase(G4InuclParticle* part1,
+                    G4InuclParticle* part2,
+                    G4int ic) {
+    setBulletTarget(part1, part2);
+    setInterCase(ic);
+  };
+  G4InuclParticle* getBullet() const { return bullet; }
+  G4InuclParticle* getTarget() const { return target; }
+  void setBulletTarget(G4InuclParticle* part1,
+                       G4InuclParticle* part2) {
+    bultag = std::pair<G4InuclParticle*, G4InuclParticle*>(part1, part2);
+  };
+  G4bool valid() const      { return inter_case != 0; }
   void setInterCase(G4int ic) {
     inter_case = ic;
   };
+  G4bool twoNuclei() const  { return inter_case == -2; }
+  G4bool hadNucleus() const { return inter_case == -1; }
+  G4int  hadrons() const    { return inter_case; }      // "rtype" or "is" code
+  G4InuclParticle* getBullet() const {
+    return bultag.first;
+  };
+  G4InuclParticle* getTarget() const {
+    return bultag.second;
+  };
+  G4int getInterCase() const {
+    return inter_case;
+  };
+  // For compatibility with G4IntraNucleiCascader code
+  G4int  code() const { return ((inter_case<0) ? -inter_case : 0); }
 private:
   std::pair<G4InuclParticle*, G4InuclParticle*> bultag;
+  G4InuclParticle* bullet;
+  G4InuclParticle* target;
   G4int inter_case;
 };

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4IntraNucleiCascader.hh,v 1.10 2010/05/21 17:56:34 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100315  M. Kelsey -- Remove "using" directory and unnecessary #includes.
+// 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
+// 20100517  M. Kelsey -- Inherit from common base class, make other colliders
+//              simple data members
 #ifndef G4INTRA_NUCLEI_CASCADER_HH
 #define G4INTRA_NUCLEI_CASCADER_HH
+#include "G4Collider.hh"
+#include "G4ElementaryParticleCollider.hh"
+#include "G4InuclSpecialFunctions.hh"
+#include "G4CascadSpecialFunctions.hh"
+#include "G4InuclElementaryParticle.hh"
+#include "G4VCascadeCollider.hh"
+using namespace G4InuclSpecialFunctions;
+using namespace G4CascadSpecialFunctions;
+class G4CollisionOutput;
+class G4ElementaryParticleCollider;
+class G4InuclParticle;
-class G4IntraNucleiCascader {
+class G4IntraNucleiCascader : public G4VCascadeCollider {
 public:
+  G4IntraNucleiCascader();
+  virtual ~G4IntraNucleiCascader();
+  G4IntraNucleiCascader();
+  void collide(G4InuclParticle* bullet, G4InuclParticle* target,
+               G4CollisionOutput& output);
+  void setElementaryParticleCollider(G4ElementaryParticleCollider* ecollider) {
+    theElementaryParticleCollider = ecollider;
+  };
+  G4CollisionOutput collide(G4InuclParticle* bullet,
+                            G4InuclParticle* target);
+  // FIXME:  This should come from (or be determined by) G4InteractionCase
   void setInteractionCase(G4int intcase) {
     inter_case = intcase;
 …
 private:
-G4int verboseLevel;
   G4ElementaryParticleCollider* theElementaryParticleCollider;
+  // FIXME:  This should come from (or be determined by) G4InteractionCase
   G4int inter_case;
   G4bool goodCase(G4double a, G4double z, G4double eexs, G4double ein) const;
 };
 #endif // G4INTRA_NUCLEI_CASCADER_HH
+#endif /* G4INTRA_NUCLEI_CASCADER_HH */

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4InuclCollider.hh,v 1.13 2010/05/21 17:56:34 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
+// 20100517  M. Kelsey -- Inherit from common base class, make other colliders
+//              simple data members
 #ifndef G4INUCL_COLLIDER_HH
 #define G4INUCL_COLLIDER_HH
-#include "G4Collider.hh"
-#include "G4IntraNucleiCascader.hh"
-#include "G4NonEquilibriumEvaporator.hh"
-#include "G4EquilibriumEvaporator.hh"
-#include "G4Fissioner.hh"
-#include "G4BigBanger.hh"
-#include "G4ElementaryParticleCollider.hh"
-#include "G4InteractionCase.hh"
-#include "G4InuclNuclei.hh"
-#include "G4InuclSpecialFunctions.hh"
-#include "G4Analyser.hh"
+using namespace G4InuclSpecialFunctions;
+#include "G4VCascadeCollider.hh"
+class G4InuclCollider {
+class G4BigBanger;
+class G4CollisionOutput;
+class G4ElementaryParticleCollider;
+class G4EquilibriumEvaporator;
+class G4IntraNucleiCascader;
+class G4InuclParticle;
+class G4NonEquilibriumEvaporator;
+class G4InuclCollider : public G4VCascadeCollider {
 public:
   G4InuclCollider();
+  virtual ~G4InuclCollider();
+  G4InuclCollider(G4ElementaryParticleCollider* ecollider,
+                  G4IntraNucleiCascader* incascader,
+                  G4NonEquilibriumEvaporator* noeqevaporator,
+                  G4EquilibriumEvaporator* eqevaporator,
+                  G4Fissioner* fissioner,
+                  G4BigBanger* bigbanger) {
+    setElementaryParticleCollider(ecollider);
+    setIntraNucleiCascader(incascader,ecollider);
+    setNonEquilibriumEvaporator(noeqevaporator);
+    setEquilibriumEvaporator(eqevaporator, fissioner, bigbanger);
+    setBigBanger(bigbanger);
+  };
+  void setElementaryParticleCollider(G4ElementaryParticleCollider* ecollider) {
+    theElementaryParticleCollider = ecollider;
+  };
+  void setIntraNucleiCascader(G4IntraNucleiCascader* incascader,
+                              G4ElementaryParticleCollider* ecollider) {
+    theIntraNucleiCascader = incascader;
+    theIntraNucleiCascader->setElementaryParticleCollider(ecollider);
+  };
+  void setNonEquilibriumEvaporator(G4NonEquilibriumEvaporator* noeqevaporator) {
+    theNonEquilibriumEvaporator = noeqevaporator;
+  };
+  void setEquilibriumEvaporator(G4EquilibriumEvaporator* eqevaporator,
+                                G4Fissioner* fissioner,
+                                G4BigBanger* bigbanger) {
+    theEquilibriumEvaporator = eqevaporator;
+    theEquilibriumEvaporator->setFissioner(fissioner);
+    theEquilibriumEvaporator->setBigBanger(bigbanger);
+  };
+  void setBigBanger(G4BigBanger* bigbanger) {
+    theBigBanger = bigbanger;
+  };
+  G4CollisionOutput collide(G4InuclParticle* bullet,
+                            G4InuclParticle* target);
+  void collide(G4InuclParticle* bullet, G4InuclParticle* target,
+               G4CollisionOutput& output);
 private:
-  G4int verboseLevel;
-  G4bool inelasticInteractionPossible(G4InuclParticle* bullet,
-                                      G4InuclParticle* target,
-                                      G4double ekin) const;
-  G4InteractionCase bulletTargetSetter(G4InuclParticle* bullet,
-                                       G4InuclParticle* target) const;
-  G4bool explosion(G4InuclNuclei* target) const;
   G4ElementaryParticleCollider* theElementaryParticleCollider;
   G4IntraNucleiCascader* theIntraNucleiCascader;
 …
   G4EquilibriumEvaporator* theEquilibriumEvaporator;
   G4BigBanger* theBigBanger;
 };
 #endif // G4INUCL_COLLIDER_HH
+#endif /* G4INUCL_COLLIDER_HH */

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

-              r1196
+              r1315
+#ifndef G4INUCL_ELEMENTARY_PARTICLE_HH
+#define G4INUCL_ELEMENTARY_PARTICLE_HH
 //
 // ********************************************************************
 …
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4InuclElementaryParticle.hh,v 1.22 2010/04/29 19:39:55 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+#ifndef G4INUCL_ELEMENTARY_PARTICLE_HH
+#define G4INUCL_ELEMENTARY_PARTICLE_HH
+// 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
+#include "G4InuclParticle.hh"
+#include "G4InuclParticleNames.hh"
 #include "globals.hh"
+#ifndef G4INUCL_PARTICLE_HH
+#include "G4InuclParticle.hh"
+#endif
+class G4ParticleDefinition;
 class G4InuclElementaryParticle : public G4InuclParticle {
+public:
+  G4InuclElementaryParticle()
+    : G4InuclParticle(), generation(0) {}
+//                     known particle types:
+//      1 - proton          11 - k+         111 - quasideuteron PP
+//      2 - neutron         13 - k-         112 - quasideuteron PN
+//      3 - pi+             15 - k0         122 - quasideuteron NN
+//      5 - pi-             17 - k0bar
+//      7 - pi 0            21 - lambda
+//     10 - photon          23 - sigma+
+//                          25 - sigma0
+//                          27 - sigma-
+//                          29 - xi0
+//                          31 - xi-
+public:
+  explicit G4InuclElementaryParticle(G4int type)
+    : G4InuclParticle(makeDefinition(type)), generation(0) {}
+  G4InuclElementaryParticle() {
+    particleType = 0;     // DHW: added to keep 4.3 compiler happy
+    particleMass = 0.;    //            "              "
+    valid_particle = false;
+    generation = 0;
+  };
+  G4InuclElementaryParticle(const G4LorentzVector& mom,
+                            G4int type, G4int model=0)
+    : G4InuclParticle(makeDefinition(type), mom), generation(0) {
+    setModel(model);
+  }
   G4InuclElementaryParticle(G4int type)
     : particleType(type) {
+  G4InuclElementaryParticle(G4double ekin, G4int type)
+    : G4InuclParticle(makeDefinition(type), ekin), generation(0) {}
     particleMass = getParticleMass(type);
     valid_particle = false;
   };
+  // Copy and assignment constructors for use with std::vector<>
+  G4InuclElementaryParticle(const G4InuclElementaryParticle& right)
+    : G4InuclParticle(right), generation(right.generation) {}
+  G4InuclElementaryParticle(const G4CascadeMomentum& mom,
+                            G4int type)
+    : G4InuclParticle(mom),
+      particleType(type) {
+  G4InuclElementaryParticle& operator=(const G4InuclElementaryParticle& right);
+    particleMass = getParticleMass(type);
+    momentum[0] = std::sqrt(momentum[1] * momentum[1] + momentum[2] * momentum[2] +
+                       momentum[3] * momentum[3] + particleMass * particleMass);
+    valid_particle = true;
+  };
+  void setType(G4int ityp);
+  G4int type() const { return type(getDefinition()); }
+  G4InuclElementaryParticle(const G4CascadeMomentum& mom,
+                            G4int type, G4int model)
+    : G4InuclParticle(mom),
+      particleType(type) {
+  static G4int type(const G4ParticleDefinition* pd);
     G4InuclParticle::setModel(model);
+  G4bool isPhoton() const { return (type() == G4InuclParticleNames::photon); }
+    particleMass = getParticleMass(type);
+    momentum[0] = std::sqrt(momentum[1] * momentum[1] + momentum[2] * momentum[2] +
+                       momentum[3] * momentum[3] + particleMass * particleMass);
+    valid_particle = true;
+  };
+  G4bool pion() const { return (type()==G4InuclParticleNames::pionPlus ||
+                                type()==G4InuclParticleNames::pionMinus ||
+                                type()==G4InuclParticleNames::pionZero); }
+  G4InuclElementaryParticle(G4double ekin,
+                            G4int type)
+    : particleType(type) {
+  G4bool nucleon() const { return (type()==G4InuclParticleNames::proton ||
+                                   type()==G4InuclParticleNames::neutron); }
+    particleMass = getParticleMass(type);
+    momentum[0] = ekin + particleMass;
+    momentum[3] = std::sqrt(momentum[0] * momentum[0] - particleMass * particleMass);
+    momentum[1] = momentum[2] = 0.0;
+    valid_particle = true;
+  };
+  G4int baryon() const {                // Can use as a bool (!=0 ==> true)
+    return getDefinition()->GetBaryonNumber();
+  }
   void setType(G4int ityp) {
+  G4bool quasi_deutron() const { return (type() > 100); }
+    particleType = ityp;
+    particleMass = getParticleMass(ityp);
+  };
+  void setMomentum(const G4CascadeMomentum& mom) {
+    momentum = mom;
+    momentum[0] = std::sqrt(momentum[1] * momentum[1] + momentum[2] * momentum[2] +
+                       momentum[3] * momentum[3] + particleMass * particleMass);
+    valid_particle = true;
+  };
+  G4int type() const {
+    return particleType;
+  };
+  G4bool photon() const {
+    return particleType == 10;
+  };
+  G4bool nucleon() const {
+    return particleType <= 2;
+  };
+  G4bool baryon() const {
+    return (particleType == 1  ||
+            particleType == 2  ||
+            particleType == 21 ||
+            particleType == 23 ||
+            particleType == 25 ||
+            particleType == 27 ||
+            particleType == 29 ||
+            particleType == 31 );
+  };
+  G4bool pion() const {
+    return particleType == 3 || particleType == 5 || particleType == 7;
+  };
+  G4bool quasi_deutron() const {
+    return particleType > 100;
+  };
+  G4double getMass() const {
+    return particleMass;
+  };
+  G4double getParticleMass() const {
+    G4double mass;
+    switch(particleType) {
+    case 1: // proton
+      mass = 0.93827;
+      break;
+    case 2: // neutron
+      mass = 0.93957;
+      break;
+    case 3: // pi+
+      mass = 0.13957;
+      break;
+    case 5: // pi-
+      mass = 0.13957;
+      break;
+    case 7: // pi0
+      mass = 0.13498;
+      break;
+    case 10: // photon
+      mass = 0.0;
+      break;
+    case 11: // k+
+      mass = 0.49368;
+      break;
+    case 13: // k-
+      mass = 0.49368;
+      break;
+    case 15: // k0
+      mass = 0.49767;
+      break;
+    case 17: // k0bar
+      mass = 0.49767;
+      break;
+    case 21: // lambda
+      mass = 1.1157;
+      break;
+    case 23: // sigma+
+      mass = 1.1894;
+      break;
+    case 25: // sigma0
+      mass = 1.1926;
+      break;
+    case 27: // sigma-
+      mass = 1.1974;
+      break;
+    case 29: // xi0
+      mass = 1.3148;
+      break;
+    case 31: // xi-
+      mass = 1.3213;
+      break;
+    case 111: // PP
+      mass = 0.93827 + 0.93827;
+      break;
+    case 112: // PN
+      mass = 0.93827 + 0.93957;
+      break;
+    case 122: // NN
+      mass = 0.93957 + 0.93957;
+      break;
+    default:
+      G4cout << " uups, unknown particle type " << particleType << G4endl;
+      mass = 0.;
+    };
+    return mass;
+  };
+  G4double getCharge() const {
+    G4double charge;
+    switch(particleType) {
+    case 1: // proton
+      charge = 1.0;
+      break;
+    case 2: // neutron
+      charge = 0.0;
+      break;
+    case 3: // pi+
+      charge = 1.0;
+      break;
+    case 5: // pi-
+      charge = -1.0;
+      break;
+    case 7: // pi0
+      charge = 0.0;
+      break;
+    case 10: // photon
+      charge = 0.0;
+      break;
+    case 11: // k+
+      charge = 1.0;
+      break;
+    case 13: // k-
+      charge = -1.0;
+      break;
+    case 15: // k0
+      charge = 0.0;
+      break;
+    case 17: // k0bar
+      charge = 0.0;
+      break;
+    case 21: // lambda
+      charge = 0.0;
+      break;
+    case 23: // sigma+
+      charge = 1.0;
+      break;
+    case 25: // sigma0
+      charge = 0.0;
+      break;
+    case 27: // sigma-
+      charge = -1.0;
+      break;
+    case 29: // xi0
+      charge = 0.0;
+      break;
+    case 31: // xi-
+      charge = -1.0;
+      break;
+    case 111: // PP
+      charge = 2.0;
+      break;
+    case 112: // PN
+      charge = 1.0;
+      break;
+    case 122: // NN
+      charge = 0.0;
+      break;
+    default:
+      G4cout << " uups, unknown particle type " << particleType << G4endl;
+      charge = 0.0;
+    };
+    return charge;
+  };
+  G4double getStrangeness(G4int type) const {
+    G4double strangeness;
+    switch(type) {
+    case 1: // proton
+      strangeness = 0.0;
+      break;
+    case 2: // neutron
+      strangeness = 0.0;
+      break;
+    case 3: // pi+
+      strangeness = 0.0;
+      break;
+    case 5: // pi-
+      strangeness = 0.0;
+      break;
+    case 7: // pi0
+      strangeness = 0.0;
+      break;
+    case 10: // photon
+      strangeness = 0.0;
+      break;
+    case 11: // k+
+      strangeness = 1.0;
+      break;
+    case 13: // k-
+      strangeness = -1.0;
+      break;
+    case 15: // k0
+      strangeness = 1.0;
+      break;
+    case 17: // k0bar
+      strangeness = -1.0;
+      break;
+    case 21: // lambda
+      strangeness = -1.0;
+      break;
+    case 23: // sigma+
+      strangeness = -1.0;
+      break;
+    case 25: // sigma0
+      strangeness = -1.0;
+      break;
+    case 27: // sigma-
+      strangeness = -1.0;
+      break;
+    case 29: // xi0
+      strangeness = -2.0;
+      break;
+    case 31: // xi-
+      strangeness = -2.0;
+      break;
+    case 111: // PP
+      strangeness = 0.0;
+      break;
+    case 112: // PN
+      strangeness = 0.0;
+      break;
+    case 122: // NN
+      strangeness = 0.0;
+      break;
+    default:
+      G4cout << " unknown particle type " << type << G4endl;
+      strangeness = 0.0;
+    };
+    return strangeness;
+  };
+  G4double getParticleMass(G4int type) const {
+    G4double mass;
+    switch(type) {
+    case 1: // proton
+      mass = 0.93827;
+      break;
+    case 2: // neutron
+      mass = 0.93957;
+      break;
+    case 3: // pi+
+      mass = 0.13957;
+      break;
+    case 5: // pi-
+      mass = 0.13957;
+      break;
+    case 7: // pi0
+      mass = 0.13498;
+      break;
+    case 10: // photon
+      mass = 0.0;
+      break;
+    case 11: // k+
+      mass = 0.49368;
+      break;
+    case 13: // k-
+      mass = 0.49368;
+      break;
+    case 15: // k0
+      mass = 0.49767;
+      break;
+    case 17: // k0bar
+      mass = 0.49767;
+      break;
+    case 21: // lambda
+      mass = 1.1157;
+      break;
+    case 23: // sigma+
+      mass = 1.1894;
+      break;
+    case 25: // sigma0
+      mass = 1.1926;
+      break;
+    case 27: // sigma-
+      mass = 1.1974;
+      break;
+    case 29: // xi0
+      mass = 1.3148;
+      break;
+    case 31: // xi-
+      mass = 1.3213;
+      break;
+    case 111: // PP
+      mass = 0.93827 + 0.93827;
+      break;
+    case 112: // PN
+      mass = 0.93827 + 0.93957;
+      break;
+    case 122: // NN
+      mass = 0.93957 + 0.93957;
+      break;
+    default:
+      G4cout << " uups, unknown particle type " << type << G4endl;
+      mass = 0.0;
+    };
+    return mass;
+  };
+  G4double getKineticEnergy() const {
+    return momentum[0] - particleMass;
+  };
+  G4double getEnergy() const {
+    return momentum[0];
+  };
+  G4bool valid() const {
+    return valid_particle;
+  };
+  G4bool valid() const { return type()>0; }
   virtual void printParticle() const {
     G4InuclParticle::printParticle();
+    G4cout << " Particle: type " << particleType << " mass " << particleMass <<
+      " ekin " << getKineticEnergy() << G4endl;
+  };
+  void setGeneration(G4int gen) {
+    generation = gen;
+    G4cout << " Particle: type " << type() << " mass " << getMass()
+           << " ekin " << getKineticEnergy() << G4endl;
+  }
+  G4int getGeneration() {
+    return generation;
+  }
+  void setGeneration(G4int gen) { generation = gen; }
+  G4int getGeneration() const { return generation; }
+  static G4double getStrangeness(G4int type);
+  static G4double getParticleMass(G4int type);
+protected:
+  // Convert internal type code to standard GEANT4 pointer
+  static G4ParticleDefinition* makeDefinition(G4int ityp);
 private:
-  G4int particleType;
-  G4double particleMass;
-  G4bool valid_particle;
   G4int generation;
 };

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

-              r819
+              r1315
 // ********************************************************************
 //
 // $Id: G4InuclEvaporation.hh,v 1.5 2007/05/24 23:27:01 miheikki Exp $
+// $Id: G4InuclEvaporation.hh,v 1.8 2010/05/21 18:07:30 mkelsey Exp $
 // Defines an interface to evaporation models of Bertini cascase (BERT)
 // based on INUCL code.
 //
+// 20100405  M. Kelsey -- Pass const-ref std::vector<>
+// 20100517  M. Kelsey -- MakeG4EvaporationInuclCollider a data member.
+// 20100520  M. Kelsey -- Clean up interface
 #ifndef G4INUCLEVAPORATION_h
 #define G4INUCLEVAPORATION_h 1
 …
 #include "G4Fragment.hh"
+//#define DEBUG
+class G4EvaporationInuclCollider;
 class G4InuclEvaporation : public G4VEvaporation {
 …
   G4bool operator!=(const G4InuclEvaporation &right) const;
-  void fillResult( std::vector< G4DynamicParticle * > secondaryParticleVector,
-                   G4FragmentVector * aResult );
 public:
   G4FragmentVector * BreakItUp(const G4Fragment &theNucleus);
   void setVerboseLevel( const G4int verbose );
 private:
   G4int verboseLevel;
+#ifdef DEBUG
+#endif
+  G4EvaporationInuclCollider* evaporator;
 };

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

-              r962
+              r1315
+#ifndef G4INUCL_NUCLEI_HH
+#define G4INUCL_NUCLEI_HH
 //
 // ********************************************************************
 …
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4InuclNuclei.hh,v 1.16 2010/04/09 19:33:11 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+#ifndef G4INUCL_NUCLEI_HH
+#define G4INUCL_NUCLEI_HH
+// 20100112  Michael Kelsey -- Replace G4CascadeMomentum with G4LorentzVector
+// 20100301  M. Kelsey -- Add function to create unphysical nuclei for use
+//           as temporary final-state fragments.
+// 20100319  M. Kelsey -- Remove "using" directory and unnecessary #includes.
+// 20100409  M. Kelsey -- Drop unused string argument from ctors.
-#ifndef G4INUCL_PARTICLE_HH
 #include "G4InuclParticle.hh"
-#endif
 #include "G4ExitonConfiguration.hh"
-#include "G4InuclSpecialFunctions.hh"
 using namespace G4InuclSpecialFunctions;
+class G4ParticleDefinition;
 class G4InuclNuclei : public G4InuclParticle {
+public:
+  G4InuclNuclei() : G4InuclParticle() {}
+public:
+  G4InuclNuclei(G4double a, G4double z)
+    : G4InuclParticle(makeDefinition(a,z)),
+      exitationEnergy(0.0) {}
+  G4InuclNuclei() {};
+  G4InuclNuclei(const G4LorentzVector& mom, G4double a, G4double z)
+    : G4InuclParticle(makeDefinition(a,z), mom),
+      exitationEnergy(0.0) {}
+  G4InuclNuclei(G4double a,
+                G4double z)
+    : A(a),
+      Z(z) {
+  G4InuclNuclei(G4double ekin, G4double a, G4double z)
+    : G4InuclParticle(makeDefinition(a,z), ekin),
+      exitationEnergy(0.0) {}
+    setNucleiMass();
+    exitationEnergy = 0.0;
+  };
+  virtual ~G4InuclNuclei() {}
+  G4InuclNuclei(const G4CascadeMomentum& mom,
+                G4double a,
+                G4double z)
+    : G4InuclParticle(mom),
+      A(a),
+      Z(z) {
+  // Copy and assignment constructors for use with std::vector<>
+  G4InuclNuclei(const G4InuclNuclei& right)
+    : G4InuclParticle(right), exitationEnergy(right.exitationEnergy),
+      theExitonConfiguration(right.theExitonConfiguration) {}
+    setNucleiMass();
+    exitationEnergy = 0.0;
+  };
+  G4InuclNuclei& operator=(const G4InuclNuclei& right);
+  G4InuclNuclei(G4double ekin,
+                G4double a,
+                G4double z)
+    : A(a),
+    Z(z) {
+    setNucleiMass();
+    G4CascadeMomentum mom;
+    mom[0] = ekin + nucleiMass;
+    mom[3] = std::sqrt(mom[0] * mom[0] - nucleiMass * nucleiMass);
+    G4InuclParticle::setMomentum(mom);
+    exitationEnergy = 0.0;
+  };
+  void setA(G4double a) {
+    A = a;
+  };
+  void setZ(G4double z) {
+    Z = z;
+  };
+  void setExitationEnergy(G4double e) {
+    exitationEnergy = e;
+  };
+  void setEnergy() {
+    momentum[0] = std::sqrt(momentum[1] * momentum[1] + momentum[2] * momentum[2] +
+                       momentum[3] * momentum[3] + nucleiMass * nucleiMass);
+  };
+  void setNucleiMass() {
+    nucleiMass = 0.93827 * Z + 0.93957 * (A - Z) - 0.001 * bindingEnergy(A, Z);
+  };
+  void setExitationEnergy(G4double e) { exitationEnergy = e; }
   void setExitonConfiguration(const G4ExitonConfiguration& config) {
+    theExitonConfiguration = config;
+  }
+    theExitonConfiguration = config;
+  };
+  G4double getA() const { return getDefinition()->GetAtomicMass(); }
   G4double getA() const {
+  G4double getZ() const { return getDefinition()->GetAtomicNumber(); }
+    return A;
+  };
+  G4double getZ() const {
+    return Z;
+  };
+  G4double getExitationEnergy() const {
+    return exitationEnergy;
+  };
+  G4double getExitationEnergy() const { return exitationEnergy; }
   G4double getExitationEnergyInGeV() const {
+    return 0.001 * exitationEnergy;
+  }
+    return 0.001 * exitationEnergy;
+  };
+  const G4ExitonConfiguration& getExitonConfiguration() const {
+    return theExitonConfiguration;
+  }
+  G4ExitonConfiguration getExitonConfiguration() const {
+    return theExitonConfiguration;
+  };
+  G4double getMass() const {
+    return nucleiMass;
+  };
+  G4double getKineticEnergy() const {
+    return momentum[0] - nucleiMass;
+  };
+  G4double getNucleiMass(G4double a,
+                         G4double z) const {
+    return 0.93827 * z + 0.93957 * (a - z) - 0.001 * bindingEnergy(a, z);
+  };
+  static G4double getNucleiMass(G4double a, G4double z);
   virtual void printParticle() const {
+    G4cout << " A " << getA() << " Z " << getZ() << " mass "
+           << getMass() << " Eex (MeV) " << exitationEnergy << G4endl;
+    G4InuclParticle::printParticle();
+  }
+    G4cout << " A " << A << " Z " << Z << " mass " << nucleiMass <<
+      " Eex (MeV) " << exitationEnergy << G4endl;
+protected:
+  // Convert nuclear configuration to standard GEANT4 pointer
+  static G4ParticleDefinition*
+  makeDefinition(G4double a, G4double z, G4double exc=0.);
+    G4cout << " Px " << momentum[1] << " Py " << momentum[2] << " Pz " <<
+        momentum[3] <<  " E " << momentum[0] << G4endl;
+  };
+  static G4ParticleDefinition*
+  makeNuclearFragment(G4double a, G4double z, G4double exc=0.);
 private:
-  G4double A;
-  G4double Z;
   G4double exitationEnergy;
-  G4double nucleiMass;
   G4ExitonConfiguration theExitonConfiguration;
 };

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

-              r962
+              r1315
+#ifndef G4INUCL_PARTICLE_HH
+#define G4INUCL_PARTICLE_HH
 //
 // ********************************************************************
 …
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4InuclParticle.hh,v 1.19 2010/05/21 18:07:30 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+#ifndef G4INUCL_PARTICLE_HH
+#define G4INUCL_PARTICLE_HH
+// 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
+#ifndef GLOB
+#include "G4DynamicParticle.hh"
+#include "G4LorentzVector.hh"
 #include "globals.hh"
-#endif
-#include <iostream>
-#include <vector>
-#include "G4CascadeMomentum.hh"
-// Notice: no cc-file for G4InuclParticle
 class G4InuclParticle {
+public:
+  G4InuclParticle() : modelId(0) {}
+public:
+  G4InuclParticle() {
+    setModel(0); // default model
+  };
+  explicit G4InuclParticle(const G4LorentzVector& mom) : modelId(0) {
+    pDP.Set4Momentum(mom*GeV/MeV);              // From Bertini to G4 units
+  }
+  virtual ~G4InuclParticle() { };
+  G4InuclParticle(const G4CascadeMomentum& mom) {
+    setMomentum(mom);
+    setModel(0);
+  };
+  virtual ~G4InuclParticle() {}
   void setMomentum(const G4CascadeMomentum& mom) {
     momentum = mom;
   };
+  // Copy and assignment constructors for use with std::vector<>
+  G4InuclParticle(const G4InuclParticle& right)
+    : pDP(right.pDP), modelId(right.modelId) {}
+  G4InuclParticle& operator=(const G4InuclParticle& right);
+  const G4CascadeMomentum& getMomentum() const {
+    return momentum;
+  };
+  // This is no longer required, as setMomentum() handles mass adjustment
+  void setEnergy() { ; }
+  G4double getMomModule() const {
+    return std::sqrt(momentum[1] * momentum[1] +
+                     momentum[2] * momentum[2] +
+                     momentum[3] * momentum[3]);
+  };
+  virtual void printParticle() const {
+    G4cout << " px " << momentum[1] << " py " << momentum[2] <<
+      " pz " << momentum[3] <<
+      " pmod " << std::sqrt(momentum[1] * momentum[1] +
+                            momentum[2] * momentum[2] +
+                            momentum[3] * momentum[3])
+           << " E " << momentum[0]
+           << " creator model " << modelId << G4endl;
+  };
+  // These are call-throughs to G4DynamicParticle
+  void setMomentum(const G4LorentzVector& mom);
+  void setModel(G4int model) {
+    modelId = model;
+  };
+  void setMass(G4double mass) { pDP.SetMass(mass*GeV/MeV); }
+  G4int getModel() {
+    return modelId;
+  };
+  G4double getMass() const {
+    return pDP.GetMass()*MeV/GeV;               // From G4 to Bertini units
+  }
+  G4double getCharge() const {
+    return pDP.GetCharge();
+  }
+  G4double getKineticEnergy() const {
+    return pDP.GetKineticEnergy()*MeV/GeV;      // From G4 to Bertini units
+  }
+  G4double getEnergy() const {
+    return pDP.GetTotalEnergy()*MeV/GeV;        // From G4 to Bertini units
+  }
+  G4double getMomModule() const {
+    return pDP.GetTotalMomentum()*MeV/GeV;      // From G4 to Bertini units
+  }
+  G4LorentzVector getMomentum() const {
+    return pDP.Get4Momentum()*MeV/GeV;          // From G4 to Bertini units
+  }
+  virtual void printParticle() const;
+  void setModel(G4int model) { modelId = model; }
+  G4int getModel() const { return modelId; }
+  G4ParticleDefinition* getDefinition() const {
+    return pDP.GetDefinition();
+  }
+  const G4DynamicParticle& getDynamicParticle() const {
+    return pDP;
+  }
 protected:
+  G4CascadeMomentum momentum;
+  //  Special constructors for subclasses to set particle type correctly
+  explicit G4InuclParticle(G4ParticleDefinition* pd) : modelId(0) {
+    setDefinition(pd);
+  }
+  // FIXME: Bertini code doesn't pass valid 4-vectors, so force mass value
+  //        from supplied PartDefn, with required unit conversions
+  G4InuclParticle(G4ParticleDefinition* pd, const G4LorentzVector& mom);
+  // NOTE:  Momentum forced along Z direction
+  G4InuclParticle(G4ParticleDefinition* pd, G4double ekin)
+    : pDP(pd,G4ThreeVector(0.,0.,1.),ekin*GeV/MeV), modelId(0) {}
+  void setDefinition(G4ParticleDefinition* pd) { pDP.SetDefinition(pd); }
 private:
   G4int modelId; // used to indicate model that created instance of G4InuclParticle
+  G4DynamicParticle pDP;                // Carries all the kinematics and info
+  G4int modelId;
+  // used to indicate model that created instance of G4InuclParticle
   // 0 default
   // 1 bullet

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4InuclSpecialFunctions.hh,v 1.16 2010/04/13 05:30:10 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
+// 20100319  M. Kelsey -- Add optional mass argument to generateWithFixedTheta;
+//              define new generateWithRandomAngles, encapsulating code; define
+//              cbrt() cube-root function (in math.h, but not in <math>!)
+// 20100412  M. Kelsey -- Modify paraMaker[Truncated] to take buffer as argument
 #ifndef G4INUCL_SPECIAL_FUNC_HH
 #define G4INUCL_SPECIAL_FUNC_HH
 #include "globals.hh"
-#include <cmath>
 #include <algorithm>
 #include <vector>
 #include "G4CascadeMomentum.hh"
+#include "G4LorentzVector.hh"
 namespace G4InuclSpecialFunctions {
 …
                        G4int ntype);
   std::pair<std::vector<G4double>, std::vector<G4double> > paraMaker(G4double Z);
+  void paraMaker(G4double Z, std::pair<std::vector<G4double>, std::vector<G4double> >& parms);
   std::pair<G4double, G4double> paraMakerTruncated(G4double Z);
+  void paraMakerTruncated(G4double Z, std::pair<G4double, G4double>& parms);
   G4double getAL(G4double A);
 …
   G4double csPN(G4double e);
+  G4double G4cbrt(G4double x);  // Can't use "cbrt" name, clashes with <math.h>
   G4double inuclRndm();
 …
   G4double nucleiLevelDensity(G4double a);
+  G4CascadeMomentum generateWithFixedTheta(G4double ct,
+                                          G4double p);
+  // Optional mass argument will be used to fill G4LorentzVector correctly
+  G4LorentzVector generateWithFixedTheta(G4double ct, G4double p,
+                                         G4double m=0.);
+  G4LorentzVector generateWithRandomAngles(G4double p, G4double m=0.);
+}
 #endif

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4LorentzConvertor.hh,v 1.15 2010/05/21 17:56:34 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100108  Michael Kelsey -- Use G4LorentzVector internally
+// 20100120  M. Kelsey -- BUG FIX:  scm_momentum should be G4ThreeVector
+// 20100126  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
+// 20100519  M. Kelsey -- Add interfaces to pass G4InuclParticles directly
 #ifndef G4LORENTZ_CONVERTOR_HH
 #define G4LORENTZ_CONVERTOR_HH
-#ifndef GLOB
 #include "globals.hh"
+#endif
+#include "G4LorentzVector.hh"
+#include "G4ThreeVector.hh"
+#include <vector>
+#include "G4CascadeMomentum.hh"
+class G4InuclParticle;
 class G4LorentzConvertor {
 …
   G4LorentzConvertor();
+  G4LorentzConvertor(const G4CascadeMomentum& bmom,
+                     G4double bmass,
+                     const G4CascadeMomentum& tmom,
+                     G4double tmass) {
+  G4LorentzConvertor(const G4LorentzVector& bmom, G4double bmass,
+                     const G4LorentzVector& tmom, G4double tmass) {
     setBullet(bmom, bmass);
     setTarget(tmom, tmass);
+    degenerated = false;
+  };
+  }
+  void setBullet(const G4CascadeMomentum& bmom,
+                 G4double bmass) {
+  G4LorentzConvertor(const G4InuclParticle* bullet,
+                     const G4InuclParticle* target) {
+    setBullet(bullet);
+    setTarget(target);
+  }
+    bullet_mom = bmom;
+    bullet_mass = bmass;
+    //  G4cout << " bullet: e " << bmom[0] << " mass " << bmass << G4endl;
+  void setVerbose(G4int vb=0) { verboseLevel = vb; }
+  void setBullet(const G4InuclParticle* bullet);
+  void setTarget(const G4InuclParticle* target);
+  void setBullet(const G4InuclParticle& bullet) { setBullet(&bullet); }
+  void setTarget(const G4InuclParticle& target) { setTarget(&target); }
+  // Use correct four-vectors as input
+  void setBullet(const G4LorentzVector& bmom) { bullet_mom = bmom; }
+  void setTarget(const G4LorentzVector& bmom) { target_mom = bmom; }
+  // NOTE:  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;
   };
   void setTarget(const G4CascadeMomentum& tmom,
+                 G4double tmass) {
+  void setTarget(const G4LorentzVector& tmom, G4double tmass) {
+    target_mom.setVectM(tmom.vect(), tmass);
+    target_mom = tmom;
+    target_mass = tmass;
+    //  G4cout << " target: e " << tmom[0] << " mass " << tmass << G4endl;
+    //  G4cout << " target: e " << target_mom.e() << " mass "
+    //         << target_mom.m() << G4endl;
   };
   void toTheCenterOfMass();
   void toTheTargetRestFrame();
   G4CascadeMomentum backToTheLab(const G4CascadeMomentum& mom) const;
+  G4LorentzVector backToTheLab(const G4LorentzVector& mom) const;
+  G4double getKinEnergyInTheTRS() const {
+  // Four-vectors of bullet and target in last chosen reference frame
+  const G4LorentzVector& getBullet() const { return bullet_mom; }
+  const G4LorentzVector& getTarget() const { return target_mom; }
+  G4double getKinEnergyInTheTRS() const;
+  G4double getTotalSCMEnergy() const { return ecm_tot; }
+  G4double getSCMMomentum() const { return scm_momentum.rho(); }
+  G4double getTRSMomentum() const;
+    G4double pv = bullet_mom[1] * target_mom[1] +
+      bullet_mom[2] * target_mom[2] +
+      bullet_mom[3] * target_mom[3];
+    G4double ekin_trf = (target_mom[0] *
+                         bullet_mom[0] - pv) / target_mass - bullet_mass;
+    return ekin_trf;
+  };
+  G4LorentzVector rotate(const G4LorentzVector& mom) const;
+  G4double getTotalSCMEnergy() const {
+    return ecm_tot;
+  };
+  G4double getSCMMomentum() const {
+    return pscm;
+  };
+  G4double getTRSMomentum() const {
+    return plab;
+  };
+  G4CascadeMomentum rotate(const G4CascadeMomentum& mom) const;
+  G4CascadeMomentum rotate(const G4CascadeMomentum& mom1,
+                            const G4CascadeMomentum& mom) const;
+  G4LorentzVector rotate(const G4LorentzVector& mom1,
+                         const G4LorentzVector& mom) const;
   G4bool reflectionNeeded() const;
+  G4bool trivial() const {
+    return degenerated;
+  };
+  G4bool trivial() const { return degenerated; }
 private:
+G4int verboseLevel;
+  G4CascadeMomentum bullet_mom;
+  G4double bullet_mass;
+  static const G4double small;
+  G4CascadeMomentum target_mom;
+  G4double target_mass;
+  G4int verboseLevel;
+  G4LorentzVector bullet_mom;
+  G4LorentzVector target_mom;
   std::vector<G4double> velocity;
+  G4LorentzVector scm_momentum;         // CM momentum relative to target/bullet
+  G4CascadeMomentum scm_momentum;
+  // Buffer variables for doing ::rotate() calculations
+  G4ThreeVector velocity;
+  G4double gamma;
+  G4double v2;
   G4double ecm_tot;
-  G4double pscm;
-  G4double plab;
-  G4double gamma;
-  G4double v2;
   G4double ga;
   G4double gb;
   G4double gbpp;
   G4double gapp;
   G4bool degenerated;
 };

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4NonEquilibriumEvaporator.hh,v 1.10 2010/05/21 17:56:34 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 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
 #ifndef G4NON_EQUILIBRIUM_EVAPORATOR_HH
 #define G4NON_EQUILIBRIUM_EVAPORATOR_HH
+#include "G4Collider.hh"
+#include "G4InuclSpecialFunctions.hh"
+#include "G4VCascadeCollider.hh"
+using namespace G4InuclSpecialFunctions;
+class G4CollisionOutput;
+class G4InuclParticle;
+class G4NonEquilibriumEvaporator {
+class G4NonEquilibriumEvaporator : public G4VCascadeCollider {
+public:
+  G4NonEquilibriumEvaporator();
+  virtual ~G4NonEquilibriumEvaporator() {}
+public:
+  G4NonEquilibriumEvaporator();
+  G4CollisionOutput collide(G4InuclParticle* bullet,
+                                    G4InuclParticle* target);
+  void collide(G4InuclParticle* bullet, G4InuclParticle* target,
+               G4CollisionOutput& output);
 private:
-G4int verboseLevel;
   G4double getMatrixElement(G4double A) const;
   G4double getE0(G4double A) const;
   G4double getParLev(G4double A, G4double Z) const;
 };
 #endif // G4NON_EQUILIBRIUM_EVAPORATOR_HH
+#endif /* G4NON_EQUILIBRIUM_EVAPORATOR_HH */

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

-              r819
+              r1315
+#ifndef G4NUCL_WATCHER_HH
+#define G4NUCL_WATCHER_HH
 //
 // ********************************************************************
 …
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4NuclWatcher.hh,v 1.13 2010/04/07 18:23:15 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+#ifndef G4NUCL_WATCHER_HH
+#define G4NUCL_WATCHER_HH
+// 20100202  M. Kelsey -- Move most code into .cc file
+// 20100405  M. Kelsey -- Pass const-ref std::vector<>
+#ifndef GLOB
+#include "globals.hh"
+#endif
+#include "G4Types.hh"
 #include <algorithm>
 …
 class G4NuclWatcher {
+public:
+  G4NuclWatcher(G4double z,
+                const std::vector<G4double>& expa,
+                const std::vector<G4double>& expcs,
+                const std::vector<G4double>& experr,
+                G4bool check,
+                G4bool nucl);
+public:
+  ~G4NuclWatcher() {}
+  G4NuclWatcher(G4double z,
+                std::vector<G4double> expa,
+                std::vector<G4double> expcs,
+                std::vector<G4double> experr,
+                G4bool check,
+                G4bool nucl)
+    : nuclz(z),
+      checkable(check),
+      nucleable(nucl)  {
+  void watch(G4double a, G4double z);
+  void setInuclCs(G4double csec, G4int nev);
+    exper_as = expa;
+    exper_cs = expcs;
+    exper_err = experr;
+  };
+  G4double getChsq() const { return izotop_chsq; }
+  G4bool to_check() const { return checkable; }
+  G4bool look_forNuclei() const { return nucleable; }
+  G4double getLhood() const { return aver_lhood; }
+  G4double getNmatched() const { return aver_matched; }
+  void watch(G4double a,
+             G4double z) {
+    const G4double small = 0.001;
+    if(std::fabs(z - nuclz) < small) {
+      G4bool here = false;
+      G4int  simulatedAsSize = simulated_as.size();
+      for(G4int i = 0; i < simulatedAsSize; i++) {
+        if(std::fabs(simulated_as[i] - a) < small) {
+          simulated_cs[i] += 1.0;
+          here = true;
+          break;
+        };
+      };
+      if(!here) {
+        simulated_as.push_back(a);
+        simulated_cs.push_back(1.0);
+      };
+    };
+  };
+  void setInuclCs(G4double csec,
+                  G4int nev) {
+    G4int  simulatedAsSize = simulated_as.size();
+    for(G4int i = 0; i < simulatedAsSize ; i++) {
+      double err = std::sqrt(simulated_cs[i]) / simulated_cs[i];
+      simulated_prob.push_back(simulated_cs[i] / nev);
+      simulated_cs[i] *= csec / nev;
+      simulated_errors.push_back(simulated_cs[i] * err);
+    };
+  };
+  G4double getChsq() const {
+    return izotop_chsq;
+  };
+  std::pair<G4double, G4double> getExpCs() const;
+  std::pair<G4double, G4double> getInuclCs() const;
   std::pair<G4double, G4double> getAverageRatio() const {
+    return std::pair<G4double, G4double>(average_ratio, aver_rat_err);
+  }
+    return std::pair<G4double, G4double>(average_ratio, aver_rat_err);
+  };
+  std::pair<G4double, G4double> getExpCs() const {
+    G4double cs = 0.0;
+    G4double err = 0.0;
+    G4int experAsSize = exper_as.size();
+    for(G4int iz = 0; iz < experAsSize; iz++) {
+      cs += exper_cs[iz];
+      err += exper_err[iz];
+    };
+    return std::pair<G4double, G4double>(cs, err);
+  };
+  G4bool to_check() const {
+    return checkable;
+  };
+  G4bool look_forNuclei() const {
+    return nucleable;
+  };
+  std::pair<G4double, G4double> getInuclCs() const {
+    G4double cs = 0.0;
+    G4double err = 0.0;
+    G4int  simulatedAsSize = simulated_as.size();
+    for(G4int iz = 0; iz < simulatedAsSize; iz++) {
+      cs += simulated_cs[iz];
+      err += simulated_errors[iz];
+    };
+    return std::pair<G4double, G4double>(cs, err);
+  };
+  void print() {
+    const G4double small = 0.001;
+    G4cout << G4endl << " ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ "
+           << G4endl;
+    G4cout << " **** izotop Z **** " << nuclz << G4endl;
+    izotop_chsq = 0.0;
+    average_ratio = 0.0;
+    aver_rat_err = 0.0;
+    G4double exp_cs = 0.0;
+    G4double exp_cs_err = 0.0;
+    G4double inucl_cs = 0.0;
+    G4double inucl_cs_err = 0.0;
+    std::vector<G4bool> not_used(simulated_cs.size(), true);
+    G4int nmatched = exper_as.size();
+    G4int nused = simulated_cs.size();
+    G4double lhood = 0.0;
+    G4int experAsSize = exper_as.size();
+    for(G4int iz = 0; iz < experAsSize; iz++) {
+      G4double a = exper_as[iz];
+      exp_cs += exper_cs[iz];
+      exp_cs_err += exper_err[iz];
+      G4bool found = false;
+    G4int  simulatedAsSize = simulated_as.size();
+      for(G4int i = 0; i < simulatedAsSize; i++) {
+        if(std::fabs(simulated_as[i] - a) < small) {
+          G4double rat = simulated_cs[i] / exper_cs[iz];
+          lhood += std::log10(rat) * std::log10(rat);
+          G4double rat_err = std::sqrt(simulated_errors[i] * simulated_errors[i] +
+                                  exper_err[iz] * exper_err[iz] * rat * rat) / exper_cs[iz];
+          average_ratio += rat;
+          aver_rat_err += rat_err;
+          G4cout << " A " << a << " exp.cs " << exper_cs[iz] << " err " <<
+            exper_err[iz] << G4endl <<
+            " sim. cs " << simulated_cs[i] << " err " << simulated_errors[i] << G4endl
+                 << " ratio " << rat << " err " << rat_err << G4endl;
+          G4cout << " simulated production rate " << simulated_prob[i] << G4endl;
+          not_used[i] = false;
+          izotop_chsq += (rat - 1.0) * (rat - 1.0) / rat_err / rat_err;
+          found = true;
+          nused--;
+          break;
+        };
+      };
+      if(!found) {
+        G4cout << " not found exper.: A " << a << " exp.cs " << exper_cs[iz]
+               << " err " << exper_err[iz] << G4endl;
+      }
+      else {
+        nmatched--;
+      };
+    };
+    G4cout << " not found in simulations " << nmatched << G4endl;
+    G4cout << " not found in exper: " << nused << G4endl;
+    G4int  simulatedAsSize = simulated_as.size();
+    for(G4int i = 0; i < simulatedAsSize; i++) {
+      inucl_cs += simulated_cs[i];
+      inucl_cs_err += simulated_errors[i];
+      if(not_used[i])
+        G4cout << " extra simul.: A " << simulated_as[i] <<
+          " sim. cs " << simulated_cs[i] << " err " << simulated_errors[i] << G4endl;
+      G4cout << " simulated production rate " << simulated_prob[i] << G4endl;
+    };
+    G4int matched = exper_as.size() - nmatched;
+    if(matched > 0) {
+      aver_lhood = lhood;
+      aver_matched = matched;
+      lhood = std::pow(10.0, std::sqrt(lhood / matched));
+      G4cout << " matched " << matched << " CHSQ " << std::sqrt(izotop_chsq) / matched
+             << G4endl
+             << " raw chsq " << izotop_chsq << G4endl
+             << " average ratio " << average_ratio / matched
+             << " err " << aver_rat_err / matched << G4endl
+             << " lhood " << lhood << G4endl;
+    }
+    else {
+      izotop_chsq = 0.0;
+      aver_lhood = 0.0;
+    };
+    G4cout << " exper. cs " << exp_cs << " err " << exp_cs_err << G4endl
+           << " inucl. cs " << inucl_cs << " err " << inucl_cs_err << G4endl;
+    G4cout <<  " ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ " << G4endl;
+  };
+  G4double getLhood() const {
+    return aver_lhood;
+  };
+  G4double getNmatched() const {
+    return aver_matched;
+  };
+  void print();
 private:
   G4double nuclz;
   G4double izotop_chsq;
   G4double average_ratio;
   G4double aver_rat_err;
   G4double aver_lhood;
   G4double aver_matched;
   std::vector<G4double> exper_as;
   std::vector<G4double> exper_cs;
   std::vector<G4double> exper_err;
   std::vector<G4double> simulated_as;
   std::vector<G4double> simulated_cs;
   std::vector<G4double> simulated_errors;
   std::vector<G4double> simulated_prob;
   G4bool checkable;
   G4bool nucleable;
+};
+};
 #endif // G4NUCL_WATCHER_HH

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

-              r1196
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4NucleiModel.hh,v 1.25 2010/05/21 17:44:38 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100319  M. Kelsey -- Remove "using" directory and unnecessary #includes,
+//              move ctor to .cc file
+// 20100407  M. Kelsey -- Create "partners thePartners" data member to act
+//              as buffer between ::generateInteractionPartners() and
+//              ::generateParticleFate(), and make "outgoing_cparticles" a
+//              data member returned from the latter by const-ref.  Replace
+//              return-by-value of initializeCascad() with an input buffer.
+// 20100409  M. Kelsey -- Add function to sort list of partnerts by pathlen,
+//              move non-inlinable code to .cc.
+// 20100421  M. Kelsey -- Move getFermiKinetic() to .cc, no hardwired masses.
+// 20100517  M. Kelsey -- Change cross-section tables to static arrays.  Move
+//              absorptionCrossSection() from SpecialFunc.
+// 20100520  M. Kelsey -- Add function to separate momentum from nucleon
 #ifndef G4NUCLEI_MODEL_HH
 #define G4NUCLEI_MODEL_HH
-#ifndef G4INUCL_ELEMENTARY_PARTICLE_HH
 #include "G4InuclElementaryParticle.hh"
-#endif
 #include "G4CascadParticle.hh"
+#include "G4InuclSpecialFunctions.hh"
+#include "G4ElementaryParticleCollider.hh"
+#include <algorithm>
 #include <vector>
 class G4InuclNuclei;
+using namespace G4InuclSpecialFunctions;
+typedef std::pair<G4InuclElementaryParticle, G4double> partner;
+typedef std::vector<partner> partners;
+class G4ElementaryParticleCollider;
 class G4NucleiModel {
 …
   G4NucleiModel();
+  G4NucleiModel(G4InuclNuclei* nuclei) {
+    generateModel(nuclei->getA(), nuclei->getZ());
+  }
+  G4NucleiModel(G4InuclNuclei* nuclei);
   void generateModel(G4double a, G4double z);
   void reset() {
 …
+  }
+  G4double getFermiKinetic(G4int ip, G4int izone) const {
+    G4double ekin = 0.0;
+    if(ip < 3 && izone < number_of_zones) {
+      G4double pf = fermi_momenta[ip - 1][izone];
+      G4double mass = ip == 1 ? 0.93827 : 0.93957;
+      ekin = std::sqrt(pf * pf + mass * mass) - mass;
+    }
+    return ekin;
+  }
+  G4double getFermiKinetic(G4int ip, G4int izone) const;
   G4double getPotential(G4int ip, G4int izone) const {
 …
   std::vector<G4CascadParticle>
+  const std::vector<G4CascadParticle>&
   generateParticleFate(G4CascadParticle& cparticle,
                        G4ElementaryParticleCollider* theElementaryParticleCollider);
 …
+  std::pair<std::vector<G4CascadParticle>, std::vector<G4InuclElementaryParticle> >
+  initializeCascad(G4InuclNuclei* bullet, G4InuclNuclei* target);
+  typedef std::pair<std::vector<G4CascadParticle>, std::vector<G4InuclElementaryParticle> > modelLists;
+  void initializeCascad(G4InuclNuclei* bullet, G4InuclNuclei* target,
+                        modelLists& output);
 …
   G4InuclElementaryParticle generateNucleon(G4int type, G4int zone) const;
+  G4LorentzVector generateNucleonMomentum(G4int type, G4int zone) const;
+  G4double absorptionCrossSection(G4double e, G4int type) const;
+  G4double totalCrossSection(G4double ke, G4int rtype) const;
 private:
   G4int verboseLevel;
-  void initTotalCrossSections();
-  G4double totalCrossSection(G4double e, G4int rtype) const;
   G4bool passFermi(const std::vector<G4InuclElementaryParticle>& particles,
 …
                                                  G4int zone) const;
+  partners generateInteractionPartners(G4CascadParticle& cparticle) const;
+  typedef std::pair<G4InuclElementaryParticle, G4double> partner;
+  std::vector<partner> thePartners;             // Buffer for output below
+  void generateInteractionPartners(G4CascadParticle& cparticle);
+  // Function for std::sort() to use in organizing partners by path length
+  static G4bool sortPartners(const partner& p1, const partner& p2) {
+    return (p2.second > p1.second);
+  }
   G4double volNumInt(G4double r1, G4double r2, G4double cu,
 …
   G4double getRatio(G4int ip) const;
+  std::vector<G4CascadParticle> outgoing_cparticles;    // Return buffer
   std::vector<std::vector<G4double> > nucleon_densities;
 …
   // Total cross sections
+  G4double PPtot[30];
+  G4double NPtot[30];
+  G4double pipPtot[30];
+  G4double pimPtot[30];
+  G4double pizPtot[30];
+  G4double kpPtot[30];
+  G4double kpNtot[30];
+  G4double kmPtot[30];
+  G4double kmNtot[30];
+  G4double lPtot[30];
+  G4double spPtot[30];
+  G4double smPtot[30];
+  G4double xi0Ptot[30];
+  G4double ximPtot[30];
+  static const G4double PPtot[30];
+  static const G4double NPtot[30];
+  static const G4double pipPtot[30];
+  static const G4double pimPtot[30];
+  static const G4double pizPtot[30];
+  static const G4double kpPtot[30];
+  static const G4double kpNtot[30];
+  static const G4double kmPtot[30];
+  static const G4double kmNtot[30];
+  static const G4double lPtot[30];
+  static const G4double spPtot[30];
+  static const G4double smPtot[30];
+  static const G4double xi0Ptot[30];
+  static const G4double ximPtot[30];
 };

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

-              r1197
+              r1315
+#ifndef G4ParticleLargerBeta_h
+#define G4ParticleLargerBeta_h
 //
 // ********************************************************************
 …
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4ParticleLargerBeta.hh,v 1.6 2010/05/15 04:25:17 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+#ifndef G4ParticleLargerBeta_h
+#define G4ParticleLargerBeta_h
+// 20100112  M. Kelsey -- Add additional operator() which uses pointers,
+//              also fix bug which returns wrong result
-#ifndef G4INUCL_ELEMENTARY_PARTICLE_HH
 #include "G4InuclElementaryParticle.hh"
-#endif
 class G4ParticleLargerBeta {
 public:
   G4bool operator() (const G4InuclElementaryParticle& part1,
                      const G4InuclElementaryParticle& part2) {
+    return part1.getMomModule()/part1.getEnergy() <=
            part2.getMomModule()/part2.getEnergy();
+    return (part1.getMomModule()/part1.getEnergy() >=
+            part2.getMomModule()/part2.getEnergy()
+            );
+  }
+  G4bool operator() (const G4InuclElementaryParticle* part1,
+                     const G4InuclElementaryParticle* part2) {
+    return (part1 && part2 && operator()(*part1, *part2));
+  }
 };
 #endif
+#endif  /* G4ParticleLargerBeta_h */

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

-              r819
+              r1315
+#ifndef G4PARTICLE_LARGER_EKIN_HH
+#define G4PARTICLE_LARGER_EKIN_HH
 //
 // ********************************************************************
 …
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4ParticleLargerEkin.hh,v 1.11 2010/05/15 04:25:17 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+#ifndef G4PARTICLE_LARGER_EKIN_HH
+#define G4PARTICLE_LARGER_EKIN_HH
+// Implements a *reverse* sorting: std::sort expects a less-than operator
+// which returns true if arg1<arg2.  This function returns true if arg1>=arg2.
+//
+// 20091125  M. Kelsey -- Add additional operator() which uses pointers
-#ifndef G4INUCL_ELEMENTARY_PARTICLE_HH
 #include "G4InuclElementaryParticle.hh"
+#ifdef G4CASCADE_DEBUG_SORT
+#include "G4ios.hh"
 #endif
 class G4ParticleLargerEkin {
 public:
   G4bool operator() (const G4InuclElementaryParticle& part1,
                      const G4InuclElementaryParticle& part2) {
+    return part1.getKineticEnergy() >= part2.getKineticEnergy();
+    //  return part1.getEnergy() >= part2.getEnergy();
+    //  return part1.getMomModule() >= part2.getMomModule();
+  };
+#ifdef G4CASCADE_DEBUG_SORT
+    G4cout << "part1 @ " << &part1 << ": ";
+    part1.printParticle();
+    G4cout << "part2 @ " << &part2 << ": ";
+    part2.printParticle();
+    G4cout << G4endl;
+#endif
+    return (part1.getKineticEnergy() >= part2.getKineticEnergy());
+  }
+  G4bool operator() (const G4InuclElementaryParticle* part1,
+                     const G4InuclElementaryParticle* part2) {
+    return (part1 && part2 && operator()(*part1, *part2));
+  }
 };

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

-              r819
+              r1315
 // ********************************************************************
 //
 // $Id: G4PreCompoundCascadeInterface.hh,v 1.1 2007/05/23 14:37:28 miheikki Exp $
+// $Id: G4PreCompoundCascadeInterface.hh,v 1.3 2010/05/21 18:07:30 mkelsey Exp $
 // Defines an interface to Bertini (BERT) INC with exitons. Evaporation is NOT included
+//
+// 20100520 M. Kelsey -- Add missing name string to ctor, follow code changes from
+//              G4CascadeInterface.
 #ifndef G4PRECOMPOUNDCASCADEINTERFACE_H
 …
 public:
   G4PreCompoundCascadeInterface();
+  G4PreCompoundCascadeInterface(const G4String& nam="PreCompound Bertini Cascade");
   ~G4PreCompoundCascadeInterface(){
 …
 private:
   G4int operator==(G4PreCompoundCascadeInterface& right) {
+  G4int operator==(const G4PreCompoundCascadeInterface& right) const {
     return (this == &right);
+  }
   G4int operator!=(G4PreCompoundCascadeInterface& right) {
+  G4int operator!=(const G4PreCompoundCascadeInterface& right) const {
     return (this != &right);
+  }

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4PreCompoundInuclCollider.hh,v 1.6 2010/05/21 17:56:34 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100315  M. Kelsey -- Remove "using" directive and unneeded #includes.
+// 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
+// 20100517  M. Kelsey -- Inherit from common base class, make other colliders
+//              simple data members
 #ifndef G4PRECOMPOUNDINUCL_COLLIDER_HH
 #define G4PRECOMPOUNDINUCL_COLLIDER_HH
+#include "G4Collider.hh"
+#include "G4IntraNucleiCascader.hh"
+#include "G4NonEquilibriumEvaporator.hh"
+#include "G4BigBanger.hh"
+#include "G4ElementaryParticleCollider.hh"
+#include "G4InteractionCase.hh"
+#include "G4InuclNuclei.hh"
+#include "G4InuclSpecialFunctions.hh"
+#include "G4Analyser.hh"
+#include "G4VCascadeCollider.hh"
+using namespace G4InuclSpecialFunctions;
+class G4BigBanger;
+class G4CollisionOutput;
+class G4ElementaryParticleCollider;
+class G4IntraNucleiCascader;
+class G4InuclParticle;
+class G4NonEquilibriumEvaporator;
+class G4PreCompoundInuclCollider {
+class G4PreCompoundInuclCollider : public G4VCascadeCollider {
 public:
   G4PreCompoundInuclCollider();
+  G4PreCompoundInuclCollider(G4ElementaryParticleCollider* ecollider,
+                  G4IntraNucleiCascader* incascader,
+                  G4NonEquilibriumEvaporator* noeqevaporator,
+                  G4BigBanger* bigbanger) {
+    setElementaryParticleCollider(ecollider);
+    setIntraNucleiCascader(incascader,ecollider);
+    setNonEquilibriumEvaporator(noeqevaporator);
+    setBigBanger(bigbanger);
+  };
+  void setElementaryParticleCollider(G4ElementaryParticleCollider* ecollider) {
+    theElementaryParticleCollider = ecollider;
+  };
+  void setIntraNucleiCascader(G4IntraNucleiCascader* incascader,
+                              G4ElementaryParticleCollider* ecollider) {
+    theIntraNucleiCascader = incascader;
+    theIntraNucleiCascader->setElementaryParticleCollider(ecollider);
+  };
+  void setNonEquilibriumEvaporator(G4NonEquilibriumEvaporator* noeqevaporator) {
+    theNonEquilibriumEvaporator = noeqevaporator;
+  };
+  void setBigBanger(G4BigBanger* bigbanger) {
+    theBigBanger = bigbanger;
+  };
+  virtual ~G4PreCompoundInuclCollider();
   G4CollisionOutput collide(G4InuclParticle* bullet,
                             G4InuclParticle* target);
+  void collide(G4InuclParticle* bullet, G4InuclParticle* target,
+               G4CollisionOutput& globalOutput);
 private:
-  G4int verboseLevel;
-  G4bool inelasticInteractionPossible(G4InuclParticle* bullet,
-                                      G4InuclParticle* target,
-                                      G4double ekin) const;
-  G4InteractionCase bulletTargetSetter(G4InuclParticle* bullet,
-                                       G4InuclParticle* target) const;
-  G4bool explosion(G4InuclNuclei* target) const;
   G4ElementaryParticleCollider* theElementaryParticleCollider;
   G4IntraNucleiCascader* theIntraNucleiCascader;
   G4NonEquilibriumEvaporator* theNonEquilibriumEvaporator;
   G4BigBanger* theBigBanger;
 };
 #endif // G4PRECOMPOUNDINUCL_COLLIDER_HH
+#endif /* G4PRECOMPOUNDINUCL_COLLIDER_HH */

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

-              r819
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4WatcherGun.hh,v 1.9 2010/04/08 15:48:00 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100407  M. Kelsey -- Return const-ref to avoid copy overhead.
 #ifndef G4WATCHER_GUN_HH
 #define G4WATCHER_GUN_HH
 …
   void setWatchers();
   std::vector<G4NuclWatcher> getWatchers() const {
+  const std::vector<G4NuclWatcher>& getWatchers() const {
     return watchers;
   };

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

r819	r1315
29	29
30	30	G4Analyser::G4Analyser()
31		:verboseLevel(1) {
	31	:verboseLevel(0) {
32	32
33	33	if (verboseLevel > 3) {

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4BigBanger.cc,v 1.29 2010/05/21 17:56:34 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
+// 20100301  M. Kelsey -- In generateBangInSCM(), restore old G4CascMom calcs.
+//              for (N-1)th outgoing nucleon.
+// 20100319  M. Kelsey -- Use new generateWithRandomAngles for theta,phi stuff
+// 20100407  M. Kelsey -- Replace std::vector<> returns with data members.
+// 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
+// 20100517  M. Kelsey -- Inherit from common base class, clean up code
 #include "G4BigBanger.hh"
+#include "G4CollisionOutput.hh"
 #include "G4InuclNuclei.hh"
+#include "G4InuclElementaryParticle.hh"
+#include "G4InuclSpecialFunctions.hh"
 #include "G4ParticleLargerEkin.hh"
 #include "G4LorentzConvertor.hh"
+#include "G4HadTmpUtil.hh"
+#include "G4NucleiProperties.hh"
 #include <algorithm>
+using namespace G4InuclSpecialFunctions;
 typedef std::vector<G4InuclElementaryParticle>::iterator particleIterator;
+G4BigBanger::G4BigBanger()
+  : verboseLevel(1) {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4BigBanger::G4BigBanger" << G4endl;
+  }
+}
+G4CollisionOutput G4BigBanger::collide(G4InuclParticle* /*bullet*/,
+                                       G4InuclParticle* target) {
+G4BigBanger::G4BigBanger() : G4VCascadeCollider("G4BigBanger") {}
+void
+G4BigBanger::collide(G4InuclParticle* /*bullet*/, G4InuclParticle* target,
+                     G4CollisionOutput& output) {
   if (verboseLevel > 3) {
 …
   const G4double small_ekin = 1.0e-6;
+  G4CollisionOutput output;
+  G4CascadeMomentum totscm;
+  G4CascadeMomentum totlab;
+  if(G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target)) {
+    G4double A = nuclei_target->getA();
+    G4double Z = nuclei_target->getZ();
+    const G4CascadeMomentum& PEX = nuclei_target->getMomentum();
+    G4double EEXS = nuclei_target->getExitationEnergy();
+    G4InuclElementaryParticle dummy(small_ekin, 1);
+    G4LorentzConvertor toTheNucleiSystemRestFrame;
+    toTheNucleiSystemRestFrame.setBullet(dummy.getMomentum(), dummy.getMass());
+    toTheNucleiSystemRestFrame.setTarget(PEX, nuclei_target->getMass());
+    toTheNucleiSystemRestFrame.toTheTargetRestFrame();
+    G4double etot = 0.001 * (EEXS - bindingEnergy(A, Z));
+  G4LorentzVector totscm;
+  G4LorentzVector totlab;
+  G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target);
+  if (!nuclei_target) {
+    G4cerr << " BigBanger -> try to bang not nuclei " << G4endl;
+    return;
+  }
+  G4double A = nuclei_target->getA();
+  G4double 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
+  if (etot < 0.0) etot = 0.0;
+  if (verboseLevel > 2) {
+    G4cout << " BigBanger: target " << G4endl;
+    nuclei_target->printParticle();
+    G4cout << " BigBanger: a " << A << " z " << Z << " eexs " << EEXS << " etot " <<
+      etot << " nm " << nuclei_target->getMass() << G4endl;
+  }
+  generateBangInSCM(etot, A, Z);
+  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
+    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 << " BigBanger: target " << G4endl;
+      nuclei_target->printParticle();
+      G4cout << " BigBanger: a " << A << " z " << Z << " eexs " << EEXS << " etot " <<
+        etot << " nm " << nuclei_target->getMass() << G4endl;
+    }
+    std::vector<G4InuclElementaryParticle> particles =
+      generateBangInSCM(etot, A, Z, dummy.getParticleMass(1), dummy.getParticleMass(2));
+    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
+      //      if (verboseLevel > 2) {
+      // not used    G4CascadeMomentum totscm;
+      // not used    G4CascadeMomentum totlab;
+      //      }
+      particleIterator ipart;
+      for(ipart = particles.begin(); ipart != particles.end(); ipart++) {
+        if (verboseLevel > 2) {
+          const G4CascadeMomentum& mom_scm = ipart->getMomentum();
+          for(G4int i = 0; i < 4; i++) totscm[i] += mom_scm[i];
+        }
+        G4CascadeMomentum mom =
+          toTheNucleiSystemRestFrame.backToTheLab(ipart->getMomentum());
+        ipart->setMomentum(mom);
+        if (verboseLevel > 2) {
+          mom = ipart->getMomentum();
+          for(G4int i = 0; i < 4; i++) totlab[i] += mom[i];
+        }
+      };
+      std::sort(particles.begin(), particles.end(), G4ParticleLargerEkin());
+      if (verboseLevel > 2) {
+        G4cout << " In SCM: total outgoing momentum " << G4endl
+               << " E " << totscm[0] << " px " << totscm[1]
+               << " py " << totscm[2] << " pz " << totscm[3] << G4endl;
+        G4cout << " In Lab: mom cons " << G4endl
+               << " E " << PEX[0] + 0.001 * EEXS - totlab[0]
+               << " px " << PEX[1] - totlab[1]
+               << " py " << PEX[2] - totlab[2]
+               << " pz " << PEX[3] - totlab[3] << G4endl;
+      }
+    };
+    output.addOutgoingParticles(particles);
+  }
+  else {
+    G4cout << " BigBanger -> try to bang not nuclei " << G4endl;
+  };
+  return output;
+      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;
+    }
+  }
+  output.addOutgoingParticles(particles);
+  return;
+}
+std::vector<G4InuclElementaryParticle>
+G4BigBanger::generateBangInSCM(G4double etot,
+                               G4double a,
+                               G4double z,
+                               G4double mp,
+                               G4double mn) const {
+void G4BigBanger::generateBangInSCM(G4double etot, G4double a, G4double 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;
 …
     G4cout << " ia " << ia << " iz " << iz << G4endl;
+  }
+  std::vector<G4InuclElementaryParticle> particles;
+  particles.clear();    // Reset output vector before filling
   if(ia == 1) {
 …
     G4double m = iz > 0 ? mp : mn;
     G4double pmod = std::sqrt((etot + 2.0 * m) * etot);
+    G4CascadeMomentum mom;
+    std::pair<G4double, G4double> COS_SIN = randomCOS_SIN();
+    G4double FI = randomPHI();
+    G4double Pt = pmod * COS_SIN.second;
+    mom[1] = Pt * std::cos(FI);
+    mom[2] = Pt * std::sin(FI);
+    mom[3] = Pt * COS_SIN.first;
+    G4LorentzVector mom = generateWithRandomAngles(pmod, m);
     G4int knd = iz > 0 ? 1 : 2;
-    //    particles.push_back(G4InuclElementaryParticle(mom, knd));
     particles.push_back(G4InuclElementaryParticle(mom, knd, 8)); // modelId included
     return particles;
+    return;
   };
   std::vector<G4double> pmod = generateMomentumModules(etot, a, z, mp, mn);
+  generateMomentumModules(etot, a, z);
   G4bool bad = true;
   G4int itry = 0;
 …
   while(bad && itry < itry_max) {
     itry++;
     std::vector<G4CascadeMomentum> scm_momentums;
     G4CascadeMomentum tot_mom;
+    std::vector<G4LorentzVector> scm_momentums;
+    G4LorentzVector tot_mom;
     if(ia == 2) {
+      G4CascadeMomentum mom;
+      std::pair<G4double, G4double> COS_SIN = randomCOS_SIN();
+      double FI = randomPHI();
+      double Pt = pmod[0] * COS_SIN.second;
+      mom[1] = Pt * std::cos(FI);
+      mom[2] = Pt * std::sin(FI);
+      mom[3] = Pt * COS_SIN.first;
+      for(G4int j = 1; j < 4; j++) tot_mom[j] += mom[j];
+      // FIXME:  This isn't actually a correct four-vector, wrong mass!
+      G4LorentzVector mom = generateWithRandomAngles(momModules[0]);
+      tot_mom += mom;
       scm_momentums.push_back(mom);
+      G4CascadeMomentum mom1;
+      for(G4int i = 1; i < 4; i++) mom1[i] = - mom[i];
+      G4LorentzVector mom1 = -mom;
       scm_momentums.push_back(mom1);
       bad = false;
+    }
+    else {
+    } else {
       for(G4int i = 0; i < ia - 2; i++) {
+        G4CascadeMomentum mom;
+        std::pair<G4double, G4double> COS_SIN = randomCOS_SIN();
+        G4double FI = randomPHI();
+        G4double Pt = pmod[i] * COS_SIN.second;
+        mom[1] = Pt * std::cos(FI);
+        mom[2] = Pt * std::sin(FI);
+        mom[3] = Pt * COS_SIN.first;
+        for(G4int j = 1; j < 4; j++) tot_mom[j] += mom[j];
+        // FIXME:  This isn't actually a correct four-vector, wrong mass!
+        G4LorentzVector mom = generateWithRandomAngles(momModules[i]);
+        tot_mom += mom;
         scm_momentums.push_back(mom);
 …
       //                handle last two
+      G4double tot_mod = std::sqrt(tot_mom[1] * tot_mom[1] +
+                              tot_mom[2] * tot_mom[2] +
+                              tot_mom[3] * tot_mom[3]);
+      G4double ct = -0.5 * (tot_mod * tot_mod + pmod[ia - 2] * pmod[ia - 2] -
+                            pmod[ia - 1] * pmod[ia - 1]) / tot_mod / pmod[ia - 2];
+      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) {
 …
       if(std::fabs(ct) < ang_cut) {
+        G4CascadeMomentum mom2 = generateWithFixedTheta(ct, pmod[ia - 2]);
+        // FIXME:  These are not actually four-vectors, just three-momenta
+        G4LorentzVector mom2 = generateWithFixedTheta(ct, momModules[ia - 2]);
         //       rotate to the normal system
+        G4CascadeMomentum apr = tot_mom;
+        G4int i;
+        for(i = 1; i < 4; i++) apr[i] /= tot_mod;
+        G4double a_tr = std::sqrt(apr[1] * apr[1] + apr[2] * apr[2]);
+        G4CascadeMomentum mom;
+        mom[1] = mom2[3] * apr[1] + ( mom2[1] * apr[2] + mom2[2] * apr[3] * apr[1]) / a_tr; // ::: replace with clhep tools?
+        mom[2] = mom2[3] * apr[2] + (-mom2[1] * apr[1] + mom2[2] * apr[3] * apr[2]) / a_tr;
+        mom[3] = mom2[3] * apr[3] - mom2[2] * a_tr;
+        G4LorentzVector apr = tot_mom/tot_mod;
+        G4double a_tr = std::sqrt(apr.x()*apr.x() + apr.y()*apr.y());
+        G4LorentzVector mom;
+        mom.setX(mom2.z()*apr.x() + ( mom2.x()*apr.y() + mom2.y()*apr.z()*apr.x())/a_tr);
+        mom.setY(mom2.z()*apr.y() + (-mom2.x()*apr.x() + mom2.y()*apr.z()*apr.y())/a_tr);
+        mom.setZ(mom2.z()*apr.z() - mom2.y()*a_tr);
         scm_momentums.push_back(mom);
         //               and the last one
+        G4CascadeMomentum mom1;
+        for(i = 1; i < 4; i++) mom1[i] = - mom[i] - tot_mom[i];
+        G4LorentzVector mom1= - mom - tot_mom;
         scm_momentums.push_back(mom1);
         bad = false;
 …
         G4int knd = i < iz ? 1 : 2;
         particles.push_back(G4InuclElementaryParticle(scm_momentums[i], knd));
+        particles.push_back(G4InuclElementaryParticle(scm_momentums[i], knd, 8));
       };
     };
 …
+  }
+  return particles;
+  return;
+}
+std::vector<G4double> G4BigBanger::generateMomentumModules(G4double etot,
+                                                             G4double a,
+                                                             G4double z,
+                                                             G4double mp,
+                                                             G4double mn) const {
+void G4BigBanger::generateMomentumModules(G4double etot, G4double a, G4double z) {
   if (verboseLevel > 3) {
     G4cout << " >>> G4BigBanger::generateMomentumModules" << G4endl;
+  }
+  G4int ia = int(a + 0.1);
+  G4int iz = int(z + 0.1);
+  std::vector<G4double> pmod;
+  // Proton and neutron masses
+  const G4double mp = G4InuclElementaryParticle::getParticleMass(1);
+  const G4double mn = G4InuclElementaryParticle::getParticleMass(2);
+  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);
 …
       G4cout << " i " << i << " x " << x << G4endl;
+    }
     pmod.push_back(x);
+    momModules.push_back(x);
     xtot += x;
   };
 …
     G4double m = i < iz ? mp : mn;
     pmod[i] = pmod[i] * etot / xtot;
     pmod[i] = std::sqrt(pmod[i] * (pmod[i] + 2.0 * m));
+    momModules[i] = momModules[i] * etot / xtot;
+    momModules[i] = std::sqrt(momModules[i] * (momModules[i] + 2.0 * m));
     if (verboseLevel > 2) {
       G4cout << " i " << i << " pmod " << pmod[i] << G4endl;
+      G4cout << " i " << i << " pmod " << momModules[i] << G4endl;
+    }
   };
+  return pmod;
+}
+G4double G4BigBanger::xProbability(G4double x,
+                                   G4int ia) const {
+  return;
+}
+G4double G4BigBanger::xProbability(G4double x, G4int ia) const {

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadParticle.cc,v 1.14 2010/03/16 22:10:26 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100112  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
+// 20100114  M. Kelsey -- Replace vector<G4Double> position with G4ThreeVector
 #include "G4CascadParticle.hh"
+#include "G4ios.hh"
+#include <cmath>
 G4CascadParticle::G4CascadParticle()
   : verboseLevel(2) {
+  : verboseLevel(0), current_zone(-1), current_path(-1.), movingIn(false),
+    reflectionCounter(0), reflected(false), generation(-1) {
   if (verboseLevel > 3) {
     G4cout << " >>> G4CascadParticle::G4CascadParticle" << G4endl;
 …
 G4double G4CascadParticle::getPathToTheNextZone(G4double rz_in,
                                                 G4double rz_out) {
-  verboseLevel = 2;
   if (verboseLevel > 3) {
     G4cout << " >>> G4CascadParticle::getPathToTheNextZone" << G4endl;
+  }
+  const G4LorentzVector& mom = getMomentum();
   G4double path = -1.0;
+  G4double rp = 0.0;
+  G4double rr = 0.0;
+  G4double pp = 0.0;
+  const G4CascadeMomentum& mom = theParticle.getMomentum();
+  for (G4int i = 1; i < 4; i++) {
+    rp += mom[i] * position[i - 1];
+    rr += position[i - 1] * position[i - 1];
+    pp += mom[i] * mom[i];
+  };
+  G4double rp = mom.vect().dot(position);
+  G4double rr = position.mag2();
+  G4double pp = mom.vect().mag2();
   G4double ra = rr - rp * rp / pp;
 …
     ds = 1.0;
     movingIn = false;
   } else {
     d2 = rz_in * rz_in - ra;
     if (d2 > 0.0) {
       ds = -1.0;
       movingIn = true;
     } else {
       d2 = rz_out * rz_out - ra;
       ds = 1.0;
       movingIn = false;
     };
   };
+    }
+  }
   path = ds * std::sqrt(d2) - rp / pp;
 …
 void G4CascadParticle::propagateAlongThePath(G4double path) {
   if (verboseLevel > 3) {
     G4cout << " >>> G4CascadParticle::propagateAlongThePath" << G4endl;
+  }
   const G4CascadeMomentum& mom = theParticle.getMomentum();
+  G4double pmod = theParticle.getMomModule();
+  position += getMomentum().vect().unit()*path;
+}
+  for(G4int i = 0; i < 3; i++) position[i] += mom[i + 1] * path / pmod;
+void G4CascadParticle::print() const {
+  theParticle.printParticle();
+  G4cout << " zone " << current_zone << " current_path " << current_path
+         << " reflectionCounter " << reflectionCounter << G4endl
+         << " x " << position.x() << " y " << position.y()
+         << " z " << position.z() << G4endl;
+}
+}

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeChannel.cc,v 1.7 2010/05/15 04:25:17 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100514  M. Kelsey -- All functionality removed except quantum-number
+//              validation functions.
 #include "G4CascadeChannel.hh"
+#include "Randomize.hh"
+std::pair<G4int, G4double>
+G4CascadeChannel::interpolateEnergy(G4double e)
+{
+  G4int index = 30;
+  G4double fraction = 0.0;
+  for (G4int i = 1; i < 31; i++) {
+    if (e < energyScale[i]) {
+      index = i-1;
+      fraction = (e - energyScale[index]) / (energyScale[i] - energyScale[index]);
+      break;
+    }
+  }
+  return std::pair<G4int, G4double>(index, fraction);
+}
+#include "G4ParticleDefinition.hh"
+#include <vector>
+G4int
+G4CascadeChannel::sampleFlat(std::vector<G4double> const& sigma)
+{
+  G4int i;
+  G4double sum(0.);
+  for (i = 0; i < G4int(sigma.size()); i++) sum += sigma[i];
+  G4double fsum = sum*G4UniformRand();
+  G4double partialSum = 0.0;
+  G4int channel = 0;
+  for (i = 0; i < G4int(sigma.size()); i++) {
+    partialSum += sigma[i];
+    if (fsum < partialSum) {
+      channel = i;
+      break;
+    }
+  }
+  return channel;
+}
+std::vector<G4int>
+G4CascadeChannel::getQnums(G4int type)
+{
+std::vector<G4int> G4CascadeChannel::getQnums(G4int type) {
   G4int bary=0, str=0, ch=0;
   std::vector<G4int> Qnums(3);
 …
+}
+void
+G4CascadeChannel::CheckQnums(const G4FastVector<G4ReactionProduct,256> &vec,
+                             G4int &vecLen,
+                             G4ReactionProduct &currentParticle,
+                             G4ReactionProduct &targetParticle,
+                             G4double Q, G4double B, G4double S) {
+  G4ParticleDefinition* projDef = currentParticle.GetDefinition();
+  G4ParticleDefinition* targDef = targetParticle.GetDefinition();
+  G4double chargeSum = projDef->GetPDGCharge() + targDef->GetPDGCharge();
+  G4double baryonSum = projDef->GetBaryonNumber() + targDef->GetBaryonNumber();
+  G4double strangenessSum = projDef->GetQuarkContent(3) -
+                            projDef->GetAntiQuarkContent(3) +
+                            targDef->GetQuarkContent(3) -
+                            targDef->GetAntiQuarkContent(3);
+  G4ParticleDefinition* secDef = 0;
+  for (G4int i = 0; i < vecLen; i++) {
+    secDef = vec[i]->GetDefinition();
+    chargeSum += secDef->GetPDGCharge();
+    baryonSum += secDef->GetBaryonNumber();
+    strangenessSum += secDef->GetQuarkContent(3)
+                    - secDef->GetAntiQuarkContent(3);
+  }
+const G4double G4CascadeChannel::energyScale[31] =
+  { 0.0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45,
+.5, 1.0,  1.5, 2.0,  2.5, 3.0,  3.5, 4.0,  4.5, 5.0,
+.5, 6.0,  6.5, 7.0,  7.5, 8.0,  8.5, 9.0,  9.5, 10.0, 15.0 };
+  G4bool OK = true;
+  if (chargeSum != Q) {
+    G4cout << " Charge not conserved " << G4endl;
+    OK = false;
+  }
+  if (baryonSum != B) {
+    G4cout << " Baryon number not conserved " << G4endl;
+    OK = false;
+  }
+  if (strangenessSum != S) {
+    G4cout << " Strangeness not conserved " << G4endl;
+    OK = false;
+  }
+  if (!OK) {
+    G4cout << " projectile: " << projDef->GetParticleName()
+           << "  target: " << targDef->GetParticleName() << G4endl;
+    for (G4int i = 0; i < vecLen; i++) {
+      secDef = vec[i]->GetDefinition();
+      G4cout << secDef->GetParticleName() << " " ;
+    }
+    G4cout << G4endl;
+  }
+}

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

-              r1196
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeInterface.cc,v 1.77 2010/05/21 18:07:30 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
+// 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
+// 20100414  M. Kelsey -- Check for K0L/K0S before using G4InuclElemPart::type
+// 20100418  M. Kelsey -- Reference output particle lists via const-ref, use
+//              const_iterator for both.
+// 20100428  M. Kelsey -- Use G4InuclParticleNames enum
+// 20100429  M. Kelsey -- Change "case gamma:" to "case photon:"
+// 20100517  M. Kelsey -- Follow new ctors for G4*Collider family.
+// 20100520  M. Kelsey -- Simplify collision loop, move momentum rotations to
+//              G4CollisionOutput, copy G4DynamicParticle directly from
+//              G4InuclParticle, no switch-block required.
 #include "G4CascadeInterface.hh"
 #include "globals.hh"
 #include "G4DynamicParticleVector.hh"
 #include "G4IonTable.hh"
+#include "G4CollisionOutput.hh"
+#include "G4DynamicParticle.hh"
 #include "G4InuclCollider.hh"
-// #include "G4IntraNucleiCascader.hh"
 #include "G4InuclElementaryParticle.hh"
 #include "G4InuclNuclei.hh"
 #include "G4InuclParticle.hh"
+#include "G4CollisionOutput.hh"
+#include "G4InuclParticleNames.hh"
+#include "G4KaonZeroShort.hh"
+#include "G4KaonZeroLong.hh"
+#include "G4LorentzRotation.hh"
+#include "G4Nucleus.hh"
+#include "G4ParticleDefinition.hh"
+#include "G4Track.hh"
 #include "G4V3DNucleus.hh"
+#include "G4Track.hh"
+#include "G4Nucleus.hh"
+#include "G4NucleiModel.hh"
+#include "G4LorentzRotation.hh"
+using namespace G4InuclParticleNames;
 //#define BERTDEV 1  // A flag to activate a development version of Bertini cascade
 typedef std::vector<G4InuclElementaryParticle>::iterator particleIterator;
 typedef std::vector<G4InuclNuclei>::iterator nucleiIterator;
+typedef std::vector<G4InuclElementaryParticle>::const_iterator particleIterator;
+typedef std::vector<G4InuclNuclei>::const_iterator nucleiIterator;
 G4CascadeInterface::G4CascadeInterface(const G4String& nam)
 …
   // NOTE: Geant4 units are MeV = 1 and GeV = 1000. Cascade code by default use GeV = 1.
+  enum particleType { nuclei = 0, proton = 1, neutron = 2, pionPlus = 3,
+                      pionMinus = 5, pionZero = 7, photon = 10,
+                      kaonPlus = 11, kaonMinus = 13, kaonZero = 15,
+                      kaonZeroBar = 17, lambda = 21, sigmaPlus = 23,
+                      sigmaZero = 25, sigmaMinus = 27, xiZero = 29, xiMinus = 31 };
+  G4int bulletType = 0;
+  // Coding particles
+  if (aTrack.GetDefinition() ==    G4Proton::Proton()    ) bulletType = proton;
+  if (aTrack.GetDefinition() ==   G4Neutron::Neutron()   ) bulletType = neutron;
+  if (aTrack.GetDefinition() ==  G4PionPlus::PionPlus()  ) bulletType = pionPlus;
+  if (aTrack.GetDefinition() == G4PionMinus::PionMinus() ) bulletType = pionMinus;
+  if (aTrack.GetDefinition() ==  G4PionZero::PionZero()  ) bulletType = pionZero;
+  if (aTrack.GetDefinition() ==     G4Gamma::Gamma()     ) bulletType = photon;
+  if (aTrack.GetDefinition() == G4KaonPlus::KaonPlus()     ) bulletType = kaonPlus;
+  if (aTrack.GetDefinition() == G4KaonMinus::KaonMinus()   ) bulletType = kaonMinus;
+  if (aTrack.GetDefinition() == G4Lambda::Lambda()         ) bulletType = lambda;
+  if (aTrack.GetDefinition() == G4SigmaPlus::SigmaPlus()   ) bulletType = sigmaPlus;
+  if (aTrack.GetDefinition() == G4SigmaZero::SigmaZero()   ) bulletType = sigmaZero;
+  if (aTrack.GetDefinition() == G4SigmaMinus::SigmaMinus() ) bulletType = sigmaMinus;
+  if (aTrack.GetDefinition() == G4XiZero::XiZero()         ) bulletType = xiZero;
+  if (aTrack.GetDefinition() == G4XiMinus::XiMinus()       ) bulletType = xiMinus;
+  G4int bulletType;
   if (aTrack.GetDefinition() == G4KaonZeroLong::KaonZeroLong() ||
+      aTrack.GetDefinition() == G4KaonZeroShort::KaonZeroShort() ) {
+    if (G4UniformRand() > 0.5) {
+      bulletType = kaonZero;
+    } else {
+      bulletType = kaonZeroBar;
+    }
+  }
+      aTrack.GetDefinition() == G4KaonZeroShort::KaonZeroShort() )
+    bulletType = (G4UniformRand() > 0.5) ? kaonZero : kaonZeroBar;
+  else
+    bulletType = G4InuclElementaryParticle::type(aTrack.GetDefinition());
   // Code momentum and energy.
-  G4double px,py,pz;
-  px=aTrack.Get4Momentum().px() / GeV;
-  py=aTrack.Get4Momentum().py() / GeV;
-  pz=aTrack.Get4Momentum().pz() / GeV;
   G4LorentzVector projectileMomentum = aTrack.Get4Momentum();
   G4LorentzRotation toZ;
 …
   G4LorentzRotation toLabFrame = toZ.inverse();
+  G4CascadeMomentum momentumBullet;
+  momentumBullet[0] =0.;
+  momentumBullet[1] =0;
+  momentumBullet[2] =0;
+  momentumBullet[3] =std::sqrt(px*px+py*py+pz*pz);
+  G4InuclElementaryParticle *  bullet = new G4InuclElementaryParticle(momentumBullet, bulletType);
+  G4LorentzVector momentumBullet(0., 0., aTrack.GetTotalMomentum()/GeV,
+                                 aTrack.GetTotalEnergy()/GeV);
+  G4InuclElementaryParticle* bullet =
+    new G4InuclElementaryParticle(momentumBullet, bulletType);
   sumEnergy = bullet->getKineticEnergy(); // In GeV
+  if (bulletType == proton || bulletType == neutron || bulletType == lambda ||
+      bulletType == sigmaPlus || bulletType == sigmaZero || bulletType == sigmaMinus ||
+      bulletType == xiZero || bulletType == xiMinus) {
+    sumBaryon += 1;
+  }
+  sumBaryon += bullet->baryon();        // Returns baryon number (0, 1, or 2)
   // Set target
   G4InuclNuclei*   target  = 0;
   G4InuclParticle* targetH = 0;
-  // and outcoming particles
-  G4DynamicParticle* cascadeParticle = 0;
-  G4CascadeMomentum targetMomentum;
   G4double theNucleusA = theNucleus.GetN();
+  if ( !(G4int(theNucleusA) == 1) ) {
+    target  = new G4InuclNuclei(targetMomentum,
+                                theNucleusA,
+                                theNucleus.GetZ());
+    target->setEnergy();
+    const G4CascadeMomentum& bmom = bullet->getMomentum();
+    eInit = std::sqrt(bmom[0] * bmom[0]);
+    const G4CascadeMomentum& tmom = target->getMomentum();
+    eInit += std::sqrt(tmom[0] * tmom[0]);
+  if ( G4int(theNucleusA) != 1 ) {
+    target  = new G4InuclNuclei(theNucleusA, theNucleus.GetZ());
+    eInit = bullet->getEnergy() + target->getEnergy();
     sumBaryon += theNucleusA;
 …
   // Colliders initialisation
+  //  G4ElementaryParticleCollider*   colep = new G4ElementaryParticleCollider;
+  //  G4IntraNucleiCascader*            inc = new G4IntraNucleiCascader; // the actual cascade
+  //  inc->setInteractionCase(1); // Interaction type is particle with nuclei.
+  inc.setInteractionCase(1); // Interaction type is particle with nuclei.
+  //  G4NonEquilibriumEvaporator*     noneq = new G4NonEquilibriumEvaporator;
+  //  G4EquilibriumEvaporator*         eqil = new G4EquilibriumEvaporator;
+  //  G4Fissioner*                     fiss = new G4Fissioner;
+  //  G4BigBanger*                     bigb = new G4BigBanger;
+  G4InuclCollider* collider = new G4InuclCollider(&colep, &inc, &noneq, &eqil, &fiss, &bigb);
+      G4int  maxTries = 100; // maximum tries for inelastic collision to avoid infinite loop
+      G4int  nTries   = 0;  // try counter
+  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)
+        targetH = new G4InuclElementaryParticle(targetMomentum, 1);
+        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[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[3] > cutElastic[bulletType]) { // inelastic collision possible
+          do {   // we try to create inelastic interaction
+            output = collider->collide(bullet, targetH);
+            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
+          output = collider->collide(bullet, targetH);
+  G4int coulombOK =0;  // flag for correct Coulomb barrier
+#endif
+  if (G4int(theNucleusA) == 1) { // special treatment for target H(1,1) (proton)
+    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;
+          }
+        }
+        sumBaryon += 1;
+        const G4CascadeMomentum& bmom = bullet->getMomentum();
+        eInit = std::sqrt(bmom[0] * bmom[0]);
+        const G4CascadeMomentum& tmom = targetH->getMomentum();
+        eInit += std::sqrt(tmom[0] * tmom[0]);
+        if (verboseLevel > 2) {
+          G4cout << "Target:  " << G4endl;
+          targetH->printParticle();
+        }
+      } else {  // treat all other targets excepet H(1,1)
+        do  // we try to create inelastic interaction
+          {
+      }
+#endif
+    } while(
+            (nTries < maxTries) &&  // conditions for next try
+            (output.getOutgoingParticles().size()!=0) &&
 #ifdef BERTDEV
+            coulombOK=0;  // by default coulomb analysis is OK
+#endif
+            output = collider->collide(bullet, target );
+            nTries++;
+#ifdef BERTDEV
+            G4double coulumbBarrier = 8.7 * MeV;
+            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;
+                }
+              }
+            }
+          } while(
+                  (nTries < maxTries) &&  // conditions for next try
+                  (coulombOK==1) &&
+                  ((output.getOutgoingParticles().size() + output.getNucleiFragments().size()) > 2.5) &&
+                  (output.getOutgoingParticles().size()!=0)
+                  );
+            (coulombOK==1) &&
+            ((output.getOutgoingParticles().size() + output.getNucleiFragments().size()) > 2.5)
 #else
+          } while(
+                   (nTries < maxTries)                                                               &&
+                   (output.getOutgoingParticles().size() + output.getNucleiFragments().size() < 2.5) &&
+                   (output.getOutgoingParticles().size()!=0) &&
+                   (output.getOutgoingParticles().begin()->type()==bullet->type())
+                   );
+#endif
+     }
+  if (verboseLevel > 1)
+    {
+      G4cout << " Cascade output: " << G4endl;
+      output.printCollisionOutput();
+    }
+            ((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
   std::vector<G4InuclNuclei>             nucleiFragments = output.getNucleiFragments();
   std::vector<G4InuclElementaryParticle> particles =       output.getOutgoingParticles();
+  const std::vector<G4InuclNuclei>& nucleiFragments = output.getNucleiFragments();
+  const std::vector<G4InuclElementaryParticle>& particles = output.getOutgoingParticles();
   theResult.SetStatusChange(stopAndKill);
+  // Get outcoming particles
+  G4DynamicParticle* cascadeParticle = 0;
   if (!particles.empty()) {
+    particleIterator ipart;
+    G4int outgoingParticle;
+    for (ipart = particles.begin(); ipart != particles.end(); ipart++) {
+      outgoingParticle = ipart->type();
+      const G4CascadeMomentum& mom = ipart->getMomentum();
+      eTot   += std::sqrt(mom[0] * mom[0]);
+      G4double ekin = ipart->getKineticEnergy() * GeV;
+      G4ThreeVector aMom(mom[1], mom[2], mom[3]);
+      aMom = aMom.unit();
+      if (ipart->baryon() ) {
+        sumBaryon -= 1;
+    particleIterator ipart = particles.begin();
+    for (; ipart != particles.end(); ipart++) {
+      G4int outgoingType = ipart->type();
+      eTot += ipart->getEnergy();
+      sumBaryon -= ipart->baryon();
+      sumEnergy -= ipart->getKineticEnergy();
+      if (!ipart->valid() || ipart->quasi_deutron()) {
+        G4cerr << " ERROR: G4CascadeInterface::Propagate incompatible"
+               << " particle type " << outgoingType << G4endl;
+        continue;
+      }
+      sumEnergy -= ekin / GeV;
+      switch(outgoingParticle) {
+      case proton:
+#ifdef debug_G4CascadeInterface
+        G4cerr << "proton " << counter << " " << aMom << " " << ekin << G4endl;
+#endif
+        cascadeParticle =
+          new G4DynamicParticle(G4Proton::ProtonDefinition(), aMom, ekin);
+        break;
+      case neutron:
+#ifdef debug_G4CascadeInterface
+        G4cerr << "neutron "<< counter<<" "<<aMom<<" "<<  ekin<<G4endl;
+#endif
+        cascadeParticle =
+          new G4DynamicParticle(G4Neutron::NeutronDefinition(), aMom, ekin);
+        break;
+      case pionPlus:
+        cascadeParticle =
+          new G4DynamicParticle(G4PionPlus::PionPlusDefinition(), aMom, ekin);
+#ifdef debug_G4CascadeInterface
+        G4cerr << "pionPlus "<< counter<<" "<<aMom<<" "<<  ekin<<G4endl;
+#endif
+        break;
+      case pionMinus:
+        cascadeParticle =
+          new G4DynamicParticle(G4PionMinus::PionMinusDefinition(), aMom, ekin);
+#ifdef debug_G4CascadeInterface
+        G4cerr << "pionMinus "<< counter<<" "<<aMom<<" "<<  ekin<<G4endl;
+#endif
+        break;
+      case pionZero:
+        cascadeParticle =
+          new G4DynamicParticle(G4PionZero::PionZeroDefinition(), aMom, ekin);
+#ifdef debug_G4CascadeInterface
+        G4cerr << "pionZero "<< counter<<" "<<aMom<<" "<<  ekin<<G4endl;
+#endif
+        break;
+      case photon:
+        cascadeParticle =
+          new G4DynamicParticle(G4Gamma::Gamma(), aMom, ekin);
+#ifdef debug_G4CascadeInterface
+        G4cerr << "photon "<< counter<<" "<<aMom<<" "<<  ekin<<G4endl;
+#endif
+        break;
+      case kaonPlus:
+        cascadeParticle =
+          new G4DynamicParticle(G4KaonPlus::KaonPlusDefinition(), aMom, ekin);
+        break;
+      case kaonMinus:
+        cascadeParticle =
+         new G4DynamicParticle(G4KaonMinus::KaonMinusDefinition(), aMom, ekin);
+        break;
+      case kaonZero:
+        if (G4UniformRand() > 0.5) {
+          cascadeParticle = new G4DynamicParticle(
+                              G4KaonZeroLong::KaonZeroLongDefinition(),
+                              aMom, ekin);
+        } else {
+          cascadeParticle = new G4DynamicParticle(
+                              G4KaonZeroShort::KaonZeroShortDefinition(),
+                              aMom, ekin);
+        }
+        break;
+      case kaonZeroBar:
+        if (G4UniformRand() > 0.5) {
+          cascadeParticle = new G4DynamicParticle(
+                              G4KaonZeroLong::KaonZeroLongDefinition(),
+                              aMom, ekin);
+        } else {
+          cascadeParticle = new G4DynamicParticle(
+                              G4KaonZeroShort::KaonZeroShortDefinition(),
+                              aMom, ekin);
+        }
+        break;
+      case lambda:
+        cascadeParticle =
+         new G4DynamicParticle(G4Lambda::LambdaDefinition(), aMom, ekin);
+        break;
+      case sigmaPlus:
+        cascadeParticle =
+         new G4DynamicParticle(G4SigmaPlus::SigmaPlusDefinition(), aMom, ekin);
+        break;
+      case sigmaZero:
+        cascadeParticle =
+         new G4DynamicParticle(G4SigmaZero::SigmaZeroDefinition(), aMom, ekin);
+        break;
+      case sigmaMinus:
+        cascadeParticle =
+         new G4DynamicParticle(G4SigmaMinus::SigmaMinusDefinition(), aMom, ekin);
+        break;
+      case xiZero:
+        cascadeParticle =
+         new G4DynamicParticle(G4XiZero::XiZeroDefinition(), aMom, ekin);
+        break;
+      case xiMinus:
+        cascadeParticle =
+         new G4DynamicParticle(G4XiMinus::XiMinusDefinition(), aMom, ekin);
+        break;
+      default:
+        G4cout << " ERROR: G4CascadeInterface::Propagate undefined particle type"
+               << G4endl;
+      // Copy local G4DynPart to public output (handle kaon mixing specially)
+      if (outgoingType == kaonZero || outgoingType == kaonZeroBar) {
+        G4ThreeVector momDir = ipart->getMomentum().vect().unit();
+        G4double ekin = ipart->getKineticEnergy();
+        G4ParticleDefinition* pd = G4KaonZeroShort::Definition();
+        if (G4UniformRand() > 0.5) pd = G4KaonZeroLong::Definition();
+        cascadeParticle = new G4DynamicParticle(pd, momDir, ekin);
+      } else {
+        cascadeParticle = new G4DynamicParticle(ipart->getDynamicParticle());
+      }
-      cascadeParticle->Set4Momentum(cascadeParticle->Get4Momentum()*=toLabFrame);
       theResult.AddSecondary(cascadeParticle);
+    }
 …
   // get nuclei fragments
   G4DynamicParticle * aFragment = 0;
-  G4ParticleDefinition * aIonDef = 0;
-  G4ParticleTable *theTableOfParticles = G4ParticleTable::GetParticleTable();
   if (!nucleiFragments.empty()) {
+    nucleiIterator ifrag;
+    for (ifrag = nucleiFragments.begin(); ifrag != nucleiFragments.end(); ifrag++)
+      {
+        G4double eKin = ifrag->getKineticEnergy() * GeV;
+        const G4CascadeMomentum& mom = ifrag->getMomentum();
+        eTot   += std::sqrt(mom[0] * mom[0]);
+        G4ThreeVector aMom(mom[1], mom[2], mom[3]);
+        aMom = aMom.unit();
+        // hpw @@@ ==> Should be zero: G4double fragmentExitation = ifrag->getExitationEnergyInGeV();
+        if (verboseLevel > 2) {
+          G4cout << " Nuclei fragment: " << G4endl;
+          ifrag->printParticle();
+        }
+        G4int A = G4int(ifrag->getA());
+        G4int Z = G4int(ifrag->getZ());
+        aIonDef = theTableOfParticles->FindIon(Z, A, 0, Z);
+        aFragment =  new G4DynamicParticle(aIonDef, aMom, eKin);
+        sumBaryon -= A;
+        sumEnergy -= eKin / GeV;
+        aFragment->Set4Momentum(aFragment->Get4Momentum()*=toLabFrame);
+        theResult.AddSecondary(aFragment);
+    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 (verboseLevel > 2) {
+        G4cout << " Nuclei fragment: " << G4endl;
+        ifrag->printParticle();
+      }
+  }
+      // Copy local G4DynPart to public output
+      aFragment =  new G4DynamicParticle(ifrag->getDynamicParticle());
+      theResult.AddSecondary(aFragment);
+    }
+  }
+  // Report violations of energy, baryon conservation
   if (verboseLevel > 2) {
     if (sumBaryon != 0) {
 …
   delete bullet;
-//  delete inc;
   delete collider;
   if(target != 0) delete target;
   if(targetH != 0) delete targetH;
- // if(cascadeParticle != 0) delete cascadeParticle;
- // if(aFragment != 0) delete aFragment;
   return &theResult;

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

-              r962
+              r1315
 namespace {
-  // Total cross section as a function of kinetic energy
-  G4double kmntot[31];
-  // Multiplicities as a function of kinetic energy
-  G4double kmnMultiplicities[6][31];
-  const G4int kmnindex[6][2] =
-    {{0, 5}, {5, 20}, {20, 48}, {48, 90}, {90, 110}, {110, 121}};
   // Outgoing particle types of a given multiplicity
   const G4int kmn2bfs[5][2] =
+  static const G4int kmn2bfs[5][2] =
     {{2, 13}, {5, 21}, {5, 25}, {7, 27}, {15, 31} };
   const G4int kmn3bfs[15][3] =
+  static const G4int kmn3bfs[15][3] =
     {{1,5,13},   {2,7,13},   {2,5,17},   {5,7,21},   {5,5,23},
      {5,7,25},   {7,7,27},   {3,5,27},   {13,15,21}, {13,15,25},
      {15,17,27}, {11,13,27}, {5,15,29},  {7,15,31},  {5,11,31} };
   const G4int kmn4bfs[28][4] =
+  static const G4int kmn4bfs[28][4] =
     {{1,5,7,13},   {1,5,5,17},   {2,7,7,13},   {2,3,5,13},
      {2,5,7,17},   {5,7,7,21},   {3,5,5,21},   {5,5,7,23},
 …
      {5,5,11,29},  {7,7,15,31},  {3,5,15,31},  {5,7,11,31} };
   const G4int kmn5bfs[42][5] =
+  static const G4int kmn5bfs[42][5] =
     {{1,5,7,7,13},   {1,3,5,5,13},   {1,5,5,7,17},   {2,7,7,7,13},
      {2,3,5,7,13},   {2,5,7,7,17},   {2,3,5,5,17},   {5,7,7,7,21},
 …
      {5,7,7,11,31},  {3,5,5,11,31} };
   const G4int kmn6bfs[20][6] =
+  static const G4int kmn6bfs[20][6] =
     {{1,5,7,7,7,13}, {1,3,5,5,7,13}, {1,5,5,7,7,17}, {1,3,5,5,5,17},
      {2,7,7,7,7,13}, {2,3,5,7,7,13}, {2,3,3,5,5,13}, {2,5,7,7,7,17},
 …
      {3,3,5,5,5,25}, {7,7,7,7,7,27}, {3,5,7,7,7,27}, {3,3,5,5,7,27} };
   const G4int kmn7bfs[11][7] =
+  static const G4int kmn7bfs[11][7] =
     {{1,5,7,7,7,7,13}, {1,3,5,5,7,7,13}, {1,3,3,5,5,5,13},
      {1,5,5,7,7,7,17}, {1,3,5,5,5,7,17}, {2,7,7,7,7,7,13},
 …
   // second index: kinetic energy
   //
   const G4float kmnCrossSections[121][31] = {
+  static const G4double kmnCrossSections[121][31] = {
     //
     // multiplicity 2 (5 channels)
 …
 G4CascadeKminusNChannelData::data_t
+G4CascadeKminusNChannelData::data = { kmntot,
+                                      kmnMultiplicities,
+                                      kmnindex,
+                                      kmn2bfs,
+                                      kmn3bfs,
+                                      kmn4bfs,
+                                      kmn5bfs,
+                                      kmn6bfs,
+                                      kmn7bfs,
+                                      kmnCrossSections };
+namespace {
+  struct initializer
+  {
+    initializer() { G4CascadeKminusNChannelData::data.initialize(); }
+  };
+  initializer init;
+}
+G4CascadeKminusNChannelData::data(kmn2bfs, kmn3bfs, kmn4bfs,
+                                  kmn5bfs, kmn6bfs, kmn7bfs,
+                                  kmnCrossSections);

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

-              r962
+              r1315
 namespace {
-  // Total cross section as a function of kinetic energy
-  G4double kmptot[31];
-  // Multiplicities as a function of kinetic energy
-  G4double kmpMultiplicities[6][31];
-  const G4int kmpindex[6][2] =
-    {{0, 8}, {8, 28}, {28, 62}, {62, 110}, {110, 132}, {132, 148}};
   // Outgoing particle types of a given multiplicity
   const G4int kmp2bfs[8][2] =
+  static const G4int kmp2bfs[8][2] =
     {{1, 13}, {2, 17}, {7, 21},  {5, 23},
      {7, 25}, {3, 27}, {15, 29}, {11, 31} };
   const G4int kmp3bfs[20][3] =
+  static const G4int kmp3bfs[20][3] =
     {{1,7,13},   {1,5,17},   {2,3,13},   {2,7,17},   {7,7,21},
      {3,5,21},   {11,13,21}, {15,17,21}, {5,7,23},   {13,15,23},
 …
      {11,17,27}, {7,15,29},  {5,11,29},  {3,15,31},  {7,11,31} };
   const G4int kmp4bfs[34][4] =
+  static const G4int kmp4bfs[34][4] =
     {{1,7,7,13},   {1,3,5,13},   {1,5,7,17},   {2,3,7,13},
      {2,7,7,17},   {2,3,5,17},   {7,7,7,21},   {3,5,7,21},
 …
      {7,7,11,31},  {3,5,11,31} };
   const G4int kmp5bfs[48][5] =
+  static const G4int kmp5bfs[48][5] =
     {{1,7,7,7,13},   {1,3,5,7,13},   {1,5,7,7,17},   {1,3,5,5,17},
      {2,3,7,7,13},   {2,3,3,5,13},   {2,7,7,7,17},   {2,3,5,7,17},
 …
      {7,7,7,11,31},  {3,5,7,11,31},  {3,7,7,15,31},  {3,3,5,15,31} };
   const G4int kmp6bfs[22][6] =
+  static const G4int kmp6bfs[22][6] =
     {{1,7,7,7,7,13}, {1,3,5,7,7,13}, {1,3,3,5,5,13}, {1,5,7,7,7,17},
      {1,3,5,5,7,17}, {2,3,7,7,7,13}, {2,3,3,5,7,13}, {2,7,7,7,7,17},
 …
      {3,3,5,7,7,27}, {3,3,3,5,5,27} };
   const G4int kmp7bfs[16][7] =
+  static const G4int kmp7bfs[16][7] =
     {{1,7,7,7,7,7,13}, {1,3,5,7,7,7,13}, {1,3,3,5,5,7,13},
      {1,5,7,7,7,7,17}, {1,3,5,5,7,7,17}, {1,3,3,5,5,5,17},
 …
   // second index: kinetic energy
   //
   const G4float kmpCrossSections[148][31] = {
+  static const G4double kmpCrossSections[148][31] = {
     //
     // multiplicity 2 (8 channels)
 …
 G4CascadeKminusPChannelData::data_t
+G4CascadeKminusPChannelData::data = { kmptot,
+                                      kmpMultiplicities,
+                                      kmpindex,
+                                      kmp2bfs,
+                                      kmp3bfs,
+                                      kmp4bfs,
+                                      kmp5bfs,
+                                      kmp6bfs,
+                                      kmp7bfs,
+                                      kmpCrossSections };
+namespace {
+  struct initializer
+  {
+    initializer() { G4CascadeKminusPChannelData::data.initialize(); }
+  };
+  initializer init;
+}
+G4CascadeKminusPChannelData::data(kmp2bfs, kmp3bfs, kmp4bfs,
+                                  kmp5bfs, kmp6bfs, kmp7bfs,
+                                  kmpCrossSections);

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

-              r962
+              r1315
 namespace {
-  // Total cross section as a function of kinetic energy
-  G4double kpntot[31];
-  // Multiplicities as a function of kinetic energy
-  G4double kpnMultiplicities[6][31];
-  const G4int kpnindex[6][2] =
-    {{0, 2}, {2, 7}, {7,20}, {20,42}, {42,74}, {74,115}};
   // Outgoing particle types of a given multiplicity
   const G4int kpn2bfs[2][2] =
+  static const G4int kpn2bfs[2][2] =
     {{2,11}, {1,15}};
   const G4int kpn3bfs[5][3] =
+  static const G4int kpn3bfs[5][3] =
     {{2,7,11}, {1,5,11}, {2,3,15}, {1,7,15}, {11,15,21}};
   const G4int kpn4bfs[13][4] =
+  static const G4int kpn4bfs[13][4] =
     {{2,7,7,11},   {2,3,5,11},   {1,5,7,11},   {2,3,7,15},   {1,7,7,15},
      {1,3,5,15},   {2,11,11,13}, {2,11,15,17}, {1,15,15,17}, {1,11,13,15},
      {7,11,15,21}, {5,11,11,21}, {3,15,15,21}};
   const G4int kpn5bfs[22][5] =
+  static const G4int kpn5bfs[22][5] =
     {{2,11,7,7,7},   {2,3,5,7,11},   {1,5,7,7,11},   {1,3,5,5,11},
      {2,3,7,7,15},   {2,3,3,5,15},   {1,7,7,7,15},   {1,3,5,7,15},
 …
      {5,7,11,11,21}, {3,7,15,15,21}};
   const G4int kpn6bfs[32][6] =
+  static const G4int kpn6bfs[32][6] =
     {{2,7,7,7,7,11},   {2,3,5,7,7,11},   {2,3,3,5,5,11},   {1,5,7,7,7,11},
      {1,3,5,5,7,11},   {2,3,7,7,7,15},   {2,3,3,5,7,15},   {1,7,7,7,7,15},
 …
      {5,7,7,11,11,21}, {3,5,5,11,11,21}, {3,7,7,15,15,21}, {3,3,5,15,15,21}};
   const G4int kpn7bfs[41][7] =
+  static const G4int kpn7bfs[41][7] =
     {{2,7,7,7,7,7,11},   {2,3,5,7,7,7,11},   {2,3,3,5,5,7,11},
      {1,5,7,7,7,7,11},   {1,3,5,5,7,7,11},   {1,3,3,5,5,5,11},
 …
   // second index: kinetic energy
   //
   const G4float kpnCrossSections[115][31] = {
+  static const G4double kpnCrossSections[115][31] = {
     //
     // multiplicity 2 (2 channels)
 …
 G4CascadeKplusNChannelData::data_t
+G4CascadeKplusNChannelData::data = { kpntot,
+                                     kpnMultiplicities,
+                                     kpnindex,
+                                     kpn2bfs,
+                                     kpn3bfs,
+                                     kpn4bfs,
+                                     kpn5bfs,
+                                     kpn6bfs,
+                                     kpn7bfs,
+                                     kpnCrossSections };
+namespace {
+  struct initializer
+  {
+    initializer() { G4CascadeKplusNChannelData::data.initialize(); }
+  };
+  initializer init;
+}
+G4CascadeKplusNChannelData::data(kpn2bfs, kpn3bfs, kpn4bfs,
+                                 kpn5bfs, kpn6bfs, kpn7bfs,
+                                 kpnCrossSections);

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

-              r962
+              r1315
 namespace {
-  // Total cross section as a function of kinetic energy
-  G4double kpptot[31];
-  // Multiplicities as a function of kinetic energy
-  G4double kppMultiplicities[6][31];
-  const G4int kppindex[6][2] =
-    {{0, 1}, {1, 5}, {5,15}, {15,34}, {34,62}, {62,100}};
   // Outgoing particle types of a given multiplicity
   const G4int kpp2bfs[1][2] =
+  static const G4int kpp2bfs[1][2] =
     {{1, 11}};
   const G4int kpp3bfs[4][3] =
+  static const G4int kpp3bfs[4][3] =
     {{1,7,11}, {2,3,11}, {1,3,15}, {11,11,21}};
   const G4int kpp4bfs[10][4] =
+  static const G4int kpp4bfs[10][4] =
     {{1,7,7,11},  {1,3,5,11},  {2,3,7,11},  {1,3,7,15},  {2,3,3,15},
      {1,11,15,17},{1,11,11,13},{2,11,11,17},{7,11,11,21},{3,11,15,21}};
   const G4int kpp5bfs[19][5] =
+  static const G4int kpp5bfs[19][5] =
     {{1,7,7,7,11},   {1,3,5,7,11},   {2,3,7,7,11},   {2,3,3,5,11},
      {1,3,7,7,15},   {1,3,3,5,15},   {2,3,3,7,15},   {1,7,11,15,17},
 …
      {3,5,11,11,21}, {3,7,11,15,21}, {3,3,15,15,21}};
   const G4int kpp6bfs[28][6] =
+  static const G4int kpp6bfs[28][6] =
     {{1,7,7,7,7,11},   {1,3,5,7,7,11},   {1,3,3,5,5,11},
      {2,3,7,7,7,11},   {2,3,3,5,7,11},   {1,3,7,7,7,15},
 …
      {3,3,7,15,15,21}};
   const G4int kpp7bfs[38][7] =
+  static const G4int kpp7bfs[38][7] =
     {{1,7,7,7,7,7,11},   {1,3,5,7,7,7,11},   {1,3,3,5,5,7,11},
      {2,3,7,7,7,7,11},   {2,3,3,5,7,7,11},   {2,3,3,3,5,5,11},
 …
   // second index: kinetic energy
   //
   const G4float kppCrossSections[100][31] = {
+  static const G4double kppCrossSections[100][31] = {
     //
     // multiplicity 2 (1 channel)
 …
 G4CascadeKplusPChannelData::data_t
+G4CascadeKplusPChannelData::data = { kpptot,
+                                     kppMultiplicities,
+                                     kppindex,
+                                     kpp2bfs,
+                                     kpp3bfs,
+                                     kpp4bfs,
+                                     kpp5bfs,
+                                     kpp6bfs,
+                                     kpp7bfs,
+                                     kppCrossSections };
+namespace {
+  struct initializer
+  {
+    initializer() { G4CascadeKplusPChannelData::data.initialize(); }
+  };
+  initializer init;
+}
+G4CascadeKplusPChannelData::data(kpp2bfs, kpp3bfs, kpp4bfs,
+                                 kpp5bfs, kpp6bfs, kpp7bfs,
+                                 kppCrossSections);

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+//
+// $Id: G4CascadeKzeroBarNChannel.cc,v 1.5 2010/05/16 05:18:36 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 #include "G4CascadeKzeroBarNChannel.hh"
 namespace {
-  // Total cross section as a function of kinetic energy
-  G4double kzbntot[31];
-  // Multiplicities as a function of kinetic energy
-  G4double kzbnMultiplicities[6][31];
-  const G4int kzbnindex[6][2] =
-    {{0, 8}, {8, 28}, {28, 62}, {62, 110}, {110, 132}, {132, 148}};
   // Outgoing particle types of a given multiplicity
   const G4int kzbn2bfs[8][2] =
+  static const G4int kzbn2bfs[8][2] =
     {{2, 17}, {1, 13}, {7, 21},  {5, 23},
      {7, 25}, {3, 27}, {15, 29}, {11, 31} };
   const G4int kzbn3bfs[20][3] =
+  static const G4int kzbn3bfs[20][3] =
     {{2,7,17},   {2,3,13},   {1,5,17},   {1,7,13},   {7,7,21},
      {3,5,21},   {11,13,21}, {15,17,21}, {5,7,23},   {13,15,23},
 …
      {11,17,27}, {7,15,29},  {5,11,29},  {3,15,31},  {7,11,31} };
   const G4int kzbn4bfs[34][4] =
+  static const G4int kzbn4bfs[34][4] =
     {{2,7,7,17},   {2,3,5,17},   {2,3,7,13},   {1,5,7,17},
      {1,7,7,13},   {1,3,5,13},   {7,7,7,21},   {3,5,7,21},
 …
      {7,7,11,31},  {3,5,11,31} };
   const G4int kzbn5bfs[48][5] =
+  static const G4int kzbn5bfs[48][5] =
     {{2,7,7,7,17},   {2,3,5,7,17},   {2,3,7,7,13},   {2,3,3,5,13},
      {1,5,7,7,17},   {1,3,5,5,17},   {1,7,7,7,13},   {1,3,5,7,13},
 …
      {7,7,7,11,31},  {3,5,7,11,31},  {3,7,7,15,31},  {3,3,5,15,31} };
   const G4int kzbn6bfs[22][6] =
+  static const G4int kzbn6bfs[22][6] =
     {{2,7,7,7,7,17}, {2,3,5,7,7,17}, {2,3,3,5,5,17}, {2,3,7,7,7,13},
      {2,3,3,5,7,13}, {1,5,7,7,7,17}, {1,3,5,5,7,17}, {1,7,7,7,7,13},
 …
      {3,3,5,7,7,27}, {3,3,3,5,5,27} };
   const G4int kzbn7bfs[16][7] =
+  static const G4int kzbn7bfs[16][7] =
     {{2,7,7,7,7,7,17}, {2,3,5,7,7,7,17}, {2,3,3,5,5,7,17},
      {2,3,7,7,7,7,13}, {2,3,3,5,7,7,13}, {2,3,3,3,5,5,13},
 …
   // second index: kinetic energy
   //
   const G4float kzbnCrossSections[148][31] = {
+  static const G4double kzbnCrossSections[148][31] = {
     //
     // multiplicity 2 (8 channels)
 …
 G4CascadeKzeroBarNChannelData::data_t
+G4CascadeKzeroBarNChannelData::data = { kzbntot,
+                                        kzbnMultiplicities,
+                                        kzbnindex,
+                                        kzbn2bfs,
+                                        kzbn3bfs,
+                                        kzbn4bfs,
+                                        kzbn5bfs,
+                                        kzbn6bfs,
+                                        kzbn7bfs,
+                                        kzbnCrossSections };
+namespace {
+  struct initializer
+  {
+    initializer() { G4CascadeKzeroBarNChannelData::data.initialize(); }
+  };
+  initializer init;
+}
+G4CascadeKzeroBarNChannelData::data(kzbn2bfs, kzbn3bfs, kzbn4bfs,
+                                    kzbn5bfs, kzbn6bfs, kzbn7bfs,
+                                    kzbnCrossSections);

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

-              r962
+              r1315
 namespace {
-  // Total cross section as a function of kinetic energy
-  G4double kzbptot[31];
-  // Multiplicities as a function of kinetic energy
-  G4double kzbpMultiplicities[6][31];
-  const G4int kzbpindex[6][2] =
-    {{0, 5}, {5, 20}, {20, 48}, {48, 90}, {90, 110}, {110, 121}};
   // Outgoing particle types of a given multiplicity
   const G4int kzbp2bfs[5][2] =
+  static const G4int kzbp2bfs[5][2] =
     {{1, 17}, {3, 21}, {3, 25}, {7, 23}, {11, 29} };
   const G4int kzbp3bfs[15][3] =
+  static const G4int kzbp3bfs[15][3] =
     {{2,3,17},   {1,7,17},   {1,3,13},   {3,7,21},   {11,17,21},
      {3,3,27},   {3,7,25},   {7,7,23},   {3,5,23},   {11,17,25},
      {15,17,23}, {11,13,23}, {3,11,31},  {7,11,29},  {3,15,29} };
   const G4int kzbp4bfs[28][4] =
+  static const G4int kzbp4bfs[28][4] =
     {{2,3,7,17},   {2,3,3,13},   {1,7,7,17},   {1,3,5,17},
      {1,3,7,13},   {3,7,7,21},   {3,3,5,21},   {7,11,17,21},
 …
      {3,3,15,31},  {7,7,11,29},  {3,5,11,29},  {3,7,15,29} };
   const G4int kzbp5bfs[42][5] =
+  static const G4int kzbp5bfs[42][5] =
     {{2,3,7,7,17},   {2,3,3,5,17},   {2,3,3,7,13},   {1,7,7,7,17},
      {1,3,5,7,17},   {1,3,7,7,13},   {1,3,3,5,13},   {3,7,7,7,21},
 …
      {3,7,7,15,29},  {3,3,5,15,29} };
   const G4int kzbp6bfs[20][6] =
+  static const G4int kzbp6bfs[20][6] =
     {{2,3,7,7,7,17}, {2,3,3,5,7,17}, {2,3,3,7,7,13}, {2,3,3,3,5,13},
      {1,7,7,7,7,17}, {1,3,5,7,7,17}, {1,3,3,5,5,17}, {1,3,7,7,7,13},
 …
      {3,3,3,5,5,25}, {7,7,7,7,7,23}, {3,5,7,7,7,23}, {3,3,5,5,7,23} };
   const G4int kzbp7bfs[11][7] =
+  static const G4int kzbp7bfs[11][7] =
     {{2,3,7,7,7,7,17}, {2,3,3,5,7,7,17}, {2,3,3,3,5,5,17},
      {2,3,3,7,7,7,13}, {2,3,3,3,5,7,13}, {1,7,7,7,7,7,17},
 …
   // second index: kinetic energy
   //
   const G4float kzbpCrossSections[121][31] = {
+  static const G4double kzbpCrossSections[121][31] = {
     //
     // multiplicity 2 (5 channels)
 …
 G4CascadeKzeroBarPChannelData::data_t
+G4CascadeKzeroBarPChannelData::data = { kzbptot,
+                                        kzbpMultiplicities,
+                                        kzbpindex,
+                                        kzbp2bfs,
+                                        kzbp3bfs,
+                                        kzbp4bfs,
+                                        kzbp5bfs,
+                                        kzbp6bfs,
+                                        kzbp7bfs,
+                                        kzbpCrossSections };
+namespace {
+  struct initializer
+  {
+    initializer() { G4CascadeKzeroBarPChannelData::data.initialize(); }
+  };
+  initializer init;
+}
+G4CascadeKzeroBarPChannelData::data(kzbp2bfs, kzbp3bfs, kzbp4bfs,
+                                    kzbp5bfs, kzbp6bfs, kzbp7bfs,
+                                    kzbpCrossSections);

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

-              r962
+              r1315
 namespace {
-  // Total cross section as a function of kinetic energy
-  G4double k0ntot[31];
-  // Multiplicities as a function of kinetic energy
-  G4double k0nMultiplicities[6][31];
-  const G4int k0nindex[6][2] =
-    {{0, 1}, {1, 5}, {5,15}, {15,34}, {34,62}, {62,100}};
   // Outgoing particle types of a given multiplicity
   const G4int k0n2bfs[1][2] =
+  static const G4int k0n2bfs[1][2] =
     {{2,15}};
   const G4int k0n3bfs[4][3] =
+  static const G4int k0n3bfs[4][3] =
     {{2,7,15}, {2,5,11}, {1,5,15}, {15,15,21}};
   const G4int k0n4bfs[10][4] =
+  static const G4int k0n4bfs[10][4] =
     {{2,7,7,15},  {1,5,5,11},  {2,5,7,11},  {1,5,7,15},  {2,3,5,15},
      {1,13,15,15},{2,11,13,15},{2,15,15,17},{7,15,15,21},{5,11,15,21}};
   const G4int k0n5bfs[19][5] =
+  static const G4int k0n5bfs[19][5] =
     {{2,7,7,7,15},   {1,5,5,7,11},   {2,5,7,7,11},   {2,3,5,5,11},
      {1,5,7,7,15},   {1,3,5,5,15},   {2,3,5,7,15},   {1,7,13,15,15},
 …
      {5,5,11,11,21}, {5,7,11,15,21}, {3,5,15,15,21}};
   const G4int k0n6bfs[28][6] =
+  static const G4int k0n6bfs[28][6] =
     {{2,7,7,7,7,15},   {1,5,5,7,7,11},   {1,3,5,5,5,11},
      {2,5,7,7,7,11},   {2,3,5,5,7,11},   {1,5,7,7,7,15},
 …
      {3,5,7,15,15,21}};
   const G4int k0n7bfs[38][7] =
+  static const G4int k0n7bfs[38][7] =
     {{2,7,7,7,7,7,15},   {1,3,5,5,5,7,11},   {1,5,5,7,7,7,11},
      {2,5,7,7,7,7,11},   {2,3,5,5,7,7,11},   {2,3,3,5,5,5,11},
 …
   // second index: kinetic energy
   //
   const G4float k0nCrossSections[100][31] = {
+  static const G4double k0nCrossSections[100][31] = {
     //
     // multiplicity 2 (1 channel)
 …
 G4CascadeKzeroNChannelData::data_t
+G4CascadeKzeroNChannelData::data = { k0ntot,
+                                     k0nMultiplicities,
+                                     k0nindex,
+                                     k0n2bfs,
+                                     k0n3bfs,
+                                     k0n4bfs,
+                                     k0n5bfs,
+                                     k0n6bfs,
+                                     k0n7bfs,
+                                     k0nCrossSections };
+namespace {
+  struct initializer
+  {
+    initializer() { G4CascadeKzeroNChannelData::data.initialize(); }
+  };
+  initializer init;
+}
+G4CascadeKzeroNChannelData::data(k0n2bfs, k0n3bfs, k0n4bfs,
+                                 k0n5bfs, k0n6bfs, k0n7bfs,
+                                 k0nCrossSections);

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

-              r962
+              r1315
 namespace {
-  // Total cross section as a function of kinetic energy
-  G4double k0ptot[31];
-  // Multiplicities as a function of kinetic energy
-  G4double k0pMultiplicities[6][31];
-  const G4int k0pindex[6][2] =
-    {{0, 2}, {2, 7}, {7,20}, {20,42}, {42,74}, {74,115}};
   // Outgoing particle types of a given multiplicity
   const G4int k0p2bfs[2][2] =
+  static const G4int k0p2bfs[2][2] =
     {{1,15}, {2,11}};
   const G4int k0p3bfs[5][3] =
+  static const G4int k0p3bfs[5][3] =
     {{1,7,15}, {2,3,15}, {1,5,11}, {2,7,11}, {11,15,21}};
   const G4int k0p4bfs[13][4] =
+  static const G4int k0p4bfs[13][4] =
     {{1,7,7,15},   {1,3,5,15},   {2,3,7,15},   {1,5,7,11},   {2,7,7,11},
      {2,3,5,11},   {1,11,13,15}, {1,15,15,17}, {2,11,15,17}, {2,11,11,13},
      {7,11,15,21}, {5,11,11,21}, {3,15,15,21}};
   const G4int k0p5bfs[22][5] =
+  static const G4int k0p5bfs[22][5] =
     {{1,7,7,7,15},   {1,3,5,7,15},   {2,3,7,7,15},   {2,3,3,5,15},
      {1,5,7,7,11},   {1,3,5,5,11},   {2,7,7,7,11},   {2,3,5,7,11},
 …
      {5,7,11,11,21}, {3,7,15,15,21}};
   const G4int k0p6bfs[32][6] =
+  static const G4int k0p6bfs[32][6] =
     {{1,7,7,7,7,15},   {1,3,5,7,7,15},   {1,3,3,5,5,15},   {2,3,7,7,7,15},
      {2,3,3,5,7,15},   {1,5,7,7,7,11},   {1,3,5,5,7,11},   {2,7,7,7,7,11},
 …
      {5,7,7,11,11,21}, {3,5,5,11,11,21}, {3,7,7,15,15,21}, {3,3,5,15,15,21}};
   const G4int k0p7bfs[41][7] =
+  static const G4int k0p7bfs[41][7] =
     {{1,7,7,7,7,7,15},   {1,3,5,7,7,7,15},   {1,3,3,5,5,7,15},
      {2,3,7,7,7,7,15},   {2,3,3,5,7,7,15},   {2,3,3,3,5,5,15},
 …
   // second index: kinetic energy
   //
   const G4float k0pCrossSections[115][31] = {
+  static const G4double k0pCrossSections[115][31] = {
     //
     // multiplicity 2 (2 channels)
 …
 G4CascadeKzeroPChannelData::data_t
+G4CascadeKzeroPChannelData::data = { k0ptot,
+                                     k0pMultiplicities,
+                                     k0pindex,
+                                     k0p2bfs,
+                                     k0p3bfs,
+                                     k0p4bfs,
+                                     k0p5bfs,
+                                     k0p6bfs,
+                                     k0p7bfs,
+                                     k0pCrossSections };
+namespace {
+  struct initializer
+  {
+    initializer() { G4CascadeKzeroPChannelData::data.initialize(); }
+  };
+  initializer init;
+}
+G4CascadeKzeroPChannelData::data(k0p2bfs, k0p3bfs, k0p4bfs,
+                                 k0p5bfs, k0p6bfs, k0p7bfs,
+                                 k0pCrossSections);

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

-              r962
+              r1315
 namespace {
-  // Total cross section as a function of kinetic energy
-  G4double lntot[31];
-  // Multiplicities as a function of kinetic energy
-  G4double lnMultiplicities[6][31];
-  const G4int lnindex[6][2] =
-    {{0, 3}, {3, 15}, {15,48}, {48,107}, {107,137}, {137,157}};
   // Outgoing particle types of a given multiplicity
   const G4int ln2bfs[3][2] =
+  static const G4int ln2bfs[3][2] =
     {{2, 21}, {2,25}, {1,27}};
   const G4int ln3bfs[12][3] =
+  static const G4int ln3bfs[12][3] =
     {{1,2,13}, {2,2,17}, {1,5,21}, {2,7,21},  {1,7,27},  {2,3,27},
      {1,5,25}, {2,7,25}, {2,5,23}, {1,15,31}, {2,11,31}, {2,15,29}};
   const G4int ln4bfs[33][4] =
+  static const G4int ln4bfs[33][4] =
     {{1,1,5,13},   {1,2,7,13},   {1,2,5,17},   {2,2,3,13},   {2,2,7,17},
      {1,5,7,21},   {2,3,5,21},   {2,7,7,21},   {1,13,15,21}, {2,11,13,21},
 …
      {2,7,15,29},  {1,5,15,29},  {2,5,11,29}};
   const G4int ln5bfs[59][5] =
+  static const G4int ln5bfs[59][5] =
     {{1,1,5,7,13},   {1,1,5,5,17},   {1,2,5,7,17},   {1,2,7,7,13},
      {2,2,3,5,17},   {1,2,3,5,13},   {2,2,7,7,17},   {2,2,3,7,13},
 …
      {1,3,5,15,31},  {2,3,5,11,31},  {2,3,7,15,31}};
   const G4int ln6bfs[30][6] =
+  static const G4int ln6bfs[30][6] =
     {{1,1,5,7,7,13},   {1,1,3,5,5,13},   {1,1,5,5,7,17},
      {1,2,3,5,5,17},   {1,2,7,7,7,13},   {1,2,3,5,7,13},
 …
      {1,3,5,5,5,23},   {2,5,7,7,7,23},   {2,3,5,5,7,23}};
   const G4int ln7bfs[20][7] =
+  static const G4int ln7bfs[20][7] =
     {{1,1,5,7,7,7,13},  {1,1,3,5,5,7,13},  {1,2,3,3,5,5,13},
      {1,1,5,5,7,7,17},  {1,1,3,5,5,5,17},  {1,2,7,7,7,7,13},
 …
   // second index: kinetic energy
   //
   const G4float lnCrossSections[157][31] = {
+  static const G4double lnCrossSections[157][31] = {
     //
     // multiplicity 2 (3 channels)
 …
 G4CascadeLambdaNChannelData::data_t
+G4CascadeLambdaNChannelData::data = { lntot,
+                                      lnMultiplicities,
+                                      lnindex,
+                                      ln2bfs,
+                                      ln3bfs,
+                                      ln4bfs,
+                                      ln5bfs,
+                                      ln6bfs,
+                                      ln7bfs,
+                                      lnCrossSections };
+namespace {
+  struct initializer
+  {
+    initializer() { G4CascadeLambdaNChannelData::data.initialize(); }
+  };
+  initializer init;
+}
+G4CascadeLambdaNChannelData::data(ln2bfs, ln3bfs, ln4bfs,
+                                  ln5bfs, ln6bfs, ln7bfs,
+                                  lnCrossSections);

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

-              r962
+              r1315
 namespace {
-  // Total cross section as a function of kinetic energy
-  G4double lptot[31];
-  // Multiplicities as a function of kinetic energy
-  G4double lpMultiplicities[6][31];
-  const G4int lpindex[6][2] =
-    {{0, 3}, {3, 15}, {15,48}, {48,107}, {107,137}, {137,157}};
   // Outgoing particle types of a given multiplicity
   const G4int lp2bfs[3][2] =
+  static const G4int lp2bfs[3][2] =
     {{1, 21}, {1,25}, {2,23}};
   const G4int lp3bfs[12][3] =
+  static const G4int lp3bfs[12][3] =
     {{1,1,13}, {1,2,17}, {1,7,21}, {2,3,21},  {1,5,23},  {2,7,23},
      {1,7,25}, {2,3,25}, {1,3,27}, {1,15,29}, {2,11,29}, {1,11,31}};
   const G4int lp4bfs[33][4] =
+  static const G4int lp4bfs[33][4] =
     {{1,1,7,13},   {1,1,5,17},   {1,2,7,17},   {1,2,3,13},   {2,2,3,17},
      {1,7,7,21},   {1,3,5,21},   {2,3,7,21},   {1,15,17,21}, {1,11,13,21},
 …
      {1,7,11,31},  {1,3,15,31},  {2,3,11,31}};
   const G4int lp5bfs[59][5] =
+  static const G4int lp5bfs[59][5] =
     {{1,1,7,7,13},   {1,1,3,5,13},   {1,1,5,7,17},   {1,2,7,7,17},
      {1,2,3,5,17},   {1,2,3,7,13},   {2,2,3,7,17},   {2,2,3,3,13},
 …
      {1,3,7,15,31},  {2,3,7,11,31},  {2,3,3,15,31}};
   const G4int lp6bfs[30][6] =
+  static const G4int lp6bfs[30][6] =
     {{1,1,7,7,7,13},   {1,1,3,5,7,13},   {1,1,5,7,7,17},
      {1,1,3,5,5,17},   {1,2,7,7,7,17},   {1,2,3,5,7,17},
 …
      {1,3,3,5,7,27},   {2,3,3,7,7,27},   {2,3,3,3,5,27}};
   const G4int lp7bfs[20][7] =
+  static const G4int lp7bfs[20][7] =
     {{1,1,7,7,7,7,13},  {1,1,3,5,7,7,13},  {1,1,3,3,5,5,13},
      {1,1,5,7,7,7,17},  {1,1,3,5,5,7,17},  {1,2,7,7,7,7,17},
 …
   // second index: kinetic energy
   //
   const G4float lpCrossSections[157][31] = {
+  static const G4double lpCrossSections[157][31] = {
     //
     // multiplicity 2 (3 channels)
 …
 G4CascadeLambdaPChannelData::data_t
+G4CascadeLambdaPChannelData::data = { lptot,
+                                      lpMultiplicities,
+                                      lpindex,
+                                      lp2bfs,
+                                      lp3bfs,
+                                      lp4bfs,
+                                      lp5bfs,
+                                      lp6bfs,
+                                      lp7bfs,
+                                      lpCrossSections };
+namespace {
+  struct initializer
+  {
+    initializer() { G4CascadeLambdaPChannelData::data.initialize(); }
+  };
+  initializer init;
+}
+G4CascadeLambdaPChannelData::data(lp2bfs, lp3bfs, lp4bfs,
+                                  lp5bfs, lp6bfs, lp7bfs,
+                                  lpCrossSections);

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

-              r962
+              r1315
 namespace {
-  // Total cross section as a function of kinetic energy
-  G4double smntot[31];
-  // Multiplicities as a function of kinetic energy
-  G4double smnMultiplicities[6][31];
-  const G4int smnindex[6][2] =
-    {{0, 1}, {1, 7}, {7,27}, {27,69}, {69,94}, {94,111}};
   // Outgoing particle types of a given multiplicity
   const G4int smn2bfs[1][2] =
+  static const G4int smn2bfs[1][2] =
     {{2,27}};
   const G4int smn3bfs[6][3] =
+  static const G4int smn3bfs[6][3] =
     {{2,2,13}, {2,5,21}, {2,7,27}, {1,5,27},  {2,5,25},  {2,15,31}};
   const G4int smn4bfs[20][4] =
+  static const G4int smn4bfs[20][4] =
     {{1,2,5,13},   {2,2,5,17}, {2,2,7,13},  {2,5,7,21},   {1,5,5,21},
      {2,13,15,21}, {2,5,5,23}, {2,5,7,25},  {1,5,5,25},   {2,7,7,27},
 …
      {1,13,15,27}, {2,5,15,29},{2,5,11,31}, {2,7,15,31},  {1,5,15,31}};
   const G4int smn5bfs[42][5] =
+  static const G4int smn5bfs[42][5] =
     {{2,2,5,7,17},   {2,2,3,5,13},   {2,2,7,7,13},   {1,2,5,7,13},
      {1,2,5,5,17},   {1,1,5,5,13},   {1,5,5,7,21},   {2,3,5,5,21},
 …
      {2,5,7,15,29},  {1,5,5,15,29}};
   const G4int smn6bfs[25][6] =
+  static const G4int smn6bfs[25][6] =
     {{2,2,7,7,7,13}, {2,2,3,5,7,13}, {2,2,5,7,7,17}, {2,2,3,5,5,17},
      {1,2,5,7,7,13}, {1,2,3,5,5,13}, {1,2,5,5,7,17}, {1,1,5,5,7,13},
 …
      {1,5,5,5,7,23}};
   const G4int smn7bfs[17][7] =
+  static const G4int smn7bfs[17][7] =
     {{2,2,7,7,7,7,13}, {2,2,3,5,7,7,13}, {2,2,3,3,5,5,13},
      {2,2,5,7,7,7,17}, {2,2,3,5,5,7,17}, {1,2,5,5,7,7,17},
 …
   // second index: kinetic energy
   //
   const G4float smnCrossSections[111][31] = {
+  static const G4double smnCrossSections[111][31] = {
     //
     // multiplicity 2 (1 channel)
 …
 G4CascadeSigmaMinusNChannelData::data_t
+G4CascadeSigmaMinusNChannelData::data = { smntot,
+                                          smnMultiplicities,
+                                          smnindex,
+                                          smn2bfs,
+                                          smn3bfs,
+                                          smn4bfs,
+                                          smn5bfs,
+                                          smn6bfs,
+                                          smn7bfs,
+                                          smnCrossSections };
+namespace {
+  struct initializer
+  {
+    initializer() { G4CascadeSigmaMinusNChannelData::data.initialize(); }
+  };
+  initializer init;
+}
+G4CascadeSigmaMinusNChannelData::data(smn2bfs, smn3bfs, smn4bfs,
+                                      smn5bfs, smn6bfs, smn7bfs,
+                                      smnCrossSections);

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

-              r962
+              r1315
 namespace {
-  // Total cross section as a function of kinetic energy
-  G4double smptot[31];
-  // Multiplicities as a function of kinetic energy
-  G4double smpMultiplicities[6][31];
-  const G4int smpindex[6][2] =
-    {{0, 3}, {3, 15}, {15,48}, {48,107}, {107,137}, {137,157}};
   // Outgoing particle types of a given multiplicity
   const G4int smp2bfs[3][2] =
+  static const G4int smp2bfs[3][2] =
     {{1,27}, {2,21}, {2,25}};
   const G4int smp3bfs[12][3] =
+  static const G4int smp3bfs[12][3] =
     {{1,2,13}, {2,2,17}, {2,7,21}, {1,5,21},  {2,5,23},  {2,7,25},
      {1,5,25}, {1,7,27}, {2,3,27}, {2,15,29}, {1,15,31}, {2,11,31}};
   const G4int smp4bfs[33][4] =
+  static const G4int smp4bfs[33][4] =
     {{1,1,5,13},   {1,2,7,13},   {1,2,5,17},   {2,2,3,13},   {2,2,7,17},
      {1,5,7,21},   {2,7,7,21},   {2,3,5,21},   {1,13,15,21}, {2,11,13,21},
 …
      {2,3,15,31},  {1,5,11,31},  {1,7,15,31}};
   const G4int smp5bfs[59][5] =
+  static const G4int smp5bfs[59][5] =
     {{1,1,5,7,13},   {1,1,5,5,17},   {1,2,7,7,13},   {1,2,3,5,13},
      {1,2,5,7,17},   {2,2,3,7,13},   {2,2,7,7,17},   {2,2,3,5,17},
 …
      {1,7,7,15,31},  {1,3,5,15,31},  {1,5,7,11,31}};
   const G4int smp6bfs[30][6] =
+  static const G4int smp6bfs[30][6] =
     {{1,1,5,7,7,13}, {1,1,3,5,5,13}, {1,1,5,5,7,17},
      {1,2,7,7,7,13}, {1,2,3,5,7,13}, {1,2,5,7,7,17},
 …
      {1,3,3,5,5,27}, {2,3,7,7,7,27}, {2,3,3,5,7,27}};
   const G4int smp7bfs[20][7] =
+  static const G4int smp7bfs[20][7] =
     {{1,1,5,7,7,7,13}, {1,1,3,5,5,7,13}, {1,1,5,5,7,7,17},
      {1,1,3,5,5,5,17}, {1,2,7,7,7,7,13}, {1,2,3,5,7,7,13},
 …
   // second index: kinetic energy
   //
   const G4float smpCrossSections[157][31] = {
+  static const G4double smpCrossSections[157][31] = {
     //
     // multiplicity 2 (3 channels)
 …
 G4CascadeSigmaMinusPChannelData::data_t
+G4CascadeSigmaMinusPChannelData::data = { smptot,
+                                          smpMultiplicities,
+                                          smpindex,
+                                          smp2bfs,
+                                          smp3bfs,
+                                          smp4bfs,
+                                          smp5bfs,
+                                          smp6bfs,
+                                          smp7bfs,
+                                          smpCrossSections };
+namespace {
+  struct initializer
+  {
+    initializer() { G4CascadeSigmaMinusPChannelData::data.initialize(); }
+  };
+  initializer init;
+}
+G4CascadeSigmaMinusPChannelData::data(smp2bfs, smp3bfs, smp4bfs,
+                                      smp5bfs, smp6bfs, smp7bfs,
+                                      smpCrossSections);

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

-              r1196
+              r1315
 namespace {
-  // Total cross section as a function of kinetic energy
-  G4double spntot[31];
-  // Multiplicities as a function of kinetic energy
-  G4double spnMultiplicities[6][31];
-  const G4int spnindex[6][2] =
-    {{0, 3}, {3, 15}, {15,48}, {48,107}, {107,137}, {137,157}};
   // Outgoing particle types of a given multiplicity
   const G4int spn2bfs[3][2] =
+  static const G4int spn2bfs[3][2] =
     {{2,23}, {1,21}, {1,25}};
   const G4int spn3bfs[12][3] =
+  static const G4int spn3bfs[12][3] =
     {{1,1,13}, {1,2,17}, {2,7,23}, {2,3,25},  {1,5,23},  {1,7,25},
      {1,7,21}, {2,3,21}, {1,3,27}, {1,15,29}, {2,11,29}, {1,11,31}};
   const G4int spn4bfs[33][4] =
+  static const G4int spn4bfs[33][4] =
     {{1,1,7,13},   {1,1,5,17},   {1,2,7,17},   {1,2,3,13},   {2,2,3,17},
      {2,7,7,23},   {2,3,5,23},   {2,3,7,25},   {2,15,17,23}, {2,11,13,23},
 …
      {1,7,11,31},  {1,3,15,31},  {2,3,11,31}};
   const G4int spn5bfs[59][5] =
+  static const G4int spn5bfs[59][5] =
     {{1,1,7,7,13},   {1,1,3,5,13},   {1,1,5,7,17},   {1,2,7,7,17},
      {1,2,3,5,17},   {1,2,3,7,13},   {2,2,3,7,17},   {2,2,3,3,13},
 …
      {1,3,7,15,31},  {2,3,7,11,31},  {2,3,3,15,31}};
   const G4int spn6bfs[30][6] =
+  static const G4int spn6bfs[30][6] =
     {{1,1,7,7,7,13},   {1,1,3,5,7,13},   {1,1,5,7,7,17},
      {1,1,3,5,5,17},   {1,2,7,7,7,17},   {1,2,3,5,7,17},
 …
      {1,3,3,5,7,27},   {2,3,3,7,7,27},   {2,3,3,3,5,27}};
   const G4int spn7bfs[20][7] =
+  static const G4int spn7bfs[20][7] =
     {{1,1,7,7,7,7,13},  {1,1,3,5,7,7,13},  {1,1,3,3,5,5,13},
      {1,1,5,7,7,7,17},  {1,1,3,5,5,7,17},  {1,2,7,7,7,7,17},
 …
   // second index: kinetic energy
   //
   const G4float spnCrossSections[157][31] = {
+  static const G4double spnCrossSections[157][31] = {
     //
     // multiplicity 2 (3 channels)
 …
 G4CascadeSigmaPlusNChannelData::data_t
+G4CascadeSigmaPlusNChannelData::data = { spntot,
+                                         spnMultiplicities,
+                                         spnindex,
+                                         spn2bfs,
+                                         spn3bfs,
+                                         spn4bfs,
+                                         spn5bfs,
+                                         spn6bfs,
+                                         spn7bfs,
+                                         spnCrossSections };
+namespace {
+  struct initializer
+  {
+    initializer() { G4CascadeSigmaPlusNChannelData::data.initialize(); }
+  };
+  initializer init;
+}
+G4CascadeSigmaPlusNChannelData::data(spn2bfs, spn3bfs, spn4bfs,
+                                     spn5bfs, spn6bfs, spn7bfs,
+                                     spnCrossSections);

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

-              r962
+              r1315
 namespace {
-  // Total cross section as a function of kinetic energy
-  G4double spptot[31];
-  // Multiplicities as a function of kinetic energy
-  G4double sppMultiplicities[6][31];
-  const G4int sppindex[6][2] =
-    {{0, 1}, {1, 7}, {7,27}, {27,69}, {69,94}, {94,111}};
   // Outgoing particle types of a given multiplicity
   const G4int spp2bfs[1][2] =
+  static const G4int spp2bfs[1][2] =
     {{1,23}};
   const G4int spp3bfs[6][3] =
+  static const G4int spp3bfs[6][3] =
     {{1,1,17}, {1,3,21}, {1,7,23}, {2,3,23},  {1,3,25},  {1,11,29}};
   const G4int spp4bfs[20][4] =
+  static const G4int spp4bfs[20][4] =
     {{1,1,7,17},   {1,1,3,13},   {1,2,3,17}, {1,3,7,21}, {2,3,3,21},
      {1,11,17,21}, {1,7,7,23},   {1,3,5,23}, {2,3,7,23}, {1,15,17,23},
 …
      {1,3,3,27},   {1,7,11,29},  {1,3,15,29},{2,3,11,29},{1,3,11,31}};
   const G4int spp5bfs[42][5] =
+  static const G4int spp5bfs[42][5] =
     {{1,1,7,7,17},   {1,1,3,5,17},   {1,1,3,7,13},   {1,2,3,7,17},
      {1,2,3,3,13},   {2,2,3,3,17},   {1,3,7,7,21},   {1,3,3,5,21},
 …
      {1,3,3,15,31},  {2,3,3,11,31}};
   const G4int spp6bfs[25][6] =
+  static const G4int spp6bfs[25][6] =
     {{1,1,7,7,7,17}, {1,1,3,5,7,17}, {1,1,3,7,7,13}, {1,1,3,3,5,13},
      {1,2,3,7,7,17}, {1,2,3,3,5,17}, {1,2,3,3,7,13}, {2,2,3,3,7,17},
 …
      {2,3,3,3,7,27}};
   const G4int spp7bfs[17][7] =
+  static const G4int spp7bfs[17][7] =
     {{1,1,7,7,7,7,17}, {1,1,3,5,7,7,17}, {1,1,3,3,5,5,17},
      {1,1,3,7,7,7,13}, {1,1,3,3,5,7,13}, {1,2,3,7,7,7,17},
 …
   // second index: kinetic energy
   //
   const G4float sppCrossSections[111][31] = {
+  static const G4double sppCrossSections[111][31] = {
     //
     // multiplicity 2 (1 channel)
 …
 G4CascadeSigmaPlusPChannelData::data_t
+G4CascadeSigmaPlusPChannelData::data = { spptot,
+                                         sppMultiplicities,
+                                         sppindex,
+                                         spp2bfs,
+                                         spp3bfs,
+                                         spp4bfs,
+                                         spp5bfs,
+                                         spp6bfs,
+                                         spp7bfs,
+                                         sppCrossSections };
+namespace {
+  struct initializer
+  {
+    initializer() {G4CascadeSigmaPlusPChannelData::data.initialize(); }
+  };
+  initializer init;
+}
+G4CascadeSigmaPlusPChannelData::data(spp2bfs, spp3bfs, spp4bfs,
+                                     spp5bfs, spp6bfs, spp7bfs,
+                                     sppCrossSections);

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

-              r962
+              r1315
 namespace {
-  // Total cross section as a function of kinetic energy
-  G4double s0ntot[31];
-  // Multiplicities as a function of kinetic energy
-  G4double s0nMultiplicities[6][31];
-  const G4int s0nindex[6][2] =
-    {{0, 3}, {3, 15}, {15,48}, {48,107}, {107,137}, {137,157}};
   // Outgoing particle types of a given multiplicity
   const G4int s0n2bfs[3][2] =
+  static const G4int s0n2bfs[3][2] =
     {{2, 25}, {2,21}, {1,27}};
   const G4int s0n3bfs[12][3] =
+  static const G4int s0n3bfs[12][3] =
     {{1,2,13}, {2,2,17}, {1,5,25}, {2,7,25},  {1,7,27},  {2,3,27},
      {1,5,21}, {2,7,21}, {2,5,23}, {1,15,31}, {2,11,31}, {2,15,29}};
   const G4int s0n4bfs[33][4] =
+  static const G4int s0n4bfs[33][4] =
     {{1,1,5,13},   {1,2,7,13},   {1,2,5,17},   {2,2,3,13},   {2,2,7,17},
      {1,5,7,25},   {2,3,5,25},   {2,7,7,25},   {1,13,15,25}, {2,11,13,25},
 …
      {2,7,15,29},  {1,5,15,29},  {2,5,11,29}};
   const G4int s0n5bfs[59][5] =
+  static const G4int s0n5bfs[59][5] =
     {{1,1,5,7,13},   {1,1,5,5,17},   {1,2,5,7,17},   {1,2,7,7,13},
      {2,2,3,5,17},   {1,2,3,5,13},   {2,2,7,7,17},   {2,2,3,7,13},
 …
      {1,3,5,15,31},  {2,3,5,11,31},  {2,3,7,15,31}};
   const G4int s0n6bfs[30][6] =
+  static const G4int s0n6bfs[30][6] =
     {{1,1,5,7,7,13},   {1,1,3,5,5,13},   {1,1,5,5,7,17},
      {1,2,3,5,5,17},   {1,2,7,7,7,13},   {1,2,3,5,7,13},
 …
      {1,3,5,5,5,23},   {2,5,7,7,7,23},   {2,3,5,5,7,23}};
   const G4int s0n7bfs[20][7] =
+  static const G4int s0n7bfs[20][7] =
     {{1,1,5,7,7,7,13},  {1,1,3,5,5,7,13},  {1,2,3,3,5,5,13},
      {1,1,5,5,7,7,17},  {1,1,3,5,5,5,17},  {1,2,7,7,7,7,13},
 …
   // second index: kinetic energy
   //
   const G4float s0nCrossSections[157][31] = {
+  static const G4double s0nCrossSections[157][31] = {
     //
     // multiplicity 2 (3 channels)
 …
 G4CascadeSigmaZeroNChannelData::data_t
+G4CascadeSigmaZeroNChannelData::data = { s0ntot,
+                                         s0nMultiplicities,
+                                         s0nindex,
+                                         s0n2bfs,
+                                         s0n3bfs,
+                                         s0n4bfs,
+                                         s0n5bfs,
+                                         s0n6bfs,
+                                         s0n7bfs,
+                                         s0nCrossSections };
+namespace {
+  struct initializer
+  {
+    initializer() { G4CascadeSigmaZeroNChannelData::data.initialize(); }
+  };
+  initializer init;
+}
+G4CascadeSigmaZeroNChannelData::data(s0n2bfs, s0n3bfs, s0n4bfs,
+                                     s0n5bfs, s0n6bfs, s0n7bfs,
+                                     s0nCrossSections);

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

-              r962
+              r1315
 namespace {
-  // Total cross section as a function of kinetic energy
-  G4double s0ptot[31];
-  // Multiplicities as a function of kinetic energy
-  G4double s0pMultiplicities[6][31];
-  const G4int s0pindex[6][2] =
-    {{0, 3}, {3, 15}, {15,48}, {48,107}, {107,137}, {137,157}};
   // Outgoing particle types of a given multiplicity
   const G4int s0p2bfs[3][2] =
+  static const G4int s0p2bfs[3][2] =
     {{1, 25}, {1,21}, {2,23}};
   const G4int s0p3bfs[12][3] =
+  static const G4int s0p3bfs[12][3] =
     {{1,1,13}, {1,2,17}, {1,7,25}, {2,3,25},  {1,5,23},  {2,7,23},
      {1,7,21}, {2,3,21}, {1,3,27}, {1,15,29}, {2,11,29}, {1,11,31}};
   const G4int s0p4bfs[33][4] =
+  static const G4int s0p4bfs[33][4] =
     {{1,1,7,13},   {1,1,5,17},   {1,2,7,17},   {1,2,3,13},   {2,2,3,17},
      {1,7,7,25},   {1,3,5,25},   {2,3,7,25},   {1,15,17,25}, {1,11,13,25},
 …
      {1,7,11,31},  {1,3,15,31},  {2,3,11,31}};
   const G4int s0p5bfs[59][5] =
+  static const G4int s0p5bfs[59][5] =
     {{1,1,7,7,13},   {1,1,3,5,13},   {1,1,5,7,17},   {1,2,7,7,17},
      {1,2,3,5,17},   {1,2,3,7,13},   {2,2,3,7,17},   {2,2,3,3,13},
 …
      {1,3,7,15,31},  {2,3,7,11,31},  {2,3,3,15,31}};
   const G4int s0p6bfs[30][6] =
+  static const G4int s0p6bfs[30][6] =
     {{1,1,7,7,7,13},   {1,1,3,5,7,13},   {1,1,5,7,7,17},
      {1,1,3,5,5,17},   {1,2,7,7,7,17},   {1,2,3,5,7,17},
 …
      {1,3,3,5,7,27},   {2,3,3,7,7,27},   {2,3,3,3,5,27}};
   const G4int s0p7bfs[20][7] =
+  static const G4int s0p7bfs[20][7] =
     {{1,1,7,7,7,7,13},  {1,1,3,5,7,7,13},  {1,1,3,3,5,5,13},
      {1,1,5,7,7,7,17},  {1,1,3,5,5,7,17},  {1,2,7,7,7,7,17},
 …
   // second index: kinetic energy
   //
   const G4float s0pCrossSections[157][31] = {
+  static const G4double s0pCrossSections[157][31] = {
     //
     // multiplicity 2 (3 channels)
 …
 G4CascadeSigmaZeroPChannelData::data_t
+G4CascadeSigmaZeroPChannelData::data = { s0ptot,
+                                         s0pMultiplicities,
+                                         s0pindex,
+                                         s0p2bfs,
+                                         s0p3bfs,
+                                         s0p4bfs,
+                                         s0p5bfs,
+                                         s0p6bfs,
+                                         s0p7bfs,
+                                         s0pCrossSections };
+namespace {
+  struct initializer {
+    initializer() { G4CascadeSigmaZeroPChannelData::data.initialize(); }
+  };
+  initializer init;
+}
+G4CascadeSigmaZeroPChannelData::data(s0p2bfs, s0p3bfs, s0p4bfs,
+                                     s0p5bfs, s0p6bfs, s0p7bfs,
+                                     s0pCrossSections);

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

-              r962
+              r1315
 namespace {
-  // Total cross section as a function of kinetic energy
-  G4double xmntot[31];
-  // Multiplicities as a function of kinetic energy
-  G4double xmnMultiplicities[6][31];
-  const G4int xmnindex[6][2] =
-    {{0, 3}, {3, 21}, {21,74}, {74,76}, {76,78}, {78,80}};
   // Outgoing particle types of a given multiplicity
   const G4int xmn2bfs[3][2] =
+  static const G4int xmn2bfs[3][2] =
     {{2, 31}, {21,27}, {25,27}};
   const G4int xmn3bfs[18][3] =
+  static const G4int xmn3bfs[18][3] =
     {{2,13,21}, {5,21,21}, {1,13,27}, {2,13,25}, {7,21,27}, {5,23,27},
      {7,25,27}, {3,27,27}, {2,17,27}, {5,21,25}, {5,25,25}, {2,5,29},
      {2,7,31},  {15,21,31},{11,27,31},{15,27,29},{1,5,31},  {15,25,31}};
   const G4int xmn4bfs[53][4] =
+  static const G4int xmn4bfs[53][4] =
     {{1,2,13,13},  {1,5,13,21},  {1,5,13,25},  {1,7,13,27},  {1,5,17,27},
      {1,5,5,29},   {1,5,7,31},   {1,13,15,31}, {2,2,13,17},  {2,7,13,21},
 …
      {3,15,27,31}, {7,11,27,31}, {7,15,27,29}};
   const G4int xmn5bfs[2][5] =
+  static const G4int xmn5bfs[2][5] =
     {{2,7,7,7,31},  {2,3,5,7,31}};
   const G4int xmn6bfs[2][6] =
+  static const G4int xmn6bfs[2][6] =
     {{2,7,7,7,7,31},  {2,3,5,7,7,31}};
   const G4int xmn7bfs[2][7] =
+  static const G4int xmn7bfs[2][7] =
     {{2,7,7,7,7,7,31},  {2,3,5,7,7,7,31}};
 …
   // second index: kinetic energy
   //
   const G4float xmnCrossSections[80][31] = {
+  static const G4double xmnCrossSections[80][31] = {
     //
     // multiplicity 2 (3 channels)
 …
 G4CascadeXiMinusNChannelData::data_t
+G4CascadeXiMinusNChannelData::data = { xmntot,
+                                       xmnMultiplicities,
+                                       xmnindex,
+                                       xmn2bfs,
+                                       xmn3bfs,
+                                       xmn4bfs,
+                                       xmn5bfs,
+                                       xmn6bfs,
+                                       xmn7bfs,
+                                       xmnCrossSections };
+namespace {
+  struct initializer
+  {
+    initializer() { G4CascadeXiMinusNChannelData::data.initialize(); }
+  };
+  initializer init;
+}
+G4CascadeXiMinusNChannelData::data(xmn2bfs, xmn3bfs, xmn4bfs,
+                                   xmn5bfs, xmn6bfs, xmn7bfs,
+                                   xmnCrossSections);

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

-              r962
+              r1315
 namespace {
-  // Total cross section as a function of kinetic energy
-  G4double xmptot[31];
-  // Multiplicities as a function of kinetic energy
-  G4double xmpMultiplicities[6][31];
-  const G4int xmpindex[6][2] =
-    {{0, 6}, {6,30}, {30,34}, {34,38}, {38,42}, {42,46}};
   // Outgoing particle types of a given multiplicity
   const G4int xmp2bfs[6][2] =
+  static const G4int xmp2bfs[6][2] =
     {{1,31}, {2,29}, {21,21}, {21,25}, {25,25}, {23,27}};
   const G4int xmp3bfs[24][3] =
+  static const G4int xmp3bfs[24][3] =
     {{1,13,21},  {1,13,25}, {1,17,27}, {1,5,29},   {1,7,31},   {2,17,21},
      {2,17,25},  {2,13,23}, {2,7,29},  {2,3,31},   {7,21,21},  {7,21,25},
 …
      {15,23,31}, {7,25,25}, {3,25,27}, {15,25,29}, {11,25,31}, {11,27,29}};
   const G4int xmp4bfs[4][4] =
+  static const G4int xmp4bfs[4][4] =
     {{1,7,13,21}, {2,7,17,21}, {1,3,5,31}, {2,3,5,29}};
   const G4int xmp5bfs[4][5] =
+  static const G4int xmp5bfs[4][5] =
     {{1,3,5,13,21}, {2,3,5,17,21}, {1,3,5,7,31}, {2,3,5,7,29}};
   const G4int xmp6bfs[4][6] =
+  static const G4int xmp6bfs[4][6] =
     {{1,3,5,7,13,21}, {2,3,5,7,17,21}, {1,3,3,5,5,31}, {2,3,3,5,5,29}};
   const G4int xmp7bfs[4][7] =
+  static const G4int xmp7bfs[4][7] =
     {{1,3,3,5,5,13,21}, {2,3,3,5,5,17,21}, {1,3,3,5,5,7,31}, {2,3,3,5,5,7,29}};
 …
   // second index: kinetic energy
   //
   const G4float xmpCrossSections[46][31] = {
+  static const G4double xmpCrossSections[46][31] = {
     //
     // multiplicity 2 (6 channels)
 …
 G4CascadeXiMinusPChannelData::data_t
+G4CascadeXiMinusPChannelData::data = { xmptot,
+                                       xmpMultiplicities,
+                                       xmpindex,
+                                       xmp2bfs,
+                                       xmp3bfs,
+                                       xmp4bfs,
+                                       xmp5bfs,
+                                       xmp6bfs,
+                                       xmp7bfs,
+                                       xmpCrossSections };
+namespace {
+  struct initializer
+  {
+    initializer() { G4CascadeXiMinusPChannelData::data.initialize(); }
+  };
+  initializer init;
+}
+G4CascadeXiMinusPChannelData::data(xmp2bfs, xmp3bfs, xmp4bfs,
+                                   xmp5bfs, xmp6bfs, xmp7bfs,
+                                   xmpCrossSections);

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

-              r962
+              r1315
 namespace {
-  // Total cross section as a function of kinetic energy
-  G4double x0ntot[31];
-  // Multiplicities as a function of kinetic energy
-  G4double x0nMultiplicities[6][31];
-  const G4int x0nindex[6][2] =
-    {{0, 6}, {6,30}, {30,34}, {34,38}, {38,42}, {42,46}};
   // Outgoing particle types of a given multiplicity
   const G4int x0n2bfs[6][2] =
+  static const G4int x0n2bfs[6][2] =
     {{2,29}, {1,31}, {21,21}, {21,25}, {25,25}, {23,27}};
   const G4int x0n3bfs[24][3] =
+  static const G4int x0n3bfs[24][3] =
     {{1,13,21},  {1,13,25}, {1,17,27}, {1,5,29},   {1,7,31},   {2,17,21},
      {2,17,25},  {2,13,23}, {2,7,29},  {2,3,31},   {7,21,21},  {7,21,25},
 …
      {15,23,31}, {7,25,25}, {3,25,27}, {15,25,29}, {11,25,31}, {11,27,29}};
   const G4int x0n4bfs[4][4] =
+  static const G4int x0n4bfs[4][4] =
     {{1,7,13,21}, {2,7,17,21}, {1,3,5,31}, {2,3,5,29}};
   const G4int x0n5bfs[4][5] =
+  static const G4int x0n5bfs[4][5] =
     {{1,3,5,13,21}, {2,3,5,17,21}, {1,3,5,7,31}, {2,3,5,7,29}};
   const G4int x0n6bfs[4][6] =
+  static const G4int x0n6bfs[4][6] =
     {{1,3,5,7,13,21}, {2,3,5,7,17,21}, {1,3,3,5,5,31}, {2,3,3,5,5,29}};
   const G4int x0n7bfs[4][7] =
+  static const G4int x0n7bfs[4][7] =
     {{1,3,3,5,5,13,21}, {2,3,3,5,5,17,21}, {1,3,3,5,5,7,31}, {2,3,3,5,5,7,29}};
 …
   // second index: kinetic energy
   //
   const G4float x0nCrossSections[46][31] = {
+  static const G4double x0nCrossSections[46][31] = {
     //
     // multiplicity 2 (6 channels)
 …
 G4CascadeXiZeroNChannelData::data_t
+G4CascadeXiZeroNChannelData::data = { x0ntot,
+                                      x0nMultiplicities,
+                                      x0nindex,
+                                      x0n2bfs,
+                                      x0n3bfs,
+                                      x0n4bfs,
+                                      x0n5bfs,
+                                      x0n6bfs,
+                                      x0n7bfs,
+                                      x0nCrossSections };
+namespace {
+  struct initializer
+  {
+    initializer() { G4CascadeXiZeroNChannelData::data.initialize(); }
+  };
+  initializer init;
+}
+G4CascadeXiZeroNChannelData::data(x0n2bfs, x0n3bfs, x0n4bfs,
+                                  x0n5bfs, x0n6bfs, x0n7bfs,
+                                  x0nCrossSections);

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

-              r962
+              r1315
 namespace {
-  // Total cross section as a function of kinetic energy
-  G4double x0ptot[31];
-  // Multiplicities as a function of kinetic energy
-  G4double x0pMultiplicities[6][31];
-  const G4int x0pindex[6][2] =
-    {{0, 3}, {3, 21}, {21,74}, {74,76}, {76,78}, {78,80}};
   // Outgoing particle types of a given multiplicity
   const G4int x0p2bfs[3][2] =
+  static const G4int x0p2bfs[3][2] =
     {{1, 29}, {21,23}, {23,25}};
   const G4int x0p3bfs[18][3] =
+  static const G4int x0p3bfs[18][3] =
     {{1,17,21}, {3,21,21}, {1,13,23}, {2,17,23}, {7,21,23}, {5,23,23},
      {7,23,25}, {3,23,27}, {1,17,25}, {3,21,25}, {3,25,25}, {1,7,29},
      {2,3,29},  {11,21,29},{11,25,29},{15,23,29},{1,3,31},  {11,23,31}};
   const G4int x0p4bfs[53][4] =
+  static const G4int x0p4bfs[53][4] =
     {{1,1,13,17},  {1,2,17,17},  {1,7,17,21},  {1,3,13,21},  {1,7,17,25},
      {1,3,13,25},  {1,7,13,23},  {1,5,17,23},  {1,3,17,27},  {1,7,7,29},
 …
      {3,15,23,31}, {7,11,23,31}, {3,11,27,29}};
   const G4int x0p5bfs[2][5] =
+  static const G4int x0p5bfs[2][5] =
     {{1,7,7,7,29},  {1,3,5,7,29}};
   const G4int x0p6bfs[2][6] =
+  static const G4int x0p6bfs[2][6] =
     {{1,7,7,7,7,29},  {1,3,5,7,7,29}};
   const G4int x0p7bfs[2][7] =
+  static const G4int x0p7bfs[2][7] =
     {{1,7,7,7,7,7,29},  {1,3,5,7,7,7,29}};
 …
   // second index: kinetic energy
   //
   const G4float x0pCrossSections[80][31] = {
+  static const G4double x0pCrossSections[80][31] = {
     //
     // multiplicity 2 (3 channels)
 …
 G4CascadeXiZeroPChannelData::data_t
+G4CascadeXiZeroPChannelData::data = { x0ptot,
+                                      x0pMultiplicities,
+                                      x0pindex,
+                                      x0p2bfs,
+                                      x0p3bfs,
+                                      x0p4bfs,
+                                      x0p5bfs,
+                                      x0p6bfs,
+                                      x0p7bfs,
+                                      x0pCrossSections };
+namespace {
+  struct initializer
+  {
+    initializer() { G4CascadeXiZeroPChannelData::data.initialize(); }
+  };
+  initializer init;
+}
+G4CascadeXiZeroPChannelData::data(x0p2bfs, x0p3bfs, x0p4bfs,
+                                  x0p5bfs, x0p6bfs, x0p7bfs,
+                                  x0pCrossSections);

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

-              r1196
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CollisionOutput.cc,v 1.23 2010/05/21 18:07:30 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
+// 20100309  M. Kelsey -- Introduced bug checking i3 for valid tuning pair
+// 20100409  M. Kelsey -- Move non-inlinable code here out of .hh file, replace
+//              loop over push_back() with block insert().
+// 20100418  M. Kelsey -- Add function to boost output lists to lab frame
+// 20100520  M. Kelsey -- Add function to rotate Z axis, from G4Casc.Interface
 #include "G4CollisionOutput.hh"
 #include "G4ParticleLargerEkin.hh"
+#include "G4LorentzConvertor.hh"
+#include "G4LorentzRotation.hh"
 #include <algorithm>
 typedef std::vector<G4InuclElementaryParticle>::iterator particleIterator;
+typedef std::vector<G4InuclNuclei>::iterator nucleiIterator;
 …
+}
+void G4CollisionOutput::reset() {
+  nucleiFragments.clear();
+  outgoingParticles.clear();
+}
+void G4CollisionOutput::addOutgoingParticles(const std::vector<G4InuclElementaryParticle>& particles) {
+  outgoingParticles.insert(outgoingParticles.end(),
+                           particles.begin(), particles.end());
+}
+void G4CollisionOutput::addTargetFragments(const std::vector<G4InuclNuclei>& nuclea) {
+  nucleiFragments.insert(nucleiFragments.end(), nuclea.begin(), nuclea.end());
+}
+G4LorentzVector G4CollisionOutput::getTotalOutputMomentum() const {
+  G4LorentzVector tot_mom;
+  double eex_r = 0.0;
+  G4int i(0);
+  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);
+  return tot_mom;
+}
+void G4CollisionOutput::printCollisionOutput() const {
+  G4int i(0);
+  G4cout << " Output: " << G4endl
+         << " Outgoing Particles: " << outgoingParticles.size() << G4endl;
+  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();
+}
+// Boost particles and fragment to LAB -- "convertor" must already be configured
+void G4CollisionOutput::boostToLabFrame(const G4LorentzConvertor& convertor) {
+  G4bool withReflection = convertor.reflectionNeeded();
+  if (!outgoingParticles.empty()) {
+    particleIterator ipart = outgoingParticles.begin();
+    for(; ipart != outgoingParticles.end(); ipart++) {
+      G4LorentzVector mom = ipart->getMomentum();
+      if (withReflection) mom.setZ(-mom.z());
+      mom = convertor.rotate(mom);
+      mom = convertor.backToTheLab(mom);
+      ipart->setMomentum(mom);
+    }
+    std::sort(outgoingParticles.begin(), outgoingParticles.end(), G4ParticleLargerEkin());
+  }
+  if (!nucleiFragments.empty()) {
+    nucleiIterator inuc = nucleiFragments.begin();
+    for (; inuc != nucleiFragments.end(); inuc++) {
+      G4LorentzVector mom = inuc->getMomentum();
+      if (withReflection) mom.setZ(-mom.z());
+      mom = convertor.rotate(mom);
+      mom = convertor.backToTheLab(mom);
+      inuc->setMomentum(mom);
+    }
+  }
+}
+// Apply LorentzRotation to all particles in event
+void G4CollisionOutput::rotateEvent(const G4LorentzRotation& rotate) {
+  particleIterator ipart = outgoingParticles.begin();
+  for(; ipart != outgoingParticles.end(); ipart++)
+    ipart->setMomentum(ipart->getMomentum()*=rotate);
+  nucleiIterator inuc = nucleiFragments.begin();
+  for (; inuc != nucleiFragments.end(); inuc++)
+    inuc->setMomentum(inuc->getMomentum()*=rotate);
+}
+void G4CollisionOutput::trivialise(G4InuclParticle* bullet,
+                                   G4InuclParticle* target) {
+  if (G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target)) {
+    nucleiFragments.push_back(*nuclei_target);
+  } else {
+    G4InuclElementaryParticle* particle =
+      dynamic_cast<G4InuclElementaryParticle*>(target);
+    outgoingParticles.push_back(*particle);
+  }
+  if (G4InuclNuclei* nuclei_bullet = dynamic_cast<G4InuclNuclei*>(bullet)) {
+    nucleiFragments.push_back(*nuclei_bullet);
+  } else {
+    G4InuclElementaryParticle* particle =
+      dynamic_cast<G4InuclElementaryParticle*>(bullet);
+    outgoingParticles.push_back(*particle);
+  }
+}
 void G4CollisionOutput::setOnShell(G4InuclParticle* bullet,
 …
   on_shell = false;
+  G4CascadeMomentum ini_mom = bullet->getMomentum();
+  const G4CascadeMomentum& momt = target->getMomentum();
+  G4int i;
+  for(i = 0; i < 4; i++) ini_mom[i] += momt[i];
+  G4CascadeMomentum out_mom = getTotalOutputMomentum();
+  G4CascadeMomentum mon_non_cons;
+  G4LorentzVector ini_mom = bullet->getMomentum();
+  G4LorentzVector momt = target->getMomentum();
+  ini_mom += momt;
+  G4LorentzVector out_mom = getTotalOutputMomentum();
+  G4LorentzVector mon_non_cons;
   if(verboseLevel > 2){
+    G4cout << " bullet momentum = " << ini_mom[0]<<", "<< ini_mom[1]<<", "<< ini_mom[2]<<", "<< ini_mom[3]<<G4endl;
+    G4cout << " target momentum = " << momt[0]<<", "<< momt[1]<<", "<< momt[2]<<", "<< momt[3]<<G4endl;
+    G4cout << " Fstate momentum = " << out_mom[0]<<", "<< out_mom[1]<<", "<< out_mom[2]<<", "<< out_mom[3]<<G4endl;
+  }
+  for(i = 0; i < 4; i++) mon_non_cons[i] = ini_mom[i] - out_mom[i];
+  G4double pnc = std::sqrt(mon_non_cons[1] * mon_non_cons[1] +
+                      mon_non_cons[2] * mon_non_cons[2] +
+                      mon_non_cons[3] * mon_non_cons[3]);
+    G4cout << " bullet momentum = " << ini_mom.e() <<", "<< ini_mom.x() <<", "<< ini_mom.y()<<", "<< ini_mom.z()<<G4endl;
+    G4cout << " target momentum = " << momt.e()<<", "<< momt.x()<<", "<< momt.y()<<", "<< momt.z()<<G4endl;
+    G4cout << " Fstate momentum = " << out_mom.e()<<", "<< out_mom.x()<<", "<< out_mom.y()<<", "<< out_mom.z()<<G4endl;
+  }
+  mon_non_cons = ini_mom - out_mom;
+  G4double pnc = mon_non_cons.rho();
   setRemainingExitationEnergy();
 …
     printCollisionOutput();
     G4cout << " momentum non conservation: " << G4endl
            << " e " << mon_non_cons[0]
+           << " e " << mon_non_cons.e()
            << " p " << pnc << G4endl;
     G4cout << " remaining exitation " << eex_rest << G4endl;
+  }
   if(std::fabs(mon_non_cons[0]) > accuracy || pnc > accuracy) { // renormalization
+  if(std::fabs(mon_non_cons.e()) > accuracy || pnc > accuracy) { // renormalization
     G4int npart = outgoingParticles.size();
     if(npart > 0) {
       G4CascadeMomentum last_mom = outgoingParticles[npart - 1].getMomentum();
       for(G4int i = 1; i < 4; i++) last_mom[i] += mon_non_cons[i];
+      G4LorentzVector last_mom = outgoingParticles[npart - 1].getMomentum();
+      last_mom += mon_non_cons;
       outgoingParticles[npart - 1].setMomentum(last_mom);
+    }
 …
       if(nnuc > 0) {
         G4CascadeMomentum last_mom = nucleiFragments[nnuc - 1].getMomentum();
         for(G4int i = 1; i < 4; i++) last_mom[i] += mon_non_cons[i];
+        G4LorentzVector last_mom = nucleiFragments[nnuc - 1].getMomentum();
+        last_mom += mon_non_cons;
         nucleiFragments[nnuc - 1].setMomentum(last_mom);
         nucleiFragments[nnuc - 1].setEnergy();
 …
     };
     out_mom = getTotalOutputMomentum();
+    for(G4int i = 0; i < 4; i++) mon_non_cons[i] = ini_mom[i] - out_mom[i];
+    pnc = std::sqrt(mon_non_cons[1] * mon_non_cons[1] +
+               mon_non_cons[2] * mon_non_cons[2] +
+               mon_non_cons[3] * mon_non_cons[3]);
+    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[0] << " p " << pnc << G4endl;
+             << " e " << mon_non_cons.e() << " p " << pnc << G4endl;
+    }
     G4bool need_hard_tuning = true;
 …
         G4double eex = nucleiFragments[i].getExitationEnergyInGeV();
         if(eex > 0.0 && eex + mon_non_cons[0] >= 0.0) {
           nucleiFragments[i].setExitationEnergy(1000.0 * (eex + mon_non_cons[0]));
+        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[0] > 0.) {
         nucleiFragments[0].setExitationEnergy(1000.0 * mon_non_cons[0]);
+      if(need_hard_tuning && mon_non_cons.e() > 0.) {
+        nucleiFragments[0].setExitationEnergy(1000.0 * mon_non_cons.e());
         need_hard_tuning = false;
       };
 …
     if(need_hard_tuning) {
       std::pair<std::pair<G4int, G4int>, G4int> tune_par = selectPairToTune(mon_non_cons[0]);
+      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(tune_particles.first >= 0 && tune_particles.second >= 0 &&
          mom_ind >= 1) { // tunning possible
         G4CascadeMomentum mom1 = outgoingParticles[tune_particles.first].getMomentum();
         G4CascadeMomentum mom2 = outgoingParticles[tune_particles.second].getMomentum();
         G4double newE12 = mom1[0] + mom2[0] + mon_non_cons[0];
         G4double R = 0.5 * (newE12 * newE12 + mom2[0] * mom2[0] - mom1[0] * mom1[0]) / newE12;
+         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[0] * mom2[0] - R * R) * UDQ;
+        G4double V = (mom2.e() * mom2.e() - R * R) * UDQ;
         G4double DET = W * W + V;
 …
           G4double x = 0.0;
           if(mon_non_cons[0] > 0.0) { // x has to be > 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) {
 …
               };
             };
           };
+          }     // if(mon_non_cons.e() > 0.0)
           if(xset) { // retune momentums
             mom1[mom_ind] += x;
 …
             out_mom = getTotalOutputMomentum();
             std::sort(outgoingParticles.begin(), outgoingParticles.end(), G4ParticleLargerEkin());
+            for(G4int i = 0; i < 4; i++) mon_non_cons[i] = ini_mom[i] - out_mom[i];
+            pnc = std::sqrt(mon_non_cons[1] * mon_non_cons[1] +
+                       mon_non_cons[2] * mon_non_cons[2] +
+                       mon_non_cons[3] * mon_non_cons[3]);
+            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[0] << " p " << pnc << G4endl;
+                     << " e " << mon_non_cons.e() << " p " << pnc << G4endl;
+            }
             if(std::fabs(mon_non_cons[0]) < accuracy || pnc < accuracy) on_shell = true;
+            if(std::fabs(mon_non_cons.e()) < accuracy || pnc < accuracy) on_shell = true;
+          }
           else {
 …
               G4cout << " no appropriate solution found " << G4endl;
+            }
           };
+          }     // if(xset)
+        }
         else {
 …
             G4cout << " DET < 0 " << G4endl;
+          }
         };
+        }       // if(DET > 0.0)
+      }
       else {
 …
           G4cout << " tuning impossible " << G4endl;
+        }
       };
+      } // if (<tuning-possible>)
+    }
     else {
       on_shell = true;
     };
+    }   // if(need_hard_tuning)
+  }
   else {
     on_shell = true;
+  };
+}
+std::pair<std::pair<G4int, G4int>, G4int> G4CollisionOutput::selectPairToTune(G4double de) const {
+  };    // if (<renormalization>)
+}
+void G4CollisionOutput::setRemainingExitationEnergy() {
+  eex_rest = 0.0;
+  for(G4int i = 0; i < G4int(nucleiFragments.size()); i++)
+    eex_rest += 0.001 * nucleiFragments[i].getExitationEnergy();
+}
+std::pair<std::pair<G4int, G4int>, G4int>
+G4CollisionOutput::selectPairToTune(G4double de) const {
   if (verboseLevel > 3) {
     G4cout << " >>> G4CollisionOutput::selectPairToTune" << G4endl;
 …
   std::pair<G4int, G4int> tup(-1, -1);
   G4int i3 = -1;
+  std::pair<std::pair<G4int, G4int>, G4int> badp(tup, i3);
+  if(outgoingParticles.size() < 2) {
+    return badp;
+  }
+  else {
+    G4int ibest1 = -1;
+    G4int ibest2 = -1;
+    G4double pbest = 0.0;
+    G4double pcut = 0.3 * std::sqrt(1.88 * std::fabs(de));
+    G4double p1 = 0.0;
+    G4double p2;
+    for(G4int i = 0; i < G4int(outgoingParticles.size()) - 1; i++) {
+      const G4CascadeMomentum& mom1 = outgoingParticles[i].getMomentum();
+      for(G4int j = i+1; j < G4int(outgoingParticles.size()); j++) {
+        const G4CascadeMomentum& mom2 = outgoingParticles[j].getMomentum();
+        for(G4int l = 1; l < 4; l++) {
+          if(mom1[l] * mom2[l] < 0.0) {
+            if(std::fabs(mom1[l]) > pcut && std::fabs(mom2[l]) > pcut) {
+              G4double psum = std::fabs(mom1[l]) + std::fabs(mom2[l]);
+              if(psum > pbest) {
+                ibest1 = i;
+                ibest2 = j;
+                i3 = l;
+                p1 = mom1[l];
+                p2 = mom2[l];
+                pbest = psum;
+              };
+            };
+          };
+        };
+      };
+    };
+    if(i3 > 0) {
+      if(de > 0.0) {
+        if(p1 > 0.0) {
+          tup.first  = ibest1;
+          tup.second = ibest2;
+        }
+        else {
+          tup.first  = ibest2;
+          tup.second = ibest1;
+        };
+      }
+      else {
+        if(p1 < 0.0) {
+          tup.first  = ibest2;
+          tup.second = ibest1;
+        }
+        else {
+          tup.first  = ibest1;
+          tup.second = ibest2;
+        };
+      };
+      return std::pair<std::pair<G4int, G4int>, G4int>(tup, i3);
+    };
+  };
+  return badp;
+}
+  std::pair<std::pair<G4int, G4int>, G4int> tuner(tup, i3);     // Set invalid
+  if (outgoingParticles.size() < 2) return tuner;       // Nothing to do
+  G4int ibest1 = -1;
+  G4int ibest2 = -1;
+  G4double pbest = 0.0;
+  G4double pcut = 0.3 * std::sqrt(1.88 * std::fabs(de));
+  G4double p1 = 0.0;
+  G4double p2;
+  for (G4int i = 0; i < G4int(outgoingParticles.size()) - 1; i++) {
+    G4LorentzVector mom1 = outgoingParticles[i].getMomentum();
+    for (G4int j = i+1; j < G4int(outgoingParticles.size()); j++) {
+      G4LorentzVector mom2 = outgoingParticles[j].getMomentum();
+      for (G4int l = G4LorentzVector::X; l<=G4LorentzVector::Z; l++) {
+        if (mom1[l]*mom2[l]<0.0) {
+          if (std::fabs(mom1[l])>pcut && std::fabs(mom2[l])>pcut) {
+            G4double psum = std::fabs(mom1[l]) + std::fabs(mom2[l]);
+            if(psum > pbest) {
+              ibest1 = i;
+              ibest2 = j;
+              i3 = l;
+              p1 = mom1[l];
+              p2 = mom2[l];
+              pbest = psum;
+            }   // psum > pbest
+          }     // mom1 and mom2 > pcut
+        }       // mom1 ~ -mom2
+      } // for (G4int l ...
+    }   // for (G4int j ...
+  }     // for (G4int i ...
+  if (i3 < 0) return tuner;
+  tuner.second = i3;            // Momentum axis for tuning
+  // NOTE: Sign of de determines order for special case of p1==0.
+  if (de > 0.0) {
+    tuner.first.first  = (p1>0.) ? ibest1 : ibest2;
+    tuner.first.second = (p1>0.) ? ibest2 : ibest1;
+  } else {
+    tuner.first.first  = (p1<0.) ? ibest2 : ibest1;
+    tuner.first.second = (p1<0.) ? ibest1 : ibest2;
+  }
+  return tuner;
+}

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

-              r1196
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4ElementaryParticleCollider.cc,v 1.64 2010/05/21 18:26:16 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
+// 20100316  D. Wright (restored by M. Kelsey) -- Replace original (incorrect)
+//              pp, pn, nn 2-body to 2-body scattering angular distributions
+//              with a new parametrization of elastic scattering data using
+//              the sum of two exponentials.
+// 20100319  M. Kelsey -- Use new generateWithRandomAngles for theta,phi stuff;
+//              eliminate some unnecessary std::pow()
+// 20100407  M. Kelsey -- Replace std::vector<>::resize(0) with ::clear()
+//              Eliminate return-by-value std::vector<> by creating buffers
+//              buffers for particles, momenta, and particle types.
+//              The following functions now return void and are non-const:
+//                ::generateSCMfinalState()
+//                ::generateMomModules()
+//                ::generateStrangeChannelPartTypes()
+//                ::generateSCMpionAbsorption()
+// 20100408  M. Kelsey -- Follow changes to G4*Sampler to pass particle_kinds
+//              as input buffer.
+// 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
+// 20100428  M. Kelsey -- Use G4InuclParticleNames enum
+// 20100429  M. Kelsey -- Change "photon()" to "isPhoton()"
+// 20100507  M. Kelsey -- Rationalize multiplicity returns to be actual value
+// 20100511  M. Kelsey -- Replace G4PionSampler and G4NucleonSampler with new
+//              pi-N and N-N classes, reorganize if-cascades
+// 20100511  M. Kelsey -- Eliminate three residual random-angles blocks.
+// 20100511  M. Kelsey -- Bug fix: pi-N two-body final states not correctly
+//              tested for charge-exchange case.
+// 20100512  M. Kelsey -- Rationalize multiplicity returns to be actual value
+// 20100512  M. Kelsey -- Add some additional debugging messages for 2-to-2
+// 20100512  M. Kelsey -- Replace "if (is==)" cascades with switch blocks.
+//              Use G4CascadeInterpolator for angular distributions.
+// 20100517  M. Kelsey -- Inherit from common base class, make arrays static
+// 20100519  M. Kelsey -- Use G4InteractionCase to compute "is" values.
+#include "G4ElementaryParticleCollider.hh"
+#include "G4CascadePiMinusNChannel.hh"
+#include "G4CascadePiMinusPChannel.hh"
+#include "G4CascadePiPlusNChannel.hh"
+#include "G4CascadePiPlusPChannel.hh"
+#include "G4CascadePiZeroNChannel.hh"
+#include "G4CascadePiZeroPChannel.hh"
 #include "G4CascadeKplusPChannel.hh"
 #include "G4CascadeKplusNChannel.hh"
 …
 #include "G4CascadeKzeroBarPChannel.hh"
 #include "G4CascadeKzeroBarNChannel.hh"
+#include "G4CascadeNNChannel.hh"
+#include "G4CascadeNPChannel.hh"
+#include "G4CascadePPChannel.hh"
 #include "G4CascadeLambdaPChannel.hh"
 #include "G4CascadeLambdaNChannel.hh"
 …
 #include "G4CascadeXiMinusNChannel.hh"
+#include "G4Collider.hh"
+#include "G4ElementaryParticleCollider.hh"
+#include "G4CascadeInterpolator.hh"
+#include "G4CollisionOutput.hh"
+#include "G4InuclParticleNames.hh"
+#include "G4InuclSpecialFunctions.hh"
 #include "G4ParticleLargerEkin.hh"
+#include "G4LorentzConvertor.hh"
+#include "Randomize.hh"
 #include <algorithm>
+#include <vector>
+using namespace G4InuclParticleNames;
+using namespace G4InuclSpecialFunctions;
 typedef std::vector<G4InuclElementaryParticle>::iterator particleIterator;
 …
 G4ElementaryParticleCollider::G4ElementaryParticleCollider()
+  : verboseLevel(1)
+  : G4VCascadeCollider("G4ElementaryParticleCollider") {}
+void
+G4ElementaryParticleCollider::collide(G4InuclParticle* bullet,
+                                      G4InuclParticle* target,
+                                      G4CollisionOutput& output)
+{
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4ElementaryParticleCollider ctor " << G4endl;
+  }
+  initializeArrays();
+}
+G4CollisionOutput
+G4ElementaryParticleCollider::collide(G4InuclParticle* bullet,
+                                      G4InuclParticle* target)
+{
+  if (!useEPCollider(bullet,target)) {          // Sanity check
+    G4cerr << " ElementaryParticleCollider -> can collide only particle with particle "
+           << G4endl;
+    return;
+  }
+  interCase.set(bullet, target);        // To identify kind of collision
   G4InuclElementaryParticle* particle1 =
     dynamic_cast<G4InuclElementaryParticle*>(bullet);
 …
     dynamic_cast<G4InuclElementaryParticle*>(target);
+  G4CollisionOutput output;
+  if (!(particle1 && particle2)) {
+    G4cout << " ElementaryParticleCollider -> can collide only particle with particle "
+  if (particle1->isPhoton() || particle2->isPhoton()) {
+    G4cout << " ElementaryParticleCollider -> cannot collide photons "
            << G4endl;
   } else {
-    collide(particle1, particle2, output);
+  }
-  return output;
+}
-void
-G4ElementaryParticleCollider::collide(G4InuclElementaryParticle* particle1,
-                                      G4InuclElementaryParticle* particle2,
-                                      G4CollisionOutput& output) {
   // Generate nucleon or pion collision with nucleon
   // or pion with quasi-deuteron
-  if (!particle1->photon() && !particle2->photon()) { // ok
     if (particle1->nucleon() || particle2->nucleon()) { // ok
       G4LorentzConvertor convertToSCM;
       if(particle2->nucleon()) {
         convertToSCM.setBullet(particle1->getMomentum(), particle1->getMass());
         convertToSCM.setTarget(particle2->getMomentum(), particle2->getMass());
+        convertToSCM.setBullet(particle1);
+        convertToSCM.setTarget(particle2);
       } else {
         convertToSCM.setBullet(particle2->getMomentum(), particle2->getMass());
         convertToSCM.setTarget(particle1->getMomentum(), particle1->getMass());
+        convertToSCM.setBullet(particle2);
+        convertToSCM.setTarget(particle1);
       };
       convertToSCM.toTheCenterOfMass();
 …
       G4double pscm = convertToSCM.getSCMMomentum();
       std::vector<G4InuclElementaryParticle> particles =
         generateSCMfinalState(ekin, etot_scm, pscm, particle1, particle2, &convertToSCM);
+      generateSCMfinalState(ekin, etot_scm, pscm, particle1, particle2,
+                            &convertToSCM);
       if(verboseLevel > 2){
 …
+      }
       if(!particles.empty()) { // convert back to Lab
+        G4LorentzVector mom;            // Buffer to avoid memory churn
         particleIterator ipart;
         for(ipart = particles.begin(); ipart != particles.end(); ipart++) {
+          G4CascadeMomentum mom =
+            convertToSCM.backToTheLab(ipart->getMomentum());
+          mom = convertToSCM.backToTheLab(ipart->getMomentum());
           ipart->setMomentum(mom);
         };
         std::sort(particles.begin(), particles.end(), G4ParticleLargerEkin());
+        output.addOutgoingParticles(particles);
       };
-      output.addOutgoingParticles(particles);
     } else {
       if(particle1->quasi_deutron() || particle2->quasi_deutron()) {
 …
           G4LorentzConvertor convertToSCM;
           if(particle1->pion()) {
             convertToSCM.setBullet(particle1->getMomentum(), particle1->getMass());
             convertToSCM.setTarget(particle2->getMomentum(), particle2->getMass());
+            convertToSCM.setBullet(particle1);
+            convertToSCM.setTarget(particle2);
           } else {
             convertToSCM.setBullet(particle2->getMomentum(), particle2->getMass());
             convertToSCM.setTarget(particle1->getMomentum(), particle1->getMass());
+            convertToSCM.setBullet(particle2);
+            convertToSCM.setTarget(particle1);
           };
           convertToSCM.toTheCenterOfMass();
           G4double etot_scm = convertToSCM.getTotalSCMEnergy();
+          std::vector<G4InuclElementaryParticle> particles =
             generateSCMpionAbsorption(etot_scm, particle1, particle2);
+          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++) {
+              G4CascadeMomentum mom =
+                convertToSCM.backToTheLab(ipart->getMomentum());
+              mom = convertToSCM.backToTheLab(ipart->getMomentum());
               ipart->setMomentum(mom);
             };
 …
     };
+  } else {
+    G4cout << " ElementaryParticleCollider -> cannot collide photons "
+           << G4endl;
+  };
+  }
+}
 …
+{
   G4int mul = 0;
+  G4int l = is;
+  if ( ( l > 10 && l < 14 ) || ( l > 14 && l < 63 ) ) {
+    // strange particle branch
+    if ( l == 11 ) {
+      mul = G4CascadeKplusPChannel::getMultiplicity(ekin);
+    } else if ( l == 13 ) {
+      mul = G4CascadeKminusPChannel::getMultiplicity(ekin);
+    } else if ( l == 15 ) {
+      mul = G4CascadeKzeroPChannel::getMultiplicity(ekin);
+    } else if ( l == 17 ) {
+      mul = G4CascadeKzeroBarPChannel::getMultiplicity(ekin);
+    } else if ( l == 21 ) {
+      mul = G4CascadeLambdaPChannel::getMultiplicity(ekin);
+    } else if ( l == 23 ) {
+      mul = G4CascadeSigmaPlusPChannel::getMultiplicity(ekin);
+    } else if ( l == 25 ) {
+      mul = G4CascadeSigmaZeroPChannel::getMultiplicity(ekin);
+    } else if ( l == 27 ) {
+      mul = G4CascadeSigmaMinusPChannel::getMultiplicity(ekin);
+    } else if ( l == 29 ) {
+      mul = G4CascadeXiZeroPChannel::getMultiplicity(ekin);
+    } else if ( l == 31 ) {
+      mul = G4CascadeXiMinusPChannel::getMultiplicity(ekin);
+    } else if ( l == 22 ) {
+      mul = G4CascadeKplusNChannel::getMultiplicity(ekin);
+    } else if ( l == 26 ) {
+      mul = G4CascadeKminusNChannel::getMultiplicity(ekin);
+    } else if ( l == 30 ) {
+      mul = G4CascadeKzeroNChannel::getMultiplicity(ekin);
+    } else if ( l == 34 ) {
+      mul = G4CascadeKzeroBarNChannel::getMultiplicity(ekin);
+    } else if ( l == 42 ) {
+      mul = G4CascadeLambdaNChannel::getMultiplicity(ekin);
+    } else if ( l == 46 ) {
+      mul = G4CascadeSigmaPlusNChannel::getMultiplicity(ekin);
+    } else if ( l == 50 ) {
+      mul = G4CascadeSigmaZeroNChannel::getMultiplicity(ekin);
+    } else if ( l == 54 ) {
+      mul = G4CascadeSigmaMinusNChannel::getMultiplicity(ekin);
+    } else if ( l == 58 ) {
+      mul = G4CascadeXiZeroNChannel::getMultiplicity(ekin);
+    } else if ( l == 62 ) {
+      mul = G4CascadeXiMinusNChannel::getMultiplicity(ekin);
+    } else {
+      G4cout << " G4ElementaryParticleCollider:"
+             << " Unknown strange interaction channel - multiplicity not generated "
+             << G4endl;
+    }
+  // Non-strange branch
+  } else if (l == 1 || l == 4) {
+    mul = nucSampler.GetMultiplicityT1(ekin) - 2;
+    if (mul > 7) G4cout << " Nuc sampler pp mult too high: mul = " << mul << G4endl;
+  } else if (l == 2) {
+    mul = nucSampler.GetMultiplicityT0(ekin) - 2;
+    if (mul > 7) G4cout << " Nuc sampler np mult too high: mul = " << mul << G4endl;
+  } else if (l == 3 || l == 10) {
+    // |T,Tz> = |3/2,3/2>
+    mul = piSampler.GetMultiplicityT33(ekin) - 2;
+  } else if (l == 5 || l == 6) {
+    // |T,Tz> = |3/2,1/2>
+    mul = piSampler.GetMultiplicityT31(ekin) - 2;
+  } else if (l == 7 || l == 14) {
+    // |T,Tz> = |1/2,1/2>
+    mul = piSampler.GetMultiplicityT11(ekin) - 2;
+  } else {
+    G4cout << " G4ElementaryParticleCollider: "
+           << " Unknown interaction channel - multiplicity not generated "
+           << G4endl;
+  switch (is) {
+  case  1: mul = G4CascadePPChannel::getMultiplicity(ekin); break;
+  case  2: mul = G4CascadeNPChannel::getMultiplicity(ekin); break;
+  case  3: mul = G4CascadePiPlusPChannel::getMultiplicity(ekin); break;
+  case  4: mul = G4CascadeNNChannel::getMultiplicity(ekin); break;
+  case  5: mul = G4CascadePiMinusPChannel::getMultiplicity(ekin); break;
+  case  6: mul = G4CascadePiPlusNChannel::getMultiplicity(ekin); break;
+  case  7: mul = G4CascadePiZeroPChannel::getMultiplicity(ekin); break;
+  case 10: mul = G4CascadePiMinusNChannel::getMultiplicity(ekin); break;
+  case 11: mul = G4CascadeKplusPChannel::getMultiplicity(ekin); break;
+  case 13: mul = G4CascadeKminusPChannel::getMultiplicity(ekin); break;
+  case 14: mul = G4CascadePiZeroNChannel::getMultiplicity(ekin); break;
+  case 15: mul = G4CascadeKzeroPChannel::getMultiplicity(ekin); break;
+  case 17: mul = G4CascadeKzeroBarPChannel::getMultiplicity(ekin); break;
+  case 21: mul = G4CascadeLambdaPChannel::getMultiplicity(ekin); break;
+  case 22: mul = G4CascadeKplusNChannel::getMultiplicity(ekin); break;
+  case 23: mul = G4CascadeSigmaPlusPChannel::getMultiplicity(ekin); break;
+  case 25: mul = G4CascadeSigmaZeroPChannel::getMultiplicity(ekin); break;
+  case 26: mul = G4CascadeKminusNChannel::getMultiplicity(ekin); break;
+  case 27: mul = G4CascadeSigmaMinusPChannel::getMultiplicity(ekin); break;
+  case 29: mul = G4CascadeXiZeroPChannel::getMultiplicity(ekin); break;
+  case 30: mul = G4CascadeKzeroNChannel::getMultiplicity(ekin); break;
+  case 31: mul = G4CascadeXiMinusPChannel::getMultiplicity(ekin); break;
+  case 34: mul = G4CascadeKzeroBarNChannel::getMultiplicity(ekin); break;
+  case 42: mul = G4CascadeLambdaNChannel::getMultiplicity(ekin); break;
+  case 46: mul = G4CascadeSigmaPlusNChannel::getMultiplicity(ekin); break;
+  case 50: mul = G4CascadeSigmaZeroNChannel::getMultiplicity(ekin); break;
+  case 54: mul = G4CascadeSigmaMinusNChannel::getMultiplicity(ekin); break;
+  case 58: mul = G4CascadeXiZeroNChannel::getMultiplicity(ekin); break;
+  case 62: mul = G4CascadeXiMinusNChannel::getMultiplicity(ekin); break;
+  default:
+    G4cerr << " G4ElementaryParticleCollider: Unknown interaction channel "
+           << is << " - multiplicity not generated " << G4endl;
+  }
   if(verboseLevel > 3){
     G4cout << " G4ElementaryParticleCollider::generateMultiplicity: "
            << " multiplicity = " << mul + 2 << G4endl;
+  }
   return mul + 2;
+           << " multiplicity = " << mul << G4endl;
+  }
+  return mul;
+}
+std::vector<G4InuclElementaryParticle>
+void
 G4ElementaryParticleCollider::generateSCMfinalState(G4double ekin,
                                      G4double etot_scm,
 …
                                      G4InuclElementaryParticle* particle1,
                                      G4InuclElementaryParticle* particle2,
+                                     G4LorentzConvertor* toSCM) const
+{
+                                     G4LorentzConvertor* toSCM) {
   if (verboseLevel > 3) {
     G4cout << " >>> G4ElementaryParticleCollider::generateSCMfinalState"
 …
   const G4int itry_max = 10;
   G4InuclElementaryParticle dummy;
+  std::vector<G4InuclElementaryParticle> particles;
+  std::vector<G4int> particle_kinds;
   G4int type1 = particle1->type();
   G4int type2 = particle2->type();
   G4int is = type1 * type2;
 …
   G4int multiplicity = 0;
   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.resize(0);
+      particle_kinds.clear();
+    }
+    if(multiplicity == 2) { // 2 -> 2
+      G4int kw = 1;
+      if ( (is > 10 && is < 14) || (is > 14 && is < 63) ) {
+        particle_kinds =
+          generateStrangeChannelPartTypes(is, 2, ekin);
+        G4int finaltype = particle_kinds[0]*particle_kinds[1];
+        if (finaltype != is) kw = 2;  // Charge or strangeness exchange
+      } else if (is == 1 || is == 2 || is == 4) {
+          particle_kinds.push_back(type1);
+          particle_kinds.push_back(type2);
+      } else if (is == 3) {
+        particle_kinds = piSampler.GetFSPartTypesForPipP(2, ekin);
+        if (particle_kinds[0] != G4PionSampler::pro) kw = 2;
+      } else if (is == 10) {
+        particle_kinds = piSampler.GetFSPartTypesForPimN(2, ekin);
+        if (particle_kinds[0] != G4PionSampler::neu) kw = 2;
+      } else if (is == 5) {
+        particle_kinds = piSampler.GetFSPartTypesForPimP(2, ekin);
+        if (particle_kinds[0] != G4PionSampler::pro) kw = 2;
+      } else if (is == 6) {
+        particle_kinds = piSampler.GetFSPartTypesForPipN(2, ekin);
+        if (particle_kinds[0] != G4PionSampler::neu) kw = 2;
+      } else if (is == 7) {
+        particle_kinds = piSampler.GetFSPartTypesForPizP(2, ekin);
+        if (particle_kinds[0] != G4PionSampler::pro) kw = 2;
+      } else if (is == 14) {
+        particle_kinds = piSampler.GetFSPartTypesForPizN(2, ekin);
+        if (particle_kinds[0] != G4PionSampler::neu) kw = 2;
+      } else {
+        G4cout << " Unexpected interaction type (2->2) is = " << is << G4endl;
+      }
+      G4CascadeMomentum mom;
+      if (kw == 2) { // need to rescale momentum
+    // Generate list of final-state particles
+    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) {
+      // Identify charge or strangeness exchange (non-elastic scatter)
+      G4int finaltype = particle_kinds[0]*particle_kinds[1];
+      G4int kw = (finaltype != is) ? 2 : 1;
+      G4double pmod = pscm;     // May need to rescale momentum
+      if (kw == 2) {
         G4double m1 = dummy.getParticleMass(particle_kinds[0]);
         m1 *= m1;
 …
         G4double em = a * a - m1 * m2;
+        if (em > 0) { //  see if it is possible to rescale?
+          G4double np = std::sqrt( em / (m1 + m2 + 2.0 * a));
+          mom = particleSCMmomentumFor2to2(is, kw, ekin, np);
+        } else { // rescaling not possible
+          mom = particleSCMmomentumFor2to2(is, kw, ekin, pscm);
+        if (em > 0) {           //  It is possible to rescale
+          pmod = std::sqrt( em / (m1 + m2 + 2.0 * a));
+        }
+      } else {
+        mom = particleSCMmomentumFor2to2(is, kw, ekin, pscm);
+      };
+      //      G4cout << " Particle kinds = " << particle_kinds[0] << " , " << particle_kinds[1] << G4endl;
+      }
+      G4LorentzVector mom = sampleCMmomentumFor2to2(is, kw, ekin, pmod);
       if (verboseLevel > 3){
+        G4cout << " before rotation px " << mom[1] << " py " << mom[2] <<
+          " pz " << mom[3] << G4endl;
+        G4cout << " Particle kinds = " << particle_kinds[0] << " , "
+               << particle_kinds[1] << G4endl
+               << " before rotation px " << mom.x() << " py " << mom.y()
+               << " pz " << mom.z() << G4endl;
+      }
 …
       if (verboseLevel > 3){
         G4cout << " after rotation px " << mom[1] << " py " << mom[2] <<
           " pz " << mom[3] << G4endl;
+        G4cout << " after rotation px " << mom.x() << " py " << mom.y() <<
+          " pz " << mom.z() << G4endl;
+      }
+      G4CascadeMomentum mom1;
+      for (G4int i = 1; i < 4; i++) mom1[i] = -mom[i];
+      G4LorentzVector mom1 = -mom;
       particles.push_back(G4InuclElementaryParticle(mom, particle_kinds[0], 3));
-      // register modelId
       particles.push_back(G4InuclElementaryParticle(mom1, particle_kinds[1],3));
       generate = false;
+    } else { // 2 -> many
+      if ( (is > 10 && is < 14) || (is > 14 && is < 63) ) {
+        particle_kinds =
+          generateStrangeChannelPartTypes(is, multiplicity, ekin);
+      } else if (is == 1) {
+        particle_kinds = nucSampler.GetFSPartTypesForPP(multiplicity, ekin);
+      } else if (is == 2) {
+        particle_kinds = nucSampler.GetFSPartTypesForNP(multiplicity, ekin);
+      } else if (is == 4) {
+        particle_kinds = nucSampler.GetFSPartTypesForNN(multiplicity, ekin);
+      } else if (is == 3) {
+        particle_kinds = piSampler.GetFSPartTypesForPipP(multiplicity, ekin);
+      } else if (is == 10) {
+        particle_kinds = piSampler.GetFSPartTypesForPimN(multiplicity, ekin);
+      } else if (is == 5) {
+        particle_kinds = piSampler.GetFSPartTypesForPimP(multiplicity, ekin);
+      } else if (is == 6) {
+        particle_kinds = piSampler.GetFSPartTypesForPipN(multiplicity, ekin);
+      } else if (is == 7) {
+        particle_kinds = piSampler.GetFSPartTypesForPizP(multiplicity, ekin);
+      } else if (is == 14) {
+        particle_kinds = piSampler.GetFSPartTypesForPizN(multiplicity, ekin);
+      } else {
+        G4cout << " Unexpected interaction type is = " << is << G4endl;
+      }
+      //      G4cout << " Particle kinds = " ;
+      //      for (G4int i = 0; i < multiplicity; i++) G4cout << particle_kinds[i] << " , " ;
+      //       G4cout << G4endl;
+    } else {                     // 2 -> many
       G4int itry = 0;
       G4bool bad = true;
 …
+        }
+        std::vector<G4double> modules =
+          generateMomModules(particle_kinds, multiplicity, is, ekin, etot_scm);
+        if (G4int(modules.size()) == multiplicity) {
+          if (multiplicity == 3) {
+            G4CascadeMomentum mom3 =
+              particleSCMmomentumFor2to3(is, knd_last, ekin, modules[2]);
+            mom3 = toSCM->rotate(mom3);
+            // generate the momentum of first
+            G4double ct = -0.5 * (modules[2] * modules[2] +
+                                  modules[0] * modules[0] -
+                                  modules[1] * modules[1]) /
+              modules[2] / modules[0];
+            if(std::fabs(ct) < ang_cut) {
+        generateMomModules(multiplicity, is, ekin, etot_scm);
+        if (G4int(modules.size()) != multiplicity) continue;
+        if (multiplicity == 3) {
+          G4LorentzVector mom3 =
+            particleSCMmomentumFor2to3(is, knd_last, ekin, modules[2]);
+          mom3 = toSCM->rotate(mom3);
+          // generate the momentum of first
+          G4double ct = -0.5 * (modules[2] * modules[2] +
+                                modules[0] * modules[0] -
+                                modules[1] * modules[1]) /
+            modules[2] / modules[0];
+          if(std::fabs(ct) < ang_cut) {
+            if(verboseLevel > 2){
+              G4cout << " ok for mult " << multiplicity << G4endl;
+            }
+            G4LorentzVector mom1 = generateWithFixedTheta(ct, modules[0]);
+            mom1 = toSCM->rotate(mom3, mom1);
+            G4LorentzVector mom2 = -(mom3 + mom1);
+            bad = false;
+            generate = false;
+            particles.push_back(G4InuclElementaryParticle(mom1, particle_kinds[0],3));
+            particles.push_back(G4InuclElementaryParticle(mom2, particle_kinds[1],3));
+            particles.push_back(G4InuclElementaryParticle(mom3, particle_kinds[2],3));
+          };
+        } else { // multiplicity > 3
+          // generate first mult - 2 momentums
+          std::vector<G4LorentzVector> scm_momentums;
+          G4LorentzVector tot_mom;
+          for (G4int i = 0; i < multiplicity - 2; i++) {
+            G4double p0 = particle_kinds[i] < 3 ? 0.36 : 0.25;
+            G4double alf = 1.0 / p0 / (p0 - (modules[i] + p0) *
+                                       std::exp(-modules[i] / p0));
+            G4double st = 2.0;
+            G4int itry1 = 0;
+            while (std::fabs(st) > ang_cut && itry1 < itry_max) {
+              itry1++;
+              G4double s1 = modules[i] * inuclRndm();
+              G4double s2 = alf * difr_const * p0 * inuclRndm();
+              if(verboseLevel > 3){
+                G4cout << " s1 * alf * std::exp(-s1 / p0) "
+                       << s1 * alf * std::exp(-s1 / p0)
+                       << " s2 " << s2 << G4endl;
+              }
+              if(s1 * alf * std::exp(-s1 / p0) > s2) st = s1 / modules[i];
+            };
+            if(verboseLevel > 3){
+              G4cout << " itry1 " << itry1 << " i " << i << " st " << st
+                     << G4endl;
+            }
+            if(itry1 == itry_max) {
               if(verboseLevel > 2){
+                G4cout << " ok for mult " << multiplicity << G4endl;
+                G4cout << " high energy angles generation: itry1 " << itry1
+                       << G4endl;
+              }
+              G4CascadeMomentum mom1 = generateWithFixedTheta(ct, modules[0]);
+              mom1 = toSCM->rotate(mom3, mom1);
+              G4CascadeMomentum mom2;
+              for(G4int i = 1; i < 4; i++) mom2[i] = - (mom3[i] + mom1[i]);
+              bad = false;
+              generate = false;
+              particles.push_back(G4InuclElementaryParticle(mom1, particle_kinds[0]));
+              particles.push_back(G4InuclElementaryParticle(mom2, particle_kinds[1]));
+              particles.push_back(G4InuclElementaryParticle(mom3, particle_kinds[2]));
+              st = 0.5 * inuclRndm();
             };
+          } else { // multiplicity > 3
+            // generate first mult - 2 momentums
+            std::vector<G4CascadeMomentum> scm_momentums;
+            G4CascadeMomentum tot_mom;
+            for (G4int i = 0; i < multiplicity - 2; i++) {
+              G4double p0 = particle_kinds[i] < 3 ? 0.36 : 0.25;
+              G4double alf = 1.0 / p0 / (p0 - (modules[i] + p0) *
+                                         std::exp(-modules[i] / p0));
+              G4double st = 2.0;
+              G4int itry1 = 0;
+              while (std::fabs(st) > ang_cut && itry1 < itry_max) {
+                itry1++;
+                G4double s1 = modules[i] * inuclRndm();
+                G4double s2 = alf * difr_const * p0 * inuclRndm();
+                if(verboseLevel > 3){
+                  G4cout << " s1 * alf * std::exp(-s1 / p0) " << s1 * alf * std::exp(-s1 / p0)
+                         << " s2 " << s2 << G4endl;
+                }
+                if(s1 * alf * std::exp(-s1 / p0) > s2) st = s1 / modules[i];
+              };
+              if(verboseLevel > 3){
+                G4cout << " itry1 " << itry1 << " i " << i << " st " << st << G4endl;
+              }
+              if(itry1 == itry_max) {
+                if(verboseLevel > 2){
+                  G4cout << " high energy angles generation: itry1 " << itry1 << G4endl;
+                }
+                st = 0.5 * inuclRndm();
+              };
+              G4double ct = std::sqrt(1.0 - st * st);
+              if(inuclRndm() > 0.5) ct = -ct;
+              G4double pt = modules[i]*st;
+              G4double phi = randomPHI();
+              G4CascadeMomentum mom;
+              mom[1] = pt * std::cos(phi);
+              mom[2] = pt * std::sin(phi);
+              mom[3] = modules[i] * ct;
+              for(G4int i = 1; i < 4; i++) tot_mom[i] += mom[i];
+              scm_momentums.push_back(mom);
+            };
+            // handle last two
+            G4double tot_mod = std::sqrt(tot_mom[1] * tot_mom[1] +
+                                         tot_mom[2] * tot_mom[2] + tot_mom[3] * tot_mom[3]);
+            G4double ct = -0.5 * (tot_mod * tot_mod +
+                                  modules[multiplicity - 2] * modules[multiplicity - 2] -
+                                  modules[multiplicity - 1] * modules[multiplicity - 1]) / tot_mod /
+              modules[multiplicity - 2];
+            G4double ct = std::sqrt(1.0 - st * st);
+            if (inuclRndm() > 0.5) ct = -ct;
+            G4LorentzVector mom = generateWithFixedTheta(ct,modules[i]);
+            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 +
+                                modules[multiplicity - 2] * modules[multiplicity - 2] -
+                                modules[multiplicity - 1] * modules[multiplicity - 1]) / tot_mod /
+            modules[multiplicity - 2];
+          if (verboseLevel > 2){
+            G4cout << " ct last " << ct << G4endl;
+          }
+          if (std::fabs(ct) < ang_cut) {
+            G4int i(0);
+            for (i = 0; i < multiplicity - 2; i++)
+              scm_momentums[i] = toSCM->rotate(scm_momentums[i]);
+            tot_mom = toSCM->rotate(tot_mom);
+            G4LorentzVector mom =
+              generateWithFixedTheta(ct, modules[multiplicity - 2]);
+            mom = toSCM->rotate(tot_mom, mom);
+            scm_momentums.push_back(mom);
+            // and the last one
+            G4LorentzVector mom1 = -(mom+tot_mom);
+            scm_momentums.push_back(mom1);
+            bad = false;
+            generate = false;
             if (verboseLevel > 2){
+              G4cout << " ct last " << ct << G4endl;
+            }
+            if (std::fabs(ct) < ang_cut) {
+              G4int i(0);
+              for (i = 0; i < multiplicity - 2; i++)
+                scm_momentums[i] = toSCM->rotate(scm_momentums[i]);
+              tot_mom = toSCM->rotate(tot_mom);
+              G4CascadeMomentum mom =
+                generateWithFixedTheta(ct, modules[multiplicity - 2]);
+              mom = toSCM->rotate(tot_mom, mom);
+              scm_momentums.push_back(mom);
+              // and the last one
+              G4CascadeMomentum mom1;
+              for (i = 1; i < 4; i++) mom1[i] = -mom[i] - tot_mom[i];
+              scm_momentums.push_back(mom1);
+              bad = false;
+              generate = false;
+              if (verboseLevel > 2){
+                G4cout << " ok for mult " << multiplicity << G4endl;
+              }
+              for (i = 0; i < multiplicity; i++) {
+                particles.push_back(G4InuclElementaryParticle(
+                                                              scm_momentums[i], particle_kinds[i]));
+              };
+              G4cout << " ok for mult " << multiplicity << G4endl;
+            }
+            for (i = 0; i < multiplicity; i++) {
+              particles.push_back(G4InuclElementaryParticle(scm_momentums[i], particle_kinds[i],3));
             };
           };
         };
+          };
+        };
       };
       if (itry == itry_max) {
         if (verboseLevel > 2){
           G4cout << " cannot generate the distr. for mult " << multiplicity  <<
             G4endl << " and set it to " << multiplicity - 1 << G4endl;
+        }
       };
     };
 …
   if (verboseLevel > 3) {
+    G4cout << " <<< G4ElementaryParticleCollider::generateSCMfinalState" << G4endl;
+  }
+  return particles;
+    G4cout << " <<< G4ElementaryParticleCollider::generateSCMfinalState"
+           << G4endl;
+  }
+  return;       // Particles buffer filled
+}
+std::vector<G4double>
+G4ElementaryParticleCollider::generateMomModules(
+                   const std::vector<G4int>& kinds,
+                   G4int mult,
+                   G4int is,
+                   G4double ekin,
+                   G4double etot_cm) const
+{
+void
+G4ElementaryParticleCollider::generateMomModules(G4int mult,
+                                                 G4int is,
+                                                 G4double ekin,
+                                                 G4double etot_cm) {
   if (verboseLevel > 3) {
     G4cout << " >>> G4ElementaryParticleCollider::generateMomModules"
 …
   if (verboseLevel > 2){
     G4cout << " mult " << mult << " is " << is << " ekin " << ekin << " etot_cm " <<
       etot_cm << G4endl;
+    G4cout << " mult " << mult << " is " << is << " ekin " << ekin
+           << " etot_cm " << etot_cm << G4endl;
+  }
 …
   G4int itry = 0;
+  std::vector<G4double> modules(mult);
+  // 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);
   for (G4int i = 0; i < mult; i++) {
     G4double mass = dummy.getParticleMass(kinds[i]);
+    G4double mass = dummy.getParticleMass(particle_kinds[i]);
     masses2[i] = mass * mass;
   };
 …
   if (verboseLevel > 3){
     G4cout << " knd_last " << kinds[mult - 1] << " mlast "
+    G4cout << " knd_last " << particle_kinds[mult - 1] << " mlast "
            << mass_last << G4endl;
+  }
 …
       G4double pmod =
         getMomModuleFor2toMany(is, mult, kinds[i], ekin);
+        getMomModuleFor2toMany(is, mult, particle_kinds[i], ekin);
       if (pmod < small) break;
 …
       if (verboseLevel > 3){
         G4cout << " kp " << kinds[i] << " pmod " << pmod << " mass2 "
+        G4cout << " kp " << particle_kinds[i] << " pmod " << pmod << " mass2 "
                << masses2[i] << G4endl;
         G4cout << " x1 " << eleft - mass_last << G4endl;
 …
         if (mult == 3) {
+          if(satisfyTriangle(modules)) {
+            return modules;
+          }
+        } else {
+          return modules;
+        }
+          if (satisfyTriangle(modules)) return;
+        } else return;
+      }
+    }
+  }
   modules.resize(0);
   return modules;
+  modules.clear();              // Something went wrong, throw away partial
+  return;
+}
 …
+  }
+  G4bool good = true;
+  if(modules.size() == 3) {
+    if(std::fabs(modules[1] - modules[2]) > modules[0] ||
+       modules[0] > modules[1] + modules[2] ||
+       std::fabs(modules[0] - modules[2]) > modules[1] ||
+       modules[1] > modules[0] + modules[2] ||
+       std::fabs(modules[0] - modules[1]) > modules[2] ||
+       modules[2] > modules[1] + modules[0]) good = false;
+  }
+  G4bool good = ( (modules.size() != 3) ||
+                  !(std::fabs(modules[1] - modules[2]) > modules[0] ||
+                    modules[0] > modules[1] + modules[2] ||
+                    std::fabs(modules[0] - modules[2]) > modules[1] ||
+                    modules[1] > modules[0] + modules[2] ||
+                    std::fabs(modules[0] - modules[1]) > modules[2] ||
+                    modules[2] > modules[1] + modules[0]));
   return good;
 …
 std::vector<G4int>
 G4ElementaryParticleCollider::generateStrangeChannelPartTypes(
+                              G4int is, G4int mult, G4double ekin) const
+void
+G4ElementaryParticleCollider::generateOutgoingPartTypes(G4int is, G4int mult,
+                                                        G4double ekin)
+{
+  std::vector<G4int> kinds;
+  if (is == 11) {
+    kinds = G4CascadeKplusPChannel::getOutgoingParticleTypes(mult, ekin);
+  } else if (is == 13) {
+    kinds = G4CascadeKminusPChannel::getOutgoingParticleTypes(mult, ekin);
+  } else if (is == 15) {
+    kinds = G4CascadeKzeroPChannel::getOutgoingParticleTypes(mult, ekin);
+  } else if (is == 17) {
+    kinds = G4CascadeKzeroBarPChannel::getOutgoingParticleTypes(mult, ekin);
+  } else if (is == 21) {
+    kinds = G4CascadeLambdaPChannel::getOutgoingParticleTypes(mult, ekin);
+  } else if (is == 23) {
+    kinds = G4CascadeSigmaPlusPChannel::getOutgoingParticleTypes(mult, ekin);
+  } else if (is == 25) {
+    kinds = G4CascadeSigmaZeroPChannel::getOutgoingParticleTypes(mult, ekin);
+  } else if (is == 27) {
+    kinds = G4CascadeSigmaMinusPChannel::getOutgoingParticleTypes(mult, ekin);
+  } else if (is == 29) {
+    kinds = G4CascadeXiZeroPChannel::getOutgoingParticleTypes(mult, ekin);
+  } else if (is == 31) {
+    kinds = G4CascadeXiMinusPChannel::getOutgoingParticleTypes(mult, ekin);
+  } else if (is == 22) {
+    kinds = G4CascadeKplusNChannel::getOutgoingParticleTypes(mult, ekin);
+  } else if (is == 26) {
+    kinds = G4CascadeKminusNChannel::getOutgoingParticleTypes(mult, ekin);
+  } else if (is == 30) {
+    kinds = G4CascadeKzeroNChannel::getOutgoingParticleTypes(mult, ekin);
+  } else if (is == 34) {
+    kinds = G4CascadeKzeroBarNChannel::getOutgoingParticleTypes(mult, ekin);
+  } else if (is == 42) {
+    kinds = G4CascadeLambdaNChannel::getOutgoingParticleTypes(mult, ekin);
+  } else if (is == 46) {
+    kinds = G4CascadeSigmaPlusNChannel::getOutgoingParticleTypes(mult, ekin);
+  } else if (is == 50) {
+    kinds = G4CascadeSigmaZeroNChannel::getOutgoingParticleTypes(mult, ekin);
+  } else if (is == 54) {
+    kinds = G4CascadeSigmaMinusNChannel::getOutgoingParticleTypes(mult, ekin);
+  } else if (is == 58) {
+    kinds = G4CascadeXiZeroNChannel::getOutgoingParticleTypes(mult, ekin);
+  } else if (is == 62) {
+    kinds = G4CascadeXiMinusNChannel::getOutgoingParticleTypes(mult, ekin);
+  } else {
+    G4cout << " G4ElementaryParticleCollider:"
+           << " Unknown strange interaction channel - outgoing kinds not generated "
+           << G4endl;
+  }
+  return kinds;
+  particle_kinds.clear();       // Initialize buffer for generation
+  switch (is) {
+  case  1: G4CascadePPChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case  2: G4CascadeNPChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case  3: G4CascadePiPlusPChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case  4: G4CascadeNNChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case  5: G4CascadePiMinusPChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case  6: G4CascadePiPlusNChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case  7: G4CascadePiZeroPChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case 10: G4CascadePiMinusNChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case 11: G4CascadeKplusPChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case 13: G4CascadeKminusPChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case 14: G4CascadePiZeroNChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case 15: G4CascadeKzeroPChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case 17: G4CascadeKzeroBarPChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case 21: G4CascadeLambdaPChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case 22: G4CascadeKplusNChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case 23: G4CascadeSigmaPlusPChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case 25: G4CascadeSigmaZeroPChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case 26: G4CascadeKminusNChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case 27: G4CascadeSigmaMinusPChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case 29: G4CascadeXiZeroPChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case 30: G4CascadeKzeroNChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case 31: G4CascadeXiMinusPChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case 34: G4CascadeKzeroBarNChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case 42: G4CascadeLambdaNChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case 46: G4CascadeSigmaPlusNChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case 50: G4CascadeSigmaZeroNChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case 54: G4CascadeSigmaMinusNChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case 58: G4CascadeXiZeroNChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  case 62: G4CascadeXiMinusNChannel::getOutgoingParticleTypes(particle_kinds, mult, ekin); break;
+  default:
+    G4cout << " G4ElementaryParticleCollider: Unknown interaction channel "
+           << is << " - outgoing kinds not generated " << G4endl;
+  }
+  return;
+}
 …
   if(knd == 1 || knd == 2) JM = 1;
   for(G4int m = 0; m < 3; m++) PS += rmn[8 + IM + m][7 + JM][KM - 1] * std::pow(ekin, m);
   G4double PRA = PS * std::sqrt(S) * (PR + (1 - PQ) * std::pow(S, 4));
+  G4double PRA = PS * std::sqrt(S) * (PR + (1 - PQ) * (S*S*S*S));
   return std::fabs(PRA);
 …
 G4CascadeMomentum
+G4LorentzVector
 G4ElementaryParticleCollider::particleSCMmomentumFor2to3(
                            G4int is,
 …
       W += V * std::pow(S, l);
     };
     ct = 2.0 * std::sqrt(S) * (W + (1.0 - U) * std::pow(S, 4)) - 1.0;
+    ct = 2.0 * std::sqrt(S) * (W + (1.0 - U) * (S*S*S*S)) - 1.0;
   };
 …
   };
+  G4double pt = pmod * std::sqrt(1.0 - ct * ct);
+  G4double phi = randomPHI();
+  G4CascadeMomentum mom;
+  mom[1] = pt * std::cos(phi);
+  mom[2] = pt * std::sin(phi);
+  mom[3] = pmod * ct;
+  return mom;
+  return generateWithFixedTheta(ct, pmod);
+}
+std::pair<G4double, G4double>
+G4ElementaryParticleCollider::adjustIntervalForElastic(G4double ekin, G4double ak,
+                                                       G4double ae, G4int k,
+                                                       G4int l,
+                                                       const std::vector<G4double>& ssv,
+                                                       G4double st) const {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4ElementaryParticleCollider::adjustIntervalForElastic"
+G4LorentzVector
+G4ElementaryParticleCollider::sampleCMmomentumFor2to2(G4int is, G4int kw,
+                                                      G4double ekin,
+                                                      G4double pscm) const
+{
+  if (verboseLevel > 3)
+    G4cout << " >>> G4ElementaryParticleCollider::sampleCMmomentumFor2to2"
+           << " is " << is << " kw " << kw << " ekin " << ekin << " pscm "
+           << pscm << G4endl;
+  G4double pA=0.0, pC=0.0, pCos=0.0, pFrac=0.0;         // Angular parameters
+  // Arrays below are parameters for two-exponential sampling of angular
+  // distributions of two-body scattering in the specified channels
+  if (is == 1 || is == 2 || is == 4 ||
+      is == 21 || is == 23 || is == 25 || is == 27 || is ==29 || is == 31 ||
+      is == 42 || is == 46 || is == 50 || is == 54 || is ==58 || is == 62) {
+    // nucleon-nucleon or hyperon-nucleon
+    if (verboseLevel > 3) G4cout << " nucleon/hyperon elastic" << G4endl;
+    static const G4double nnke[9] =  { 0.0,   0.44, 0.59,   0.80,   1.00,   2.24,   4.40,   6.15,  10.00};
+    static const G4double nnA[9] =   { 0.0,   0.34, 2.51,   4.59,   4.2,    5.61,   6.38,   7.93,   8.7};
+    static const G4double nnC[9] =   { 0.0,   0.0,  1.21,   1.54,   1.88,   1.24,   1.91,   4.04,   8.7};
+    static const G4double nnCos[9] = {-1.0,  -1.0, 0.4226, 0.4226, 0.4384, 0.7193, 0.8788, 0.9164,  0.95};
+    static const G4double nnFrac[9] = {1.0,   1.0, 0.4898, 0.7243, 0.7990, 0.8892, 0.8493, 0.9583,  1.0};
+    static G4CascadeInterpolator<9> interp(nnke);       // Only need one!
+    pA = interp.interpolate(ekin, nnA);
+    pC = interp.interpolate(ekin, nnC);
+    pCos = interp.interpolate(ekin, nnCos);
+    pFrac = interp.interpolate(ekin, nnFrac);
+  } else if (kw == 2) {
+    // pion charge exchange (pi-p -> pi0n, pi+n -> pi0p, pi0p -> pi+n, pi0n -> pi-p
+    if (verboseLevel > 3) G4cout << " pion-nucleon charge exchange " << G4endl;
+    static const G4double nnke[10] =   {0.0,   0.062,  0.12,   0.217,  0.533,  0.873,  1.34,   2.86,   5.86,  10.0};
+    static const G4double nnA[10] =    {0.0,   0.0,    2.48,   7.93,  10.0,    9.78,   5.08,   8.13,   8.13,   8.13};
+    static const G4double nnC[10] =    {0.0, -39.58, -12.55,  -4.38,   1.81,  -1.99,  -0.33,   1.2,    1.43,   8.13};
+    static const G4double nnCos[10] =  {1.0,   1.0,    0.604, -0.033,  0.25,   0.55,   0.65,   0.80,   0.916,  0.916};
+    static const G4double nnFrac[10] = {0.0,   0.0,    0.1156, 0.5832, 0.8125, 0.3357, 0.3269, 0.7765, 0.8633, 1.0};
+    static G4CascadeInterpolator<10> interp(nnke);      // Only need one!
+    pA = interp.interpolate(ekin, nnA);
+    pC = interp.interpolate(ekin, nnC);
+    pCos = interp.interpolate(ekin, nnCos);
+    pFrac = interp.interpolate(ekin, nnFrac);
+  } else if (is == 3 || is == 7 || is == 14 || is == 10 || is == 11 ||
+             is == 30 || is == 17 || is == 26) {
+    // pi+p, pi0p, pi0n, pi-n, k+p, k0n, k0bp, or k-n
+    if (verboseLevel > 3) G4cout << " meson-nucleon elastic (1)" << G4endl;
+    static const G4double nnke[10] =   {0.0,  0.062,  0.12,   0.217,  0.533,  0.873,  1.34,   2.86,   5.86,  10.0};
+    static const G4double nnA[10] =    {0.0,  0.0,   27.58,  19.83,   6.46,   4.59,   6.47,   6.68,   6.43,   6.7};
+    static const G4double nnC[10] =    {0.0, -26.4, -30.55, -19.42,  -5.05,  -5.24,  -1.00,   2.14,   2.9,    6.7};
+    static const G4double nnCos[10] =  {1.0,  1.0,    0.174, -0.174, -0.7,   -0.295,  0.5,    0.732,  0.837,  0.89};
+    static const G4double nnFrac[10] = {0.0,  0.0,    0.2980, 0.7196, 0.9812, 0.8363, 0.5602, 0.9601, 0.9901, 1.0};
+    static G4CascadeInterpolator<10> interp(nnke);      // Only need one!
+    pA = interp.interpolate(ekin, nnA);
+    pC = interp.interpolate(ekin, nnC);
+    pCos = interp.interpolate(ekin, nnCos);
+    pFrac = interp.interpolate(ekin, nnFrac);
+  } else if (is == 5 || is == 6 || is == 13 || is == 34 || is == 22 ||
+             is == 15) {
+    // pi-p, pi+n, k-p, k0bn, k+n, or k0p
+    if (verboseLevel > 3) G4cout << " meson-nucleon elastic (2)" << G4endl;
+    static const G4double nnke[10] =   {0.0,  0.062, 0.12,   0.217,  0.533,  0.873,  1.34,   2.86,   5.86,  10.0};
+    static const G4double nnA[10] =    {0.0, 27.08, 19.32,   9.92,   7.74,   9.86,   5.51,   7.25,   7.23,   7.3};
+    static const G4double nnC[10] =    {0.0,  0.0, -19.49, -15.78,  -9.78,  -2.74,  -1.16,   2.31,   2.96,   7.3};
+    static const G4double nnCos[10] = {-1.0, -1.0,  -0.235, -0.259, -0.276,  0.336,  0.250,  0.732,  0.875,  0.9};
+    static const G4double nnFrac[10] = {1.0,  1.0,   0.6918, 0.6419, 0.7821, 0.6542, 0.8382, 0.9722, 0.9784, 1.0};
+    static G4CascadeInterpolator<10> interp(nnke);      // Only need one!
+    pA = interp.interpolate(ekin, nnA);
+    pC = interp.interpolate(ekin, nnC);
+    pCos = interp.interpolate(ekin, nnCos);
+    pFrac = interp.interpolate(ekin, nnFrac);
+  } else {
+    G4cout << " G4ElementaryParticleCollider::sampleCMmomentumFor2to2: interaction not recognized "
            << G4endl;
+  }
+  const G4int itry_max = 100;
+  const G4double small = 1.0e-4;
+  G4double a = 1.0;
+  G4double b = 0.0;
+  G4int adj_type = 0;
+  G4double s1 = 0.0;
+  G4double s2 = 0.0;
+  if (k == 1) {
+    adj_type = 1;
+    s1 = 0.0;
+    s2 = 0.5;
+  } else if(k == 2) {
+    if(l != 2) {
+      // adj_type == 0;
+    } else {
+      adj_type = 1;
+      s1 = 0.0;
+      s2 = 0.67;
+    };
+  }
+  // Use parameters determined above to get polar angle
+  G4double ct = sampleCMcosFor2to2(pscm, pFrac, pA, pC, pCos);
+  return generateWithFixedTheta(ct, pscm);
+}
+G4double
+G4ElementaryParticleCollider::sampleCMcosFor2to2(G4double pscm, G4double pFrac,
+                                                 G4double pA, G4double pC,
+                                                 G4double pCos) const
+{
+  G4double term1;
+  G4double term2;
+  G4double randScale;
+  G4double randVal;
+  G4double costheta = 1.0;
+  if (verboseLevel>3) {
+    G4cout << " sampleCMcosFor2to2: pscm " << pscm << " pFrac " << pFrac
+           << " pA " << pA << " pC " << pC << " pCos " << pCos << G4endl;
+  }
+  if (G4UniformRand() < pFrac) {
+    // Sample small angles ( 0 < theta < theta0 )
+    term1 = 2.0*pscm*pscm*pA;
+    term2 = std::exp(-2.0*term1);
+    randScale = (std::exp(-term1*(1.0 - pCos)) - term2)/(1.0 - term2);
+    randVal = (1.0 - randScale)*G4UniformRand() + randScale;
   } else {
+    if(ekin < 0.32) {
+      // adj_type == 0;
+    } else {
+      adj_type = 2;
+      s1 = 0.1813;
+      s2 = 1.0;
+    };
+  };
+  if(adj_type > 0) {
+    G4int itry = 0;
+    G4double su;
+    G4double ct;
+    if(adj_type == 1) {
+      G4double s2_old = s2;
+      G4double s1c = s1;
+      G4double s2_new;
+      while(itry < itry_max) {
+        itry++;
+        s2_new = 0.5 * (s2_old + s1c);
+        su = 0.0;
+        for(G4int i = 0; i < 4; i++) su += ssv[i] * std::pow(s2_new, i);
+        ct = ak * std::sqrt(s2_new) * (su + (1.0 - st) * std::pow(s2_new, 4)) + ae;
+        if(ct > 1.0) {
+          s2_old = s2_new;
+        } else {
+          if(1.0 - ct < small) {
+            break;
+          } else {
+            s1c = s2_new;
+          };
+        };
+      };
+      a = s2_new - s1;
+      b = s1;
+    } else {
+      G4double s1_old = s1;
+      G4double s2c = s2;
+      G4double s1_new = 0.0;
+      while (itry < itry_max) {
+        itry++;
+        s1_new = 0.5 * (s1_old + s2c);
+        su = 0.0;
+        for (G4int i = 0; i < 4; i++) su += ssv[i] * std::pow(s1_new, i);
+        ct = ak * std::sqrt(s1_new) * (su + (1.0 - st) * std::pow(s1_new, 4)) + ae;
+        if(ct < -1.0) {
+          s1_old = s1_new;
+        } else {
+          if (1.0 + ct < small) {
+            break;
+          } else {
+            s2c = s1_new;
+          };
+        };
+      };
+      a = s2 - s1_new;
+      b = s1_new;
+    };
+    if (itry == itry_max) {
+      if (verboseLevel > 2){
+        G4cout << " in adjustIntervalForElastic: " << itry_max << G4endl;
+        G4cout << " e " << ekin << " ak " << ak << " ae " << ae << G4endl << " k " << k
+               << " is " << l << " adj_type " << adj_type << G4endl;
+      }
+      a = 1.0;
+      b = 0.0;
+    };
+  };
+  return std::pair<G4double, G4double>(a, b);
+}
+G4CascadeMomentum
+G4ElementaryParticleCollider::particleSCMmomentumFor2to2(
+                           G4int is,
+                           G4int kw,
+                           G4double ekin,
+                           G4double pscm) const
+{
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4ElementaryParticleCollider::particleSCMmomentumFor2to2"
+           << G4endl;
+  }
+  const G4int itry_max = 100;
+  const G4double ct_cut = 0.9999;
+  const G4double huge_num = 60.0;
+  G4int k = getElasticCase(is, kw, ekin);
+  G4double ae = -1.0;
+  G4double ak = 2.0;
+  if(k == 1) {
+    if(is != 2) { ak = 1.0; ae = 0.0;};
+  } else if(k == 2) {
+    if(is != 2) { ak = 0.5; ae = 0.0; };
+  }
+  G4double ct = 2.0;
+  G4double ab;
+  G4double ac;
+  G4double ad;
+  G4int itry = 0;
+  if(k == 14) {
+    ab = 7.5;
+    if(is == 1 || is == 2 || is == 4) ab = 8.7;
+    ac = -2.0 * ab * pscm * pscm;
+    ad = 2.0 * ac;
+    if(ad < -huge_num) {
+      ad = std::exp(ad);
+    } else {
+      ad = std::exp(-huge_num);
+    };
+    while(std::fabs(ct) > ct_cut && itry < itry_max) {
+      itry++;
+      ct = 1.0 - std::log(inuclRndm() * (1.0 - ad) + ad) / ac;
+    };
+  } else if(k == 0) {
+    ct = 2.0 * inuclRndm() - 1;
+  } else {
+    G4int k1 = k - 1;
+    // first set all coefficients
+    std::vector<G4double> ssv(4);
+    G4double st = 0.0;
+    for(G4int i = 0; i < 4; i++) {
+      G4double ss = 0.0;
+      for(G4int m = 0; m < 4; m++) ss += ang[m][i][k1] * std::pow(ekin, m);
+      st += ss;
+      ssv[i] = ss;
+    };
+    G4double a = 1.0;
+    G4double b = 0.0;
+    if(k <= 3) {
+      std::pair<G4double, G4double> ab = adjustIntervalForElastic(ekin, ak, ae, k, is, ssv, st);
+      a = ab.first;
+      b = ab.second;
+    };
+    while(std::fabs(ct) > ct_cut && itry < itry_max) {
+      itry++;
+      G4double mrand = a * inuclRndm() + b;
+      G4double su = 0.0;
+      for(G4int i = 0; i < 4; i++) su += ssv[i] * std::pow(mrand, i);
+      ct = ak * std::sqrt(mrand) * (su + (1.0 - st) * std::pow(mrand, 4)) + ae;
+    };
+  };
+  if(itry == itry_max) {
+    if(verboseLevel > 2){
+      G4cout << " particleSCMmomentumFor2to2 -> itry = itry_max "
+             << itry << G4endl;
+    }
+    ct = 2.0 * inuclRndm() - 1.0;
+  }
+  G4double pt = pscm * std::sqrt(1.0 - ct * ct);
+  G4double phi = randomPHI();
+  G4CascadeMomentum mom;
+  mom[1] = pt * std::cos(phi);
+  mom[2] = pt * std::sin(phi);
+  mom[3] = pscm * ct;
+  return mom;
+    // Sample large angles ( theta0 < theta < 180 )
+    term1 = 2.0*pscm*pscm*pC;
+    term2 = std::exp(-2.0*term1);
+    randScale = (std::exp(-term1*(1.0 - pCos)) - term2)/(1.0 - term2);
+    randVal = randScale*G4UniformRand();
+  }
+  costheta = 1.0 + std::log(randVal*(1.0 - term2) + term2)/term1;
+  if (verboseLevel>3) {
+    G4cout << " term1 " << term1 << " term2 " << term2 << " randVal "
+           << randVal << " => costheta " << costheta << G4endl;
+  }
+  return costheta;
+}
+G4int
+G4ElementaryParticleCollider::getElasticCase(G4int is,
+                                             G4int kw,
+                                             G4double ekin) const
+{
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4ElementaryParticleCollider::getElasticCase"
+           << G4endl;
+  }
+  G4int l = is;
+  G4int k = 0; // isotropic
+  if(l == 4) {
+    l = 1;
+  } else if(l == 10 || l == 7 || l == 14) {
+    l = 3;
+  } else if(l == 5 || l == 6) {
+    l = 4;
+  }
+  if(l < 3) { // nucleon nucleon
+    if(ekin > 2.8) {
+      // DHW      k = 2;
+      // DHW      if(ekin > 10.0) k = 14;
+      k = 14;
+    } else {
+      if(l == 1) { // PP or NN
+        if(ekin > 0.46) k = 1;
+      } else {
+        k = 3;
+        if(ekin >= 0.97) k = 1;
+      }
+    }
+  } else { // pi nucleon
+    if(l == 3) { // pi+ P, pi- N, pi0 P, pi0 N
+      k = 8;
+      if(ekin > 0.08) k = 9;
+      if(ekin > 0.3) k = 10;
+      if(ekin > 1.0) k = 11;
+      if(ekin > 2.4) k = 14;
+    } else { // pi- P, pi+ N
+      if(kw == 1) {
+        k = 4;
+        if(ekin > 0.08) k = 5;
+        if(ekin > 0.3) k = 6;
+        if(ekin > 1.0) k = 7;
+        if (ekin > 2.4) k = 14;
+      } else {
+        k = 12;
+        if (ekin > 0.08) k = 13;
+        if (ekin > 0.3) k = 6;
+        if (ekin > 1.0) k = 7;
+        if (ekin > 2.4) k = 14;
+      }
+    }
+  }
+  return k;
+}
+std::vector<G4InuclElementaryParticle>
+void
 G4ElementaryParticleCollider::generateSCMpionAbsorption(G4double etot_scm,
                                      G4InuclElementaryParticle* particle1,
+                                     G4InuclElementaryParticle* particle2) const
+{
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4ElementaryParticleCollider::generateSCMpionAbsorption"
+           << G4endl;
+  }
+                                     G4InuclElementaryParticle* particle2) {
+  if (verboseLevel > 3) G4cout << " >>> G4ElementaryParticleCollider::generateSCMpionAbsorption"
+                               << G4endl;
   // generate nucleons momenta for pion absorption
 …
   G4InuclElementaryParticle dummy;
+  std::vector<G4InuclElementaryParticle> particles;
+  std::vector<G4int> particle_kinds;
+  particles.clear();            // Initialize buffers for this event
+  particle_kinds.clear();
   G4int type1 = particle1->type();
   G4int type2 = particle2->type();
 …
       G4cout << " pion absorption: pi+ + PP -> ? " << G4endl;
       return particles;
+      return;
+    }
     else if(type2 == 112) { // pi+ + PN -> PP
 …
       G4cout << " pion absorption: pi- + NN -> ? " << G4endl;
       return particles;
+      return;
     };
+  }
 …
   G4double m1 = dummy.getParticleMass(particle_kinds[0]);
+  m1 *= m1;
+  G4double m1sq = m1*m1;
   G4double m2 = dummy.getParticleMass(particle_kinds[1]);
+  m2 *= m2;
+  G4double a = 0.5 * (etot_scm * etot_scm - m1 - m2);
+  G4double pmod = std::sqrt((a * a - m1 * m2) / (m1 + m2 + 2.0 * a));
+  G4CascadeMomentum mom;
+  std::pair<G4double, G4double> COS_SIN = randomCOS_SIN();
+  G4double FI = randomPHI();
+  G4double pt = pmod * COS_SIN.second;
+  mom[1] = pt * std::cos(FI);
+  mom[2] = pt * std::sin(FI);
+  mom[3] = pmod * COS_SIN.first;
+  G4CascadeMomentum mom1 = mom;
+  for(G4int i = 1; i < 4; i++) mom1[i] *= -1.0;
+  particles.push_back(G4InuclElementaryParticle(mom , particle_kinds[0]));
+  particles.push_back(G4InuclElementaryParticle(mom1, particle_kinds[1]));
+  return particles;
+  G4double m2sq = m2*m2;
+  G4double a = 0.5 * (etot_scm * etot_scm - m1sq - m2sq);
+  G4double pmod = std::sqrt((a * a - m1sq * m2sq) / (m1sq + m2sq + 2.0 * a));
+  G4LorentzVector mom1 = generateWithRandomAngles(pmod, m1);
+  G4LorentzVector mom2;
+  mom2.setVectM(-mom1.vect(), m2);
+  particles.push_back(G4InuclElementaryParticle(mom1, particle_kinds[0],3));
+  particles.push_back(G4InuclElementaryParticle(mom2, particle_kinds[1],3));
+  return;
+}
+void G4ElementaryParticleCollider::initializeArrays()
+{
+  // Parameter array for momentum calculation of many body final states
+  const G4double rmnData[14][10][2] = {
+    {{0.5028,   0.6305}, {3.1442, -3.7333}, {-7.8172,  13.464}, {8.1667, -18.594},
+     {1.6208,   1.9439}, {-4.3139, -4.6268}, {12.291,  9.7879}, {-15.288, -9.6074},
+     {   0.0,     0.0}, {   0.0,      0.0}},
+    {{0.9348,   2.1801}, {-10.59,  1.5163}, { 29.227,  -16.38}, {-34.55,  27.944},
+     {-0.2009, -0.3464}, {1.3641,   1.1093}, {-3.403, -1.9313}, { 3.8559,  1.7064},
+     {   0.0,     0.0}, {    0.0,     0.0}},
+    {{-0.0967, -1.2886}, {4.7335,  -2.457}, {-14.298,  15.129}, {17.685, -23.295},
+     { 0.0126,  0.0271}, {-0.0835, -0.1164}, { 0.186,  0.2697}, {-0.2004, -0.3185},
+     {   0.0,     0.0}, {    0.0,     0.0}},
+    {{-0.025,   0.2091}, {-0.6248, 0.5228}, { 2.0282, -2.8687}, {-2.5895, 4.2688},
+     {-0.0002, -0.0007}, {0.0014,   0.0051}, {-0.0024, -0.015}, { 0.0022,  0.0196},
+     {    0.0,    0.0}, {    0.0,     0.0}},
+    {{1.1965,   0.9336}, {-0.8289,-1.8181}, { 1.0426,  5.5157}, { -1.909,-8.5216},
+     { 1.2419,  1.8693}, {-4.3633, -5.5678}, { 13.743, 14.795}, {-18.592, -16.903},
+     {    0.0,    0.0}, {    0.0,     0.0}},
+    {{0.287,    1.7811}, {-4.9065,-8.2927}, { 16.264,  20.607}, {-19.904,-20.827},
+     {-0.244,  -0.4996}, {1.3158,   1.7874}, {-3.5691, -4.133}, { 4.3867,  3.8393},
+     {    0.0,    0.0}, {   0.0,      0.0}},
+    {{-0.2449, -1.5264}, { 2.9191, 6.8433}, {-9.5776, -16.067}, { 11.938, 16.845},
+     {0.0157,   0.0462}, {-0.0826, -0.1854}, { 0.2143, 0.4531}, {-0.2585, -0.4627},
+     {    0.0,    0.0}, {   0.0,      0.0}},
+    {{0.0373,   0.2713}, {-0.422, -1.1944}, { 1.3883,  2.7495}, {-1.7476,-2.9045},
+     {-0.0003, -0.0013}, {0.0014,   0.0058}, {-0.0034,-0.0146}, { 0.0039,  0.0156},
+     {    0.0,    0.0}, {    0.0,     0.0}},
+    {{   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0}, {    0.0,     0.0},
+     {    0.0,     0.0}, {   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0},
+     { 0.1451,  0.0929},{ 0.1538,  0.1303}},
+    {{   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0}, {    0.0,     0.0},
+     {    0.0,     0.0}, {   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0},
+     { 0.4652,  0.5389},{ 0.2744,  0.4071}},
+    {{   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0}, {    0.0,     0.0},
+     {    0.0,     0.0}, {   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0},
+     { -0.033, -0.0545},{-0.0146, -0.0288}},
+    {{   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0}, {    0.0,     0.0},
+     {    0.0,     0.0}, {   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0},
+     { 0.6296,  0.1491},{ 0.8381,  0.1802}},
+    {{   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0}, {    0.0,     0.0},
+     {    0.0,     0.0}, {   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0},
+     { 0.1787,   0.385},{ 0.0086,  0.3302}},
+    {{   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0}, {    0.0,     0.0},
+     {    0.0,     0.0}, {   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0},
+     {-0.0026, -0.0128},{ 0.0033, -0.0094}}
+  };
+  // Copy to class scope
+  for (G4int i = 0; i < 14; i++) {
+    for (G4int j = 0; j < 10; j++) {
+      for (G4int k = 0; k < 2; k++) rmn[i][j][k] = rmnData[i][j][k];
+    }
+  }
+  // Parameter array for angular distribution calculation
+  const G4double angData[4][4][13] = {
+    {{ 2.7404, -30.853,  0.1026,-0.3829,  0.2499, 3.9025, 19.402,
+.1579, 0.3153,-17.953, 0.4217, 0.1499,  0.5369},
+     {-9.6998,  106.24, -1.0542, 3.7587,  32.028,-91.126,-224.46,
+.9671,-7.4981, 109.72, 147.05, 2.8753, -13.216},
+     { 10.400, -129.39,  11.389,-6.5144, -118.82, 323.73, 747.33,
+       -5.5251, 43.295,-239.54,-653.35,-5.3078,  81.011},
+     { 2.3882,  54.339, -16.638, 6.7740,  150.99,-400.48,-935.70,
+.8925,-76.460, 228.26, 915.07, 6.2233, -142.85}},
+    {{-7.5137,  19.465, -0.4961, 103.81, -2.6994,-20.619,-44.180,
+      -7.0218,-6.5373, 91.968,-3.5198,-5.9558, -10.550},
+     { 44.096, -68.102,  11.800,-272.82, -460.45, 491.70, 471.94,
+      -205.34, 193.07,-519.63,-260.19,-162.03,  296.29},
+     {-74.379,  96.358, -90.857, 477.59,  1895.9,-1715.5,-1485.6,
+.51,-1018.1, 1126.6, 1225.0, 430.79, -1695.7},
+     { 46.038, -56.827,  164.76,-512.22, -2519.0, 2114.3, 1805.5,
+     -898.58, 1742.6,-1074.0,-1748.1,-625.48,  2893.5}},
+    {{ 7.5479, -3.4831,  1.5437,-1788.2,  16.268, 33.004, 31.567,
+.96, 46.864,-132.70, 3.6373, 128.75,  69.621},
+     {-39.274,  12.341, -33.769, 4305.2,  2138.4,-766.84,-301.76,
+.2,-1303.0, 741.12, 155.92, 3140.2, -1924.5},
+     { 64.835, -18.592,  251.92,-7931.4, -9126.2, 2700.3, 907.63,
+       -14674., 6729.1,-1600.0,-752.01,-7918.9, 10620.0},
+     { 41.609,  12.024, -450.71, 9347.1, 12431.0,-3352.5,-1077.3,
+.,-11075., 1524.9, 1079.6, 10983., -17468.}},
+    {{-1.8369,  0.1894, -1.2021, 7147.5, -29.654,-16.367,-6.8648,
+      -821.16,-95.192, 58.598,-0.7804,-851.61, -138.65},
+     { 8.6911, -0.6788,  0.2534,-3339.5, -3182.3, 373.94, 60.476,
+      -32586., 2637.3,-318.74,-30.563,-18780.,  3928.1},
+     {-13.060,  1.0665, -186.58,-4139.2,  13944.,-1320.2,-175.20,
+.,-12857., 677.51, 147.95, 44607., -20293.},
+     { 7.1880, -0.7291,  332.54,-4436.4, -19342., 1642.3, 203.81,
+       -165530.,20294.,-640.11,-212.50,-58790.,  32058.}}
+  };
+  // Copy to class scope
+  for (G4int i = 0; i < 4; i++) {
+    for (G4int j = 0; j < 4; j++) {
+      for (G4int k = 0; k < 13; k++) ang[i][j][k] = angData[i][j][k];
+    }
+  }
+  const G4double abnData[4][4][4] = {
+    {{0.0856,  0.0716,  0.1729,  0.0376},  {5.0390,  3.0960,  7.1080,  1.4331},
+     {-13.782, -11.125, -17.961, -3.1350},  {14.661,  18.130,  16.403,  6.4864}},
+    {{0.0543,  0.0926, -0.1450,  0.2383}, {-9.2324, -3.2186, -13.032,  1.8253},
+     {36.397,  20.273,  41.781,  1.7648}, {-42.962, -33.245, -40.799, -16.735}},
+    {{-0.0511, -0.0515,  0.0454, -0.1541}, {4.6003,  0.8989,  8.3515, -1.5201},
+     {-20.534, -7.5084, -30.260, -1.5692},  {27.731,  13.188,  32.882,  17.185}},
+    {{0.0075,  0.0058, -0.0048,  0.0250}, {-0.6253, -0.0017, -1.4095,  0.3059},
+     {2.9159,  0.7022,  5.3505,  0.3252}, {-4.1101, -1.4854, -6.0946, -3.5277}}
+  };
+  // Copy to class scope
+  for (G4int i = 0; i < 4; i++) {
+    for (G4int j = 0; j < 4; j++) {
+      for (G4int k = 0; k < 4; k++) abn[i][j][k] = abnData[i][j][k];
+    }
+  }
+}
+// Parameter array for momentum calculation of many body final states
+const G4double G4ElementaryParticleCollider::rmn[14][10][2] = {
+  {{0.5028,   0.6305}, {3.1442, -3.7333}, {-7.8172,  13.464}, {8.1667, -18.594},
+   {1.6208,   1.9439}, {-4.3139, -4.6268}, {12.291,  9.7879}, {-15.288, -9.6074},
+   {   0.0,     0.0}, {   0.0,      0.0}},
+  {{0.9348,   2.1801}, {-10.59,  1.5163}, { 29.227,  -16.38}, {-34.55,  27.944},
+   {-0.2009, -0.3464}, {1.3641,   1.1093}, {-3.403, -1.9313}, { 3.8559,  1.7064},
+   {   0.0,     0.0}, {    0.0,     0.0}},
+  {{-0.0967, -1.2886}, {4.7335,  -2.457}, {-14.298,  15.129}, {17.685, -23.295},
+   { 0.0126,  0.0271}, {-0.0835, -0.1164}, { 0.186,  0.2697}, {-0.2004, -0.3185},
+   {   0.0,     0.0}, {    0.0,     0.0}},
+  {{-0.025,   0.2091}, {-0.6248, 0.5228}, { 2.0282, -2.8687}, {-2.5895, 4.2688},
+   {-0.0002, -0.0007}, {0.0014,   0.0051}, {-0.0024, -0.015}, { 0.0022,  0.0196},
+   {    0.0,    0.0}, {    0.0,     0.0}},
+  {{1.1965,   0.9336}, {-0.8289,-1.8181}, { 1.0426,  5.5157}, { -1.909,-8.5216},
+   { 1.2419,  1.8693}, {-4.3633, -5.5678}, { 13.743, 14.795}, {-18.592, -16.903},
+   {    0.0,    0.0}, {    0.0,     0.0}},
+  {{0.287,    1.7811}, {-4.9065,-8.2927}, { 16.264,  20.607}, {-19.904,-20.827},
+   {-0.244,  -0.4996}, {1.3158,   1.7874}, {-3.5691, -4.133}, { 4.3867,  3.8393},
+   {    0.0,    0.0}, {   0.0,      0.0}},
+  {{-0.2449, -1.5264}, { 2.9191, 6.8433}, {-9.5776, -16.067}, { 11.938, 16.845},
+   {0.0157,   0.0462}, {-0.0826, -0.1854}, { 0.2143, 0.4531}, {-0.2585, -0.4627},
+   {    0.0,    0.0}, {   0.0,      0.0}},
+  {{0.0373,   0.2713}, {-0.422, -1.1944}, { 1.3883,  2.7495}, {-1.7476,-2.9045},
+   {-0.0003, -0.0013}, {0.0014,   0.0058}, {-0.0034,-0.0146}, { 0.0039,  0.0156},
+   {    0.0,    0.0}, {    0.0,     0.0}},
+  {{   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0}, {    0.0,     0.0},
+   {    0.0,     0.0}, {   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0},
+   { 0.1451,  0.0929},{ 0.1538,  0.1303}},
+  {{   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0}, {    0.0,     0.0},
+   {    0.0,     0.0}, {   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0},
+   { 0.4652,  0.5389},{ 0.2744,  0.4071}},
+  {{   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0}, {    0.0,     0.0},
+   {    0.0,     0.0}, {   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0},
+   { -0.033, -0.0545},{-0.0146, -0.0288}},
+  {{   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0}, {    0.0,     0.0},
+   {    0.0,     0.0}, {   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0},
+   { 0.6296,  0.1491},{ 0.8381,  0.1802}},
+  {{   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0}, {    0.0,     0.0},
+   {    0.0,     0.0}, {   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0},
+   { 0.1787,   0.385},{ 0.0086,  0.3302}},
+  {{   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0}, {    0.0,     0.0},
+   {    0.0,     0.0}, {   0.0,      0.0}, {    0.0,    0.0}, {    0.0,     0.0},
+   {-0.0026, -0.0128},{ 0.0033, -0.0094}}
+};
+const G4double G4ElementaryParticleCollider::abn[4][4][4] = {
+  {{0.0856,  0.0716,  0.1729,  0.0376},  {5.0390,  3.0960,  7.1080,  1.4331},
+   {-13.782, -11.125, -17.961, -3.1350},  {14.661,  18.130,  16.403,  6.4864}},
+  {{0.0543,  0.0926, -0.1450,  0.2383}, {-9.2324, -3.2186, -13.032,  1.8253},
+   {36.397,  20.273,  41.781,  1.7648}, {-42.962, -33.245, -40.799, -16.735}},
+  {{-0.0511, -0.0515,  0.0454, -0.1541}, {4.6003,  0.8989,  8.3515, -1.5201},
+   {-20.534, -7.5084, -30.260, -1.5692},  {27.731,  13.188,  32.882,  17.185}},
+  {{0.0075,  0.0058, -0.0048,  0.0250}, {-0.6253, -0.0017, -1.4095,  0.3059},
+   {2.9159,  0.7022,  5.3505,  0.3252}, {-4.1101, -1.4854, -6.0946, -3.5277}}
+};

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4EquilibriumEvaporator.cc,v 1.32 2010/05/21 17:56:34 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
+// 20100308  M. Kelsey -- Bug fix for setting masses of evaporating nuclei
+// 20100319  M. Kelsey -- Use new generateWithRandomAngles for theta,phi stuff;
+//              eliminate some unnecessary std::pow()
+// 20100319  M. Kelsey -- Bug fix in new GetBindingEnergy() use right after
+//              goodRemnant() -- Q1 should be outside call.
+// 20100412  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
+// 20100413  M. Kelsey -- Pass buffers to paraMaker[Truncated]
+// 20100419  M. Kelsey -- Handle fission output list via const-ref
+// 20100517  M. Kelsey -- Use G4CascadeInterpolator for QFF
+// 20100520  M. Kelsey -- Inherit from common base class, make other colliders
+//              simple data members.  Rename timeToBigBang() to override
+//              base explosion().
 #define RUN
 #include "G4EquilibriumEvaporator.hh"
+#include "G4BigBanger.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"
+using namespace G4InuclSpecialFunctions;
 G4EquilibriumEvaporator::G4EquilibriumEvaporator()
+  : verboseLevel(1) {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4EquilibriumEvaporator::G4EquilibriumEvaporator" << G4endl;
+  }
+  : G4VCascadeCollider("G4EquilibriumEvaporator"),
+    theFissioner(new G4Fissioner),
+    theBigBanger(new G4BigBanger) {}
+G4EquilibriumEvaporator::~G4EquilibriumEvaporator() {
+  delete theFissioner;
+  delete theBigBanger;
+}
+G4CollisionOutput G4EquilibriumEvaporator::collide(G4InuclParticle* /*bullet*/,
+                                                   G4InuclParticle* target) {
+void G4EquilibriumEvaporator::collide(G4InuclParticle* /*bullet*/,
+                                      G4InuclParticle* target,
+                                      G4CollisionOutput& output) {
   if (verboseLevel > 3) {
     G4cout << " >>> G4EquilibriumEvaporator::collide" << G4endl;
+  }
+  // Sanity check
+  G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target);
+  if (!nuclei_target) {
+    G4cerr << " EquilibriumEvaporator -> target is not nuclei " << G4endl;
+    return;
+  }
 …
   const G4double huge_num = 50.0;
   const G4double small = -50.0;
-  const G4double one_third = 1.0 / 3.0;
-  const G4double two_thirds = 2.0 / 3.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 };
 …
   G4double coul_coeff;
+  G4CollisionOutput output;
+  if (G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target)) {
     G4double A = nuclei_target->getA();
     G4double Z = nuclei_target->getZ();
     G4CascadeMomentum PEX = nuclei_target->getMomentum();
+    G4LorentzVector PEX = nuclei_target->getMomentum();
     G4double EEXS = nuclei_target->getExitationEnergy();
 …
     G4InuclElementaryParticle dummy(small_ekin, 1);
     G4LorentzConvertor toTheNucleiSystemRestFrame;
     toTheNucleiSystemRestFrame.setBullet(dummy.getMomentum(), dummy.getMass());
     G4CascadeMomentum ppout;
+    toTheNucleiSystemRestFrame.setBullet(dummy);
+    G4LorentzVector ppout;
     if (timeToBigBang(A, Z, EEXS)) {
+    if (explosion(A, Z, EEXS)) {
       if (verboseLevel > 3) {
 …
+      }
       return theBigBanger->collide(0, target);
+      theBigBanger->collide(0, target, output);
+      return;
     } else {
 …
       G4InuclNuclei dummy_nuc;
       G4double EEXS_new;
       G4CascadeMomentum pin = PEX;
       pin[0] += 0.001 * EEXS;
+      G4LorentzVector pin = PEX;
+      pin.setE(pin.e() + 0.001 * EEXS);
       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++;
 …
         nuc_mass = dummy_nuc.getNucleiMass(A, Z);
+        PEX[0] = std::sqrt(PEX[1] * PEX[1] +
+                      PEX[2] * PEX[2] +
+                      PEX[3] * PEX[3] +
+                      nuc_mass * nuc_mass);
+        PEX.setVectM(PEX.vect(), nuc_mass);
         toTheNucleiSystemRestFrame.setTarget(PEX, nuc_mass);
         toTheNucleiSystemRestFrame.toTheTargetRestFrame();
         if (timeToBigBang(A, Z, EEXS)) { // big bang
+        if (explosion(A, Z, EEXS)) { // big bang
           if (verboseLevel > 2){
 …
           nuclei.setExitationEnergy(EEXS);
+          G4CollisionOutput explosion = theBigBanger->collide(0, &nuclei);
+          output.addOutgoingParticles(explosion.getOutgoingParticles());
+          return output;
+          theBigBanger->collide(0, &nuclei, output);
+          return;
         } else { // normal chain
 …
             G4double parlev = getPARLEVDEN(A, Z);
             G4double u1 = parlev * A;
+            std::pair<std::vector<G4double>, std::vector<G4double> > parms = paraMaker(Z);
+            std::vector<G4double> AK = parms.first;
+            std::vector<G4double> CPA = parms.second;
+            G4double DM0 = bindingEnergy(A, Z);
+            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);
 …
               if (goodRemnant(A1[i], Z1[i])) {
+                G4double QB = DM0 - bindingEnergy(A1[i], Z1[i]) - Q1[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) /
                   (std::pow(A1[i], one_third) + std::pow(AN[i], one_third));
+                  (G4cbrt(A1[i]) + G4cbrt(AN[i]));
                 TM[i] = EEXS - QB - V[i] * A / A1[i];
               };
 …
             if (TM[0] > cut_off_energy) {
               G4double AL = getAL(A);
               W[0] = BE * std::pow(A1[0], two_thirds) * G[0] * AL;
+              W[0] = BE * G4cbrt(A1[0]*A1[0]) * G[0] * AL;
               G4double TM1 = 2.0 * std::sqrt(u[0] * TM[0]) - ue;
 …
               if (TM[i] > cut_off_energy) {
                 W[i] = BE * std::pow(A1[i], two_thirds) * G[i] * (1.0 + CPA[i]);
+                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 (T04 < EEXS) {
+                  FMAX = std::pow(T04, 4) * std::exp((EEXS - T04) / T00);
+                  FMAX = (T04*T04*T04*T04) * std::exp((EEXS - T04) / T00);
                 } else {
                   FMAX = std::pow(EEXS, 4);
+                  FMAX = EEXS*EEXS*EEXS*EEXS;
                 };
 …
                   itry++;
                   S = EEXS * inuclRndm();
                   G4double X1 = std::pow(S, 4) * std::exp((EEXS - S) / T00);
+                  G4double X1 = (S*S*S*S) * std::exp((EEXS - S) / T00);
                   if (X1 > FMAX * inuclRndm()) break;
 …
                   particle.setModel(6);
                   G4double pmod = 0.001 * S;
+                  G4CascadeMomentum mom;
+                  std::pair<G4double, G4double> COS_SIN = randomCOS_SIN();
+                  G4double FI = randomPHI();
+                  G4double P1 = pmod * COS_SIN.second;
+                  mom[1] = P1 * std::cos(FI);
+                  mom[2] = P1 * std::sin(FI);
+                  mom[3] = pmod * COS_SIN.first;
+                  mom[0] = pmod;
+                  G4CascadeMomentum mom_at_rest;
+                  for (G4int i = 1; i < 4; i++) mom_at_rest[i] = -mom[i];
+                  mom_at_rest[0] = std::sqrt(mom_at_rest[1] * mom_at_rest[1] +
+                                        mom_at_rest[2] * mom_at_rest[2] +
+                                        mom_at_rest[3] * mom_at_rest[3] +
+                                        nuc_mass * nuc_mass);
+                  G4CascadeMomentum part_mom =
+                    toTheNucleiSystemRestFrame.backToTheLab(mom);
+                  part_mom[0] = std::sqrt(part_mom[1] * part_mom[1] +
+                                     part_mom[2] * part_mom[2] +
+                                     part_mom[3] * part_mom[3]);
+                  G4CascadeMomentum ex_mom =
+                    toTheNucleiSystemRestFrame.backToTheLab(mom_at_rest);
+                  ex_mom[0] = std::sqrt(ex_mom[1] * ex_mom[1] +
+                                   ex_mom[2] * ex_mom[2]
+                                   + ex_mom[3] * ex_mom[3] +
+                                   nuc_mass * nuc_mass);
+                  EEXS_new = 1000.0 * (PEX[0] + 0.001 * EEXS -
+                                       part_mom[0] - ex_mom[0]);
+                  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(part_mom);
+                    particle.setMomentum(mom);
                     output.addOutgoingParticle(particle);
                     for (G4int i = 0; i < 4; i++) ppout[i] += part_mom[i];
+                    ppout += mom;
                   } else {
 …
                       // generate particle momentum
                       G4double pmod = std::sqrt((2.0 * mass + S) * S);
+                      G4CascadeMomentum mom;
+                      std::pair<G4double, G4double> COS_SIN = randomCOS_SIN();
+                      G4double FI = randomPHI();
+                      G4double P1 = pmod * COS_SIN.second;
+                      mom[1] = P1 * std::cos(FI);
+                      mom[2] = P1 * std::sin(FI);
+                      mom[3] = pmod * COS_SIN.first;
+                      G4CascadeMomentum mom_at_rest;
+                      for (G4int i = 1; i < 4; i++) mom_at_rest[i] = -mom[i];
+                      G4double new_nuc_mass = dummy_nuc.getNucleiMass(A1[icase],
+                                                                      Z1[icase]);
+                      mom_at_rest[0] = std::sqrt(mom_at_rest[1] * mom_at_rest[1] +
+                                            mom_at_rest[2] * mom_at_rest[2] +
+                                            mom_at_rest[3] * mom_at_rest[3] +
+                                            new_nuc_mass * new_nuc_mass);
+                      mom[0] = std::sqrt(mom[1] * mom[1] + mom[2] * mom[2] +
+                                    mom[3] * mom[3] + mass * mass);
+                      G4CascadeMomentum part_mom =
+                        toTheNucleiSystemRestFrame.backToTheLab(mom);
+                      part_mom[0] = std::sqrt(part_mom[1] * part_mom[1] +
+                                         part_mom[2] * part_mom[2] +
+                                         part_mom[3] * part_mom[3] +
+                                         mass * mass);
+                      G4CascadeMomentum ex_mom =
+                        toTheNucleiSystemRestFrame.backToTheLab(mom_at_rest);
+                      ex_mom[0] = std::sqrt(ex_mom[1] * ex_mom[1] +
+                                       ex_mom[2] * ex_mom[2] +
+                                       ex_mom[3] * ex_mom[3] +
+                                       new_nuc_mass * new_nuc_mass);
+                      EEXS_new = 1000.0 * (PEX[0] + 0.001 * EEXS -
+                                           part_mom[0] - ex_mom[0]);
+                      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
 …
                         A = A1[icase];
                         Z = Z1[icase];
                         particle.setMomentum(part_mom);
+                        particle.setMomentum(mom);
                         output.addOutgoingParticle(particle);
                         for (G4int i = 0; i < 4; i++) ppout[i] += part_mom[i];
+                        ppout += mom;
                         bad = false;
                       };
                     } else {
                       G4InuclNuclei nuclei(AN[icase], Q[icase]);
 …
                       // generate particle momentum
                       G4double pmod = std::sqrt((2.0 * mass + S) * S);
+                      G4CascadeMomentum mom;
+                      std::pair<G4double, G4double> COS_SIN = randomCOS_SIN();
+                      G4double FI = randomPHI();
+                      G4double P1 = pmod * COS_SIN.second;
+                      mom[1] = P1 * std::cos(FI);
+                      mom[2] = P1 * std::sin(FI);
+                      mom[3] = pmod * COS_SIN.first;
+                      G4CascadeMomentum mom_at_rest;
+                      for (G4int i = 1; i < 4; i++) mom_at_rest[i] = -mom[i];
+                      G4double new_nuc_mass = dummy_nuc.getNucleiMass(A1[icase],
+                                                                      Z1[icase]);
+                      mom_at_rest[0] = std::sqrt(mom_at_rest[1] * mom_at_rest[1] +
+                                            mom_at_rest[2] * mom_at_rest[2] +
+                                            mom_at_rest[3] * mom_at_rest[3] +
+                                            new_nuc_mass * new_nuc_mass);
+                      mom[0] = std::sqrt(mom[1] * mom[1] +
+                                    mom[2] * mom[2] +
+                                    mom[3] * mom[3] +
+                                    mass * mass);
+                      G4CascadeMomentum part_mom =
+                        toTheNucleiSystemRestFrame.backToTheLab(mom);
+                      part_mom[0] = std::sqrt(part_mom[1] * part_mom[1] +
+                                         part_mom[2] * part_mom[2] +
+                                         part_mom[3] * part_mom[3] +
+                                         mass * mass);
+                      G4CascadeMomentum ex_mom =
+                        toTheNucleiSystemRestFrame.backToTheLab(mom_at_rest);
+                      ex_mom[0] = std::sqrt(ex_mom[1] * ex_mom[1] +
+                                       ex_mom[2] * ex_mom[2] +
+                                       ex_mom[3] * ex_mom[3] +
+                                       new_nuc_mass * new_nuc_mass);
+                      EEXS_new = 1000.0 * (PEX[0] + 0.001 * EEXS -
+                                           part_mom[0] - ex_mom[0]);
+                      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
 …
                         Z = Z1[icase];
+                        for (G4int i = 0; i < 4; i++) ppout[i] += part_mom[i];
+                        nuclei.setMomentum(part_mom);
+                        ppout += mom;
                         nuclei.setExitationEnergy(0.0);
                         nuclei.setEnergy();
+                        nuclei.setMomentum(mom);
                         output.addTargetFragment(nuclei);
                         bad = false;
 …
+                }
+                G4CollisionOutput foutput = theFissioner->collide(0, &nuclei);
+                std::vector<G4InuclNuclei> nuclea = foutput.getNucleiFragments();
+                if (nuclea.size() == 2) { // fission o'k
+                  // convert back to the lab
+                // 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++) {
+                    G4CascadeMomentum mom = nuclea[i].getMomentum();
+                    mom = toTheNucleiSystemRestFrame.backToTheLab(mom);
+                    mom = toTheNucleiSystemRestFrame.backToTheLab(nuclea[i].getMomentum());
                     nuclea[i].setMomentum(mom);
+                    nuclea[i].setEnergy();
+                  };
+                  G4CollisionOutput output1 = this->collide(0, &nuclea[0]);
+                  output.addOutgoingParticles(output1.getOutgoingParticles());
+                  output.addTargetFragments(output1.getNucleiFragments());
+                  output1 = this->collide(0, &nuclea[1]);
+                  output.addOutgoingParticles(output1.getOutgoingParticles());
+                  output.addTargetFragments(output1.getNucleiFragments());
+                  return output;
+                  }
+                  this->collide(0, &nuclea[0], output);
+                  this->collide(0, &nuclea[1], output);
+                  return;
                 } else { // fission forbidden now
                   fission_open = false;
 …
+      }
+      G4CascadeMomentum pnuc;
+      for (G4int i = 1; i < 4; i++) pnuc[i] = pin[i] - ppout[i];
+      G4LorentzVector pnuc = pin - ppout;
       G4InuclNuclei nuclei(pnuc, A, Z);
       nuclei.setModel(6);
-      nuclei.setEnergy();
       pnuc = nuclei.getMomentum();
       G4double eout = pnuc[0] + ppout[0];
       G4double eex_real = 1000.0 * (pin[0] - eout);
+      G4double eout = pnuc.e() + ppout.e();
+      G4double eex_real = 1000.0 * (pin.e() - eout);
       nuclei.setExitationEnergy(eex_real);
       output.addTargetFragment(nuclei);
+    };
+  } else {
+    G4cout << " EquilibriumEvaporator -> target is not nuclei " << G4endl;
+  };
+  return output;
+    }
+  return;
+}
+G4bool G4EquilibriumEvaporator::timeToBigBang(G4double a,
+                                              G4double z,
+                                              G4double e) const {
+G4bool G4EquilibriumEvaporator::explosion(G4double a,
+                                          G4double z,
+                                          G4double e) const {
   if (verboseLevel > 3) {
     G4cout << " >>> G4EquilibriumEvaporator::timeToBigBang" << G4endl;
+    G4cout << " >>> G4EquilibriumEvaporator::explosion" << G4endl;
+  }
   const G4double be_cut = 3.0;
+  G4bool bigb = true;
+  if (a >= 12 && z >= 6.0 && z < 3.0 * (a - z)) {
+    bigb = false;
+  } else {
+    if (e < be_cut * bindingEnergy(a, z)) bigb = false;
+  };
+  // 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)))
+                 );
   return bigb;
 …
 G4bool G4EquilibriumEvaporator::goodRemnant(G4double a,
                                             G4double z) const {
   if (verboseLevel > 3) {
     G4cout << " >>> G4EquilibriumEvaporator::goodRemnant" << G4endl;
 …
+  }
   const G4double QFREP[72] = {
+  static const G4double QFREP[72] = {
     //     TL201 *     *   *    *
     //      1    2     3   4    5
 …
 .2,  3.8,  5.6,  4.0,  4.0,  4.2,  4.2,  3.5 };
   const G4double XREP[72] = {
+  static const G4double XREP[72] = {
     //      1      2     3      4      5
 .6761, 0.677, 0.6788, 0.6803, 0.685,
 …
   if (x < XMIN || x > XMAX) {
     G4double X1 = 1.0 - 0.02 * x2;
+    G4double FX = (0.73 + (3.33 * X1 - 0.66) * X1) * std::pow(X1, 3);
+    QFF = G0 * FX * std::pow(a, 2.0 / 3.0);
+    G4double FX = (0.73 + (3.33 * X1 - 0.66) * X1) * (X1*X1*X1);
+    QFF = G0 * FX * G4cbrt(a*a);
   } else {
+    for (G4int i = 1; i < 72; i++) {
+      if (x <= XREP[i]) {
+        QFF = QFREP[i - 1] + (QFREP[i] - QFREP[i - 1]) * (x - XREP[i - 1])/
+          (XREP[i] - XREP[i - 1]);
+        break;
+      };
+    };
+  };
+    static G4CascadeInterpolator<72> interp(XREP);      // Only need one!
+    QFF = interp.interpolate(x, QFREP);
+  }
   if (QFF < 0.0) QFF = 0.0;

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4EvaporationInuclCollider.cc,v 1.10 2010/05/21 17:56:34 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
+// 20100309  M. Kelsey -- Eliminate some unnecessary std::pow()
+// 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
+// 20100517  M. Kelsey -- Inherit from common base class, make other colliders
+//              simple data members.  Eliminate unnecessary G4InuclNuclei ctor.
 #include "G4EvaporationInuclCollider.hh"
 #include "G4InuclElementaryParticle.hh"
 #include "G4LorentzConvertor.hh"
 #include "G4ParticleLargerEkin.hh"
+#include <algorithm>
+#include "G4CollisionOutput.hh"
+#include "G4EquilibriumEvaporator.hh"
+#include "G4InuclNuclei.hh"
 typedef std::vector<G4InuclElementaryParticle>::iterator particleIterator;
 typedef std::vector<G4InuclNuclei>::iterator nucleiIterator;
 G4EvaporationInuclCollider::G4EvaporationInuclCollider()
+  : verboseLevel(0) {
+  : G4VCascadeCollider("G4EvaporationInuclCollider"),
+    theEquilibriumEvaporator(new G4EquilibriumEvaporator) {}
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4EvaporationInuclCollider::G4EvaporationInuclCollider" << G4endl;
+  }
+}
+G4CollisionOutput G4EvaporationInuclCollider::collide(G4InuclParticle* /*bullet*/, G4InuclParticle* target) {
+  verboseLevel = 0;
+void
+G4EvaporationInuclCollider::collide(G4InuclParticle* /*bullet*/,
+                                    G4InuclParticle* target,
+                                    G4CollisionOutput& globalOutput) {
   if (verboseLevel > 3) {
     G4cout << " >>> G4EvaporationInuclCollider::evaporate" << G4endl;
+  }
   G4CollisionOutput globalOutput;
+  if (!dynamic_cast<G4InuclNuclei*>(target)) return;    // Only nuclei evaporate
+  G4LorentzConvertor convertToTargetRestFrame;
+  G4InuclNuclei* ntarget = dynamic_cast<G4InuclNuclei*>(target);
+  convertToTargetRestFrame.setTarget(ntarget->getMomentum(), ntarget->getMass());
+  target->printParticle();      // FIXME: Why is this not verbose protected???
+  G4double at = ntarget->getA();
+  G4double zt = ntarget->getZ();
+  G4double eEx = ntarget->getExitationEnergy();
+  G4CascadeMomentum bmom;
+  bmom[3] = convertToTargetRestFrame.getTRSMomentum();
+  G4InuclNuclei targ(at, zt);
+  G4CascadeMomentum tmom;
+  targ.setExitationEnergy(eEx);
+  targ.setMomentum(tmom);
+  targ.setEnergy();
+  targ.printParticle();
+  G4CollisionOutput output;
+  output = theEquilibriumEvaporator->collide(0, &targ);
+  G4CollisionOutput TRFoutput;
+  TRFoutput.addOutgoingParticles(output.getOutgoingParticles());
+  TRFoutput.addTargetFragments(output.getNucleiFragments());
+  theEquilibriumEvaporator->collide(0, target, globalOutput);
   if (verboseLevel > 3) {
     G4cout << " After EquilibriumEvaporator " << G4endl;
+    output.printCollisionOutput();
+  };
+  std::vector<G4InuclElementaryParticle> particles = TRFoutput.getOutgoingParticles();
+  std::vector<G4InuclNuclei> nucleus = TRFoutput.getNucleiFragments();
+  globalOutput.addOutgoingParticles(particles);
+  globalOutput.addTargetFragments(nucleus);
+  if (verboseLevel > 3) G4cout << "G4EvaporationInuclCollider::collide end" << G4endl;
+  return globalOutput;
+    globalOutput.printCollisionOutput();
+    G4cout << "G4EvaporationInuclCollider::collide end" << G4endl;
+  }
+}
-G4bool G4EvaporationInuclCollider::inelasticInteractionPossible(G4InuclParticle* bullet,
-                                                     G4InuclParticle* target,
-                                                     G4double ekin) const {
-  if (verboseLevel > 3) {
-    G4cout << " >>> G4EvaporationInuclCollider::inelasticInteractionPossible" << G4endl;
+  }
-  const G4double coeff = 0.001 * 1.2;
-  const G4double one_third = 1.0 / 3.0;
-  G4bool possible = true;
-  G4double at;
-  G4double zt;
-  G4double ab;
-  G4double zb;
-  if (G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target)) {
-    at = nuclei_target->getA();
-    zt = nuclei_target->getZ();
-    if (G4InuclNuclei* nuclei_bullet = dynamic_cast<G4InuclNuclei*>(bullet)) {
-      ab = nuclei_bullet->getA();
-      zb = nuclei_bullet->getZ();
-    } else {
-      G4InuclElementaryParticle* particle =
-        dynamic_cast<G4InuclElementaryParticle*>(bullet);
-      ab = 1;
-      zb = particle->getCharge();
-    };
-  } else {
-    if(G4InuclNuclei* nuclei_bullet = dynamic_cast<G4InuclNuclei*>(bullet)) {
-      ab = nuclei_bullet->getA();
-      zb = nuclei_bullet->getZ();
-      G4InuclElementaryParticle* particle =
-        dynamic_cast<G4InuclElementaryParticle*>(target);
-      at = 1;
-      zt = particle->getCharge();
-    } else {
-      return possible;
-    };
-  };
-  // VCOL used  for testing if elastic collision possible
-  G4double VCOL = coeff * zt * zb / (std::pow(at, one_third) + std::pow(ab, one_third));
-  // possible = VCOL < ekin; // NOTE: inelastic collision if not true
-  possible = true; // we force elastic
-  if (verboseLevel > 3) {
-    G4cout << " >>> G4EvaporationInuclCollider::inelasticInteractionPossible" << G4endl;
-    G4cout << " VCOL: " << VCOL << " ekin: " << ekin << " inelastic possible: " << possible << G4endl;
+  }
-  return possible;
+}
-G4InteractionCase G4EvaporationInuclCollider::bulletTargetSetter(G4InuclParticle* bullet,
-                                                      G4InuclParticle* target) const {
-  if (verboseLevel > 3) {
-    G4cout << " >>> G4EvaporationInuclCollider::bulletTargetSetter" << G4endl;
+  }
-  G4InteractionCase interCase;
-  if (G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target)) {
-    if (G4InuclNuclei* nuclei_bullet = dynamic_cast<G4InuclNuclei*>(bullet)) { // A + A
-      interCase.setInterCase(2);
-      if (nuclei_target->getA() >= nuclei_bullet->getA()) {
-        interCase.setBulletTarget(bullet, target);
-      } else {
-        interCase.setBulletTarget(target, bullet);
-      };
-    } else {
-      interCase.setInterCase(1);
-      interCase.setBulletTarget(bullet, target);
-    };
-  } else {
-    G4InuclNuclei* nuclei_bullet = dynamic_cast<G4InuclNuclei*>(bullet);
-    if (nuclei_bullet) {
-      G4InuclElementaryParticle* part =
-        dynamic_cast<G4InuclElementaryParticle*>(target);
-      if (part) {
-        interCase.setInterCase(1);
-        interCase.setBulletTarget(target, bullet);
-      };
-    };
-  };
-  return interCase;
+}
-G4bool G4EvaporationInuclCollider::explosion(G4InuclNuclei* target) const {
-  if (verboseLevel > 3) {
-    G4cout << " >>> G4EvaporationInuclCollider::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();
-  G4bool explo = true;
-  if (a > a_cut) {
-    explo = false;
-  } else {
-    if (eexs < be_cut * bindingEnergy(a, z)) explo = false;
-  };
-  return explo;
+}

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

r819	r1315
28	28
29	29	G4FissionStore::G4FissionStore()
30		: verboseLevel(2){
	30	: verboseLevel(0){
31	31
32	32	if (verboseLevel > 3) {

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4Fissioner.cc,v 1.28 2010/05/21 17:56:34 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
+// 20100318  M. Kelsey -- Bug fix setting mass with G4LV
+// 20100319  M. Kelsey -- Use new generateWithRandomAngles for theta,phi stuff;
+//              eliminate some unnecessary std::pow()
+// 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
+// 20100517  M. Kelsey -- Inherit from common base class
 #include "G4Fissioner.hh"
+#include "G4CollisionOutput.hh"
 #include "G4InuclNuclei.hh"
+#include "G4InuclParticle.hh"
 #include "G4FissionStore.hh"
 #include "G4FissionConfiguration.hh"
+G4Fissioner::G4Fissioner()
+  : verboseLevel(1) {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4Fissioner::G4Fissioner" << G4endl;
+  }
+}
 G4CollisionOutput G4Fissioner::collide(G4InuclParticle* /*bullet*/,
                                        G4InuclParticle* target) {
+#include "G4NucleiProperties.hh"
+#include "G4HadTmpUtil.hh"
+#include "G4InuclSpecialFunctions.hh"
+using namespace G4InuclSpecialFunctions;
+G4Fissioner::G4Fissioner() : G4VCascadeCollider("G4Fissioner") {}
+void G4Fissioner::collide(G4InuclParticle* /*bullet*/,
+                          G4InuclParticle* target,
+                          G4CollisionOutput& output) {
   if (verboseLevel > 3) {
     G4cout << " >>> G4Fissioner::collide" << G4endl;
+  }
-  const G4double one_third = 1.0 / 3.0;
-  const G4double two_thirds = 2.0 / 3.0;
   //  const G4int itry_max = 1000;
-  G4CollisionOutput output;
   if (G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target)) {
 …
     G4double mass_in = nuclei_target->getMass();
     G4double e_in = mass_in + 0.001 * EEXS;
     G4double PARA = 0.055 * std::pow(A, two_thirds) * (std::pow(A - Z, one_third) + std::pow(Z, one_third));
+    G4double PARA = 0.055 * G4cbrt(A*A) * (G4cbrt(A - Z) + G4cbrt(Z));
     G4double TEM = std::sqrt(EEXS / PARA);
     G4double TETA = 0.494 * std::pow(A, one_third) * TEM;
+    G4double TETA = 0.494 * G4cbrt(A) * TEM;
     TETA = TETA / std::sinh(TETA);
 …
     G4double A2 = A - A1;
     G4double ALMA = -1000.0;
+    G4double DM1 = bindingEnergy(A, Z);
+    //    G4double DM1 = bindingEnergy(A, Z);
+    G4double DM1 = G4NucleiProperties::GetBindingEnergy(G4lrint(A), G4lrint(Z));
     G4double EVV = EEXS - DM1;
     G4double DM2 = bindingEnergyAsymptotic(A, Z);
 …
     std::vector<G4double> BET1(2, 0.05);
     G4FissionStore fissionStore;
     G4double R12 = std::pow(A1, one_third) + std::pow(A2, one_third);
+    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 / std::pow(A1, one_third);
       G4double X4 = 1.0 / std::pow(A2, one_third);
+      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);
 …
       potentialMinimization(VPOT, EDEF1, VCOUL, A1, A2, Z1, Z2, AL1, BET1, R12);
+      G4double DM3 = bindingEnergy(A1, Z1);
+      //      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 = bindingEnergy(A2, Z2);
+      G4double DM5 = G4NucleiProperties::GetBindingEnergy(G4lrint(A2), G4lrint(Z2));
       G4double DM6 = bindingEnergyAsymptotic(A2, Z2);
       G4double DMT1 = DM4 + DM6 - DM2;
 …
         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 + 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);
 …
       G4double EK = config.ekin;
       G4double pmod = std::sqrt(0.001 * EK * mass1 * mass2 / mass_in);
+      std::pair<G4double, G4double> COS_SIN = randomCOS_SIN();
+      G4double Fi = randomPHI();
+      G4double P1 = pmod * COS_SIN.second;
+      G4CascadeMomentum mom1;
+      G4CascadeMomentum mom2;
+      mom1[1] = P1 * std::cos(Fi);
+      mom1[2] = P1 * std::sin(Fi);
+      mom1[3] = pmod * COS_SIN.first;
+      for (G4int i = 1; i < 4; i++) mom2[i] = -mom1[i];
+      G4double e_out = std::sqrt(pmod * pmod + mass1 * mass1) +
+        std::sqrt(pmod * pmod + mass2 * mass2);
+      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;
 …
   };
   return output;
+  return;
+}
 …
   G4double C2 = 124.57 * (1.0 / A1 + 1.0 / A2) + 0.78 * (X3 + X4) - 176.9 *
     (std::pow(X3, 4) + std::pow(X4, 4)) + 219.36 * (1.0 / (A1 * A1) + 1.0 / (A2 * A2)) - 1.108 / R12;
+    ((X3*X3*X3*X3) + (X4*X4*X4*X4)) + 219.36 * (1.0 / (A1 * A1) + 1.0 / (A2 * A2)) - 1.108 / R12;
   return C2;
 …
   G4double Zopt = (87.7 * (X4 - X3) * (1.0 - 1.25 * (X4 + X3)) +
                    ZT * ((124.57 / A2 + 0.78 * X4 - 176.9 * std::pow(X4, 4) + 219.36 / (A2 * A2)) - 0.554 / R12)) /
+                   ZT * ((124.57 / A2 + 0.78 * X4 - 176.9 * (X4*X4*X4*X4) + 219.36 / (A2 * A2)) - 0.554 / R12)) /
     getC2(A1, A2, X3, X4, R12);
 …
   const G4double huge_num = 2.0e35;
-  const G4double one_third = 1.0 / 3.0;
-  //  const G4double two_thirds = 2.0 / 3.0;
   const G4int itry_max = 2000;
   const G4double DSOL1 = 1.0e-6;
 …
   for (i = 0; i < 2; i++) {
     R[i] = std::pow(A1[i], one_third);
+    R[i] = G4cbrt(A1[i]);
     Y1 = R[i] * R[i];
     Y2 = Z1[i] * Z1[i] / R[i];

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

-              r1007
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4IntraNucleiCascader.cc,v 1.35 2010/05/21 17:56:34 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
+// 20100307  M. Kelsey -- Bug fix: momentum_out[0] should be momentum_out.e()
+// 20100309  M. Kelsey -- Eliminate some unnecessary std::pow()
+// 20100407  M. Kelsey -- Pass "all_particles" as argument to initializeCascad,
+//              following recent change to G4NucleiModel.
+// 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
+// 20100517  M. Kelsey -- Inherit from common base class, make other colliders
+//              simple data members
+#include "G4IntraNucleiCascader.hh"
 #define RUN
+#include "G4IntraNucleiCascader.hh"
+#include "G4CascadParticle.hh"
+#include "G4CollisionOutput.hh"
+#include "G4ElementaryParticleCollider.hh"
+#include "G4HadTmpUtil.hh"
 #include "G4InuclElementaryParticle.hh"
 #include "G4InuclNuclei.hh"
+#include "G4LorentzConvertor.hh"
+#include "G4InuclSpecialFunctions.hh"
+#include "G4NucleiModel.hh"
+#include "G4NucleiProperties.hh"
 #include "G4ParticleLargerEkin.hh"
-#include "G4NucleiModel.hh"
-#include "G4CascadParticle.hh"
 #include "Randomize.hh"
 #include <algorithm>
+using namespace G4InuclSpecialFunctions;
 typedef std::vector<G4InuclElementaryParticle>::iterator particleIterator;
 G4IntraNucleiCascader::G4IntraNucleiCascader()
+  : verboseLevel(1) {
+  : G4VCascadeCollider("G4IntraNucleiCascader"),
+    theElementaryParticleCollider(new G4ElementaryParticleCollider) {}
+G4IntraNucleiCascader::~G4IntraNucleiCascader() {
+  delete theElementaryParticleCollider;
+}
+void G4IntraNucleiCascader::collide(G4InuclParticle* bullet,
+                                    G4InuclParticle* target,
+                                    G4CollisionOutput& output) {
   if (verboseLevel > 3) {
+    G4cout << " >>> G4IntraNucleiCascader::G4IntraNucleiCascader" << G4endl;
+  }
+}
+G4CollisionOutput G4IntraNucleiCascader::collide(G4InuclParticle* bullet,
+                                                 G4InuclParticle* target) {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4IntraNucleiCascader::collide" << G4endl;
+    G4cout << " >>> G4IntraNucleiCascader::collide inter_case " << inter_case
+           << G4endl;
+  }
 …
     target->printParticle();
+  }
-  G4CollisionOutput output;
 #ifdef RUN
 …
   G4NucleiModel model(tnuclei);
   G4double coulombBarrier = 0.00126*tnuclei->getZ()/
                                       (1.+std::pow(tnuclei->getA(),0.333));
   G4CascadeMomentum momentum_in = bullet->getMomentum();
   momentum_in[0] += tnuclei->getMass();
+                                      (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[0] << " Px " << momentum_in[1]
+           << " Py " << momentum_in[2] << " Pz " << momentum_in[3] << G4endl;
+    G4cout << " intitial momentum  E " << momentum_in.e() << " Px "
+           << momentum_in.x() << " Py " << momentum_in.y() << " Pz "
+           << momentum_in.z() << G4endl;
+  }
 …
       zfin += zb;
       std::pair<std::vector<G4CascadParticle>, std::vector<G4InuclElementaryParticle> >
         all_particles = model.initializeCascad(bnuclei, tnuclei);
+      G4NucleiModel::modelLists all_particles;    // Buffer to receive lists
+      model.initializeCascad(bnuclei, tnuclei, all_particles);
       cascad_particles = all_particles.first;
 …
         for (i = 0; i < ihn; i++) theExitonConfiguration.incrementHoles(2);
         for (i = 0; i < ihz; i++) theExitonConfiguration.incrementHoles(1);
       };
 …
                                             (1./KE - 1./coulombBarrier)*
                                          std::sqrt(mass*(coulombBarrier-KE)) );
             if (G4UniformRand() < CBP) {
               output_particles.push_back(currentParticle);
 …
+    }
     G4CascadeMomentum momentum_out;
+    G4LorentzVector momentum_out;
     particleIterator ipart;
     for (ipart = output_particles.begin(); ipart != output_particles.end(); ipart++) {
+      const G4CascadeMomentum& mom = ipart->getMomentum();
+      for (G4int j = 0; j < 4; j++) momentum_out[j] += mom[j];
+      momentum_out += ipart->getMomentum();
       zfin -= ipart->getCharge();
 …
       G4InuclNuclei outgoing_nuclei(afin, zfin);
       G4double mass = outgoing_nuclei.getMass();
       momentum_out[0] += mass;
       for (int j = 0; j < 4; j++) momentum_out[j] = momentum_in[j] - momentum_out[j];
+      momentum_out.setE(momentum_out.e()+mass);
+      momentum_out = momentum_in - momentum_out;
       if (verboseLevel > 3) {
         G4cout << "  Eex + Ekin " << momentum_out[0]  <<  G4endl;
+        G4cout << "  Eex + Ekin " << momentum_out.e()  <<  G4endl;
+      }
+      if (momentum_out[0] > 0.0) { // Eex + Ekin > 0.0
+        G4double pnuc = momentum_out[1] * momentum_out[1] +
+          momentum_out[2] * momentum_out[2] +
+          momentum_out[3] * momentum_out[3];
+      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[0] - ekin);
+        G4double Eex = 1000.0 * (momentum_out.e() - ekin);
         if (verboseLevel > 3) {
 …
           output.addOutgoingParticles(output_particles);
           outgoing_nuclei.setMomentum(momentum_out);
-          outgoing_nuclei.setEnergy();
           outgoing_nuclei.setExitationEnergy(Eex);
           outgoing_nuclei.setExitonConfiguration(theExitonConfiguration);
           output.addTargetFragment(outgoing_nuclei);
           return output;
+          return;
         };
       };
 …
       if (afin == 1.0) { // recoiling nucleon
         for (int j = 0; j < 4; j++) momentum_out[j] = momentum_in[j] - momentum_out[j];
+        momentum_out = momentum_in - momentum_out;
         G4InuclElementaryParticle  last_particle;
 …
       output.addOutgoingParticles(output_particles);
       return output;
+      return;
     };
   };
 …
   // special branch to avoid the cascad generation but to get the input for evaporation etc
   G4CascadeMomentum momentum_out;
+  G4LorentzVector momentum_out;
   G4InuclNuclei outgoing_nuclei(169, 69);
   outgoing_nuclei.setMomentum(momentum_out);
-  outgoing_nuclei.setEnergy();
   outgoing_nuclei.setExitationEnergy(150.0);
 …
   output.addTargetFragment(outgoing_nuclei);
   return output;
+  return;
   /*
 …
     output.addOutgoingParticle(*bparticle);
     output.addTargetFragment(*tnuclei);
     return output;
+    return;
   */
 …
   output.trivialise(bullet, target);
   return output;
+  return;
+}
 …
   if (eexs > eexs_cut) {
     G4double eexs_max0z = 1000.0 * ein / ediv_cut;
+    G4double dm = bindingEnergy(a, z);
+    //    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;

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4InuclCollider.cc,v 1.30 2010/05/21 17:56:34 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
+// 20100309  M. Kelsey -- Eliminate some unnecessary std::pow()
+// 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
+// 20100418  M. Kelsey -- Move lab-frame transformation code to G4CollisonOutput
+// 20100429  M. Kelsey -- Change "photon()" to "isPhoton()"
+// 20100517  M. Kelsey -- Inherit from common base class, make other colliders
+//              simple data members, consolidate code
 #include "G4InuclCollider.hh"
+#include "G4BigBanger.hh"
+#include "G4CollisionOutput.hh"
+#include "G4ElementaryParticleCollider.hh"
+#include "G4EquilibriumEvaporator.hh"
+#include "G4IntraNucleiCascader.hh"
 #include "G4InuclElementaryParticle.hh"
 #include "G4LorentzConvertor.hh"
+#include "G4ParticleLargerEkin.hh"
+#include <algorithm>
+typedef std::vector<G4InuclElementaryParticle>::iterator particleIterator;
+typedef std::vector<G4InuclNuclei>::iterator nucleiIterator;
+#include "G4NonEquilibriumEvaporator.hh"
 G4InuclCollider::G4InuclCollider()
+  : verboseLevel(0) {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4InuclCollider::G4InuclCollider" << G4endl;
+  }
+  : G4VCascadeCollider("G4InuclCollider"),
+    theElementaryParticleCollider(new G4ElementaryParticleCollider),
+    theIntraNucleiCascader(new G4IntraNucleiCascader),
+    theNonEquilibriumEvaporator(new G4NonEquilibriumEvaporator),
+    theEquilibriumEvaporator(new G4EquilibriumEvaporator),
+    theBigBanger(new G4BigBanger) {}
+G4InuclCollider::~G4InuclCollider() {
+  delete theElementaryParticleCollider;
+  delete theIntraNucleiCascader;
+  delete theNonEquilibriumEvaporator;
+  delete theEquilibriumEvaporator;
+  delete theBigBanger;
+}
+G4CollisionOutput G4InuclCollider::collide(G4InuclParticle* bullet,
+                                           G4InuclParticle* target) {
+  verboseLevel = 0;
+void G4InuclCollider::collide(G4InuclParticle* bullet, G4InuclParticle* target,
+                              G4CollisionOutput& globalOutput) {
   if (verboseLevel > 3) {
     G4cout << " >>> G4InuclCollider::collide" << G4endl;
 …
   const G4int itry_max = 1000;
+  G4CollisionOutput globalOutput;
+  G4InuclElementaryParticle* particle1 =
+    dynamic_cast<G4InuclElementaryParticle*>(bullet);
+  G4InuclElementaryParticle* particle2 =
+    dynamic_cast<G4InuclElementaryParticle*>(target);
+  if (particle1 && particle2) { // particle + particle (NOTE: also the h + H(1,1) treated here)
+  if (useEPCollider(bullet,target)) {
     if (verboseLevel > 2) {
       particle1->printParticle();
       particle2->printParticle();
+      bullet->printParticle();
+      target->printParticle();
+    }
+    globalOutput = theElementaryParticleCollider->collide(bullet, target);
+    theElementaryParticleCollider->collide(bullet, target, globalOutput);
   } else { // needs to call all machinery
     G4LorentzConvertor convertToTargetRestFrame;
+    G4InteractionCase interCase = bulletTargetSetter(bullet, target);
+    G4int intcase = interCase.getInterCase();
+    if (intcase > 0) { // ok
+    interCase.set(bullet,target);
+    if (interCase.valid()) { // ok
       G4InuclNuclei* ntarget =
         dynamic_cast<G4InuclNuclei*>(interCase.getTarget());
+      convertToTargetRestFrame.setTarget(ntarget->getMomentum(),
+                                         ntarget->getMass());
+      convertToTargetRestFrame.setTarget(ntarget);
       G4int btype = 0;
       G4double ab = 0.0;
 …
       G4double zt = ntarget->getZ();
       if (intcase == 1) { // particle with nuclei
+      if (interCase.hadNucleus()) { // particle with nuclei
         G4InuclElementaryParticle* pbullet =
           dynamic_cast<G4InuclElementaryParticle*>(interCase.getBullet());
         if (pbullet->photon()) {
           G4cout << " InuclCollider -> can not collide with photon " << G4endl;
+        if (pbullet->isPhoton()) {
+          G4cerr << " InuclCollider -> can not collide with photon " << G4endl;
           globalOutput.trivialise(bullet, target);
+          return globalOutput;
+          return;
         } else {
+          convertToTargetRestFrame.setBullet(pbullet->getMomentum(),
+                                             pbullet->getMass());
+          convertToTargetRestFrame.setBullet(pbullet);
           btype = pbullet->type();
         };
 …
           dynamic_cast<G4InuclNuclei*>(interCase.getBullet());
+        convertToTargetRestFrame.setBullet(nbullet->getMomentum(),
+                                           nbullet->getMass());
+        convertToTargetRestFrame.setBullet(nbullet);
         ab = nbullet->getA();
         zb = nbullet->getZ();
 …
+        }
+        G4CascadeMomentum bmom;
+        bmom[3] = convertToTargetRestFrame.getTRSMomentum();
+        G4InuclNuclei ntarget(at, zt);
+        G4CascadeMomentum tmom;
+        ntarget.setMomentum(tmom);
+        ntarget.setEnergy();
+        theIntraNucleiCascader->setInteractionCase(intcase);
+        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) {
-          G4CollisionOutput TRFoutput;
-          G4CollisionOutput output;
           itry++;
+          if (intcase == 1) {
+          output.reset();       // Clear buffers for this attempt
+          TRFoutput.reset();
+          if (interCase.hadNucleus()) {
             G4InuclElementaryParticle pbullet(bmom, btype);
             output = theIntraNucleiCascader->collide(&pbullet, &ntarget);
+            theIntraNucleiCascader->collide(&pbullet, &ntarget, output);
           } else {
+            G4InuclNuclei nbullet(ab, zb);
+            nbullet.setMomentum(bmom);
+            nbullet.setEnergy();
+            output = theIntraNucleiCascader->collide(&nbullet, &ntarget);
+            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
+          if (output.numberOfNucleiFragments() == 1) { // there is smth. after
             G4InuclNuclei cascad_rec_nuclei = output.getNucleiFragments()[0];
             if (explosion(&cascad_rec_nuclei)) {
 …
               };
+              output = theBigBanger->collide(0,&cascad_rec_nuclei);
+              TRFoutput.addOutgoingParticles(output.getOutgoingParticles());
+              theBigBanger->collide(0,&cascad_rec_nuclei, TRFoutput);
             } else {
+              output = theNonEquilibriumEvaporator->collide(0, &cascad_rec_nuclei);
+              output.reset();
+              theNonEquilibriumEvaporator->collide(0, &cascad_rec_nuclei, output);
               if (verboseLevel > 3) {
 …
               TRFoutput.addOutgoingParticles(output.getOutgoingParticles());
               G4InuclNuclei exiton_rec_nuclei = output.getNucleiFragments()[0];
+              output = theEquilibriumEvaporator->collide(0, &exiton_rec_nuclei);
+              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());
+              TRFoutput.addTargetFragments(output.getNucleiFragments());
             };
           };
+          // convert to the LAB
+          G4bool withReflection = convertToTargetRestFrame.reflectionNeeded();
+          std::vector<G4InuclElementaryParticle> particles =
+            TRFoutput.getOutgoingParticles();
+          if (!particles.empty()) {
+            particleIterator ipart;
+            for(ipart = particles.begin(); ipart != particles.end(); ipart++) {
+              G4CascadeMomentum mom = ipart->getMomentum();
+              if (withReflection) mom[3] = -mom[3];
+              mom = convertToTargetRestFrame.rotate(mom);
+              ipart->setMomentum(mom);
+              mom = convertToTargetRestFrame.backToTheLab(ipart->getMomentum());
+              ipart->setMomentum(mom);
+            };
+            std::sort(particles.begin(), particles.end(), G4ParticleLargerEkin());
+          };
+          std::vector<G4InuclNuclei> nucleus = TRFoutput.getNucleiFragments();
+          if (!nucleus.empty()) {
+            nucleiIterator inuc;
+            for (inuc = nucleus.begin(); inuc != nucleus.end(); inuc++) {
+              G4CascadeMomentum mom = inuc->getMomentum();
+              if (withReflection) mom[3] = -mom[3];
+              mom = convertToTargetRestFrame.rotate(mom);
+              inuc->setMomentum(mom);
+              inuc->setEnergy();
+              mom = convertToTargetRestFrame.backToTheLab(inuc->getMomentum());
+              inuc->setMomentum(mom);
+              inuc->setEnergy();
+            };
+          };
+          globalOutput.addOutgoingParticles(particles);
+          globalOutput.addTargetFragments(nucleus);
+          // convert to the LAB
+          TRFoutput.boostToLabFrame(convertToTargetRestFrame);
+          globalOutput.addOutgoingParticles(TRFoutput.getOutgoingParticles());
+          globalOutput.addTargetFragments(TRFoutput.getNucleiFragments());
           globalOutput.setOnShell(bullet, target);
+          if(globalOutput.acceptable()) {
+            return globalOutput;
+          } else {
+            globalOutput.reset();
+          };
+          if (globalOutput.acceptable()) return;
+          globalOutput.reset();         // Clear and try again
         };
 …
                  << itry_max << " attempts " << G4endl;
+        }
-        globalOutput.trivialise(bullet, target);
-        return globalOutput;
       } else {
         if (verboseLevel > 3) {
           G4cout << " InuclCollider -> inelastic interaction is impossible " << G4endl
                  << " due to the coulomb barirer " << G4endl;
+        }
+        globalOutput.trivialise(bullet, target);
+        return globalOutput;
+      };
+      }
+      globalOutput.trivialise(bullet, target);
+      return;
     } else {
       if (verboseLevel > 3) {
         G4cout << " InuclCollider -> inter case " << intcase << G4endl;
+        G4cout << " InuclCollider -> inter case " << interCase.code() << G4endl;
       };
     };
   };
   return globalOutput;
+  return;
+}
-G4bool G4InuclCollider::inelasticInteractionPossible(G4InuclParticle* bullet,
-                                                     G4InuclParticle* target,
-                                                     G4double ekin) const {
-  if (verboseLevel > 3) {
-    G4cout << " >>> G4InuclCollider::inelasticInteractionPossible" << G4endl;
+  }
-  const G4double coeff = 0.001 * 1.2;
-  const G4double one_third = 1.0 / 3.0;
-  G4bool possible = true;
-  G4double at;
-  G4double zt;
-  G4double ab;
-  G4double zb;
-  if (G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target)) {
-    at = nuclei_target->getA();
-    zt = nuclei_target->getZ();
-    if (G4InuclNuclei* nuclei_bullet = dynamic_cast<G4InuclNuclei*>(bullet)) {
-      ab = nuclei_bullet->getA();
-      zb = nuclei_bullet->getZ();
-    } else {
-      G4InuclElementaryParticle* particle =
-        dynamic_cast<G4InuclElementaryParticle*>(bullet);
-      ab = 1;
-      zb = particle->getCharge();
-    };
-  } else {
-    if(G4InuclNuclei* nuclei_bullet = dynamic_cast<G4InuclNuclei*>(bullet)) {
-      ab = nuclei_bullet->getA();
-      zb = nuclei_bullet->getZ();
-      G4InuclElementaryParticle* particle =
-        dynamic_cast<G4InuclElementaryParticle*>(target);
-      at = 1;
-      zt = particle->getCharge();
-    } else {
-      return possible;
-    };
-  };
-  // VCOL used  for testing if elastic collision possible
-  G4double VCOL = coeff * zt * zb / (std::pow(at, one_third) + std::pow(ab, one_third));
-  // possible = VCOL < ekin; // NOTE: inelastic collision if not true
-  possible = true; // we force elastic
-  if (verboseLevel > 3) {
-    G4cout << " >>> G4InuclCollider::inelasticInteractionPossible" << G4endl;
-    G4cout << " VCOL: " << VCOL << " ekin: " << ekin << " inelastic possible: " << possible << G4endl;
+  }
-  return possible;
+}
-G4InteractionCase G4InuclCollider::bulletTargetSetter(G4InuclParticle* bullet,
-                                                      G4InuclParticle* target) const {
-  if (verboseLevel > 3) {
-    G4cout << " >>> G4InuclCollider::bulletTargetSetter" << G4endl;
+  }
-  G4InteractionCase interCase;
-  if (G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target)) {
-    if (G4InuclNuclei* nuclei_bullet = dynamic_cast<G4InuclNuclei*>(bullet)) { // A + A
-      interCase.setInterCase(2);
-      if (nuclei_target->getA() >= nuclei_bullet->getA()) {
-        interCase.setBulletTarget(bullet, target);
-      } else {
-        interCase.setBulletTarget(target, bullet);
-      };
-    } else {
-      interCase.setInterCase(1);
-      interCase.setBulletTarget(bullet, target);
-    };
-  } else {
-    G4InuclNuclei* nuclei_bullet = dynamic_cast<G4InuclNuclei*>(bullet);
-    if (nuclei_bullet) {
-      G4InuclElementaryParticle* part =
-        dynamic_cast<G4InuclElementaryParticle*>(target);
-      if (part) {
-        interCase.setInterCase(1);
-        interCase.setBulletTarget(target, bullet);
-      };
-    };
-  };
-  return interCase;
+}
-G4bool G4InuclCollider::explosion(G4InuclNuclei* target) const {
-  if (verboseLevel > 3) {
-    G4cout << " >>> G4InuclCollider::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();
-  G4bool explo = true;
-  if (a > a_cut) {
-    explo = false;
-  } else {
-    if (eexs < be_cut * bindingEnergy(a, z)) explo = false;
-  };
-  return explo;
+}

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4InuclEvaporation.cc,v 1.18 2010/05/21 18:26:16 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// $Id: G4InuclEvaporation.cc,v 1.8 2008/10/24 20:49:07 dennis Exp $
+//
+// 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
+// 20100405  M. Kelsey -- Pass const-ref std::vector<>
+// 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide(), use
+//              const_iterator.
+// 20100428  M. Kelsey -- Use G4InuclParticleNames enum
+// 20100429  M. Kelsey -- Change "case gamma:" to "case photon:"
+// 20100517  M. Kelsey -- Follow new ctors for G4*Collider family.  Make
+//              G4EvaporationInuclCollider a data member.
+// 20100520  M. Kelsey -- Simplify collision loop, move momentum rotations to
+//              G4CollisionOutput, copy G4DynamicParticle directly from
+//              G4InuclParticle, no switch-block required.  Fix scaling factors.
 #include <numeric>
 #include "G4IonTable.hh"
 …
 #include "G4LorentzVector.hh"
 #include "G4EquilibriumEvaporator.hh"
-#include "G4Fissioner.hh"
-#include "G4BigBanger.hh"
 #include "G4InuclElementaryParticle.hh"
 #include "G4InuclParticle.hh"
 #include "G4CollisionOutput.hh"
+#include "G4InuclParticleNames.hh"
+typedef std::vector<G4InuclElementaryParticle>::iterator particleIterator;
+typedef std::vector<G4InuclNuclei>::iterator nucleiIterator;
+using namespace G4InuclParticleNames;
+typedef std::vector<G4InuclElementaryParticle>::const_iterator particleIterator;
+typedef std::vector<G4InuclNuclei>::const_iterator nucleiIterator;
+G4InuclEvaporation::G4InuclEvaporation() {
+  verboseLevel=0;
+}
+G4InuclEvaporation::G4InuclEvaporation()
+  : verboseLevel(0),   evaporator(new G4EvaporationInuclCollider) {}
 G4InuclEvaporation::G4InuclEvaporation(const G4InuclEvaporation &) : G4VEvaporation() {
 …
+}
 G4InuclEvaporation::~G4InuclEvaporation() {
+  delete evaporator;
+}
 …
+}
+G4FragmentVector * G4InuclEvaporation::BreakItUp(const G4Fragment &theNucleus) {
+  enum particleType { nuclei = 0, proton = 1, neutron = 2, pionPlus = 3,
+                      pionMinus = 5, pionZero = 7, photon = 10,
+                      kaonPlus = 11, kaonMinus = 13, kaonZero = 15,
+                      kaonZeroBar = 17, lambda = 21, sigmaPlus = 23,
+                      sigmaZero = 25, sigmaMinus = 27, xiZero = 29, xiMinus = 31 };
+  std::vector< G4DynamicParticle * > secondaryParticleVector;
+  G4FragmentVector * theResult = new G4FragmentVector;
+G4FragmentVector* G4InuclEvaporation::BreakItUp(const G4Fragment &theNucleus) {
+  G4FragmentVector* theResult = new G4FragmentVector;
   if (theNucleus.GetExcitationEnergy() <= 0.0) { // Check that Excitation Energy > 0
 …
   G4double Z = theNucleus.GetZ();
   G4double mTar  = G4NucleiProperties::GetNuclearMass(A, Z); // Mass of the target nucleus
-  G4LorentzVector tmp =theNucleus.GetMomentum();
   G4ThreeVector momentum = tmp.vect();
+  G4ThreeVector momentum =  theNucleus.GetMomentum().vect() / GeV;
   //  G4double energy = tmp.e();
   G4double exitationE = theNucleus.GetExcitationEnergy();
 …
   // Move to CMS frame, save initial velocity of the nucleus to boostToLab vector.
   //   G4ThreeVector boostToLab( ( 1/G4NucleiProperties::GetNuclearMass( A, Z ) ) * momentum );
+  G4InuclNuclei* tempNuc = new G4InuclNuclei(A, Z);
   G4double mass=tempNuc->getMass()*1000;
   G4ThreeVector boostToLab( ( 1/mass) * momentum );
+  G4double mass = mTar / GeV;
+  G4ThreeVector boostToLab( momentum/mass );
   if ( verboseLevel > 2 )
 …
   G4InuclNuclei* nucleus = new G4InuclNuclei(A, Z);
+  nucleus->setExitationEnergy(exitationE/1000);
+  G4CascadeMomentum tmom;
+  nucleus->setMomentum(tmom);
+  nucleus->setEnergy();
+  nucleus->setExitationEnergy(exitationE);
-  G4EquilibriumEvaporator*          eqil = new G4EquilibriumEvaporator;
-  G4Fissioner*                      fiss = new G4Fissioner;
-  G4BigBanger*                      bigb = new G4BigBanger;
-  G4EvaporationInuclCollider* evaporator = new G4EvaporationInuclCollider(eqil, fiss, bigb);
   G4CollisionOutput output;
+  evaporator->collide(0, nucleus, output);
+  output = evaporator->collide(0, nucleus);
+  const std::vector<G4InuclNuclei>& nucleiFragments = output.getNucleiFragments();
+  const std::vector<G4InuclElementaryParticle>& particles = output.getOutgoingParticles();
   std::vector<G4InuclNuclei>             nucleiFragments = output.getNucleiFragments();
   std::vector<G4InuclElementaryParticle> particles =       output.getOutgoingParticles();
+  G4double eTot=0.0;
+  G4int  i=1;
-  G4double ekin,emas;
-  G4double eTot=0.0;
-  G4DynamicParticle* cascadeParticle = 0;
-  G4int  i=1;
-  //G4cout << "# particles: " << output.getOutgoingParticles().size() << G4endl;
   if (!particles.empty()) {
+    particleIterator ipart;
+    G4int outgoingParticle;
+    for (ipart = particles.begin(); ipart != particles.end(); ipart++) {
+      outgoingParticle = ipart->type();
+    G4int outgoingType;
+    particleIterator ipart = particles.begin();
+    for (; ipart != particles.end(); ipart++) {
+      outgoingType = ipart->type();
       if (verboseLevel > 2) {
         G4cout << "Evaporated particle:  " << i << " of type: " << outgoingParticle << G4endl;
+        G4cout << "Evaporated particle:  " << i << " of type: " << outgoingType << G4endl;
         i++;
         //              ipart->printParticle();
+      }
+      const G4CascadeMomentum& mom = ipart->getMomentum();
+      eTot   += std::sqrt(mom[0]*1000 * mom[0]*1000);
+      eTot += ipart->getEnergy();
+      G4LorentzVector vlab = ipart->getMomentum().boost(boostToLab);
+      ekin = ipart->getKineticEnergy()*1000;
+      emas = ipart->getMass()*1000;
+      G4ThreeVector aMom(mom[1]*1000, mom[2]*1000, mom[3]*1000);
+      G4LorentzVector v(aMom, (ekin+emas));
+      v.boost( boostToLab );
+      switch(outgoingParticle) {
+      case proton:
+        cascadeParticle = new G4DynamicParticle(G4Proton::ProtonDefinition(), v.vect(), v.e());
+        break;
+      case neutron:
+        cascadeParticle = new G4DynamicParticle(G4Neutron::NeutronDefinition(), v.vect(), v.e());
+        break;
+      case photon:
+        cascadeParticle = new G4DynamicParticle(G4Gamma::Gamma(), v.vect(), v.e());
+        break;
+      default:
+        G4cout << " ERROR: GInuclEvapration::Propagate undefined particle type" << G4endl;
+      };
+      secondaryParticleVector.push_back( cascadeParticle );
+      theResult->push_back( new G4Fragment(vlab, ipart->getDefinition()) );
       //      theResult.AddSecondary(cascadeParticle);
+    }
+  }
-  fillResult( secondaryParticleVector, theResult);
   //  G4cout << "# fragments " << output.getNucleiFragments().size() << G4endl;
   i=1;
   if (!nucleiFragments.empty()) {
+    nucleiIterator ifrag;
+    for (ifrag = nucleiFragments.begin(); ifrag != nucleiFragments.end(); ifrag++) {
+      ekin = ifrag->getKineticEnergy()*1000;
+      emas = ifrag->getMass()*1000;
+      const G4CascadeMomentum& mom = ifrag->getMomentum();
+      eTot  += std::sqrt(mom[0]*1000 * mom[0]*1000);
+      G4ThreeVector aMom(mom[1]*1000, mom[2]*1000, mom[3]*1000);
+      //      aMom = aMom.unit();
+      G4LorentzVector v(aMom, (ekin+emas));
+      v.boost( boostToLab );
+    nucleiIterator ifrag = nucleiFragments.begin();
+    for (; ifrag != nucleiFragments.end(); ifrag++) {
       if (verboseLevel > 2) {
         G4cout << " Nuclei fragment: " << i << G4endl; i++;
-        //      ifrag->printParticle();
+      }
+      eTot += ifrag->getEnergy();
+      G4LorentzVector vlab = ifrag->getMomentum().boost(boostToLab);
       G4int A = G4int(ifrag->getA());
       G4int Z = G4int(ifrag->getZ());
-      //        cascadeParticle = new G4DynamicParticle(G4Proton::ProtonDefinition(), v.vect(), v.e());
       if (verboseLevel > 2) {
         G4cout << "boosted v" << v << G4endl;
+        G4cout << "boosted v" << vlab << G4endl;
+      }
+      // theResult->push_back( new G4Fragment(A, Z, tmp) );
+      theResult->push_back( new G4Fragment(A, Z, v) );
+      theResult->push_back( new G4Fragment(A, Z, vlab) );
+    }
+  }
 …
   return theResult;
+}
-void G4InuclEvaporation::fillResult( std::vector<G4DynamicParticle *> secondaryParticleVector,
-                                     G4FragmentVector * aResult )
+{
-  // Fill the vector pParticleChange with secondary particles stored in vector.
-  for ( size_t i = 0 ; i < secondaryParticleVector.size() ; i++ )
+    {
-      G4int aZ = static_cast<G4int> (secondaryParticleVector[i]->GetDefinition()->GetPDGCharge() );
-      G4int aA = static_cast<G4int> (secondaryParticleVector[i]->GetDefinition()->GetBaryonNumber());
-      G4LorentzVector aMomentum = secondaryParticleVector[i]->Get4Momentum();
-      if(aA>0) {
-        aResult->push_back( new G4Fragment(aA, aZ, aMomentum) );
-      } else {
-        aResult->push_back( new G4Fragment(aMomentum, secondaryParticleVector[i]->GetDefinition()) );
+      }
+    }
-  return;
+}

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4InuclSpecialFunctions.cc,v 1.19 2010/03/19 05:03:23 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
 #include "G4InuclSpecialFunctions.hh"
+#include "G4LorentzVector.hh"
+#include "G4ThreeVector.hh"
 #include "Randomize.hh"
+#include <cmath>
 G4double G4InuclSpecialFunctions::getAL(G4double A) {
 …
+  }
   return 0.76 + 2.2 / std::pow(A, 0.333333);
+  return 0.76 + 2.2 / G4cbrt(A);
+}
 …
   const G4double C = 55.4;
   G4double Ef;
+  G4double arg = (ntype==0) ? (A-Z)/A : Z/A;
   if (ntype == 0) {
+    Ef = C * std::pow((A - Z) / A, 0.666667);
+  return C * G4cbrt(arg*arg);   // 2/3 power
+}
+  } else {
+    Ef = C * std::pow(Z / A, 0.666667);
+  };
+  return Ef;
+G4double G4InuclSpecialFunctions::G4cbrt(G4double x) {
+  return x==0 ? 0. : (x<0?-1.:1.)*std::exp(std::log(std::fabs(x))/3.);
+}
 …
+}
 G4CascadeMomentum G4InuclSpecialFunctions::generateWithFixedTheta(G4double ct,
+                                                                        G4double p) {
+  G4int verboseLevel = 2;
+G4LorentzVector
+G4InuclSpecialFunctions::generateWithFixedTheta(G4double ct, G4double p,
+                                                G4double m) {
+  const G4int verboseLevel = 0;
   if (verboseLevel > 3) {
     G4cout << " >>> G4InuclSpecialFunctions::generateWithFixedTheta" << G4endl;
+  }
-  G4CascadeMomentum momr;
   G4double phi = randomPHI();
   G4double pt = p * std::sqrt(std::fabs(1.0 - ct * ct));
+  //  not used:  G4CascadeMomentum mom1;
+  momr[1] = pt * std::cos(phi);
+  momr[2] = pt * std::sin(phi);
+  momr[3] = p * ct;
+  static G4ThreeVector pvec;    // Buffers to avoid memory thrashing
+  static G4LorentzVector momr;
+  pvec.set(pt*std::cos(phi), pt*std::sin(phi), p*ct);
+  momr.setVectM(pvec, m);
   return momr;
+}
+G4LorentzVector
+G4InuclSpecialFunctions::generateWithRandomAngles(G4double p, G4double m) {
+  std::pair<G4double, G4double> COS_SIN = randomCOS_SIN();
+  G4double phi = randomPHI();
+  G4double pt = p * COS_SIN.second;
+  static G4ThreeVector pvec;    // Buffers to avoid memory thrashing
+  static G4LorentzVector momr;
+  pvec.set(pt*std::cos(phi), pt*std::sin(phi), p*COS_SIN.first);
+  momr.setVectM(pvec, m);
+  return momr;
+}

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4LorentzConvertor.cc,v 1.23 2010/05/21 17:56:34 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100108  Michael Kelsey -- Use G4LorentzVector internally
+// 20100112  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
+// 20100308  M. Kelsey -- Bug fix in toTheTargetRestFrame: scm_momentum should
+//              be data member, not local.
+// 20100409  M. Kelsey -- Protect std::sqrt(ga) against round-off negatives
+// 20100519  M. Kelsey -- Add interfaces to pass G4InuclParticles directly
 #include "G4LorentzConvertor.hh"
+#include "G4ThreeVector.hh"
 #include "G4HadronicException.hh"
+#include "G4InuclParticle.hh"
+const G4double G4LorentzConvertor::small = 1.0e-10;
 G4LorentzConvertor::G4LorentzConvertor()
   : verboseLevel(2), degenerated(false) {
+  : verboseLevel(0), degenerated(false) {
   if (verboseLevel > 3) {
 …
+}
+// Extract four-vectors from input particles
+void G4LorentzConvertor::setBullet(const G4InuclParticle* bullet) {
+  setBullet(bullet->getMomentum());
+}
+void G4LorentzConvertor::setTarget(const G4InuclParticle* target) {
+  setTarget(target->getMomentum());
+}
+// Boost bullet and target four-vectors into destired frame
 void G4LorentzConvertor::toTheCenterOfMass() {
   if (verboseLevel > 3) {
     G4cout << " >>> G4LorentzConvertor::toTheCenterOfMass" << G4endl;
+  }
+  const G4double small = 1.0e-10;
+  v2 = 0.0;
+  G4double pv = 0.0;
+   G4double e_sum = target_mom[0] + bullet_mom[0];
+  velocity.resize(4);
+  G4int i(0);
+  for(i = 1; i < 4; i++) {
+    velocity[i] = (target_mom[i] + bullet_mom[i]) / e_sum;
+    v2 += velocity[i] * velocity[i];
+    pv += target_mom[i] * velocity[i];
+  };
+  gamma = 1.0 / std::sqrt(std::fabs(1.0 - v2));
+  ecm_tot = e_sum / gamma;
+  G4double pa = 0.0;
+  G4double pb = 0.0;
+  G4double xx = pv * (gamma - 1.0) / v2 - target_mom[0] * gamma;
+  for(i = 1; i < 4; i++) {
+    scm_momentum[i] = -target_mom[i] - velocity[i] * xx;
+    if (verboseLevel > 3) {
+      G4cout << " i " << i << " pscm(i) " << scm_momentum[i] << G4endl;
+    }
+    pa += scm_momentum[i] * scm_momentum[i];
+    pb += scm_momentum[i] * velocity[i];
+  };
+  ga = v2 - pb * pb / pa;
+  if(ga < small) {
+    ga = small;
+    degenerated = true;
+    if (verboseLevel > 3) {
+      G4cout << " degenerated case " << G4endl;
+    }
+  } else {
+    ga = std::sqrt(ga);
+  };
+  if (verboseLevel > 3) {
+    G4cout << " ga " << ga << " v2 " << v2 << " pb " << pb <<
+      " pb * pb / pa " << pb * pb / pa << " pv " << pv << G4endl;
+  }
+  pscm = std::sqrt(pa);
+  G4LorentzVector cm4v = target_mom + bullet_mom;
+  velocity = cm4v.boostVector();
+  // "SCM" is reverse target momentum in the CM frame
+  scm_momentum = target_mom;
+  scm_momentum.boost(-velocity);
+  scm_momentum.setVect(-scm_momentum.vect());
+  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;
+  // Compute kinematic quantities for rotate() functions
+  v2 = velocity.mag2();
+  gamma = cm4v.e()/cm4v.m();
+  ecm_tot = cm4v.m();
+  G4double pscm = scm_momentum.rho();
+  G4double pa   = scm_momentum.vect().mag2();
+  G4double pb   = scm_momentum.vect().dot(velocity);
+  G4double gasq = v2-pb*pb/pa;
+  ga = (gasq > small*small) ? std::sqrt(gasq) : 0.;
   gb = pb / pscm;
   gbpp = gb / pscm;
   gapp = ga * pscm;
+}
+G4CascadeMomentum G4LorentzConvertor::rotate(const G4CascadeMomentum& mom) const {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4LorentzConvertor::rotate(G4CascadeMomentum)" << G4endl;
+  }
+  G4CascadeMomentum mom_rot;
+  if (verboseLevel > 3) {
+    G4cout << " ga " << ga << " gbpp " << gbpp << " gapp " << gapp << G4endl;
+    G4cout << " gegenerated " << degenerated << G4endl;
+    G4cout << " before rotation: px " << mom[1] << " py " << mom[2] <<
+      " pz " << mom[3] << G4endl;
+  }
+  if(degenerated) {
+    mom_rot = mom;
+  } else {
+    mom_rot[1] = mom[1] * (velocity[1] - gbpp * scm_momentum[1]) / ga +
+      mom[2] * (scm_momentum[2] * velocity[3] - scm_momentum[3] * velocity[2]) / gapp +
+      mom[3] * scm_momentum[1] / pscm;
+    mom_rot[2] = mom[1] * (velocity[2] - gbpp * scm_momentum[2]) / ga +
+      mom[2] * (scm_momentum[3] * velocity[1] - scm_momentum[1] * velocity[3]) / gapp +
+      mom[3] * scm_momentum[2] / pscm;
+    mom_rot[3] = mom[1] * (velocity[3] - gbpp * scm_momentum[3]) / ga +
+      mom[2] * (scm_momentum[1] * velocity[2] - scm_momentum[2] * velocity[1]) / gapp +
+      mom[3] * scm_momentum[3] / pscm;
+  degenerated = (ga < small);
+  if (degenerated && verboseLevel > 3)
+    G4cout << " degenerated case " << G4endl;
+  if (verboseLevel > 3) {
+    G4double pv = target_mom.vect().dot(velocity);
+    G4cout << " ga " << ga << " v2 " << v2 << " pb " << pb
+           << " pb * pb / pa " << pb * pb / pa << " pv " << pv << G4endl;
+  }
+}
+void G4LorentzConvertor::toTheTargetRestFrame() {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4LorentzConvertor::toTheTargetRestFrame" << G4endl;
+  }
+  velocity = target_mom.boostVector();
+  // "SCM" is bullet momentum in the target's frame
+  scm_momentum = bullet_mom;
+  scm_momentum.boost(-velocity);
+  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;
+  // Compute kinematic quantities for rotate() functions
+  v2 = velocity.mag2();
+  gamma = target_mom.e() / target_mom.m();
+  G4double pscm = scm_momentum.rho();
+  G4double pa   = scm_momentum.vect().mag2();
+  G4double pb   = velocity.dot(scm_momentum.vect());
+  G4double gasq = v2-pb*pb/pa;
+  ga = (gasq > small*small) ? std::sqrt(gasq) : 0.;
+  gb = pb/pscm;
+  gbpp = gb/pscm;
+  gapp = ga*pscm;
+  degenerated = (ga < small);
+  if (degenerated && verboseLevel > 3)
+    G4cout << " degenerated case " << G4endl;
+}
+G4LorentzVector
+G4LorentzConvertor::backToTheLab(const G4LorentzVector& mom) const {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4LorentzConvertor::backToTheLab" << G4endl
+           << " at rest: px " << mom.x() << " py " << mom.y() << " pz "
+           << mom.z() << " e " << mom.e() << G4endl
+           << " v2 " << v2 << G4endl;
+  }
+  G4LorentzVector mom1 = mom;
+  if (v2 > small) mom1.boost(velocity);
+  if (verboseLevel > 3)
+    G4cout << " at lab: px " << mom1.x() << " py " << mom1.y() << " pz "
+           << mom1.z() << G4endl;
+  return mom1;
+}
+// Bullet kinematics in target rest frame (LAB frame, usually)
+G4double G4LorentzConvertor::getKinEnergyInTheTRS() const {
+  G4double pv = bullet_mom.vect().dot(target_mom.vect());
+   G4double ekin_trf =
+    (target_mom.e() * bullet_mom.e() - pv) / target_mom.m()
+    - bullet_mom.m();
+  return ekin_trf;
+}
+G4double G4LorentzConvertor::getTRSMomentum() const {
+  G4LorentzVector bmom = bullet_mom;
+  bmom.boost(-target_mom.boostVector());
+  return bmom.rho();
+}
+G4LorentzVector G4LorentzConvertor::rotate(const G4LorentzVector& mom) const {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4LorentzConvertor::rotate(G4LorentzVector)" << G4endl
+           << " ga " << ga << " gbpp " << gbpp << " gapp " << gapp << G4endl
+           << " degenerated " << degenerated << G4endl
+           << " before rotation: px " << mom.x() << " py " << mom.y()
+           << " pz " << mom.z() << G4endl;
+  }
+  G4LorentzVector mom_rot = mom;
+  if (!degenerated) {
+    G4ThreeVector vscm = velocity - gbpp*scm_momentum.vect();
+    G4ThreeVector vxcm = scm_momentum.vect().cross(velocity);
+    mom_rot.setVect(mom.x()*vscm/ga + mom.y()*vxcm/gapp +
+                    mom.z()*scm_momentum.vect().unit() );
   };
   if (verboseLevel > 3) {
     G4cout << " after rotation: px " << mom_rot[1] << " py " << mom_rot[2] <<
       " pz " << mom_rot[3] << G4endl;
+    G4cout << " after rotation: px " << mom_rot.x() << " py " << mom_rot.y()
+           << " pz " << mom_rot.z() << G4endl;
+  }
 …
+}
+G4CascadeMomentum G4LorentzConvertor::rotate(const G4CascadeMomentum& mom1,
+                                            const G4CascadeMomentum& mom) const {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4LorentzConvertor::rotate(G4CascadeMomentum,G4CascadeMomentum)" << G4endl;
+  }
+  const G4double small = 1.0e-10;
+  G4CascadeMomentum mom_rot;
+  G4double pp = 0.0;
+  G4double pv = 0.0;
+  for(G4int i = 0; i < 4; i++) {
+    pp += mom1[i] * mom1[i];
+    pv += mom1[i] * velocity[i];
+G4LorentzVector G4LorentzConvertor::rotate(const G4LorentzVector& mom1,
+                                           const G4LorentzVector& mom) const {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4LorentzConvertor::rotate(G4LorentzVector,G4LorentzVector)"
+           << G4endl
+           << " before rotation: px " << mom.x() << " py " << mom.y()
+           << " pz " << mom.z() << G4endl;
+  }
+  G4double pp = mom1.vect().mag2();
+  G4double pv = mom1.vect().dot(velocity);
+  G4double ga1 = v2 - pv * pv / pp;
+  if (verboseLevel > 3) {
+    G4cout << " ga1 " << ga1 << " small? " << (ga1 <= small) << G4endl;
+  }
+  G4LorentzVector mom_rot = mom;
+  if (ga1 > small) {
+    ga1 = std::sqrt(ga1);
+    G4double gb1 = pv / pp;
+    pp = std::sqrt(pp);
+    G4double ga1pp = ga1 * pp;
+    if (verboseLevel > 3) {
+      G4cout << " gb1 " << gb1 << " ga1pp " << ga1pp << G4endl;
+    }
+    G4ThreeVector vmom1 = velocity - gb1*mom1;
+    G4ThreeVector vxm1  = mom1.vect().cross(velocity);
+    mom_rot.setVect(mom.x()*vmom1/ga1 + mom.y()*vxm1/ga1pp +
+                    mom.z()*mom1.vect().unit() );
   };
+  G4double ga1 = v2 - pv * pv / pp;
+  if(ga1 < small) {
+    mom_rot = mom;
+  } else {
+    ga1 = std::sqrt(ga1);
+    G4double gb1 = pv / pp;
+    pp = std::sqrt(pp);
+    G4double ga1pp = ga1 * pp;
+    mom_rot[1] = mom[1] * (velocity[1] - gb1 * mom1[1]) / ga1 +
+      mom[2] * (mom1[2] * velocity[3] - mom1[3] * velocity[2]) / ga1pp +
+      mom[3] * mom1[1] / pp;
+    mom_rot[2] = mom[1] * (velocity[2] - gb1 * mom1[2]) / ga1 +
+      mom[2] * (mom1[3] * velocity[1] - mom1[1] * velocity[3]) / ga1pp +
+      mom[3] * mom1[2] / pp;
+    mom_rot[3] = mom[1] * (velocity[3] - gb1 * mom1[3]) / ga1 +
+      mom[2] * (mom1[1] * velocity[2] - mom1[2] * velocity[1]) / ga1pp +
+      mom[3] * mom1[3] / pp;
+  };
+  if (verboseLevel > 3) {
+    G4cout << " after rotation: px " << mom_rot.x() << " py " << mom_rot.y()
+           << " pz " << mom_rot.z() << G4endl;
+  }
   return mom_rot;
+}
-void G4LorentzConvertor::toTheTargetRestFrame() {
-  if (verboseLevel > 3) {
-    G4cout << " >>> G4LorentzConvertor::toTheTargetRestFrame" << G4endl;
+  }
-  const G4double small = 1.0e-10;
-  gamma = target_mom[0] / target_mass;
-  v2 = 0.0;
-  G4double pv = 0.0;
-  //  G4double e_sum = target_mom[0] + bullet_mom[0];
-  velocity.resize(4);
-  G4int i(0);
-  for(i = 1; i < 4; i++) {
-    velocity[i] = target_mom[i] / target_mom[0];
-    v2 += velocity[i] * velocity[i];
-    pv += bullet_mom[i] * velocity[i];
-  };
-  G4double pa = 0.0;
-  G4double pb = 0.0;
-  G4double xx = 0.0;
-  if(v2 > small) xx = pv * (gamma - 1.0) / v2 - bullet_mom[0] * gamma;
-  for(i = 1; i < 4; i++) {
-    scm_momentum[i] = bullet_mom[i] + velocity[i] * xx;
-    if (verboseLevel > 3) {
-      G4cout << " rf: i " << i << " pscm(i) " << scm_momentum[i] << G4endl;
+    }
-    pa += scm_momentum[i] * scm_momentum[i];
-    pb += scm_momentum[i] * velocity[i];
-  };
-  ga = v2 - pb * pb / pa;
-  if(ga < small) {
-    ga = small;
-    degenerated = true;
-  } else {
-    ga = std::sqrt(ga);
-  };
-  pscm = std::sqrt(pa);
-  plab = pscm;
-  gb = pb / pscm;
-  gbpp = gb / pscm;
-  gapp = ga * pscm;
+}
-G4CascadeMomentum G4LorentzConvertor::backToTheLab(const G4CascadeMomentum& mom) const {
-  if (verboseLevel > 3) {
-    G4cout << " >>> G4LorentzConvertor::backToTheLab" << G4endl;
+  }
-  const G4double small = 1.0e-10;
-  if (verboseLevel > 3) {
-    G4cout << " at rest: px " << mom[1] << " py " << mom[2] << " pz " << mom[3] <<
-      " e " << mom[0] << G4endl;
-    G4cout << " v2 " << v2 << G4endl;
+  }
-  G4CascadeMomentum mom1;
-  if(v2 < small) {
-    mom1 = mom;
-  } else {
-    G4double pv = 0.0;
-    G4int i(0);
-    for(i = 1; i < 4; i++) pv += mom[i] * velocity[i];
-    G4double xx = pv * (gamma - 1.0) / v2 + mom[0] * gamma;
-    for(i = 1; i < 4; i++) mom1[i] = mom[i] + velocity[i] * xx;
-  };
-  if (verboseLevel > 3) {
-    G4cout << " at lab: px " << mom1[1] << " py " << mom1[2] << " pz " << mom1[3] << G4endl;
+  }
-  return mom1;
+}
 G4bool G4LorentzConvertor::reflectionNeeded() const {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4LorentzConvertor::reflectionNeeded" << G4endl;
+  }
+  const G4double small = 1.0e-10;
+  if(v2 < small) {
+    return false;
+  }  else {
+    if(degenerated) return (scm_momentum[3] < 0.0);
+    else
+    {
+      throw G4HadronicException(__FILE__, __LINE__, "G4LorentzConvertor::reflectionNeeded - return value undefined");
+      return false;
+    }
+  };
+}
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4LorentzConvertor::reflectionNeeded: v2 = " << v2
+           << " SCM z = " << scm_momentum.z() << " degenerated? "
+           << degenerated << G4endl;
+  }
+  if (v2 < small && !degenerated)
+    throw G4HadronicException(__FILE__, __LINE__, "G4LorentzConvertor::reflectionNeeded - return value undefined");
+  return (v2>=small && (!degenerated || scm_momentum.z() < 0.0));
+}

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4NonEquilibriumEvaporator.cc,v 1.29 2010/05/21 17:56:34 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
+// 20100309  M. Kelsey -- Use new generateWithRandomAngles for theta,phi stuff;
+//              eliminate some unnecessary std::pow()
+// 20100412  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
+// 20100413  M. Kelsey -- Pass buffers to paraMaker[Truncated]
+// 20100517  M. Kelsey -- Inherit from common base class
 #define RUN
 #include <cmath>
 #include "G4NonEquilibriumEvaporator.hh"
+#include "G4CollisionOutput.hh"
 #include "G4InuclElementaryParticle.hh"
 #include "G4InuclNuclei.hh"
+#include "G4InuclSpecialFunctions.hh"
 #include "G4LorentzConvertor.hh"
+#include "G4NucleiProperties.hh"
+#include "G4HadTmpUtil.hh"
+using namespace G4InuclSpecialFunctions;
 G4NonEquilibriumEvaporator::G4NonEquilibriumEvaporator()
+  : verboseLevel(1) {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4NonEquilibriumEvaporator::G4NonEquilibriumEvaporator" << G4endl;
+  }
+}
+G4CollisionOutput G4NonEquilibriumEvaporator::collide(G4InuclParticle* /*bullet*/,
+                                                      G4InuclParticle* target) {
+  : G4VCascadeCollider("G4NonEquilibriumEvaporator") {}
+void G4NonEquilibriumEvaporator::collide(G4InuclParticle* /*bullet*/,
+                                         G4InuclParticle* target,
+                                         G4CollisionOutput& output) {
   if (verboseLevel > 3) {
 …
+  }
+  const G4double one_third = 1.0/3.0;
+  // Sanity check
+  G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target);
+  if (!nuclei_target) {
+    G4cerr << " NonEquilibriumEvaporator -> target is not nuclei " << G4endl;
+    return;
+  }
   const G4double a_cut = 5.0;
   const G4double z_cut = 3.0;
 …
   const G4double small_ekin = 1.0e-6;
   const G4double width_cut = 0.005;
+  G4CollisionOutput output;
+  if (G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target)) {
+    //  initialization
     G4double A = nuclei_target->getA();
     G4double Z = nuclei_target->getZ();
     G4CascadeMomentum PEX = nuclei_target->getMomentum();
     G4CascadeMomentum pin = PEX;
+    G4LorentzVector PEX = nuclei_target->getMomentum();
+    G4LorentzVector pin = PEX;
     G4double EEXS = nuclei_target->getExitationEnergy();
     pin[0] += 0.001 * EEXS;
+    pin.setE(pin.e() + 0.001 * EEXS);
     G4InuclNuclei dummy_nuc;
     G4ExitonConfiguration config = nuclei_target->getExitonConfiguration();
 …
     G4LorentzConvertor toTheExitonSystemRestFrame;
     toTheExitonSystemRestFrame.setBullet(dummy.getMomentum(), dummy.getMass());
+    toTheExitonSystemRestFrame.setBullet(dummy);
     G4double EFN = FermiEnergy(A, Z, 0);
 …
     G4double ZR = Z - QPP;
     G4int NEX = G4int(QEX + 0.5);
     G4CascadeMomentum ppout;
     G4bool try_again = NEX > 0 ? true : false;
+    G4LorentzVector ppout;
+    G4bool try_again = (NEX > 0);
+    // Buffer for parameter sets
+    std::pair<G4double, G4double> parms;
     while (try_again) {
 …
         // update exiton system
         G4double nuc_mass = dummy_nuc.getNucleiMass(A, Z);
+        PEX[0] = std::sqrt(PEX[1] * PEX[1] + PEX[2] * PEX[2] + PEX[3] * PEX[3] +
+                      nuc_mass * nuc_mass);
+        PEX.setVectM(PEX.vect(), nuc_mass);
         toTheExitonSystemRestFrame.setTarget(PEX, nuc_mass);
         toTheExitonSystemRestFrame.toTheTargetRestFrame();
 …
         if (QEX < std::sqrt(2.0 * EG)) { // ok
           std::pair<G4double, G4double> parms = paraMakerTruncated(Z);
           G4double AK1 = parms.first;
+          G4double CPA1 = parms.second;
           G4double VP = coul_coeff * Z * AK1 / (std::pow(A - 1.0, one_third) + 1.0) /
+          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 = 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 APH1 = APH + 0.5 * (QP + QH);
               ESP = EEXS / QEX;
               G4double MELE = MEL / ESP / std::pow(A, 3);
+              G4double MELE = MEL / ESP / (A*A*A);
               if (ESP > 15.0) {
 …
                   if (NEX >= 2) {
                     D[1] = 0.0462 / parlev / std::pow(A, one_third) * QP * EEXS / QEX;
+                    D[1] = 0.0462 / parlev / G4cbrt(A) * QP * EEXS / QEX;
                     if (EMP > eexs_cut)
 …
                           // generate particle momentum
                           G4double pmod = std::sqrt(EPART * (2.0 * mass + EPART));
+                          G4CascadeMomentum mom;
+                          std::pair<G4double, G4double> COS_SIN = randomCOS_SIN();
+                          G4double FI = randomPHI();
+                          G4double P1 = pmod * COS_SIN.second;
+                          mom[1] = P1 * std::cos(FI);
+                          mom[2] = P1 * std::sin(FI);
+                          mom[3] = pmod * COS_SIN.first;
+                          G4CascadeMomentum mom_at_rest;
+                          for (G4int i = 1; i < 4; i++) mom_at_rest[i] = -mom[i];
+                          G4LorentzVector mom = generateWithRandomAngles(pmod,mass);
+                          G4LorentzVector mom_at_rest;
                           G4double QPP_new = QPP;
 …
                           G4double new_exiton_mass =
                             dummy_nuc.getNucleiMass(A_new, Z_new);
+                          mom_at_rest[0] = std::sqrt(mom_at_rest[1] * mom_at_rest[1] +
+                                                mom_at_rest[2] * mom_at_rest[2] +
+                                                mom_at_rest[3] * mom_at_rest[3] +
+                                                new_exiton_mass * new_exiton_mass);
+                          mom[0] = std::sqrt(mom[1] * mom[1] + mom[2] * mom[2] +
+                                        mom[3] * mom[3] + mass * mass);
+                          G4CascadeMomentum part_mom =
+                          mom_at_rest.setVectM(-mom.vect(), new_exiton_mass);
+                          G4LorentzVector part_mom =
                             toTheExitonSystemRestFrame.backToTheLab(mom);
+                          part_mom[0] = std::sqrt(part_mom[1] * part_mom[1] +
+                                             part_mom[2] * part_mom[2] + part_mom[3] * part_mom[3] +
+                                             mass * mass);
+                          G4CascadeMomentum ex_mom =
+                          part_mom.setVectM(part_mom.vect(), mass);
+                          G4LorentzVector ex_mom =
                             toTheExitonSystemRestFrame.backToTheLab(mom_at_rest);
+                          ex_mom[0] = std::sqrt(ex_mom[1] * ex_mom[1] + ex_mom[2] * ex_mom[2]
+                                           + ex_mom[3] * ex_mom[3] + new_exiton_mass * new_exiton_mass);
+                          ex_mom.setVectM(ex_mom.vect(), new_exiton_mass);
                           //             check energy conservation and set new exitation energy
                           EEXS_new = 1000.0 * (PEX[0] + 0.001 * EEXS -
                                                part_mom[0] - ex_mom[0]);
+                          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);
+                            for (G4int i = 0; i < 4; i++) ppout[i] += part_mom[i];
+                            ppout += part_mom;
                             A = A_new;
                             Z = Z_new;
 …
     // conservation
+    G4CascadeMomentum pnuc;
+    for (G4int i = 1; i < 4; i++) pnuc[i] = pin[i] - ppout[i];
+    G4LorentzVector pnuc = pin - ppout;
     G4InuclNuclei nuclei(pnuc, A, Z);
 …
     pnuc = nuclei.getMomentum();
     G4double eout = pnuc[0] + ppout[0];
     G4double eex_real = 1000.0 * (pin[0] - eout);
+    G4double eout = pnuc.e() + ppout.e();
+    G4double eex_real = 1000.0 * (pin.e() - eout);
     nuclei.setExitationEnergy(eex_real);
     output.addTargetFragment(nuclei);
+  } else {
+    G4cout << " NonEquilibriumEvaporator -> target is not nuclei " << G4endl;
+  };
+  return output;
+  return;
+}

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

-              r1228
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4NucleiModel.cc,v 1.48 2010/05/26 18:29:28 dennis Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100112  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
+// 20100114  M. Kelsey -- Use G4ThreeVector for position
+// 20100309  M. Kelsey -- Use new generateWithRandomAngles for theta,phi stuff;
+//              eliminate some unnecessary std::pow(), move ctor here
+// 20100407  M. Kelsey -- Replace std::vector<>::resize(0) with ::clear().
+//              Move output vectors from generateParticleFate() and
+//              ::generateInteractionPartners() to be data members; return via
+//              const-ref instead of by value.
+// 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
+// 20100418  M. Kelsey -- Reference output particle lists via const-ref
+// 20100421  M. Kelsey -- Replace hardwired p/n masses with G4PartDef's
+// 20100517  M. Kelsey -- Use G4CascadeINterpolator for cross-section
+//              calculations.  use G4Cascade*Channel for total xsec in pi-N
+//              N-N channels.  Move absorptionCrossSection() from SpecialFunc.
 //#define CHC_CHECK
 #include "G4NucleiModel.hh"
+#include "G4CascadeInterpolator.hh"
+#include "G4CascadeNNChannel.hh"
+#include "G4CascadeNPChannel.hh"
+#include "G4CascadePPChannel.hh"
+#include "G4CascadePiMinusNChannel.hh"
+#include "G4CascadePiMinusPChannel.hh"
+#include "G4CascadePiPlusNChannel.hh"
+#include "G4CascadePiPlusPChannel.hh"
+#include "G4CascadePiZeroNChannel.hh"
+#include "G4CascadePiZeroPChannel.hh"
+#include "G4CollisionOutput.hh"
+#include "G4ElementaryParticleCollider.hh"
+#include "G4HadTmpUtil.hh"
+#include "G4InuclNuclei.hh"
+#include "G4InuclParticleNames.hh"
+#include "G4InuclSpecialFunctions.hh"
 #include "G4LorentzConvertor.hh"
+#include "G4CollisionOutput.hh"
+#include "G4Neutron.hh"
+#include "G4NucleiProperties.hh"
+#include "G4Proton.hh"
+using namespace G4InuclParticleNames;
+using namespace G4InuclSpecialFunctions;
 typedef std::vector<G4InuclElementaryParticle>::iterator particleIterator;
+G4NucleiModel::G4NucleiModel()
+  : verboseLevel(2) {
+G4NucleiModel::G4NucleiModel() : verboseLevel(0) {
   if (verboseLevel > 3) {
     G4cout << " >>> G4NucleiModel::G4NucleiModel" << G4endl;
 …
+}
+G4NucleiModel::G4NucleiModel(G4InuclNuclei* nuclei) : verboseLevel(0) {
+  generateModel(nuclei->getA(), nuclei->getZ());
+}
 void
 G4NucleiModel::generateModel(G4double a, G4double z) {
-  verboseLevel = 2;
   if (verboseLevel > 3) {
     G4cout << " >>> G4NucleiModel::generateModel" << G4endl;
+  }
-  initTotalCrossSections();
   const G4double AU = 1.7234;
+  const G4double cuu = 3.3836;
+  const G4double one_third = 1.0 / 3.0;
+  const G4double oneBypiTimes4 = 0.0795775; // 1 / 4 Pi
+  const G4double cuu = 3.3836;
+  //  const G4double convertToFermis = 2.8197;
   const G4double pf_coeff = 1.932;
   const G4double pion_vp = 0.007; // in GeV
 …
   const G4double radForSmall = 8.0; // fermi
   const G4double piTimes4thirds = 4.189; // 4 Pi/3
   const G4double mproton = 0.93827;
   const G4double mneutron = 0.93957;
+  const G4double mproton = G4Proton::Definition()->GetPDGMass() / GeV;
+  const G4double mneutron = G4Neutron::Definition()->GetPDGMass() / GeV;
   const G4double alfa3[3] = { 0.7, 0.3, 0.01 }; // listing zone radius
   //  const G4double alfa6[6] = { 0.9, 0.6, 0.4, 0.2, 0.1, 0.05 };
+  const G4double alfa6[6] = { 0.9, 0.6, 0.4, 0.2, 0.1, 0.05 };
   A = a;
 …
 // 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 * std::pow(a, one_third);
+  G4double D1 = CU / AU;
+  G4double D = std::exp(-D1);
+//  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
+  G4double CU = cuu*G4cbrt(a); // half-density radius * 2.8197
+  G4double D1 = CU/AU;
+  G4double D = std::exp(-D1);
   G4double CU2 = 0.0;
   if (a > 3.5) { // a > 3
+  if (a > 4.5) {
     std::vector<G4double> ur;
     G4int icase = 0;
+    if (a > 11.5) { // a > 11
+      // number_of_zones = 6;
+    if (a > 99.5) {
+      number_of_zones = 6;
+      ur.push_back(-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);
+      }
+    } else if (a > 11.5) {
       number_of_zones = 3;
       ur.push_back(-D1);
       for (G4int i = 0; i < number_of_zones; i++) {
-        // G4double y = std::log((1.0 + D) / alfa6[i] - 1.0);
         G4double y = std::log((1.0 + D)/alfa3[i] - 1.0);
         zone_radii.push_back(CU + AU * y);
         ur.push_back(y);
       };
+      }
     } else {
 …
         zone_radii.push_back(CU2 * y);
         ur.push_back(y);
       };
     };
+      }
+    }
     G4double tot_vol = 0.0;
 …
       v.push_back(v0);
       tot_vol += v0;
+      v0 = (i == 0 ? std::pow(zone_radii[i], G4double(3)) : std::pow(zone_radii[i], G4double(3)) -
+            std::pow(zone_radii[i - 1], G4double(3)));
+      v0 = zone_radii[i]*zone_radii[i]*zone_radii[i];
+      if (i > 0) v0 -= zone_radii[i-1]*zone_radii[i-1]*zone_radii[i-1];
       v1.push_back(v0);
+    }
+    // proton
+    G4double dd0 = 3.0 * z * oneBypiTimes4 / tot_vol;
+    // Protons
+    G4double dd0 = z/tot_vol/piTimes4thirds;
     std::vector<G4double> rod;
     std::vector<G4double> pf;
 …
       G4double rd = dd0 * v[i] / v1[i];
       rod.push_back(rd);
       G4double pff = pf_coeff * std::pow(rd, one_third);
+      G4double pff = pf_coeff * G4cbrt(rd);
       pf.push_back(pff);
       vz.push_back(0.5 * pff * pff / mproton + binding_energies[0]);
 …
     zone_potentials.push_back(vz);
     fermi_momenta.push_back(pf);
+    //  neutron stuff
+    dd0 = 3.0 * (a - z) * oneBypiTimes4 / tot_vol;
+    rod.resize(0);
+    pf.resize(0);
+    vz.resize(0);
+    // Neutrons
+    dd0 = (a - z)/tot_vol/piTimes4thirds;
+    rod.clear();
+    pf.clear();
+    vz.clear();
     for (i = 0; i < number_of_zones; i++) {
       G4double rd = dd0 * v[i] / v1[i];
       rod.push_back(rd);
       G4double pff = pf_coeff * std::pow(rd, one_third);
+      G4double pff = pf_coeff * G4cbrt(rd);
       pf.push_back(pff);
       vz.push_back(0.5 * pff * pff / mneutron + binding_energies[1]);
 …
     zone_potentials.push_back(hp);
   } else { // a < 4
+  } else { // a < 5
     number_of_zones = 1;
+    zone_radii.push_back(radForSmall);
+    G4double vol = 1.0 / piTimes4thirds / std::pow(zone_radii[0], G4double(3));
+    G4double smallRad = radForSmall;
+    if (a == 4) smallRad *= 0.7;
+    zone_radii.push_back(smallRad);
+    G4double vol = 1.0 / piTimes4thirds / (zone_radii[0]*zone_radii[0]*zone_radii[0]);
+    // proton
     std::vector<G4double> rod;
     std::vector<G4double> pf;
     std::vector<G4double> vz;
+    G4int i(0);
+    for (i = 0; i < number_of_zones; i++) {
+      G4double rd = vol;
+    for (G4int i = 0; i < number_of_zones; i++) {
+      G4double rd = vol*z;
       rod.push_back(rd);
       G4double pff = pf_coeff * std::pow(rd, one_third);
+      G4double pff = pf_coeff * G4cbrt(rd);
       pf.push_back(pff);
       vz.push_back(0.5 * pff * pff / mproton + binding_energies[0]);
     };
+    }
     nucleon_densities.push_back(rod);
 …
     // neutron
+    rod.resize(0);
+    pf.resize(0);
+    vz.resize(0);
+    for (i = 0; i < number_of_zones; i++) {
+      G4double rd = vol;
+    rod.clear();
+    pf.clear();
+    vz.clear();
+    for (G4int i = 0; i < number_of_zones; i++) {
+      G4double rd = vol*(a-z);
       rod.push_back(rd);
       G4double pff = pf_coeff * std::pow(rd, one_third);
+      G4double pff = pf_coeff * G4cbrt(rd);
       pf.push_back(pff);
       vz.push_back(0.5 * pff * pff / mneutron + binding_energies[1]);
     };
+    }
     nucleon_densities.push_back(rod);
 …
     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;
+  */
+}
+G4double G4NucleiModel::getFermiKinetic(G4int ip, G4int izone) const {
+  G4double ekin = 0.0;
+  if (ip < 3 && izone < number_of_zones) {      // ip for proton/neutron only
+    G4double pf = fermi_momenta[ip - 1][izone];
+    G4double mass = G4InuclElementaryParticle::getParticleMass(ip);
+    ekin = std::sqrt(pf * pf + mass * mass) - mass;
+  }
+  return ekin;
+}
 …
+  }
   return std::pow(cu2, G4double(3)) * fun;
+  return cu2*cu2*cu2 * fun;
+}
 …
+G4LorentzVector
+G4NucleiModel::generateNucleonMomentum(G4int type, G4int zone) const {
+  G4double pmod = getFermiMomentum(type, zone) * G4cbrt(inuclRndm());
+  G4double mass = G4InuclElementaryParticle::getParticleMass(type);
+  return generateWithRandomAngles(pmod, mass);
+}
 G4InuclElementaryParticle
 G4NucleiModel::generateNucleon(G4int type, G4int zone) const {
   if (verboseLevel > 3) {
     G4cout << " >>> G4NucleiModel::generateNucleon" << G4endl;
+  }
+  const G4double one_third = 1.0 / 3.0;
+//G4double pmod = getFermiMomentum(type, zone) * std::pow(inuclRndm(), one_third);
+  G4double pmod = fermi_momenta[type - 1][zone] * std::pow(inuclRndm(), one_third);
+  G4CascadeMomentum mom;
+  std::pair<G4double, G4double> COS_SIN = randomCOS_SIN();
+  G4double FI = randomPHI();
+  G4double pt = pmod * COS_SIN.second;
+  mom[1] = pt * std::cos(FI);
+  mom[2] = pt * std::sin(FI);
+  mom[3] = pmod * COS_SIN.first;
+  G4LorentzVector mom = generateNucleonMomentum(type, zone);
   return G4InuclElementaryParticle(mom, type);
+}
 …
+  }
+  G4CascadeMomentum mom = generateNucleon(type1, zone).getMomentum();
+  G4CascadeMomentum mom1 = generateNucleon(type2, zone).getMomentum();
+  G4CascadeMomentum dmom;
+  for (G4int i = 1; i < 4; i++) dmom[i] = mom[i] + mom1[i];
+  // Quasideuteron consists of an unbound but associated nucleon pair
+  // FIXME:  Why generate two separate nucleon momenta (randomly!) and
+  //         add them, instead of just throwing a net momentum for the
+  //         dinulceon state?  And why do I have to capture the two
+  //         return values into local variables?
+  G4LorentzVector mom1 = generateNucleonMomentum(type1, zone);
+  G4LorentzVector mom2 = generateNucleonMomentum(type2, zone);
+  G4LorentzVector dmom = mom1+mom2;
   G4int dtype = 0;
+  if (type1 * type2 == 1) {
+    dtype = 111;
+  } else if (type1 * type2 == 2) {
+    dtype = 112;
+  } else if (type1 * type2 == 4) {
+    dtype = 122;
+  };
+       if (type1*type2 == pro*pro) dtype = 111;
+  else if (type1*type2 == pro*neu) dtype = 112;
+  else if (type1*type2 == neu*neu) dtype = 122;
   return G4InuclElementaryParticle(dmom, dtype);
 …
+partners
+G4NucleiModel::generateInteractionPartners(G4CascadParticle& cparticle) const {
+void
+G4NucleiModel::generateInteractionPartners(G4CascadParticle& cparticle) {
   if (verboseLevel > 3) {
     G4cout << " >>> G4NucleiModel::generateInteractionPartners" << G4endl;
 …
   //const G4double young_cut = 0.0;
   partners thePartners;
+  thePartners.clear();          // Reset buffer for next cycle
   G4int ptype = cparticle.getParticle().type();
   G4int zone = cparticle.getCurrentZone();
   G4double pmass = cparticle.getParticle().getMass();
   const G4CascadeMomentum& pmom = cparticle.getParticle().getMomentum();
+  G4LorentzVector pmom = cparticle.getParticle().getMomentum();
   G4double r_in;
   G4double r_out;
 …
   if (path < -small) { // something wrong
     return thePartners;
+    return;
   } else if (std::fabs(path) < small) { // just on the boundary
     path = 0.0;
+    G4InuclElementaryParticle particle;
+    G4InuclElementaryParticle particle; // Dummy -- no type or momentum
     thePartners.push_back(partner(particle, path));
   } else { // normal case
-    std::vector<G4InuclElementaryParticle> particles;
     G4LorentzConvertor dummy_convertor;
     dummy_convertor.setBullet(pmom, pmass);
 …
       dummy_convertor.setTarget(particle.getMomentum(), particle.getMass());
       G4double ekin = dummy_convertor.getKinEnergyInTheTRS();
+      // Total cross section converted from mb to fm**2
       G4double csec = totalCrossSection(ekin, ptype * ip);
 …
     if (cparticle.getParticle().pion()) { // absorption possible
+      std::vector<G4InuclElementaryParticle> qdeutrons;
+      std::vector<G4double> acsecs;
+      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 = std::pow(zone_radii[zone], G4double(3));
       if (zone > 0) vol -= std::pow(zone_radii[zone - 1], G4double(3));
+      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 ekin = dummy_convertor.getKinEnergyInTheTRS();
+        abs_sec = absorptionCrosSection(ekin, ptype);
+        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;
 …
       G4double ekin = dummy_convertor.getKinEnergyInTheTRS();
+      abs_sec = absorptionCrosSection(ekin, ptype);
+      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;
 …
         G4double ekin = dummy_convertor.getKinEnergyInTheTRS();
+        abs_sec = absorptionCrosSection(ekin, ptype);
+        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;
 …
+    }
+    if (thePartners.size() > 1) { // sort partners
+    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));
+  }
+      for (G4int i = 0; i < G4int(thePartners.size()) - 1; i++) {
+        for (G4int j = i + 1; j < G4int(thePartners.size()); j++) {
+          if (thePartners[i].second > thePartners[j].second) {
+            G4InuclElementaryParticle particle = thePartners[i].first;
+            G4double pathi = thePartners[i].second;
+            thePartners[i] = partner(thePartners[j].first, thePartners[j].second);
+            thePartners[j] = partner(particle, pathi);
+          };
+        };
+      };
+    };
+    G4InuclElementaryParticle particle;
+    thePartners.push_back(partner(particle, path));
+  };
+  return thePartners;
+}
+std::vector<G4CascadParticle>
+  return;
+}
+const std::vector<G4CascadParticle>&
 G4NucleiModel::generateParticleFate(G4CascadParticle& cparticle,
                                     G4ElementaryParticleCollider* theElementaryParticleCollider) {
+  if (verboseLevel > 3) G4cout << " >>> G4NucleiModel::generateParticleFate" << G4endl;
+  std::vector<G4CascadParticle> outgouing_cparticles;
+  partners thePartners = generateInteractionPartners(cparticle);
+  if(thePartners.empty()) { // smth. is wrong -> needs special treatment
+  if (verboseLevel > 3)
+    G4cout << " >>> G4NucleiModel::generateParticleFate" << G4endl;
+  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;
+  } else {
+    G4int npart = thePartners.size();
+    if (npart == 1) { // cparticle is on the next zone entry
+      // need to go here if particle outside nucleus ?
+      //
+      cparticle.propagateAlongThePath(thePartners[0].second);
+      cparticle.incrementCurrentPath(thePartners[0].second);
+    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 ?
+    //
+    cparticle.propagateAlongThePath(thePartners[0].second);
+    cparticle.incrementCurrentPath(thePartners[0].second);
+    boundaryTransition(cparticle);
+    outgoing_cparticles.push_back(cparticle);
+    if (verboseLevel > 2){
+      G4cout << " next zone " << G4endl;
+      cparticle.print();
+    }
+  } else { // there are possible interactions
+    G4ThreeVector old_position = cparticle.getPosition();
+    G4InuclElementaryParticle bullet = cparticle.getParticle();
+    G4bool no_interaction = true;
+    G4int zone = cparticle.getCurrentZone();
+    G4CollisionOutput output;
+    for (G4int i = 0; i < npart - 1; i++) {
+      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;
+      }
+      output.reset();
+      theElementaryParticleCollider->collide(&bullet, &target, output);
+      if (verboseLevel > 2) output.printCollisionOutput();
+      // 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
+        G4double out_charge = 0.0;
+        for (G4int ip = 0; ip < G4int(outgoing_particles.size()); ip++)
+          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()
+               << " 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
+      cparticle.updatePosition(old_position);
+      cparticle.propagateAlongThePath(thePartners[npart - 1].second);
+      cparticle.incrementCurrentPath(thePartners[npart - 1].second);
       boundaryTransition(cparticle);
+      outgouing_cparticles.push_back(cparticle);
+      if (verboseLevel > 2){
+        G4cout << " next zone " << G4endl;
+        cparticle.print();
+      }
+    } else { // there are possible interactions
+      std::vector<G4double> old_position = cparticle.getPosition();
+      G4InuclElementaryParticle bullet = cparticle.getParticle();
+      G4bool no_interaction = true;
+      G4int zone = cparticle.getCurrentZone();
+      for (G4int i = 0; i < npart - 1; i++) {
+        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;
+        }
+        G4CollisionOutput output = theElementaryParticleCollider->collide(&bullet, &target);
+        if (verboseLevel > 2) output.printCollisionOutput();
+        std::vector<G4InuclElementaryParticle> outgoing_particles =
+          output.getOutgoingParticles();
+        if (passFermi(outgoing_particles, zone)) { // interaction
+          cparticle.propagateAlongThePath(thePartners[i].second);
+          std::vector<G4double> new_position = cparticle.getPosition();
+          /*
+          // find jet axis for new particles
+          G4double incidentE = cparticle.getParticle().getEnergy();
+          G4CascadeMomentum jetAxis;
+          for (G4int i = 0; i < G4int(outgoing_particles.size()); i++) {
+            for (G4int j = 1; j < 4; j++) jetAxis[j] += (outgoing_particles[i].getMomentum())[j];
+          }
+          // Find pT wrt jet axis for each secondary
+          */
+          for (G4int ip = 0; ip < G4int(outgoing_particles.size()); ip++) {
+            G4CascadParticle temp(outgoing_particles[ip], new_position, zone, 0.0, 0);
+            /*
+            G4double pathLength = temp.getPathToTheNextZone(0, nuclei_radius);
+            // Get jet axis
+            G4CascadeMomentum pmom = temp.getMomentum();
+            G4double secMass = temp.getParticle().getMass();
+            G4double dot = 0.0;
+            G4double pmod = 0.0;
+            G4double jmod = 0.0;
+            for (G4int i = 1; i < 4; i++) {
+              dot += pmom[i]*jetAxis[i];
+              pmod += pmom[i]*pmom[i];
+              jmod += jetAxis[i]*jetAxis[i];
+            }
+            //            G4double sinTheta = std::sqrt(1.0 - dot*dot/pmod/jmod);
+            G4double pT2 = pmod - dot*dot/jmod;
+            // G4cout << " mass = " << secMass << " Energy = " << incidentE << " pT = " << pT << G4endl;
+            G4double formationLength = 1.0*0.1973*incidentE/(pT2 + secMass*secMass);
+            if(formationLength > pathLength) {
+              //              G4cout << " formation length = " << formationLength
+              //                     << " path length = " << pathLength << G4endl;
+              temp.propagateAlongThePath(pathLength);
+              temp.incrementCurrentPath(pathLength);
+              temp.updateZone(number_of_zones-1);
+            }
+            */
+            outgouing_cparticles.push_back(temp);
+          }
+          no_interaction = false;
+          current_nucl1 = 0;
+          current_nucl2 = 0;
+#ifdef CHC_CHECK
+          G4double out_charge = 0.0;
+          for (G4int ip = 0; ip < outgoing_particles.size(); ip++)
+            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()
+                 << " 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
+        cparticle.updatePosition(old_position);
+        cparticle.propagateAlongThePath(thePartners[npart - 1].second);
+        cparticle.incrementCurrentPath(thePartners[npart - 1].second);
+        boundaryTransition(cparticle);
+        outgouing_cparticles.push_back(cparticle);
+      };
+    };
+      outgoing_cparticles.push_back(cparticle);
+    };
   };
   return outgouing_cparticles;
+  return outgoing_cparticles;
+}
 …
   } else {
     G4CascadeMomentum mom = cparticle.getMomentum();
     std::vector<G4double> pos = cparticle.getPosition();
+    G4LorentzVector mom = cparticle.getMomentum();
+    G4ThreeVector pos = cparticle.getPosition();
     G4int type = cparticle.getParticle().type();
+    G4double pr = 0.0;
+    G4double r = 0.0;
+    G4int i(0);
+    for (i = 0; i < 3; i++) {
+      pr += pos[i] * mom[i + 1];
+      r += pos[i] * pos[i];
+    };
+    r = std::sqrt(r);
+    G4double pr = pos.dot(mom.vect());
+    G4double r = pos.mag();
     pr /= r;
 …
     //     << getPotential(type,next_zone) << G4endl;
     G4double qv = dv * dv - 2.0 * dv * mom[0] + pr * pr;
+    G4double qv = dv * dv - 2.0 * dv * mom.e() + pr * pr;
     G4double p1r;
 …
     G4double prr = (p1r - pr) / r;
+    for (i = 0; i < 3; i++) mom[i + 1] += pos[i] * prr;
+    mom.setVect(mom.vect() + pos*prr);
     cparticle.updateParticleMomentum(mom);
   };
 …
        getFermiKinetic(ip, zone)) worth = false;
+    if (verboseLevel > 3) {
+      G4cout << "ekin=" << cparticle.getParticle().getKineticEnergy()
+             << " fermiKin=" << getFermiKinetic(ip, zone) << " : worth? "
+             << worth << G4endl;
+    }
   };
 …
   // Calculate number of protons and neutrons in local region
   //  G4double Athird = std::pow(A, 0.3333);
+  //  G4double Athird = G4cbrt(A);
   //  G4double Nneut = Athird*(A-Z)/A;
   //  G4double Nprot = Athird*Z/A;
 …
   G4double rz = nuclei_radius * s1;
+  std::vector<G4double> pos(3);
+  pos[0] = rz * std::cos(phi);
+  pos[1] = rz * std::sin(phi);
+  pos[2] = -nuclei_radius * std::sqrt(1.0 - s1 * s1);
+  G4ThreeVector pos(rz*std::cos(phi), rz*std::sin(phi),
+                    -nuclei_radius*std::sqrt(1.0 - s1*s1));
   G4CascadParticle cpart(*particle, pos, number_of_zones, large, 0);
+  if (verboseLevel > 2){
+    cpart.print();
+  }
+  if (verboseLevel > 2) cpart.print();
   return cpart;
+}
+std::pair<std::vector<G4CascadParticle>, std::vector<G4InuclElementaryParticle> >
+G4NucleiModel::initializeCascad(G4InuclNuclei* bullet,
                                 G4InuclNuclei* target) {
+void G4NucleiModel::initializeCascad(G4InuclNuclei* bullet,
+                                     G4InuclNuclei* target,
+                                     modelLists& output) {
   if (verboseLevel > 3) {
 …
   const G4int itry_max = 100;
+  std::vector<G4CascadParticle> casparticles;
+  std::vector<G4InuclElementaryParticle> particles;
+// first decide whether it will be cascad or compound final nuclei
+  // Convenient references to input buffer contents
+  std::vector<G4CascadParticle>& casparticles = output.first;
+  std::vector<G4InuclElementaryParticle>& particles = output.second;
+  casparticles.clear();         // Reset input buffer to fill this event
+  particles.clear();
+  // first decide whether it will be cascad or compound final nuclei
   G4double ab = bullet->getA();
   G4double zb = bullet->getZ();
 …
   G4double zt = target->getZ();
+  G4double massb = bullet->getMass();   // For creating LorentzVectors below
   if (ab < max_a_for_cascad) {
     G4double benb = 0.001 * bindingEnergy(ab, zb) / ab;
     G4double bent = 0.001 * bindingEnergy(at, zt) / at;
+    G4double benb = 0.001 * G4NucleiProperties::GetBindingEnergy(G4lrint(ab), G4lrint(zb)) / ab;
+    G4double bent = 0.001 * G4NucleiProperties::GetBindingEnergy(G4lrint(at), G4lrint(zt)) / at;
     G4double ben = benb < bent ? bent : benb;
 …
         itryg++;
         if(itryg > 0) particles.resize(0);
+        if(itryg > 0) particles.clear();
         //    nucleons coordinates and momenta in nuclei rest frame
         std::vector<std::vector<G4double> > coordinates;
         std::vector<G4CascadeMomentum> momentums;
+        std::vector<G4ThreeVector> coordinates;
+        std::vector<G4LorentzVector> momentums;
         if (ab < 3.0) { // deutron, simplest case
 …
           G4double s = 2.0 * inuclRndm() - 1.0;
           G4double r1 = r * std::sqrt(1.0 - s * s);
-          std::vector<G4double> coord1(3);
           G4double phi = randomPHI();
+          coord1[0] = r1 * std::cos(phi);
+          coord1[1] = r1 * std::sin(phi);
+          coord1[2] = r * s;
+          G4ThreeVector coord1(r1*std::cos(phi), r1*std::sin(phi), r*s);
           coordinates.push_back(coord1);
+          G4int i(0);
+          for (i = 0; i < 3; i++) coord1[i] *= -1;
+          coord1 *= -1.;
           coordinates.push_back(coord1);
           G4double p = 0.0;
           G4bool bad = true;
 …
             G4cout << " p nuc " << p << G4endl;
+          }
+          G4CascadeMomentum mom;
+          std::pair<G4double, G4double> COS_SIN = randomCOS_SIN();
+          G4double FI = randomPHI();
+          G4double P1 = p * COS_SIN.second;
+          mom[1] = P1 * std::cos(FI);
+          mom[2] = P1 * std::sin(FI);
+          mom[3] = p * COS_SIN.first;
+          G4LorentzVector mom = generateWithRandomAngles(p, massb);
           momentums.push_back(mom);
+          for (i = 1; i < 4; i++) mom[i] *= -1;
+          momentums.push_back(mom);
+          mom.setVect(-mom.vect());
+          momentums.push_back(-mom);
         } else {
           G4int ia = int(ab + 0.5);
           std::vector<G4double> coord1(3);
+          G4ThreeVector coord1;
           G4bool badco = true;
 …
           if (ab < 4.0) { // a == 3
             while (badco && itry < itry_max) {
               if (itry > 0) coordinates.resize(0);
+              if (itry > 0) coordinates.clear();
               itry++;
               G4int i(0);
 …
               for (i = 0; i < 2; i++) {
                 G4int itry1 = 0;
+                G4double s;
+                G4double u;
+                G4double rho;
+                G4double s, u, rho;
                 G4double fmax = std::exp(-0.5) / std::sqrt(0.5);
 …
                   if (std::sqrt(s) * std::exp(-s) > u && s < s3max) {
                     s = r0forAeq3 * std::sqrt(s);
+                    std::pair<G4double, G4double> COS_SIN = randomCOS_SIN();
+                    u = s * COS_SIN.second;
+                    G4double phi = randomPHI();
+                    coord1[0] = u * std::cos(phi);
+                    coord1[1] = u * std::sin(phi);
+                    coord1[2] = s * COS_SIN.first;
+                    coord1 = generateWithRandomAngles(s).vect();
                     coordinates.push_back(coord1);
                     if (verboseLevel > 2){
+                      G4cout << " i " << i << " r " << std::sqrt(coord1[0] * coord1[0] +
+                                                            coord1[1] * coord1[1] +
+                                                            coord1[2] * coord1[2]) << G4endl;
+                      G4cout << " i " << i << " r " << coord1.mag() << G4endl;
+                    }
                     break;
 …
                 if (itry1 == itry_max) { // bad case
                   coord1[0] = coord1[1] = coord1[2] = 10000.;
+                  coord1.set(10000.,10000.,10000.);
                   coordinates.push_back(coord1);
                   break;
                 };
               };
+              for (i = 0; i < 3; i++) coord1[i] = - coordinates[0][i] -
+                                       coordinates[1][i];
+              coord1 = -coordinates[0] - coordinates[1];
               if (verboseLevel > 2) {
+                G4cout << " 3  r " << std::sqrt(coord1[0] * coord1[0] +
+                                           coord1[1] * coord1[1] +
+                                           coord1[2] * coord1[2]) << G4endl;
+                G4cout << " 3  r " << coord1.mag() << G4endl;
+              }
 …
               for (i = 0; i < 2; i++) {
                 for (G4int j = i+1; j < 3; j++) {
+                  G4double r2 = std::pow(coordinates[i][0] - coordinates[j][0], G4double(2)) +
+                    std::pow(coordinates[i][1] - coordinates[j][1], G4double(2)) +
+                    std::pow(coordinates[i][2] - coordinates[j][2], G4double(2));
+                  G4double r2 = (coordinates[i]-coordinates[j]).mag2();
                   if (verboseLevel > 2) {
 …
             while (badco && itry < itry_max) {
               if (itry > 0) coordinates.resize(0);
+              if (itry > 0) coordinates.clear();
               itry++;
               G4int i(0);
 …
               for (i = 0; i < ia-1; i++) {
                 G4int itry1 = 0;
+                G4double s;
+                G4double u;
+                G4double s, u;
                 while (itry1 < itry_max) {
 …
                   if (std::sqrt(s) * std::exp(-s) * (1.0 + b * s) > u && s < s4max) {
                     s = r0forAeq4 * std::sqrt(s);
+                    std::pair<double, double> COS_SIN = randomCOS_SIN();
+                    u = s * COS_SIN.second;
+                    G4double phi = randomPHI();
+                    coord1[0] = u*std::cos(phi);
+                    coord1[1] = u*std::sin(phi);
+                    coord1[2] = s*COS_SIN.first;
+                    coord1 = generateWithRandomAngles(s).vect();
                     coordinates.push_back(coord1);
                     if (verboseLevel > 2) {
+                      G4cout << " i " << i << " r " << std::sqrt(coord1[0]  * coord1[0] +
+                                                            coord1[1] * coord1[1] +
+                                                            coord1[2] * coord1[2]) << G4endl;
+                      G4cout << " i " << i << " r " << coord1.mag() << G4endl;
+                    }
 …
                 if (itry1 == itry_max) { // bad case
                   coord1[0] = coord1[1] = coord1[2] = 10000.0;
+                  coord1.set(10000.,10000.,10000.);
                   coordinates.push_back(coord1);
                   break;
                 };
               };
+              for(i = 0; i < 3; i++) {
+                coord1[i] = 0.0;
+                for(G4int j = 0; j < ia -1; j++) coord1[i] -= coordinates[j][i];
+              };
+              coord1 *= 0.0;    // Cheap way to reset
+              for(G4int j = 0; j < ia -1; j++) coord1 -= coordinates[j];
               coordinates.push_back(coord1);
               if (verboseLevel > 2){
+                G4cout << " last r " << std::sqrt(coord1[0] * coord1[0] +
+                                             coord1[1] * coord1[1] +
+                                             coord1[2] * coord1[2]) << G4endl;
+                G4cout << " last r " << coord1.mag() << G4endl;
+              }
 …
                 for (G4int j = i+1; j < ia; j++) {
+                  G4double r2 = std::pow(coordinates[i][0] - coordinates[j][0], G4double(2)) +
+                    std::pow(coordinates[i][1]-coordinates[j][1], G4double(2)) +
+                    std::pow(coordinates[i][2] - coordinates[j][2], G4double(2));
+                  G4double r2 = (coordinates[i]-coordinates[j]).mag2();
                   if (verboseLevel > 2){
 …
           if(badco) {
+            G4cout << " can not generate the nucleons coordinates for a " << ab <<
+              G4endl;
+            return std::pair<std::vector<G4CascadParticle>, std::vector<G4InuclElementaryParticle> >
+              (casparticles, particles);
+            G4cout << " can not generate the nucleons coordinates for a "
+                   << ab << G4endl;
+            casparticles.clear();       // Return empty buffer on error
+            particles.clear();
+            return;
           } else { // momentums
+            G4double p;
+            G4double u;
+            G4double x;
+            G4CascadeMomentum mom;
+            G4double p, u, x;
+            G4LorentzVector mom;
             //G4bool badp = True;
             G4int i(0);
 …
                 if(x > inuclRndm()) {
                   p = std::sqrt(0.01953 * u);
+                  std::pair<G4double, G4double> COS_SIN = randomCOS_SIN();
+                  G4double pt = p * COS_SIN.second;
+                  G4double phi = randomPHI();
+                  mom[1] = pt * std::cos(phi);
+                  mom[2] = pt * std::sin(phi);
+                  mom[3] = p * COS_SIN.first;
+                  mom = generateWithRandomAngles(p, massb);
                   momentums.push_back(mom);
 …
               if(itry == itry_max) {
+                G4cout << " can not generate proper momentum for a " << ab << G4endl;
+                return std::pair<std::vector<G4CascadParticle>, std::vector<G4InuclElementaryParticle> >
+                  (casparticles, particles);
+                G4cout << " can not generate proper momentum for a "
+                       << ab << G4endl;
+                casparticles.clear();   // Return empty buffer on error
+                particles.clear();
+                return;
               };
 …
             // last momentum
+            for(i = 1; i < 4; i++) {
+              mom[i] = 0.;
+              for(G4int j = 0; j < ia -1; j++) mom[i] -= momentums[j][i];
+            };
+            mom *= 0.;          // Cheap way to reset
+            for(G4int j=0; j< ia-1; j++) mom -= momentums[j];
             momentums.push_back(mom);
 …
         for(i = 0; i < G4int(coordinates.size()); i++) {
+          G4double rp = std::sqrt(coordinates[i][0] * coordinates[i][0] +
+                             coordinates[i][1] * coordinates[i][1] +
+                             coordinates[i][2] * coordinates[i][2]);
+          G4double rp = coordinates[i].mag2();
           if(rp > rb) rb = rp;
 …
         G4double phi = randomPHI();
         G4double rz = (nuclei_radius + rb) * s1;
+        std::vector<double> global_pos(3);
+        global_pos[0] = rz * std::cos(phi);
+        global_pos[1] = rz * std::sin(phi);
+        global_pos[2] = -(nuclei_radius + rb) * std::sqrt(1.0 - s1 * s1);
+        G4ThreeVector global_pos(rz*std::cos(phi), rz*std::sin(phi),
+                                 -(nuclei_radius+rb)*std::sqrt(1.0-s1*s1));
         for (i = 0; i < G4int(coordinates.size()); i++) {
+          coordinates[i][0] += global_pos[0];
+          coordinates[i][1] += global_pos[1];
+          coordinates[i][2] += global_pos[2];
+          coordinates[i] += global_pos;
         };
 …
         for (ipart = raw_particles.begin(); ipart != raw_particles.end(); ipart++) {
+          G4CascadeMomentum mom =
+            toTheBulletRestFrame.backToTheLab(ipart->getMomentum());
+          ipart->setMomentum(mom);
+          ipart->setMomentum(toTheBulletRestFrame.backToTheLab(ipart->getMomentum()));
         };
 …
         for(G4int ip = 0; ip < G4int(raw_particles.size()); ip++) {
+          const G4CascadeMomentum& mom = raw_particles[ip].getMomentum();
+          G4double pmod = std::sqrt(mom[1] * mom[1] + mom[2] * mom[2] + mom[3] * mom[3]);
+          G4double t0 = -(mom[1] * coordinates[ip][0] + mom[2] * coordinates[ip][1] +
+                          mom[3] * coordinates[ip][2]) / pmod;
+          G4double det = t0 * t0 + nuclei_radius * nuclei_radius -
+            coordinates[ip][0] * coordinates[ip][0] -
+            coordinates[ip][1] * coordinates[ip][1] -
+            coordinates[ip][2] * coordinates[ip][2];
+          G4LorentzVector mom = raw_particles[ip].getMomentum();
+          G4double pmod = mom.rho();
+          G4double t0 = -mom.vect().dot(coordinates[ip]) / pmod;
+          G4double det = t0 * t0 + nuclei_radius * nuclei_radius
+                       - coordinates[ip].mag2();
           G4double tr = -1.0;
 …
             if(std::fabs(t1) <= std::fabs(t2)) {
               if(t1 > 0.0) {
                 if(coordinates[ip][2] + mom[3] * t1 / pmod <= 0.0) tr = t1;
+                if(coordinates[ip].z() + mom.z() * t1 / pmod <= 0.0) tr = t1;
               };
               if(tr < 0.0 && t2 > 0.0) {
                 if(coordinates[ip][2] + mom[3] * t2 / pmod <= 0.0) tr = t2;
+                if(coordinates[ip].z() + mom.z() * t2 / pmod <= 0.0) tr = t2;
               };
 …
               if(t2 > 0.0) {
                 if(coordinates[ip][2] + mom[3] * t2 / pmod <= 0.0) tr = t2;
+                if(coordinates[ip].z() + mom.z() * t2 / pmod <= 0.0) tr = t2;
               };
               if(tr < 0.0 && t1 > 0.0) {
                 if(coordinates[ip][2] + mom[3] * t1 / pmod <= 0.0) tr = t1;
+                if(coordinates[ip].z() + mom.z() * t1 / pmod <= 0.0) tr = t1;
               };
             };
 …
           if(tr >= 0.0) { // cascad particle
+            coordinates[ip][0] += mom[1] * tr / pmod;
+            coordinates[ip][1] += mom[2] * tr / pmod;
+            coordinates[ip][2] += mom[3] * tr / pmod;
+            casparticles.push_back(
+                                   G4CascadParticle(raw_particles[ip], coordinates[ip],
+            coordinates[ip] += mom*tr / pmod;
+            casparticles.push_back(G4CascadParticle(raw_particles[ip],
+                                                    coordinates[ip],
                                                     number_of_zones, large, 0));
 …
       if(casparticles.size() == 0) {
         particles.resize(0);
         G4cout << " can not generate proper distribution for " << itry_max << " steps " << G4endl;
+        particles.clear();
+        G4cout << " can not generate proper distribution for " << itry_max
+               << " steps " << G4endl;
       };
     };
 …
   if(verboseLevel > 2){
+    G4int ip(0);
     G4cout << " cascad particles: " << casparticles.size() << G4endl;
-    G4int ip(0);
     for(ip = 0; ip < G4int(casparticles.size()); ip++) casparticles[ip].print();
     G4cout << " outgoing particles: " << particles.size() << G4endl;
+    for(ip = 0; ip < G4int(particles.size()); ip++) particles[ip].printParticle();
+  }
+  return std::pair<std::vector<G4CascadParticle>, std::vector<G4InuclElementaryParticle> >
+    (casparticles, particles);
+}
+    for(ip = 0; ip < G4int(particles.size()); ip++)
+      particles[ip].printParticle();
+  }
+  return;       // Buffer has been filled
+}
+G4double G4NucleiModel::absorptionCrossSection(G4double ke, G4int type) const {
+  if (type != pionPlus && type != pionMinus && type != pionZero) {
+    G4cerr << " absorptionCrossSection only valid for incident pions" << G4endl;
+    return 0.;
+  }
+  // was 0.2 since the beginning, then changed to 1.0
+  // now 0.1 to convert from mb to fm**2
+  const G4double corr_fac = 1.0;
+  G4double csec = 0.0;
+  if (ke < 0.3) {
+    csec = 0.1106 / std::sqrt(ke) - 0.8 + 0.08 / ((ke-0.123)*(ke-0.123) + 0.0056);
+  } else if (ke < 1.0) {
+    csec = 3.6735 * (1.0-ke)*(1.0-ke);
+  };
+  if (csec < 0.0) csec = 0.0;
+  if (verboseLevel > 2) {
+    G4cout << " ekin " << ke << " abs. csec " << corr_fac * csec << G4endl;
+  }
+  csec *= corr_fac;
+  return csec;
+}
 G4double G4NucleiModel::totalCrossSection(G4double ke, G4int rtype) const
+{
   const G4double keScale[30] = {
+  static const G4double keScale[] = {
 .0,  0.01, 0.013, 0.018, 0.024, 0.032, 0.042, 0.056, 0.075, 0.1,
 .13, 0.18, 0.24,  0.32,  0.42,  0.56,  0.75,  1.0,   1.3,   1.8,
 .4,  3.2,  4.2,   5.6,   7.5,  10.0,  13.0,  18.0,  24.0,  32.0};
+  G4int ik = 29;
+  G4double sk = 1.0;
+  for (G4int i = 1; i < 30; i++) {
+    if (ke <= keScale[i]) {
+      ik = i;
+      sk = (ke - keScale[ik - 1]) / (keScale[ik] - keScale[ik - 1]);
+      break;
+    }
+  }
+  G4double csec = 0.0;
+  // pp, nn
+  if (rtype == 1 || rtype == 4) {
+    csec = PPtot[ik - 1] + sk * (PPtot[ik] - PPtot[ik - 1]);
+  // np
+  } else if (rtype == 2) {
+    csec = NPtot[ik - 1] + sk * (NPtot[ik] - NPtot[ik - 1]);
+  // pi+p, pi-n
+  } else if (rtype == 3 || rtype == 10) {
+    csec = pipPtot[ik - 1] + sk * (pipPtot[ik] - pipPtot[ik - 1]);
+  // pi-p, pi+n
+  } else if (rtype == 5 || rtype == 6) {
+    csec = pimPtot[ik - 1] + sk * (pimPtot[ik] - pimPtot[ik - 1]);
+  // pi0p, pi0n
+  } else if (rtype == 7 || rtype == 14) {
+    csec = pizPtot[ik - 1] + sk * (pizPtot[ik] - pizPtot[ik - 1]);
+    // k+ p, k0 n
+  } else if (rtype == 11 || rtype == 30) {
+    csec = kpPtot[ik - 1] + sk * (kpPtot[ik] - kpPtot[ik - 1]);
+  // k- p, k0b n
+  } else if (rtype == 13 || rtype == 34) {
+    csec = kmPtot[ik - 1] + sk * (kmPtot[ik] - kmPtot[ik - 1]);
+  // k+ n, k0 p
+  } else if (rtype == 22 || rtype == 15) {
+    csec = kpNtot[ik - 1] + sk * (kpNtot[ik] - kpNtot[ik - 1]);
+  // k- n, k0b p
+  } else if (rtype == 26 || rtype == 17) {
+    csec = kmNtot[ik - 1] + sk * (kmNtot[ik] - kmNtot[ik - 1]);
+  // L p, L n, S0 p, S0 n
+  } else if (rtype == 21 || rtype == 25 || rtype == 42 || rtype == 50) {
+    csec = lPtot[ik - 1] + sk * (lPtot[ik] - lPtot[ik - 1]);
+  // Sp p, Sm n
+  } else if (rtype == 23 || rtype == 54) {
+    csec = spPtot[ik - 1] + sk * (spPtot[ik] - spPtot[ik - 1]);
+  // Sm p, Sp n
+  } else if (rtype == 27 || rtype == 46) {
+    csec = smPtot[ik - 1] + sk * (smPtot[ik] - smPtot[ik - 1]);
+  // Xi0 p, Xi- n
+  } else if (rtype == 29 || rtype == 62) {
+    csec = xi0Ptot[ik - 1] + sk * (xi0Ptot[ik] - xi0Ptot[ik - 1]);
+  // Xi- p, Xi0 n
+  } else if (rtype == 31 || rtype == 58) {
+    csec = ximPtot[ik - 1] + sk * (ximPtot[ik] - ximPtot[ik - 1]);
+  } else {
+  static const G4int NBINS = sizeof(keScale)/sizeof(G4double);
+  static G4CascadeInterpolator<NBINS> interp(keScale);
+  // Pion and nucleon scattering cross-sections are available elsewhere
+  switch (rtype) {
+  case pro*pro: return G4CascadePPChannel::getCrossSection(ke); break;
+  case pro*neu: return G4CascadeNPChannel::getCrossSection(ke); break;
+  case pip*pro: return G4CascadePiPlusPChannel::getCrossSection(ke); break;
+  case neu*neu: return G4CascadeNNChannel::getCrossSection(ke); break;
+  case pim*pro: return G4CascadePiMinusPChannel::getCrossSection(ke); break;
+  case pip*neu: return G4CascadePiPlusNChannel::getCrossSection(ke); break;
+  case pi0*pro: return G4CascadePiZeroPChannel::getCrossSection(ke); break;
+  case pim*neu: return G4CascadePiMinusNChannel::getCrossSection(ke); break;
+  case pi0*neu: return G4CascadePiZeroNChannel::getCrossSection(ke); break;
+    // Remaining channels are handled locally until arrays are moved
+  case kpl*pro:
+  case k0*neu:  return interp.interpolate(ke, kpPtot); break;
+  case kmi*pro:
+  case k0b*neu: return interp.interpolate(ke, kmPtot); break;
+  case kpl*neu:
+  case k0*pro:  return interp.interpolate(ke, kpNtot); break;
+  case kmi*neu:
+  case k0b*pro: return interp.interpolate(ke, kmNtot); break;
+  case lam*pro:
+  case lam*neu:
+  case s0*pro:
+  case s0*neu:  return interp.interpolate(ke, lPtot); break;
+  case sp*pro:
+  case sm*neu:  return interp.interpolate(ke, spPtot); break;
+  case sm*pro:
+  case sp*neu:  return interp.interpolate(ke, smPtot); break;
+  case xi0*pro:
+  case xim*neu: return interp.interpolate(ke, xi0Ptot); break;
+  case xim*pro:
+  case xi0*neu: return interp.interpolate(ke, ximPtot); break;
+  default:
     G4cout << " unknown collison type = " << rtype << G4endl;
+  }
+  return csec;
+}
+void G4NucleiModel::initTotalCrossSections()
+{
+  const G4double PPtotData[30] = {
+.0, 302.9, 257.1, 180.6, 128.4,  90.5,  66.1,  49.4,  36.9, 29.6,
+.0,  23.1,  22.6,  23.0,  27.0,  32.0,  44.0,  47.04, 44.86, 46.03,
+.09, 41.81, 41.17, 40.65, 40.15, 40.18, 39.26, 38.36, 38.39, 38.41};
+  const G4double NPtotData[30] = {
+.0, 912.6, 788.6, 582.1, 415.0, 272.0, 198.8, 145.0, 100.4,  71.1,
+.8,  45.7,  38.9,  34.4,  34.0,  35.0,  37.5,  39.02, 40.29, 40.72,
+.36, 41.19, 42.04, 41.67, 40.96, 39.48, 39.79, 39.39, 39.36, 39.34};
+  const G4double pipPtotData[30] = {
+.0,   1.2,   2.5,   3.8,   5.0,  7.0,   9.0,  15.0, 30.0,  64.0,
+.0, 190.0, 130.0,  56.0,  28.0, 17.14, 19.28, 27.4, 40.05, 32.52,
+.46, 29.0,  27.26, 25.84, 25.5, 24.5,  24.0,  23.5, 23.0,  23.0};
+  const G4double pimPtotData[30] = {
+.13,  6.4,   6.67,  6.94,  7.22,  7.5,  8.3,  12.0,  14.4,  24.0,
+.0,  72.04, 43.02, 27.19, 27.32, 43.8, 37.08, 51.37, 34.21, 34.79,
+.08, 31.19, 30.32, 28.5,  27.0,  25.9, 25.5,  25.2,  25.0,  24.8};
+  //  const G4double pizPtotData[30] = {
+  //    0.0,   3.55,  4.65,  5.9,   7.75, 10.1,  11.8,  18.0,  27.7, 52.5,
+  //  102.0, 150.0, 102.64, 51.03, 34.94, 34.52, 32.45, 44.05, 40.2, 34.93,
+  //   32.0,  30.0,  28.29, 26.91, 26.25, 25.25, 24.75, 24.35, 24.0, 23.9};
+  // New test
+  const G4double pizPtotData[30] = {
+.43,  7.18,  7.54,  8.01,  8.52,  9.13, 10.22, 14.37, 20.96, 34.73,
+.07, 98.23, 61.97, 32.62, 28.07, 31.37, 35.15, 40.17, 37.27, 33.49,
+.06, 29.52, 28.29, 26.91, 26.25, 25.25, 24.75, 24.35, 24.0,  23.9};
+  const G4double kpPtotData[30] = {
+  return 0.;            // Failure
+}
+// Initialize cross-section interpolation tables
+const G4double G4NucleiModel::kpPtot[30] = {
 .0,  10.34, 10.44, 10.61, 10.82, 11.09, 11.43, 11.71, 11.75, 11.8,
 .98, 12.28, 12.56, 12.48, 12.67, 14.48, 15.92, 17.83, 17.93, 17.88,
 .46, 17.3,  17.3,  17.4,  17.4,  17.4,  17.4,  17.5,  17.7,  17.8};
   const G4double kpNtotData[30] = {
+const G4double G4NucleiModel::kpNtot[30] = {
 .64,  6.99,  7.09,  7.27,  7.48,  7.75,  8.1,  8.49,  8.84, 9.31,
 .8,  10.62, 11.64, 13.08, 14.88, 16.60, 17.5, 18.68, 18.68, 18.29,
 .81, 17.6,  17.6,  17.6,  17.6,  17.6,  17.7, 17.8,  17.9,  18.0};
   const G4double kmPtotData[30] = {
+const G4double G4NucleiModel::kmPtot[30] = {
 .0, 1681.41, 1586.74, 1428.95, 1239.59, 987.12, 671.54, 377.85, 247.30, 75.54,
 .08, 54.74,   44.08,   44.38,   45.45,  45.07,  41.04,  35.75,  33.22, 30.08,
 .61, 26.5,    25.2,    24.0,    23.4,   22.8,   22.0,   21.3,   21.0,  20.9};
   const G4double kmNtotData[30] = {
+const G4double G4NucleiModel::kmNtot[30] = {
 .15,  6.93,  7.16,  7.55,  8.02,  8.65,  9.43, 10.36, 11.34, 12.64,
 .01, 16.45, 19.32, 23.0,  27.6,  30.92, 29.78, 28.28, 25.62, 23.1,
 .31, 21.9,  21.73, 21.94, 21.23, 20.5,  20.4,  20.2,  20.1,  20.0};
   const G4double lPtotData[30] = {
+const G4double G4NucleiModel::lPtot[30] = {
 .0, 249.07, 233.8, 208.33, 177.78, 137.04, 86.11, 41.41, 28.86, 12.35,
 .82, 16.76, 20.68,  25.9,   30.37,  31.56, 32.83, 34.5,  34.91, 35.11,
 .03, 36.06, 35.13,  35.01,  35.0,   35.0,  35.0,  35.0,  35.0,  35.0};
   const G4double spPtotData[30] = {
+const G4double G4NucleiModel::spPtot[30] = {
 .0, 146.0, 144.8, 142.8, 140.4, 137.2, 133.2, 127.6, 120.0, 110.0,
 .06, 84.16, 72.28, 56.58, 43.22, 40.44, 36.14, 30.48, 31.53, 31.92,
 .25, 28.37, 29.81, 33.15, 33.95, 34.0,  34.0,  34.0,  34.0,  34.0};
   const G4double smPtotData[30] = {
+const G4double G4NucleiModel::smPtot[30] = {
 .0, 788.14, 743.48, 669.05, 579.74, 460.65, 311.79, 183.33, 153.65, 114.6,
 .18, 89.54,  70.58,  45.5,   32.17,  32.54,  32.95,  33.49,  33.55,  33.87,
 .02, 34.29,  33.93,  33.88,  34.0,   34.0,   34.0,   34.0,   34.0,   34.0};
   const G4double xi0PtotData[30] = {
+const G4double G4NucleiModel::xi0Ptot[30] = {
 .0,  14.72, 14.34, 13.7,  12.93, 11.9,  10.62, 9.29, 8.3,   7.0,
 .96,  9.56, 11.48, 14.04, 19.22, 25.29, 29.4, 34.8, 34.32, 33.33,
 .89, 29.55, 27.89, 21.43, 17.0,  16.0,  16.0, 16.0, 16.0,  16.0};
   const G4double ximPtotData[30] = {
+const G4double G4NucleiModel::ximPtot[30] = {
 .0,  32.5,  32.35, 32.1,  31.8,  31.4,  30.9, 30.2, 29.25, 28.0,
 .5,  24.6,  22.8,  20.78, 18.22, 19.95, 21.7, 24.0, 24.74, 25.95,
 .59, 27.54, 23.16, 17.43, 12.94, 12.0,  12.0, 12.0, 12.0,  12.0};
-  for (G4int i = 0; i < 30; i++) {
-    PPtot[i] = PPtotData[i];
-    NPtot[i] = NPtotData[i];
-    pipPtot[i] = pipPtotData[i];
-    pimPtot[i] = pimPtotData[i];
-    pizPtot[i] = pizPtotData[i];
-    kpPtot[i] = kpPtotData[i];
-    kpNtot[i] = kpNtotData[i];
-    kmPtot[i] = kmPtotData[i];
-    kmNtot[i] = kmNtotData[i];
-    lPtot[i] = lPtotData[i];
-    spPtot[i] = spPtotData[i];
-    smPtot[i] = smPtotData[i];
-    xi0Ptot[i] = xi0PtotData[i];
-    ximPtot[i] = ximPtotData[i];
+  }
+}

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4PreCompoundCascadeInterface.cc,v 1.13 2010/05/21 18:07:30 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
+// 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
+// 20100414  M. Kelsey -- Check for K0L/K0S before using G4InuclElemPart::type
+// 20100419  M. Kelsey -- Access G4CollisionOutput lists by const-ref, and
+//              const_iterator
+// 20100428  M. Kelsey -- Use G4InuclParticleNames enum
+// 20100429  M. Kelsey -- Change "case gamma:" to "case photon:"
+// 20100517  M. Kelsey -- Follow new ctors for G4*Collider family.
+// 20100520  M. Kelsey -- Add missing name string to ctor, follow code changes
+//              from G4CascadeInterface.
 #include "G4PreCompoundCascadeInterface.hh"
 #include "globals.hh"
+#include "G4DynamicParticleVector.hh"
+#include "G4IonTable.hh"
+#include "G4PreCompoundInuclCollider.hh"
+#include "G4IntraNucleiCascader.hh"
+#include "G4ElementaryParticleCollider.hh"
+#include "G4NonEquilibriumEvaporator.hh"
+#include "G4BigBanger.hh"
+#include "G4CollisionOutput.hh"
+#include "G4DynamicParticle.hh"
 #include "G4InuclElementaryParticle.hh"
 #include "G4InuclNuclei.hh"
 #include "G4InuclParticle.hh"
+#include "G4CollisionOutput.hh"
+#include "G4InuclParticleNames.hh"
+#include "G4KaonZeroShort.hh"
+#include "G4KaonZeroLong.hh"
+#include "G4LorentzRotation.hh"
+#include "G4Nucleus.hh"
+#include "G4ParticleDefinition.hh"
+#include "G4PreCompoundInuclCollider.hh"
+#include "G4Track.hh"
 #include "G4V3DNucleus.hh"
+#include "G4Track.hh"
+#include "G4Nucleus.hh"
+#include "G4NucleiModel.hh"
+#include "G4LorentzRotation.hh"
+typedef std::vector<G4InuclElementaryParticle>::iterator particleIterator;
+typedef std::vector<G4InuclNuclei>::iterator nucleiIterator;
+G4PreCompoundCascadeInterface::G4PreCompoundCascadeInterface()
+  :verboseLevel(0)  {
+using namespace G4InuclParticleNames;
+typedef std::vector<G4InuclElementaryParticle>::const_iterator particleIterator;
+typedef std::vector<G4InuclNuclei>::const_iterator nucleiIterator;
+G4PreCompoundCascadeInterface::G4PreCompoundCascadeInterface(const G4String& nam)
+  :G4VIntraNuclearTransportModel(nam), verboseLevel(0)  {
   if (verboseLevel > 3) {
 …
   // NOTE: Geant4 units are MeV = 1 and GeV = 1000. Cascade code by default use GeV = 1.
+  enum particleType { nuclei      = 0,  proton     = 1,  neutron   = 2,  pionPlus = 3,
+                      pionMinus   = 5,  pionZero   = 7,  photon    = 10,
+                      kaonPlus    = 11, kaonMinus  = 13, kaonZero  = 15,
+                      kaonZeroBar = 17, lambda     = 21, sigmaPlus = 23,
+                      sigmaZero   = 25, sigmaMinus = 27, xiZero    = 29, xiMinus  = 31 };
+  G4int bulletType = 0;
+  // Coding particles
+  if (aTrack.GetDefinition() == G4Proton::Proton()         ) bulletType = proton;
+  if (aTrack.GetDefinition() == G4Neutron::Neutron()       ) bulletType = neutron;
+  if (aTrack.GetDefinition() == G4PionPlus::PionPlus()     ) bulletType = pionPlus;
+  if (aTrack.GetDefinition() == G4PionMinus::PionMinus()   ) bulletType = pionMinus;
+  if (aTrack.GetDefinition() == G4PionZero::PionZero()     ) bulletType = pionZero;
+  if (aTrack.GetDefinition() == G4Gamma::Gamma()           ) bulletType = photon;
+  if (aTrack.GetDefinition() == G4KaonPlus::KaonPlus()     ) bulletType = kaonPlus;
+  if (aTrack.GetDefinition() == G4KaonMinus::KaonMinus()   ) bulletType = kaonMinus;
+  if (aTrack.GetDefinition() == G4Lambda::Lambda()         ) bulletType = lambda;
+  if (aTrack.GetDefinition() == G4SigmaPlus::SigmaPlus()   ) bulletType = sigmaPlus;
+  if (aTrack.GetDefinition() == G4SigmaZero::SigmaZero()   ) bulletType = sigmaZero;
+  if (aTrack.GetDefinition() == G4SigmaMinus::SigmaMinus() ) bulletType = sigmaMinus;
+  if (aTrack.GetDefinition() == G4XiZero::XiZero()         ) bulletType = xiZero;
+  if (aTrack.GetDefinition() == G4XiMinus::XiMinus()       ) bulletType = xiMinus;
+  G4int bulletType;
   if (aTrack.GetDefinition() == G4KaonZeroLong::KaonZeroLong() ||
+      aTrack.GetDefinition() == G4KaonZeroShort::KaonZeroShort() ) {
+    if (G4UniformRand() > 0.5) {
+      bulletType = kaonZero;
+    } else {
+      bulletType = kaonZeroBar;
+    }
+  }
+      aTrack.GetDefinition() == G4KaonZeroShort::KaonZeroShort() )
+    bulletType = (G4UniformRand() > 0.5) ? kaonZero : kaonZeroBar;
+  else
+    bulletType = G4InuclElementaryParticle::type(aTrack.GetDefinition());
   // Code momentum and energy.
-  G4double px,py,pz;
-  px=aTrack.Get4Momentum().px() / GeV;
-  py=aTrack.Get4Momentum().py() / GeV;
-  pz=aTrack.Get4Momentum().pz() / GeV;
   G4LorentzVector projectileMomentum = aTrack.Get4Momentum();
   G4LorentzRotation toZ;
 …
   G4LorentzRotation toLabFrame = toZ.inverse();
+  G4CascadeMomentum momentumBullet;
+  momentumBullet[0] =0.;
+  momentumBullet[1] =0;
+  momentumBullet[2] =0;
+  momentumBullet[3] =std::sqrt(px*px+py*py+pz*pz);
+  G4InuclElementaryParticle *  bullet = new G4InuclElementaryParticle(momentumBullet, bulletType);
+  G4LorentzVector momentumBullet(0., 0., aTrack.GetTotalMomentum()/GeV,
+                                 aTrack.GetTotalEnergy()/GeV);
+  G4InuclElementaryParticle *  bullet =
+    new G4InuclElementaryParticle(momentumBullet, bulletType);
   sumEnergy = bullet->getKineticEnergy(); // In GeV
+  if (bulletType == proton || bulletType == neutron || bulletType == lambda ||
+      bulletType == sigmaPlus || bulletType == sigmaZero || bulletType == sigmaMinus ||
+      bulletType == xiZero || bulletType == xiMinus) {
+    sumBaryon += 1;
+  }
+  sumBaryon += bullet->baryon();
   // Set target
   G4InuclNuclei*   target  = 0;
   G4InuclParticle* targetH = 0;
-  // and outcoming particles
-  G4DynamicParticle* cascadeParticle = 0;
-  G4CascadeMomentum targetMomentum;
   G4double theNucleusA = theNucleus.GetN();
   if ( !(G4int(theNucleusA) == 1) ) {
+    target  = new G4InuclNuclei(targetMomentum,
+                                theNucleusA,
+                                theNucleus.GetZ());
+    target->setEnergy();
+    const G4CascadeMomentum& bmom = bullet->getMomentum();
+    eInit = std::sqrt(bmom[0] * bmom[0]);
+    const G4CascadeMomentum& tmom = target->getMomentum();
+    eInit += std::sqrt(tmom[0] * tmom[0]);
+    target  = new G4InuclNuclei(theNucleusA, theNucleus.GetZ());
+    eInit = bullet->getEnergy() + target->getEnergy();
     sumBaryon += theNucleusA;
 …
   // Colliders initialisation
+  G4ElementaryParticleCollider*   colep = new G4ElementaryParticleCollider;
+  G4IntraNucleiCascader*            inc = new G4IntraNucleiCascader; // the actual cascade
+  inc->setInteractionCase(1); // Interaction type is particle with nuclei.
+  G4NonEquilibriumEvaporator*     noneq = new G4NonEquilibriumEvaporator;
+  G4BigBanger*                     bigb = new G4BigBanger;
+  G4PreCompoundInuclCollider*  collider = new G4PreCompoundInuclCollider(colep, inc, noneq, bigb);
+  G4PreCompoundInuclCollider*  collider = new G4PreCompoundInuclCollider;
   G4int  maxTries = 10; // maximum tries for inelastic collision to avoid infinite loop
 …
   if (G4int(theNucleusA) == 1) { // special treatment for target H(1,1) (proton)
     targetH = new G4InuclElementaryParticle(targetMomentum, 1);
+    targetH = new G4InuclElementaryParticle(1);
     G4float cutElastic[32];
 …
     cutElastic[kaonPlus ]   = 0.5; // 0.5 GeV
     cutElastic[kaonMinus]   = 0.5;
-    cutElastic[kaonMinus]   = 0.5;
     cutElastic[kaonZero]    = 0.5;
     cutElastic[kaonZeroBar] = 0.5;
 …
     if (momentumBullet[3] > cutElastic[bulletType]) { // inelastic collision possible
+    if (momentumBullet.z() > cutElastic[bulletType]) { // inelastic collision possible
       do {   // we try to create inelastic interaction
+        output = collider->collide(bullet, targetH);
+        output.reset();
+        collider->collide(bullet, targetH, output);
         nTries++;
       } while(
 …
     } else { // only elastic collision is energetically possible
       output = collider->collide(bullet, targetH);
+      collider->collide(bullet, targetH, output);
+    }
     sumBaryon += 1;
+    const G4CascadeMomentum& bmom = bullet->getMomentum();
+    eInit = std::sqrt(bmom[0] * bmom[0]);
+    const G4CascadeMomentum& tmom = targetH->getMomentum();
+    eInit += std::sqrt(tmom[0] * tmom[0]);
+    eInit = bullet->getEnergy() + target->getEnergy();
     if (verboseLevel > 2) {
 …
     do  // we try to create inelastic interaction
+      {
+        output = collider->collide(bullet, target );
+        output.reset();
+        collider->collide(bullet, target, output);
         nTries++;
       } while (
-               //             (nTries < maxTries)                                                               &&
-               //(output.getOutgoingParticles().size() + output.getNucleiFragments().size() < 2.5) &&
-               //(output.getOutgoingParticles().size()!=0)                                         &&
-               //(output.getOutgoingParticles().begin()->type()==bullet->type())
-               //);
                (nTries < maxTries) &&
                output.getOutgoingParticles().size() == 1 &&     // we retry when elastic collision happened
 …
+  }
+  if (verboseLevel > 1)
+    {
+  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
   std::vector<G4InuclNuclei>             nucleiFragments = output.getNucleiFragments();
   std::vector<G4InuclElementaryParticle> particles =       output.getOutgoingParticles();
+  const std::vector<G4InuclNuclei>& nucleiFragments = output.getNucleiFragments();
+  const std::vector<G4InuclElementaryParticle>& particles = output.getOutgoingParticles();
   theResult.SetStatusChange(stopAndKill);
+  // Get outcoming particles
+  G4DynamicParticle* cascadeParticle = 0;
   if (!particles.empty()) {
+    particleIterator ipart;
+    G4int outgoingParticle;
+    for (ipart = particles.begin(); ipart != particles.end(); ipart++) {
+      outgoingParticle = ipart->type();
+      const G4CascadeMomentum& mom = ipart->getMomentum();
+      eTot   += std::sqrt(mom[0] * mom[0]);
+      G4double ekin = ipart->getKineticEnergy() * GeV;
+      G4ThreeVector aMom(mom[1], mom[2], mom[3]);
+      aMom = aMom.unit();
+      if (ipart->baryon() ) {
+        sumBaryon -= 1;
+    particleIterator ipart = particles.begin();
+    for (; ipart != particles.end(); ipart++) {
+      G4int outgoingType = ipart->type();
+      eTot += ipart->getEnergy();
+      sumBaryon -= ipart->baryon();
+      sumEnergy -= ipart->getKineticEnergy();
+      if (!ipart->valid() || ipart->quasi_deutron()) {
+        G4cerr << " ERROR: G4PreCompoundCascadeInterface::Propagate incompatible"
+               << " particle type " << ipart->type() << G4endl;
+        continue;
+      }
+      sumEnergy -= ekin / GeV;
+      switch(outgoingParticle) {
+      case proton:
+#ifdef debug_G4PreCompoundCascadeInterface
+        G4cerr << "proton " << counter << " " << aMom << " " << ekin << G4endl;
+#endif
+        cascadeParticle = new G4DynamicParticle(G4Proton::ProtonDefinition(), aMom, ekin);
+        break;
+      case neutron:
+#ifdef debug_G4PreCompoundCascadeInterface
+        G4cerr << "neutron "<< counter<<" "<<aMom<<" "<<  ekin<<G4endl;
+#endif
+        cascadeParticle = new G4DynamicParticle(G4Neutron::NeutronDefinition(), aMom, ekin);
+        break;
+      case pionPlus:
+        cascadeParticle = new G4DynamicParticle(G4PionPlus::PionPlusDefinition(), aMom, ekin);
+#ifdef debug_G4PreCompoundCascadeInterface
+        G4cerr << "pionPlus "<< counter<<" "<<aMom<<" "<<  ekin<<G4endl;
+#endif
+        break;
+      case pionMinus:
+        cascadeParticle = new G4DynamicParticle(G4PionMinus::PionMinusDefinition(), aMom, ekin);
+#ifdef debug_G4PreCompoundCascadeInterface
+        G4cerr << "pionMinus "<< counter<<" "<<aMom<<" "<<  ekin<<G4endl;
+#endif
+        break;
+      case pionZero:
+        cascadeParticle = new G4DynamicParticle(G4PionZero::PionZeroDefinition(), aMom, ekin);
+#ifdef debug_G4PreCompoundCascadeInterface
+        G4cerr << "pionZero "<< counter<<" "<<aMom<<" "<<  ekin<<G4endl;
+#endif
+        break;
+      case photon:
+        cascadeParticle = new G4DynamicParticle(G4Gamma::Gamma(), aMom, ekin);
+#ifdef debug_G4PreCompoundCascadeInterface
+        G4cerr << "photon "<< counter<<" "<<aMom<<" "<<  ekin<<G4endl;
+#endif
+        break;
+      case kaonPlus:
+        cascadeParticle = new G4DynamicParticle(G4KaonPlus::KaonPlusDefinition(), aMom, ekin);
+        break;
+      case kaonMinus:
+        cascadeParticle = new G4DynamicParticle(G4KaonMinus::KaonMinusDefinition(), aMom, ekin);
+        break;
+      case kaonZero:
+        if (G4UniformRand() > 0.5) {
+          cascadeParticle = new G4DynamicParticle(G4KaonZeroLong::KaonZeroLongDefinition(), aMom, ekin);
+        } else {
+          cascadeParticle = new G4DynamicParticle(G4KaonZeroShort::KaonZeroShortDefinition(), aMom, ekin);
+        }
+        break;
+      case kaonZeroBar:
+        if (G4UniformRand() > 0.5) {
+          cascadeParticle = new G4DynamicParticle(G4KaonZeroLong::KaonZeroLongDefinition(), aMom, ekin);
+        } else {
+          cascadeParticle = new G4DynamicParticle(G4KaonZeroShort::KaonZeroShortDefinition(), aMom, ekin);
+        }
+        break;
+      case lambda:
+        cascadeParticle = new G4DynamicParticle(G4Lambda::LambdaDefinition(), aMom, ekin);
+        break;
+      case sigmaPlus:
+        cascadeParticle = new G4DynamicParticle(G4SigmaPlus::SigmaPlusDefinition(), aMom, ekin);
+        break;
+      case sigmaZero:
+        cascadeParticle = new G4DynamicParticle(G4SigmaZero::SigmaZeroDefinition(), aMom, ekin);
+        break;
+      case sigmaMinus:
+        cascadeParticle = new G4DynamicParticle(G4SigmaMinus::SigmaMinusDefinition(), aMom, ekin);
+        break;
+      case xiZero:
+        cascadeParticle = new G4DynamicParticle(G4XiZero::XiZeroDefinition(), aMom, ekin);
+        break;
+      case xiMinus:
+        cascadeParticle = new G4DynamicParticle(G4XiMinus::XiMinusDefinition(), aMom, ekin);
+        break;
+      default:
+        G4cout << " ERROR: G4PreCompoundCascadeInterface::Propagate undefined particle type" << G4endl;
+      // Copy local G4DynPart to public output (handle kaon mixing specially)
+      if (outgoingType == kaonZero || outgoingType == kaonZeroBar) {
+        G4ThreeVector momDir = ipart->getMomentum().vect().unit();
+        G4double ekin = ipart->getKineticEnergy();
+        G4ParticleDefinition* pd = G4KaonZeroShort::Definition();
+        if (G4UniformRand() > 0.5) pd = G4KaonZeroLong::Definition();
+        cascadeParticle = new G4DynamicParticle(pd, momDir, ekin);
+      } else {
+        cascadeParticle = new G4DynamicParticle(ipart->getDynamicParticle());
+      }
+      cascadeParticle->Set4Momentum(cascadeParticle->Get4Momentum()*=toLabFrame);
       theResult.AddSecondary(cascadeParticle);
+    }
 …
   // get nuclei fragments
   G4DynamicParticle * aFragment = 0;
-  G4ParticleDefinition * aIonDef = 0;
-  G4ParticleTable *theTableOfParticles = G4ParticleTable::GetParticleTable();
   if (!nucleiFragments.empty()) {
+    nucleiIterator ifrag;
+    for (ifrag = nucleiFragments.begin(); ifrag != nucleiFragments.end(); ifrag++)
+      {
+        G4double eKin = ifrag->getKineticEnergy() * GeV;
+        const G4CascadeMomentum& mom = ifrag->getMomentum();
+        eTot   += std::sqrt(mom[0] * mom[0]);
+        G4ThreeVector aMom(mom[1], mom[2], mom[3]);
+        aMom = aMom.unit();
+        // hpw @@@ ==> Should be zero: G4double fragmentExitation = ifrag->getExitationEnergyInGeV();
+        if (verboseLevel > 2) {
+          G4cout << " Nuclei fragment: " << G4endl;
+          ifrag->printParticle();
+        }
+        G4int A = G4int(ifrag->getA());
+        G4int Z = G4int(ifrag->getZ());
+        aIonDef = theTableOfParticles->FindIon(Z, A, 0, Z);
+        aFragment =  new G4DynamicParticle(aIonDef, aMom, eKin);
+        sumBaryon -= A;
+        sumEnergy -= eKin / GeV;
+        aFragment->Set4Momentum(aFragment->Get4Momentum()*=toLabFrame);
+        theResult.AddSecondary(aFragment);
+    nucleiIterator ifrag = nucleiFragments.begin();
+    for (; ifrag != nucleiFragments.end(); ifrag++) {
+      eTot += ifrag->getEnergy();
+      sumBaryon -= ifrag->getA();
+      sumEnergy -= ifrag->getKineticEnergy();
+      if (verboseLevel > 2) {
+        G4cout << " Nuclei fragment: " << G4endl;
+        ifrag->printParticle();
+      }
+  }
+      // Copy local G4DynPart to public output
+      aFragment =  new G4DynamicParticle(ifrag->getDynamicParticle());
+      theResult.AddSecondary(aFragment);
+    }
+  }
+  // Report violations of energy, baryon conservation
   if (verboseLevel > 2) {
     if (sumBaryon != 0) {
+      G4cout << "ERROR: no baryon number conservation, sum of baryons = " << sumBaryon << G4endl;
+      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 << "Kinetic energy conservation violated by "
+             << sumEnergy << " GeV" << G4endl;
+    }
+    G4cout << "Total energy conservation at level ~" << (eInit - eTot) * GeV << " MeV" << 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;
+      G4cout << "FATAL ERROR: energy created  "
+             << sumEnergy * GeV << " MeV" << G4endl;
+    }
+  }
   delete bullet;
-  delete colep;
-  delete inc;
-  delete noneq;
-  delete bigb;
   delete collider;
   if(target != 0) delete target;
   if(targetH != 0) delete targetH;
-  // if(cascadeParticle != 0) delete cascadeParticle;
-  // if(aFragment != 0) delete aFragment;
   return &theResult;

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

-              r962
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4PreCompoundInuclCollider.cc,v 1.9 2010/05/21 17:56:34 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100114  M. Kelsey -- Remove G4CascadeMomentum, use G4LorentzVector directly
+// 20100309  M. Kelsey -- Eliminate some unnecessary std::pow()
+// 20100413  M. Kelsey -- Pass G4CollisionOutput by ref to ::collide()
+// 20100429  M. Kelsey -- Change "photon()" to "isPhoton()"
+// 20100517  M. Kelsey -- Inherit from common base class, make other colliders
+//              simple data members, consolidate code
 #include "G4PreCompoundInuclCollider.hh"
+#include "G4BigBanger.hh"
+#include "G4CollisionOutput.hh"
+#include "G4ElementaryParticleCollider.hh"
+#include "G4IntraNucleiCascader.hh"
 #include "G4InuclElementaryParticle.hh"
 #include "G4LorentzConvertor.hh"
+#include "G4ParticleLargerEkin.hh"
+#include <algorithm>
+typedef std::vector<G4InuclElementaryParticle>::iterator particleIterator;
+typedef std::vector<G4InuclNuclei>::iterator nucleiIterator;
+#include "G4NonEquilibriumEvaporator.hh"
 G4PreCompoundInuclCollider::G4PreCompoundInuclCollider()
+  : verboseLevel(0) {
+  if (verboseLevel > 3) {
+    G4cout << " >>> G4PreCompoundInuclCollider::G4PreCompoundInuclCollider" << G4endl;
+  }
+  : G4VCascadeCollider("G4PreCompoundInuclCollider"),
+    theElementaryParticleCollider(new G4ElementaryParticleCollider),
+    theIntraNucleiCascader(new G4IntraNucleiCascader),
+    theNonEquilibriumEvaporator(new G4NonEquilibriumEvaporator),
+    theBigBanger(new G4BigBanger) {}
+G4PreCompoundInuclCollider::~G4PreCompoundInuclCollider() {
+  delete theElementaryParticleCollider;
+  delete theIntraNucleiCascader;
+  delete theNonEquilibriumEvaporator;
+  delete theBigBanger;
+}
+G4CollisionOutput G4PreCompoundInuclCollider::collide(G4InuclParticle* bullet,
+                                           G4InuclParticle* target) {
+  verboseLevel = 0;
+void G4PreCompoundInuclCollider::collide(G4InuclParticle* bullet,
+                                         G4InuclParticle* target,
+                                         G4CollisionOutput& globalOutput) {
   if (verboseLevel > 3) {
     G4cout << " >>> G4PreCompoundInuclCollider::collide" << G4endl;
 …
   const G4int itry_max = 1000;
+  G4CollisionOutput globalOutput;
+  G4InuclElementaryParticle* particle1 =
+    dynamic_cast<G4InuclElementaryParticle*>(bullet);
+  G4InuclElementaryParticle* particle2 =
+    dynamic_cast<G4InuclElementaryParticle*>(target);
+  if (particle1 && particle2) { // particle + particle (NOTE: also the h + H(1,1) treated here)
+  if (useEPCollider(bullet,target)) {
     if (verboseLevel > 2) {
       particle1->printParticle();
       particle2->printParticle();
+      bullet->printParticle();
+      target->printParticle();
+    }
+    globalOutput = theElementaryParticleCollider->collide(bullet, target);
+    theElementaryParticleCollider->collide(bullet, target, globalOutput);
   } else { // needs to call all machinery
     G4LorentzConvertor convertToTargetRestFrame;
+    G4InteractionCase interCase = bulletTargetSetter(bullet, target);
     G4int intcase = interCase.getInterCase();
+    interCase.set(bullet, target);
     if (intcase > 0) { // ok
+    if (interCase.valid()) { // ok
       G4InuclNuclei* ntarget =
         dynamic_cast<G4InuclNuclei*>(interCase.getTarget());
+      convertToTargetRestFrame.setTarget(ntarget->getMomentum(),
+                                         ntarget->getMass());
+      convertToTargetRestFrame.setTarget(ntarget);
       G4int btype = 0;
       G4double ab = 0.0;
 …
       G4double zt = ntarget->getZ();
       if (intcase == 1) { // particle with nuclei
+      if (interCase.hadNucleus()) { // particle with nuclei
         G4InuclElementaryParticle* pbullet =
           dynamic_cast<G4InuclElementaryParticle*>(interCase.getBullet());
         if (pbullet->photon()) {
+        if (pbullet->isPhoton()) {
           G4cout << " InuclCollider -> can not collide with photon " << G4endl;
           globalOutput.trivialise(bullet, target);
+          return globalOutput;
+          return;
         } else {
+          convertToTargetRestFrame.setBullet(pbullet->getMomentum(),
+                                             pbullet->getMass());
+          convertToTargetRestFrame.setBullet(pbullet);
           btype = pbullet->type();
         };
 …
           dynamic_cast<G4InuclNuclei*>(interCase.getBullet());
+        convertToTargetRestFrame.setBullet(nbullet->getMomentum(),
+                                           nbullet->getMass());
+        convertToTargetRestFrame.setBullet(nbullet);
         ab = nbullet->getA();
         zb = nbullet->getZ();
 …
+        }
+        G4CascadeMomentum bmom;
+        bmom[3] = convertToTargetRestFrame.getTRSMomentum();
+        G4InuclNuclei ntarget(at, zt);
+        G4CascadeMomentum tmom;
+        ntarget.setMomentum(tmom);
+        ntarget.setEnergy();
+        theIntraNucleiCascader->setInteractionCase(intcase);
+        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) {
-          G4CollisionOutput TRFoutput;
-          G4CollisionOutput output;
           itry++;
+          if (intcase == 1) {
+          output.reset();       // Clear buffers for this attempt
+          TRFoutput.reset();
+          if (interCase.hadNucleus()) {
             G4InuclElementaryParticle pbullet(bmom, btype);
             output = theIntraNucleiCascader->collide(&pbullet, &ntarget);
+            theIntraNucleiCascader->collide(&pbullet, &ntarget, output);
           } else {
+            G4InuclNuclei nbullet(ab, zb);
+            nbullet.setMomentum(bmom);
+            nbullet.setEnergy();
+            output = theIntraNucleiCascader->collide(&nbullet, &ntarget);
+            G4InuclNuclei nbullet(bmom, ab, zb);
+            theIntraNucleiCascader->collide(&nbullet, &ntarget, output);
           };
           if (verboseLevel > 3) {
             G4cout << " After Cascade " << G4endl;
             output.printCollisionOutput();
+          }
 …
           TRFoutput.addOutgoingParticles(output.getOutgoingParticles());
           if (output.numberOfNucleiFragments() == 1) { // there is smth. after
+          if (output.numberOfNucleiFragments() == 1) { // there is smth. after
             G4InuclNuclei cascad_rec_nuclei = output.getNucleiFragments()[0];
             if (explosion(&cascad_rec_nuclei)) {
 …
               };
+              output = theBigBanger->collide(0,&cascad_rec_nuclei);
+              TRFoutput.addOutgoingParticles(output.getOutgoingParticles());
+              theBigBanger->collide(0,&cascad_rec_nuclei, TRFoutput);
             } else {
+              output = theNonEquilibriumEvaporator->collide(0, &cascad_rec_nuclei);
+              output.reset();
+              theNonEquilibriumEvaporator->collide(0, &cascad_rec_nuclei, output);
               if (verboseLevel > 3) {
 …
               TRFoutput.addOutgoingParticles(output.getOutgoingParticles());
               TRFoutput.addTargetFragments(output.getNucleiFragments());
+              TRFoutput.addTargetFragments(output.getNucleiFragments());
             };
           };
           // convert to the LAB
+          G4bool withReflection = convertToTargetRestFrame.reflectionNeeded();
+          std::vector<G4InuclElementaryParticle> particles =
+            TRFoutput.getOutgoingParticles();
+          if (!particles.empty()) {
+            particleIterator ipart;
+            for(ipart = particles.begin(); ipart != particles.end(); ipart++) {
+              G4CascadeMomentum mom = ipart->getMomentum();
+              if (withReflection) mom[3] = -mom[3];
+              mom = convertToTargetRestFrame.rotate(mom);
+              ipart->setMomentum(mom);
+              mom = convertToTargetRestFrame.backToTheLab(ipart->getMomentum());
+              ipart->setMomentum(mom);
+            };
+            std::sort(particles.begin(), particles.end(), G4ParticleLargerEkin());
+          };
+          std::vector<G4InuclNuclei> nucleus = TRFoutput.getNucleiFragments();
+          if (!nucleus.empty()) {
+            nucleiIterator inuc;
+            for (inuc = nucleus.begin(); inuc != nucleus.end(); inuc++) {
+              G4CascadeMomentum mom = inuc->getMomentum();
+              if (withReflection) mom[3] = -mom[3];
+              mom = convertToTargetRestFrame.rotate(mom);
+              inuc->setMomentum(mom);
+              inuc->setEnergy();
+              mom = convertToTargetRestFrame.backToTheLab(inuc->getMomentum());
+              inuc->setMomentum(mom);
+              inuc->setEnergy();
+            };
+          };
+          globalOutput.addOutgoingParticles(particles);
+          globalOutput.addTargetFragments(nucleus);
+          TRFoutput.boostToLabFrame(convertToTargetRestFrame);
+          globalOutput.addOutgoingParticles(TRFoutput.getOutgoingParticles());
+          globalOutput.addTargetFragments(TRFoutput.getNucleiFragments());
           globalOutput.setOnShell(bullet, target);
+          if(globalOutput.acceptable()) {
+            return globalOutput;
+          } else {
+            globalOutput.reset();
+          };
+          if (globalOutput.acceptable()) return;
+          globalOutput.reset();         // Clear and try again
         };
 …
                  << itry_max << " attempts " << G4endl;
+        }
-        globalOutput.trivialise(bullet, target);
-        return globalOutput;
       } else {
         if (verboseLevel > 3) {
           G4cout << " InuclCollider -> inelastic interaction is impossible " << G4endl
                  << " due to the coulomb barirer " << G4endl;
+        }
+        globalOutput.trivialise(bullet, target);
+        return globalOutput;
+      };
+      }
+      globalOutput.trivialise(bullet, target);
+      return;
     } else {
       if (verboseLevel > 3) {
         G4cout << " InuclCollider -> inter case " << intcase << G4endl;
+        G4cout << " InuclCollider -> inter case " << interCase.code() << G4endl;
       };
     };
   };
   return globalOutput;
+  return;
+}
-G4bool G4PreCompoundInuclCollider::inelasticInteractionPossible(G4InuclParticle* bullet,
-                                                     G4InuclParticle* target,
-                                                     G4double ekin) const {
-  if (verboseLevel > 3) {
-    G4cout << " >>> G4PreCompoundInuclCollider::inelasticInteractionPossible" << G4endl;
+  }
-  const G4double coeff = 0.001 * 1.2;
-  const G4double one_third = 1.0 / 3.0;
-  G4bool possible = true;
-  G4double at;
-  G4double zt;
-  G4double ab;
-  G4double zb;
-  if (G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target)) {
-    at = nuclei_target->getA();
-    zt = nuclei_target->getZ();
-    if (G4InuclNuclei* nuclei_bullet = dynamic_cast<G4InuclNuclei*>(bullet)) {
-      ab = nuclei_bullet->getA();
-      zb = nuclei_bullet->getZ();
-    } else {
-      G4InuclElementaryParticle* particle =
-        dynamic_cast<G4InuclElementaryParticle*>(bullet);
-      ab = 1;
-      zb = particle->getCharge();
-    };
-  } else {
-    if(G4InuclNuclei* nuclei_bullet = dynamic_cast<G4InuclNuclei*>(bullet)) {
-      ab = nuclei_bullet->getA();
-      zb = nuclei_bullet->getZ();
-      G4InuclElementaryParticle* particle =
-        dynamic_cast<G4InuclElementaryParticle*>(target);
-      at = 1;
-      zt = particle->getCharge();
-    } else {
-      return possible;
-    };
-  };
-  // VCOL used  for testing if elastic collision possible
-  G4double VCOL = coeff * zt * zb / (std::pow(at, one_third) + std::pow(ab, one_third));
-  // possible = VCOL < ekin; // NOTE: inelastic collision if not true
-  possible = true; // we force elastic
-  if (verboseLevel > 3) {
-    G4cout << " >>> G4PreCompoundInuclCollider::inelasticInteractionPossible" << G4endl;
-    G4cout << " VCOL: " << VCOL << " ekin: " << ekin << " inelastic possible: " << possible << G4endl;
+  }
-  return possible;
+}
-G4InteractionCase G4PreCompoundInuclCollider::bulletTargetSetter(G4InuclParticle* bullet,
-                                                      G4InuclParticle* target) const {
-  if (verboseLevel > 3) {
-    G4cout << " >>> G4PreCompoundInuclCollider::bulletTargetSetter" << G4endl;
+  }
-  G4InteractionCase interCase;
-  if (G4InuclNuclei* nuclei_target = dynamic_cast<G4InuclNuclei*>(target)) {
-    if (G4InuclNuclei* nuclei_bullet = dynamic_cast<G4InuclNuclei*>(bullet)) { // A + A
-      interCase.setInterCase(2);
-      if (nuclei_target->getA() >= nuclei_bullet->getA()) {
-        interCase.setBulletTarget(bullet, target);
-      } else {
-        interCase.setBulletTarget(target, bullet);
-      };
-    } else {
-      interCase.setInterCase(1);
-      interCase.setBulletTarget(bullet, target);
-    };
-  } else {
-    G4InuclNuclei* nuclei_bullet = dynamic_cast<G4InuclNuclei*>(bullet);
-    if (nuclei_bullet) {
-      G4InuclElementaryParticle* part =
-        dynamic_cast<G4InuclElementaryParticle*>(target);
-      if (part) {
-        interCase.setInterCase(1);
-        interCase.setBulletTarget(target, bullet);
-      };
-    };
-  };
-  return interCase;
+}
-G4bool G4PreCompoundInuclCollider::explosion(G4InuclNuclei* target) const {
-  if (verboseLevel > 3) {
-    G4cout << " >>> G4PreCompoundInuclCollider::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();
-  G4bool explo = true;
-  if (a > a_cut) {
-    explo = false;
-  } else {
-    if (eexs < be_cut * bindingEnergy(a, z)) explo = false;
-  };
-  return explo;
+}

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

-              r819
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4RegionModel.cc,v 1.16 2010/03/19 05:03:23 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100319  M. Kelsey -- Eliminate unnecessary use of std::pow()
 #include "G4RegionModel.hh"
 #include "G4HadronicException.hh"
+#include "G4InuclSpecialFunctions.hh"
+using namespace G4InuclSpecialFunctions;
 const G4double G4RegionModel::radius0 = 1.0E-15;
 …
+{
   //count the radiuses, densities and fermi momenta with A and Z
+  G4double oneThird = 1.0/3.0;
+  G4double r = radius0*std::pow(G4double(A), G4double(oneThird));
+  G4double r = radius0*G4cbrt(A);
   if(numberOfLayers==1){
     radius.push_back(r);
+    G4double rho = G4double(A) / (4.0/3.0*pi*std::pow(r,G4double(3)));
+    G4double vol = 4.0/3.0 * pi * r*r*r;
+    G4double rho = G4double(A) / vol;
     density.push_back(rho);
     G4double protonMass = G4Proton::Proton()->GetPDGMass();
     G4double neutronMass = G4Neutron::Neutron()->GetPDGMass();
     G4double protonDensity = G4double(Z) / (4.0/3.0*pi*std::pow(r,G4double(3)));
     G4double neutronDensity = G4double(A-Z) / (4.0/3.0*pi*std::pow(r,G4double(3)));
+    G4double protonDensity = G4double(Z) / vol;
+    G4double neutronDensity = G4double(A-Z) / vol;
     protonFermiEnergy.push_back(GetFermiEnergy(protonDensity, protonMass));
 …
 G4double G4RegionModel::GetFermiMomentum(G4double aDensity,
                                          G4double aMass){
   return std::sqrt(2*aMass*GetFermiEnergy(aDensity, aMass));
+}
 G4double G4RegionModel::GetFermiEnergy(G4double aDensity,
                                          G4double aMass){
+G4double twoThirds = 2.0/3.0;
+    return (std::pow(hbar_Planck,2)/(2.0*aMass)*std::pow((3.0*pi2*aDensity),twoThirds));
+  G4double densFactor = G4cbrt(3.0*pi2*aDensity);               // 2/3 power
+  densFactor *= densFactor;
+  return hbar_Planck*hbar_Planck/(2.0*aMass) * densFactor;
+}

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

-              r819
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4WatcherGun.cc,v 1.13 2010/04/08 15:48:00 mkelsey Exp $
+// GEANT4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100407  M. Kelsey -- Replace std::vector<>::resize(0) with ::clear(),
+//              and create vectors pre-sized to maximum needed.
 //#define PB
 #include "G4WatcherGun.hh"
+#include "G4ios.hh"
 G4WatcherGun::G4WatcherGun()
   : verboseLevel(2) {
+  : verboseLevel(0) {
   if (verboseLevel > 3) {
 …
+  }
   std::vector<G4double> as;
   std::vector<G4double> cs;
   std::vector<G4double> errs;
+  std::vector<G4double> as(27);         // Reserve maximum number of entries
+  std::vector<G4double> cs(27);
+  std::vector<G4double> errs(27);
   // specific stuff to monitor the difference with fortran
 …
   // Z = 1
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(1.0);
   cs.push_back(7645.0);
 …
   // Z = 1
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(2.0);
   cs.push_back(658.7);
 …
   // Z = -1
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(0.0);
   cs.push_back(198.3);
 …
   // Z = 2
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(3.0);
   cs.push_back(28.2);
 …
   // Z = 22
   // watchers for pb208 + 1 GeV p
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(47.0);
   cs.push_back(0.2);
 …
   // Z = 23
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(49.0);
   cs.push_back(0.182);
 …
   // Z = 24
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(51.0);
   cs.push_back(0.215);
 …
   // Z = 25
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(53.0);
   cs.push_back(0.181);
 …
   // Z = 26
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(55.0);
   cs.push_back(0.129);
 …
   // Z = 27
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(57.0);
   cs.push_back(0.0866);
 …
   // Z = 28
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(59.0);
   cs.push_back(0.035);
 …
   // Z = 29
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(61.0);
   cs.push_back(0.026);
 …
   // Z = 30
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(64.0);
   cs.push_back(0.149);
 …
   // Z = 31
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(66.0);
   cs.push_back(0.082);
 …
   // Z = 32
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(68.0);
   cs.push_back(0.038);
 …
   // Z = 33
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(71.0);
   cs.push_back(0.176);
 …
   // Z = 34
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(73.0);
   cs.push_back(0.102);
 …
   // Z = 35
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(75.0);
   cs.push_back(0.048);
 …
   // spallation part
   // Z = 61
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(132.0);
   cs.push_back(0.002);
 …
   // Z = 69
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(152.0);
   cs.push_back(0.045);
 …
   // Z = 73
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(160.0);
   cs.push_back(0.003);
 …
   // Z = 77
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(170.0);
   cs.push_back(0.003);
 …
   // Z = 81
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(184.0);
   cs.push_back(0.058);
 …
   // Z = 82
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(187.0);
   cs.push_back(0.01);
 …
   // watchers for Au197 + P, 800 MeV
   // Z = 80
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(196.0);
   cs.push_back(1.54);
 …
   // Z = 77
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(171.0);
   cs.push_back(0.07);
 …
   // Z = 73
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(162.0);
   cs.push_back(0.31);
 …
   // Z = 61
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(133.0);
   cs.push_back(0.01);
 …
   // Z = 79
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(178.0);
   cs.push_back(0.12);
 …
   // Z = 78
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(178.0);
   cs.push_back(3.04);
 …
   // Z = 72
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(176.0);
   cs.push_back(0.13);
 …
   // Z = 66
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(157.0);
   cs.push_back(0.14);
 …
   // Z = 65
   as.resize(0);
   cs.resize(0);
   errs.resize(0);
+  as.clear();
+  cs.clear();
+  errs.clear();
   as.push_back(153.0);
   cs.push_back(0.21);

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

-              r819
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: bindingEnergyAsymptotic.cc,v 1.11 2010/04/08 15:48:00 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100202  M. Kelsey -- Eliminate unnecessary use of std::pow()
 #include "G4InuclSpecialFunctions.hh"
 …
   // using smooth liquid high energy formula
   G4double X = (1.0 - 2.0 * Z / A) * (1.0 - 2.0 * Z / A);
   G4double X1 = std::pow(A, 0.3333333);
+  G4double X1 = G4cbrt(A);
   G4double X2 = X1 * X1;
   G4double X3 = 1.0 / X1;
 …
 .779 * Z * (Z - 1.0) * X3 *
     (1.0 - 1.5849 * X4 + 1.2273 / A + 1.5772 * X4 * X4) +
 .4328 * std::pow(Z, 1.333333) * X3 *
+.4328 * G4cbrt(Z*Z*Z*Z) * X3 *
     (1.0 - 0.57811 * X3 - 0.14518 * X4 + 0.496 / A);

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

-              r819
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: bindingEnergyKummel.cc,v 1.12 2010/03/19 05:03:23 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100202  M. Kelsey -- Eliminate unnecessary use of std::pow()
 #include "G4InuclSpecialFunctions.hh"
+using namespace G4InuclSpecialFunctions;
 G4double G4InuclSpecialFunctions::bindingEnergyKummel(G4double A,
 …
   G4double TDEF = 0.0;
   G4double X = Z * Z / A;
   G4double X1 = std::pow(A, 0.3333333);
+  G4double X1 = G4cbrt(A);
   G4double X2 = X1 * X1;
 …
       // G4double ALM = AL0 * (X7 + 0.143 * AL0 * X5 / X3);
       TDEF = -X4 * (X6 + 1.0) + DNZ + 0.038 * X2 * std::pow(AL0 * X7, 3.0) * X5;
+      TDEF = -X4 * (X6 + 1.0) + DNZ + 0.038 * X2 * (AL0*X7 * AL0*X7 * AL0*X7) * X5;
     };
   };

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

-              r819
+              r1315
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: paraMaker.cc,v 1.17 2010/06/01 17:20:31 mkelsey Exp $
+// Geant4 tag: $Name: geant4-09-04-beta-cand-01 $
 //
+// 20100412  M. Kelsey -- Modify paraMaker[Truncated] to take buffer as argument
+// 20100517  M. Kelsey -- BUG FIX:  Must check for array boundary "if (Z>=70)"
+// 20100517  M. Kelsey -- Use G4CascadeInterpolator, which handles boundaries
+// 20100601  M. Kelsey -- Bug fix from Gunter Folger; resize(6,0.), not clear()
 #include "G4InuclSpecialFunctions.hh"
+#include "G4CascadeInterpolator.hh"
+std::pair<std::vector<G4double>, std::vector<G4double> > G4InuclSpecialFunctions::paraMaker(G4double Z) {
+  G4int verboseLevel = 1;
+void
+G4InuclSpecialFunctions::paraMaker(G4double Z,
+           std::pair<std::vector<G4double>, std::vector<G4double> >& parms) {
+  G4int verboseLevel(0);
   if (verboseLevel > 3) {
 …
   // coulumb barier, c.s. etc needed for evaporators
+  const G4double Z1[5] = {10.0, 20.0, 30.0, 50.0, 70.0};
+  const G4double AP[5] = {0.42, 0.58, 0.68, 0.77, 0.80};
+  const G4double CP[5] = {0.50, 0.28, 0.20, 0.15, 0.10};
+  const G4double AA[5] = {0.68, 0.82, 0.91, 0.97, 0.98};
+  const G4double CA[5] = {0.10, 0.10, 0.10, 0.08, 0.06};
+  std::vector<G4double> AK(6);
+  std::vector<G4double> CPA(6);
+  static const G4double Z1[5] = {10.0, 20.0, 30.0, 50.0, 70.0};
+  static const G4double AP[5] = {0.42, 0.58, 0.68, 0.77, 0.80};
+  static const G4double CP[5] = {0.50, 0.28, 0.20, 0.15, 0.10};
+  static const G4double AA[5] = {0.68, 0.82, 0.91, 0.97, 0.98};
+  static const G4double CA[5] = {0.10, 0.10, 0.10, 0.08, 0.06};
+  // Set up input buffer for results
+  std::vector<G4double>& AK = parms.first;
+  AK.resize(6,0.);
+  std::vector<G4double>& CPA = parms.second;
+  CPA.resize(6,0.);
   AK[0] = 0.0;
   CPA[0] = 0.0;
-  G4double AK2 = 0.0;
-  G4double CP2 = 0.0;
-  G4double AK6 = 0.0;
-  G4double CP6 = 0.0;
+  if (Z < 10.0) {
+    AK2=0.42;
+    CP2=0.5;
+    AK6=0.68;
+    CP6=0.1;
+  static G4CascadeInterpolator<5> interp(Z1, false);    // Do not extrapolate
+  AK[1]  = interp.interpolate(Z, AP);
+  AK[5]  = interp.interpolate(Z, AA);
+  CPA[1] = interp.interpolate(Z, CP);
+  CPA[5] = interp.interpolate(Z, CA);
+  AK[2] = AK[1] + 0.06;
+  AK[3] = AK[1] + 0.12;
+  AK[4] = AK[5] - 0.06;
+  } else if(Z > 70.0) {
+    AK6=0.98;  // normal
+    CP6=0.06;
+    AK2=0.8;
+    CP2=0.1;
+    // AK6=1.1; // modified
+    // CP6=0.0;
+  CPA[2] = CPA[1] * 0.5;
+  CPA[3] = CPA[1] / 3.0;
+  CPA[4] = 4.0 * CPA[5] / 3.0;
+  } else {
+    for (G4int i = 1; i < 5; i++) {
+      if (Z <= Z1[i]) {
+        G4double Z2 = 1.0 / (Z1[i] - Z1[i - 1]);
+        AK2 = ((AP[i] - AP[i - 1]) * Z + AP[i - 1] * Z1[i] - AP[i] * Z1[i - 1]) * Z2;
+        CP2 = ((CP[i] - CP[i - 1]) * Z + CP[i - 1] * Z1[i] - CP[i] * Z1[i - 1]) * Z2;
+        AK6 = ((AA[i] - AA[i - 1]) * Z + AA[i - 1] * Z1[i] - AA[i] * Z1[i - 1]) * Z2;
+        CP6 = ((CA[i] - CA[i - 1]) * Z + CA[i - 1] * Z1[i] - CA[i] * Z1[i - 1]) * Z2;
+        break;
+      };
+    };
+  };
+  AK[1] = AK2;
+  AK[5] = AK6;
+  CPA[1] = CP2;
+  CPA[5] = CP6;
+  AK[2] = AK2 + 0.06;
+  CPA[2] = CP2 * 0.5;
+  AK[3] = AK2 + 0.12;
+  CPA[3] = CP2 / 3.0;
+  AK[4] = AK6 - 0.06;
+  CPA[4] = 4.0 * CP6 / 3.0;
+  return std::pair<std::vector<G4double>, std::vector<G4double> >(AK, CPA);
+  return;       // Buffer filled
+}
+std::pair<G4double, G4double> G4InuclSpecialFunctions::paraMakerTruncated(G4double Z) {
+  G4int verboseLevel = 1;
+void
+G4InuclSpecialFunctions::paraMakerTruncated(G4double Z,
+                                    std::pair<G4double,G4double>& parms) {
+  G4int verboseLevel(0);
   if (verboseLevel > 3) {
 …
   // truncated version of the previous one
+  const G4double Z1[5] = {10.0, 20.0, 30.0, 50.0, 70.0};
+  const G4double AP[5] = {0.42, 0.58, 0.68, 0.77, 0.8};
+  const G4double CP[5] = {0.5, 0.28, 0.2, 0.15, 0.1};
+  G4double AK2=0.;
+  G4double CP2=0.;
+  static const G4double Z1[5] = {10.0, 20.0, 30.0, 50.0, 70.0};
+  static const G4double AP[5] = {0.42, 0.58, 0.68, 0.77, 0.8};
+  static const G4double CP[5] = {0.5, 0.28, 0.2, 0.15, 0.1};
   if (Z < 10.0) {
     AK2=0.42;
     CP2=0.5;
+  // Set up buffers for output
+  G4double& AK2=parms.first;
+  G4double& CP2=parms.second;
   } else if (Z > 70.0) {
     AK2=0.8;
     CP2=0.1;
+  static G4CascadeInterpolator<5> interp(Z1, false);            // Do not extrapolate
+  AK2 = interp.interpolate(Z, AP);
+  CP2 = interp.interpolate(Z, CP);
+  } else {
+    for (G4int i = 1; i < 5; i++) {
+      if (Z < Z1[i]) {
+        G4double Z2 = 1.0 / (Z1[i] - Z1[i - 1]);
+        AK2 = ((AP[i] - AP[i - 1]) * Z + AP[i - 1] * Z1[i] - AP[i] * Z1[i - 1]) * Z2;
+        CP2 = ((CP[i] - CP[i - 1]) * Z + CP[i - 1] * Z1[i] - CP[i] * Z1[i - 1]) * Z2;
+        break;
+      };
+    };
+  };
+  return std::pair<G4double, G4double>(AK2, CP2);
+  return;       // Buffer filled
+}

Context Navigation

Legend:

Download in other formats: