Changeset 1347 for trunk/source/processes/hadronic

trunk/source/processes/hadronic/cross_sections/History

-              r1340
+              r1347
      ---------------------------------------------------------------
+October 2010 Vladimir Ivanchenko (hadr-cross-V09-03-12)
+December 2010 Dennis Wright (hadr-cross-V09-03-21)
+-----------------------------------------------------
+- G4ElectroNuclearCrossSection::GetEquivalentPhotonEnergy() : remove
+  initialization of array Y[]. This forced expensive re-calculation
+  at each call.
+November 2010 Vladimir Ivanchenko (hadr-cross-V09-03-20)
+----------------------------------------------------------
+- G4BGGPionElasticXS, G4BGGNucleonElasticXS,G4BGGNucleonInelasticXS
+        fixed low-energy (E < 20 MeV) models
+- G4TripathiLightCrossSection - J.M.Quesada fix for threshold shape
+November 2010 Vladimir Ivanchenko (hadr-cross-V09-03-19)
+----------------------------------------------------------
+- added G4CrossSectionInelastic and G4CrossSectionElastic - wrappers
+        for components
+November 2010 Gunter Folger       (hadr-cross-V09-03-18)
+- replace leftover calls to GetIsoZACrossSection by  GetZandACrossSection, and
+   IsZAApplicable by IsIsoApplicable.
+November 2010 Vladimir Ivanchenko (hadr-cross-V09-03-17)
+----------------------------------------------------------
+- G4NeutronCaptureXS, G4NeutronElasticXS, G4NeutronInelasticXS - do
+  not use G4Element, only G4NistManager
+- G4ComponentAntiNuclNuclearXS - new class (A.Galoyan)
+November 2010 Gunter Folger (hadr-cross-V09-03-16)
+------------------------------------------------------
+- Fix bug from Integer A&Z transition:
+  - G4VCrossSectionDataSet.cc:
+  make new methods (IsIsoApplicable, GetZandACrossSection) forward to old
+  methods (IsZAApplicable, GetIsoZACrossSection); old methods print a obsolete
+   warning once.
+  - G4CrossSectionDataStore.cc: use new methods only.
+November 2010  Gunter Folger (hadr-cross-V09-03-15)
+------------------------------------------------------
+- Add new class G4CrossSectionPairGG to extend a given cross-section with
+   a scaled G4GlauberGribovCrossSection. Scaling result in smooth transition.
+November 2010  Dennis Wright (hadr-cross-V09-03-14)
+------------------------------------------------------
+Back out memory leak fixes of G4NeutronElasticXS.cc and G4NeutronInelasticXS.cc
+Not a memory leak after all.
+November 2010  Dennis Wright (hadr-cross-V09-03-13)
+------------------------------------------------------
+NOTE: this tag deals exclusively with fixes of CoVerity-identified
+bugs
+- G4HadronCrossSections.hh : fix uninitialized variable prevElement in ctor
+- Initialize arrays theGlauberFac and theCoulombFac in ctors of
+  G4BGGNucleonElasticXS.cc, G4BGGNucleonInelasticXS.cc, G4BGGPionElasticXS.cc,
+  G4BGGPionInelasticXS.cc
+- Initialize all elements of array Y[nE] to 0.0 in
+  G4ElectroNuclearCrossSection::GetEquivalentPhotonEnergy()
+- Initialize fTotalXsc, fElasticXsc, fInelasticXsc, fProductionXsc,
+  fDiffractionXsc, fHadronNucleonXsc to 0.0 in ctors of
+  G4GlauberGribovCrossSection.cc, G4GGNuclNuclCrossSection.cc
+- Initialize fTotalXsc, fElasticXsc, fInelasticXsc, fHadronNucleonXsc to 0.0
+  in ctor of G4HadronNucleonXsc,
+- fix memory leak in G4NeutronElasticXS:Initialise and
+  G4NeutronInelasticXS:Initialise :
+   const G4Element* Elem =
+     G4Element* G4NistManager::FindOrBuildElement(G4int Z, G4bool isotopes)
+  Elem goes out of scope, so delete it
+- Initialize fTotalXsc, fElasticXsc to 0.0 in ctors of
+  G4NucleonNuclearCrossSection.cc, G4PiNuclearCrossSection.cc
+- Initialize array theFac in ctors of
+  G4UElasticCrossSection.cc, G4UInelasticCrossSection.cc
+November 2010 Vladimir Ivanchenko (hadr-cross-V09-03-12)
+-----------------------------------------------------------
 - G4VComponentCrossSection - use G4ParticleDefinition and kinetic
    energy instead of G4DynamicParticle
+- G4EMDissociationCrossSection - is now applicable for Hydrogen but
+   cross section for Hydrogen is zero
 October 2010 Gunter Folger (hadr-cross-V09-03-11)
+----------------------------------------------------
 - add missing inline for GetCrossSection in G4BGGPionElasticXS.hh
 October 2010 Dennis Wright (hadr-cross-V09-03-10)

trunk/source/processes/hadronic/cross_sections/src/G4EMDissociationCrossSection.cc

-              r1340
+              r1347
 // Beta release
 //
 // 30. May 2005, J.P. Wellisch removed a compilation warning on gcc 3.4 for
+// 30 May 2005, J.P. Wellisch removed a compilation warning on gcc 3.4 for
 //               geant4 7.1.
+// 09 November 2010, V.Ivanchenko make class applicable for Hydrogen but
+//                   set cross section for Hydrogen to zero
 //
 // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 G4bool
 G4EMDissociationCrossSection::IsIsoApplicable(const G4DynamicParticle* theDynamicParticle,
                                               G4int /*ZZ*/, G4int AA)
+                                              G4int /*ZZ*/, G4int/* AA*/)
+{
 //
 …
 //
   if (G4ParticleTable::GetParticleTable()->GetIonTable()->
     IsIon(theDynamicParticle->GetDefinition()) && AA > 1)
+      IsIon(theDynamicParticle->GetDefinition()) /*&& AA > 1*/)
     return true;
   else
 …
   G4int nIso = theElement->GetNumberOfIsotopes();
   G4double crossSection = 0;
+  // VI protection for Hydrogen
+  if(theElement->GetZ() < 1.5) { return crossSection; }
   if (nIso) {
 …
                                                    G4int ZZ, G4int AA, G4double /*temperature*/)
+{
+  // VI protection for Hydrogen
+  if(ZZ <= 1) { return 0.0; }
 //
 // Get relevant information about the projectile and target (A, Z) and

trunk/source/processes/hadronic/cross_sections/src/G4GGNuclNuclCrossSection.cc

-              r1340
+              r1347
 // ********************************************************************
 //
-//
 // 24.11.08 V. Grichine - first implementation
 //
 …
-///////////////////////////////////////////////////////////////////////////////
-//
-//
 G4GGNuclNuclCrossSection::G4GGNuclNuclCrossSection()
 : fUpperLimit( 100000 * GeV ),
   fLowerLimit( 0.1 * MeV ),
+  fRadiusConst( 1.08*fermi )  // 1.1, 1.3 ?
+  fRadiusConst( 1.08*fermi ),  // 1.1, 1.3 ?
+  fTotalXsc(0.0), fElasticXsc(0.0), fInelasticXsc(0.0), fProductionXsc(0.0),
+  fDiffractionXsc(0.0), fHadronNucleonXsc(0.0)
+{
   theProton   = G4Proton::Proton();
 …
+}
-///////////////////////////////////////////////////////////////////////////////
-//
-//
 G4GGNuclNuclCrossSection::~G4GGNuclNuclCrossSection()
 {}
-///////////////////////////////////////////////////////////////////////////////
-//
-//

trunk/source/processes/hadronic/cross_sections/src/G4GlauberGribovCrossSection.cc

-              r1340
+              r1347
 #include "G4ParticleDefinition.hh"
+//////////////////////////////////////////////////////////////////////////////////////
+//
+///////////////////////////////////////////////////////////////////////////////
 //
 …
+////////////////////////////////////////////////////////////////////////////////
+//
+//////////////////////////////////////////////////////////////////////////////
 //
 …
 : fUpperLimit( 100000 * GeV ),
   fLowerLimit( 3 * GeV ),
+  fRadiusConst( 1.08*fermi )  // 1.1, 1.3 ?
+  fRadiusConst( 1.08*fermi ),  // 1.1, 1.3 ?
+  fTotalXsc(0.0), fElasticXsc(0.0), fInelasticXsc(0.0), fProductionXsc(0.0),
+  fDiffractionXsc(0.0), fHadronNucleonXsc(0.0)
+{
   theGamma    = G4Gamma::Gamma();

trunk/source/processes/hadronic/cross_sections/src/G4HadronNucleonXsc.cc

-              r1340
+              r1347
 // ********************************************************************
 //
-//
 // 14.03.07 V. Grichine - first implementation
 //
 …
 G4HadronNucleonXsc::G4HadronNucleonXsc()
 : fUpperLimit( 10000 * GeV ),
+  fLowerLimit( 0.03 * MeV )
+  fLowerLimit( 0.03 * MeV ),
+  fTotalXsc(0.0), fElasticXsc(0.0), fInelasticXsc(0.0), fHadronNucleonXsc(0.0)
+{
   theGamma    = G4Gamma::Gamma();
 …
+}
-///////////////////////////////////////////////////////////////////////////////////////
-//
-//
 G4HadronNucleonXsc::~G4HadronNucleonXsc()
 {}
-////////////////////////////////////////////////////////////////////////////////////////
-//
-//

trunk/source/processes/hadronic/cross_sections/src/G4IonsKoxCrossSection.cc

r1340	r1347
107	107	G4int ZZ = G4lrint(anElement->GetZ());
108	108	G4int AA = G4lrint(anElement->GetN());
109		xsection = Get~~IsoZ~~ACrossSection(aParticle, ZZ, AA, temperature);
	109	xsection = GetZandACrossSection(aParticle, ZZ, AA, temperature);
110	110	}
111	111

trunk/source/processes/hadronic/cross_sections/src/G4IonsShenCrossSection.cc

-              r1340
+              r1347
       ZZ = (*isoVector)[i]->GetZ();
       AA = (*isoVector)[i]->GetN();
       sig = GetIsoZACrossSection(aParticle, ZZ, AA, temperature);
+      sig = GetZandACrossSection(aParticle, ZZ, AA, temperature);
       xsection += sig*abundVector[i];
+    }
 …
     G4int ZZ = G4lrint(anElement->GetZ());
     G4int AA = G4lrint(anElement->GetN());
     xsection = GetIsoZACrossSection(aParticle, ZZ, AA, temperature);
+    xsection = GetZandACrossSection(aParticle, ZZ, AA, temperature);
+  }

trunk/source/processes/hadronic/cross_sections/src/G4IonsSihverCrossSection.cc

-              r1340
+              r1347
       ZZ = (*isoVector)[i]->GetZ();
       AA = (*isoVector)[i]->GetN();
       sig = GetIsoZACrossSection(aParticle, ZZ, AA, temperature);
+      sig = GetZandACrossSection(aParticle, ZZ, AA, temperature);
       xsection += sig*abundVector[i];
+    }
 …
     G4int ZZ = G4lrint(anElement->GetZ());
     G4int AA = G4lrint(anElement->GetN());
     xsection = GetIsoZACrossSection(aParticle, ZZ, AA, temperature);
+    xsection = GetZandACrossSection(aParticle, ZZ, AA, temperature);
+  }

trunk/source/processes/hadronic/cross_sections/src/G4NucleonNuclearCrossSection.cc

-              r1340
+              r1347
 ///////////////////////////////////////////////////////////////////////////////
-//
-//
 G4NucleonNuclearCrossSection::G4NucleonNuclearCrossSection()
+ :fTotalXsc(0.0), fElasticXsc(0.0)
+{
   theNeutron = G4Neutron::Neutron();

trunk/source/processes/hadronic/cross_sections/src/G4PiNuclearCrossSection.cc

-              r1340
+              r1347
 , 1980, 1950, 1978, 1830, 1780};
+ G4PiNuclearCrossSection::
+ G4PiNuclearCrossSection()
+G4PiNuclearCrossSection::G4PiNuclearCrossSection()
+  : fTotalXsc(0.0), fElasticXsc(0.0)
+ {
    thePimData.push_back(new G4PiData(he_t,   he_in,  e1, 38));

trunk/source/processes/hadronic/cross_sections/src/G4TripathiCrossSection.cc

r1340	r1347
169	169	G4int ZZ = G4lrint(anEle->GetZ());
170	170	G4int AA = G4lrint(anEle->GetN());
171		xsection = Get~~IsoZ~~ACrossSection(aPart, ZZ, AA, temperature);
	171	xsection = GetZandACrossSection(aPart, ZZ, AA, temperature);
172	172	}
173	173

trunk/source/processes/hadronic/cross_sections/src/G4TripathiLightCrossSection.cc

-              r1340
+              r1347
 // 15 March 2004, P R Truscott, QinetiQ Ltd, UK
 // Beta release
+//
+// J. M. Quesada 24 November 2010 bug fixed in X_m
+//(according to eq. 14 in  R.K. Tripathi et al. Nucl. Instr. and Meth. in Phys. Res. B 155 (1999) 349-356)
 //
 // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
+  }
   G4double S_L = 1.2 + 1.6*(1.0-std::exp(-E/15.0));
+  G4double X_m = 1.0 - X1*std::exp(-E/X1*S_L);
+//JMQ 241110 bug fixed
+//  G4double X_m = 1.0 - X1*std::exp(-E/X1*S_L);
+  G4double X_m = 1.0 - X1*std::exp(-E/(X1*S_L));
 //
 //
 …
     G4int ZZ = G4lrint(theTarget->GetZ());
     G4int AA = G4lrint(theTarget->GetN());
     xsection = GetIsoZACrossSection(theProjectile, ZZ, AA, theTemperature);
+    xsection = GetZandACrossSection(theProjectile, ZZ, AA, theTemperature);
+  }

trunk/source/processes/hadronic/cross_sections/src/G4UElasticCrossSection.cc

-              r1340
+              r1347
 // 06.03.07 V.Ivanchenko - add Initialise function
 //
-//
 #include "G4UElasticCrossSection.hh"
 …
 #include "G4NistManager.hh"
-//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 G4UElasticCrossSection::G4UElasticCrossSection(const G4ParticleDefinition*)
 …
   hasGlauber = false;
   thEnergy   = 90.*GeV;
+  for (G4int i = 0; i < 93; i++) theFac[i] = 0.0;
   fGlauber   = new G4GlauberGribovCrossSection();
   fGheisha   = G4HadronCrossSections::Instance();
 …
+}
-//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 G4UElasticCrossSection::~G4UElasticCrossSection()
 …
                                               const G4Element*  elm)
+{
   return IsZAApplicable(dp, elm->GetZ(), elm->GetN());
+  return IsIsoApplicable(dp, G4lrint(elm->GetZ()), G4lrint(elm->GetN()));
+}
 …
   G4int A = G4lrint(nist->GetAtomicMassAmu(2));
   if(fGlauber->IsZAApplicable(&dp, 2.0, A)) {
+  if(fGlauber->IsIsoApplicable(&dp, 2, A)) {
     hasGlauber = true;

trunk/source/processes/hadronic/cross_sections/src/G4UInelasticCrossSection.cc

-              r1340
+              r1347
 // 06.03.07 V.Ivanchenko - add Initialise function
 //
-//
 …
 #include "G4NistManager.hh"
-//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 G4UInelasticCrossSection::G4UInelasticCrossSection(const G4ParticleDefinition*)
 …
   hasGlauber = false;
   thEnergy   = 90.*GeV;
+  for (G4int i = 0; i < 93; i++) theFac[i] = 0.0;
   fGlauber   = new G4GlauberGribovCrossSection();
   fGheisha   = G4HadronCrossSections::Instance();
 …
+}
-//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 G4UInelasticCrossSection::~G4UInelasticCrossSection()
 …
                                               const G4Element*  elm)
+{
   return IsZAApplicable(dp, elm->GetZ(), elm->GetN());
+  return IsIsoApplicable(dp, G4lrint(elm->GetZ()), G4lrint(elm->GetN()));
+}
 …
   G4int Z = G4lrint(elm->GetZ());
   G4int N = G4lrint(elm->GetN());
   return GetIsoZACrossSection(dp, Z, N, temp);
+  return GetZandACrossSection(dp, Z, N, temp);
+}
 …
       cross = theFac[Z]*fGlauber->GetInelasticGlauberGribov(dp, Z, A);
     } else {
       cross = fNucleon->GetIsoZACrossSection(dp, Z, A);
+      cross = fNucleon->GetZandACrossSection(dp, Z, A);
+    }
 …
       // proton and neutron
       if(fNucleon) {
         csdn = fNucleon->GetIsoZACrossSection(&dp, iz, A);
+        csdn = fNucleon->GetZandACrossSection(&dp, iz, A);
         // pions

trunk/source/processes/hadronic/management/History

-              r1340
+              r1347
      ---------------------------------------------------------------
+November 2010  Dennis Wright  (hadr-man-V09-03-06)
+-----------------------------------------------------
+- G4HadronicProcess.cc : in PostStepDoIt, check cross section value
+  before calling ApplyYourself.  If less than or equal to zero, return
+  track unchanged.
+November 2010  Dennis Wright  (hadr-man-V09-03-05)
+-----------------------------------------------------
+- G4EnergyRangeManager: initialize theHadronicInteractionCounter
+  and ptr theHadronicInteraction as per CoVerity
 August 2010  Vladimir Ivanchenko (hadr-man-V09-03-04)
 ------------------------------------------------
+--------------------------------------------------------
 - G4HadronicProcess - use const GetParticleDefinition method of
                       G4DynamicParticle

trunk/source/processes/hadronic/models/abla/History

-              r1340
+              r1347
      Geant4 - an Object-Oriented Toolkit for Physics Simulation
      ==========================================================
 $Id: History,v 1.1 2008/02/27 18:31:10 miheikki Exp $
+$Id: History,v 1.2 2010/11/11 02:13:12 dennis Exp $
 ---------------------------------------------------------------------
 …
    ---------------------------------------------------------------
+November 2010  Dennis Wright
+-------------------------------
+- the code in this directory is not used as of this date
 February 2008 - Pekka Kaitaniemi
 -----------------------------------

trunk/source/processes/hadronic/models/abrasion/History

-              r1340
+              r1347
      ---------------------------------------------------------------
+-Nov-2010, Dennis Wright                  (had-abrasion-V09-03-01)
+--------------------------------------------------------------------
+- G4WilsonAbrasionModel.cc : initialize r0sq in ctor (CoVerity)
+- G4NuclearAbrasionGeometry::GetExcitationEnergyOfTarget :
+   fix memory leak by deleting revAbrasionGeometry  (CoVerity)
 -Sep-2010, Gunter Folger                  (had-abrasion-V09-03-00)
+--------------------------------------------------------------------
 - G4WilsonAbrasionModel.cc: remove several unused #includes

trunk/source/processes/hadronic/models/abrasion/src/G4NuclearAbrasionGeometry.cc

-              r819
+              r1347
   return Es;
+}
+//////////////////////////////////////////////////////////////////////////////////////
+//
 G4double G4NuclearAbrasionGeometry::GetExcitationEnergyOfTarget ()
+{
+//
+//
+// This member function declares a new G4NuclearAbrasionGeometry object but with the
+// projectile and target exchanged to determine the values for F and P.  Determination
+// of the excess surface area and excitation energy is as above.
+//
+  G4NuclearAbrasionGeometry *revAbrasionGeometry =
+  // This member function declares a new G4NuclearAbrasionGeometry object
+  // but with the projectile and target exchanged to determine the values
+  // for F and P.  Determination of the excess surface area and excitation
+  // energy is as above.
+  G4NuclearAbrasionGeometry* revAbrasionGeometry =
     new G4NuclearAbrasionGeometry(AT, AP, r);
   G4double F1 = revAbrasionGeometry->F();
 …
   Es = 0.95 * MeV * 4.0 * pi * rT*rT/fermi/fermi *
        (1.0+P1-std::pow(1.0-F1,2.0/3.0));
 //  if (rP < rT && r < rT-rP)
+  if ((r-rT)/rP < rth)
+  {
+  if ((r-rT)/rP < rth) {
     G4double omega = 0.0;
     if      (AT < 12.0)  omega = 1500.0;
 …
   else if (Es > B * AT)
     Es = B * AT;
+  delete revAbrasionGeometry;
   return Es;
+}
-////////////////////////////////////////////////////////////////////////////////
-//

trunk/source/processes/hadronic/models/abrasion/src/G4WilsonAbrasionModel.cc

-              r1340
+              r1347
 // ********************************************************************
 //
 // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 //
 // MODULE:              G4WilsonAbrasionModel.cc
 …
 // Contract:            17191/03/NL/LvH
 //
 // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 //
 // CHANGE HISTORY
 …
 // Additional clauses have been included in
 //    G4WilsonAbrasionModel::GetNucleonInducedExcitation
 // Previously it was possible to get sqrt of negative number as Wilson algorithm
 // not properly defined if either:
+// Previously it was possible to get sqrt of negative number as Wilson
+// algorithm not properly defined if either:
 //    rT > rP && rsq < rTsq - rPsq) or (rP > rT && rsq < rPsq - rTsq)
 //
 // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 ////////////////////////////////////////////////////////////////////////////////
+//
+// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+///////////////////////////////////////////////////////////////////////////////
 #include "G4WilsonAbrasionModel.hh"
 #include "G4WilsonRadius.hh"
 …
 #include "G4IonTable.hh"
 #include "globals.hh"
+////////////////////////////////////////////////////////////////////////////////
+//
 G4WilsonAbrasionModel::G4WilsonAbrasionModel (G4bool useAblation1)
   :G4HadronicInteraction("G4WilsonAbrasion")
+{
+//
+//
+// Send message to stdout to advise that the G4Abrasion model is being used.
+//
+  // Send message to stdout to advise that the G4Abrasion model is being used.
   PrintWelcomeMessage();
+//
+//
+// Set the default verbose level to 0 - no output.
+//
+  // Set the default verbose level to 0 - no output.
   verboseLevel = 0;
   useAblation  = useAblation1;
+//
+//
+// No de-excitation handler has been supplied - define the default handler.
+//
+  // No de-excitation handler has been supplied - define the default handler.
   theExcitationHandler  = new G4ExcitationHandler;
   theExcitationHandlerx = new G4ExcitationHandler;
 …
     theExcitationHandlerx->SetMaxAandZForFermiBreakUp(12, 6);
+  }
+//
+//
+// Set the minimum and maximum range for the model (despite nomanclature, this
+// is in energy per nucleon number).
+//
+  // Set the minimum and maximum range for the model (despite nomanclature,
+  // this is in energy per nucleon number).
   SetMinEnergy(70.0*MeV);
   SetMaxEnergy(10.1*GeV);
   isBlocked = false;
+//
+//
+// npK, when mutiplied by the nuclear Fermi momentum, determines the range of
+// momentum over which the secondary nucleon momentum is sampled.
+//
   npK              = 5.0;
   B                = 10.0 * MeV;
   third            = 1.0 / 3.0;
   fradius          = 0.99;
   conserveEnergy   = false;
+  // npK, when mutiplied by the nuclear Fermi momentum, determines the range of
+  // momentum over which the secondary nucleon momentum is sampled.
+  r0sq = 0.0;
+  npK = 5.0;
+  B = 10.0 * MeV;
+  third = 1.0 / 3.0;
+  fradius = 0.99;
+  conserveEnergy = false;
   conserveMomentum = true;
+}
+////////////////////////////////////////////////////////////////////////////////
+//
 G4WilsonAbrasionModel::G4WilsonAbrasionModel (G4ExcitationHandler *aExcitationHandler)
+{

trunk/source/processes/hadronic/models/binary_cascade/History

-              r1340
+              r1347
      * Please list in reverse chronological order (last date on top)
      ---------------------------------------------------------------
+Nov 2010, G.Folger                    had-binary-V09-03-05
+- fix compilation errors and warnings in G4BinaryCascade.
+Nov 2010, G.Folger                    had-binary-V09-03-04
+- *** lower CaptureThreshold in G4GeneratorPrecompoundInterface.cc
+       from 80 to 10 MeV.
+- G4BinaryCascade: disable G4Exception in StepParticlesOut() introduced in
+   previous tag. Need to investigate why this happens first.
+Nov 2010,  G.Folger                    had-binary-V09-03-03
+- Fix coverity warnings
+   - in Propagate(), mem leak for products
+   - in StepParticlesOut, check return code of GetSphereInter....
+   - Scatter1H1(0 always check secs
 Sep 2010, G.Folger                     had-binary-V09-03-02
 …
 . Shift of particle's formation times that the min. time=0.
+. Including of captured particles (Due to absend of the options there
+     were
+     a large energy-non-conservation).
+. Including of captured particles (Due to absence of the options there
+     were a large energy-non-conservation).
 . GetExcitationEnergy() - correction for the case when all nucleons are

trunk/source/processes/hadronic/models/binary_cascade/include/G4BinaryCascade.hh

-              r1228
+              r1347
   G4int GetTotalCharge(std::vector<G4KineticTrack *> & aV)
+  {
-G4cout<<"GetTotalCharge(std::vector<G4KineticTrack *> & aV)"<<G4endl; // Uzhi
     G4int result = 0;
     std::vector<G4KineticTrack *>::iterator i;
 …
+    {
        result += G4lrint((*i)->GetDefinition()->GetPDGCharge());
+G4cout<<(*i)->GetDefinition()->GetParticleName()<<" "<<(*i)->GetDefinition()->GetPDGCharge()<<G4endl; // Uzhi
+    }
+    return result;
+  }
+  G4int GetTotalBaryonCharge(std::vector<G4KineticTrack *> & aV)
+  {
+    G4int result = 0;
+    std::vector<G4KineticTrack *>::iterator i;
+    for(i = aV.begin(); i != aV.end(); ++i)
+    {
+       if ( (*i)->GetDefinition()->GetBaryonNumber() != 0 ){
+             result += G4lrint((*i)->GetDefinition()->GetPDGCharge());
+       }
+    }
     return result;

trunk/source/processes/hadronic/models/binary_cascade/src/G4BinaryCascade.cc

-              r1340
+              r1347
+{
   static G4int eventcounter=0;
+//   if ( eventcounter == 0 ) {
+//      SetEpReportLevel(3);   // report non conservation with model etc.
+//      G4double relativeLevel = 1*perCent;
+//      G4double absoluteLevel = 2*MeV;
+//      SetEnergyMomentumCheckLevels(relativeLevel,absoluteLevel);
+//   }
   //if(eventcounter == 100*(eventcounter/100) )
   eventcounter++;
 …
    G4cout << "G4BinaryCascade Propagate starting -------------------------------------------------------" <<G4endl;
 #endif
+   // *GF* FIXME ? in propagate mode this test is wrong! Could be in Apply....
+  if(nucleus->GetMassNumber() == 1) // 1H1 is special case
+  {
+      #ifdef debug_BIC_Propagate
+          G4cout << " special case 1H1.... " << G4endl;
+      #endif
+     return Propagate1H1(secondaries,nucleus);
+  }
   G4ReactionProductVector * products = new G4ReactionProductVector;
   the3DNucleus = nucleus;
 …
   ClearAndDestroy(&theFinalState);
   std::vector<G4KineticTrack *>::iterator iter;
-   // *GF* FIXME ? in propagate mode this test is wrong! Could be in Apply....
-  if(nucleus->GetMassNumber() == 1) // 1H1 is special case
+  {
-      #ifdef debug_BIC_Propagate
-          G4cout << " special case 1H1.... " << G4endl;
-      #endif
-     return Propagate1H1(secondaries,nucleus);
+  }
   BuildTargetList();
 …
      PrintKTVector(&target_collection,std::string("... targets"));
 //*GF*     throw G4HadronicException(__FILE__, __LINE__, "G4BinaryCasacde::ApplyCollision()");
 #else
+#endif
      return false;
-#endif
+  }
 …
   G4KineticTrackVector * products=0;
   products = collision->GetFinalState();
+  G4bool lateParticleCollision= (!haveTarget) && products && products->size() == 1;
   #ifdef debug_BIC_ApplyCollision
 …
            PrintKTVector(&collision->GetTargetCollection(),std::string(" Target particles"));
+      }
-   #endif
-     G4bool lateParticleCollision= (!haveTarget) && products && products->size() == 1;
         //  if ( lateParticleCollision ) G4cout << " Added late particle--------------------------"<<G4endl;
         //  if ( lateParticleCollision && products ) PrintKTVector(products, " reaction products");
+   #endif
 //****************************************
 …
+      {
           nsec++;
+          G4double tStep(0), tdummy(0);
+          ((G4RKPropagation*)thePropagator)->GetSphereIntersectionTimes(kt,tdummy,tStep);
+          G4double tStep(0), tdummy(0);
+          G4bool intersect =
+               ((G4RKPropagation*)thePropagator)->GetSphereIntersectionTimes(kt,tdummy,tStep);
 #ifdef debug_BIC_StepParticlesOut
           G4cout << " minTimeStep, tStep Particle " <<minTimeStep << " " <<tStep
                  << " " <<kt->GetDefinition()->GetParticleName()
                  << " 4mom " << kt->GetTrackingMomentum()<<G4endl;
+#endif
+          if(tStep<minTimeStep && tStep> 0 )
+          if ( ! intersect );
+          {
+             PrintKTVector(&theSecondaryList, std::string(" state ERROR....."));
+             throw G4HadronicException(__FILE__, __LINE__, "G4BinaryCascade::StepParticlesOut() particle not in nucleus");
+          }
+#endif
+          if(intersect && tStep<minTimeStep && tStep> 0 )
+          {
             minTimeStep = tStep;
 …
+    }
     size_t current(0);
     for(current=0; current<secs->size(); current++)
+    for(current=0; secs && current<secs->size(); current++)
+    {
       if((*secs)[current]->GetDefinition()->IsShortLived())
 …
                                           G4KineticTrackVector * products)
+{
-  G4RKPropagation * RKprop=(G4RKPropagation *)thePropagator;
   G4KineticTrackVector debug1;
 …
   PrintKTVector(products,std::string(" Scatterer products"));
+#ifdef dontUse
   G4double thisExcitation(0);
 //  excitation energy from this collision
 …
   G4KineticTrack * kt=collision->GetPrimary();
   initial +=  kt->Get4Momentum().e();
+  G4RKPropagation * RKprop=(G4RKPropagation *)thePropagator;
   initial +=  RKprop->GetField(kt->GetDefinition()->GetPDGEncoding(),kt->GetPosition());
 …
          << G4endl;
    currentInitialEnergy-=final;
+#endif
+}

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

-              r1340
+              r1347
 $Id: History,v 1.203 2010/10/22 20:41:05 mkelsey Exp $
+$Id: History,v 1.206 2010/11/24 21:16:17 mkelsey Exp $
 -------------------------------------------------------------------
 …
      * Please list in reverse chronological order (last date on top)
      ---------------------------------------------------------------
+November 2010 Michael Kelsey (hadr-casc-V09-03-87)
+-----------------------------------------------------
+- G4InuclCollider.cc:  Delete local "zbullet" before exiting.  Fixes memory
+  leak reported for 9.4 cand-01.
+November 2010 Michael Kelsey (hadr-casc-V09-03-86)
+-----------------------------------------------------
+- G4NucleiModel.cc:  Put messages related to negative-path-length and
+  zero-interaction-partners behind verbosity flag.
+October 2010 Michael Kelsey (hadr-casc-V09-03-85)
+----------------------------------------------------
+- G4NucleiModel:  Bring tagged version kelsey-20101020 (refactoring) to HEAD
+  and tag for 9.4 release.  This is the last substantive modification to be
+  included; validated by direct |diff|ing of output vs. V09-03-84 code.
 October 2010 Michael Kelsey (hadr-casc-V09-03-84)

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4Analyser.hh,v 1.10 2010/10/14 20:55:10 mkelsey Exp $
+//
+// $Id: G4Analyser.hh,v 1.11 2010/12/15 07:39:28 gunter Exp $
 //
 // 20101010  M. Kelsey -- Migrate to integer A and Z

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4ExitonConfiguration.hh,v 1.7 2010/09/24 06:26:06 mkelsey Exp $
+//
+// $Id: G4ExitonConfiguration.hh,v 1.8 2010/12/15 07:39:50 gunter Exp $
 //
 // 20100909  Add function to reset values to zero

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4FissionStore.hh,v 1.11 2010/10/19 21:33:58 mkelsey Exp $
+//
+// $Id: G4FissionStore.hh,v 1.12 2010/12/15 07:39:52 gunter Exp $
 //
 // 20100728  Move ::addConfig() to .cc file, add setVerboseLevel(), clear()

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeKminusNChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
+//
+// $Id: G4CascadeKminusNChannel.cc,v 1.6 2010/12/15 07:40:17 gunter Exp $
 //
 // 20100804  M. Kelsey -- Add name string to ctor

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeKminusPChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
+//
+// $Id: G4CascadeKminusPChannel.cc,v 1.6 2010/12/15 07:40:19 gunter Exp $
 //
 // 20100804  M. Kelsey -- Add name string to ctor

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeKplusNChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
+//
+// $Id: G4CascadeKplusNChannel.cc,v 1.6 2010/12/15 07:40:21 gunter Exp $
 //
 // 20100804  M. Kelsey -- Add name string to ctor

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeKplusPChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
+//
+// $Id: G4CascadeKplusPChannel.cc,v 1.6 2010/12/15 07:40:23 gunter Exp $
 //
 // 20100804  M. Kelsey -- Add name string to ctor

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeKzeroBarPChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
+//
+// $Id: G4CascadeKzeroBarPChannel.cc,v 1.6 2010/12/15 07:40:25 gunter Exp $
 //
 // 20100804  M. Kelsey -- Add name string to ctor

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeKzeroNChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
+//
+// $Id: G4CascadeKzeroNChannel.cc,v 1.6 2010/12/15 07:40:27 gunter Exp $
 //
 // 20100804  M. Kelsey -- Add name string to ctor

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeKzeroPChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
+//
+// $Id: G4CascadeKzeroPChannel.cc,v 1.6 2010/12/15 07:40:29 gunter Exp $
 //
 // 20100804  M. Kelsey -- Add name string to ctor

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeLambdaNChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
+//
+// $Id: G4CascadeLambdaNChannel.cc,v 1.6 2010/12/15 07:40:31 gunter Exp $
 //
 // 20100804  M. Kelsey -- Add name string to ctor

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeLambdaPChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
+//
+// $Id: G4CascadeLambdaPChannel.cc,v 1.6 2010/12/15 07:40:33 gunter Exp $
 //
 // 20100804  M. Kelsey -- Add name string to ctor

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeSigmaMinusNChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
+//
+// $Id: G4CascadeSigmaMinusNChannel.cc,v 1.6 2010/12/15 07:40:37 gunter Exp $
 //
 // 20100804  M. Kelsey -- Add name string to ctor

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeSigmaMinusPChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
+//
+// $Id: G4CascadeSigmaMinusPChannel.cc,v 1.6 2010/12/15 07:40:39 gunter Exp $
 //
 // 20100804  M. Kelsey -- Add name string to ctor

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeSigmaPlusNChannel.cc,v 1.6 2010/08/04 05:28:24 mkelsey Exp $
+//
+// $Id: G4CascadeSigmaPlusNChannel.cc,v 1.7 2010/12/15 07:40:41 gunter Exp $
 //
 // 20100804  M. Kelsey -- Add name string to ctor

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeSigmaPlusPChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
+//
+// $Id: G4CascadeSigmaPlusPChannel.cc,v 1.6 2010/12/15 07:40:43 gunter Exp $
 //
 // 20100804  M. Kelsey -- Add name string to ctor

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeSigmaZeroNChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
+//
+// $Id: G4CascadeSigmaZeroNChannel.cc,v 1.6 2010/12/15 07:40:45 gunter Exp $
 //
 // 20100804  M. Kelsey -- Add name string to ctor

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeSigmaZeroPChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
+//
+// $Id: G4CascadeSigmaZeroPChannel.cc,v 1.6 2010/12/15 07:40:47 gunter Exp $
 //
 // 20100804  M. Kelsey -- Add name string to ctor

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeXiMinusNChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
+//
+// $Id: G4CascadeXiMinusNChannel.cc,v 1.6 2010/12/15 07:40:52 gunter Exp $
 //
 // 20100804  M. Kelsey -- Add name string to ctor

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeXiMinusPChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
+//
+// $Id: G4CascadeXiMinusPChannel.cc,v 1.6 2010/12/15 07:40:54 gunter Exp $
 //
 // 20100804  M. Kelsey -- Add name string to ctor

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeXiZeroNChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
+//
+// $Id: G4CascadeXiZeroNChannel.cc,v 1.6 2010/12/15 07:40:56 gunter Exp $
 //
 // 20100804  M. Kelsey -- Add name string to ctor

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4CascadeXiZeroPChannel.cc,v 1.5 2010/08/04 05:28:24 mkelsey Exp $
+//
+// $Id: G4CascadeXiZeroPChannel.cc,v 1.6 2010/12/15 07:40:59 gunter Exp $
 //
 // 20100804  M. Kelsey -- Add name string to ctor

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: G4FissionStore.cc,v 1.16 2010/10/19 21:33:58 mkelsey Exp $
+//
+// $Id: G4FissionStore.cc,v 1.17 2010/12/15 07:41:05 gunter Exp $
 //
 // 20100728  Move ::addConfig() implementation to .cc file

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: bindingEnergy.cc,v 1.10 2010/09/14 17:51:36 mkelsey Exp $
+//
+// $Id: bindingEnergy.cc,v 1.11 2010/12/15 07:41:25 gunter Exp $
 //
 // 20100622 M. Kelsey -- Replace all functionally with call-through to

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

-              r1340
+              r1347
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
+// $Id: nucleiLevelDensity.cc,v 1.8 2010/09/14 17:51:36 mkelsey Exp $
+//
+// $Id: nucleiLevelDensity.cc,v 1.9 2010/12/15 07:41:27 gunter Exp $
 //
 // 20100914  M. Kelsey -- Migrate to integer A and Z; simplify code

trunk/source/processes/hadronic/models/chiral_inv_phase_space/History

-              r1340
+              r1347
 <<<<<<< History (please, make changes only with Mikhail.Kossov@cern.ch approval)
+-Nov-2010 Dennis Wright                       (hadr-chips-V09-03-09)
+----------------------------------------------------------------------
+Overall CHIPS tag which includes integer Z and A conversion and some
+correction of CoVerity errors
 -Jun-2010 M.Kosov                             (hadr-chips-V09-03-08)

trunk/source/processes/hadronic/models/chiral_inv_phase_space/body/History

-              r1340
+              r1347
      -----------------------------------------------------------------
+-Jun-2010 M.Kosov                           (hadr-chips-body-V09-03-13)
+Nov 2010 Dennis Wright                   (hadr-chips-body-V09-03-15)
+-----------------------------------------------------------------------
+- G4QContent.cc : fix bug 1131 by removing dead code in quark ctor
+  and remove dead code indicated by CoVerity in method MakePartonPair.
+  Remove dead code due to efFlag being set permanently false.
+- G4QNucleus.cc - remove dead code
+- G4QEnvironment.cc - remove dead code
+Nov 2010 Dennis Wright                   (hadr-chips-body-V09-03-14)
+-----------------------------------------------------------------------
+Bring up to geant4-09-03-ref-09 and tag
+-Jun-2010 M.Kosov                         (hadr-chips-body-V09-03-13)
 -----------------------------------------------------------------------
 Using HARP data a big bug is fixed, which influences CHIPS physics

trunk/source/processes/hadronic/models/chiral_inv_phase_space/fragmentation/History

-              r1337
+              r1347
        ==========================================================
+History file for  hadronic/models/chiral_inv_phase_space/fragmentation  directory.
+History file for  hadronic/models/chiral_inv_phase_space/fragmentation
+directory.
 Summarize all code modifications & keep track of all tags in this file.
 …
      -----------------------------------------------------------------
+Nov 2010  Dennis Wright                  (hadr-chips-frag-V09-03-07)
+-----------------------------------------------------------------------
+Previous tag was already used - retag
+Nov 2010  Dennis Wright                       (hadr-chips-V09-03-07)
+-----------------------------------------------------------------------
+Bring up to geant4-09-03-ref-09 and tag
 -Jun-2010 M.Kosov                             (hadr-chips-V09-03-06)
 -----------------------------------------------------------------------
+----------------------------------------------------------------------
 Mutual CHIPS tag for the G4-9-4-beta debugging
 -Jun-2010 M.Kosov                           (hadr-chips-frag-V09-03-05)
 --------------------------------------------------------------------------
+-Jun-2010 M.Kosov                         (hadr-chips-frag-V09-03-05)
+-----------------------------------------------------------------------
 Trap and cure for the bug: return to vacuum what appeared from vacuum

trunk/source/processes/hadronic/models/chiral_inv_phase_space/interface/History

-              r1340
+              r1347
      * Please list in reverse chronological order (last date on top)
      ---------------------------------------------------------------
+-Nov-2010 J.Apostolakis                      (hadr-chips-inter-V09-03-03)
+---------------------------------------------------------------------------
+- G4ChiralInvariantPhaseSpace.cc: Change to use integer value of Z and A.
+-Nov-2010 V.Ivanchenko                       (hadr-chips-inter-V09-03-02)
+---------------------------------------------------------------------------
+- G4ElectroNuclearReaction - cross section classes are included by pointer
+  and not by value, this should not change any result but providing
+  clear siquence of removel of cross sections after execution
+  (fixed old problem reported in HyperNews)
 -Sep-2010 A. Dotti                           (hadr-chips-inter-V09-03-01)

trunk/source/processes/hadronic/models/chiral_inv_phase_space/interface/src/G4ChiralInvariantPhaseSpace.cc

-              r1340
+              r1347
   //target properties needed in constructor of quasmon
   G4int targetZ = G4int(aTargetNucleus.GetZ()+0.5);
   G4int targetA = G4int(aTargetNucleus.GetN()+0.5);
+  G4int targetZ = aTargetNucleus.GetZ_asInt();
+  G4int targetA = aTargetNucleus.GetA_asInt();
   G4int targetPDGCode = 90000000 + 1000*targetZ + (targetA-targetZ);
   // NOT NECESSARY ______________

trunk/source/processes/hadronic/models/coherent_elastic/History

-              r1340
+              r1347
      * Please list in reverse chronological order (last date on top)
      ---------------------------------------------------------------
+November 2010 - V.Ivanchenko (hadr-cohe-V09-03-07)
+------------------------------------------------------
+- G4WHadronElasticProcess, G4VHadronElastic, G4HadronElastic,
+  G4ChargeExchange - fixed bug introduced in the previous tag -
+    use now GetA_asInt() method instead of GetN_asInt()
+November 2010 - V.Ivanchenko (hadr-cohe-V09-03-06)
+------------------------------------------------------
+- G4NuclNuclDiffuseElastic - new model
+- Use integer Z and A in other classes
 September 2010 - G.Cosmo (hadr-cohe-V09-03-05)

trunk/source/processes/hadronic/models/de_excitation/History

-              r1340
+              r1347
      * Please list in reverse chronological order (last date on top)
      ---------------------------------------------------------------
+October 2010 Vladimir Ivanchenko (hadr-deex-V09-03-27)
+----------------------------------------------------------
+- G4Evaporation, G4EvaporationChannel, G4EvaporationProbability -
+  improved computation of minimal and maximal evaporation energy
+- G4E1Probability, G4PhotonEvaporation - fixed probability
+October 2010 Vladimir Ivanchenko (hadr-deex-V09-03-26)
+----------------------------------------------------------
+- G4ParaFissionModel - use GetA_asInt()
+October 2010 Vladimir Ivanchenko (hadr-deex-V09-03-25)
+----------------------------------------------------------
+G4GEMChannel - cleanup: integer Z,A; G4Pow; use the same formulas as in
+  G4GEMProbability class
+October 2010 Vladimir Ivanchenko (hadr-deex-V09-03-24)
+----------------------------------------------------------
+- photon_evaporation, fission - integer Z and A, constructors
+   moved to src, usage of G4Pow, general cleanup
+- G4ContiniumGammaTransition - use exponential law for sampling of
+                               decay time
+- removed unused classes: G4DummyProbability, G4E1ProbabilityXXX,
+  G4E1SingleProbabilityXXX, where XXX=001,01,1,10,100 - these classes
+  are the same as the one really used but a scale factor for the
+  probability is different, scale factor may be applied in the main
+  class if needed
+October 2010 Vladimir Ivanchenko (hadr-deex-V09-03-23)
+----------------------------------------------------------
+- utils, management, evaporation - integer Z and A, constructors
+   moved to src, usage of G4Pow, general cleanup
+- G4EvaporationChannel - removed new and delete of probability objects
+  at each to the class, use instead local G4EvaporationProbability
+  of the channel
+October 2010 Vladimir Ivanchenko (hadr-deex-V09-03-22)
+----------------------------------------------------------
+- Fixed problems reported by the Coveruty tool (mainly pedantic
+  initialisation); moved constructors and destructors to source
+October 2010 Dennis Wright (hadr-deex-V09-03-21)
+---------------------------------------------------
+- add Luciano Pandola's README file explaining the photo-evaporation
+  data files
 October 2010 Vladimir Ivanchenko (hadr-deex-V09-03-20)

trunk/source/processes/hadronic/models/de_excitation/ablation/src/G4WilsonAblationModel.cc

r1228	r1347
150	150	OPTxs = 3;
151	151	useSICB = false;
	152	fragmentVector = 0;
152	153	}
153	154	////////////////////////////////////////////////////////////////////////////////

trunk/source/processes/hadronic/models/de_excitation/evaporation/include/G4AlphaEvaporationChannel.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4AlphaEvaporationChannel.hh,v 1.8 2008/09/19 13:32:54 ahoward Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4AlphaEvaporationChannel.hh,v 1.9 2010/11/17 12:14:59 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Nov. 1999)
 //
+// 17-11-2010 V.Ivanchenko moved constructor and destructor to source and cleanup
 #ifndef G4AlphaEvaporationChannel_h
 …
 public:
   // only available constructor
+  G4AlphaEvaporationChannel() : G4EvaporationChannel(4,2,"alpha",
+                                                     &theEvaporationProbability,&theCoulombBarrier) {};
+  G4AlphaEvaporationChannel();
   // destructor
   ~G4AlphaEvaporationChannel() {};
+  virtual ~G4AlphaEvaporationChannel();
 private:
 …
   G4AlphaEvaporationChannel(const G4AlphaEvaporationChannel & right);
-public:
   G4bool operator==(const G4AlphaEvaporationChannel & right) const;
   G4bool operator!=(const G4AlphaEvaporationChannel & right) const;
-private:
   G4AlphaCoulombBarrier theCoulombBarrier;

trunk/source/processes/hadronic/models/de_excitation/evaporation/include/G4AlphaEvaporationProbability.hh

-              r962
+              r1347
 // ********************************************************************
 //
+//J.M. Quesada (August2008). Based on:
+// $Id: G4AlphaEvaporationProbability.hh,v 1.14 2010/11/17 11:06:03 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
+//
+// J.M. Quesada (August2008). Based on:
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Oct 1998)
+//
+// Modified:
+// 17-11-2010 V.Ivanchenko integer Z and A
 //
 #ifndef G4AlphaEvaporationProbability_h
 …
   G4AlphaEvaporationProbability();
+  ~G4AlphaEvaporationProbability() {}
+  virtual ~G4AlphaEvaporationProbability();
 private:
   // Copy constructor
 …
   G4bool operator!=(const G4AlphaEvaporationProbability &right) const;
 private:
   virtual G4double CrossSection(const  G4Fragment & fragment, const  G4double K);
+  virtual G4double CrossSection(const  G4Fragment & fragment, G4double K);
+  G4double GetOpt0(const G4double K);
+  G4double GetOpt12(const G4double K);
+  G4double GetOpt34(const G4double K);
+  G4double GetOpt0(G4double K);
+  G4double GetOpt12(G4double K);
+  G4double GetOpt34(G4double K);
+  virtual G4double CalcAlphaParam(const G4Fragment & fragment) ;
+  virtual G4double CalcBetaParam(const G4Fragment & fragment)  ;
+  G4double CCoeficient(G4int aZ) ;
+  //data members
+  G4AlphaCoulombBarrier theCoulombBarrier;
+ virtual G4double CalcAlphaParam(const G4Fragment & fragment) ;
+ virtual G4double CalcBetaParam(const G4Fragment & fragment)  ;
+  G4double CCoeficient(const G4double aZ) ;
+//data members
+      G4AlphaCoulombBarrier theCoulombBarrier;
+      G4double ResidualA;
+      G4double ResidualZ;
+      G4double theA;
+      G4double theZ;
+      G4double ResidualAthrd;
+      G4double FragmentA;
+      G4double FragmentAthrd;
+  G4int ResidualA;
+  G4int ResidualZ;
+  G4int theA;
+  G4int theZ;
+  G4double ResidualAthrd;
+  G4int FragmentA;
+  G4double FragmentAthrd;
 };

trunk/source/processes/hadronic/models/de_excitation/evaporation/include/G4DeuteronEvaporationChannel.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4DeuteronEvaporationChannel.hh,v 1.8 2008/09/19 13:32:54 ahoward Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4DeuteronEvaporationChannel.hh,v 1.9 2010/11/17 12:14:59 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Nov. 1999)
 //
+// 17-11-2010 V.Ivanchenko moved constructor and destructor to source and cleanup
 #ifndef G4DeuteronEvaporationChannel_h
 …
 public:
   // only available constructor
+  G4DeuteronEvaporationChannel() : G4EvaporationChannel(2,1,"deuteron",
+                                                        &theEvaporationProbability,&theCoulombBarrier) {};
+  G4DeuteronEvaporationChannel();
   // destructor
   ~G4DeuteronEvaporationChannel() {};
+  virtual ~G4DeuteronEvaporationChannel();
 private:
 …
   G4DeuteronEvaporationChannel(const G4DeuteronEvaporationChannel & right);
-public:
   G4bool operator==(const G4DeuteronEvaporationChannel & right) const;
   G4bool operator!=(const G4DeuteronEvaporationChannel & right) const;
-private:
   G4DeuteronCoulombBarrier theCoulombBarrier;

trunk/source/processes/hadronic/models/de_excitation/evaporation/include/G4DeuteronEvaporationProbability.hh

-              r962
+              r1347
 // ********************************************************************
 //
+//J.M. Quesada (August2008). Based on:
+// $Id: G4DeuteronEvaporationProbability.hh,v 1.14 2010/11/17 11:06:03 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
+//
+// J.M. Quesada (August2008). Based on:
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Oct 1998)
+//
+// Modified:
+// 17-11-2010 V.Ivanchenko integer Z and A
 //
 …
   G4DeuteronEvaporationProbability();
+  ~G4DeuteronEvaporationProbability() {}
+  virtual ~G4DeuteronEvaporationProbability();
 private:
   // Copy constructor
 …
 private:
   virtual G4double CrossSection(const  G4Fragment & fragment, const  G4double K);
+  virtual G4double CrossSection(const  G4Fragment & fragment, G4double K);
   G4double GetOpt0(const G4double K);
   G4double GetOpt12(const G4double K);
   G4double GetOpt34(const G4double K);
+  G4double GetOpt0(G4double K);
+  G4double GetOpt12(G4double K);
+  G4double GetOpt34(G4double K);
+  virtual G4double CalcAlphaParam(const G4Fragment & fragment) ;
+  virtual G4double CalcBetaParam(const G4Fragment & fragment) ;
+  G4double CCoeficient(G4int aZ) ;
+ virtual G4double CalcAlphaParam(const G4Fragment & fragment) ;
+ virtual G4double CalcBetaParam(const G4Fragment & fragment) ;
+  G4double CCoeficient(const G4double aZ) ;
+//data members
+  //data members
       G4DeuteronCoulombBarrier theCoulombBarrier;
+  G4DeuteronCoulombBarrier theCoulombBarrier;
+      G4double ResidualA;
+      G4double ResidualZ;
+      G4double theA;
+      G4double theZ;
+      G4double ResidualAthrd;
+      G4double FragmentA;
+      G4double FragmentAthrd;
+  G4int ResidualA;
+  G4int ResidualZ;
+  G4int theA;
+  G4int theZ;
+  G4double ResidualAthrd;
+  G4int FragmentA;
+  G4double FragmentAthrd;
 };

trunk/source/processes/hadronic/models/de_excitation/evaporation/include/G4Evaporation.hh

r1340	r1347
26	26	//
27	27	// $Id: G4Evaporation.hh,v 1.12 2010/05/11 11:34:09 vnivanch Exp $
28		// GEANT4 tag $Name: geant4-09-0~~3-ref-09~~ $
	28	// GEANT4 tag $Name: geant4-09-04-ref-00 $
29	29	//
30	30	// Hadronic Process: Nuclear De-excitations

trunk/source/processes/hadronic/models/de_excitation/evaporation/include/G4EvaporationChannel.hh

-              r962
+              r1347
 // ********************************************************************
 //
+// $Id: G4EvaporationChannel.hh,v 1.11 2010/11/17 12:19:08 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
+//
+//
 //J.M. Quesada (August2008). Based on:
 //
 …
 // by V. Lara (Oct 1998)
 //
+// 17-11-2010 V.Ivanchenko in constructor replace G4VEmissionProbability by
+//            G4EvaporationProbability and do not new and delete probability
+//            object at each call; use G4Pow
 #ifndef G4EvaporationChannel_h
 …
 #include "G4VEvaporationChannel.hh"
-#include "G4VEmissionProbability.hh"
 #include "G4EvaporationProbability.hh"
-#include "G4NeutronEvaporationProbability.hh"
-#include "G4ProtonEvaporationProbability.hh"
-#include "G4DeuteronEvaporationProbability.hh"
-#include "G4TritonEvaporationProbability.hh"
-#include "G4He3EvaporationProbability.hh"
-#include "G4AlphaEvaporationProbability.hh"
-#include "G4VLevelDensityParameter.hh"
 #include "G4VCoulombBarrier.hh"
-#include "G4EvaporationLevelDensityParameter.hh"
-#include "G4NucleiProperties.hh"
-#include "Randomize.hh"
-#include "G4ParticleTable.hh"
-#include "G4IonTable.hh"
+class G4EvaporationLevelDensityParameter;
 class G4EvaporationChannel : public G4VEvaporationChannel
 …
 public:
   // constructor
+  G4EvaporationChannel(const G4int theA, const G4int theZ, const G4String & aName,
+                       G4VEmissionProbability * aEmissionStrategy,
+  G4EvaporationChannel(G4int theA, G4int theZ, const G4String & aName,
+                       G4EvaporationProbability * aEmissionStrategy,
                        G4VCoulombBarrier * aCoulombBarrier);
 public:
   // destructor
   ~G4EvaporationChannel();
+  virtual ~G4EvaporationChannel();
   void SetEmissionStrategy(G4VEmissionProbability * aEmissionStrategy)
+  inline void SetEmissionStrategy(G4EvaporationProbability * aEmissionStrategy)
   {theEvaporationProbabilityPtr = aEmissionStrategy;}
   void SetCoulombBarrierStrategy(G4VCoulombBarrier * aCoulombBarrier)
+  inline void SetCoulombBarrierStrategy(G4VCoulombBarrier * aCoulombBarrier)
   {theCoulombBarrierPtr = aCoulombBarrier;}
 protected:
   // default constructor
   G4EvaporationChannel() {};
+  G4EvaporationChannel();
 private:
 …
   G4FragmentVector * BreakUp(const G4Fragment & theNucleus);
-  // void SetLevelDensityParameter(G4VLevelDensityParameter * aLevelDensity);
 public:
   inline G4double GetEmissionProbability(void) const
   {return EmissionProbability;}
   inline G4double GetMaximalKineticEnergy(void) const
   { return MaximalKineticEnergy; }
 …
   // Calculate Binding Energy for separate fragment from nucleus
   G4double CalcBindingEnergy(const G4int anA, const G4int aZ);
+  G4double CalcBindingEnergy(G4int anA, G4int aZ);
   // Calculate maximal kinetic energy that can be carried by fragment (in MeV)
   G4double CalcMaximalKineticEnergy(const G4double U);
+  G4double CalcMaximalKineticEnergy(G4double U);
   // Samples fragment kinetic energy.
     G4double  GetKineticEnergy(const G4Fragment & aFragment);
+  G4double  GetKineticEnergy(const G4Fragment & aFragment);
   // This has to be removed and put in Random Generator
   G4ThreeVector IsotropicVector(const G4double Magnitude  = 1.0);
+  G4ThreeVector IsotropicVector(G4double Magnitude  = 1.0);
         // Data Members
 …
   G4int theZ;
+  G4double EvaporatedMass;
+  G4double ResidualMass;
   // For evaporation probability calcualation
   G4VEmissionProbability * theEvaporationProbabilityPtr;
+  G4EvaporationProbability * theEvaporationProbabilityPtr;
   // For Level Density calculation
  // G4bool MyOwnLevelDensity;
+  // G4bool MyOwnLevelDensity;
   G4VLevelDensityParameter * theLevelDensityPtr;
   // For Coulomb Barrier calculation
   G4VCoulombBarrier * theCoulombBarrierPtr;
   G4double CoulombBarrier;
   //---------------------------------------------------
 …
   G4double EmissionProbability;
   // Maximal Kinetic Energy that can be carried by fragment
   G4double MaximalKineticEnergy;
 };

trunk/source/processes/hadronic/models/de_excitation/evaporation/include/G4EvaporationDefaultGEMFactory.hh

r1340	r1347
26	26	//
27	27	// $Id: G4EvaporationDefaultGEMFactory.hh,v 1.1 2009/07/27 10:20:13 vnivanch Exp $
28		// GEANT4 tag $Name: geant4-09-0~~3-ref-09~~ $
	28	// GEANT4 tag $Name: geant4-09-04-ref-00 $
29	29	//
30	30	// Hadronic Process: Nuclear De-excitations

trunk/source/processes/hadronic/models/de_excitation/evaporation/include/G4EvaporationFactory.hh

r1340	r1347
26	26	//
27	27	// $Id: G4EvaporationFactory.hh,v 1.4 2010/04/27 11:43:16 vnivanch Exp $
28		// GEANT4 tag $Name: geant4-09-0~~3-ref-09~~ $
	28	// GEANT4 tag $Name: geant4-09-04-ref-00 $
29	29	//
30	30	// Hadronic Process: Nuclear De-excitations

trunk/source/processes/hadronic/models/de_excitation/evaporation/include/G4EvaporationProbability.hh

-              r962
+              r1347
 // ********************************************************************
 //
+// $Id: G4EvaporationProbability.hh,v 1.13 2010/11/17 11:06:03 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
+//
 //J.M. Quesada (August2008). Based on:
 //
 …
 public:
   // Only available constructor
+  G4EvaporationProbability(const G4int anA, const G4int aZ, const G4double aGamma,G4VCoulombBarrier * aCoulombBarrier) :
+    theA(anA),
+    theZ(aZ),
+    Gamma(aGamma)
+,  theCoulombBarrierptr(aCoulombBarrier)
+  {
+    theEvapLDPptr = new G4EvaporationLevelDensityParameter;
+  G4EvaporationProbability(G4int anA, G4int aZ, G4double aGamma,
+                           G4VCoulombBarrier * aCoulombBarrier);
+  }
+  virtual ~G4EvaporationProbability();
+  ~G4EvaporationProbability()
+  {
+    if (theEvapLDPptr != 0) delete theEvapLDPptr;
+  }
+  inline G4int GetZ(void) const { return theZ; }
+  G4double GetZ(void) const { return theZ; }
+  G4double GetA(void) const { return theA;}
+  inline G4int GetA(void) const { return theA;}
 protected:
   // Default constructor
   G4EvaporationProbability() {}
+  G4EvaporationProbability();
 private:
 …
 public:
  G4double ProbabilityDistributionFunction( const G4Fragment & aFragment, const G4double K);
+  G4double ProbabilityDistributionFunction( const G4Fragment & aFragment, G4double K);
  G4double EmissionProbability(const G4Fragment & fragment, const G4double anEnergy);
+  G4double EmissionProbability(const G4Fragment & fragment, G4double anEnergy);
 private:
   G4double CalculateProbability(const G4Fragment & fragment, const G4double MaximalKineticEnergy );
+  G4double CalculateProbability(const G4Fragment & fragment, G4double MaximalKineticEnergy );
+  G4double IntegrateEmissionProbability(const G4Fragment & aFragment, const G4double & Low, const G4double & Up );
+  G4double IntegrateEmissionProbability(const G4Fragment & aFragment,
+                                        const G4double & Low, const G4double & Up );
 protected:
  virtual G4double CrossSection( const  G4Fragment & fragment, const G4double K )= 0;
+ virtual G4double CrossSection( const  G4Fragment & fragment, G4double K )= 0;
  virtual G4double CalcAlphaParam(const G4Fragment & fragment)=0 ;
 …
 private:
+  // Data Members
+  G4VLevelDensityParameter * theEvapLDPptr;
+  // Data Members
   G4int theA;
   G4int theZ;
 …
   G4double Gamma;
+//The Coulomb Barrier
+         G4VCoulombBarrier * theCoulombBarrierptr;
+  //The Coulomb Barrier
+  G4VCoulombBarrier * theCoulombBarrierptr;
 };
 #endif

trunk/source/processes/hadronic/models/de_excitation/evaporation/include/G4He3EvaporationChannel.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4He3EvaporationChannel.hh,v 1.8 2008/09/19 13:32:54 ahoward Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4He3EvaporationChannel.hh,v 1.9 2010/11/17 12:14:59 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Nov. 1999)
 //
+// 17-11-2010 V.Ivanchenko moved constructor and destructor to source and cleanup
 #ifndef G4He3EvaporationChannel_h
 …
 public:
   // only available constructor
+  G4He3EvaporationChannel() : G4EvaporationChannel(3,2,"He3",
+                                                   &theEvaporationProbability,&theCoulombBarrier) {};
+  G4He3EvaporationChannel();
   // destructor
   ~G4He3EvaporationChannel() {};
+  virtual ~G4He3EvaporationChannel();
 private:
   const G4He3EvaporationChannel & operator=(const G4He3EvaporationChannel & right);
   G4He3EvaporationChannel(const G4He3EvaporationChannel & right);
-public:
   G4bool operator==(const G4He3EvaporationChannel & right) const;
   G4bool operator!=(const G4He3EvaporationChannel & right) const;
+private:
+    G4He3CoulombBarrier theCoulombBarrier;
+  G4He3CoulombBarrier theCoulombBarrier;
   G4He3EvaporationProbability theEvaporationProbability;

trunk/source/processes/hadronic/models/de_excitation/evaporation/include/G4He3EvaporationProbability.hh

-              r962
+              r1347
 // ********************************************************************
 //
+//J.M. Quesada (August2008). Based on:
+// $Id: G4He3EvaporationProbability.hh,v 1.14 2010/11/17 11:06:03 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
+//
+// J.M. Quesada (August2008). Based on:
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Oct 1998)
+//
+// Modified:
+// 17-11-2010 V.Ivanchenko integer Z and A
 //
 #ifndef G4He3EvaporationProbability_h
 …
   G4He3EvaporationProbability();
+  ~G4He3EvaporationProbability() {}
+  virtual ~G4He3EvaporationProbability();
 private:
   // Copy constructor
 …
   G4bool operator!=(const G4He3EvaporationProbability &right) const;
 private:
   virtual G4double CrossSection(const  G4Fragment & fragment, const  G4double K);
+  virtual G4double CrossSection(const  G4Fragment & fragment, G4double K);
   G4double GetOpt0(const G4double K);
   G4double GetOpt12(const G4double K);
   G4double GetOpt34(const G4double K);
+  G4double GetOpt0(G4double K);
+  G4double GetOpt12(G4double K);
+  G4double GetOpt34(G4double K);
+  virtual G4double CalcAlphaParam(const G4Fragment & fragment) ;
+  virtual G4double CalcBetaParam(const G4Fragment & fragment) ;
+  G4double CCoeficient(G4int aZ) ;
+ virtual G4double CalcAlphaParam(const G4Fragment & fragment) ;
+ virtual G4double CalcBetaParam(const G4Fragment & fragment) ;
+  G4double CCoeficient(const G4double aZ) ;
+//data members
+  //data members
       G4He3CoulombBarrier theCoulombBarrier;
+  G4He3CoulombBarrier theCoulombBarrier;
+      G4double ResidualA;
+      G4double ResidualZ;
+      G4double theA;
+      G4double theZ;
+      G4double ResidualAthrd;
+      G4double FragmentA;
+      G4double FragmentAthrd;
+  G4int ResidualA;
+  G4int ResidualZ;
+  G4int theA;
+  G4int theZ;
+  G4double ResidualAthrd;
+  G4int FragmentA;
+  G4double FragmentAthrd;
 };

trunk/source/processes/hadronic/models/de_excitation/evaporation/include/G4NeutronEvaporationChannel.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4NeutronEvaporationChannel.hh,v 1.8 2008/09/19 13:32:54 ahoward Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4NeutronEvaporationChannel.hh,v 1.9 2010/11/17 12:14:59 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Nov. 1999)
 //
+// 17-11-2010 V.Ivanchenko moved constructor and destructor to source and cleanup
 #ifndef G4NeutronEvaporationChannel_h
 …
 public:
   // only available constructor
+  G4NeutronEvaporationChannel() : G4EvaporationChannel(1,0,"neutron",
+                                                       &theEvaporationProbability,&theCoulombBarrier) {};
+  G4NeutronEvaporationChannel();
   // destructor
   ~G4NeutronEvaporationChannel() {};
+  virtual ~G4NeutronEvaporationChannel();
 private:
   const G4NeutronEvaporationChannel & operator=(const G4NeutronEvaporationChannel & right);
   G4NeutronEvaporationChannel(const G4NeutronEvaporationChannel & right);
-public:
   G4bool operator==(const G4NeutronEvaporationChannel & right) const;
   G4bool operator!=(const G4NeutronEvaporationChannel & right) const;
+private:
+ G4NeutronCoulombBarrier theCoulombBarrier;
+  G4NeutronCoulombBarrier theCoulombBarrier;
   G4NeutronEvaporationProbability theEvaporationProbability;

trunk/source/processes/hadronic/models/de_excitation/evaporation/include/G4NeutronEvaporationProbability.hh

-              r962
+              r1347
 // ********************************************************************
 //
+//J.M. Quesada (August2008). Based on:
+// $Id: G4NeutronEvaporationProbability.hh,v 1.15 2010/11/17 11:06:03 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
+//
+// J.M. Quesada (August2008). Based on:
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Oct 1998)
+//
+// Modified:
+// 17-11-2010 V.Ivanchenko integer Z and A
 //
 …
   G4NeutronEvaporationProbability();
+  ~G4NeutronEvaporationProbability() {}
+  virtual ~G4NeutronEvaporationProbability();
 private:
 …
 private:
   virtual G4double CrossSection(const  G4Fragment & fragment, const  G4double K);
+  virtual G4double CrossSection(const  G4Fragment & fragment, G4double K);
   G4double GetOpt12(const G4double K);
   G4double GetOpt34(const G4double K);
+  G4double GetOpt12(G4double K);
+  G4double GetOpt34(G4double K);
  virtual G4double CalcAlphaParam(const G4Fragment & fragment);
+  virtual G4double CalcAlphaParam(const G4Fragment & fragment);
  virtual G4double CalcBetaParam(const G4Fragment & fragment);
+  virtual G4double CalcBetaParam(const G4Fragment & fragment);
+//data members
+  //data members
       G4NeutronCoulombBarrier theCoulombBarrier;
+  G4NeutronCoulombBarrier theCoulombBarrier;
+      G4double ResidualA;
+      G4double ResidualZ;
+      G4double theA;
+      G4double theZ;
+      G4double ResidualAthrd;
+      G4double FragmentA;
+      G4double FragmentAthrd;
+  G4int ResidualA;
+  G4int ResidualZ;
+  G4int theA;
+  G4int theZ;
+  G4double ResidualAthrd;
+  G4int FragmentA;
+  G4double FragmentAthrd;
 };

trunk/source/processes/hadronic/models/de_excitation/evaporation/include/G4ProtonEvaporationChannel.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4ProtonEvaporationChannel.hh,v 1.8 2008/09/19 13:32:54 ahoward Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4ProtonEvaporationChannel.hh,v 1.9 2010/11/17 12:14:59 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Nov. 1999)
 //
+// 17-11-2010 V.Ivanchenko moved constructor and destructor to source and cleanup
 #ifndef G4ProtonEvaporationChannel_h
 …
 public:
   // only available constructor
+  G4ProtonEvaporationChannel() : G4EvaporationChannel(1,1,"proton",
+                                                      &theEvaporationProbability,&theCoulombBarrier) {};
+  G4ProtonEvaporationChannel();
   // destructor
   ~G4ProtonEvaporationChannel() {};
+  virtual ~G4ProtonEvaporationChannel();
 private:
   const G4ProtonEvaporationChannel & operator=(const G4ProtonEvaporationChannel & right);
   G4ProtonEvaporationChannel(const G4ProtonEvaporationChannel & right);
-public:
   G4bool operator==(const G4ProtonEvaporationChannel & right) const;
   G4bool operator!=(const G4ProtonEvaporationChannel & right) const;
+private:
+   G4ProtonCoulombBarrier  theCoulombBarrier;
+  G4ProtonCoulombBarrier  theCoulombBarrier;
   G4ProtonEvaporationProbability  theEvaporationProbability;

trunk/source/processes/hadronic/models/de_excitation/evaporation/include/G4ProtonEvaporationProbability.hh

-              r962
+              r1347
 // ********************************************************************
 //
+//J.M. Quesada (August2008). Based on:
+// $Id: G4ProtonEvaporationProbability.hh,v 1.14 2010/11/17 11:06:03 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
+//
+// J.M. Quesada (August2008). Based on:
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Oct 1998)
+//
+// Modified:
+// 17-11-2010 V.Ivanchenko integer Z and A
 //
 …
   G4ProtonEvaporationProbability();
+  ~G4ProtonEvaporationProbability() {}
+  virtual ~G4ProtonEvaporationProbability();
 private:
   // Copy constructor
 …
   G4bool operator!=(const G4ProtonEvaporationProbability &right) const;
 private:
   virtual G4double CrossSection(const  G4Fragment & fragment, const  G4double K);
+  virtual G4double CrossSection(const  G4Fragment & fragment, G4double K);
   G4double GetOpt0(const G4double K);
   G4double GetOpt1(const G4double K);
   G4double GetOpt2(const G4double K);
   G4double GetOpt3(const G4double K);
+  G4double GetOpt0(G4double K);
+  G4double GetOpt1(G4double K);
+  G4double GetOpt2(G4double K);
+  G4double GetOpt3(G4double K);
+  virtual G4double CalcAlphaParam(const G4Fragment & fragment)  ;
+  virtual G4double CalcBetaParam(const G4Fragment & fragment) ;
+  G4double CCoeficient(G4int aZ) ;
+ virtual G4double CalcAlphaParam(const G4Fragment & fragment)  ;
+ virtual G4double CalcBetaParam(const G4Fragment & fragment) ;
+  G4double CCoeficient(const G4double aZ) ;
+//data members
+  //data members
       G4ProtonCoulombBarrier theCoulombBarrier;
+  G4ProtonCoulombBarrier theCoulombBarrier;
+      G4double ResidualA;
+      G4double ResidualZ;
+      G4double theA;
+      G4double theZ;
+      G4double ResidualAthrd;
+      G4double FragmentA;
+      G4double FragmentAthrd;
+      G4double U;
+  G4int ResidualA;
+  G4int ResidualZ;
+  G4int theA;
+  G4int theZ;
+  G4double ResidualAthrd;
+  G4int FragmentA;
+  G4double FragmentAthrd;
+  G4double U;
 };

trunk/source/processes/hadronic/models/de_excitation/evaporation/include/G4TritonEvaporationChannel.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4TritonEvaporationChannel.hh,v 1.8 2008/09/19 13:32:54 ahoward Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4TritonEvaporationChannel.hh,v 1.9 2010/11/17 12:14:59 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Nov. 1999)
 //
+// 17-11-2010 V.Ivanchenko moved constructor and destructor to source and cleanup
 #ifndef G4TritonEvaporationChannel_h
 …
 public:
   // only available constructor
+  G4TritonEvaporationChannel() : G4EvaporationChannel(3,1,"triton",
+                                                      &theEvaporationProbability,&theCoulombBarrier) {};
+  G4TritonEvaporationChannel();
   // destructor
   ~G4TritonEvaporationChannel() {};
+  virtual ~G4TritonEvaporationChannel();
 private:
 …
   G4TritonEvaporationChannel(const G4TritonEvaporationChannel & right);
-public:
   G4bool operator==(const G4TritonEvaporationChannel & right) const;
   G4bool operator!=(const G4TritonEvaporationChannel & right) const;
-private:
   G4TritonCoulombBarrier theCoulombBarrier;

trunk/source/processes/hadronic/models/de_excitation/evaporation/include/G4TritonEvaporationProbability.hh

-              r962
+              r1347
 // ********************************************************************
 //
+//J.M. Quesada (August2008). Based on:
+// $Id: G4TritonEvaporationProbability.hh,v 1.14 2010/11/17 11:06:03 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
+//
+// J.M. Quesada (August2008). Based on:
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Oct 1998)
 //
+// Modified:
+// 17-11-2010 V.Ivanchenko integer Z and A
 #ifndef G4TritonEvaporationProbability_h
 #define G4TritonEvaporationProbability_h 1
 …
   G4TritonEvaporationProbability();
+  ~G4TritonEvaporationProbability() {}
+  virtual ~G4TritonEvaporationProbability();
 private:
   // Copy constructor
 …
 private:
   virtual G4double CrossSection(const  G4Fragment & fragment, const  G4double K);
+  virtual G4double CrossSection(const G4Fragment & fragment, G4double K);
   G4double GetOpt0(const G4double K);
   G4double GetOpt12(const G4double K);
   G4double GetOpt34(const G4double K);
+  G4double GetOpt0(G4double K);
+  G4double GetOpt12(G4double K);
+  G4double GetOpt34(G4double K);
  virtual G4double CalcAlphaParam(const G4Fragment & fragment)  ;
+  virtual G4double CalcAlphaParam(const G4Fragment & fragment)  ;
  virtual G4double CalcBetaParam(const G4Fragment & fragment)  ;
+  virtual G4double CalcBetaParam(const G4Fragment & fragment)  ;
   G4double CCoeficient(const G4double aZ) ;
+  G4double CCoeficient(G4int aZ) ;
+//data members
+  //data members
+  G4TritonCoulombBarrier theCoulombBarrier;
+      G4TritonCoulombBarrier theCoulombBarrier;
+      G4double ResidualA;
+      G4double ResidualZ;
+      G4double theA;
+      G4double theZ;
+      G4double ResidualAthrd;
+      G4double FragmentA;
+      G4double FragmentAthrd;
+  G4int ResidualA;
+  G4int ResidualZ;
+  G4int theA;
+  G4int theZ;
+  G4double ResidualAthrd;
+  G4int FragmentA;
+  G4double FragmentAthrd;
 };
 #endif

trunk/source/processes/hadronic/models/de_excitation/evaporation/include/G4UnstableFragmentBreakUp.hh

r1340	r1347
25	25	//
26	26	// $Id: G4UnstableFragmentBreakUp.hh,v 1.2 2010/05/11 11:26:15 vnivanch Exp $
27		// GEANT4 tag $Name: geant4-09-0~~3-ref-09~~ $
	27	// GEANT4 tag $Name: geant4-09-04-ref-00 $
28	28	//
29	29	// -------------------------------------------------------------------

trunk/source/processes/hadronic/models/de_excitation/evaporation/include/G4VEvaporation.hh

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4VEvaporation.hh,v 1.6 2010/04/27 14:00:40 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4VEvaporation.hh,v 1.8 2010/11/17 11:06:03 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
   // for superimposed Coulomb Barrier for inverse cross sections
   inline void UseSICB(G4bool use) { useSICB = use; }
 protected:
    G4int OPTxs;
    G4bool useSICB;
+  G4int OPTxs;
+  G4bool useSICB;
 };

trunk/source/processes/hadronic/models/de_excitation/evaporation/src/G4AlphaEvaporationChannel.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4AlphaEvaporationChannel.cc,v 1.4 2006/06/29 20:10:17 gunter Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4AlphaEvaporationChannel.cc,v 1.5 2010/11/17 12:14:59 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Nov. 1999)
 //
+// 17-11-2010 V.Ivanchenko moved constructor and destructor to source and cleanup
 #include "G4AlphaEvaporationChannel.hh"
+G4AlphaEvaporationChannel::G4AlphaEvaporationChannel()
+: G4EvaporationChannel(4,2,"alpha",&theEvaporationProbability,&theCoulombBarrier)
+{}
+const G4AlphaEvaporationChannel & G4AlphaEvaporationChannel::operator=(const G4AlphaEvaporationChannel & )
+{
+  throw G4HadronicException(__FILE__, __LINE__, "G4AlphaEvaporationChannel::operator= meant to not be accessable");
+  return *this;
+}
+G4AlphaEvaporationChannel::~G4AlphaEvaporationChannel()
+{}
-G4AlphaEvaporationChannel::G4AlphaEvaporationChannel(const G4AlphaEvaporationChannel & ) : G4EvaporationChannel()
+{
-  throw G4HadronicException(__FILE__, __LINE__, "G4AlphaEvaporationChannel::CopyConstructor meant to not be accessable");
+}
-G4bool G4AlphaEvaporationChannel::operator==(const G4AlphaEvaporationChannel &right ) const
+{
-  return (this == (G4AlphaEvaporationChannel *) &right);
-  //  return false;
+}
-G4bool G4AlphaEvaporationChannel::operator!=(const G4AlphaEvaporationChannel &right ) const
+{
-  return (this != (G4AlphaEvaporationChannel *) &right);
-  //  return true;
+}

trunk/source/processes/hadronic/models/de_excitation/evaporation/src/G4AlphaEvaporationProbability.cc

-              r1315
+              r1347
 // ********************************************************************
 //
+//J.M. Quesada (August2008). Based on:
+// $Id: G4AlphaEvaporationProbability.cc,v 1.18 2010/11/17 11:06:03 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
+//
+// J.M. Quesada (August2008). Based on:
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Oct 1998)
 //
+// Modif (03 September 2008) by J. M. Quesada for external choice of inverse
+// cross section option
+// Modified:
+// 03-09-2008 J.M. Quesada for external choice of inverse cross section option
+// 17-11-2010 V.Ivanchenko integer Z and A
 #include "G4AlphaEvaporationProbability.hh"
 …
 G4AlphaEvaporationProbability::G4AlphaEvaporationProbability() :
     G4EvaporationProbability(4,2,1,&theCoulombBarrier) // A,Z,Gamma,&theCoumlombBarrier
+{
+{}
+G4AlphaEvaporationProbability::~G4AlphaEvaporationProbability()
+{}
+G4double G4AlphaEvaporationProbability::CalcAlphaParam(const G4Fragment & fragment)
+  { return 1.0 + CCoeficient(fragment.GetZ_asInt()-GetZ());}
+}
+G4AlphaEvaporationProbability::G4AlphaEvaporationProbability(const G4AlphaEvaporationProbability &): G4EvaporationProbability()
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4AlphaEvaporationProbability::copy_constructor meant to not be accessable");
+}
+const G4AlphaEvaporationProbability & G4AlphaEvaporationProbability::
+operator=(const G4AlphaEvaporationProbability &)
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4AlphaEvaporationProbability::operator= meant to not be accessable");
+    return *this;
+}
+G4bool G4AlphaEvaporationProbability::operator==(const G4AlphaEvaporationProbability &) const
+{
+    return false;
+}
+G4bool G4AlphaEvaporationProbability::operator!=(const G4AlphaEvaporationProbability &) const
+{
+    return true;
+}
+ G4double G4AlphaEvaporationProbability::CalcAlphaParam(const G4Fragment & fragment)
+  { return 1.0 + CCoeficient(static_cast<G4double>(fragment.GetZ()-GetZ()));}
+G4double G4AlphaEvaporationProbability::CalcBetaParam(const G4Fragment &)
+  { return 0.0; }
+G4double G4AlphaEvaporationProbability::CCoeficient(G4int aZ)
+{
+  // Data comes from
+  // Dostrovsky, Fraenkel and Friedlander
+  // Physical Review, vol 116, num. 3 1959
+  //
+  // const G4int size = 5;
+  // G4double Zlist[5] = { 10.0, 20.0, 30.0, 50.0, 70.0};
+  //    G4double Calpha[5] = { 0.10, 0.10, 0.10, 0.08, 0.06};
+  G4double C = 0.0;
+ G4double G4AlphaEvaporationProbability::CalcBetaParam(const G4Fragment &)
+  { return 0.0; }
+G4double G4AlphaEvaporationProbability::CCoeficient(const G4double aZ)
+{
+    // Data comes from
+    // Dostrovsky, Fraenkel and Friedlander
+    // Physical Review, vol 116, num. 3 1959
+    //
+    // const G4int size = 5;
+    // G4double Zlist[5] = { 10.0, 20.0, 30.0, 50.0, 70.0};
+    //  G4double Calpha[5] = { 0.10, 0.10, 0.10, 0.08, 0.06};
+    G4double C = 0.0;
+    if (aZ <= 30) {
+        C = 0.10;
+    } else if (aZ <= 50) {
+        C = 0.1 + -((aZ-50.)/20.)*0.02;
+    } else if (aZ < 70) {
+        C = 0.08 + -((aZ-70.)/20.)*0.02;
+    } else {
+        C = 0.06;
+    }
+    return C;
+  if (aZ <= 30)
+    {
+      C = 0.10;
+    }
+  else if (aZ <= 50)
+    {
+      C = 0.1 - (aZ-30)*0.001;
+    }
+  else if (aZ < 70)
+    {
+      C = 0.08 - (aZ-50)*0.001;
+    }
+  else
+    {
+      C = 0.06;
+    }
+  return C;
+}
 …
 //OPT=3,4 Kalbach's parameterization
 //
 G4double G4AlphaEvaporationProbability::CrossSection(const  G4Fragment & fragment,
                                                      const  G4double K)
+G4double
+G4AlphaEvaporationProbability::CrossSection(const G4Fragment & fragment, G4double K)
+{
   theA=GetA();
   theZ=GetZ();
+  ResidualA=fragment.GetA()-theA;
+  ResidualZ=fragment.GetZ()-theZ;
+  ResidualAthrd=std::pow(ResidualA,0.33333);
+  FragmentA=fragment.GetA();
+  FragmentAthrd=std::pow(FragmentA,0.33333);
+  ResidualA=fragment.GetA_asInt()-theA;
+  ResidualZ=fragment.GetZ_asInt()-theZ;
+  ResidualAthrd=fG4pow->Z13(ResidualA);
+  FragmentA=fragment.GetA_asInt();
+  FragmentAthrd=fG4pow->Z13(FragmentA);
   if (OPTxs==0) {std::ostringstream errOs;
 …
+}
+//
+//********************* OPT=1,2 : Chatterjee's cross section ************************
+//
+//********************* OPT=1,2 : Chatterjee's cross section ********************
 //(fitting to cross section from Bechetti & Greenles OM potential)
+G4double G4AlphaEvaporationProbability::GetOpt12(const  G4double K)
+{
+// c     ** alpha from huizenga and igo
+G4double G4AlphaEvaporationProbability::GetOpt12(G4double K)
+{
   G4double Kc=K;
   // JMQ xsec is set constat above limit of validity
   if (K>50) Kc=50;
+  // JMQ xsec is set constant above limit of validity
+  if (K > 50*MeV) { Kc = 50*MeV; }
   G4double landa ,mu ,nu ,p , Ec,q,r,ji,xs;
   G4double     p0 = 10.95;
   G4double     p1 = -85.2;
 …
   G4double     delta=1.2;
   Ec = 1.44*theZ*ResidualZ/(1.5*ResidualAthrd+delta);
   p = p0 + p1/Ec + p2/(Ec*Ec);
   landa = landa0*ResidualA + landa1;
+  mu = mu0*std::pow(ResidualA,mu1);
+  nu = std::pow(ResidualA,mu1)*(nu0 + nu1*Ec + nu2*(Ec*Ec));
+  G4double resmu1 = fG4pow->powZ(ResidualA,mu1);
+  mu = mu0*resmu1;
+  nu = resmu1*(nu0 + nu1*Ec + nu2*(Ec*Ec));
   q = landa - nu/(Ec*Ec) - 2*p*Ec;
   r = mu + 2*nu/Ec + p*(Ec*Ec);
   ji=std::max(Kc,Ec);
   if(Kc < Ec) { xs = p*Kc*Kc + q*Kc + r;}
   else {xs = p*(Kc - ji)*(Kc - ji) + landa*Kc + mu + nu*(2 - Kc/ji)/ji ;}
   if (xs <0.0) {xs=0.0;}
   return xs;
+}
 // *********** OPT=3,4 : Kalbach's cross sections (from PRECO code)*************
 G4double G4AlphaEvaporationProbability::GetOpt34(const  G4double K)
+G4double G4AlphaEvaporationProbability::GetOpt34(G4double K)
 // c     ** alpha from huizenga and igo
+{
   G4double landa, mu, nu, p , signor(1.),sig;
   G4double ec,ecsq,xnulam,etest(0.),a;
   G4double b,ecut,cut,ecut2,geom,elab;
   G4double     flow = 1.e-18;
   G4double     spill= 1.e+18;
   G4double       p0 = 10.95;
+  G4double     p0 = 10.95;
   G4double     p1 = -85.2;
   G4double     p2 = 1146.;
 …
   G4double      ra=1.20;
   //JMQ 13/02/09 increase of reduced radius to lower the barrier
   // ec = 1.44 * theZ * ResidualZ / (1.5*ResidualAthrd+ra);
 …
   p = p0 + p1/ec + p2/ecsq;
   landa = landa0*ResidualA + landa1;
   a = std::pow(ResidualA,mu1);
+  a = fG4pow->powZ(ResidualA,mu1);
   mu = mu0 * a;
   nu = a* (nu0+nu1*ec+nu2*ecsq);
   xnulam = nu / landa;
   if (xnulam > spill) xnulam=0.;
   if (xnulam >= flow) etest = 1.2 *std::sqrt(xnulam);
+  if (xnulam > spill) { xnulam=0.; }
+  if (xnulam >= flow) { etest = 1.2 *std::sqrt(xnulam); }
   a = -2.*p*ec + landa - nu/ecsq;
   b = p*ecsq + mu + 2.*nu/ec;
   ecut = 0.;
   cut = a*a - 4.*p*b;
   if (cut > 0.) ecut = std::sqrt(cut);
+  if (cut > 0.) { ecut = std::sqrt(cut); }
   ecut = (ecut-a) / (p+p);
   ecut2 = ecut;
+//JMQ 290310 for avoiding unphysical increase below minimum (at ecut)
+//ecut<0 means that there is no cut with energy axis, i.e. xs is set to 0 bellow minimum
+//  if (cut < 0.) ecut2 = ecut - 2.;
+  if (cut < 0.) ecut2 = ecut;
+  elab = K * FragmentA / ResidualA;
+  //JMQ 290310 for avoiding unphysical increase below minimum (at ecut)
+  // ecut<0 means that there is no cut with energy axis, i.e. xs is set
+  // to 0 bellow minimum
+  //  if (cut < 0.) ecut2 = ecut - 2.;
+  if (cut < 0.) { ecut2 = ecut; }
+  elab = K * FragmentA / G4double(ResidualA);
   sig = 0.;
   if (elab <= ec) { //start for E<Ec
     if (elab > ecut2)  sig = (p*elab*elab+a*elab+b) * signor;
+    if (elab > ecut2) { sig = (p*elab*elab+a*elab+b) * signor; }
   }           //end for E<Ec
   else {           //start for E>Ec
     sig = (landa*elab+mu+nu/elab) * signor;
     geom = 0.;
     if (xnulam < flow || elab < etest) return sig;
+    if (xnulam < flow || elab < etest) { return sig; }
     geom = std::sqrt(theA*K);
     geom = 1.23*ResidualAthrd + ra + 4.573/geom;
 …
   }           //end for E>Ec
   return sig;
+}
+//   ************************** end of cross sections *******************************
+}

trunk/source/processes/hadronic/models/de_excitation/evaporation/src/G4DeuteronEvaporationChannel.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4DeuteronEvaporationChannel.cc,v 1.4 2006/06/29 20:10:21 gunter Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4DeuteronEvaporationChannel.cc,v 1.5 2010/11/17 12:14:59 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Nov. 1999)
 //
+// 17-11-2010 V.Ivanchenko moved constructor and destructor to source and cleanup
 #include "G4DeuteronEvaporationChannel.hh"
+G4DeuteronEvaporationChannel::G4DeuteronEvaporationChannel()
+: G4EvaporationChannel(2,1,"deuteron",&theEvaporationProbability,&theCoulombBarrier)
+{}
+const G4DeuteronEvaporationChannel & G4DeuteronEvaporationChannel::operator=(const G4DeuteronEvaporationChannel & )
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4DeuteronEvaporationChannel::operator= meant to not be accessable");
+    return *this;
+}
+G4DeuteronEvaporationChannel::~G4DeuteronEvaporationChannel()
+{}
-G4DeuteronEvaporationChannel::G4DeuteronEvaporationChannel(const G4DeuteronEvaporationChannel & ) : G4EvaporationChannel()
+{
-    throw G4HadronicException(__FILE__, __LINE__, "G4DeuteronEvaporationChannel::CopyConstructor meant to not be accessable");
+}
-G4bool G4DeuteronEvaporationChannel::operator==(const G4DeuteronEvaporationChannel & right) const
+{
-    return (this == (G4DeuteronEvaporationChannel *) &right);
-    //  return false;
+}
-G4bool G4DeuteronEvaporationChannel::operator!=(const G4DeuteronEvaporationChannel & right) const
+{
-    return (this != (G4DeuteronEvaporationChannel *) &right);
-    //  return true;
+}

trunk/source/processes/hadronic/models/de_excitation/evaporation/src/G4DeuteronEvaporationProbability.cc

-              r1315
+              r1347
 // ********************************************************************
 //
+//J.M. Quesada (August2008). Based on:
+// $Id: G4DeuteronEvaporationProbability.cc,v 1.20 2010/11/17 11:06:03 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
+//
+// J.M. Quesada (August2008). Based on:
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Oct 1998)
 //
+// Modif (03 September 2008) by J. M. Quesada for external choice of inverse
+// cross section option
+// Modified:
+// 03-09-2008 J.M. Quesada for external choice of inverse cross section option
+// 17-11-2010 V.Ivanchenko integer Z and A
 …
 G4DeuteronEvaporationProbability::G4DeuteronEvaporationProbability() :
     G4EvaporationProbability(2,1,3,&theCoulombBarrier) // A,Z,Gamma (fixed JMQ)
+{       }
+G4DeuteronEvaporationProbability::G4DeuteronEvaporationProbability(const G4DeuteronEvaporationProbability &) : G4EvaporationProbability()
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4DeuteronEvaporationProbability::copy_constructor meant to not be accessable");
+}
+const G4DeuteronEvaporationProbability & G4DeuteronEvaporationProbability::
+operator=(const G4DeuteronEvaporationProbability &)
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4DeuteronEvaporationProbability::operator= meant to not be accessable");
+    return *this;
+}
+G4bool G4DeuteronEvaporationProbability::operator==(const G4DeuteronEvaporationProbability &) const
+{
+    return false;
+}
+G4bool G4DeuteronEvaporationProbability::operator!=(const G4DeuteronEvaporationProbability &) const
+{
+    return true;
+}
+{}
+G4DeuteronEvaporationProbability::~G4DeuteronEvaporationProbability()
+{}
 G4double G4DeuteronEvaporationProbability::CalcAlphaParam(const G4Fragment & fragment)
+{
+    return 1.0 + CCoeficient(static_cast<G4double>(fragment.GetZ()-GetZ()));
+}
+  return 1.0 + CCoeficient(fragment.GetZ_asInt()-GetZ());
+}
 G4double G4DeuteronEvaporationProbability::CalcBetaParam(const G4Fragment & )
+{
+    return 0.0;
+}
+G4double G4DeuteronEvaporationProbability::CCoeficient(const G4double aZ)
+{
+    // Data comes from
+    // Dostrovsky, Fraenkel and Friedlander
+    // Physical Review, vol 116, num. 3 1959
+    //
+    // const G4int size = 5;
+    // G4double Zlist[5] = { 10.0, 20.0, 30.0, 50.0, 70.0};
+    // G4double Cp[5] = { 0.50, 0.28, 0.20, 0.15, 0.10};
+    // C for deuteron is equal to C for protons divided by 2
+    G4double C = 0.0;
+  return 0.0;
+}
+G4double G4DeuteronEvaporationProbability::CCoeficient(G4int aZ)
+{
+  // Data comes from
+  // Dostrovsky, Fraenkel and Friedlander
+  // Physical Review, vol 116, num. 3 1959
+  //
+  // const G4int size = 5;
+  // G4double Zlist[5] = { 10.0, 20.0, 30.0, 50.0, 70.0};
+  // G4double Cp[5] = { 0.50, 0.28, 0.20, 0.15, 0.10};
+  // C for deuteron is equal to C for protons divided by 2
+  G4double C = 0.0;
     if (aZ >= 70) {
         C = 0.10;
     } else {
         C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375;
+    }
+  if (aZ >= 70) {
+    C = 0.10;
+  } else {
+    C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375;
+  }
     return C/2.0;
+  return C/2.0;
+}
 …
 //OPT=3,4 Kalbach's parameterization
 //
+G4double G4DeuteronEvaporationProbability::CrossSection(const  G4Fragment & fragment, const  G4double K)
+{
+       theA=GetA();
+       theZ=GetZ();
+       ResidualA=fragment.GetA()-theA;
+       ResidualZ=fragment.GetZ()-theZ;
+G4double
+G4DeuteronEvaporationProbability::CrossSection(const  G4Fragment & fragment, G4double K)
+{
+  theA=GetA();
+  theZ=GetZ();
+  ResidualA=fragment.GetA_asInt()-theA;
+  ResidualZ=fragment.GetZ_asInt()-theZ;
+  ResidualAthrd=fG4pow->Z13(ResidualA);
+  FragmentA=fragment.GetA_asInt();
+  FragmentAthrd=fG4pow->Z13(FragmentA);
+  if (OPTxs==0) {std::ostringstream errOs;
+  errOs << "We should'n be here (OPT =0) at evaporation cross section calculation (deuterons)!!"
+        <<G4endl;
+  throw G4HadronicException(__FILE__, __LINE__, errOs.str());
+  return 0.;}
+  if( OPTxs==1 || OPTxs==2) return G4DeuteronEvaporationProbability::GetOpt12( K);
+  else if (OPTxs==3 || OPTxs==4)  return G4DeuteronEvaporationProbability::GetOpt34( K);
+  else{
+    std::ostringstream errOs;
+    errOs << "BAD Deuteron CROSS SECTION OPTION AT EVAPORATION!!"  <<G4endl;
+    throw G4HadronicException(__FILE__, __LINE__, errOs.str());
+    return 0.;
+  }
+}
+//
+//********************* OPT=1,2 : Chatterjee's cross section ********************
+//(fitting to cross section from Bechetti & Greenles OM potential)
+G4double G4DeuteronEvaporationProbability::GetOpt12(G4double K)
+{
+  G4double Kc = K;
+  // JMQ xsec is set constat above limit of validity
+  if (K > 50*MeV) { Kc = 50*MeV; }
+  G4double landa ,mu ,nu ,p , Ec,q,r,ji,xs;
+       ResidualAthrd=std::pow(ResidualA,0.33333);
+       FragmentA=fragment.GetA();
+       FragmentAthrd=std::pow(FragmentA,0.33333);
+       if (OPTxs==0) {std::ostringstream errOs;
+         errOs << "We should'n be here (OPT =0) at evaporation cross section calculation (deuterons)!!"  <<G4endl;
+         throw G4HadronicException(__FILE__, __LINE__, errOs.str());
+         return 0.;}
+       if( OPTxs==1 || OPTxs==2) return G4DeuteronEvaporationProbability::GetOpt12( K);
+       else if (OPTxs==3 || OPTxs==4)  return G4DeuteronEvaporationProbability::GetOpt34( K);
+       else{
+         std::ostringstream errOs;
+         errOs << "BAD Deuteron CROSS SECTION OPTION AT EVAPORATION!!"  <<G4endl;
+         throw G4HadronicException(__FILE__, __LINE__, errOs.str());
+         return 0.;
+       }
+}
+//********************* OPT=1,2 : Chatterjee's cross section ************************
+//(fitting to cross section from Bechetti & Greenles OM potential)
+G4double G4DeuteronEvaporationProbability::GetOpt12(const  G4double K)
+{
+  G4double Kc=K;
+// JMQ xsec is set constat above limit of validity
+ if (K>50) Kc=50;
+ G4double landa ,mu ,nu ,p , Ec,q,r,ji,xs;
+ G4double    p0 = -38.21;
+ G4double    p1 = 922.6;
+ G4double    p2 = -2804.;
+ G4double    landa0 = -0.0323;
+ G4double    landa1 = -5.48;
+ G4double    mu0 = 336.1;
+ G4double    mu1 = 0.48;
+ G4double    nu0 = 524.3;
+ G4double    nu1 = -371.8;
+ G4double    nu2 = -5.924;
+ G4double    delta=1.2;
+ Ec = 1.44*theZ*ResidualZ/(1.5*ResidualAthrd+delta);
+ p = p0 + p1/Ec + p2/(Ec*Ec);
+ landa = landa0*ResidualA + landa1;
+ mu = mu0*std::pow(ResidualA,mu1);
+ nu = std::pow(ResidualA,mu1)*(nu0 + nu1*Ec + nu2*(Ec*Ec));
+ q = landa - nu/(Ec*Ec) - 2*p*Ec;
+ r = mu + 2*nu/Ec + p*(Ec*Ec);
+ ji=std::max(Kc,Ec);
+ if(Kc < Ec) { xs = p*Kc*Kc + q*Kc + r;}
+ else {xs = p*(Kc - ji)*(Kc - ji) + landa*Kc + mu + nu*(2 - Kc/ji)/ji ;}
+  G4double    p0 = -38.21;
+  G4double    p1 = 922.6;
+  G4double    p2 = -2804.;
+  G4double    landa0 = -0.0323;
+  G4double    landa1 = -5.48;
+  G4double    mu0 = 336.1;
+  G4double    mu1 = 0.48;
+  G4double    nu0 = 524.3;
+  G4double    nu1 = -371.8;
+  G4double    nu2 = -5.924;
+  G4double    delta=1.2;
+  Ec = 1.44*theZ*ResidualZ/(1.5*ResidualAthrd+delta);
+  p = p0 + p1/Ec + p2/(Ec*Ec);
+  landa = landa0*ResidualA + landa1;
+  G4double resmu1 = fG4pow->powZ(ResidualA,mu1);
+  mu = mu0*resmu1;
+  nu = resmu1*(nu0 + nu1*Ec + nu2*(Ec*Ec));
+  q = landa - nu/(Ec*Ec) - 2*p*Ec;
+  r = mu + 2*nu/Ec + p*(Ec*Ec);
+  ji=std::max(Kc,Ec);
+  if(Kc < Ec) { xs = p*Kc*Kc + q*Kc + r;}
+  else {xs = p*(Kc - ji)*(Kc - ji) + landa*Kc + mu + nu*(2 - Kc/ji)/ji ;}
+ if (xs <0.0) {xs=0.0;}
+ return xs;
+}
+  if (xs <0.0) {xs=0.0;}
+  return xs;
+}
 // *********** OPT=3,4 : Kalbach's cross sections (from PRECO code)*************
 G4double G4DeuteronEvaporationProbability::GetOpt34(const  G4double K)
+G4double G4DeuteronEvaporationProbability::GetOpt34(G4double K)
 //     ** d from o.m. of perey and perey
+{
   G4double landa, mu, nu, p , signor(1.),sig;
+  G4double landa, mu, nu, p ,signor(1.),sig;
   G4double ec,ecsq,xnulam,etest(0.),a;
   G4double b,ecut,cut,ecut2,geom,elab;
   G4double     flow = 1.e-18;
   G4double     spill= 1.e+18;
   G4double     p0 = 0.798;
 …
   G4double     nu1 = -474.5;
   G4double     nu2 = -3.592;
   G4double      ra=0.80;
+  G4double     ra=0.80;
   //JMQ 13/02/09 increase of reduced radius to lower the barrier
+  //  ec = 1.44 * theZ * ResidualZ / (1.5*ResidualAthrd+ra);
+   ec = 1.44 * theZ * ResidualZ / (1.7*ResidualAthrd+ra);
+  // ec = 1.44 * theZ * ResidualZ / (1.5*ResidualAthrd+ra);
+  ec = 1.44 * theZ * ResidualZ / (1.7*ResidualAthrd+ra);
   ecsq = ec * ec;
   p = p0 + p1/ec + p2/ecsq;
   landa = landa0*ResidualA + landa1;
   a = std::pow(ResidualA,mu1);
+  a = fG4pow->powZ(ResidualA,mu1);
   mu = mu0 * a;
   nu = a* (nu0+nu1*ec+nu2*ecsq);
   xnulam = nu / landa;
   if (xnulam > spill) xnulam=0.;
   if (xnulam >= flow) etest = 1.2 *std::sqrt(xnulam);
+  if (xnulam > spill) { xnulam=0.; }
+  if (xnulam >= flow) { etest = 1.2 *std::sqrt(xnulam); }
   a = -2.*p*ec + landa - nu/ecsq;
 …
   ecut = 0.;
   cut = a*a - 4.*p*b;
   if (cut > 0.) ecut = std::sqrt(cut);
+  if (cut > 0.) { ecut = std::sqrt(cut); }
   ecut = (ecut-a) / (p+p);
   ecut2 = ecut;
+//JMQ 290310 for avoiding unphysical increase below minimum (at ecut)
+//ecut<0 means that there is no cut with energy axis, i.e. xs is set to 0 bellow minimum
+//  if (cut < 0.) ecut2 = ecut - 2.;
+  if (cut < 0.) ecut2 = ecut;
+  elab = K * FragmentA / ResidualA;
+  //JMQ 290310 for avoiding unphysical increase below minimum (at ecut)
+  //ecut<0 means that there is no cut with energy axis, i.e. xs is set
+  //to 0 bellow minimum
+  //  if (cut < 0.) ecut2 = ecut - 2.;
+  if (cut < 0.) { ecut2 = ecut; }
+  elab = K * FragmentA / G4double(ResidualA);
   sig = 0.;
   if (elab <= ec) { //start for E<Ec
     if (elab > ecut2)  sig = (p*elab*elab+a*elab+b) * signor;
+    if (elab > ecut2) { sig = (p*elab*elab+a*elab+b) * signor; }
   }           //end for E<Ec
   else {           //start for E>Ec
     sig = (landa*elab+mu+nu/elab) * signor;
     geom = 0.;
     if (xnulam < flow || elab < etest) return sig;
+    if (xnulam < flow || elab < etest) { return sig; }
     geom = std::sqrt(theA*K);
     geom = 1.23*ResidualAthrd + ra + 4.573/geom;
 …
   }           //end for E>Ec
   return sig;
+}
+//   ************************** end of cross sections *******************************
+}

trunk/source/processes/hadronic/models/de_excitation/evaporation/src/G4Evaporation.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4Evaporation.cc,v 1.25 2010/06/09 11:56:47 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4Evaporation.cc,v 1.26 2010/11/23 18:10:10 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
     G4int Z = theResidualNucleus->GetZ_asInt();
     G4double abun = nist->GetIsotopeAbundance(Z, A);
     /*
     G4cout << "### G4Evaporation::BreakItUp step " << ia << " Z= " << Z
            << " A= " << A << " Eex(MeV)= "
            << theResidualNucleus->GetExcitationEnergy()
            << " aban= " << abun << G4endl;
     */
+    // G4cout << "### G4Evaporation::BreakItUp step " << ia << " Z= " << Z
+    //     << " A= " << A << " Eex(MeV)= "
+    //     << theResidualNucleus->GetExcitationEnergy()
+    //     << " aban= " << abun << G4endl;
     if(theResidualNucleus->GetExcitationEnergy() <= minExcitation &&
        (abun > 0.0))
 …
     // do evaporation chain and reset total probability
     if(0.0 < totprob && probabilities[0] == totprob) {
+      //G4cout << "Start gamma evaporation" << G4endl;
       theTempResult = (*theChannels)[0]->BreakUpFragment(theResidualNucleus);
       if(theTempResult) {
 …
     // single photon evaporation, primary pointer is kept
     if(0 == i) {
+      //G4cout << "Single gamma" << G4endl;
       G4Fragment* gamma = (*theChannels)[0]->EmittedFragment(theResidualNucleus);
       if(gamma) { theResult->push_back(gamma); }
 …
       // fission, return results to the main loop if fission is succesful
     } else if(1 == i) {
+      //G4cout << "Fission" << G4endl;
       theTempResult = (*theChannels)[1]->BreakUp(*theResidualNucleus);
       if(theTempResult) {
 …
       // other channels
     } else {
+      //G4cout << "Channel # " << i << G4endl;
       theTempResult = (*theChannels)[i]->BreakUp(*theResidualNucleus);
       if(theTempResult) {

trunk/source/processes/hadronic/models/de_excitation/evaporation/src/G4EvaporationChannel.cc

-              r962
+              r1347
 // ********************************************************************
 //
+// $Id: G4EvaporationChannel.cc,v 1.19 2010/11/24 15:30:49 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //J.M. Quesada (August2008). Based on:
 …
 // by V. Lara (Oct 1998)
 //
+// Modif (03 September 2008) by J. M. Quesada for external choice of inverse
+// cross section option
+// JMQ (06 September 2008) Also external choices have been added for
+// superimposed Coulomb barrier (if useSICB is set true, by default is false)
+// Modified:
+// 03-09-2008 J.M. Quesada for external choice of inverse cross section option
+// 06-09-2008 J.M. Quesada Also external choices have been added for superimposed
+//                 Coulomb barrier (if useSICB is set true, by default is false)
+// 17-11-2010 V.Ivanchenko in constructor replace G4VEmissionProbability by
+//            G4EvaporationProbability and do not new and delete probability
+//            object at each call; use G4Pow
 #include "G4EvaporationChannel.hh"
 #include "G4PairingCorrection.hh"
+G4EvaporationChannel::G4EvaporationChannel(const G4int anA, const G4int aZ, const G4String & aName,
+                                           G4VEmissionProbability * aEmissionStrategy,
+                                           G4VCoulombBarrier * aCoulombBarrier):
+#include "G4NucleiProperties.hh"
+#include "G4Pow.hh"
+#include "G4EvaporationLevelDensityParameter.hh"
+#include "Randomize.hh"
+#include "G4Alpha.hh"
+G4EvaporationChannel::G4EvaporationChannel(G4int anA, G4int aZ,
+                                           const G4String & aName,
+                                           G4EvaporationProbability* aEmissionStrategy,
+                                           G4VCoulombBarrier* aCoulombBarrier):
     G4VEvaporationChannel(aName),
     theA(anA),
 …
     MaximalKineticEnergy(-1000.0)
+{
+    theLevelDensityPtr = new G4EvaporationLevelDensityParameter;
+//    MyOwnLevelDensity = true;
+  ResidualA = 0;
+  ResidualZ = 0;
+  ResidualMass = CoulombBarrier=0.0;
+  EvaporatedMass = G4NucleiProperties::GetNuclearMass(theA, theZ);
+  theLevelDensityPtr = new G4EvaporationLevelDensityParameter;
+}
+G4EvaporationChannel::G4EvaporationChannel():
+    G4VEvaporationChannel(""),
+    theA(0),
+    theZ(0),
+    theEvaporationProbabilityPtr(0),
+    theCoulombBarrierPtr(0),
+    EmissionProbability(0.0),
+    MaximalKineticEnergy(-1000.0)
+{
+  ResidualA = 0;
+  ResidualZ = 0;
+  EvaporatedMass = ResidualMass = CoulombBarrier = 0.0;
+  theLevelDensityPtr = new G4EvaporationLevelDensityParameter;
+}
 …
   delete theLevelDensityPtr;
+}
-G4EvaporationChannel::G4EvaporationChannel(const G4EvaporationChannel & ) : G4VEvaporationChannel()
+{
-    throw G4HadronicException(__FILE__, __LINE__, "G4EvaporationChannel::copy_costructor meant to not be accessable");
+}
-const G4EvaporationChannel & G4EvaporationChannel::operator=(const G4EvaporationChannel & )
+{
-    throw G4HadronicException(__FILE__, __LINE__, "G4EvaporationChannel::operator= meant to not be accessable");
-    return *this;
+}
-G4bool G4EvaporationChannel::operator==(const G4EvaporationChannel & right) const
+{
-    return (this == (G4EvaporationChannel *) &right);
-    //  return false;
+}
-G4bool G4EvaporationChannel::operator!=(const G4EvaporationChannel & right) const
+{
-    return (this != (G4EvaporationChannel *) &right);
-    //  return true;
+}
-//void G4EvaporationChannel::SetLevelDensityParameter(G4VLevelDensityParameter * aLevelDensity)
-//  {
-//    if (MyOwnLevelDensity) delete theLevelDensityPtr;
-//    theLevelDensityPtr = aLevelDensity;
-//    MyOwnLevelDensity = false;
-//  }
 void G4EvaporationChannel::Initialize(const G4Fragment & fragment)
 …
   theEvaporationProbabilityPtr->UseSICB(useSICB);
+  G4int FragmentA = static_cast<G4int>(fragment.GetA());
+  G4int FragmentZ = static_cast<G4int>(fragment.GetZ());
+  G4int FragmentA = fragment.GetA_asInt();
+  G4int FragmentZ = fragment.GetZ_asInt();
   ResidualA = FragmentA - theA;
   ResidualZ = FragmentZ - theZ;
+  //G4cout << "G4EvaporationChannel::Initialize Z= " << theZ << " A= " << theA
+  //     << " FragZ= " << FragmentZ << " FragA= " << FragmentA << G4endl;
   //Effective excitation energy
 …
     G4PairingCorrection::GetInstance()->GetPairingCorrection(FragmentA,FragmentZ);
   // Only channels which are physically allowed are taken into account
   if (ResidualA <= 0 || ResidualZ <= 0 || ResidualA < ResidualZ ||
       (ResidualA == ResidualZ && ResidualA > 1) || ExEnergy <= 0.0) {
     CoulombBarrier=0.0;
+    CoulombBarrier = ResidualMass = 0.0;
     MaximalKineticEnergy = -1000.0*MeV;
     EmissionProbability = 0.0;
   } else {
+    ResidualMass = G4NucleiProperties::GetNuclearMass(ResidualA, ResidualZ);
+    G4double FragmentMass = fragment.GetGroundStateMass();
     CoulombBarrier = theCoulombBarrierPtr->GetCoulombBarrier(ResidualA,ResidualZ,ExEnergy);
     // Maximal Kinetic Energy
     MaximalKineticEnergy = CalcMaximalKineticEnergy
       (G4ParticleTable::GetParticleTable()->
        GetIonTable()->GetNucleusMass(FragmentZ,FragmentA)+ExEnergy);
+    MaximalKineticEnergy = CalcMaximalKineticEnergy(FragmentMass + ExEnergy);
+    //MaximalKineticEnergy = ExEnergy + fragment.GetGroundStateMass()
+    //  - EvaporatedMass - ResidualMass;
     // Emission probability
 …
       limit= CoulombBarrier;
     else limit=0.;
+    limit = std::max(limit, FragmentMass - ResidualMass - EvaporatedMass);
     // The threshold for charged particle emission must be  set to 0 if Coulomb
     //cutoff  is included in the cross sections
-    //if (MaximalKineticEnergy <= 0.0) EmissionProbability = 0.0;
     if (MaximalKineticEnergy <= limit) EmissionProbability = 0.0;
     else {
 …
+    }
+  }
+  //G4cout << "G4EvaporationChannel:: probability= " << EmissionProbability << G4endl;
   return;
 …
 G4FragmentVector * G4EvaporationChannel::BreakUp(const G4Fragment & theNucleus)
+{
+  G4double EvaporatedKineticEnergy=GetKineticEnergy(theNucleus);
+  G4double EvaporatedMass = G4ParticleTable::GetParticleTable()->GetIonTable()->
+    GetIonMass(theZ,theA);
+  G4double EvaporatedEnergy = EvaporatedKineticEnergy + EvaporatedMass;
+  /*
+  G4double Ecm = GetKineticEnergy(theNucleus) + ResidualMass + EvaporatedMass;
+  G4double EvaporatedEnergy =
+    ((Ecm-ResidualMass)*(Ecm+ResidualMass) + EvaporatedMass*EvaporatedMass)/(2*Ecm);
+  */
+  G4double EvaporatedEnergy = GetKineticEnergy(theNucleus) + EvaporatedMass;
   G4ThreeVector momentum(IsotropicVector
+                         (std::sqrt(EvaporatedKineticEnergy*
+                                    (EvaporatedKineticEnergy+2.0*EvaporatedMass))));
+  momentum.rotateUz(theNucleus.GetMomentum().vect().unit());
+                         (std::sqrt((EvaporatedEnergy - EvaporatedMass)*
+                                    (EvaporatedEnergy + EvaporatedMass))));
   G4LorentzVector EvaporatedMomentum(momentum,EvaporatedEnergy);
+  EvaporatedMomentum.boost(theNucleus.GetMomentum().boostVector());
+  G4LorentzVector ResidualMomentum = theNucleus.GetMomentum();
+  EvaporatedMomentum.boost(ResidualMomentum.boostVector());
   G4Fragment * EvaporatedFragment = new G4Fragment(theA,theZ,EvaporatedMomentum);
+#ifdef PRECOMPOUND_TEST
+  EvaporatedFragment->SetCreatorModel(G4String("G4Evaporation"));
+#endif
+  // ** And now the residual nucleus **
+  G4double theExEnergy = theNucleus.GetExcitationEnergy();
+  G4double theMass = G4ParticleTable::GetParticleTable()->GetIonTable()->
+    GetNucleusMass(static_cast<G4int>(theNucleus.GetZ()),
+                   static_cast<G4int>(theNucleus.GetA()));
+  G4double ResidualEnergy = theMass +
+    (theExEnergy - EvaporatedKineticEnergy) - EvaporatedMass;
+  G4LorentzVector ResidualMomentum(-momentum,ResidualEnergy);
+  ResidualMomentum.boost(theNucleus.GetMomentum().boostVector());
+  G4Fragment * ResidualFragment = new G4Fragment(ResidualA, ResidualZ, ResidualMomentum );
+#ifdef PRECOMPOUND_TEST
+  ResidualFragment->SetCreatorModel(G4String("ResidualNucleus"));
+#endif
+  ResidualMomentum -= EvaporatedMomentum;
+  G4Fragment * ResidualFragment = new G4Fragment(ResidualA, ResidualZ, ResidualMomentum);
   G4FragmentVector * theResult = new G4FragmentVector;
 …
 /////////////////////////////////////////
 // Calculates the maximal kinetic energy that can be carried by fragment.
+G4double G4EvaporationChannel::CalcMaximalKineticEnergy(const G4double NucleusTotalE)
+{
+  G4double ResidualMass = G4ParticleTable::GetParticleTable()->
+    GetIonTable()->GetNucleusMass( ResidualZ, ResidualA );
+  G4double EvaporatedMass = G4ParticleTable::GetParticleTable()->
+    GetIonTable()->GetNucleusMass( theZ, theA );
+G4double G4EvaporationChannel::CalcMaximalKineticEnergy(G4double NucleusTotalE)
+{
   // This is the "true" assimptotic kinetic energy (from energy conservation)
+  G4double Tmax = (NucleusTotalE*NucleusTotalE + EvaporatedMass*EvaporatedMass -
+                   ResidualMass*ResidualMass)/(2.0*NucleusTotalE) - EvaporatedMass;
+  G4double Tmax =
+    ((NucleusTotalE-ResidualMass)*(NucleusTotalE+ResidualMass) + EvaporatedMass*EvaporatedMass)
+    /(2.0*NucleusTotalE) - EvaporatedMass;
   //JMQ (13-09-08) bug fixed: in the original version the Tmax is calculated
 …
     if (MaximalKineticEnergy < 0.0)
+    if (MaximalKineticEnergy < 0.0) {
       throw G4HadronicException(__FILE__, __LINE__,
                                 "G4EvaporationChannel::CalcKineticEnergy: maximal kinetic at the Coulomb barrier is less than 0");
+    }
     G4double Rb = 4.0*theLevelDensityPtr->
       LevelDensityParameter(ResidualA+theA,ResidualZ+theZ,MaximalKineticEnergy)*
 …
       G4double Q2 = 1.0;
       if (theZ == 0) { // for emitted neutron
         G4double Beta = (2.12/std::pow(G4double(ResidualA),2./3.) - 0.05)*MeV/
           (0.76 + 2.2/std::pow(G4double(ResidualA),1./3.));
+        G4double Beta = (2.12/G4Pow::GetInstance()->Z23(ResidualA) - 0.05)*MeV/
+          (0.76 + 2.2/G4Pow::GetInstance()->Z13(ResidualA));
         Q1 = 1.0 + Beta/(MaximalKineticEnergy);
         Q2 = Q1*std::sqrt(Q1);
 …
   } else if (OPTxs==1 || OPTxs==2 || OPTxs==3 || OPTxs==4) {
     G4double V;
     if(useSICB) V= CoulombBarrier;
     else V=0.;
+    //If Coulomb barrier is just included  in the cross sections
     //  G4double V=0.;
+    // Coulomb barrier is just included  in the cross sections
+    G4double V = 0;
+    if(useSICB) { V= CoulombBarrier; }
+    V = std::max(V, aFragment.GetGroundStateMass()-EvaporatedMass-ResidualMass);
     G4double Tmax=MaximalKineticEnergy;
     G4double T(0.0);
     G4double NormalizedProbability(1.0);
+    // VI: This is very ineffective - create new objects at each call to the method
+    /*
     // A pointer is created in order to access the distribution function.
     G4EvaporationProbability * G4EPtemp;
+    G4EvaporationProbability * G4EPtemp = 0;
     if (theA==1 && theZ==0) G4EPtemp=new G4NeutronEvaporationProbability();
 …
       G4EPtemp->SetOPTxs(OPTxs);
       G4EPtemp->UseSICB(useSICB);
+    */
+    // use local pointer and not create a new one
     do
+      {
         T=V+G4UniformRand()*(Tmax-V);
+        NormalizedProbability=G4EPtemp->ProbabilityDistributionFunction(aFragment,T)/
+          (this->GetEmissionProbability());
+        NormalizedProbability =
+          theEvaporationProbabilityPtr->ProbabilityDistributionFunction(aFragment,T)/
+          GetEmissionProbability();
+      }
     while (G4UniformRand() > NormalizedProbability);
    delete G4EPtemp;
    return T;
+    //   delete G4EPtemp;
+    return T;
   } else{
     std::ostringstream errOs;
 …
+}
 G4ThreeVector G4EvaporationChannel::IsotropicVector(const G4double Magnitude)
+G4ThreeVector G4EvaporationChannel::IsotropicVector(G4double Magnitude)
     // Samples a isotropic random vectorwith a magnitud given by Magnitude.
     // By default Magnitude = 1.0
+{
     G4double CosTheta = 1.0 - 2.0*G4UniformRand();
     G4double SinTheta = std::sqrt(1.0 - CosTheta*CosTheta);
     G4double Phi = twopi*G4UniformRand();
     G4ThreeVector Vector(Magnitude*std::cos(Phi)*SinTheta,
                          Magnitude*std::sin(Phi)*SinTheta,
                          Magnitude*CosTheta);
     return Vector;
+            }
+  G4double CosTheta = 1.0 - 2.0*G4UniformRand();
+  G4double SinTheta = std::sqrt(1.0 - CosTheta*CosTheta);
+  G4double Phi = twopi*G4UniformRand();
+  G4ThreeVector Vector(Magnitude*std::cos(Phi)*SinTheta,
+                       Magnitude*std::sin(Phi)*SinTheta,
+                       Magnitude*CosTheta);
+  return Vector;
+}

trunk/source/processes/hadronic/models/de_excitation/evaporation/src/G4EvaporationDefaultGEMFactory.cc

r1340	r1347
26	26	//
27	27	// $Id: G4EvaporationDefaultGEMFactory.cc,v 1.2 2010/04/27 11:43:16 vnivanch Exp $
28		// GEANT4 tag $Name: geant4-09-0~~3-ref-09~~ $
	28	// GEANT4 tag $Name: geant4-09-04-ref-00 $
29	29	//
30	30	// Hadronic Process: Nuclear De-excitations

trunk/source/processes/hadronic/models/de_excitation/evaporation/src/G4EvaporationFactory.cc

r1340	r1347
26	26	//
27	27	// $Id: G4EvaporationFactory.cc,v 1.5 2010/04/27 11:43:16 vnivanch Exp $
28		// GEANT4 tag $Name: geant4-09-0~~3-ref-09~~ $
	28	// GEANT4 tag $Name: geant4-09-04-ref-00 $
29	29	//
30	30	// Hadronic Process: Nuclear De-excitations

trunk/source/processes/hadronic/models/de_excitation/evaporation/src/G4EvaporationProbability.cc

-              r1315
+              r1347
 #include "G4IonTable.hh"
+G4EvaporationProbability::G4EvaporationProbability(const G4EvaporationProbability &) : G4VEmissionProbability()
+G4EvaporationProbability::G4EvaporationProbability(G4int anA, G4int aZ,
+                                                   G4double aGamma,
+                                                   G4VCoulombBarrier * aCoulombBarrier)
+  : theA(anA),
+    theZ(aZ),
+    Gamma(aGamma),
+    theCoulombBarrierptr(aCoulombBarrier)
+{}
+G4EvaporationProbability::G4EvaporationProbability()
+  : theA(0),
+    theZ(0),
+    Gamma(0.0),
+    theCoulombBarrierptr(0)
+{}
+G4EvaporationProbability::~G4EvaporationProbability()
+{}
+G4double
+G4EvaporationProbability::EmissionProbability(const G4Fragment & fragment, G4double anEnergy)
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4EvaporationProbability::copy_constructor meant to not be accessable");
+}
+const G4EvaporationProbability & G4EvaporationProbability::
+operator=(const G4EvaporationProbability &)
+  G4double EmissionProbability = 0.0;
+  G4double MaximalKineticEnergy = anEnergy;
+  if (MaximalKineticEnergy > 0.0 && fragment.GetExcitationEnergy() > 0.0) {
+    EmissionProbability = CalculateProbability(fragment, MaximalKineticEnergy);
+  }
+  return EmissionProbability;
+}
+////////////////////////////////////
+// Computes the integrated probability of evaporation channel
+G4double
+G4EvaporationProbability::CalculateProbability(const G4Fragment & fragment,
+                                               G4double MaximalKineticEnergy)
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4EvaporationProbability::operator= meant to not be accessable");
+    return *this;
+}
+G4bool G4EvaporationProbability::operator==(const G4EvaporationProbability &) const
+{
+    return false;
+}
+G4bool G4EvaporationProbability::operator!=(const G4EvaporationProbability &) const
+{
+    return true;
+}
+G4double G4EvaporationProbability::EmissionProbability(const G4Fragment & fragment, const G4double anEnergy)
+{
+    G4double EmissionProbability = 0.0;
+    G4double MaximalKineticEnergy = anEnergy;
+    if (MaximalKineticEnergy > 0.0 && fragment.GetExcitationEnergy() > 0.0) {
+        EmissionProbability = CalculateProbability(fragment, MaximalKineticEnergy);
+    }
+    return EmissionProbability;
+}
+////////////////////////////////////
+// Computes the integrated probability of evaporation channel
+G4double G4EvaporationProbability::CalculateProbability(const G4Fragment & fragment, const G4double MaximalKineticEnergy)
+{
+    G4double ResidualA = fragment.GetA() - theA;
+    G4double ResidualZ = fragment.GetZ() - theZ;
+    G4double U = fragment.GetExcitationEnergy();
+  G4int ResidualA = fragment.GetA_asInt() - theA;
+  G4int ResidualZ = fragment.GetZ_asInt() - theZ;
+  G4double U = fragment.GetExcitationEnergy();
+ if (OPTxs==0) {
+    G4double NuclearMass = G4ParticleTable::GetParticleTable()->GetIonTable()->GetNucleusMass(theZ,theA);
+    G4double delta0 = G4PairingCorrection::GetInstance()->GetPairingCorrection(static_cast<G4int>(fragment.GetA()),
+                                                                               static_cast<G4int>(fragment.GetZ()));
+    G4double SystemEntropy = 2.0*std::sqrt(theEvapLDPptr->LevelDensityParameter(static_cast<G4int>(fragment.GetA()),
+                                                                           static_cast<G4int>(fragment.GetZ()),U)*
+                                      (U-delta0));
+  if (OPTxs==0) {
+    G4double NuclearMass = fragment.ComputeGroundStateMass(theZ,theA);
+    G4double delta0 = fPairCorr->GetPairingCorrection(fragment.GetA_asInt(),
+                                                      fragment.GetZ_asInt());
+    G4double SystemEntropy = 2.0*std::sqrt(
+      theEvapLDPptr->LevelDensityParameter(fragment.GetA_asInt(),fragment.GetZ_asInt(),U)*
+      (U-delta0));
+    G4double RN = 1.5*fermi;
+    const G4double RN = 1.5*fermi;
     G4double Alpha = CalcAlphaParam(fragment);
 …
     G4double Rmax = MaximalKineticEnergy;
+    G4double a = theEvapLDPptr->LevelDensityParameter(static_cast<G4int>(ResidualA),
+                                                      static_cast<G4int>(ResidualZ),
+                                                      Rmax);
+    G4double GlobalFactor = static_cast<G4double>(Gamma) * (Alpha/(a*a)) *
+        (NuclearMass*RN*RN*std::pow(ResidualA,2./3.))/
+        (2.*pi* hbar_Planck*hbar_Planck);
+    G4double a = theEvapLDPptr->LevelDensityParameter(ResidualA,ResidualZ,Rmax);
+    G4double GlobalFactor = Gamma * Alpha/(a*a) *
+        (NuclearMass*RN*RN*fG4pow->Z23(ResidualA))/
+        (twopi* hbar_Planck*hbar_Planck);
     G4double Term1 = (2.0*Beta*a-3.0)/2.0 + Rmax*a;
     G4double Term2 = (2.0*Beta*a-3.0)*std::sqrt(Rmax*a) + 2.0*a*Rmax;
     G4double ExpTerm1 = 0.0;
     if (SystemEntropy <= 600.0) ExpTerm1 = std::exp(-SystemEntropy);
+    if (SystemEntropy <= 600.0) { ExpTerm1 = std::exp(-SystemEntropy); }
     G4double ExpTerm2 = 2.*std::sqrt(a*Rmax) - SystemEntropy;
     if (ExpTerm2 > 700.0) ExpTerm2 = 700.0;
+    if (ExpTerm2 > 700.0) { ExpTerm2 = 700.0; }
     ExpTerm2 = std::exp(ExpTerm2);
 …
  } else if (OPTxs==1 || OPTxs==2 ||OPTxs==3 || OPTxs==4) {
+   G4double limit;
+   if (useSICB) limit=theCoulombBarrierptr->GetCoulombBarrier(G4lrint(ResidualA),G4lrint(ResidualZ),U);
+   else limit=0.;
+   if (MaximalKineticEnergy <= limit)  return 0.0;
+   // if Coulomb barrier cutoff is superimposed for all cross sections the limit is the Coulomb Barrier
+   G4double EvaporatedMass = fragment.ComputeGroundStateMass(theZ,theA);
+   G4double ResidulalMass = fragment.ComputeGroundStateMass(ResidualZ,ResidualA);
+   G4double limit = std::max(0.0,fragment.GetGroundStateMass()-EvaporatedMass-ResidulalMass);
+   if (useSICB) {
+     limit = std::max(limit,theCoulombBarrierptr->GetCoulombBarrier(ResidualA,ResidualZ,U));
+   }
+   if (MaximalKineticEnergy <= limit) { return 0.0; }
+   // if Coulomb barrier cutoff is superimposed for all cross sections
+   // then the limit is the Coulomb Barrier
    G4double LowerLimit= limit;
    //  MaximalKineticEnergy: asimptotic value (already accounted for in G4EvaporationChannel)
+   //MaximalKineticEnergy: asimptotic value (already accounted for in G4EvaporationChannel)
    G4double UpperLimit = MaximalKineticEnergy;
    G4double Width = IntegrateEmissionProbability(fragment,LowerLimit,UpperLimit);
    return Width;
  } else{
+ } else {
    std::ostringstream errOs;
    errOs << "Bad option for cross sections at evaporation"  <<G4endl;
 …
 G4double G4EvaporationProbability::
+IntegrateEmissionProbability(const G4Fragment & fragment, const G4double & Low, const G4double & Up )
+IntegrateEmissionProbability(const G4Fragment & fragment,
+                             const G4double & Low, const G4double & Up )
+{
   static const G4int N = 10;
   // 10-Points Gauss-Legendre abcisas and weights
 …
 //New method (OPT=1,2,3,4)
+G4double G4EvaporationProbability::ProbabilityDistributionFunction( const G4Fragment & fragment, const G4double K)
+G4double
+G4EvaporationProbability::ProbabilityDistributionFunction( const G4Fragment & fragment,
+                                                           G4double K)
+{
+  G4int ResidualA = fragment.GetA_asInt() - theA;
+  G4int ResidualZ = fragment.GetZ_asInt() - theZ;
+  G4double U = fragment.GetExcitationEnergy();
+  //G4cout << "### G4EvaporationProbability::ProbabilityDistributionFunction" << G4endl;
+  //G4cout << "FragZ= " << fragment.GetZ_asInt() << " FragA= " << fragment.GetA_asInt()
+  //     << " Z= " << theZ << "  A= " << theA << G4endl;
+  //G4cout << "PC " << fPairCorr << "   DP " << theEvapLDPptr << G4endl;
+  // if(K <= theCoulombBarrierptr->GetCoulombBarrier(ResidualA,ResidualZ,U)) return 0.0;
+  G4double delta1 = fPairCorr->GetPairingCorrection(ResidualA,ResidualZ);
+  G4double ResidualA = fragment.GetA() - theA;
+  G4double ResidualZ = fragment.GetZ() - theZ;
+  G4double U = fragment.GetExcitationEnergy();
+  //        if(K <= theCoulombBarrierptr->GetCoulombBarrier(G4lrint(ResidualA),G4lrint(ResidualZ),U)) return 0.0;
+  G4double delta1 = G4PairingCorrection::GetInstance()->GetPairingCorrection(static_cast<G4int>(ResidualA),static_cast<G4int>(ResidualZ));
+  G4double delta0 = G4PairingCorrection::GetInstance()->GetPairingCorrection(static_cast<G4int>(fragment.GetA()),static_cast<G4int>(fragment.GetZ()));
+  G4double ParticleMass = G4ParticleTable::GetParticleTable()->GetIonTable()->GetNucleusMass(theZ,theA);
+  G4double theSeparationEnergy= G4NucleiProperties::GetMassExcess(static_cast<G4int>(theA),static_cast<G4int>(theZ)) +
+    G4NucleiProperties::GetMassExcess(static_cast<G4int>(ResidualA),static_cast<G4int>(ResidualZ)) -
+    G4NucleiProperties::GetMassExcess(static_cast<G4int>(fragment.GetA()),static_cast<G4int>(fragment.GetZ()));
+  G4double a0 = theEvapLDPptr->LevelDensityParameter(static_cast<G4int>(fragment.GetA()),static_cast<G4int>(fragment.GetZ()),U - delta0);
+  G4double a1 = theEvapLDPptr->LevelDensityParameter(static_cast<G4int>(ResidualA),static_cast<G4int>(ResidualZ),U - theSeparationEnergy - delta1);
+  G4double E0=U-delta0;
+  G4double E1=U-theSeparationEnergy-delta1-K;
+  if (E1<0.) return 0.;
+  G4double delta0 = fPairCorr->GetPairingCorrection(fragment.GetA_asInt(),
+                                                    fragment.GetZ_asInt());
+  G4double ParticleMass = fragment.ComputeGroundStateMass(theZ,theA);
+  G4double ResidualMass = fragment.ComputeGroundStateMass(ResidualZ,ResidualA);
+  G4double theSeparationEnergy = ParticleMass + ResidualMass
+    - fragment.GetGroundStateMass();
+  G4double a0 = theEvapLDPptr->LevelDensityParameter(fragment.GetA_asInt(),
+                                                     fragment.GetZ_asInt(),
+                                                     U - delta0);
+  G4double a1 = theEvapLDPptr->LevelDensityParameter(ResidualA, ResidualZ,
+                                                     U - theSeparationEnergy - delta1);
+  G4double E0 = U - delta0;
+  G4double E1 = U - theSeparationEnergy - delta1 - K;
+  if (E1<0.) { return 0.; }
   //JMQ 14/02/09 BUG fixed: hbarc should be in the denominator instead of hbar_Planck
   //Without 1/hbar_Panck remains as a width
-  //  G4double  Prob=Gamma*ParticleMass/((pi*hbar_Planck)*(pi*hbar_Planck)*
-  //std::exp(2*std::sqrt(a0*E0)))*K*CrossSection(fragment,K)*std::exp(2*std::sqrt(a1*E1))*millibarn;
   G4double Prob=Gamma*ParticleMass/((pi*hbarc)*(pi*hbarc)*std::exp(2*std::sqrt(a0*E0)))

trunk/source/processes/hadronic/models/de_excitation/evaporation/src/G4He3EvaporationChannel.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4He3EvaporationChannel.cc,v 1.4 2006/06/29 20:10:33 gunter Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4He3EvaporationChannel.cc,v 1.5 2010/11/17 12:14:59 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Nov. 1999)
 //
+// 17-11-2010 V.Ivanchenko moved constructor and destructor to source and cleanup
 #include "G4He3EvaporationChannel.hh"
+G4He3EvaporationChannel::G4He3EvaporationChannel()
+: G4EvaporationChannel(3,2,"He3",&theEvaporationProbability,&theCoulombBarrier)
+{}
+const G4He3EvaporationChannel & G4He3EvaporationChannel::operator=(const G4He3EvaporationChannel & )
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4He3EvaporationChannel::operator= meant to not be accessable");
+    return *this;
+}
+G4He3EvaporationChannel::~G4He3EvaporationChannel()
+{}
-G4He3EvaporationChannel::G4He3EvaporationChannel(const G4He3EvaporationChannel & ) : G4EvaporationChannel()
+{
-    throw G4HadronicException(__FILE__, __LINE__, "G4He3EvaporationChannel::CopyConstructor meant to not be accessable");
+}
-G4bool G4He3EvaporationChannel::operator==(const G4He3EvaporationChannel & right) const
+{
-    return (this == (G4He3EvaporationChannel *) &right);
-    //  return false;
+}
-G4bool G4He3EvaporationChannel::operator!=(const G4He3EvaporationChannel & right) const
+{
-    return (this != (G4He3EvaporationChannel *) &right);
-    //  return true;
+}

trunk/source/processes/hadronic/models/de_excitation/evaporation/src/G4He3EvaporationProbability.cc

-              r1315
+              r1347
 // ********************************************************************
 //
+//J.M. Quesada (August2008). Based on:
+// $Id: G4He3EvaporationProbability.cc,v 1.18 2010/11/17 11:06:03 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
+//
+// J.M. Quesada (August2008). Based on:
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Oct 1998)
 //
+// Modif (03 September 2008) by J. M. Quesada for external choice of inverse
+// cross section option
+// Modified:
+// 03-09-2008 J.M. Quesada for external choice of inverse cross section option
+// 17-11-2010 V.Ivanchenko integer Z and A
 #include "G4He3EvaporationProbability.hh"
 …
 G4He3EvaporationProbability::G4He3EvaporationProbability() :
    G4EvaporationProbability(3,2,2,&theCoulombBarrier) // A,Z,Gamma,&theCoulombBarrier
+{
+}
+G4He3EvaporationProbability::G4He3EvaporationProbability(const G4He3EvaporationProbability &) : G4EvaporationProbability()
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4He3EvaporationProbability::copy_constructor meant to not be accessable");
+}
+const G4He3EvaporationProbability & G4He3EvaporationProbability::
+operator=(const G4He3EvaporationProbability &)
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4He3EvaporationProbability::operator= meant to not be accessable");
+    return *this;
+}
+G4bool G4He3EvaporationProbability::operator==(const G4He3EvaporationProbability &) const
+{
+    return false;
+}
+G4bool G4He3EvaporationProbability::operator!=(const G4He3EvaporationProbability &) const
+{
+    return true;
+}
+  G4double G4He3EvaporationProbability::CalcAlphaParam(const G4Fragment & fragment)
+  { return 1.0 + CCoeficient(static_cast<G4double>(fragment.GetZ()-GetZ()));}
+{}
+G4He3EvaporationProbability::~G4He3EvaporationProbability()
+{}
+G4double G4He3EvaporationProbability::CalcAlphaParam(const G4Fragment & fragment)
+  { return 1.0 + CCoeficient(fragment.GetZ_asInt()-GetZ());}
   G4double G4He3EvaporationProbability::CalcBetaParam(const G4Fragment & )
+G4double G4He3EvaporationProbability::CalcBetaParam(const G4Fragment & )
   { return 0.0; }
 G4double G4He3EvaporationProbability::CCoeficient(const G4double aZ)
+{
     // Data comes from
     // Dostrovsky, Fraenkel and Friedlander
     // Physical Review, vol 116, num. 3 1959
     //
     // const G4int size = 5;
     // G4double Zlist[5] = { 10.0, 20.0, 30.0, 50.0, 70.0};
     //  G4double Calpha[5] = { 0.10, 0.10, 0.10, 0.08, 0.06};
     // C for He3 is equal to C for alpha times 4/3
     G4double C = 0.0;
+G4double G4He3EvaporationProbability::CCoeficient(G4int aZ)
+{
+  // Data comes from
+  // Dostrovsky, Fraenkel and Friedlander
+  // Physical Review, vol 116, num. 3 1959
+  //
+  // const G4int size = 5;
+  // G4double Zlist[5] = { 10.0, 20.0, 30.0, 50.0, 70.0};
+  //    G4double Calpha[5] = { 0.10, 0.10, 0.10, 0.08, 0.06};
+  // C for He3 is equal to C for alpha times 4/3
+  G4double C = 0.0;
+    if (aZ <= 30) {
+        C = 0.10;
+    } else if (aZ <= 50) {
+        C = 0.1 + -((aZ-50.)/20.)*0.02;
+    } else if (aZ < 70) {
+        C = 0.08 + -((aZ-70.)/20.)*0.02;
+    } else {
+        C = 0.06;
+    }
+    return C*(4.0/3.0);
+  if (aZ <= 30)
+    {
+      C = 0.10;
+    }
+  else if (aZ <= 50)
+    {
+      C = 0.1 - (aZ - 30)*0.001;
+    }
+  else if (aZ < 70)
+    {
+      C = 0.08 - (aZ - 50)*0.001;
+    }
+  else
+    {
+      C = 0.06;
+    }
+  return C*(4.0/3.0);
+}
 …
 //OPT=3,4 Kalbach's parameterization
 //
+G4double G4He3EvaporationProbability::CrossSection(const  G4Fragment & fragment, const  G4double K)
+{
+       theA=GetA();
+       theZ=GetZ();
+       ResidualA=fragment.GetA()-theA;
+       ResidualZ=fragment.GetZ()-theZ;
+       ResidualAthrd=std::pow(ResidualA,0.33333);
+       FragmentA=fragment.GetA();
+       FragmentAthrd=std::pow(FragmentA,0.33333);
+       if (OPTxs==0) {std::ostringstream errOs;
+         errOs << "We should'n be here (OPT =0) at evaporation cross section calculation (He3's)!!"
+               <<G4endl;
+         throw G4HadronicException(__FILE__, __LINE__, errOs.str());
+         return 0.;}
+       if( OPTxs==1 || OPTxs==2) return G4He3EvaporationProbability::GetOpt12( K);
+       else if (OPTxs==3 || OPTxs==4)  return G4He3EvaporationProbability::GetOpt34( K);
+       else{
+         std::ostringstream errOs;
+         errOs << "BAD He3's CROSS SECTION OPTION AT EVAPORATION!!"  <<G4endl;
+         throw G4HadronicException(__FILE__, __LINE__, errOs.str());
+         return 0.;
+       }
+}
+//
+//********************* OPT=1,2 : Chatterjee's cross section ************************
+G4double
+G4He3EvaporationProbability::CrossSection(const  G4Fragment & fragment, G4double K)
+{
+  theA=GetA();
+  theZ=GetZ();
+  ResidualA=fragment.GetA_asInt()-theA;
+  ResidualZ=fragment.GetZ_asInt()-theZ;
+  ResidualAthrd=fG4pow->Z13(ResidualA);
+  FragmentA=fragment.GetA_asInt();
+  FragmentAthrd=fG4pow->Z13(FragmentA);
+  if (OPTxs==0) {std::ostringstream errOs;
+  errOs << "We should'n be here (OPT =0) at evaporation cross section calculation (He3's)!!"
+        <<G4endl;
+  throw G4HadronicException(__FILE__, __LINE__, errOs.str());
+  return 0.;}
+  if( OPTxs==1 || OPTxs==2) return G4He3EvaporationProbability::GetOpt12( K);
+  else if (OPTxs==3 || OPTxs==4)  return G4He3EvaporationProbability::GetOpt34( K);
+  else{
+    std::ostringstream errOs;
+    errOs << "BAD He3's CROSS SECTION OPTION AT EVAPORATION!!"  <<G4endl;
+    throw G4HadronicException(__FILE__, __LINE__, errOs.str());
+    return 0.;
+  }
+}
+//********************* OPT=1,2 : Chatterjee's cross section *****************
 //(fitting to cross section from Bechetti & Greenles OM potential)
 G4double G4He3EvaporationProbability::GetOpt12(const  G4double K)
+{
+G4double Kc=K;
+// JMQ xsec is set constat above limit of validity
+ if (K>50) Kc=50;
+ G4double landa ,mu ,nu ,p , Ec,q,r,ji,xs;
+ G4double     p0 = -3.06;
+ G4double     p1 = 278.5;
+ G4double     p2 = -1389.;
+ G4double     landa0 = -0.00535;
+ G4double     landa1 = -11.16;
+ G4double     mu0 = 555.5;
+ G4double     mu1 = 0.40;
+ G4double     nu0 = 687.4;
+ G4double     nu1 = -476.3;
+ G4double     nu2 = 0.509;
+ G4double     delta=1.2;
+      Ec = 1.44*theZ*ResidualZ/(1.5*ResidualAthrd+delta);
+      p = p0 + p1/Ec + p2/(Ec*Ec);
+      landa = landa0*ResidualA + landa1;
+      mu = mu0*std::pow(ResidualA,mu1);
+      nu = std::pow(ResidualA,mu1)*(nu0 + nu1*Ec + nu2*(Ec*Ec));
+      q = landa - nu/(Ec*Ec) - 2*p*Ec;
+      r = mu + 2*nu/Ec + p*(Ec*Ec);
+   ji=std::max(Kc,Ec);
+   if(Kc < Ec) { xs = p*Kc*Kc + q*Kc + r;}
+   else {xs = p*(Kc - ji)*(Kc - ji) + landa*Kc + mu + nu*(2 - Kc/ji)/ji ;}
+   if (xs <0.0) {xs=0.0;}
+  G4double Kc = K;
+  // JMQ xsec is set constat above limit of validity
+  if (K > 50*MeV) { Kc = 50*MeV; }
+  G4double landa ,mu ,nu ,p , Ec,q,r,ji,xs;
+  G4double     p0 = -3.06;
+  G4double     p1 = 278.5;
+  G4double     p2 = -1389.;
+  G4double     landa0 = -0.00535;
+  G4double     landa1 = -11.16;
+  G4double     mu0 = 555.5;
+  G4double     mu1 = 0.40;
+  G4double     nu0 = 687.4;
+  G4double     nu1 = -476.3;
+  G4double     nu2 = 0.509;
+  G4double     delta=1.2;
+  Ec = 1.44*theZ*ResidualZ/(1.5*ResidualAthrd+delta);
+  p = p0 + p1/Ec + p2/(Ec*Ec);
+  landa = landa0*ResidualA + landa1;
+  G4double resmu1 = fG4pow->powZ(ResidualA,mu1);
+  mu = mu0*resmu1;
+  nu = resmu1*(nu0 + nu1*Ec + nu2*(Ec*Ec));
+  q = landa - nu/(Ec*Ec) - 2*p*Ec;
+  r = mu + 2*nu/Ec + p*(Ec*Ec);
+  ji=std::max(Kc,Ec);
+  if(Kc < Ec) { xs = p*Kc*Kc + q*Kc + r;}
+  else {xs = p*(Kc - ji)*(Kc - ji) + landa*Kc + mu + nu*(2 - Kc/ji)/ji ;}
+  if (xs <0.0) {xs=0.0;}
    return xs;
+  return xs;
+}
 …
 //c     ** 3he from o.m. of gibson et al
+{
   G4double landa, mu, nu, p , signor(1.),sig;
   G4double ec,ecsq,xnulam,etest(0.),a;
   G4double b,ecut,cut,ecut2,geom,elab;
   G4double     flow = 1.e-18;
   G4double     spill= 1.e+18;
   G4double     p0 = -2.88;
 …
   G4double      ra=0.80;
   //JMQ 13/02/09 increase of reduced radius to lower the barrier
   // ec = 1.44 * theZ * ResidualZ / (1.5*ResidualAthrd+ra);
 …
   p = p0 + p1/ec + p2/ecsq;
   landa = landa0*ResidualA + landa1;
   a = std::pow(ResidualA,mu1);
+  a = fG4pow->powZ(ResidualA,mu1);
   mu = mu0 * a;
   nu = a* (nu0+nu1*ec+nu2*ecsq);
   xnulam = nu / landa;
   if (xnulam > spill) xnulam=0.;
   if (xnulam >= flow) etest = 1.2 *std::sqrt(xnulam);
+  if (xnulam > spill) { xnulam=0.; }
+  if (xnulam >= flow) { etest = 1.2 *std::sqrt(xnulam); }
   a = -2.*p*ec + landa - nu/ecsq;
 …
   ecut = (ecut-a) / (p+p);
   ecut2 = ecut;
+//JMQ 290310 for avoiding unphysical increase below minimum (at ecut)
+//ecut<0 means that there is no cut with energy axis, i.e. xs is set to 0 bellow minimum
+//  if (cut < 0.) ecut2 = ecut - 2.;
+  if (cut < 0.) ecut2 = ecut;
+  elab = K * FragmentA / ResidualA;
+  //JMQ 290310 for avoiding unphysical increase below minimum (at ecut)
+  // ecut<0 means that there is no cut with energy axis, i.e. xs is set
+  // to 0 bellow minimum
+  //  if (cut < 0.) ecut2 = ecut - 2.;
+  if (cut < 0.) { ecut2 = ecut; }
+  elab = K * FragmentA /G4double(ResidualA);
   sig = 0.;
   if (elab <= ec) { //start for E<Ec
     if (elab > ecut2)  sig = (p*elab*elab+a*elab+b) * signor;
+    if (elab > ecut2) { sig = (p*elab*elab+a*elab+b) * signor; }
   }           //end for E<Ec
   else {           //start for E>Ec
     sig = (landa*elab+mu+nu/elab) * signor;
     geom = 0.;
     if (xnulam < flow || elab < etest) return sig;
+    if (xnulam < flow || elab < etest) { return sig; }
     geom = std::sqrt(theA*K);
     geom = 1.23*ResidualAthrd + ra + 4.573/geom;
 …
+}
-//   ************************** end of cross sections *******************************

trunk/source/processes/hadronic/models/de_excitation/evaporation/src/G4NeutronEvaporationChannel.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4NeutronEvaporationChannel.cc,v 1.4 2006/06/29 20:10:37 gunter Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4NeutronEvaporationChannel.cc,v 1.5 2010/11/17 12:14:59 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Nov. 1999)
 //
+// 17-11-2010 V.Ivanchenko moved constructor and destructor to source and cleanup
 #include "G4NeutronEvaporationChannel.hh"
+G4NeutronEvaporationChannel::G4NeutronEvaporationChannel()
+: G4EvaporationChannel(1,0,"neutron",&theEvaporationProbability,&theCoulombBarrier)
+{}
+const G4NeutronEvaporationChannel & G4NeutronEvaporationChannel::operator=(const G4NeutronEvaporationChannel & )
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4NeutronEvaporationChannel::operator= meant to not be accessable");
+    return *this;
+}
+G4NeutronEvaporationChannel::G4NeutronEvaporationChannel(const G4NeutronEvaporationChannel & ) : G4EvaporationChannel()
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4NeutronEvaporationChannel::CopyConstructor meant to not be accessable");
+}
+G4bool G4NeutronEvaporationChannel::operator==(const G4NeutronEvaporationChannel & right) const
+{
+    return (this == (G4NeutronEvaporationChannel *) &right);
+    //  return false;
+}
+G4bool G4NeutronEvaporationChannel::operator!=(const G4NeutronEvaporationChannel & right) const
+{
+    return (this != (G4NeutronEvaporationChannel *) &right);
+    //  return true;
+}
+G4NeutronEvaporationChannel::~G4NeutronEvaporationChannel()
+{}

trunk/source/processes/hadronic/models/de_excitation/evaporation/src/G4NeutronEvaporationProbability.cc

-              r962
+              r1347
 // ********************************************************************
 //
+//J.M. Quesada (August2008). Based on:
+// $Id: G4NeutronEvaporationProbability.cc,v 1.16 2010/11/17 11:06:03 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
+//
+// J.M. Quesada (August2008). Based on:
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Oct 1998)
 //
+// Modif (03 September 2008) by J. M. Quesada for external choice of inverse
+// cross section option
+// Modified:
+// 03-09-2008 J.M. Quesada for external choice of inverse cross section option
+// 17-11-2010 V.Ivanchenko integer Z and A
 #include "G4NeutronEvaporationProbability.hh"
 …
 G4NeutronEvaporationProbability::G4NeutronEvaporationProbability() :
     G4EvaporationProbability(1,0,2,&theCoulombBarrier) // A,Z,Gamma,&theCoulombBarrier
+{
+}
+G4NeutronEvaporationProbability::G4NeutronEvaporationProbability(const G4NeutronEvaporationProbability &) : G4EvaporationProbability()
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4NeutronEvaporationProbability::copy_constructor meant to not be accessable");
+}
+const G4NeutronEvaporationProbability & G4NeutronEvaporationProbability::
+operator=(const G4NeutronEvaporationProbability &)
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4NeutronEvaporationProbability::operator= meant to not be accessable");
+    return *this;
+}
+G4bool G4NeutronEvaporationProbability::operator==(const G4NeutronEvaporationProbability &) const
+{
+    return false;
+}
+G4bool G4NeutronEvaporationProbability::operator!=(const G4NeutronEvaporationProbability &) const
+{
+    return true;
+}
+ G4double G4NeutronEvaporationProbability::CalcAlphaParam(const G4Fragment & fragment)
+  { return 0.76+2.2/std::pow(static_cast<G4double>(fragment.GetA()-GetA()),1.0/3.0);}
+{}
+G4NeutronEvaporationProbability::~G4NeutronEvaporationProbability()
+{}
+G4double G4NeutronEvaporationProbability::CalcAlphaParam(const G4Fragment & fragment)
+{
+  return 0.76+2.2/fG4pow->Z13(fragment.GetA_asInt()-GetA());
+}
+  G4double G4NeutronEvaporationProbability::CalcBetaParam(const G4Fragment &  fragment)
+  { return (2.12/std::pow(static_cast<G4double>(fragment.GetA()-GetA()),2.0/3.0) - 0.05)*MeV/
+      CalcAlphaParam(fragment); }
+G4double G4NeutronEvaporationProbability::CalcBetaParam(const G4Fragment &  fragment)
+{
+  return (2.12/fG4pow->Z23(fragment.GetA_asInt()-GetA()) - 0.05)*MeV/
+    CalcAlphaParam(fragment);
+}
 ////////////////////////////////////////////////////////////////////////////////////
 …
 //OPT=3,4 Kalbach's parameterization
 //
+ G4double G4NeutronEvaporationProbability::CrossSection(const  G4Fragment & fragment, const  G4double K)
+G4double
+G4NeutronEvaporationProbability::CrossSection(const  G4Fragment & fragment, G4double K)
+{
   theA=GetA();
   theZ=GetZ();
+  ResidualA=fragment.GetA()-theA;
+  ResidualZ=fragment.GetZ()-theZ;
+  ResidualAthrd=std::pow(ResidualA,0.33333);
+  FragmentA=fragment.GetA();
+  FragmentAthrd=std::pow(FragmentA,0.33333);
+  ResidualA=fragment.GetA_asInt()-theA;
+  ResidualZ=fragment.GetZ_asInt()-theZ;
+  ResidualAthrd=fG4pow->Z13(ResidualA);
+  FragmentA=fragment.GetA_asInt();
+  FragmentAthrd=fG4pow->Z13(FragmentA);
   if (OPTxs==0) {std::ostringstream errOs;
 …
+  }
+}
+//********************* OPT=1,2 : Chatterjee's cross section ************************
+//********************* OPT=1,2 : Chatterjee's cross section ***************
 //(fitting to cross section from Bechetti & Greenles OM potential)
 G4double G4NeutronEvaporationProbability::GetOpt12(const  G4double K)
+G4double G4NeutronEvaporationProbability::GetOpt12(G4double K)
+{
   G4double Kc=K;
+// JMQ  xsec is set constat above limit of validity
+  if (K>50) Kc=50;
+  // Pramana (Bechetti & Greenles) for neutrons is chosen
+  // JMQ  xsec is set constat above limit of validity
+  if (K > 50*MeV) { Kc = 50*MeV; }
   G4double landa, landa0, landa1, mu, mu0, mu1,nu, nu0, nu1, nu2,xs;
 …
     errOs <<"  xsec("<<Kc<<" MeV) ="<<xs <<G4endl;
     throw G4HadronicException(__FILE__, __LINE__, errOs.str());
+  }
+              }
   return xs;
+}
 // *********** OPT=3,4 : Kalbach's cross sections (from PRECO code)*************
 G4double G4NeutronEvaporationProbability::GetOpt34(const  G4double K)
+G4double G4NeutronEvaporationProbability::GetOpt34(G4double K)
+{
   G4double landa, landa0, landa1, mu, mu0, mu1,nu, nu0, nu1, nu2;
   G4double p, p0, p1, p2;
 …
   G4double b,ecut,cut,ecut2,geom,elab;
 //safety initialization
+  //safety initialization
   landa0=0;
   landa1=0;
 …
   p2=0.;
   flow = 1.e-18;
   spill= 1.0e+18;
+// PRECO xs for neutrons is choosen
+  // PRECO xs for neutrons is choosen
   p0 = -312.;
   p1= 0.;
 …
   nu2 = 1280.8;
   if (ResidualA < 40.) signor=0.7+ResidualA*0.0075;
   if (ResidualA > 210.) signor = 1. + (ResidualA-210.)/250.;
+  if (ResidualA < 40)  { signor =0.7 + ResidualA*0.0075; }
+  if (ResidualA > 210) { signor = 1. + (ResidualA-210)/250.; }
   landa = landa0/ResidualAthrd + landa1;
   mu = mu0*ResidualAthrd + mu1*ResidualAthrd*ResidualAthrd;
 …
   // JMQ very low energy behaviour corrected (problem  for A (apprx.)>60)
   if (nu < 0.)nu=-nu;
+  if (nu < 0.) { nu=-nu; }
   ec = 0.5;
 …
   xnulam = 1.;
   etest = 32.;
+//          ** etest is the energy above which the rxn cross section is
+//          ** compared with the geometrical limit and the max taken.
+//          ** xnulam here is a dummy value to be used later.
+  //          ** etest is the energy above which the rxn cross section is
+  //          ** compared with the geometrical limit and the max taken.
+  //          ** xnulam here is a dummy value to be used later.
   a = -2.*p*ec + landa - nu/ecsq;
 …
   ecut = 0.;
   cut = a*a - 4.*p*b;
   if (cut > 0.) ecut = std::sqrt(cut);
+  if (cut > 0.) { ecut = std::sqrt(cut); }
   ecut = (ecut-a) / (p+p);
   ecut2 = ecut;
   if (cut < 0.) ecut2 = ecut - 2.;
   elab = K * FragmentA / ResidualA;
+  if (cut < 0.) { ecut2 = ecut - 2.; }
+  elab = K * FragmentA / G4double(ResidualA);
   sig = 0.;
   if (elab <= ec) { //start for E<Ec
     if (elab > ecut2)  sig = (p*elab*elab+a*elab+b) * signor;
+    if (elab > ecut2) { sig = (p*elab*elab+a*elab+b) * signor; }
   }              //end for E<Ec
   else {           //start for  E>Ec
     sig = (landa*elab+mu+nu/elab) * signor;
     geom = 0.;
     if (xnulam < flow || elab < etest) return sig;
+    if (xnulam < flow || elab < etest) { return sig; }
     geom = std::sqrt(theA*K);
     geom = 1.23*ResidualAthrd + ra + 4.573/geom;
     geom = 31.416 * geom * geom;
     sig = std::max(geom,sig);
+  }
+  return sig;}
+//   ************************** end of cross sections *******************************
+  return sig;
+}

trunk/source/processes/hadronic/models/de_excitation/evaporation/src/G4ProtonEvaporationChannel.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4ProtonEvaporationChannel.cc,v 1.4 2006/06/29 20:10:41 gunter Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4ProtonEvaporationChannel.cc,v 1.5 2010/11/17 12:14:59 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Nov. 1999)
 //
+// 17-11-2010 V.Ivanchenko moved constructor and destructor to source and cleanup
 #include "G4ProtonEvaporationChannel.hh"
+G4ProtonEvaporationChannel::G4ProtonEvaporationChannel()
+: G4EvaporationChannel(1,1,"proton",&theEvaporationProbability,&theCoulombBarrier)
+{}
+const G4ProtonEvaporationChannel & G4ProtonEvaporationChannel::operator=(const G4ProtonEvaporationChannel & )
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4ProtonEvaporationChannel::operator= meant to not be accessable");
+    return *this;
+}
+G4ProtonEvaporationChannel::G4ProtonEvaporationChannel(const G4ProtonEvaporationChannel & ) : G4EvaporationChannel()
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4ProtonEvaporationChannel::CopyConstructor meant to not be accessable");
+}
+G4bool G4ProtonEvaporationChannel::operator==(const G4ProtonEvaporationChannel & right) const
+{
+    return (this == (G4ProtonEvaporationChannel *) &right);
+    //  return false;
+}
+G4bool G4ProtonEvaporationChannel::operator!=(const G4ProtonEvaporationChannel & right) const
+{
+    return (this != (G4ProtonEvaporationChannel *) &right);
+    //  return true;
+}
+G4ProtonEvaporationChannel::~G4ProtonEvaporationChannel()
+{}

trunk/source/processes/hadronic/models/de_excitation/evaporation/src/G4ProtonEvaporationProbability.cc

-              r1315
+              r1347
 // ********************************************************************
 //
+//J.M. Quesada (August2008). Based on:
+// $Id: G4ProtonEvaporationProbability.cc,v 1.17 2010/11/17 11:06:03 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
+//
+// J.M. Quesada (August2008). Based on:
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Oct 1998)
 //
+// Modif (03 September 2008) by J. M. Quesada for external choice of inverse
+// cross section option
+// Modified:
+// 03-09-2008 J.M. Quesada for external choice of inverse cross section option
+// 17-11-2010 V.Ivanchenko integer Z and A
 #include "G4ProtonEvaporationProbability.hh"
 …
 G4ProtonEvaporationProbability::G4ProtonEvaporationProbability() :
     G4EvaporationProbability(1,1,2,&theCoulombBarrier) // A,Z,Gamma,&theCoulombBarrier
+{
+}
+G4ProtonEvaporationProbability::G4ProtonEvaporationProbability(const G4ProtonEvaporationProbability &) : G4EvaporationProbability()
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4ProtonEvaporationProbability::copy_constructor meant to not be accessable");
+}
+const G4ProtonEvaporationProbability & G4ProtonEvaporationProbability::
+operator=(const G4ProtonEvaporationProbability &)
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4ProtonEvaporationProbability::operator= meant to not be accessable");
+    return *this;
+}
+G4bool G4ProtonEvaporationProbability::operator==(const G4ProtonEvaporationProbability &) const
+{
+    return false;
+}
+G4bool G4ProtonEvaporationProbability::operator!=(const G4ProtonEvaporationProbability &) const
+{
+    return true;
+}
+  G4double G4ProtonEvaporationProbability::CalcAlphaParam(const G4Fragment & fragment)
+  { return 1.0 + CCoeficient(static_cast<G4double>(fragment.GetZ()-GetZ()));}
+  G4double G4ProtonEvaporationProbability::CalcBetaParam(const G4Fragment & )
+{}
+G4ProtonEvaporationProbability::~G4ProtonEvaporationProbability()
+{}
+G4double G4ProtonEvaporationProbability::CalcAlphaParam(const G4Fragment & fragment)
+  { return 1.0 + CCoeficient(fragment.GetZ_asInt()-GetZ());}
+G4double G4ProtonEvaporationProbability::CalcBetaParam(const G4Fragment & )
   { return 0.0; }
   G4double G4ProtonEvaporationProbability::CCoeficient(const G4double aZ)
+{
     // Data comes from
     // Dostrovsky, Fraenkel and Friedlander
     // Physical Review, vol 116, num. 3 1959
     //
     // const G4int size = 5;
     // G4double Zlist[5] = { 10.0, 20.0, 30.0, 50.0, 70.0};
     // G4double Cp[5] = { 0.50, 0.28, 0.20, 0.15, 0.10};
     G4double C = 0.0;
     if (aZ >= 70) {
         C = 0.10;
     } else {
         C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375;
+    }
     return C;
+G4double G4ProtonEvaporationProbability::CCoeficient(G4int aZ)
+{
+  // Data comes from
+  // Dostrovsky, Fraenkel and Friedlander
+  // Physical Review, vol 116, num. 3 1959
+  //
+  // const G4int size = 5;
+  // G4double Zlist[5] = { 10.0, 20.0, 30.0, 50.0, 70.0};
+  // G4double Cp[5] = { 0.50, 0.28, 0.20, 0.15, 0.10};
+  G4double C = 0.0;
+  if (aZ >= 70) {
+    C = 0.10;
+  } else {
+    C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375;
+  }
+  return C;
+}
 …
 //OPT=3 Kalbach's parameterization
 //
+G4double G4ProtonEvaporationProbability::CrossSection(const  G4Fragment & fragment, const  G4double K)
+{
+//  G4cout<<" In G4ProtonEVaporationProbability OPTxs="<<OPTxs<<G4endl;
+//  G4cout<<" In G4ProtonEVaporationProbability useSICB="<<useSICB<<G4endl;
+G4double
+G4ProtonEvaporationProbability::CrossSection(const  G4Fragment & fragment, G4double K)
+{
+  //  G4cout<<" In G4ProtonEVaporationProbability OPTxs="<<OPTxs<<G4endl;
+  //  G4cout<<" In G4ProtonEVaporationProbability useSICB="<<useSICB<<G4endl;
   theA=GetA();
   theZ=GetZ();
+  ResidualA=fragment.GetA()-theA;
+  ResidualZ=fragment.GetZ()-theZ;
+  ResidualAthrd=std::pow(ResidualA,0.33333);
+  FragmentA=fragment.GetA();
+  FragmentAthrd=std::pow(FragmentA,0.33333);
+  ResidualA=fragment.GetA_asInt()-theA;
+  ResidualZ=fragment.GetZ_asInt()-theZ;
+  ResidualAthrd=fG4pow->Z13(ResidualA);
+  FragmentA=fragment.GetA_asInt();
+  FragmentAthrd=fG4pow->Z13(FragmentA);
   U=fragment.GetExcitationEnergy();
 …
+  }
+}
+//********************* OPT=1 : Chatterjee's cross section ************************
+//********************* OPT=1 : Chatterjee's cross section *********************
 //(fitting to cross section from Bechetti & Greenles OM potential)
 G4double G4ProtonEvaporationProbability::GetOpt1(const  G4double K)
+G4double G4ProtonEvaporationProbability::GetOpt1(G4double K)
+{
   G4double Kc=K;
 // JMQ  xsec is set constat above limit of validity
   if (K>50)  Kc=50;
+  // JMQ  xsec is set constat above limit of validity
+  if (K > 50*MeV) { Kc = 50*MeV; }
   G4double landa, landa0, landa1, mu, mu0, mu1,nu, nu0, nu1, nu2,xs;
 …
   p = p0 + p1/Ec + p2/(Ec*Ec);
   landa = landa0*ResidualA + landa1;
+  mu = mu0*std::pow(ResidualA,mu1);
+  nu = std::pow(ResidualA,mu1)*(nu0 + nu1*Ec + nu2*(Ec*Ec));
+  G4double resmu1 = fG4pow->powZ(ResidualA,mu1);
+  mu = mu0*resmu1;
+  nu = resmu1*(nu0 + nu1*Ec + nu2*(Ec*Ec));
   q = landa - nu/(Ec*Ec) - 2*p*Ec;
   r = mu + 2*nu/Ec + p*(Ec*Ec);
 …
   if(Kc < Ec) { xs = p*Kc*Kc + q*Kc + r;}
   else {xs = p*(Kc - ji)*(Kc - ji) + landa*Kc + mu + nu*(2 - Kc/ji)/ji ;}
+   if (xs <0.0) {xs=0.0;}
+   return xs;
+}
+//************* OPT=2 : Wellisch's proton reaction cross section ************************
+G4double G4ProtonEvaporationProbability::GetOpt2(const  G4double K)
+{
+  G4double rnpro,rnneu,eekin,ekin,ff1,ff2,ff3,r0,fac,fac1,fac2,b0,xine_th(0);
+  if (xs <0.0) {xs=0.0;}
+  return xs;
+}
+//************* OPT=2 : Welisch's proton reaction cross section ***************
+G4double G4ProtonEvaporationProbability::GetOpt2(G4double K)
+{
+  G4double eekin,ekin,ff1,ff2,ff3,r0,fac,fac1,fac2,b0,xine_th(0);
+//This is redundant when the Coulomb  barrier is overimposed to all cross sections
+//It should be kept when Coulomb barrier only imposed at OPTxs=2, this is why ..
+         if(!useSICB && K <= theCoulombBarrier.GetCoulombBarrier(G4lrint(ResidualA),G4lrint(ResidualZ),U)) return xine_th=0.0;
+  // This is redundant when the Coulomb  barrier is overimposed to all
+  // cross sections
+  // It should be kept when Coulomb barrier only imposed at OPTxs=2
+  if(!useSICB && K<=theCoulombBarrier.GetCoulombBarrier(ResidualA,ResidualZ,U))
+    { return 0.0; }
   eekin=K;
+  rnpro=ResidualZ;
+  rnneu=ResidualA-ResidualZ;
+  G4int rnneu=ResidualA-ResidualZ;
   ekin=eekin/1000;
   r0=1.36*1.e-15;
   fac=pi*r0*r0;
 …
   fac1=b0*(1.-1./ResidualAthrd);
   fac2=1.;
   if(rnneu > 1.5) fac2=std::log(rnneu);
+  if(rnneu > 1.5) { fac2 = fG4pow->logZ(rnneu); }
   xine_th= 1.e+31*fac*fac2*(1.+ResidualAthrd-fac1);
   xine_th=(1.-0.15*std::exp(-ekin))*xine_th/(1.00-0.0007*ResidualA);
   ff1=0.70-0.0020*ResidualA ;
   ff2=1.00+1/ResidualA;
   ff3=0.8+18/ResidualA-0.002*ResidualA;
+  ff1=0.70-0.0020*ResidualA;
+  ff2=1.00+1/G4double(ResidualA);
+  ff3=0.8+18/G4double(ResidualA)-0.002*ResidualA;
   fac=1.-(1./(1.+std::exp(-8.*ff1*(std::log10(ekin)+1.37*ff2))));
   xine_th=xine_th*(1.+ff3*fac);
   ff1=1.-1/ResidualA-0.001*ResidualA;
   ff2=1.17-2.7/ResidualA-0.0014*ResidualA;
+  ff1=1.-1/G4double(ResidualA)-0.001*ResidualA;
+  ff2=1.17-2.7/G4double(ResidualA)-0.0014*ResidualA;
   fac=-8.*ff1*(std::log10(ekin)+2.0*ff2);
   fac=1./(1.+std::exp(fac));
   xine_th=xine_th*fac;
+  xine_th=xine_th*fac;
   if (xine_th < 0.0){
     std::ostringstream errOs;
 …
     throw G4HadronicException(__FILE__, __LINE__, errOs.str());
+  }
   return xine_th;
+}
+}
 // *********** OPT=3 : Kalbach's cross sections (from PRECO code)*************
 G4double G4ProtonEvaporationProbability::GetOpt3(const  G4double K)
+{
 //     ** p from  becchetti and greenlees (but modified with sub-barrier
 //     ** correction function and xp2 changed from -449)
+  //     ** p from  becchetti and greenlees (but modified with sub-barrier
+  //     ** correction function and xp2 changed from -449)
   G4double landa, landa0, landa1, mu, mu0, mu1,nu, nu0, nu1, nu2;
 …
   nu1 = -182.4;
   nu2 = -1.872;
 // parameters for  proton cross section refinement
+  // parameters for  proton cross section refinement
   G4double afit,bfit,a2,b2;
   afit=-0.0785656;
 …
   a2= -0.00089076;
   b2= 0.0231597;
   G4double ec,ecsq,xnulam,etest(0.),ra(0.),a,w,c,signor(1.),signor2,sig;
   G4double b,ecut,cut,ecut2,geom,elab;
   G4double      flow = 1.e-18;
   G4double       spill= 1.e+18;
+  if (ResidualA <= 60.)  signor = 0.92;
+  else if (ResidualA < 100.) signor = 0.8 + ResidualA*0.002;
+  if (ResidualA <= 60)      { signor = 0.92; }
+  else if (ResidualA < 100) { signor = 0.8 + ResidualA*0.002; }
   ec = 1.44 * theZ * ResidualZ / (1.5*ResidualAthrd+ra);
   ecsq = ec * ec;
   p = p0 + p1/ec + p2/ecsq;
   landa = landa0*ResidualA + landa1;
   a = std::pow(ResidualA,mu1);
+  a = fG4pow->powZ(ResidualA,mu1);
   mu = mu0 * a;
   nu = a* (nu0+nu1*ec+nu2*ecsq);
   c =std::min(3.15,ec*0.5);
   w = 0.7 * c / 3.15;
   xnulam = nu / landa;
   if (xnulam > spill) xnulam=0.;
   if (xnulam >= flow) etest =std::sqrt(xnulam) + 7.;
+  if (xnulam > spill) { xnulam=0.; }
+  if (xnulam >= flow) { etest =std::sqrt(xnulam) + 7.; }
   a = -2.*p*ec + landa - nu/ecsq;
   b = p*ecsq + mu + 2.*nu/ec;
   ecut = 0.;
   cut = a*a - 4.*p*b;
   if (cut > 0.) ecut = std::sqrt(cut);
+  if (cut > 0.) { ecut = std::sqrt(cut); }
   ecut = (ecut-a) / (p+p);
   ecut2 = ecut;
+//JMQ 290310 for avoiding unphysical increase below minimum (at ecut)
+//ecut<0 means that there is no cut with energy axis, i.e. xs is set to 0 bellow minimum
+//  if (cut < 0.) ecut2 = ecut - 2.;
+ if (cut < 0.) ecut2 = ecut;
+  elab = K * FragmentA / ResidualA;
+  //JMQ 290310 for avoiding unphysical increase below minimum (at ecut)
+  // ecut<0 means that there is no cut with energy axis, i.e. xs is set
+  // to 0 bellow minimum
+  //  if (cut < 0.) ecut2 = ecut - 2.;
+  if (cut < 0.) { ecut2 = ecut; }
+  elab = K * FragmentA /G4double(ResidualA);
   sig = 0.;
   if (elab <= ec) { //start for E<Ec
+    if (elab > ecut2)  sig = (p*elab*elab+a*elab+b) * signor;
+    if (elab > ecut2) { sig = (p*elab*elab+a*elab+b) * signor; }
     signor2 = (ec-elab-c) / w;
     signor2 = 1. + std::exp(signor2);
     sig = sig / signor2;
                        }       //end for E<=Ec
   else            {           //start for  E>Ec
+    sig = sig / signor2;
+  }              //end for E<=Ec
+  else{           //start for  E>Ec
     sig = (landa*elab+mu+nu/elab) * signor;
     geom = 0.;
     if (xnulam < flow || elab < etest)
+     {
+    if (xnulam < flow || elab < etest)
+      {
         if (sig <0.0) {sig=0.0;}
         return sig;
 …
     geom = 31.416 * geom * geom;
     sig = std::max(geom,sig);
   }   //end for E>Ec
+ return sig;}
+//   ************************** end of cross sections *******************************
+  return sig;
+}

trunk/source/processes/hadronic/models/de_excitation/evaporation/src/G4TritonEvaporationChannel.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4TritonEvaporationChannel.cc,v 1.4 2006/06/29 20:10:45 gunter Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4TritonEvaporationChannel.cc,v 1.5 2010/11/17 12:14:59 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Nov. 1999)
 //
+// 17-11-2010 V.Ivanchenko moved constructor and destructor to source and cleanup
 #include "G4TritonEvaporationChannel.hh"
+G4TritonEvaporationChannel::G4TritonEvaporationChannel()
+: G4EvaporationChannel(3,1,"triton",&theEvaporationProbability,&theCoulombBarrier)
+{}
+const G4TritonEvaporationChannel & G4TritonEvaporationChannel::
+operator=(const G4TritonEvaporationChannel & )
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4TritonEvaporationChannel::operator= meant to not be accessable");
+    return *this;
+}
+G4TritonEvaporationChannel::~G4TritonEvaporationChannel()
+{}
-G4TritonEvaporationChannel::G4TritonEvaporationChannel(const G4TritonEvaporationChannel & ) : G4EvaporationChannel()
+{
-    throw G4HadronicException(__FILE__, __LINE__, "G4TritonEvaporationChannel::CopyConstructor meant to not be accessable");
+}
-G4bool G4TritonEvaporationChannel::operator==(const G4TritonEvaporationChannel & right) const
+{
-    return (this == (G4TritonEvaporationChannel *) &right);
+}
-G4bool G4TritonEvaporationChannel::operator!=(const G4TritonEvaporationChannel & right) const
+{
-    return (this != (G4TritonEvaporationChannel *) &right);
+}

trunk/source/processes/hadronic/models/de_excitation/evaporation/src/G4TritonEvaporationProbability.cc

-              r1315
+              r1347
 // ********************************************************************
 //
+//J.M. Quesada (August2008). Based on:
+// $Id: G4TritonEvaporationProbability.cc,v 1.18 2010/11/17 11:06:03 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
+//
+// J.M. Quesada (August2008). Based on:
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Oct 1998)
 //
+// Modif (03 September 2008) by J. M. Quesada for external choice of inverse
+// cross section option
+// Modified:
+// 03-09-2008 J.M. Quesada for external choice of inverse cross section option
+// 17-11-2010 V.Ivanchenko integer Z and A
 #include "G4TritonEvaporationProbability.hh"
 …
 G4TritonEvaporationProbability::G4TritonEvaporationProbability() :
     G4EvaporationProbability(3,1,2,&theCoulombBarrier) // A,Z,Gamma,&theCoulombBarrier
+{
+}
+G4TritonEvaporationProbability::G4TritonEvaporationProbability(const G4TritonEvaporationProbability &) : G4EvaporationProbability()
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4TritonEvaporationProbability::copy_constructor meant to not be accessable");
+}
+const G4TritonEvaporationProbability & G4TritonEvaporationProbability::
+operator=(const G4TritonEvaporationProbability &)
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4TritonEvaporationProbability::operator= meant to not be accessable");
+    return *this;
+}
+G4bool G4TritonEvaporationProbability::operator==(const G4TritonEvaporationProbability &) const
+{
+    return false;
+}
+G4bool G4TritonEvaporationProbability::operator!=(const G4TritonEvaporationProbability &) const
+{
+    return true;
+}
+   G4double G4TritonEvaporationProbability::CalcAlphaParam(const G4Fragment & fragment)
+  { return 1.0 + CCoeficient(static_cast<G4double>(fragment.GetZ()-GetZ()));}
+{}
+G4TritonEvaporationProbability::~G4TritonEvaporationProbability()
+{}
+G4double G4TritonEvaporationProbability::CalcAlphaParam(const G4Fragment & fragment)
+{
+  return 1.0 + CCoeficient(fragment.GetZ_asInt()-GetZ());
+}
+  G4double G4TritonEvaporationProbability::CalcBetaParam(const G4Fragment & )
+  { return 0.0; }
+G4double G4TritonEvaporationProbability::CCoeficient(const G4double aZ)
+{
+    // Data comes from
+    // Dostrovsky, Fraenkel and Friedlander
+    // Physical Review, vol 116, num. 3 1959
+    //
+    // const G4int size = 5;
+    // G4double Zlist[5] = { 10.0, 20.0, 30.0, 50.0, 70.0};
+    // G4double Cp[5] = { 0.50, 0.28, 0.20, 0.15, 0.10};
+    // C for triton is equal to C for protons divided by 3
+    G4double C = 0.0;
+G4double G4TritonEvaporationProbability::CalcBetaParam(const G4Fragment & )
+{
+  return 0.0;
+}
+G4double G4TritonEvaporationProbability::CCoeficient(G4int aZ)
+{
+  // Data comes from
+  // Dostrovsky, Fraenkel and Friedlander
+  // Physical Review, vol 116, num. 3 1959
+  //
+  // const G4int size = 5;
+  // G4double Zlist[5] = { 10.0, 20.0, 30.0, 50.0, 70.0};
+  // G4double Cp[5] = { 0.50, 0.28, 0.20, 0.15, 0.10};
+  // C for triton is equal to C for protons divided by 3
+  G4double C = 0.0;
     if (aZ >= 70) {
         C = 0.10;
     } else {
         C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375;
+    }
+  if (aZ >= 70) {
+    C = 0.10;
+  } else {
+    C = ((((0.15417e-06*aZ) - 0.29875e-04)*aZ + 0.21071e-02)*aZ - 0.66612e-01)*aZ + 0.98375;
+  }
+    return C/3.0;
+  return C/3.0;
+}
 …
 //OPT=3,4 Kalbach's parameterization
 //
+G4double G4TritonEvaporationProbability::CrossSection(const  G4Fragment & fragment, const  G4double K)
+G4double
+G4TritonEvaporationProbability::CrossSection(const  G4Fragment & fragment, G4double K)
+{
   theA=GetA();
   theZ=GetZ();
   ResidualA=fragment.GetA()-theA;
   ResidualZ=fragment.GetZ()-theZ;
+  ResidualA=fragment.GetA_asInt()-theA;
+  ResidualZ=fragment.GetZ_asInt()-theZ;
+  ResidualAthrd=std::pow(ResidualA,0.33333);
+  FragmentA=fragment.GetA();
+  FragmentAthrd=std::pow(FragmentA,0.33333);
+  ResidualAthrd=fG4pow->Z13(ResidualA);
+  FragmentA=fragment.GetA_asInt();
+  FragmentAthrd=fG4pow->Z13(FragmentA);
   if (OPTxs==0) {std::ostringstream errOs;
     errOs << "We should'n be here (OPT =0) at evaporation cross section calculation (tritons)!!"
 …
 //
 //********************* OPT=1,2 : Chatterjee's cross section ************************
+//********************* OPT=1,2 : Chatterjee's cross section *****************
 //(fitting to cross section from Bechetti & Greenles OM potential)
+G4double G4TritonEvaporationProbability::GetOpt12(const  G4double K)
+{
+G4double G4TritonEvaporationProbability::GetOpt12(G4double K)
+{
   G4double Kc=K;
+// JMQ xsec is set constat above limit of validity
+  if (K>50) Kc=50;
+ G4double landa ,mu ,nu ,p , Ec,q,r,ji,xs;
+//G4double Eo(0),epsilon1(0),epsilon2(0),discri(0);
+  // JMQ xsec is set constat above limit of validity
+  if (K > 50*MeV) { Kc=50*MeV; }
+  G4double landa ,mu ,nu ,p , Ec,q,r,ji,xs;
+ G4double    p0 = -11.04;
+ G4double    p1 = 619.1;
+ G4double    p2 = -2147.;
+ G4double    landa0 = -0.0426;
+ G4double    landa1 = -10.33;
+ G4double    mu0 = 601.9;
+ G4double    mu1 = 0.37;
+ G4double    nu0 = 583.0;
+ G4double    nu1 = -546.2;
+ G4double    nu2 = 1.718;
+ G4double    delta=1.2;
+ Ec = 1.44*theZ*ResidualZ/(1.5*ResidualAthrd+delta);
+ p = p0 + p1/Ec + p2/(Ec*Ec);
+ landa = landa0*ResidualA + landa1;
+ mu = mu0*std::pow(ResidualA,mu1);
+ nu = std::pow(ResidualA,mu1)*(nu0 + nu1*Ec + nu2*(Ec*Ec));
+ q = landa - nu/(Ec*Ec) - 2*p*Ec;
+ r = mu + 2*nu/Ec + p*(Ec*Ec);
+ ji=std::max(Kc,Ec);
+ if(Kc < Ec) { xs = p*Kc*Kc + q*Kc + r;}
+ else {xs = p*(Kc - ji)*(Kc - ji) + landa*Kc + mu + nu*(2 - Kc/ji)/ji ;}
+ if (xs <0.0) {xs=0.0;}
+ return xs;
+  G4double    p0 = -11.04;
+  G4double    p1 = 619.1;
+  G4double    p2 = -2147.;
+  G4double    landa0 = -0.0426;
+  G4double    landa1 = -10.33;
+  G4double    mu0 = 601.9;
+  G4double    mu1 = 0.37;
+  G4double    nu0 = 583.0;
+  G4double    nu1 = -546.2;
+  G4double    nu2 = 1.718;
+  G4double    delta=1.2;
+  Ec = 1.44*theZ*ResidualZ/(1.5*ResidualAthrd+delta);
+  p = p0 + p1/Ec + p2/(Ec*Ec);
+  landa = landa0*ResidualA + landa1;
+  G4double resmu1 = fG4pow->powZ(ResidualA,mu1);
+  mu = mu0*resmu1;
+  nu = resmu1*(nu0 + nu1*Ec + nu2*(Ec*Ec));
+  q = landa - nu/(Ec*Ec) - 2*p*Ec;
+  r = mu + 2*nu/Ec + p*(Ec*Ec);
+  ji=std::max(Kc,Ec);
+  if(Kc < Ec) { xs = p*Kc*Kc + q*Kc + r;}
+  else {xs = p*(Kc - ji)*(Kc - ji) + landa*Kc + mu + nu*(2 - Kc/ji)/ji ;}
+  if (xs <0.0) {xs=0.0;}
+  return xs;
+}
 // *********** OPT=3,4 : Kalbach's cross sections (from PRECO code)*************
 G4double G4TritonEvaporationProbability::GetOpt34(const  G4double K)
+G4double G4TritonEvaporationProbability::GetOpt34(G4double K)
 //     ** t from o.m. of hafele, flynn et al
+{
   G4double landa, mu, nu, p , signor(1.),sig;
   G4double ec,ecsq,xnulam,etest(0.),a;
   G4double b,ecut,cut,ecut2,geom,elab;
   G4double     flow = 1.e-18;
   G4double     spill= 1.e+18;
 …
   p = p0 + p1/ec + p2/ecsq;
   landa = landa0*ResidualA + landa1;
   a = std::pow(ResidualA,mu1);
+  a = fG4pow->powZ(ResidualA,mu1);
   mu = mu0 * a;
   nu = a* (nu0+nu1*ec+nu2*ecsq);
   xnulam = nu / landa;
   if (xnulam > spill) xnulam=0.;
   if (xnulam >= flow) etest = 1.2 *std::sqrt(xnulam);
+  if (xnulam > spill) { xnulam=0.; }
+  if (xnulam >= flow) { etest = 1.2 *std::sqrt(xnulam); }
   a = -2.*p*ec + landa - nu/ecsq;
   b = p*ecsq + mu + 2.*nu/ec;
   ecut = 0.;
   cut = a*a - 4.*p*b;
   if (cut > 0.) ecut = std::sqrt(cut);
+  if (cut > 0.) { ecut = std::sqrt(cut); }
   ecut = (ecut-a) / (p+p);
   ecut2 = ecut;
+//JMQ 290310 for avoiding unphysical increase below minimum (at ecut)
+//ecut<0 means that there is no cut with energy axis, i.e. xs is set to 0 bellow minimum
+//  if (cut < 0.) ecut2 = ecut - 2.;
+  if (cut < 0.) ecut2 = ecut;
+  elab = K * FragmentA / ResidualA;
+  //JMQ 290310 for avoiding unphysical increase below minimum (at ecut)
+  // ecut<0 means that there is no cut with energy axis, i.e. xs is set
+  // to 0 bellow minimum
+  //  if (cut < 0.) ecut2 = ecut - 2.;
+  if (cut < 0.) { ecut2 = ecut; }
+  elab = K * FragmentA / G4double(ResidualA);
   sig = 0.;
   if (elab <= ec) { //start for E<Ec
     if (elab > ecut2)  sig = (p*elab*elab+a*elab+b) * signor;
+    if (elab > ecut2) { sig = (p*elab*elab+a*elab+b) * signor; }
   }           //end for E<Ec
   else {           //start for E>Ec
+  else {           //start for E>Ec
     sig = (landa*elab+mu+nu/elab) * signor;
     geom = 0.;
     if (xnulam < flow || elab < etest) return sig;
+    if (xnulam < flow || elab < etest) { return sig; }
     geom = std::sqrt(theA*K);
     geom = 1.23*ResidualAthrd + ra + 4.573/geom;
 …
   }           //end for E>Ec
   return sig;
+}
+//   ************************** end of cross sections *******************************
+}

trunk/source/processes/hadronic/models/de_excitation/evaporation/src/G4UnstableFragmentBreakUp.cc

r1340	r1347
25	25	//
26	26	// $Id: G4UnstableFragmentBreakUp.cc,v 1.8 2010/06/25 09:46:09 gunter Exp $
27		// GEANT4 tag $Name: geant4-09-0~~3-ref-09~~ $
	27	// GEANT4 tag $Name: geant4-09-04-ref-00 $
28	28	//
29	29	// -------------------------------------------------------------------

trunk/source/processes/hadronic/models/de_excitation/evaporation/src/G4VEvaporation.cc

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4VEvaporation.cc,v 1.7 2010/04/27 14:00:40 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4VEvaporation.cc,v 1.8 2010/10/29 17:35:03 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 #include "G4VEvaporation.hh"
 G4VEvaporation::G4VEvaporation()
+G4VEvaporation::G4VEvaporation():OPTxs(3),useSICB(false)
 {}

trunk/source/processes/hadronic/models/de_excitation/fermi_breakup/include/G4VFermiFragment.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4VFermiFragment.hh,v 1.3 2006/06/29 20:12:37 gunter Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4VFermiFragment.hh,v 1.4 2010/10/29 17:35:03 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 #include "G4FragmentVector.hh"
+#include "G4NucleiProperties.hh"
+#include "G4ParticleTable.hh"
+#include "G4IonTable.hh"
+#include "globals.hh"
 class G4VFermiFragment
+{
 public:
+  G4VFermiFragment(const G4int anA, const G4int aZ, const G4int Pol, const G4double ExE):
+    A(anA),
+    Z(aZ),
+    Polarization(Pol),
+    ExcitEnergy(ExE)
+    {}
+  G4VFermiFragment(G4int anA, G4int aZ, G4int Pol, G4double ExE);
   virtual ~G4VFermiFragment() {};
+  virtual ~G4VFermiFragment();
 protected:
   G4VFermiFragment() {};
+  G4VFermiFragment();
 private:
 …
   virtual G4FragmentVector * GetFragment(const G4LorentzVector & aMomentum) const = 0;
   G4int GetA(void) const
+  inline G4int GetA(void) const
+  {
     return A;
+  }
   G4int GetZ(void) const
+  inline G4int GetZ(void) const
+  {
     return Z;
+  }
   G4int GetPolarization(void) const
+  inline G4int GetPolarization(void) const
+  {
     return Polarization;
+  }
   G4double GetExcitationEnergy(void) const
+  inline G4double GetExcitationEnergy(void) const
+  {
     return ExcitEnergy;
+  }
   G4double GetFragmentMass(void) const
+  inline G4double GetFragmentMass(void) const
+  {
     return G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z,A);
+    return fragmentMass;
+  }
   G4double GetTotalEnergy(void) const
+  inline G4double GetTotalEnergy(void) const
+  {
     return this->GetFragmentMass() + this->GetExcitationEnergy();
+    return (GetFragmentMass() + GetExcitationEnergy());
+  }
 …
   G4double ExcitEnergy;
+  G4double fragmentMass;
 };

trunk/source/processes/hadronic/models/de_excitation/fermi_breakup/src/G4VFermiFragment.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4VFermiFragment.cc,v 1.5 2006/06/29 20:13:15 gunter Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4VFermiFragment.cc,v 1.6 2010/10/29 17:35:03 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 #include "G4VFermiFragment.hh"
 #include "G4HadronicException.hh"
+#include "G4NucleiProperties.hh"
+G4VFermiFragment::G4VFermiFragment(const G4VFermiFragment &)
+G4VFermiFragment::G4VFermiFragment(G4int anA, G4int aZ, G4int Pol, G4double ExE):
+    A(anA),
+    Z(aZ),
+    Polarization(Pol),
+    ExcitEnergy(ExE)
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4VFermiFragment::copy_constructor meant to not be accessable");
+  fragmentMass = 0.0;
+  if(A > 0) { fragmentMass = G4NucleiProperties::GetNuclearMass(A, Z); }
+}
+const G4VFermiFragment & G4VFermiFragment::operator=(const G4VFermiFragment &)
+G4VFermiFragment::G4VFermiFragment():
+    A(0),
+    Z(0),
+    Polarization(0),
+    ExcitEnergy(0.0)
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4VFermiFragment::operator= meant to not be accessable");
+    return *this;
+  fragmentMass = 0.0;
+}
+G4bool G4VFermiFragment::operator==(const G4VFermiFragment &) const
+{
+    return false;
+}
+G4bool G4VFermiFragment::operator!=(const G4VFermiFragment &) const
+{
+    return true;
+}
+G4VFermiFragment::~G4VFermiFragment()
+{}

trunk/source/processes/hadronic/models/de_excitation/fission/include/G4CompetitiveFission.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4CompetitiveFission.hh,v 1.3 2006/06/29 20:13:19 gunter Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4CompetitiveFission.hh,v 1.5 2010/11/17 20:22:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 private:
   G4CompetitiveFission(const G4CompetitiveFission &right);
   const G4CompetitiveFission & operator=(const G4CompetitiveFission &right);
-public:
   G4bool operator==(const G4CompetitiveFission &right) const;
   G4bool operator!=(const G4CompetitiveFission &right) const;
 …
   G4double LevelDensityParameter;
   //  --------------------
   // Sample AtomicNumber of Fission products
   G4int FissionAtomicNumber(const G4int A, const G4FissionParameters & theParam);
   G4double MassDistribution(const G4double x, const G4double A, const G4FissionParameters & theParam);
+  G4int FissionAtomicNumber(G4int A, const G4FissionParameters & theParam);
+  G4double MassDistribution(G4double x, G4double A, const G4FissionParameters & theParam);
   // Sample Charge of fission products
   G4int FissionCharge(const G4double A, const G4double Z, const G4double Af);
+  G4int FissionCharge(G4double A, G4double Z, G4double Af);
   // Sample Kinetic energy of fission products
   G4double FissionKineticEnergy(const G4double A, const G4double Z,
                                 const G4double Af1, const G4double Zf1,
                                 const G4double Af2, const G4double Zf2,
                                 const G4double U, const G4double Tmax,
+  G4double FissionKineticEnergy(G4int A, G4int Z,
+                                G4double Af1, G4double Zf1,
+                                G4double Af2, G4double Zf2,
+                                G4double U, G4double Tmax,
                                 const G4FissionParameters & theParam);
+  G4double Ratio(G4double A, G4double A11, G4double B1, G4double A00);
+  G4double SymmetricRatio(G4int A, G4double A11);
+  G4double AsymmetricRatio(G4int A, G4double A11);
+  G4double Ratio(const G4double A,const G4double A11,const G4double B1,const G4double A00);
+  G4double SymmetricRatio(const G4double A,const G4double A11);
+  G4double AsymmetricRatio(const G4double A,const G4double A11);
+  G4ThreeVector IsotropicVector(const G4double Magnitude = 1.0);
+  G4ThreeVector IsotropicVector(G4double Magnitude = 1.0);
 #ifdef debug
 …
 #endif
 };
 #endif

trunk/source/processes/hadronic/models/de_excitation/fission/include/G4FissionBarrier.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4FissionBarrier.hh,v 1.5 2009/12/16 16:50:07 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4FissionBarrier.hh,v 1.6 2010/11/17 20:22:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
+{
 public:
   G4FissionBarrier() {};
   ~G4FissionBarrier() {};
+  G4FissionBarrier();
+  ~G4FissionBarrier();
 private:
 …
 public:
   G4double FissionBarrier(const G4int A, const G4int Z, const G4double U);
+  G4double FissionBarrier(G4int A, G4int Z, G4double U);
 private:
   G4double BarashenkovFissionBarrier(const G4int A, const G4int Z);
+  G4double BarashenkovFissionBarrier(G4int A, G4int Z);
   G4double SellPlusPairingCorrection(const G4int Z, const G4int N)
+  inline G4double SellPlusPairingCorrection(G4int Z, G4int N)
+  {
     G4CameronShellPlusPairingCorrections* SPtr = G4CameronShellPlusPairingCorrections::GetInstance();

trunk/source/processes/hadronic/models/de_excitation/fission/include/G4FissionLevelDensityParameter.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4FissionLevelDensityParameter.hh,v 1.3 2006/06/29 20:13:23 gunter Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4FissionLevelDensityParameter.hh,v 1.4 2010/11/17 20:22:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
+{
 public:
   G4FissionLevelDensityParameter() {};
   virtual ~G4FissionLevelDensityParameter() {};
+  G4FissionLevelDensityParameter();
+  virtual ~G4FissionLevelDensityParameter();
 private:
 …
 public:
   G4double LevelDensityParameter(const G4int A,const G4int Z,const G4double U) const;
+  G4double LevelDensityParameter(G4int A, G4int Z, G4double U) const;

trunk/source/processes/hadronic/models/de_excitation/fission/include/G4FissionParameters.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4FissionParameters.hh,v 1.3 2006/06/29 20:13:25 gunter Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4FissionParameters.hh,v 1.4 2010/11/17 20:22:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 public:
   // Only available constructor
   G4FissionParameters(const G4int A, const G4int Z, const G4double ExEnergy, const G4double FissionBarrier);
+  G4FissionParameters(G4int A, G4int Z, G4double ExEnergy, G4double FissionBarrier);
   ~G4FissionParameters() {};
+  ~G4FissionParameters();
 private:
   // Default constructor
   G4FissionParameters() {};
+  G4FissionParameters();
   // Copy constructor

trunk/source/processes/hadronic/models/de_excitation/fission/include/G4FissionProbability.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4FissionProbability.hh,v 1.3 2006/06/29 20:13:27 gunter Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4FissionProbability.hh,v 1.4 2010/11/17 20:22:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 public:
   // Default constructor
   G4FissionProbability() {};
+  G4FissionProbability();
   ~G4FissionProbability() {};
+  ~G4FissionProbability();
 private:
 …
 public:
         G4double EmissionProbability(const G4Fragment & fragment, const G4double MaximalKineticEnergy);
+  G4double EmissionProbability(const G4Fragment & fragment, G4double MaximalKineticEnergy);
 private:
         G4EvaporationLevelDensityParameter theEvapLDP;
         G4FissionLevelDensityParameter theFissLDP;
+  G4EvaporationLevelDensityParameter theEvapLDP;
+  G4FissionLevelDensityParameter theFissLDP;

trunk/source/processes/hadronic/models/de_excitation/fission/include/G4ParaFissionModel.hh

-              r819
+              r1347
 //
 #ifndef G4ParaFissionModel_h
 #define G4ParaFissionModel_h
+#define G4ParaFissionModel_h 1
 #include "G4CompetitiveFission.hh"
 …
     SetMaxEnergy( 60.*MeV );
+  }
+  ~G4ParaFissionModel() {};
   virtual G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
                                               G4Nucleus& theNucleus)
+                                         G4Nucleus& theNucleus)
+  {
     theParticleChange.Clear();
 …
     // prepare the fragment
+    G4Fragment anInitialState;
+    G4double anA = theNucleus.GetN();
+    G4double aZ = theNucleus.GetZ();
+    G4double nucMass = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(G4int(aZ) ,G4int(anA));
+    anA += aTrack.GetDefinition()->GetBaryonNumber();
+    aZ += aTrack.GetDefinition()->GetPDGCharge();
+    G4int A = theNucleus.GetA_asInt();
+    G4int Z = theNucleus.GetZ_asInt();
+    G4double nucMass =
+      G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z,A);
     G4int numberOfEx = aTrack.GetDefinition()->GetBaryonNumber();
     G4int numberOfCh = G4int(std::abs(aTrack.GetDefinition()->GetPDGCharge()));
+    G4int numberOfCh = G4int(aTrack.GetDefinition()->GetPDGCharge() + 0.5);
     G4int numberOfHoles = 0;
+    A += numberOfEx;
+    Z += numberOfCh;
+    G4ThreeVector exciton3Momentum = aTrack.Get4Momentum().vect();
+    G4double compoundMass = aTrack.GetTotalEnergy();
+    compoundMass += nucMass;
+    compoundMass = std::sqrt(compoundMass*compoundMass - exciton3Momentum*exciton3Momentum);
+    G4LorentzVector fragment4Momentum(exciton3Momentum,
+                               std::sqrt(exciton3Momentum.mag2()+compoundMass*compoundMass));
+    anInitialState.SetA(anA);
+    anInitialState.SetZ(aZ);
+    anInitialState.SetNumberOfParticles(numberOfEx-numberOfHoles);
+    anInitialState.SetNumberOfCharged(numberOfCh);
+    anInitialState.SetNumberOfHoles(numberOfHoles);
+    anInitialState.SetMomentum(fragment4Momentum);
+    G4LorentzVector v = aTrack.Get4Momentum() + G4LorentzVector(0.0,0.0,0.0,nucMass);
+    G4Fragment anInitialState(Z,A,v);
+    anInitialState.SetNumberOfExcitedParticle(numberOfEx,numberOfCh);
+    anInitialState.SetNumberOfHoles(0,0);
     // do the fission
 …
+        {
           G4ReactionProduct* rp0 = (*theExcitationResult)[j];
+          G4DynamicParticle* p0 = new G4DynamicParticle;
+          p0->SetDefinition(rp0->GetDefinition() );
+          p0->SetMomentum(rp0->GetMomentum() );
+          G4DynamicParticle* p0 =
+            new G4DynamicParticle(rp0->GetDefinition(),rp0->GetMomentum());
           theParticleChange.AddSecondary(p0);
           delete rp0;
 …
+      {
         // add secondary
         G4DynamicParticle* p0 = new G4DynamicParticle;
         p0->SetDefinition(aFragment->GetParticleDefinition());
         p0->SetMomentum(aFragment->GetMomentum().vect());
+        G4DynamicParticle* p0 =
+          new G4DynamicParticle(aFragment->GetParticleDefinition(),
+                                aFragment->GetMomentum());
         theParticleChange.AddSecondary(p0);
+      }

trunk/source/processes/hadronic/models/de_excitation/fission/include/G4VFissionBarrier.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4VFissionBarrier.hh,v 1.4 2006/06/29 20:13:31 gunter Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4VFissionBarrier.hh,v 1.5 2010/11/17 20:22:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
+{
 public:
   G4VFissionBarrier() {};
   virtual ~G4VFissionBarrier() {};
+  G4VFissionBarrier();
+  virtual ~G4VFissionBarrier();
 private:
 …
 public:
   virtual G4double FissionBarrier(const G4int A, const G4int Z,const G4double U) = 0;
+  virtual G4double FissionBarrier(G4int A, G4int Z,const G4double U) = 0;

trunk/source/processes/hadronic/models/de_excitation/fission/src/G4CompetitiveFission.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4CompetitiveFission.cc,v 1.12 2010/05/03 16:49:19 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4CompetitiveFission.cc,v 1.14 2010/11/17 20:22:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 #include "G4PairingCorrection.hh"
 #include "G4ParticleMomentum.hh"
+#include "G4Pow.hh"
 G4CompetitiveFission::G4CompetitiveFission() : G4VEvaporationChannel("fission")
 …
+}
-G4CompetitiveFission::G4CompetitiveFission(const G4CompetitiveFission &) : G4VEvaporationChannel()
+{
+}
 G4CompetitiveFission::~G4CompetitiveFission()
+{
 …
+}
-const G4CompetitiveFission & G4CompetitiveFission::operator=(const G4CompetitiveFission &)
+{
-    throw G4HadronicException(__FILE__, __LINE__, "G4CompetitiveFission::operator= meant to not be accessable");
-    return *this;
+}
-G4bool G4CompetitiveFission::operator==(const G4CompetitiveFission &right) const
+{
-    return (this == (G4CompetitiveFission *) &right);
+}
-G4bool G4CompetitiveFission::operator!=(const G4CompetitiveFission &right) const
+{
-    return (this != (G4CompetitiveFission *) &right);
+}
 void G4CompetitiveFission::Initialize(const G4Fragment & fragment)
+{
+    G4int anA = static_cast<G4int>(fragment.GetA());
+    G4int aZ = static_cast<G4int>(fragment.GetZ());
+    G4double ExEnergy = fragment.GetExcitationEnergy() -
+           G4PairingCorrection::GetInstance()->GetFissionPairingCorrection(anA,aZ);
+    // Saddle point excitation energy ---> A = 65
+    // Fission is excluded for A < 65
+    if (anA >= 65 && ExEnergy > 0.0) {
+        FissionBarrier = theFissionBarrierPtr->FissionBarrier(anA,aZ,ExEnergy);
+        MaximalKineticEnergy = ExEnergy - FissionBarrier;
+        LevelDensityParameter = theLevelDensityPtr->LevelDensityParameter(anA,aZ,ExEnergy);
+        FissionProbability = theFissionProbabilityPtr->EmissionProbability(fragment,MaximalKineticEnergy);
+    }
+    else {
+        MaximalKineticEnergy = -1000.0*MeV;
+        LevelDensityParameter = 0.0;
+        FissionProbability = 0.0;
+    }
+    return;
+}
+  G4int anA = fragment.GetA_asInt();
+  G4int aZ  = fragment.GetZ_asInt();
+  G4double ExEnergy = fragment.GetExcitationEnergy() -
+    G4PairingCorrection::GetInstance()->GetFissionPairingCorrection(anA,aZ);
+  // Saddle point excitation energy ---> A = 65
+  // Fission is excluded for A < 65
+  if (anA >= 65 && ExEnergy > 0.0) {
+    FissionBarrier = theFissionBarrierPtr->FissionBarrier(anA,aZ,ExEnergy);
+    MaximalKineticEnergy = ExEnergy - FissionBarrier;
+    LevelDensityParameter =
+      theLevelDensityPtr->LevelDensityParameter(anA,aZ,ExEnergy);
+    FissionProbability =
+      theFissionProbabilityPtr->EmissionProbability(fragment,MaximalKineticEnergy);
+    }
+  else {
+    MaximalKineticEnergy = -1000.0*MeV;
+    LevelDensityParameter = 0.0;
+    FissionProbability = 0.0;
+  }
+}
 G4FragmentVector * G4CompetitiveFission::BreakUp(const G4Fragment & theNucleus)
+{
+    // Nucleus data
+    // Atomic number of nucleus
+    G4int A = static_cast<G4int>(theNucleus.GetA());
+    // Charge of nucleus
+    G4int Z = static_cast<G4int>(theNucleus.GetZ());
+    //   Excitation energy (in MeV)
+    G4double U = theNucleus.GetExcitationEnergy() -
+        G4PairingCorrection::GetInstance()->GetFissionPairingCorrection(A,Z);
+    // Check that U > 0
+    if (U <= 0.0) {
+        G4FragmentVector * theResult = new  G4FragmentVector;
+        theResult->push_back(new G4Fragment(theNucleus));
+        return theResult;
+    }
+    // Atomic Mass of Nucleus (in MeV)
+    G4double M = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z,A);
+    // Nucleus Momentum
+    G4LorentzVector theNucleusMomentum = theNucleus.GetMomentum();
+    // Calculate fission parameters
+    G4FissionParameters theParameters(A,Z,U,FissionBarrier);
+    // First fragment
+    G4int A1 = 0;
+    G4int Z1 = 0;
+    G4double M1 = 0.0;
+    // Second fragment
+    G4int A2 = 0;
+    G4int Z2 = 0;
+    G4double M2 = 0.0;
+    G4double FragmentsExcitationEnergy = 0.0;
+    G4double FragmentsKineticEnergy = 0.0;
+    //JMQ 04/03/09 It will be used latter to fix the bug in energy conservation
+    G4double FissionPairingEnergy=G4PairingCorrection::GetInstance()->GetFissionPairingCorrection(A,Z);
+    G4int Trials = 0;
+    do {
+        // First fragment
+        A1 = FissionAtomicNumber(A,theParameters);
+        Z1 = FissionCharge(A,Z,A1);
+        M1 = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z1,A1);
+        // Second Fragment
+        A2 = A - A1;
+        Z2 = Z - Z1;
+        if (A2 < 1 || Z2 < 0)
+            throw G4HadronicException(__FILE__, __LINE__, "G4CompetitiveFission::BreakUp: Can't define second fragment! ");
+        M2 = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z2,A2);
+        // Check that fragment masses are less or equal than total energy
+        if (M1 + M2 > theNucleusMomentum.e())
+            throw G4HadronicException(__FILE__, __LINE__, "G4CompetitiveFission::BreakUp: Fragments Mass > Total Energy");
+        // Maximal Kinetic Energy (available energy for fragments)
+        G4double Tmax = M + U - M1 - M2;
+        FragmentsKineticEnergy = FissionKineticEnergy( A , Z,
+                                                       A1, Z1,
+                                                       A2, Z2,
+                                                       U , Tmax,
+                                                       theParameters);
+  // Nucleus data
+  // Atomic number of nucleus
+  G4int A = theNucleus.GetA_asInt();
+  // Charge of nucleus
+  G4int Z = theNucleus.GetZ_asInt();
+  //   Excitation energy (in MeV)
+  G4double U = theNucleus.GetExcitationEnergy() -
+    G4PairingCorrection::GetInstance()->GetFissionPairingCorrection(A,Z);
+  // Check that U > 0
+  if (U <= 0.0) {
+    G4FragmentVector * theResult = new  G4FragmentVector;
+    theResult->push_back(new G4Fragment(theNucleus));
+    return theResult;
+  }
+  // Atomic Mass of Nucleus (in MeV)
+  G4double M = theNucleus.GetGroundStateMass();
+  // Nucleus Momentum
+  G4LorentzVector theNucleusMomentum = theNucleus.GetMomentum();
+  // Calculate fission parameters
+  G4FissionParameters theParameters(A,Z,U,FissionBarrier);
+  // First fragment
+  G4int A1 = 0;
+  G4int Z1 = 0;
+  G4double M1 = 0.0;
+  // Second fragment
+  G4int A2 = 0;
+  G4int Z2 = 0;
+  G4double M2 = 0.0;
+  G4double FragmentsExcitationEnergy = 0.0;
+  G4double FragmentsKineticEnergy = 0.0;
+  //JMQ 04/03/09 It will be used latter to fix the bug in energy conservation
+  G4double FissionPairingEnergy=
+    G4PairingCorrection::GetInstance()->GetFissionPairingCorrection(A,Z);
+  G4int Trials = 0;
+  do {
+    // First fragment
+    A1 = FissionAtomicNumber(A,theParameters);
+    Z1 = FissionCharge(A,Z,A1);
+    M1 = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z1,A1);
+    // Second Fragment
+    A2 = A - A1;
+    Z2 = Z - Z1;
+    if (A2 < 1 || Z2 < 0) {
+      throw G4HadronicException(__FILE__, __LINE__,
+        "G4CompetitiveFission::BreakUp: Can't define second fragment! ");
+    }
+    M2 = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z2,A2);
+    // Check that fragment masses are less or equal than total energy
+    if (M1 + M2 > theNucleusMomentum.e()) {
+      throw G4HadronicException(__FILE__, __LINE__,
+        "G4CompetitiveFission::BreakUp: Fragments Mass > Total Energy");
+    }
+    // Maximal Kinetic Energy (available energy for fragments)
+    G4double Tmax = M + U - M1 - M2;
+    FragmentsKineticEnergy = FissionKineticEnergy( A , Z,
+                                                   A1, Z1,
+                                                   A2, Z2,
+                                                   U , Tmax,
+                                                   theParameters);
+        // Excitation Energy
+        //      FragmentsExcitationEnergy = Tmax - FragmentsKineticEnergy;
+        // JMQ 04/03/09 BUG FIXED: in order to fulfill energy conservation the
+        // fragments carry the fission pairing energy in form of
+        //excitation energy
+        FragmentsExcitationEnergy = Tmax - FragmentsKineticEnergy+FissionPairingEnergy;
+    } while (FragmentsExcitationEnergy < 0.0 && Trials++ < 100);
+    // Excitation Energy
+    //  FragmentsExcitationEnergy = Tmax - FragmentsKineticEnergy;
+    // JMQ 04/03/09 BUG FIXED: in order to fulfill energy conservation the
+    // fragments carry the fission pairing energy in form of
+    //excitation energy
+    FragmentsExcitationEnergy =
+      Tmax - FragmentsKineticEnergy+FissionPairingEnergy;
+  } while (FragmentsExcitationEnergy < 0.0 && Trials++ < 100);
+    if (FragmentsExcitationEnergy <= 0.0)
+        throw G4HadronicException(__FILE__, __LINE__, "G4CompetitiveFission::BreakItUp: Excitation energy for fragments < 0.0!");
+    // while (FragmentsExcitationEnergy < 0 && Trials < 100);
+    // Fragment 1
+    G4double U1 = FragmentsExcitationEnergy * (static_cast<G4double>(A1)/static_cast<G4double>(A));
+  if (FragmentsExcitationEnergy <= 0.0) {
+    throw G4HadronicException(__FILE__, __LINE__,
+      "G4CompetitiveFission::BreakItUp: Excitation energy for fragments < 0.0!");
+  }
+  // while (FragmentsExcitationEnergy < 0 && Trials < 100);
+  // Fragment 1
+  G4double U1 = FragmentsExcitationEnergy * A1/static_cast<G4double>(A);
     // Fragment 2
+    G4double U2 = FragmentsExcitationEnergy * (static_cast<G4double>(A2)/static_cast<G4double>(A));
+    //JMQ  04/03/09 Full relativistic calculation is performed
+    //
+    G4double Fragment1KineticEnergy=(FragmentsKineticEnergy*(FragmentsKineticEnergy+2*(M2+U2)))/(2*(M1+U1+M2+U2+FragmentsKineticEnergy));
+    G4ParticleMomentum Momentum1(IsotropicVector(std::sqrt(Fragment1KineticEnergy*(Fragment1KineticEnergy+2*(M1+U1)))));
+    G4ParticleMomentum Momentum2(-Momentum1);
+    G4LorentzVector FourMomentum1(Momentum1,std::sqrt(Momentum1.mag2()+(M1+U1)*(M1+U1)));
+    G4LorentzVector FourMomentum2(Momentum2,std::sqrt(Momentum2.mag2()+(M2+U2)*(M2+U2)));
+    //JMQ 04/03/09 now we do Lorentz boosts (instead of Galileo boosts)
+    FourMomentum1.boost(theNucleusMomentum.boostVector());
+    FourMomentum2.boost(theNucleusMomentum.boostVector());
+  G4double U2 = FragmentsExcitationEnergy * A2/static_cast<G4double>(A);
+  //JMQ  04/03/09 Full relativistic calculation is performed
+  //
+  G4double Fragment1KineticEnergy=
+    (FragmentsKineticEnergy*(FragmentsKineticEnergy+2*(M2+U2)))
+    /(2*(M1+U1+M2+U2+FragmentsKineticEnergy));
+  G4ParticleMomentum Momentum1(IsotropicVector(std::sqrt(Fragment1KineticEnergy*(Fragment1KineticEnergy+2*(M1+U1)))));
+  G4ParticleMomentum Momentum2(-Momentum1);
+  G4LorentzVector FourMomentum1(Momentum1,std::sqrt(Momentum1.mag2()+(M1+U1)*(M1+U1)));
+  G4LorentzVector FourMomentum2(Momentum2,std::sqrt(Momentum2.mag2()+(M2+U2)*(M2+U2)));
+  //JMQ 04/03/09 now we do Lorentz boosts (instead of Galileo boosts)
+  FourMomentum1.boost(theNucleusMomentum.boostVector());
+  FourMomentum2.boost(theNucleusMomentum.boostVector());
+    //////////JMQ 04/03: Old version calculation is commented
+    // There was vioation of energy momentum conservation
+    //    G4double Pmax = std::sqrt( 2 * ( ( (M1+U1)*(M2+U2) ) /
+    //                          ( (M1+U1)+(M2+U2) ) ) * FragmentsKineticEnergy);
+    //G4ParticleMomentum momentum1 = IsotropicVector( Pmax );
+    //  G4ParticleMomentum momentum2( -momentum1 );
+    // Perform a Galileo boost for fragments
+    //    momentum1 += (theNucleusMomentum.boostVector() * (M1+U1));
+    //    momentum2 += (theNucleusMomentum.boostVector() * (M2+U2));
+    // Create 4-momentum for first fragment
+    // Warning!! Energy conservation is broken
+    //JMQ 04/03/09 ...NOT ANY MORE!! BUGS FIXED: Energy and momentum are NOW conserved
+    //    G4LorentzVector FourMomentum1( momentum1 , std::sqrt(momentum1.mag2() + (M1+U1)*(M1+U1)));
+    // Create 4-momentum for second fragment
+    // Warning!! Energy conservation is broken
+    //JMQ 04/03/09 ...NOT ANY MORE!! BUGS FIXED: Energy and momentum are NOW conserved
+    //    G4LorentzVector FourMomentum2( momentum2 , std::sqrt(momentum2.mag2() + (M2+U2)*(M2+U2)));
+    //////////
+    // Create Fragments
+    G4Fragment * Fragment1 = new G4Fragment( A1, Z1, FourMomentum1);
+    if (!Fragment1) throw G4HadronicException(__FILE__, __LINE__, "G4CompetitiveFission::BreakItUp: Can't create Fragment1! ");
+    G4Fragment * Fragment2 = new G4Fragment( A2, Z2, FourMomentum2);
+    if (!Fragment2) throw G4HadronicException(__FILE__, __LINE__, "G4CompetitiveFission::BreakItUp: Can't create Fragment2! ");
+#ifdef PRECOMPOUND_TEST
+    Fragment1->SetCreatorModel(G4String("G4CompetitiveFission"));
+    Fragment2->SetCreatorModel(G4String("G4CompetitiveFission"));
+  //////////JMQ 04/03: Old version calculation is commented
+  // There was vioation of energy momentum conservation
+  //    G4double Pmax = std::sqrt( 2 * ( ( (M1+U1)*(M2+U2) ) /
+  //                            ( (M1+U1)+(M2+U2) ) ) * FragmentsKineticEnergy);
+  //G4ParticleMomentum momentum1 = IsotropicVector( Pmax );
+  //  G4ParticleMomentum momentum2( -momentum1 );
+  // Perform a Galileo boost for fragments
+  //    momentum1 += (theNucleusMomentum.boostVector() * (M1+U1));
+  //    momentum2 += (theNucleusMomentum.boostVector() * (M2+U2));
+  // Create 4-momentum for first fragment
+  // Warning!! Energy conservation is broken
+  //JMQ 04/03/09 ...NOT ANY MORE!! BUGS FIXED: Energy and momentum are NOW conserved
+  //    G4LorentzVector FourMomentum1( momentum1 , std::sqrt(momentum1.mag2() + (M1+U1)*(M1+U1)));
+  // Create 4-momentum for second fragment
+  // Warning!! Energy conservation is broken
+  //JMQ 04/03/09 ...NOT ANY MORE!! BUGS FIXED: Energy and momentum are NOW conserved
+  //    G4LorentzVector FourMomentum2( momentum2 , std::sqrt(momentum2.mag2() + (M2+U2)*(M2+U2)));
+  //////////
+  // Create Fragments
+  G4Fragment * Fragment1 = new G4Fragment( A1, Z1, FourMomentum1);
+  G4Fragment * Fragment2 = new G4Fragment( A2, Z2, FourMomentum2);
+  // Create Fragment Vector
+  G4FragmentVector * theResult = new G4FragmentVector;
+  theResult->push_back(Fragment1);
+  theResult->push_back(Fragment2);
+#ifdef debug
+  CheckConservation(theNucleus,theResult);
 #endif
+    // Create Fragment Vector
+    G4FragmentVector * theResult = new G4FragmentVector;
+    theResult->push_back(Fragment1);
+    theResult->push_back(Fragment2);
+#ifdef debug
+    CheckConservation(theNucleus,theResult);
+#endif
+    return theResult;
+}
+G4int G4CompetitiveFission::FissionAtomicNumber(const G4int A, const G4FissionParameters & theParam)
+    // Calculates the atomic number of a fission product
+{
+    // For Simplicity reading code
+    const G4double A1 = theParam.GetA1();
+    const G4double A2 = theParam.GetA2();
+    const G4double As = theParam.GetAs();
+//    const G4double Sigma1 = theParam.GetSigma1();
+    const G4double Sigma2 = theParam.GetSigma2();
+    const G4double SigmaS = theParam.GetSigmaS();
+    const G4double w = theParam.GetW();
+//    G4double FasymAsym = 2.0*std::exp(-((A2-As)*(A2-As))/(2.0*Sigma2*Sigma2)) +
+//      std::exp(-((A1-As)*(A1-As))/(2.0*Sigma1*Sigma1));
+//    G4double FsymA1A2 = std::exp(-((As-(A1+A2))*(As-(A1+A2)))/(2.0*SigmaS*SigmaS));
+    G4double C2A = A2 + 3.72*Sigma2;
+    G4double C2S = As + 3.72*SigmaS;
+    G4double C2 = 0.0;
+    if (w > 1000.0 ) C2 = C2S;
+    else if (w < 0.001) C2 = C2A;
+    else C2 =  std::max(C2A,C2S);
+    G4double C1 = A-C2;
+    if (C1 < 30.0) {
+        C2 = A-30.0;
+        C1 = 30.0;
+    }
+    G4double Am1 = (As + A1)/2.0;
+    G4double Am2 = (A1 + A2)/2.0;
+    // Get Mass distributions as sum of symmetric and asymmetric Gasussians
+    G4double Mass1 = MassDistribution(As,A,theParam);
+    G4double Mass2 = MassDistribution(Am1,A,theParam);
+    G4double Mass3 = MassDistribution(A1,A,theParam);
+    G4double Mass4 = MassDistribution(Am2,A,theParam);
+    G4double Mass5 = MassDistribution(A2,A,theParam);
+    // get maximal value among Mass1,...,Mass5
+    G4double MassMax = Mass1;
+    if (Mass2 > MassMax) MassMax = Mass2;
+    if (Mass3 > MassMax) MassMax = Mass3;
+    if (Mass4 > MassMax) MassMax = Mass4;
+    if (Mass5 > MassMax) MassMax = Mass5;
+    // Sample a fragment mass number, which lies between C1 and C2
+    G4double m;
+    G4double Pm;
+    do {
+        m = C1+G4UniformRand()*(C2-C1);
+        Pm = MassDistribution(m,A,theParam);
+    } while (G4UniformRand() > Pm/MassMax);
+    return static_cast<G4int>(m+0.5);
+}
+G4double G4CompetitiveFission::MassDistribution(const G4double x, const G4double A,
+                                                const G4FissionParameters & theParam)
+    // This method gives mass distribution F(x) = F_{asym}(x)+w*F_{sym}(x)
+    // which consist of symmetric and asymmetric sum of gaussians components.
+{
+    G4double Xsym = std::exp(-0.5*(x-theParam.GetAs())*(x-theParam.GetAs())/
+                        (theParam.GetSigmaS()*theParam.GetSigmaS()));
+    G4double Xasym = std::exp(-0.5*(x-theParam.GetA2())*(x-theParam.GetA2())/
+                         (theParam.GetSigma2()*theParam.GetSigma2())) +
+        std::exp(-0.5*(x-(A-theParam.GetA2()))*(x-(A-theParam.GetA2()))/
+            (theParam.GetSigma2()*theParam.GetSigma2())) +
+.5*std::exp(-0.5*(x-theParam.GetA1())*(x-theParam.GetA1())/
+                (theParam.GetSigma1()*theParam.GetSigma1())) +
+.5*std::exp(-0.5*(x-(A-theParam.GetA1()))*(x-(A-theParam.GetA1()))/
+                (theParam.GetSigma1()*theParam.GetSigma1()));
+    if (theParam.GetW() > 1000) return Xsym;
+    else if (theParam.GetW() < 0.001) return Xasym;
+    else return theParam.GetW()*Xsym+Xasym;
+}
+G4int G4CompetitiveFission::FissionCharge(const G4double A,
+                                          const G4double Z,
+                                          const G4double Af)
+    // Calculates the charge of a fission product for a given atomic number Af
+{
+    const G4double sigma = 0.6;
+    G4double DeltaZ = 0.0;
+    if (Af >= 134.0) DeltaZ = -0.45;                    //                      134 <= Af
+    else if (Af <= (A-134.0)) DeltaZ = 0.45;             // Af <= (A-134)
+    else DeltaZ = -0.45*(Af-(A/2.0))/(134.0-(A/2.0));   //       (A-134) < Af < 134
+    G4double Zmean = (Af/A)*Z + DeltaZ;
+  return theResult;
+}
+G4int
+G4CompetitiveFission::FissionAtomicNumber(G4int A,
+                                          const G4FissionParameters & theParam)
+  // Calculates the atomic number of a fission product
+{
+  // For Simplicity reading code
+  const G4double A1 = theParam.GetA1();
+  const G4double A2 = theParam.GetA2();
+  const G4double As = theParam.GetAs();
+  //    const G4double Sigma1 = theParam.GetSigma1();
+  const G4double Sigma2 = theParam.GetSigma2();
+  const G4double SigmaS = theParam.GetSigmaS();
+  const G4double w = theParam.GetW();
+  //    G4double FasymAsym = 2.0*std::exp(-((A2-As)*(A2-As))/(2.0*Sigma2*Sigma2)) +
+  //    std::exp(-((A1-As)*(A1-As))/(2.0*Sigma1*Sigma1));
+  //    G4double FsymA1A2 = std::exp(-((As-(A1+A2))*(As-(A1+A2)))/(2.0*SigmaS*SigmaS));
+  G4double C2A = A2 + 3.72*Sigma2;
+  G4double C2S = As + 3.72*SigmaS;
+  G4double C2 = 0.0;
+  if (w > 1000.0 ) C2 = C2S;
+  else if (w < 0.001) C2 = C2A;
+  else C2 =  std::max(C2A,C2S);
+  G4double C1 = A-C2;
+  if (C1 < 30.0) {
+    C2 = A-30.0;
+    C1 = 30.0;
+  }
+  G4double Am1 = (As + A1)/2.0;
+  G4double Am2 = (A1 + A2)/2.0;
+  // Get Mass distributions as sum of symmetric and asymmetric Gasussians
+  G4double Mass1 = MassDistribution(As,A,theParam);
+  G4double Mass2 = MassDistribution(Am1,A,theParam);
+  G4double Mass3 = MassDistribution(A1,A,theParam);
+  G4double Mass4 = MassDistribution(Am2,A,theParam);
+  G4double Mass5 = MassDistribution(A2,A,theParam);
+  // get maximal value among Mass1,...,Mass5
+  G4double MassMax = Mass1;
+  if (Mass2 > MassMax) MassMax = Mass2;
+  if (Mass3 > MassMax) MassMax = Mass3;
+  if (Mass4 > MassMax) MassMax = Mass4;
+  if (Mass5 > MassMax) MassMax = Mass5;
+  // Sample a fragment mass number, which lies between C1 and C2
+  G4double m;
+  G4double Pm;
+  do {
+    m = C1+G4UniformRand()*(C2-C1);
+    Pm = MassDistribution(m,A,theParam);
+  } while (MassMax*G4UniformRand() > Pm);
+  return static_cast<G4int>(m+0.5);
+}
+G4double
+G4CompetitiveFission::MassDistribution(G4double x, G4double A,
+                                       const G4FissionParameters & theParam)
+  // This method gives mass distribution F(x) = F_{asym}(x)+w*F_{sym}(x)
+  // which consist of symmetric and asymmetric sum of gaussians components.
+{
+  G4double Xsym = std::exp(-0.5*(x-theParam.GetAs())*(x-theParam.GetAs())/
+                           (theParam.GetSigmaS()*theParam.GetSigmaS()));
+  G4double Xasym = std::exp(-0.5*(x-theParam.GetA2())*(x-theParam.GetA2())/
+                            (theParam.GetSigma2()*theParam.GetSigma2())) +
+    std::exp(-0.5*(x-(A-theParam.GetA2()))*(x-(A-theParam.GetA2()))/
+             (theParam.GetSigma2()*theParam.GetSigma2())) +
+.5*std::exp(-0.5*(x-theParam.GetA1())*(x-theParam.GetA1())/
+                 (theParam.GetSigma1()*theParam.GetSigma1())) +
+.5*std::exp(-0.5*(x-(A-theParam.GetA1()))*(x-(A-theParam.GetA1()))/
+                 (theParam.GetSigma1()*theParam.GetSigma1()));
+  if (theParam.GetW() > 1000) return Xsym;
+  else if (theParam.GetW() < 0.001) return Xasym;
+  else return theParam.GetW()*Xsym+Xasym;
+}
+G4int G4CompetitiveFission::FissionCharge(G4double A, G4double Z,
+                                          G4double Af)
+  // Calculates the charge of a fission product for a given atomic number Af
+{
+  const G4double sigma = 0.6;
+  G4double DeltaZ = 0.0;
+  if (Af >= 134.0) DeltaZ = -0.45;                    //                      134 <= Af
+  else if (Af <= (A-134.0)) DeltaZ = 0.45;             // Af <= (A-134)
+  else DeltaZ = -0.45*(Af-(A/2.0))/(134.0-(A/2.0));   //       (A-134) < Af < 134
+  G4double Zmean = (Af/A)*Z + DeltaZ;
+    G4double theZ;
+    do {
+        theZ = G4RandGauss::shoot(Zmean,sigma);
+    } while (theZ  < 1.0 || theZ > (Z-1.0) || theZ > Af);
+    //  return static_cast<G4int>(theZ+0.5);
+    return static_cast<G4int>(theZ+0.5);
+}
+G4double G4CompetitiveFission::FissionKineticEnergy(const G4double A, const G4double Z,
+                                                    const G4double Af1, const G4double /*Zf1*/,
+                                                    const G4double Af2, const G4double /*Zf2*/,
+                                                    const G4double /*U*/, const G4double Tmax,
+                                                    const G4FissionParameters & theParam)
+    // Gives the kinetic energy of fission products
+{
+    // Find maximal value of A for fragments
+    G4double AfMax = std::max(Af1,Af2);
+    if (AfMax < (A/2.0)) AfMax = A - AfMax;
+    // Weights for symmetric and asymmetric components
+    G4double Pas;
+    if (theParam.GetW() > 1000) Pas = 0.0;
+    else {
+        G4double P1 = 0.5*std::exp(-0.5*(AfMax-theParam.GetA1())*(AfMax-theParam.GetA1())/
+                              (theParam.GetSigma1()*theParam.GetSigma1()));
+        G4double P2 = std::exp(-0.5*(AfMax-theParam.GetA2())*(AfMax-theParam.GetA2())/
+                          (theParam.GetSigma2()*theParam.GetSigma2()));
+        Pas = P1+P2;
+    }
+    G4double Ps;
+    if (theParam.GetW() < 0.001) Ps = 0.0;
+    else
+        Ps = theParam.GetW()*std::exp(-0.5*(AfMax-theParam.GetAs())*(AfMax-theParam.GetAs())/
+                                 (theParam.GetSigmaS()*theParam.GetSigmaS()));
+    G4double Psy = Ps/(Pas+Ps);
+    // Fission fractions Xsy and Xas formed in symmetric and asymmetric modes
+    G4double PPas = theParam.GetSigma1() + 2.0 * theParam.GetSigma2();
+    G4double PPsy = theParam.GetW() * theParam.GetSigmaS();
+    G4double Xas = PPas / (PPas+PPsy);
+    G4double Xsy = PPsy / (PPas+PPsy);
+    // Average kinetic energy for symmetric and asymmetric components
+    G4double Eaverage = 0.1071*MeV*(Z*Z)/std::pow(A,1.0/3.0) + 22.2*MeV;
+    // Compute maximal average kinetic energy of fragments and Energy Dispersion (sqrt)
+    G4double TaverageAfMax;
+    G4double ESigma;
+    // Select randomly fission mode (symmetric or asymmetric)
+    if (G4UniformRand() > Psy) { // Asymmetric Mode
+        G4double A11 = theParam.GetA1()-0.7979*theParam.GetSigma1();
+        G4double A12 = theParam.GetA1()+0.7979*theParam.GetSigma1();
+        G4double A21 = theParam.GetA2()-0.7979*theParam.GetSigma2();
+        G4double A22 = theParam.GetA2()+0.7979*theParam.GetSigma2();
+        // scale factor
+        G4double ScaleFactor = 0.5*theParam.GetSigma1()*(AsymmetricRatio(A,A11)+AsymmetricRatio(A,A12))+
+            theParam.GetSigma2()*(AsymmetricRatio(A,A21)+AsymmetricRatio(A,A22));
+        // Compute average kinetic energy for fragment with AfMax
+        TaverageAfMax = (Eaverage + 12.5 * Xsy) * (PPas/ScaleFactor) * AsymmetricRatio(A,AfMax);
+        ESigma = 10.0*MeV; // MeV
+    } else { // Symmetric Mode
+        G4double As0 = theParam.GetAs() + 0.7979*theParam.GetSigmaS();
+        // scale factor
+        G4double ScaleFactor = theParam.GetW()*theParam.GetSigmaS()*SymmetricRatio(A,As0);
+        // Compute average kinetic energy for fragment with AfMax
+        TaverageAfMax = (Eaverage - 12.5*MeV*Xas) * (PPsy/ScaleFactor) * SymmetricRatio(A,AfMax);
+        ESigma = 8.0*MeV;
+    }
+    // Select randomly, in accordance with Gaussian distribution, fragment kinetic energy
+    G4double KineticEnergy;
+    G4int i = 0;
+    do {
+        KineticEnergy = G4RandGauss::shoot(TaverageAfMax,ESigma);
+        if (i++ > 100) return Eaverage;
+    } while (KineticEnergy < Eaverage-3.72*ESigma ||
+             KineticEnergy > Eaverage+3.72*ESigma ||
+             KineticEnergy > Tmax);
+    return KineticEnergy;
+}
+G4double G4CompetitiveFission::AsymmetricRatio(const G4double A,const G4double A11)
+{
+    const G4double B1 = 23.5;
+    const G4double A00 = 134.0;
+    return Ratio(A,A11,B1,A00);
+}
+G4double G4CompetitiveFission::SymmetricRatio(const G4double A,const G4double A11)
+{
+    const G4double B1 = 5.32;
+    const G4double A00 = A/2.0;
+    return Ratio(A,A11,B1,A00);
+}
+G4double G4CompetitiveFission::Ratio(const G4double A,const G4double A11,
+                                     const G4double B1,const G4double A00)
+{
+    if (A == 0) throw G4HadronicException(__FILE__, __LINE__, "G4CompetitiveFission::Ratio: A == 0!");
+    if (A11 >= A/2.0 && A11 <= (A00+10.0)) return 1.0-B1*((A11-A00)/A)*((A11-A00)/A);
+    else return 1.0-B1*(10.0/A)*(10.0/A)-2.0*(10.0/A)*B1*((A11-A00-10.0)/A);
+}
+  G4double theZ;
+  do {
+    theZ = G4RandGauss::shoot(Zmean,sigma);
+  } while (theZ  < 1.0 || theZ > (Z-1.0) || theZ > Af);
+  //  return static_cast<G4int>(theZ+0.5);
+  return static_cast<G4int>(theZ+0.5);
+}
+G4double
+G4CompetitiveFission::FissionKineticEnergy(G4int A, G4int Z,
+                                           G4double Af1, G4double /*Zf1*/,
+                                           G4double Af2, G4double /*Zf2*/,
+                                           G4double /*U*/, G4double Tmax,
+                                           const G4FissionParameters & theParam)
+  // Gives the kinetic energy of fission products
+{
+  // Find maximal value of A for fragments
+  G4double AfMax = std::max(Af1,Af2);
+  if (AfMax < (A/2.0)) AfMax = A - AfMax;
+  // Weights for symmetric and asymmetric components
+  G4double Pas;
+  if (theParam.GetW() > 1000) Pas = 0.0;
+  else {
+    G4double P1 = 0.5*std::exp(-0.5*(AfMax-theParam.GetA1())*(AfMax-theParam.GetA1())/
+                               (theParam.GetSigma1()*theParam.GetSigma1()));
+    G4double P2 = std::exp(-0.5*(AfMax-theParam.GetA2())*(AfMax-theParam.GetA2())/
+                           (theParam.GetSigma2()*theParam.GetSigma2()));
+    Pas = P1+P2;
+  }
+  G4double Ps;
+  if (theParam.GetW() < 0.001) Ps = 0.0;
+  else {
+    Ps = theParam.GetW()*std::exp(-0.5*(AfMax-theParam.GetAs())*(AfMax-theParam.GetAs())/
+                                  (theParam.GetSigmaS()*theParam.GetSigmaS()));
+  }
+  G4double Psy = Ps/(Pas+Ps);
+  // Fission fractions Xsy and Xas formed in symmetric and asymmetric modes
+  G4double PPas = theParam.GetSigma1() + 2.0 * theParam.GetSigma2();
+  G4double PPsy = theParam.GetW() * theParam.GetSigmaS();
+  G4double Xas = PPas / (PPas+PPsy);
+  G4double Xsy = PPsy / (PPas+PPsy);
+  // Average kinetic energy for symmetric and asymmetric components
+  G4double Eaverage = 0.1071*MeV*(Z*Z)/G4Pow::GetInstance()->Z13(A) + 22.2*MeV;
+  // Compute maximal average kinetic energy of fragments and Energy Dispersion (sqrt)
+  G4double TaverageAfMax;
+  G4double ESigma;
+  // Select randomly fission mode (symmetric or asymmetric)
+  if (G4UniformRand() > Psy) { // Asymmetric Mode
+    G4double A11 = theParam.GetA1()-0.7979*theParam.GetSigma1();
+    G4double A12 = theParam.GetA1()+0.7979*theParam.GetSigma1();
+    G4double A21 = theParam.GetA2()-0.7979*theParam.GetSigma2();
+    G4double A22 = theParam.GetA2()+0.7979*theParam.GetSigma2();
+    // scale factor
+    G4double ScaleFactor = 0.5*theParam.GetSigma1()*(AsymmetricRatio(A,A11)+AsymmetricRatio(A,A12))+
+      theParam.GetSigma2()*(AsymmetricRatio(A,A21)+AsymmetricRatio(A,A22));
+    // Compute average kinetic energy for fragment with AfMax
+    TaverageAfMax = (Eaverage + 12.5 * Xsy) * (PPas/ScaleFactor) * AsymmetricRatio(A,AfMax);
+    ESigma = 10.0*MeV; // MeV
+  } else { // Symmetric Mode
+    G4double As0 = theParam.GetAs() + 0.7979*theParam.GetSigmaS();
+    // scale factor
+    G4double ScaleFactor = theParam.GetW()*theParam.GetSigmaS()*SymmetricRatio(A,As0);
+    // Compute average kinetic energy for fragment with AfMax
+    TaverageAfMax = (Eaverage - 12.5*MeV*Xas) * (PPsy/ScaleFactor) * SymmetricRatio(A,AfMax);
+    ESigma = 8.0*MeV;
+  }
+  // Select randomly, in accordance with Gaussian distribution, fragment kinetic energy
+  G4double KineticEnergy;
+  G4int i = 0;
+  do {
+    KineticEnergy = G4RandGauss::shoot(TaverageAfMax,ESigma);
+    if (i++ > 100) return Eaverage;
+  } while (KineticEnergy < Eaverage-3.72*ESigma ||
+           KineticEnergy > Eaverage+3.72*ESigma ||
+           KineticEnergy > Tmax);
+  return KineticEnergy;
+}
+G4double G4CompetitiveFission::AsymmetricRatio(G4int A, G4double A11)
+{
+  const G4double B1 = 23.5;
+  const G4double A00 = 134.0;
+  return Ratio(G4double(A),A11,B1,A00);
+}
+G4double G4CompetitiveFission::SymmetricRatio(G4int A, G4double A11)
+{
+  const G4double B1 = 5.32;
+  const G4double A00 = A/2.0;
+  return Ratio(G4double(A),A11,B1,A00);
+}
+G4double G4CompetitiveFission::Ratio(G4double A, G4double A11,
+                                     G4double B1, G4double A00)
+{
+  if (A == 0.0) {
+    throw G4HadronicException(__FILE__, __LINE__,
+                              "G4CompetitiveFission::Ratio: A == 0!");
+  }
+  if (A11 >= A/2.0 && A11 <= (A00+10.0)) {
+    return 1.0-B1*((A11-A00)/A)*((A11-A00)/A);
+  } else {
+    return 1.0-B1*(10.0/A)*(10.0/A)-2.0*(10.0/A)*B1*((A11-A00-10.0)/A);
+  }
+}
 G4ThreeVector G4CompetitiveFission::IsotropicVector(const G4double Magnitude)
+    // Samples a isotropic random vectorwith a magnitud given by Magnitude.
+    // By default Magnitude = 1.0
+{
+    G4double CosTheta = 1.0 - 2.0*G4UniformRand();
+    G4double SinTheta = std::sqrt(1.0 - CosTheta*CosTheta);
+    G4double Phi = twopi*G4UniformRand();
+    G4ThreeVector Vector(Magnitude*std::cos(Phi)*SinTheta,
+                         Magnitude*std::sin(Phi)*SinTheta,
+                         Magnitude*CosTheta);
+    return Vector;
+}
+  // Samples a isotropic random vectorwith a magnitud given by Magnitude.
+  // By default Magnitude = 1.0
+{
+  G4double CosTheta = 1.0 - 2.0*G4UniformRand();
+  G4double SinTheta = std::sqrt(1.0 - CosTheta*CosTheta);
+  G4double Phi = twopi*G4UniformRand();
+  G4ThreeVector Vector(Magnitude*std::cos(Phi)*SinTheta,
+                       Magnitude*std::sin(Phi)*SinTheta,
+                       Magnitude*CosTheta);
+  return Vector;
+}
 #ifdef debug

trunk/source/processes/hadronic/models/de_excitation/fission/src/G4FissionBarrier.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4FissionBarrier.cc,v 1.7 2009/12/16 16:50:07 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4FissionBarrier.cc,v 1.8 2010/11/17 20:22:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Oct 1998)
+//
+// 17.11.2010 V.Ivanchenko cleanup and add usage of G4Pow
 #include "G4FissionBarrier.hh"
+#include "G4Pow.hh"
+G4FissionBarrier::G4FissionBarrier(const G4FissionBarrier & ) : G4VFissionBarrier()
+G4FissionBarrier::G4FissionBarrier()
+{}
+G4FissionBarrier::~G4FissionBarrier()
+{}
+G4double
+G4FissionBarrier::FissionBarrier(G4int A, G4int Z, G4double U)
+  // Compute fission barrier according with Barashenkov's
+  // prescription for A >= 65
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4FissionBarrier::copy_constructor meant to not be accessable.");
+  if (A >= 65) {
+    return BarashenkovFissionBarrier(A,Z)/(1.0 + std::sqrt(U/(2.0*A)));
+  } else { return 100.0*GeV; }
+}
+G4double
+G4FissionBarrier::BarashenkovFissionBarrier(G4int A, G4int Z)
+  // Calculates Fission Barrier heights
+{
+  // Liquid drop model parameters for
+  // surface energy of a spherical nucleus
+  const G4double aSurf = 17.9439*MeV;
+  // and coulomb energy
+  const G4double aCoul = 0.7053*MeV;
+  const G4double k = 1.7826;
+  G4int N = A - Z;
+const G4FissionBarrier & G4FissionBarrier::operator=(const G4FissionBarrier & )
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4FissionBarrier::operator= meant to not be accessable.");
+    return *this;
+  // fissibility parameter
+  G4double x = (aCoul/(2.0*aSurf))*(Z*Z)/static_cast<G4double>(A);
+  x /= (1.0 - k*(N-Z)*(N-Z)/static_cast<G4double>(A*A));
+  // Liquid drop model part of Fission Barrier
+  G4double BF0 = aSurf*G4Pow::GetInstance()->Z23(A);
+  if (x <= 2./3.) { BF0 *= 0.38*(3./4.-x); }
+  else { BF0 *= 0.83*(1. - x)*(1. - x)*(1. - x); }
+  //
+  G4double D = 1.248*MeV;
+  D *= (N - 2*(N/2) + Z - 2*(Z/2));
+  return BF0 + D - SellPlusPairingCorrection(Z,N);
+}
-G4bool G4FissionBarrier::operator==(const G4FissionBarrier & ) const
+{
-    return false;
+}
-G4bool G4FissionBarrier::operator!=(const G4FissionBarrier & ) const
+{
-    return true;
+}
-G4double G4FissionBarrier::FissionBarrier(const G4int A, const G4int Z, const G4double U)
-    // Compute fission barrier according with Barashenkov's prescription for A >= 65
+{
-    if (A >= 65) return BarashenkovFissionBarrier(A,Z)/(1.0 + std::sqrt(U/(2.0*static_cast<G4double>(A))));
-    else return 100.0*GeV;
+}
-G4double G4FissionBarrier::BarashenkovFissionBarrier(const G4int A, const G4int Z)
-    // Calculates Fission Barrier heights
+{
-    // Liquid drop model parameters for
-    // surface energy of a spherical nucleus
-    const G4double aSurf = 17.9439*MeV;
-    // and coulomb energy
-    const G4double aCoul = 0.7053*MeV;
-    const G4int N = A - Z;
-    const G4double k = 1.7826;
-    // fissibility parameter
-    G4double x = (aCoul/(2.0*aSurf))*(static_cast<G4double>(Z)*static_cast<G4double>(Z))/static_cast<G4double>(A);
-    x /= (1.0 - k*(static_cast<G4double>(N-Z)/static_cast<G4double>(A))*
-          (static_cast<G4double>(N-Z)/static_cast<G4double>(A)));
-    // Liquid drop model part of Fission Barrier
-    G4double BF0 = aSurf*std::pow(static_cast<G4double>(A),2./3.);
-    if (x <= 2./3.) BF0 *= 0.38*(3./4.-x);
-    else BF0 *= 0.83*(1. - x)*(1. - x)*(1. - x);
-    //
-    G4double D = 1.248*MeV;
-    D *= (static_cast<G4double>(N)-2.0*(N/2)) + (static_cast<G4double>(Z)-2.0*(Z/2));
-    return BF0 + D - SellPlusPairingCorrection(Z,N);
+}

trunk/source/processes/hadronic/models/de_excitation/fission/src/G4FissionLevelDensityParameter.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4FissionLevelDensityParameter.cc,v 1.7 2009/11/21 18:05:26 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4FissionLevelDensityParameter.cc,v 1.8 2010/11/17 20:22:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
+G4FissionLevelDensityParameter::
+G4FissionLevelDensityParameter(const G4FissionLevelDensityParameter &) : G4VLevelDensityParameter()
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4FissionLevelDensityParameter::copy_constructor meant to not be accessable");
+}
+G4FissionLevelDensityParameter::G4FissionLevelDensityParameter()
+{}
+const G4FissionLevelDensityParameter & G4FissionLevelDensityParameter::
+operator=(const G4FissionLevelDensityParameter &)
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4FissionLevelDensityParameter::operator= meant to not be accessable");
+    return *this;
+}
+G4bool G4FissionLevelDensityParameter::
+operator==(const G4FissionLevelDensityParameter &) const
+{
+    return false;
+}
+G4bool G4FissionLevelDensityParameter::
+operator!=(const G4FissionLevelDensityParameter &) const
+{
+    return true;
+}
+G4FissionLevelDensityParameter::~G4FissionLevelDensityParameter()
+{}
 G4double G4FissionLevelDensityParameter::
 LevelDensityParameter(const G4int A,const G4int Z,const G4double U) const
+LevelDensityParameter(G4int A, G4int Z, G4double U) const
+{
   G4double EvapLDP =

trunk/source/processes/hadronic/models/de_excitation/fission/src/G4FissionParameters.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4FissionParameters.cc,v 1.7 2009/11/19 10:30:49 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4FissionParameters.cc,v 1.8 2010/11/17 20:22:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 const G4double G4FissionParameters::A2 = 141.0;
+G4FissionParameters::G4FissionParameters(const G4int A, const G4int Z, const G4double ExEnergy,
+                                         const G4double FissionBarrier)
+G4FissionParameters::G4FissionParameters(G4int A, G4int Z, G4double ExEnergy,
+                                         G4double FissionBarrier)
+{
+    G4double U = ExEnergy;
+  G4double U = ExEnergy;
+  As = A/2.0;
+    As = A/2.0;
+  if (A <= 235) Sigma2 = 5.6;  // MeV
+  else Sigma2 = 5.6 + 0.096*(A-235); // MeV
+    if (A <= 235) Sigma2 = 5.6;  // MeV
+    else Sigma2 = 5.6 + 0.096*(A-235); // MeV
+  Sigma1 = 0.5*Sigma2; // MeV
     Sigma1 = 0.5*Sigma2; // MeV
+  SigmaS = std::exp(0.00553*U/MeV + 2.1386); // MeV
+    SigmaS = std::exp(0.00553*U/MeV + 2.1386); // MeV
+  //JMQ 310509
+  //    if (SigmaS > 20.0) SigmaS = 20.0;
+  //   SigmaS*=1.3;
+  //JMQ 301009: retuning (after CEM transition prob.have been chosen as default)
+  SigmaS*=0.8;
+  //
+    //JMQ 310509
+    //    if (SigmaS > 20.0) SigmaS = 20.0;
+    //   SigmaS*=1.3;
+    //JMQ 301009: retuning (after CEM transition prob.have been chosen as default)
+    SigmaS*=0.8;
+    //
+  G4double FasymAsym = 2.0*std::exp(-((A2-As)*(A2-As))/(2.0*Sigma2*Sigma2)) +
+    std::exp(-((A1-As)*(A1-As))/(2.0*Sigma1*Sigma1));
+    G4double FasymAsym = 2.0*std::exp(-((A2-As)*(A2-As))/(2.0*Sigma2*Sigma2)) +
+      std::exp(-((A1-As)*(A1-As))/(2.0*Sigma1*Sigma1));
+    G4double FsymA1A2 = std::exp(-((As-(A1+A2)/2.0)*(As-(A1+A2)/2.0))/(2.0*SigmaS*SigmaS));
+  G4double FsymA1A2 = std::exp(-((As-(A1+A2)/2.0)*(As-(A1+A2)/2.0))
+                               /(2.0*SigmaS*SigmaS));
     G4double wa = 0.0;
     w = 0.0;
     if (Z >= 90) {         // Z >= 90
       if (U <= 16.25) wa = std::exp(0.5385*U/MeV-9.9564);  // U <= 16.25 MeV
       else wa = std::exp(0.09197*U/MeV-2.7003);            // U  > 16.25 MeV
     } else if (Z == 89) {  // Z == 89
       wa = std::exp(0.09197*U-1.0808);
     } else if (Z >= 82) {  //  82 <= Z <= 88
       G4double X = FissionBarrier - 7.5*MeV;
       if (X < 0.0) X = 0.0;
       wa = std::exp(0.09197*(U-X)/MeV-1.0808);
     } else {               // Z < 82
       w = 1001.0;
+    }
+  G4double wa = 0.0;
+  w = 0.0;
+  if (Z >= 90) {         // Z >= 90
+    if (U <= 16.25) wa = std::exp(0.5385*U/MeV-9.9564);  // U <= 16.25 MeV
+    else wa = std::exp(0.09197*U/MeV-2.7003);            // U  > 16.25 MeV
+  } else if (Z == 89) {  // Z == 89
+    wa = std::exp(0.09197*U-1.0808);
+  } else if (Z >= 82) {  //  82 <= Z <= 88
+    G4double X = FissionBarrier - 7.5*MeV;
+    if (X < 0.0) X = 0.0;
+    wa = std::exp(0.09197*(U-X)/MeV-1.0808);
+  } else {               // Z < 82
+    w = 1001.0;
+  }
+    if (w == 0.0) {
+      G4double w1 = std::max(1.03*wa - FasymAsym, 0.0001);
+      G4double w2 = std::max(1.0 - FsymA1A2*wa,   0.0001);
+  if (w == 0.0) {
+    G4double w1 = std::max(1.03*wa - FasymAsym, 0.0001);
+    G4double w2 = std::max(1.0 - FsymA1A2*wa,   0.0001);
+    w = w1/w2;
+      w = w1/w2;
+      if (82 <= Z && Z < 89 && A < 227)  w *= std::exp(0.3*(227-A));
+    }
+    if (82 <= Z && Z < 89 && A < 227)  w *= std::exp(0.3*(227-A));
+  }
+}
+G4FissionParameters::~G4FissionParameters()
+{}
-G4FissionParameters::G4FissionParameters(const G4FissionParameters &)
+{
-    throw G4HadronicException(__FILE__, __LINE__, "G4FissionParameters::copy_constructor meant to not be accessable");
+}
-const G4FissionParameters & G4FissionParameters::operator=(const G4FissionParameters &)
+{
-    throw G4HadronicException(__FILE__, __LINE__, "G4FissionParameters::operator= meant to not be accessable");
-    return *this;
+}
-G4bool G4FissionParameters::operator==(const G4FissionParameters &) const
+{
-    return false;
+}
-G4bool G4FissionParameters::operator!=(const G4FissionParameters &) const
+{
-    return true;
+}

trunk/source/processes/hadronic/models/de_excitation/fission/src/G4FissionProbability.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4FissionProbability.cc,v 1.9 2009/02/15 17:03:25 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4FissionProbability.cc,v 1.10 2010/11/17 20:22:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 #include "G4PairingCorrection.hh"
+G4FissionProbability::G4FissionProbability()
+{}
+G4FissionProbability::~G4FissionProbability()
+{}
+G4FissionProbability::G4FissionProbability(const G4FissionProbability &) : G4VEmissionProbability()
+G4double
+G4FissionProbability::EmissionProbability(const G4Fragment & fragment,
+                                          G4double MaximalKineticEnergy)
+  // Compute integrated probability of fission channel
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4FissionProbability::copy_constructor meant to not be accessable");
+  if (MaximalKineticEnergy <= 0.0) return 0.0;
+  G4int A = fragment.GetA_asInt();
+  G4int Z = fragment.GetZ_asInt();
+  G4double U = fragment.GetExcitationEnergy();
+  G4double Ucompound = U -
+    G4PairingCorrection::GetInstance()->GetPairingCorrection(A,Z);
+  G4double Ufission = U -
+    G4PairingCorrection::GetInstance()->GetFissionPairingCorrection(A,Z);
+  G4double SystemEntropy =
+.0*std::sqrt(theEvapLDP.LevelDensityParameter(A,Z,Ucompound)*Ucompound);
+  G4double afission = theFissLDP.LevelDensityParameter(A,Z,Ufission);
+  G4double Cf = 2.0*std::sqrt(afission*MaximalKineticEnergy);
+  //    G4double Q1 = 1.0 + (Cf - 1.0)*std::exp(Cf);
+  //    G4double Q2 = 4.0*pi*afission*std::exp(SystemEntropy);
+  //    G4double probability = Q1/Q2;
+  G4double Exp1 = 0.0;
+  if (SystemEntropy <= 160.0) { Exp1 = std::exp(-SystemEntropy); }
+  // @@@@@@@@@@@@@@@@@ hpw changed max to min - cannot notify vicente now
+  G4double Exp2 = std::exp( std::min(700.0,Cf-SystemEntropy) );
+  // JMQ 14/02/09 BUG fixed in fission probability (missing parenthesis
+  // at denominator)
+  //AH fix from Vincente: G4double probability =
+  //        (Exp1 + (1.0-Cf)*Exp2) / 4.0*pi*afission;
+  //    G4double probability = (Exp1 + (Cf-1.0)*Exp2) / 4.0*pi*afission;
+  G4double probability = (Exp1 + (Cf-1.0)*Exp2) / (4.0*pi*afission);
+  return probability;
+}
-const G4FissionProbability & G4FissionProbability::operator=(const G4FissionProbability &)
+{
-    throw G4HadronicException(__FILE__, __LINE__, "G4FissionProbability::operator= meant to not be accessable");
-    return *this;
+}
-G4bool G4FissionProbability::operator==(const G4FissionProbability &) const
+{
-    return false;
+}
-G4bool G4FissionProbability::operator!=(const G4FissionProbability &) const
+{
-    return true;
+}
-G4double G4FissionProbability::EmissionProbability(const G4Fragment & fragment, const G4double MaximalKineticEnergy)
-    // Compute integrated probability of fission channel
+{
-    if (MaximalKineticEnergy <= 0.0) return 0.0;
-    G4double A = fragment.GetA();
-    G4double Z = fragment.GetZ();
-    G4double U = fragment.GetExcitationEnergy();
-    G4double Ucompound = U - G4PairingCorrection::GetInstance()->GetPairingCorrection(static_cast<G4int>(A),
-                                                                                      static_cast<G4int>(Z));
-    G4double Ufission = U - G4PairingCorrection::GetInstance()->GetFissionPairingCorrection(static_cast<G4int>(A),
-                                                                                            static_cast<G4int>(Z));
-    G4double SystemEntropy = 2.0*std::sqrt(theEvapLDP.LevelDensityParameter(static_cast<G4int>(A),
-                                                                       static_cast<G4int>(Z),
-                                                                       Ucompound)*Ucompound);
-    G4double afission = theFissLDP.LevelDensityParameter(static_cast<G4int>(A),
-                                                         static_cast<G4int>(Z),
-                                                         Ufission);
-    G4double Cf = 2.0*std::sqrt(afission*MaximalKineticEnergy);
-    //    G4double Q1 = 1.0 + (Cf - 1.0)*std::exp(Cf);
-    //    G4double Q2 = 4.0*pi*afission*std::exp(SystemEntropy);
-    //    G4double probability = Q1/Q2;
-    G4double Exp1 = 0.0;
-    if (SystemEntropy <= 160.0) Exp1 = std::exp(-SystemEntropy);
-    // @@@@@@@@@@@@@@@@@ hpw changed max to min - cannot notify vicente now
-    G4double Exp2 = std::exp( std::min(700.0,Cf-SystemEntropy) );
-    // JMQ 14/02/09 BUG fixed in fission probability (missing parenthesis at denominator)
-    //AH fix from Vincente:    G4double probability = (Exp1 + (1.0-Cf)*Exp2) / 4.0*pi*afission;
-    //    G4double probability = (Exp1 + (Cf-1.0)*Exp2) / 4.0*pi*afission;
-    G4double probability = (Exp1 + (Cf-1.0)*Exp2) / (4.0*pi*afission);
-    return probability;
+}

trunk/source/processes/hadronic/models/de_excitation/fission/src/G4VFissionBarrier.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4VFissionBarrier.cc,v 1.4 2006/06/29 20:13:43 gunter Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4VFissionBarrier.cc,v 1.5 2010/11/17 20:22:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 #include "G4VFissionBarrier.hh"
+G4VFissionBarrier::G4VFissionBarrier(const G4VFissionBarrier & )
+{
+  throw G4HadronicException(__FILE__, __LINE__, "G4VFissionBarrier::copy_constructor meant to not be accessable.");
+}
+G4VFissionBarrier::G4VFissionBarrier() {}
+G4VFissionBarrier::~G4VFissionBarrier() {}
-const G4VFissionBarrier & G4VFissionBarrier::operator=(const G4VFissionBarrier & )
+{
- throw G4HadronicException(__FILE__, __LINE__, "G4VFissionBarrier::operator= meant to not be accessable.");
- return *this;
+}
-G4bool G4VFissionBarrier::operator==(const G4VFissionBarrier & ) const
+{
- return false;
+}
-G4bool G4VFissionBarrier::operator!=(const G4VFissionBarrier & ) const
+{
- return true;
+}

trunk/source/processes/hadronic/models/de_excitation/gem_evaporation/include/G4AlphaGEMChannel.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4AlphaGEMChannel.hh,v 1.4 2009/09/15 12:54:16 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4AlphaGEMChannel.hh,v 1.5 2010/10/29 17:35:04 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 private:
     const G4AlphaGEMChannel & operator=(const G4AlphaGEMChannel & right);
+    G4AlphaGEMChannel(const G4AlphaGEMChannel & right);
+public:
+    G4AlphaGEMChannel(const G4AlphaGEMChannel & right);
     G4bool operator==(const G4AlphaGEMChannel & right) const;
     G4bool operator!=(const G4AlphaGEMChannel & right) const;
-private:
 // JMQ 190709
 //       G4AlphaCoulombBarrier theCoulombBarrier;

trunk/source/processes/hadronic/models/de_excitation/gem_evaporation/include/G4GEMChannel.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4GEMChannel.hh,v 1.5 2009/09/15 12:54:16 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4GEMChannel.hh,v 1.7 2010/11/18 16:21:17 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 //#define debug
+class G4Pow;
 class G4GEMChannel : public G4VEvaporationChannel
+{
 public:
+    // Available constructors
+    G4GEMChannel(const G4int theA, const G4int theZ,
+                 G4GEMProbability * aEmissionStrategy,
+                 G4VCoulombBarrier * aCoulombBarrier);
+  G4GEMChannel(const G4int theA, const G4int theZ, const G4String & aName,
+               G4GEMProbability * aEmissionStrategy,
+               G4VCoulombBarrier * aCoulombBarrier);
+  // destructor
+  virtual ~G4GEMChannel();
+    G4GEMChannel(const G4int theA, const G4int theZ, const G4String & aName,
+                 G4GEMProbability * aEmissionStrategy,
+                 G4VCoulombBarrier * aCoulombBarrier);
+  void Initialize(const G4Fragment & fragment);
+  G4FragmentVector * BreakUp(const G4Fragment & theNucleus);
+  inline void SetLevelDensityParameter(G4VLevelDensityParameter * aLevelDensity)
+  {
+    if (MyOwnLevelDensity) { delete theLevelDensityPtr; }
+    theLevelDensityPtr = aLevelDensity;
+    MyOwnLevelDensity = false;
+  }
+  inline G4double GetEmissionProbability(void) const
+  { return EmissionProbability; }
+  inline G4double GetMaximalKineticEnergy(void) const
+  { return MaximalKineticEnergy; }
+private:
+    G4GEMChannel(const G4int theA, const G4int theZ, const G4String * aName,
+                 G4GEMProbability * aEmissionStrategy,
+                 G4VCoulombBarrier * aCoulombBarrier);
+public:
+    // destructor
+    ~G4GEMChannel();
+    void SetEmissionStrategy(G4GEMProbability * aEmissionStrategy)
+        {
+            theEvaporationProbabilityPtr = aEmissionStrategy;
+        }
+    void SetCoulombBarrierStrategy(G4VCoulombBarrier * aCoulombBarrier)
+        {
+            theCoulombBarrierPtr = aCoulombBarrier;
+        }
+  // Calculate Binding Energy for separate fragment from nucleus
+  G4double CalcBindingEnergy(G4int anA, G4int aZ);
+  // Calculate maximal kinetic energy that can be carried by fragment (in MeV)
+  G4double CalcMaximalKineticEnergy(G4double U);
+  // Samples fragment kinetic energy.
+  G4double CalcKineticEnergy(const G4Fragment & fragment);
+  // This has to be removed and put in Random Generator
+  G4ThreeVector IsotropicVector(G4double Magnitude  = 1.0);
+  G4GEMChannel(const G4GEMChannel & right);
+  const G4GEMChannel & operator=(const G4GEMChannel & right);
+  G4bool operator==(const G4GEMChannel & right) const;
+  G4bool operator!=(const G4GEMChannel & right) const;
 protected:
+    // default constructor
+    G4GEMChannel() {};
+  G4GEMChannel();
+  // Data Members ************
 private:
-    // copy constructor
-    G4GEMChannel(const G4GEMChannel & right);
-private:
-    const G4GEMChannel & operator=(const G4GEMChannel & right);
-public:
-    G4bool operator==(const G4GEMChannel & right) const;
-    G4bool operator!=(const G4GEMChannel & right) const;
+public:
+    void Initialize(const G4Fragment & fragment);
+  // This data member define the channel.
+  // They are intializated at object creation (constructor) time.
+  // Atomic Number
+  G4int A;
+  // Charge
+  G4int Z;
+    G4FragmentVector * BreakUp(const G4Fragment & theNucleus);
+  G4double EvaporatedMass;
+  G4double ResidualMass;
+    inline void SetLevelDensityParameter(G4VLevelDensityParameter * aLevelDensity)
+        {
+            if (MyOwnLevelDensity) delete theLevelDensityPtr;
+            theLevelDensityPtr = aLevelDensity;
+            MyOwnLevelDensity = false;
+        }
+public:
+  G4Pow* fG4pow;
+  // For evaporation probability calcualtion
+  G4GEMProbability * theEvaporationProbabilityPtr;
+  // For Level Density calculation
+  G4bool MyOwnLevelDensity;
+  G4VLevelDensityParameter * theLevelDensityPtr;
+  // For Coulomb Barrier calculation
+  G4VCoulombBarrier * theCoulombBarrierPtr;
+  G4double CoulombBarrier;
+  //---------------------------------------------------
+  // These values depend on the nucleus that is being evaporated.
+  // They are calculated through the Initialize method which takes as parameters
+  // the atomic number, charge and excitation energy of nucleus.
+  // Residual Atomic Number
+  G4int ResidualA;
+  // Residual Charge
+  G4int ResidualZ;
+  // Emission Probability
+  G4double EmissionProbability;
+  // Maximal Kinetic Energy that can be carried by fragment
+  G4double MaximalKineticEnergy;
-    inline G4double GetEmissionProbability(void) const
+        {
-            return EmissionProbability;
+        }
-    inline G4double GetMaximalKineticEnergy(void) const
+        {
-            return MaximalKineticEnergy;
+        }
-    // ----------------------
-private:
-    // Calculate Binding Energy for separate fragment from nucleus
-    G4double CalcBindingEnergy(const G4int anA, const G4int aZ);
-    // Calculate maximal kinetic energy that can be carried by fragment (in MeV)
-    G4double CalcMaximalKineticEnergy(const G4double U);
-    // Samples fragment kinetic energy.
-    G4double CalcKineticEnergy(const G4Fragment & fragment);
-    // This has to be removed and put in Random Generator
-    G4ThreeVector IsotropicVector(const G4double Magnitude  = 1.0);
-        // Data Members
-        // ************
-private:
-    // This data member define the channel.
-  // They are intializated at object creation (constructor) time.
-    // Atomic Number
-    G4int A;
-    // Charge
-    G4int Z;
-    // For evaporation probability calcualtion
-    G4GEMProbability * theEvaporationProbabilityPtr;
-    // For Level Density calculation
-    G4bool MyOwnLevelDensity;
-    G4VLevelDensityParameter * theLevelDensityPtr;
-    // For Coulomb Barrier calculation
-    G4VCoulombBarrier * theCoulombBarrierPtr;
-    G4double CoulombBarrier;
-    //---------------------------------------------------
-    // These values depend on the nucleus that is being evaporated.
-    // They are calculated through the Initialize method which takes as parameters
-    // the atomic number, charge and excitation energy of nucleus.
-    // Residual Atomic Number
-    G4int AResidual;
-    // Residual Charge
-    G4int ZResidual;
-    // Emission Probability
-    G4double EmissionProbability;
-    // Maximal Kinetic Energy that can be carried by fragment
-    G4double MaximalKineticEnergy;
 };

trunk/source/processes/hadronic/models/de_excitation/gem_evaporation/include/G4GEMProbability.hh

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4GEMProbability.hh,v 1.4 2010/05/19 10:21:16 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4GEMProbability.hh,v 1.6 2010/11/05 14:42:52 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //---------------------------------------------------------------------
 …
 #define G4GEMProbability_h 1
 #include "G4VEmissionProbability.hh"
 #include "G4VLevelDensityParameter.hh"
 …
   // Only available constructor
   G4GEMProbability(const G4int anA, const G4int aZ, const G4double aSpin);
+  G4GEMProbability(G4int anA, G4int aZ, G4double aSpin);
   virtual ~G4GEMProbability();
 …
+  }
-  inline void SetCoulombBarrierStrategy(G4VCoulombBarrier * aCoulombBarrier)
+  {
-    theCoulombBarrierPtr = aCoulombBarrier;
+  }
 private:
 …
 public:
   G4double EmissionProbability(const G4Fragment & fragment, const G4double anEnergy);
+  G4double EmissionProbability(const G4Fragment & fragment, G4double anEnergy);
 private:
   G4double CalcProbability(const G4Fragment & fragment, const G4double MaximalKineticEnergy,
                            const G4double V);
+  G4double CalcProbability(const G4Fragment & fragment, G4double MaximalKineticEnergy,
+                           G4double V);
   virtual G4double CCoeficient(const G4double ) const;
+  virtual G4double CCoeficient(G4double ) const;
   inline G4double I0(const G4double t);
   inline G4double I1(const G4double t, const G4double tx);
   inline G4double I2(const G4double s, const G4double sx);
   G4double I3(const G4double s, const G4double sx);
+  inline G4double I0(G4double t);
+  inline G4double I1(G4double t, G4double tx);
+  inline G4double I2(G4double s, G4double sx);
+  G4double I3(G4double s, G4double sx);
   // Data Members
 …
 };
 inline G4double G4GEMProbability::I0(const G4double t)
+inline G4double G4GEMProbability::I0(G4double t)
+{
   return std::exp(t) - 1.0;
+}
 inline G4double G4GEMProbability::I1(const G4double t, const G4double tx)
+inline G4double G4GEMProbability::I1(G4double t, G4double tx)
+{
   return (t - tx + 1.0)*std::exp(tx) - t - 1.0;
 …
 inline G4double G4GEMProbability::I2(const G4double s, const G4double sx)
+inline G4double G4GEMProbability::I2(G4double s, G4double sx)
+{
   G4double S = 1.0/std::sqrt(s);

trunk/source/processes/hadronic/models/de_excitation/gem_evaporation/src/G4AlphaGEMChannel.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4AlphaGEMChannel.cc,v 1.5 2009/09/15 12:54:16 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4AlphaGEMChannel.cc,v 1.6 2010/10/29 17:35:04 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
-const G4AlphaGEMChannel & G4AlphaGEMChannel::operator=(const G4AlphaGEMChannel & )
+{
-    throw G4HadronicException(__FILE__, __LINE__, "G4AlphaGEMChannel::operator= meant to not be accessable");
-    return *this;
+}
-G4AlphaGEMChannel::G4AlphaGEMChannel(const G4AlphaGEMChannel & ): G4GEMChannel()
+{
-    throw G4HadronicException(__FILE__, __LINE__, "G4AlphaGEMChannel::CopyConstructor meant to not be accessable");
+}
-G4bool G4AlphaGEMChannel::operator==(const G4AlphaGEMChannel & right) const
+{
-    return (this == (G4AlphaGEMChannel *) &right);
-    //  return false;
+}
-G4bool G4AlphaGEMChannel::operator!=(const G4AlphaGEMChannel & right) const
+{
-    return (this != (G4AlphaGEMChannel *) &right);
-    //  return true;
+}

trunk/source/processes/hadronic/models/de_excitation/gem_evaporation/src/G4GEMChannel.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4GEMChannel.cc,v 1.10 2009/10/08 07:55:39 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4GEMChannel.cc,v 1.12 2010/11/18 16:21:17 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 #include "G4GEMChannel.hh"
 #include "G4PairingCorrection.hh"
+G4GEMChannel::G4GEMChannel(const G4int theA, const G4int theZ,
+                           G4GEMProbability * aEmissionStrategy,
+                           G4VCoulombBarrier * aCoulombBarrier):
+    A(theA),
+    Z(theZ),
+    theEvaporationProbabilityPtr(aEmissionStrategy),
+    theCoulombBarrierPtr(aCoulombBarrier),
+    EmissionProbability(0.0),
+    MaximalKineticEnergy(-1000.0)
+{
+    theLevelDensityPtr = new G4EvaporationLevelDensityParameter;
+    MyOwnLevelDensity = true;
+}
+G4GEMChannel::G4GEMChannel(const G4int theA, const G4int theZ, const G4String & aName,
+#include "G4Pow.hh"
+G4GEMChannel::G4GEMChannel(G4int theA, G4int theZ, const G4String & aName,
                            G4GEMProbability * aEmissionStrategy,
                            G4VCoulombBarrier * aCoulombBarrier) :
 …
   theLevelDensityPtr = new G4EvaporationLevelDensityParameter;
   MyOwnLevelDensity = true;
+  EvaporatedMass = G4NucleiProperties::GetNuclearMass(A, Z);
+  ResidualMass = CoulombBarrier = 0.0;
+  fG4pow = G4Pow::GetInstance();
+}
+G4GEMChannel::G4GEMChannel() :
+  G4VEvaporationChannel("dummy"),
+  A(0),
+  Z(0),
+  theEvaporationProbabilityPtr(0),
+  theCoulombBarrierPtr(0),
+  EmissionProbability(0.0),
+  MaximalKineticEnergy(-1000.0)
+{
+  theLevelDensityPtr = 0;
+  MyOwnLevelDensity = true;
+  EvaporatedMass = 0.0;
+  ResidualMass = CoulombBarrier = 0.0;
+  fG4pow = G4Pow::GetInstance();
+}
 G4GEMChannel::~G4GEMChannel()
+{
+    if (MyOwnLevelDensity) delete theLevelDensityPtr;
+}
+G4GEMChannel::G4GEMChannel(const G4GEMChannel & ) : G4VEvaporationChannel()
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4GEMChannel::copy_costructor meant to not be accessable");
+}
+const G4GEMChannel & G4GEMChannel::operator=(const G4GEMChannel & )
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4GEMChannel::operator= meant to not be accessable");
+    return *this;
+}
+G4bool G4GEMChannel::operator==(const G4GEMChannel & right) const
+{
+    return (this == (G4GEMChannel *) &right);
+    //  return false;
+}
+G4bool G4GEMChannel::operator!=(const G4GEMChannel & right) const
+{
+    return (this != (G4GEMChannel *) &right);
+    //  return true;
+  if (MyOwnLevelDensity) { delete theLevelDensityPtr; }
+}
 void G4GEMChannel::Initialize(const G4Fragment & fragment)
+{
   G4int anA = static_cast<G4int>(fragment.GetA());
   G4int aZ = static_cast<G4int>(fragment.GetZ());
   AResidual = anA - A;
   ZResidual = aZ - Z;
+  G4int anA = fragment.GetA_asInt();
+  G4int aZ  = fragment.GetZ_asInt();
+  ResidualA = anA - A;
+  ResidualZ = aZ - Z;
   //G4cout << "G4GEMChannel::Initialize: Z= " << aZ << " A= " << anA
   //       << " Zres= " << ZResidual << " Ares= " << AResidual << G4endl;
+  //       << " Zres= " << ResidualZ << " Ares= " << ResidualA << G4endl;
   // We only take into account channels which are physically allowed
   if (AResidual <= 0 || ZResidual <= 0 || AResidual < ZResidual ||
       (AResidual == ZResidual && AResidual > 1))
+  if (ResidualA <= 0 || ResidualZ <= 0 || ResidualA < ResidualZ ||
+      (ResidualA == ResidualZ && ResidualA > 1))
+    {
       CoulombBarrier = 0.0;
 …
   else
+    {
       // Effective excitation energy
       // JMQ 071009: pairing in ExEnergy should be the one of parent compound nucleus
 …
       // param for protons must be the same)
       //    G4double ExEnergy = fragment.GetExcitationEnergy() -
       //    G4PairingCorrection::GetInstance()->GetPairingCorrection(AResidual,ZResidual);
+      //    G4PairingCorrection::GetInstance()->GetPairingCorrection(ResidualA,ResidualZ);
       G4double ExEnergy = fragment.GetExcitationEnergy() -
         G4PairingCorrection::GetInstance()->GetPairingCorrection(anA,aZ);
 …
       } else {
+        ResidualMass = G4NucleiProperties::GetNuclearMass(ResidualA, ResidualZ);
         // Coulomb Barrier calculation
         CoulombBarrier = theCoulombBarrierPtr->GetCoulombBarrier(AResidual,ZResidual,ExEnergy);
+        CoulombBarrier = theCoulombBarrierPtr->GetCoulombBarrier(ResidualA,ResidualZ,ExEnergy);
         //G4cout << "CBarrier(MeV)= " << CoulombBarrier/MeV << G4endl;
         //Maximal kinetic energy (JMQ : at the Coulomb barrier)
         MaximalKineticEnergy =
+          CalcMaximalKineticEnergy(G4ParticleTable::GetParticleTable()->
+                                   GetIonTable()->GetNucleusMass(aZ,anA)+ExEnergy);
+          CalcMaximalKineticEnergy(fragment.GetGroundStateMass()+ExEnergy);
         //G4cout << "MaxE(MeV)= " << MaximalKineticEnergy/MeV << G4endl;
         // Emission probability
 …
+          }
+      }
+    }
+    }
     //G4cout << "Prob= " << EmissionProbability << G4endl;
     return;
 …
 G4FragmentVector * G4GEMChannel::BreakUp(const G4Fragment & theNucleus)
+{
+    G4double EvaporatedKineticEnergy = CalcKineticEnergy(theNucleus);
+    G4double EvaporatedMass = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIonMass(Z,A);
+    G4double EvaporatedEnergy = EvaporatedKineticEnergy + EvaporatedMass;
+    G4ThreeVector momentum(IsotropicVector(std::sqrt(EvaporatedKineticEnergy*
+                                                (EvaporatedKineticEnergy+2.0*EvaporatedMass))));
+    momentum.rotateUz(theNucleus.GetMomentum().vect().unit());
+    G4LorentzVector EvaporatedMomentum(momentum,EvaporatedEnergy);
+    EvaporatedMomentum.boost(theNucleus.GetMomentum().boostVector());
+    G4Fragment * EvaporatedFragment = new G4Fragment(A,Z,EvaporatedMomentum);
+#ifdef PRECOMPOUND_TEST
+    EvaporatedFragment->SetCreatorModel(G4String("G4Evaporation"));
+  G4double EvaporatedKineticEnergy = CalcKineticEnergy(theNucleus);
+  G4double EvaporatedEnergy = EvaporatedKineticEnergy + EvaporatedMass;
+  G4ThreeVector momentum(IsotropicVector(std::sqrt(EvaporatedKineticEnergy*
+                                                   (EvaporatedKineticEnergy+2.0*EvaporatedMass))));
+  momentum.rotateUz(theNucleus.GetMomentum().vect().unit());
+  G4LorentzVector EvaporatedMomentum(momentum,EvaporatedEnergy);
+  EvaporatedMomentum.boost(theNucleus.GetMomentum().boostVector());
+  G4Fragment * EvaporatedFragment = new G4Fragment(A,Z,EvaporatedMomentum);
+  // ** And now the residual nucleus **
+  G4double theExEnergy = theNucleus.GetExcitationEnergy();
+  G4double theMass = theNucleus.GetGroundStateMass();
+  G4double ResidualEnergy = theMass + (theExEnergy - EvaporatedKineticEnergy) - EvaporatedMass;
+  G4LorentzVector ResidualMomentum(-momentum,ResidualEnergy);
+  ResidualMomentum.boost(theNucleus.GetMomentum().boostVector());
+  G4Fragment * ResidualFragment = new G4Fragment( ResidualA, ResidualZ, ResidualMomentum );
+  G4FragmentVector * theResult = new G4FragmentVector;
+#ifdef debug
+  G4double Efinal = ResidualMomentum.e() + EvaporatedMomentum.e();
+  G4ThreeVector Pfinal = ResidualMomentum.vect() + EvaporatedMomentum.vect();
+  if (std::abs(Efinal-theNucleus.GetMomentum().e()) > 10.0*eV) {
+    G4cout << "@@@@@@@@@@@@@@@@@@@@@ G4GEMChanel: ENERGY @@@@@@@@@@@@@@@@" << G4endl;
+    G4cout << "Initial : " << theNucleus.GetMomentum().e()/MeV << " MeV    Final :"
+           <<Efinal/MeV << " MeV    Delta: " <<  (Efinal-theNucleus.GetMomentum().e())/MeV
+           << " MeV" << G4endl;
+  }
+  if (std::abs(Pfinal.x()-theNucleus.GetMomentum().x()) > 10.0*eV ||
+      std::abs(Pfinal.y()-theNucleus.GetMomentum().y()) > 10.0*eV ||
+      std::abs(Pfinal.z()-theNucleus.GetMomentum().z()) > 10.0*eV ) {
+    G4cout << "@@@@@@@@@@@@@@@@@@@@@ G4GEMChanel: MOMENTUM @@@@@@@@@@@@@@@@" << G4endl;
+    G4cout << "Initial : " << theNucleus.GetMomentum().vect() << " MeV    Final :"
+           <<Pfinal/MeV << " MeV    Delta: " <<  Pfinal-theNucleus.GetMomentum().vect()
+           << " MeV" << G4endl;
+  }
 #endif
+    // ** And now the residual nucleus **
+    G4double theExEnergy = theNucleus.GetExcitationEnergy();
+    G4double theMass = G4ParticleTable::GetParticleTable()->
+        GetIonTable()->GetNucleusMass(static_cast<G4int>(theNucleus.GetZ()),
+                                      static_cast<G4int>(theNucleus.GetA()));
+    G4double ResidualEnergy = theMass + (theExEnergy - EvaporatedKineticEnergy) - EvaporatedMass;
+    G4LorentzVector ResidualMomentum(-momentum,ResidualEnergy);
+    ResidualMomentum.boost(theNucleus.GetMomentum().boostVector());
+    G4Fragment * ResidualFragment = new G4Fragment( AResidual, ZResidual, ResidualMomentum );
+#ifdef PRECOMPOUND_TEST
+    ResidualFragment->SetCreatorModel(G4String("ResidualNucleus"));
+#endif
+    G4FragmentVector * theResult = new G4FragmentVector;
+#ifdef debug
+    G4double Efinal = ResidualMomentum.e() + EvaporatedMomentum.e();
+    G4ThreeVector Pfinal = ResidualMomentum.vect() + EvaporatedMomentum.vect();
+    if (std::abs(Efinal-theNucleus.GetMomentum().e()) > 10.0*eV) {
+        G4cout << "@@@@@@@@@@@@@@@@@@@@@ G4GEMChanel: ENERGY @@@@@@@@@@@@@@@@" << G4endl;
+        G4cout << "Initial : " << theNucleus.GetMomentum().e()/MeV << " MeV    Final :"
+               <<Efinal/MeV << " MeV    Delta: " <<  (Efinal-theNucleus.GetMomentum().e())/MeV
+               << " MeV" << G4endl;
+    }
+    if (std::abs(Pfinal.x()-theNucleus.GetMomentum().x()) > 10.0*eV ||
+        std::abs(Pfinal.y()-theNucleus.GetMomentum().y()) > 10.0*eV ||
+        std::abs(Pfinal.z()-theNucleus.GetMomentum().z()) > 10.0*eV ) {
+        G4cout << "@@@@@@@@@@@@@@@@@@@@@ G4GEMChanel: MOMENTUM @@@@@@@@@@@@@@@@" << G4endl;
+        G4cout << "Initial : " << theNucleus.GetMomentum().vect() << " MeV    Final :"
+               <<Pfinal/MeV << " MeV    Delta: " <<  Pfinal-theNucleus.GetMomentum().vect()
+               << " MeV" << G4endl;
+    }
+#endif
+    theResult->push_back(EvaporatedFragment);
+    theResult->push_back(ResidualFragment);
+    return theResult;
+  theResult->push_back(EvaporatedFragment);
+  theResult->push_back(ResidualFragment);
+  return theResult;
+}
 G4double G4GEMChannel::CalcMaximalKineticEnergy(const G4double NucleusTotalE)
 …
 //JMQ this is not the assimptotic kinetic energy but the one at the Coulomb barrier
+{
-  G4double ResidualMass = G4ParticleTable::GetParticleTable()->
-    GetIonTable()->GetNucleusMass( ZResidual, AResidual );
-  G4double EvaporatedMass = G4ParticleTable::GetParticleTable()->
-    GetIonTable()->GetNucleusMass( Z, A );
   G4double T = (NucleusTotalE*NucleusTotalE + EvaporatedMass*EvaporatedMass - ResidualMass*ResidualMass)/
+    (2.0*NucleusTotalE) -
+    EvaporatedMass - CoulombBarrier;
+    (2.0*NucleusTotalE) - EvaporatedMass - CoulombBarrier;
   return T;
+}
 G4double G4GEMChannel::CalcKineticEnergy(const G4Fragment & fragment)
 // Samples fragment kinetic energy.
+{
   G4double U = fragment.GetExcitationEnergy();
-  G4double NuclearMass = G4ParticleTable::GetParticleTable()->GetIonTable()->GetNucleusMass(Z,A);
   G4double Alpha = theEvaporationProbabilityPtr->CalcAlphaParam(fragment);
 …
   G4double Normalization = theEvaporationProbabilityPtr->GetNormalization();
 //                       ***RESIDUAL***
+  //                       ***RESIDUAL***
   //JMQ (September 2009) the following quantities  refer to the RESIDUAL:
   G4double delta0 = G4PairingCorrection::GetInstance()->GetPairingCorrection(AResidual,ZResidual);
   G4double Ux = (2.5 + 150.0/AResidual)*MeV;
+  G4double delta0 = G4PairingCorrection::GetInstance()->GetPairingCorrection(ResidualA,ResidualZ);
+  G4double Ux = (2.5 + 150.0/ResidualA)*MeV;
   G4double Ex = Ux + delta0;
   G4double InitialLevelDensity;
 …
   //JMQ (September 2009) the following quantities   refer to the PARENT:
+  G4double deltaCN = G4PairingCorrection::GetInstance()->GetPairingCorrection(static_cast<G4int>(fragment.GetA()),
+                                                                              static_cast<G4int>(fragment.GetZ()));
+  G4double aCN = theLevelDensityPtr->LevelDensityParameter(static_cast<G4int>(fragment.GetA()),
+                                                           static_cast<G4int>(fragment.GetZ()),U-deltaCN);
+  G4double deltaCN =
+    G4PairingCorrection::GetInstance()->GetPairingCorrection(fragment.GetA_asInt(),
+                                                             fragment.GetZ_asInt());
+  G4double aCN = theLevelDensityPtr->LevelDensityParameter(fragment.GetA_asInt(),
+                                                           fragment.GetZ_asInt(),U-deltaCN);
   G4double UxCN = (2.5 + 150.0/fragment.GetA())*MeV;
   G4double ExCN = UxCN + deltaCN;
   G4double TCN = 1.0/(std::sqrt(aCN/UxCN) - 1.5/UxCN);
-  G4double E0CN = ExCN - TCN*(std::log(TCN/MeV) - std::log(aCN*MeV)/4.0 - 1.25*std::log(UxCN/MeV) + 2.0*std::sqrt(aCN*UxCN));
   //                       ***end PARENT***
 …
   if ( U < ExCN )
+    {
+      G4double E0CN = ExCN - TCN*(std::log(TCN/MeV) - std::log(aCN*MeV)/4.0
+                                  - 1.25*std::log(UxCN/MeV) + 2.0*std::sqrt(aCN*UxCN));
       InitialLevelDensity = (pi/12.0)*std::exp((U-E0CN)/TCN)/TCN;
+    }
   else
+    {
+      InitialLevelDensity = (pi/12.0)*std::exp(2*std::sqrt(aCN*(U-deltaCN)))/std::pow(aCN*std::pow(U-deltaCN,5.0),1.0/4.0);
+      G4double x  = U-deltaCN;
+      G4double x1 = std::sqrt(aCN*x);
+      InitialLevelDensity = (pi/12.0)*std::exp(2*x1)/(x*std::sqrt(x1));
+      //InitialLevelDensity =
+      //(pi/12.0)*std::exp(2*std::sqrt(aCN*(U-deltaCN)))/std::pow(aCN*std::pow(U-deltaCN,5.0),1.0/4.0);
+    }
   const G4double Spin = theEvaporationProbabilityPtr->GetSpin();
 //JMQ  BIG BUG fixed: hbarc instead of hbar_Planck !!!!
 //     it was fixed in total probability (for this channel) but remained still here!!
 //    G4double g = (2.0*Spin+1.0)*NuclearMass/(pi2* hbar_Planck*hbar_Planck);
     G4double g = (2.0*Spin+1.0)*NuclearMass/(pi2* hbarc*hbarc);
 //
 //JMQ  fix on Rb and  geometrical cross sections according to Furihata's paper
 //                      (JAERI-Data/Code 2001-105, p6)
+  //JMQ  BIG BUG fixed: hbarc instead of hbar_Planck !!!!
+  //     it was fixed in total probability (for this channel) but remained still here!!
+  //    G4double g = (2.0*Spin+1.0)*NuclearMass/(pi2* hbar_Planck*hbar_Planck);
+  G4double g = (2.0*Spin+1.0)*EvaporatedMass/(pi2* hbarc*hbarc);
+  //
+  //JMQ  fix on Rb and  geometrical cross sections according to Furihata's paper
+  //                      (JAERI-Data/Code 2001-105, p6)
   G4double Rb = 0.0;
+    if (A > 4)
+    {
+      G4double Ad = std::pow(G4double(fragment.GetA()-A),1.0/3.0);
+      G4double Aj = std::pow(G4double(A),1.0/3.0);
+  if (A > 4)
+    {
+      G4double Ad = fG4pow->Z13(ResidualA);
+      G4double Aj = fG4pow->Z13(A);
+      //        RN = 1.12*(R1 + R2) - 0.86*((R1+R2)/(R1*R2));
       Rb = 1.12*(Aj + Ad) - 0.86*((Aj+Ad)/(Aj*Ad))+2.85;
       Rb *= fermi;
+    }
+    else if (A>1)
+      {
+        //      G4double R1 = std::pow(G4double(fragment.GetA()-A),1.0/3.0);
+        //      G4double R2 = std::pow(G4double(A),1.0/3.0);
+      G4double Ad = std::pow(G4double(fragment.GetA()-A),1.0/3.0);
+      G4double Aj = std::pow(G4double(A),1.0/3.0);
+      //        RN = 1.12*(R1 + R2) - 0.86*((R1+R2)/(R1*R2));
+  else if (A>1)
+    {
+      G4double Ad = fG4pow->Z13(ResidualA);
+      G4double Aj = fG4pow->Z13(A);
       Rb=1.5*(Aj+Ad)*fermi;
+    }
+    else
+    {
+      G4double Ad = std::pow(G4double(fragment.GetA()-A),1.0/3.0);
+      //        RN = 1.5*fermi;
+  else
+    {
+      G4double Ad = fG4pow->Z13(ResidualA);
       Rb = 1.5*Ad*fermi;
+    }
+    //   G4double GeometricalXS = pi*RN*RN*std::pow(G4double(fragment.GetA()-A),2./3.);
+    G4double GeometricalXS = pi*Rb*Rb;
+    G4double ConstantFactor = g*GeometricalXS*Alpha/InitialLevelDensity;
+    ConstantFactor *= pi/12.0;
+    //JMQ : this is the assimptotic maximal kinetic energy of the ejectile
+    //      (obtained by energy-momentum conservation).
+    //      In general smaller than U-theSeparationEnergy
+    G4double theEnergy = MaximalKineticEnergy + CoulombBarrier;
+    G4double KineticEnergy;
+    G4double Probability;
+    do
+      {
+        KineticEnergy =  CoulombBarrier + G4UniformRand()*MaximalKineticEnergy;
+        Probability = ConstantFactor*(KineticEnergy + Beta);
+        G4double a = theLevelDensityPtr->LevelDensityParameter(AResidual,ZResidual,theEnergy-KineticEnergy-delta0);
+        G4double T = 1.0/(std::sqrt(a/Ux) - 1.5/Ux);
+        //JMQ fix in units
+        G4double E0 = Ex - T*(std::log(T/MeV) - std::log(a*MeV)/4.0 - 1.25*std::log(Ux/MeV) + 2.0*std::sqrt(a*Ux));
+  //   G4double GeometricalXS = pi*RN*RN*std::pow(G4double(fragment.GetA()-A),2./3.);
+  G4double GeometricalXS = pi*Rb*Rb;
+  G4double ConstantFactor = g*GeometricalXS*Alpha/InitialLevelDensity;
+  ConstantFactor *= pi/12.0;
+  //JMQ : this is the assimptotic maximal kinetic energy of the ejectile
+  //      (obtained by energy-momentum conservation).
+  //      In general smaller than U-theSeparationEnergy
+  G4double theEnergy = MaximalKineticEnergy + CoulombBarrier;
+  G4double KineticEnergy;
+  G4double Probability;
+  do
+    {
+      KineticEnergy =  CoulombBarrier + G4UniformRand()*MaximalKineticEnergy;
+      Probability = ConstantFactor*(KineticEnergy + Beta);
+      G4double a =
+        theLevelDensityPtr->LevelDensityParameter(ResidualA,ResidualZ,theEnergy-KineticEnergy-delta0);
+      G4double T = 1.0/(std::sqrt(a/Ux) - 1.5/Ux);
+      //JMQ fix in units
+        if ( theEnergy-KineticEnergy < Ex)
+          {
+            Probability *= std::exp((theEnergy-KineticEnergy-E0)/T)/T;
+          }
+        else
+          {
+            Probability *= std::exp(2*std::sqrt(a*(theEnergy-KineticEnergy-delta0)))/
+              std::pow(a*std::pow(theEnergy-KineticEnergy-delta0,5.0),1.0/4.0);
+          }
+        Probability /= Normalization;
+      }
+    while (G4UniformRand() > Probability);
+    return KineticEnergy;
+      if ( theEnergy-KineticEnergy < Ex)
+        {
+          G4double E0 = Ex - T*(std::log(T/MeV) - std::log(a*MeV)/4.0
+                                - 1.25*std::log(Ux/MeV) + 2.0*std::sqrt(a*Ux));
+          Probability *= std::exp((theEnergy-KineticEnergy-E0)/T)/T;
+        }
+      else
+        {
+          Probability *= std::exp(2*std::sqrt(a*(theEnergy-KineticEnergy-delta0)))/
+            std::pow(a*fG4pow->powN(theEnergy-KineticEnergy-delta0,5), 0.25);
+        }
+    }
+  while (Normalization*G4UniformRand() > Probability);
+  return KineticEnergy;
+}
 …
     // By default Magnitude = 1.0
+{
     G4double CosTheta = 1.0 - 2.0*G4UniformRand();
     G4double SinTheta = std::sqrt(1.0 - CosTheta*CosTheta);
     G4double Phi = twopi*G4UniformRand();
     G4ThreeVector Vector(Magnitude*std::cos(Phi)*SinTheta,
                          Magnitude*std::sin(Phi)*SinTheta,
                          Magnitude*CosTheta);
     return Vector;
+}
+  G4double CosTheta = 1.0 - 2.0*G4UniformRand();
+  G4double SinTheta = std::sqrt(1.0 - CosTheta*CosTheta);
+  G4double Phi = twopi*G4UniformRand();
+  G4ThreeVector Vector(Magnitude*std::cos(Phi)*SinTheta,
+                       Magnitude*std::sin(Phi)*SinTheta,
+                       Magnitude*CosTheta);
+  return Vector;
+}

trunk/source/processes/hadronic/models/de_excitation/gem_evaporation/src/G4GEMProbability.cc

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4GEMProbability.cc,v 1.13 2010/05/19 10:21:16 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4GEMProbability.cc,v 1.15 2010/11/05 14:43:27 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //---------------------------------------------------------------------
 …
+}
 G4GEMProbability:: G4GEMProbability(const G4int anA, const G4int aZ, const G4double aSpin) :
+G4GEMProbability:: G4GEMProbability(G4int anA, G4int aZ, G4double aSpin) :
   theA(anA), theZ(aZ), Spin(aSpin), theCoulombBarrierPtr(0),
   ExcitationEnergies(0), ExcitationSpins(0), ExcitationLifetimes(0), Normalization(1.0)
 …
 G4double G4GEMProbability::EmissionProbability(const G4Fragment & fragment,
                                                const G4double MaximalKineticEnergy)
+                                               G4double MaximalKineticEnergy)
+{
   G4double EmissionProbability = 0.0;
 …
 G4double G4GEMProbability::CalcProbability(const G4Fragment & fragment,
                                            const G4double MaximalKineticEnergy,
                                            const G4double V)
+                                           G4double MaximalKineticEnergy,
+                                           G4double V)
 // Calculate integrated probability (width) for evaporation channel
 …
   G4double Alpha = CalcAlphaParam(fragment);
   G4double Beta = CalcBetaParam(fragment);
   //                       ***RESIDUAL***
   //JMQ (September 2009) the following quantities refer to the RESIDUAL:
 …
   G4double T  = 1.0/(std::sqrt(a/Ux) - 1.5/Ux);
   //JMQ fixed bug in units
+  G4double E0 = Ex - T*(std::log(T/MeV) - std::log(a*MeV)/4.0 - 1.25*std::log(Ux/MeV) + 2.0*std::sqrt(a*Ux));
+  G4double E0 = Ex - T*(std::log(T/MeV) - std::log(a*MeV)/4.0
+        - 1.25*std::log(Ux/MeV) + 2.0*std::sqrt(a*Ux));
   //                      ***end RESIDUAL ***
 …
   //JMQ (September 2009) the following quantities refer to the PARENT:
+  G4double deltaCN=fPairCorr->GetPairingCorrection(A, Z);
+  G4double aCN = theEvapLDPptr->LevelDensityParameter(A, Z, U-deltaCN);
+  G4double UxCN = (2.5 + 150.0/G4double(A))*MeV;
+  G4double ExCN = UxCN + deltaCN;
+  G4double TCN = 1.0/(std::sqrt(aCN/UxCN) - 1.5/UxCN);
+  //JMQ fixed bug in units
+  G4double E0CN = ExCN - TCN*(std::log(TCN/MeV) - std::log(aCN*MeV)/4.0 - 1.25*std::log(UxCN/MeV) + 2.0*std::sqrt(aCN*UxCN));
+//                       ***end PARENT***
+  G4double deltaCN = fPairCorr->GetPairingCorrection(A, Z);
+  G4double aCN     = theEvapLDPptr->LevelDensityParameter(A, Z, U-deltaCN);
+  G4double UxCN    = (2.5 + 150.0/G4double(A))*MeV;
+  G4double ExCN    = UxCN + deltaCN;
+  G4double TCN     = 1.0/(std::sqrt(aCN/UxCN) - 1.5/UxCN);
+  //                     ***end PARENT***
   G4double Width;
 …
   //end of JMQ fix on Rb by 190709
+//JMQ 160909 fix: initial level density must be calculated according to the
+// conditions at the initial compound nucleus
+// (it has been removed from previous "if" for the residual)
+   if ( U < ExCN )
+      {
+        InitialLevelDensity = (pi/12.0)*std::exp((U-E0CN)/TCN)/TCN;
+      }
+    else
+      {
+        //        InitialLevelDensity = (pi/12.0)*std::exp(2*std::sqrt(aCN*(U-deltaCN)))/std::pow(aCN*std::pow(U-deltaCN,5.0),1.0/4.0);
+        //VI speedup
+        G4double x  = U-deltaCN;
+        G4double x2 = x*x;
+        G4double x3 = x2*x;
+        InitialLevelDensity = (pi/12.0)*std::exp(2*std::sqrt(aCN*x))/std::sqrt(std::sqrt(aCN*x2*x3));
+      }
+ //
+  //JMQ 160909 fix: initial level density must be calculated according to the
+  // conditions at the initial compound nucleus
+  // (it has been removed from previous "if" for the residual)
+  if ( U < ExCN )
+    {
+      //JMQ fixed bug in units
+      //VI moved the computation here
+      G4double E0CN = ExCN - TCN*(std::log(TCN/MeV) - std::log(aCN*MeV)/4.0
+                                  - 1.25*std::log(UxCN/MeV) + 2.0*std::sqrt(aCN*UxCN));
+      InitialLevelDensity = (pi/12.0)*std::exp((U-E0CN)/TCN)/TCN;
+    }
+  else
+    {
+      //InitialLevelDensity = (pi/12.0)*std::exp(2*std::sqrt(aCN*(U-deltaCN)))/std::pow(aCN*std::pow(U-deltaCN,5.0),1.0/4.0);
+      //VI speedup
+      G4double x  = U-deltaCN;
+      G4double x1 = std::sqrt(aCN*x);
+      InitialLevelDensity = (pi/12.0)*std::exp(2*x1)/(x*std::sqrt(x1));
+    }
   //JMQ 190709 BUG : pi instead of sqrt(pi) must be here according to Furihata's report:
 …
   Width *= pi*g*GeometricalXS*Alpha/(12.0*InitialLevelDensity);
   return Width;
+}
+/*
+G4double G4GEMProbability::CalcProbability(const G4Fragment & fragment,
+                                           const G4double MaximalKineticEnergy,
+                                           const G4double V)
+// Calculate integrated probability (width) for evaporation channel
+{
+  G4double ResidualA = static_cast<G4double>(fragment.GetA() - theA);
+  G4double ResidualZ = static_cast<G4double>(fragment.GetZ() - theZ);
+  G4double U = fragment.GetExcitationEnergy();
+  G4double NuclearMass = G4ParticleTable::GetParticleTable()->
+    GetIonTable()->GetNucleusMass(theZ,theA);
+  G4double Alpha = CalcAlphaParam(fragment);
+  G4double Beta = CalcBetaParam(fragment);
+  //                       ***RESIDUAL***
+  //JMQ (September 2009) the following quantities refer to the RESIDUAL:
+  G4double delta0 = G4PairingCorrection::GetInstance()->GetPairingCorrection( static_cast<G4int>( ResidualA ) , static_cast<G4int>( ResidualZ ) );
+  G4double a = theEvapLDPptr->LevelDensityParameter(static_cast<G4int>(ResidualA),
+                                                    static_cast<G4int>(ResidualZ),MaximalKineticEnergy+V-delta0);
+  G4double Ux = (2.5 + 150.0/ResidualA)*MeV;
+  G4double Ex = Ux + delta0;
+  G4double T = 1.0/(std::sqrt(a/Ux) - 1.5/Ux);
+  //JMQ fixed bug in units
+  G4double E0 = Ex - T*(std::log(T/MeV) - std::log(a*MeV)/4.0 - 1.25*std::log(Ux/MeV) + 2.0*std::sqrt(a*Ux));
+  //                      ***end RESIDUAL ***
+  //                       ***PARENT***
+  //JMQ (September 2009) the following quantities refer to the PARENT:
+  G4double deltaCN=G4PairingCorrection::GetInstance()->
+    GetPairingCorrection(static_cast<G4int>(fragment.GetA()),static_cast<G4int>(fragment.GetZ()));
+  G4double aCN = theEvapLDPptr->LevelDensityParameter(static_cast<G4int>(fragment.GetA()),
+                                                      static_cast<G4int>(fragment.GetZ()),U-deltaCN);
+  G4double UxCN = (2.5 + 150.0/fragment.GetA())*MeV;
+  G4double ExCN = UxCN + deltaCN;
+  G4double TCN = 1.0/(std::sqrt(aCN/UxCN) - 1.5/UxCN);
+  //JMQ fixed bug in units
+  G4double E0CN = ExCN - TCN*(std::log(TCN/MeV) - std::log(aCN*MeV)/4.0 - 1.25*std::log(UxCN/MeV) + 2.0*std::sqrt(aCN*UxCN));
+//                       ***end PARENT***
+  G4double Width;
+  G4double InitialLevelDensity;
+  G4double t = MaximalKineticEnergy/T;
+  if ( MaximalKineticEnergy < Ex ) {
+    //JMQ 190709 bug in I1 fixed (T was  missing)
+    Width = (I1(t,t)*T + (Beta+V)*I0(t))/std::exp(E0/T);
+//JMQ 160909 fix:  InitialLevelDensity has been taken away (different conditions for initial CN..)
+  } else {
+    G4double tx = Ex/T;
+    G4double s = 2.0*std::sqrt(a*(MaximalKineticEnergy-delta0));
+    G4double sx = 2.0*std::sqrt(a*(Ex-delta0));
+    Width = I1(t,tx)*T/std::exp(E0/T) + I3(s,sx)*std::exp(s)/(std::sqrt(2.0)*a);
+    // For charged particles (Beta+V) = 0 beacuse Beta = -V
+    if (theZ == 0) {
+      Width += (Beta+V)*(I0(tx)/std::exp(E0/T) + 2.0*std::sqrt(2.0)*I2(s,sx)*std::exp(s));
+    }
+  }
+  //JMQ 14/07/2009 BIG BUG : NuclearMass is in MeV => hbarc instead of hbar_planck must be used
+  //    G4double g = (2.0*Spin+1.0)*NuclearMass/(pi2* hbar_Planck*hbar_Planck);
+  G4double g = (2.0*Spin+1.0)*NuclearMass/(pi2* hbarc*hbarc);
+  //JMQ 190709 fix on Rb and  geometrical cross sections according to Furihata's paper
+  //                      (JAERI-Data/Code 2001-105, p6)
+  //    G4double RN = 0.0;
+  G4double Rb = 0.0;
+  if (theA > 4)
+    {
+      //        G4double R1 = std::pow(ResidualA,1.0/3.0);
+      //        G4double R2 = std::pow(G4double(theA),1.0/3.0);
+      G4double Ad = std::pow(ResidualA,1.0/3.0);
+      G4double Aj = std::pow(G4double(theA),1.0/3.0);
+      //        RN = 1.12*(R1 + R2) - 0.86*((R1+R2)/(R1*R2));
+      Rb = 1.12*(Aj + Ad) - 0.86*((Aj+Ad)/(Aj*Ad))+2.85;
+      Rb *= fermi;
+    }
+  else if (theA>1)
+    {
+      G4double Ad = std::pow(ResidualA,1.0/3.0);
+      G4double Aj = std::pow(G4double(theA),1.0/3.0);
+      Rb=1.5*(Aj+Ad)*fermi;
+    }
+  else
+    {
+      G4double Ad = std::pow(ResidualA,1.0/3.0);
+      Rb = 1.5*Ad*fermi;
+    }
+  //   G4double GeometricalXS = pi*RN*RN*std::pow(ResidualA,2./3.);
+  G4double GeometricalXS = pi*Rb*Rb;
+  //end of JMQ fix on Rb by 190709
+//JMQ 160909 fix: initial level density must be calculated according to the
+// conditions at the initial compound nucleus
+// (it has been removed from previous "if" for the residual)
+   if ( U < ExCN )
+      {
+        InitialLevelDensity = (pi/12.0)*std::exp((U-E0CN)/TCN)/TCN;
+      }
+    else
+      {
+        InitialLevelDensity = (pi/12.0)*std::exp(2*std::sqrt(aCN*(U-deltaCN)))/std::pow(aCN*std::pow(U-deltaCN,5.0),1.0/4.0);
+      }
+ //
+  //JMQ 190709 BUG : pi instead of sqrt(pi) must be here according to Furihata's report:
+  //    Width *= std::sqrt(pi)*g*GeometricalXS*Alpha/(12.0*InitialLevelDensity);
+  Width *= pi*g*GeometricalXS*Alpha/(12.0*InitialLevelDensity);
+  return Width;
+}
+*/
+G4double G4GEMProbability::I3(const G4double s, const G4double sx)
+G4double G4GEMProbability::I3(G4double s, G4double sx)
+{
   G4double s2 = s*s;

trunk/source/processes/hadronic/models/de_excitation/handler/include/G4ExcitationHandler.hh

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4ExcitationHandler.hh,v 1.12 2010/04/27 14:00:23 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4ExcitationHandler.hh,v 1.13 2010/11/17 16:20:31 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 #include "G4ReactionProductVector.hh"
 #include "G4ReactionProduct.hh"
-#include "G4ParticleTypes.hh"
-#include "G4ParticleTable.hh"
 // needed for default models
 #include "G4Evaporation.hh"
 …
 #include "G4FermiBreakUp.hh"
 #include "G4PhotonEvaporation.hh"
+#include "G4IonConstructor.hh"
+class G4IonTable;
 class G4ExcitationHandler
 …
   G4double minExcitation;
   G4ParticleTable *theTableOfParticles;
+  G4IonTable* theTableOfIons;
   G4bool MyOwnEvaporationClass;

trunk/source/processes/hadronic/models/de_excitation/handler/src/G4ExcitationHandler.cc

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4ExcitationHandler.cc,v 1.39 2010/05/18 15:46:11 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4ExcitationHandler.cc,v 1.40 2010/11/17 16:20:38 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 #include "G4LorentzVector.hh"
 #include "G4NistManager.hh"
+#include "G4ParticleTable.hh"
+#include "G4IonTable.hh"
+#include "G4IonConstructor.hh"
+#include "G4ParticleTypes.hh"
 #include <list>
 …
   maxZForFermiBreakUp(9),maxAForFermiBreakUp(17),minEForMultiFrag(4.0*GeV),
   //  maxZForFermiBreakUp(9),maxAForFermiBreakUp(17),minEForMultiFrag(3.0*MeV),
-  //maxZForFermiBreakUp(1),maxAForFermiBreakUp(1),minEForMultiFrag(4.0*GeV),
   minExcitation(CLHEP::keV),
   MyOwnEvaporationClass(true), MyOwnMultiFragmentationClass(true),MyOwnFermiBreakUpClass(true),
   MyOwnPhotonEvaporationClass(true),OPTxs(3),useSICB(false)
+{
   theTableOfParticles = G4ParticleTable::GetParticleTable();
+  theTableOfIons = G4ParticleTable::GetParticleTable()->GetIonTable();
   theEvaporation = new G4Evaporation;
 …
         theKindOfFragment = G4Alpha::AlphaDefinition();;
       } else {
+        theKindOfFragment = theTableOfParticles->FindIon(theFragmentZ,theFragmentA,0,theFragmentZ);
+        theKindOfFragment =
+          theTableOfIons->GetIon(theFragmentZ,theFragmentA,0.0);
+      }
       if (theKindOfFragment != 0)
 …
   return theReactionProductVector;
+}
 G4ReactionProductVector *
 …
       theKindOfFragment = theAlpha;
     } else {
+      theKindOfFragment = theTableOfParticles->FindIon(theFragmentZ,theFragmentA,0,theFragmentZ);
+      theKindOfFragment =
+        theTableOfIons->GetIon(theFragmentZ,theFragmentA,0.0);
+    }
     if (theKindOfFragment != 0)
 …
         theNew->SetTotalEnergy(theFragmentMomentum.e());
         theNew->SetFormationTime((*i)->GetCreationTime());
-#ifdef PRECOMPOUND_TEST
-        theNew->SetCreatorModel((*i)->GetCreatorModel());
-#endif
         theReactionProductVector->push_back(theNew);
+      }
 …
     ProductsEnergy += tmp.e();
     ProductsMomentum += tmp.vect();
     ProductsA += static_cast<G4int>((*h)->GetA());
     ProductsZ += static_cast<G4int>((*h)->GetZ());
+    ProductsA += (*h)->GetA_asInt();
+    ProductsZ += (*h)->GetZ_asInt();
+  }
   if (ProductsA != theInitialState.GetA()) {
+  if (ProductsA != theInitialState.GetA_asInt()) {
     G4cout << "!!!!!!!!!! Baryonic Number Conservation Violation !!!!!!!!!!" << G4endl;
     G4cout << "G4ExcitationHandler.cc: Barionic Number Conservation test for deexcitation fragments"
            << G4endl;
     G4cout << "Initial A = " << theInitialState.GetA()
+    G4cout << "Initial A = " << theInitialState.GetA_asInt()
            << "   Fragments A = " << ProductsA << "   Diference --> "
            << theInitialState.GetA() - ProductsA << G4endl;
+  }
   if (ProductsZ != theInitialState.GetZ()) {
+  if (ProductsZ != theInitialState.GetZ_asInt()) {
     G4cout << "!!!!!!!!!! Charge Conservation Violation !!!!!!!!!!" << G4endl;
     G4cout << "G4ExcitationHandler.cc: Charge Conservation test for deexcitation fragments"

trunk/source/processes/hadronic/models/de_excitation/management/include/G4VEvaporationChannel.hh

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4VEvaporationChannel.hh,v 1.6 2010/05/11 11:16:04 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4VEvaporationChannel.hh,v 1.7 2010/10/29 17:35:04 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
   virtual ~G4VEvaporationChannel();
-private:
-  G4VEvaporationChannel(const G4VEvaporationChannel & right);
-  const G4VEvaporationChannel & operator=(const G4VEvaporationChannel & right);
-public:
-  G4bool operator==(const G4VEvaporationChannel & right) const;
-  G4bool operator!=(const G4VEvaporationChannel & right) const;
   virtual void Initialize(const G4Fragment & fragment) = 0;
 …
   virtual G4double GetEmissionProbability(void) const = 0;
   G4String GetName() const {return Name;}
   void SetName(const G4String & aName) { Name = aName;}
+  inline G4String GetName() const {return Name;}
+  inline void SetName(const G4String & aName) { Name = aName;}
   // for cross section selection
 …
   G4String Name;
+  G4VEvaporationChannel(const G4VEvaporationChannel & right);
+  const G4VEvaporationChannel & operator=(const G4VEvaporationChannel & right);
+  G4bool operator==(const G4VEvaporationChannel & right) const;
+  G4bool operator!=(const G4VEvaporationChannel & right) const;
 };

trunk/source/processes/hadronic/models/de_excitation/management/src/G4VEvaporationChannel.cc

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4VEvaporationChannel.cc,v 1.6 2010/04/25 18:43:08 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4VEvaporationChannel.cc,v 1.7 2010/10/29 17:35:04 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 //                          new virtual methods EmittedFragment(s) to allow more optimal
 //                          work with G4Fragment objects; removed unnecesary exceptions
+// 28.10.2010 V.Ivanchenko defined members in constructor and cleaned up
 #include "G4VEvaporationChannel.hh"
-#include "G4HadronicException.hh"
 G4VEvaporationChannel::G4VEvaporationChannel(const G4String & aName)
   : Name(aName)
+  :OPTxs(3),useSICB(false),Name(aName)
 {}
 G4VEvaporationChannel::~G4VEvaporationChannel()
 {}
-//G4VEvaporationChannel::G4VEvaporationChannel(const G4VEvaporationChannel &)
-//{
-// throw G4HadronicException(__FILE__, __LINE__, "G4VEvaporationChannel::copy_constructor meant to not be accessable");
-//}
-//const G4VEvaporationChannel & G4VEvaporationChannel::operator=(const G4VEvaporationChannel &)
-//{
-//  throw G4HadronicException(__FILE__, __LINE__, "G4VEvaporationChannel::operator= meant to not be accessable");
-//  return *this;
-//}
-G4bool G4VEvaporationChannel::operator==(const G4VEvaporationChannel &right) const
+{
-  return (this == (G4VEvaporationChannel *) &right);
+}
-G4bool G4VEvaporationChannel::operator!=(const G4VEvaporationChannel &right) const
+{
-  return (this != (G4VEvaporationChannel *) &right);
+}
 G4Fragment* G4VEvaporationChannel::EmittedFragment(G4Fragment*)

trunk/source/processes/hadronic/models/de_excitation/multifragmentation/include/G4StatMFMacroTemperature.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4StatMFMacroTemperature.hh,v 1.4 2010/04/16 17:04:08 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4StatMFMacroTemperature.hh,v 1.5 2010/10/29 17:35:04 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 public:
     G4double GetMeanMultiplicity(void) const {return _MeanMultiplicity;}
+    inline G4double GetMeanMultiplicity(void) const {return _MeanMultiplicity;}
     G4double GetChemicalPotentialMu(void) const {return _ChemPotentialMu;}
+    inline G4double GetChemicalPotentialMu(void) const {return _ChemPotentialMu;}
     G4double GetChemicalPotentialNu(void) const {return _ChemPotentialNu;}
+    inline G4double GetChemicalPotentialNu(void) const {return _ChemPotentialNu;}
     G4double GetTemperature(void) const {return _MeanTemperature;}
+    inline G4double GetTemperature(void) const {return _MeanTemperature;}
     G4double GetEntropy(void) const {return _MeanEntropy;}
+    inline G4double GetEntropy(void) const {return _MeanEntropy;}
     G4double CalcTemperature(void);

trunk/source/processes/hadronic/models/de_excitation/multifragmentation/src/G4StatMF.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4StatMF.cc,v 1.6 2008/07/25 11:20:47 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4StatMF.cc,v 1.7 2010/10/29 17:35:04 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
   if (theFragment.GetExcitationEnergy() <= 0.0) {
     G4FragmentVector * theResult = new G4FragmentVector;
     theResult->push_back(new G4Fragment(theFragment));
+    //G4FragmentVector * theResult = new G4FragmentVector;
+    //theResult->push_back(new G4Fragment(theFragment));
     return 0;
+  }

trunk/source/processes/hadronic/models/de_excitation/multifragmentation/src/G4StatMFMacroTemperature.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4StatMFMacroTemperature.cc,v 1.8 2010/04/16 17:04:08 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4StatMFMacroTemperature.cc,v 1.9 2010/10/29 17:35:04 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 //          to protect code from rare unwanted exception; moved constructor
 //          and destructor to source
+// 28.10.10 V.Ivanchenko defined members in constructor and cleaned up
 #include "G4StatMFMacroTemperature.hh"
 …
   _ChemPotentialMu(0.0),
   _ChemPotentialNu(0.0),
+  _MeanEntropy(0.0),
   _theClusters(ClusterVector)
-{}
-G4StatMFMacroTemperature::G4StatMFMacroTemperature()
 {}
 G4StatMFMacroTemperature::~G4StatMFMacroTemperature()
 {}
-// operators definitions
-G4StatMFMacroTemperature &
-G4StatMFMacroTemperature::operator=(const G4StatMFMacroTemperature & )
+{
-    throw G4HadronicException(__FILE__, __LINE__, "G4StatMFMacroTemperature::operator= meant to not be accessable");
-    return *this;
+}
-G4bool G4StatMFMacroTemperature::operator==(const G4StatMFMacroTemperature & ) const
+{
-    throw G4HadronicException(__FILE__, __LINE__, "G4StatMFMacroTemperature::operator== meant to not be accessable");
-    return false;
+}
-G4bool G4StatMFMacroTemperature::operator!=(const G4StatMFMacroTemperature & ) const
+{
-    throw G4HadronicException(__FILE__, __LINE__, "G4StatMFMacroTemperature::operator!= meant to not be accessable");
-    return true;
+}

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4ContinuumGammaDeexcitation.hh

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4ContinuumGammaDeexcitation.hh,v 1.4 2010/04/25 18:43:21 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4ContinuumGammaDeexcitation.hh,v 1.5 2010/11/17 19:17:17 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // -------------------------------------------------------------------
 …
 //
 #ifndef G4ContinuumGammaDeexcitation_hh
 #define G4ContinuumGammaDeexcitation_hh
+#define G4ContinuumGammaDeexcitation_hh 1
 #include "G4VGammaDeexcitation.hh"

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4ContinuumGammaTransition.hh

-              r819
+              r1347
 // ********************************************************************
 //
+// $Id: G4ContinuumGammaTransition.hh,v 1.3 2010/11/17 19:17:17 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // -------------------------------------------------------------------
 …
 #ifndef G4ContinuumGammaTransition_hh
 #define G4ContinuumGammaTransition_hh
+#define G4ContinuumGammaTransition_hh 1
 #include "globals.hh"
 …
   // Destructor
   ~G4ContinuumGammaTransition();
+  virtual ~G4ContinuumGammaTransition();
   // Functions
 //--  virtual G4double GammaEnergy();
 //--  virtual G4double GetEnergyTo() const;
   virtual void SetEnergyFrom(const G4double energy);
+  //--  virtual G4double GammaEnergy();
+  //--  virtual G4double GetEnergyTo() const;
+  virtual void SetEnergyFrom(G4double energy);
   virtual G4double GetGammaEnergy();
   virtual G4double GetGammaCreationTime();

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4DiscreteGammaDeexcitation.hh

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4DiscreteGammaDeexcitation.hh,v 1.4 2010/04/25 18:43:21 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4DiscreteGammaDeexcitation.hh,v 1.5 2010/11/17 19:17:17 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // -------------------------------------------------------------------
 …
   virtual G4bool CanDoTransition();
   void SetICM(G4bool hl) { _icm = hl; };
+  inline void SetICM(G4bool hl) { _icm = hl; };
   void SetRDM(G4bool hl) { _rdm = hl; };
+  inline void SetRDM(G4bool hl) { _rdm = hl; };
   void SetHL(G4double hl) { _max_hl = hl; };
+  inline void SetHL(G4double hl) { _max_hl = hl; };
 private:

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4DiscreteGammaTransition.hh

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4DiscreteGammaTransition.hh,v 1.5 2010/10/07 12:31:00 mkelsey Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4DiscreteGammaTransition.hh,v 1.6 2010/11/17 19:17:17 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // -------------------------------------------------------------------
 …
   // Constructor
   G4DiscreteGammaTransition(const G4NuclearLevel& level);
 //JMQ 180410
 //  G4DiscreteGammaTransition(const G4NuclearLevel& level, G4int Z);
+  //JMQ 180410
+  //  G4DiscreteGammaTransition(const G4NuclearLevel& level, G4int Z);
   G4DiscreteGammaTransition(const G4NuclearLevel& level, G4int Z, G4int A);
   // Destructor
   ~G4DiscreteGammaTransition();
+  virtual ~G4DiscreteGammaTransition();
   // Functions
 …
 public:
   virtual void SetEnergyFrom(const G4double energy);
+  virtual void SetEnergyFrom(G4double energy);
   virtual G4double GetGammaEnergy();
   virtual G4double GetGammaCreationTime();
   virtual void SelectGamma();
   void SetICM(G4bool ic) { _icm = ic;};
   G4double GetBondEnergy () {return _bondE;};
   G4int GetOrbitNumber () {return _orbitE;};
   G4bool IsAGamma() {return _aGamma;};
+  inline void SetICM(G4bool ic) { _icm = ic;};
+  inline G4double GetBondEnergy () {return _bondE;};
+  inline G4int GetOrbitNumber () {return _orbitE;};
+  inline G4bool IsAGamma() {return _aGamma;};
 private:

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4E1Probability.hh

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4E1Probability.hh,v 1.5 2010/05/19 10:21:44 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4E1Probability.hh,v 1.6 2010/11/17 17:59:04 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //---------------------------------------------------------------------
 …
   virtual ~G4E1Probability();
   G4double EmissionProbability(const G4Fragment& frag, const G4double excite);
   G4double EmissionProbDensity(const G4Fragment& frag, const G4double ePhoton);
+  G4double EmissionProbability(const G4Fragment& frag, G4double excite);
+  G4double EmissionProbDensity(const G4Fragment& frag, G4double ePhoton);
 private:
 …
   // Integrator (simple Gaussian quadrature)
+  G4double EmissionIntegration(const G4Fragment& frag, const G4double excite,
+                               const G4double lowLim, const G4double upLim,
+                               const G4int numIters);
+  G4double EmissionIntegration(const G4Fragment& frag,
+                               G4double lowLim, G4double upLim);
   // members

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4E1SingleProbability1.hh

-              r819
+              r1347
 // ********************************************************************
 //
+// $Id: G4E1SingleProbability1.hh,v 1.3 2010/11/17 16:50:53 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
 public:
   G4E1SingleProbability1() {};
+  G4E1SingleProbability1();
   ~G4E1SingleProbability1();
+  virtual ~G4E1SingleProbability1();
   G4double EmissionProbability(const G4Fragment& frag, const G4double excite);
   G4double EmissionProbDensity(const G4Fragment& frag, const G4double ePhoton);
+  G4double EmissionProbability(const G4Fragment& frag, G4double excite);
+  G4double EmissionProbDensity(const G4Fragment& frag, G4double ePhoton);
 private:
-  // G4E1SingleProbability1() {};
   G4E1SingleProbability1(const G4E1SingleProbability1& right);
 …
   // Integrator (simple Gaussian quadrature)
+  G4double EmissionIntegration(const G4Fragment& frag, const G4double excite,
+                               const G4double lowLim, const G4double upLim,
+                               const G4int numIters);
+  // G4VLevelDensityParameter* _levelDensity; // Don't need this
+  G4double EmissionIntegration(const G4Fragment& frag, G4double excite,
+                               G4double lowLim, G4double upLim,
+                               G4int numIters);
 };

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4NeutronRadCapture.hh

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4NeutronRadCapture.hh,v 1.1 2009/08/31 13:52:42 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4NeutronRadCapture.hh,v 1.2 2010/10/29 17:35:04 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
 #include "G4Nucleus.hh"
-class G4ParticleDefinition;
 class G4PhotonEvaporation;
 …
   G4double lowestEnergyLimit;
-  G4ParticleDefinition* theNeutron;
   G4PhotonEvaporation* photonEvaporation;
 };

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4NuclearLevel.hh

-              r1340
+              r1347
 // ********************************************************************
 //
+// $Id: G4NuclearLevel.hh,v 1.4 2010/10/07 07:50:13 mkelsey Exp $
+// $Id: G4NuclearLevel.hh,v 1.7 2010/11/17 19:17:17 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
+//
 // -------------------------------------------------------------------
 //      GEANT 4 class file
 …
 //              Added half-life, angular momentum, parity, emissioni type
 //              reading from experimental data.
+//
+//        28 October 2010, V.Ivanchenko moved copy constructor to source, cleanup
+//
 //
 // -------------------------------------------------------------------
 #ifndef G4NUCLEARLEVEL_HH
 #define G4NUCLEARLEVEL_HH
+#define G4NUCLEARLEVEL_HH 1
 #include "globals.hh"
-#include "G4NuclearLevel.hh"
 #include <vector>
 …
 public:
   G4NuclearLevel(const G4double energy, const G4double halfLife,
                  const G4double angularMomentum, const std::vector<double>& eGamma,
                  const std::vector<double>& wGamma, const std::vector<double>& polarities,
                  const std::vector<double>& kCC, const std::vector<double>& l1CC,
                  const std::vector<double>& l2CC, const std::vector<double>& l3CC,
                  const std::vector<double>& m1CC, const std::vector<double>& m2CC,
                  const std::vector<double>& m3CC, const std::vector<double>& m4CC,
                  const std::vector<double>& m5CC, const std::vector<double>& nPlusCC,
                  const std::vector<double>& totalCC);
+  G4NuclearLevel(G4double energy, G4double halfLife,
+                 G4double angularMomentum, const std::vector<G4double>& eGamma,
+                 const std::vector<G4double>& wGamma, const std::vector<G4double>& polarities,
+                 const std::vector<G4double>& kCC, const std::vector<G4double>& l1CC,
+                 const std::vector<G4double>& l2CC, const std::vector<G4double>& l3CC,
+                 const std::vector<G4double>& m1CC, const std::vector<G4double>& m2CC,
+                 const std::vector<G4double>& m3CC, const std::vector<G4double>& m4CC,
+                 const std::vector<G4double>& m5CC, const std::vector<G4double>& nPlusCC,
+                 const std::vector<G4double>& totalCC);
   ~G4NuclearLevel();
   const std::vector<double>& GammaEnergies() const;
+  const std::vector<G4double>& GammaEnergies() const;
   const std::vector<double>& GammaWeights() const;
+  const std::vector<G4double>& GammaWeights() const;
   const std::vector<double>& GammaProbabilities() const;
+  const std::vector<G4double>& GammaProbabilities() const;
   const std::vector<double>& GammaCumulativeProbabilities() const;
+  const std::vector<G4double>& GammaCumulativeProbabilities() const;
   const std::vector<double>& GammaPolarities() const;
+  const std::vector<G4double>& GammaPolarities() const;
   const std::vector<double>& KConvertionProbabilities() const;
+  const std::vector<G4double>& KConvertionProbabilities() const;
   const std::vector<double>& L1ConvertionProbabilities() const;
+  const std::vector<G4double>& L1ConvertionProbabilities() const;
   const std::vector<double>& L2ConvertionProbabilities() const;
+  const std::vector<G4double>& L2ConvertionProbabilities() const;
   const std::vector<double>& L3ConvertionProbabilities() const;
+  const std::vector<G4double>& L3ConvertionProbabilities() const;
   const std::vector<double>& M1ConvertionProbabilities() const;
+  const std::vector<G4double>& M1ConvertionProbabilities() const;
   const std::vector<double>& M2ConvertionProbabilities() const;
+  const std::vector<G4double>& M2ConvertionProbabilities() const;
   const std::vector<double>& M3ConvertionProbabilities() const;
+  const std::vector<G4double>& M3ConvertionProbabilities() const;
   const std::vector<double>& M4ConvertionProbabilities() const;
+  const std::vector<G4double>& M4ConvertionProbabilities() const;
   const std::vector<double>& M5ConvertionProbabilities() const;
+  const std::vector<G4double>& M5ConvertionProbabilities() const;
   const std::vector<double>& NPlusConvertionProbabilities() const;
+  const std::vector<G4double>& NPlusConvertionProbabilities() const;
   const std::vector<double>& TotalConvertionProbabilities() const;
+  const std::vector<G4double>& TotalConvertionProbabilities() const;
   G4double Energy() const;
 …
   G4bool operator!=(const G4NuclearLevel &right) const;
   G4bool operator<(const G4NuclearLevel &right) const;
+  const G4NuclearLevel& operator=(const G4NuclearLevel &right);
+    const G4NuclearLevel& operator=(const G4NuclearLevel &right)
+    {
+      if(this != &right)
+      {
+      _energies = right._energies;
+      _weights =right._weights;
+      _prob =right._prob;
+      _cumProb =right._cumProb;
+      _polarities =right._polarities;
+      _kCC = right._kCC;
+      _l1CC =right._l1CC;
+      _l2CC =right._l2CC;
+      _l3CC =right._l3CC;
+      _m1CC = right._m1CC;
+      _m2CC = right._m2CC;
+      _m3CC = right._m3CC;
+      _m4CC = right._m4CC;
+      _m5CC = right._m5CC;
+      _nPlusCC = right._nPlusCC;
+      _totalCC = right._totalCC;
+      _energy = right._energy;
+      _halfLife = right._halfLife;
+      _angularMomentum = right._angularMomentum;
+      _nGammas = right._nGammas;
+      }
+      return *this;
+    }
+    G4NuclearLevel(const G4NuclearLevel &right)
+    {
+      if(this != &right) *this = right;
+//      G4cout << "####### Incrementing "<<Increment(1)<<G4endl;
+    }
+protected:
+  G4NuclearLevel(const G4NuclearLevel &right);
 private:
   friend class G4NuclearLevelManager;
   G4NuclearLevel();
   G4NuclearLevel(const G4double energy, const G4double halfLife,
                  const G4double angularMomentum);
+  G4NuclearLevel(G4double energy, G4double halfLife,
+                 G4double angularMomentum);
   void Finalize();
 …
   G4int Increment(G4int aF);
   std::vector<double> _energies;
   std::vector<double> _weights;
   std::vector<double> _prob;
   std::vector<double> _cumProb;
   std::vector<double> _polarities;
   std::vector<double> _kCC;
   std::vector<double> _l1CC;
   std::vector<double> _l2CC;
   std::vector<double> _l3CC;
   std::vector<double> _m1CC;
   std::vector<double> _m2CC;
   std::vector<double> _m3CC;
   std::vector<double> _m4CC;
   std::vector<double> _m5CC;
   std::vector<double> _nPlusCC;
   std::vector<double> _totalCC;
+  std::vector<G4double> _energies;
+  std::vector<G4double> _weights;
+  std::vector<G4double> _prob;
+  std::vector<G4double> _cumProb;
+  std::vector<G4double> _polarities;
+  std::vector<G4double> _kCC;
+  std::vector<G4double> _l1CC;
+  std::vector<G4double> _l2CC;
+  std::vector<G4double> _l3CC;
+  std::vector<G4double> _m1CC;
+  std::vector<G4double> _m2CC;
+  std::vector<G4double> _m3CC;
+  std::vector<G4double> _m4CC;
+  std::vector<G4double> _m5CC;
+  std::vector<G4double> _nPlusCC;
+  std::vector<G4double> _totalCC;
   G4double _energy;
 …

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4NuclearLevelManager.hh

-              r1340
+              r1347
 // ********************************************************************
 //
+// $Id: G4NuclearLevelManager.hh,v 1.5 2010/10/10 23:01:39 mkelsey Exp $
+// $Id: G4NuclearLevelManager.hh,v 1.6 2010/11/17 16:50:53 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
+//
 // -------------------------------------------------------------------
 //      GEANT 4 class file
 …
 #ifndef G4NUCLEARLEVELMANAGER_HH
 #define G4NUCLEARLEVELMANAGER_HH
+#define G4NUCLEARLEVELMANAGER_HH 1
 #include "globals.hh"
 …
   G4NuclearLevelManager();
   G4NuclearLevelManager(const G4int Z, const G4int A, const G4String& filename);
+  G4NuclearLevelManager(G4int Z, G4int A, const G4String& filename);
   G4NuclearLevelManager(const G4NuclearLevelManager & right);
   ~G4NuclearLevelManager();
   void SetNucleus(const G4int Z, const G4int A, const G4String& filename);
+  void SetNucleus(G4int Z, G4int A, const G4String& filename);
   G4bool IsValid() const { return _validity; }
+  inline G4bool IsValid() const { return _validity; }
   G4int NumberOfLevels() const { return (_levels ? _levels->size() : 0); }
+  inline G4int NumberOfLevels() const { return (_levels ? _levels->size() : 0); }
   const G4NuclearLevel* GetLevel(G4int i) const;
   const G4NuclearLevel* NearestLevel(const G4double energy,
                                      const G4double eDiffMax=9999.*GeV) const;
+  const G4NuclearLevel* NearestLevel(G4double energy,
+                                     G4double eDiffMax=9999.*GeV) const;
   const G4NuclearLevel* LowestLevel() const;

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4NuclearLevelStore.hh

-              r1340
+              r1347
 // ********************************************************************
 //
+// $Id: G4NuclearLevelStore.hh,v 1.3 2010/10/07 07:50:13 mkelsey Exp $
+// $Id: G4NuclearLevelStore.hh,v 1.4 2010/11/17 16:50:53 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
+// 20101004  M. Kelsey -- Replace G4String keys with integers (ZZZAAA),
+//              move string operation to GenerateFilename()
+// 04-10-2010  M. Kelsey -- Replace G4String keys with integers (ZZZAAA),
+//                          move string operation to GenerateFilename()
+// 17-11-2010 V. Ivanchenko - make as a classical singleton.
 #ifndef G4NuclearLevelStore_hh
 …
 public:
   static G4NuclearLevelStore* GetInstance();
   G4NuclearLevelManager* GetManager(const G4int Z, const G4int A);
+  G4NuclearLevelManager* GetManager(G4int Z, G4int A);
   ~G4NuclearLevelStore();
 private:
   G4int GenerateKey(const G4int Z, const G4int A) const { return Z*1000+A; }
+  G4int GenerateKey(G4int Z, G4int A) const { return Z*1000+A; }
   G4String GenerateFilename(const G4int Z, const G4int A) const;
+  G4String GenerateFilename(G4int Z, G4int A) const;
   typedef std::map<G4int,G4NuclearLevelManager*> ManagersMap;
 …
   ManagersMap theManagers;
   G4String dirName;
+  static G4NuclearLevelStore* theInstance;
 };
 #endif

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4PhotonEvaporation.hh

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4PhotonEvaporation.hh,v 1.7 2010/05/11 11:22:14 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4PhotonEvaporation.hh,v 1.8 2010/11/17 16:50:53 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // -------------------------------------------------------------------
 …
 #ifndef G4PHOTONEVAPORATION_HH
 #define G4PHOTONEVAPORATION_HH
+#define G4PHOTONEVAPORATION_HH 1
 #include "globals.hh"

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4PtrLevelVector.hh

-              r819
+              r1347
 // ********************************************************************
 //
+// $Id: G4PtrLevelVector.hh,v 1.3 2010/11/17 16:50:53 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // -------------------------------------------------------------------
 …
 // -------------------------------------------------------------------
 #ifndef G4PTRLEVELVECTOR_HH
 #define G4PTRLEVELVECTOR_HH
+#define G4PTRLEVELVECTOR_HH 1
 #include "G4NuclearLevel.hh"

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4RandGeneralTmp.hh

-              r819
+              r1347
 // ********************************************************************
 //
+// $Id: G4RandGeneralTmp.hh,v 1.5 2010/11/17 16:50:53 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
+//
 // -----------------------------------------------------------------------

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4VGammaDeexcitation.hh

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4VGammaDeexcitation.hh,v 1.8 2010/04/28 14:22:40 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4VGammaDeexcitation.hh,v 1.9 2010/11/17 16:50:53 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // -------------------------------------------------------------------
 …
 #ifndef G4VGAMMADEEXCITATION_HH
 #define G4VGAMMADEEXCITATION_HH
+#define G4VGAMMADEEXCITATION_HH 1
 #include "globals.hh"
 …
   inline void Initialize();
   void SetEO(G4ElectronOccupancy eo) { _electronO = eo; };
   void SetVaccantSN( G4int val ) { _vSN = val;};
+  inline void SetEO(G4ElectronOccupancy eo) { _electronO = eo; };
+  inline void SetVaccantSN( G4int val ) { _vSN = val;};
   G4ElectronOccupancy GetEO() { return _electronO; };
   G4int GetVacantSN() {return _vSN;};
+  inline G4ElectronOccupancy GetEO() { return _electronO; };
+  inline G4int GetVacantSN() {return _vSN;};
 protected:

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4VGammaTransition.hh

-              r819
+              r1347
 // ********************************************************************
 //
+// $Id: G4VGammaTransition.hh,v 1.6 2010/11/17 19:17:17 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // -------------------------------------------------------------------
 …
 //      Modifications:
 //
+//        15 April 1999, Alessandro Brunengo (Alessandro.Brunengo@ge.infn.it)
+//              Added creation time evaluation for products of evaporation
+// 15.04.1999, Alessandro Brunengo (Alessandro.Brunengo@ge.infn.it)
+//             Added creation time evaluation for products of evaporation
+// 30.10.2010  V.Ivanchenko moved constructor and destructor to the source
 //
 // -------------------------------------------------------------------
 #ifndef G4VGAMMATRANSITION_HH
 #define G4VGAMMATRANSITION_HH
+#define G4VGAMMATRANSITION_HH 1
 #include "globals.hh"
 …
 public:
   G4VGammaTransition() {};
+  G4VGammaTransition();
   virtual ~G4VGammaTransition() {};
+  virtual ~G4VGammaTransition();
   virtual void SelectGamma() = 0;
 …
   virtual G4double GetGammaCreationTime() = 0;
   virtual void SetEnergyFrom(const G4double energy) = 0;
+  virtual void SetEnergyFrom(G4double energy) = 0;
 private:

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/include/G4VPhotonEvaporation.hh

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4VPhotonEvaporation.hh,v 1.3 2010/04/25 18:43:21 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4VPhotonEvaporation.hh,v 1.4 2010/11/17 16:50:53 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // -------------------------------------------------------------------
 …
 //
 //      Modifications:
+//
+// 17-11-2010 V.Ivanchenko moved constructor an ddestructor to the source
 //
 // -------------------------------------------------------------------
 #ifndef G4VPHOTONEVAPORATION_HH
 #define G4VPHOTONEVAPORATION_HH
+#define G4VPHOTONEVAPORATION_HH 1
 #include "globals.hh"
 …
 public:
+  G4VPhotonEvaporation() {};
+  virtual ~G4VPhotonEvaporation() {};
+  G4bool operator==(const G4VPhotonEvaporation &right) const;
+  G4bool operator!=(const G4VPhotonEvaporation &right) const;
+  G4VPhotonEvaporation();
+  virtual ~G4VPhotonEvaporation();
   virtual G4FragmentVector* BreakItUp(const G4Fragment &theNucleus) = 0;
 …
   G4VPhotonEvaporation(const G4VPhotonEvaporation &right);
+    const G4VPhotonEvaporation& operator=(const G4VPhotonEvaporation &right);
+  const G4VPhotonEvaporation& operator=(const G4VPhotonEvaporation &right);
+  G4bool operator==(const G4VPhotonEvaporation &right) const;
+  G4bool operator!=(const G4VPhotonEvaporation &right) const;
 };

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4ContinuumGammaDeexcitation.cc

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4ContinuumGammaDeexcitation.cc,v 1.7 2010/04/30 16:08:03 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4ContinuumGammaDeexcitation.cc,v 1.8 2010/11/17 19:17:17 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // -------------------------------------------------------------------
 …
 G4ContinuumGammaDeexcitation::G4ContinuumGammaDeexcitation()
   : _nucleusZ(0), _nucleusA(0), _levelManager(0)
+{ }
+{}
 G4ContinuumGammaDeexcitation::~G4ContinuumGammaDeexcitation()
+{ }
+{}
 G4VGammaTransition* G4ContinuumGammaDeexcitation::CreateTransition()
+{
   G4Fragment* nucleus = GetNucleus();
   G4int Z = static_cast<G4int>(nucleus->GetZ());
   G4int A = static_cast<G4int>(nucleus->GetA());
+  G4int Z = nucleus->GetZ_asInt();
+  G4int A = nucleus->GetA_asInt();
   G4double excitation = nucleus->GetExcitationEnergy();
 …
     G4cout << "G4ContinuumGammaDeexcitation::CreateTransition - Created" << G4endl;
+  }
+  G4VGammaTransition* gt =  new G4ContinuumGammaTransition(_levelManager,Z,A,excitation,_verbose );
+  G4VGammaTransition* gt =
+    new G4ContinuumGammaTransition(_levelManager,Z,A,excitation,_verbose );
   return gt;
 …
 G4bool G4ContinuumGammaDeexcitation::CanDoTransition()
+{
+  //JMQ: far too small, creating sometimes continuum gammas instead of the right discrete ones
+  // (when excitation energy is slightly over maximum discrete  energy): changed
+  //JMQ: far too small, creating sometimes continuum gammas instead
+  //     of the right discrete ones (when excitation energy is slightly
+  //     over maximum discrete  energy): changed
   //  G4double tolerance = 10*eV;
   const G4double tolerance = CLHEP::keV;
 …
   G4double excitation = nucleus->GetExcitationEnergy();
+  //  G4int A = (G4int)nucleus->GetA();
+  // G4int Z = (G4int)nucleus->GetZ();
+  if (_nucleusA<2 || _nucleusZ<3)
+  if (_nucleusZ < 2 || _nucleusA < 3)
+    {
       if (_verbose > 1) {

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4ContinuumGammaTransition.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+// $Id: G4ContinuumGammaTransition.cc,v 1.4 2010/10/07 07:50:13 mkelsey Exp $
+// $Id: G4ContinuumGammaTransition.cc,v 1.5 2010/11/17 19:17:17 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
+//
 // -------------------------------------------------------------------
 //      GEANT 4 class file
 …
 //        15 April 1999, Alessandro Brunengo (Alessandro.Brunengo@ge.infn.it)
 //              Added creation time evaluation for products of evaporation
+//        02 May 2003,   Vladimir Ivanchenko change interface to G4NuclearlevelManager
+//        06 Oct 2010, M. Kelsey -- follow changes to G4NuclearLevelManager
+// -------------------------------------------------------------------
+//        02 May 2003,   V. Ivanchenko change interface to G4NuclearlevelManager
+//        06 Oct 2010,   M. Kelsey -- follow changes to G4NuclearLevelManager
+//        17 Nov 2010,   V. Ivanchenko use exponential law for sampling of time
+//                                     and extra cleanup
+// ----------------------------------------------------------------------------
 //
 //  Class G4ContinuumGammaTransition.cc
 …
 #include "G4ConstantLevelDensityParameter.hh"
 #include "G4RandGeneralTmp.hh"
+#include "Randomize.hh"
+#include "G4Pow.hh"
 //
 // Constructor
 …
   _eMin = 0.001 * MeV;
   // Giant Dipole Resonance energy
   G4double energyGDR = (40.3 / std::pow(G4double(_nucleusA),0.2) ) * MeV;
+  G4double energyGDR = (40.3 / G4Pow::GetInstance()->powZ(_nucleusA,0.2) ) * MeV;
   // Giant Dipole Resonance width
   G4double widthGDR = 0.30 * energyGDR;
 …
 //
+G4ContinuumGammaTransition::~G4ContinuumGammaTransition() {}
+//
+// Override GammaEnergy function from G4VGammaTransition
+//
+G4ContinuumGammaTransition::~G4ContinuumGammaTransition()
+{}
 void G4ContinuumGammaTransition::SelectGamma()
 …
   G4double finalExcitation = _excitation - _eGamma;
   if(_verbose > 10)
+  if(_verbose > 10) {
     G4cout << "*---*---* G4ContinuumTransition: eGamma = " << _eGamma
            << "   finalExcitation = " << finalExcitation
            << " random = " << random << G4endl;
 //  if (finalExcitation < 0)
+  }
+  //  if (finalExcitation < 0)
   if(finalExcitation < _minLevelE/2.)
+    {
 …
   _gammaCreationTime = GammaTime();
   if(_verbose > 10)
+  if(_verbose > 10) {
     G4cout << "*---*---* G4ContinuumTransition: _gammaCreationTime = "
            << _gammaCreationTime/second << G4endl;
+  }
   return;
+}
 …
+void G4ContinuumGammaTransition::SetEnergyFrom(const G4double energy)
+{
+void G4ContinuumGammaTransition::SetEnergyFrom(G4double energy)
+{
   if (energy > 0.) _excitation = energy;
-  return;
+}
 …
+{
   G4double theProb = 0.0;
+  if( (_excitation - e) < 0.0 || e < 0 || _excitation < 0) return theProb;
+  G4double U = std::max(0.0, _excitation - e);
+  if(e < 0.0 || _excitation < 0.0) { return theProb; }
   G4ConstantLevelDensityParameter ldPar;
+  G4double aLevelDensityParam = ldPar.LevelDensityParameter(_nucleusA,_nucleusZ,_excitation);
+  G4double levelDensBef = std::exp(2.0*std::sqrt(aLevelDensityParam*_excitation));
+  G4double levelDensAft = std::exp(2.0*std::sqrt(aLevelDensityParam*(_excitation - e)));
+  if(_verbose > 20)
+    G4cout << _nucleusA << " LevelDensityParameter = " <<  aLevelDensityParam
+           << " Bef Aft " << levelDensBef << " " << levelDensAft << G4endl;
+  G4double aLevelDensityParam =
+    ldPar.LevelDensityParameter(_nucleusA,_nucleusZ,_excitation);
+  //G4double levelDensBef = std::exp(2.0*std::sqrt(aLevelDensityParam*_excitation));
+  //G4double levelDensAft = std::exp(2.0*std::sqrt(aLevelDensityParam*(_excitation - e)));
+  G4double coeff = std::exp(2.0*(std::sqrt(aLevelDensityParam*U)
+                                 - std::sqrt(aLevelDensityParam*_excitation)));
+  //if(_verbose > 20)
+  //  G4cout << _nucleusA << " LevelDensityParameter = " <<  aLevelDensityParam
+  //       << " Bef Aft " << levelDensBef << " " << levelDensAft << G4endl;
   // Now form the probability density
 …
   G4double sigma0 = 2.5 * _nucleusA;
   G4double Egdp = (40.3 / std::pow(G4double(_nucleusA),0.2) )*MeV;
+  G4double Egdp = (40.3 /G4Pow::GetInstance()->powZ(_nucleusA,0.2) )*MeV;
   G4double GammaR = 0.30 * Egdp;
   G4double normC = 1.0 / (pi * hbarc)*(pi * hbarc);
+  const G4double normC = 1.0 / (pi * hbarc)*(pi * hbarc);
   G4double numerator = sigma0 * e*e * GammaR*GammaR;
 …
   G4double sigmaAbs = numerator/denominator ;
   if(_verbose > 20)
+  if(_verbose > 20) {
     G4cout << ".. " << Egdp << " .. " << GammaR
            << " .. " << normC << " .. " << sigmaAbs
            << " .. " << e*e << " .. " << levelDensAft/levelDensBef
+           << " .. " << e*e << " .. " << coeff
            << G4endl;
+  }
   //  theProb = normC * sigmaAbs * e*e * levelDensAft/levelDensBef;
   theProb =  sigmaAbs * e*e * levelDensAft/levelDensBef;
+  theProb =  sigmaAbs * e*e * coeff;
   return theProb;
 …
+{
   G4double GammaR = 0.30 * (40.3 / std::pow(G4double(_nucleusA),0.2) )*MeV;
+  G4double GammaR = 0.30 * (40.3 /G4Pow::GetInstance()->powZ(_nucleusA,0.2) )*MeV;
   G4double tau = hbar_Planck/GammaR;
+  G4double creationTime = -tau*std::log(G4UniformRand());
+  /*
   G4double tMin = 0;
   G4double tMax = 10.0 * tau;
 …
   G4double sampleArray[200];
   for(G4int i = 0;i<nBins;i++)
+  for(G4int i = 0; i<nBins;i++)
+  {
     G4double t = tMin + ((tMax-tMin)/nBins)*i;
 …
   G4double creationTime = tMin + (tMax - tMin) * random;
+  */
   return creationTime;
+}

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4DiscreteGammaDeexcitation.cc

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4DiscreteGammaDeexcitation.cc,v 1.15 2010/05/10 07:20:40 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4DiscreteGammaDeexcitation.cc,v 1.17 2010/11/17 19:17:17 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // -------------------------------------------------------------------
 …
+{
   G4Fragment* nucleus = GetNucleus();
   G4int A = static_cast<G4int>(nucleus->GetA());
   G4int Z = static_cast<G4int>(nucleus->GetZ());
+  G4int A = nucleus->GetA_asInt();
+  G4int Z = nucleus->GetZ_asInt();
   //  _verbose =2;
   //  G4cout << "G4DiscreteGammaDeexcitation::CreateTransition: " << nucleus << G4endl;
 …
+      }
     } else {
       if (excitation > _levelManager->MaxLevelEnergy() + _tolerance) canDo = false;
+      if (excitation > _levelManager->MaxLevelEnergy() + _tolerance) { canDo = false; }
       //if (excitation < _levelManager->MinLevelEnergy() - _tolerance) canDo = false;
       // The following is a protection to avoid looping in case of elements with very low
 …
   if (canDo) {
     const G4NuclearLevel* level = _levelManager->NearestLevel(excitation);
+    if (level != 0) {
+      if (level->HalfLife() > _max_hl && !_rdm ) canDo = false;
+    if (!level) {
+      canDo = false;
     } else {
+      canDo = false;
+    }
+    if (_verbose > 0) {
+      G4cout << "G4DiscreteGammaDeexcitation::CanDoTransition -  Halflife "
+             << level->HalfLife() << ", Calling from RDM "
+             << (_rdm ? " True " : " False ")  << ", Max-HL = " <<  _max_hl << G4endl;
+      if (level->HalfLife() > _max_hl && !_rdm ) { canDo = false; }
+      if (_verbose > 0) {
+        G4cout << "G4DiscreteGammaDeexcitation::CanDoTransition -  Halflife "
+               << level->HalfLife() << ", Calling from RDM "
+               << (_rdm ? " True " : " False ")  << ", Max-HL = " <<  _max_hl
+               << G4endl;
+      }
+    }
+  }
   if (_verbose > 0) {
     G4cout <<"G4DiscreteGammaDeexcitation::CanDoTransition - CanDo:"
+    G4cout <<"G4DiscreteGammaDeexcitation::CanDoTransition - CanDo: "
            <<  (canDo ? " True " : " False ")  << G4endl;
+  }

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4DiscreteGammaTransition.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+// $Id: G4DiscreteGammaTransition.cc,v 1.12 2010/11/17 19:17:17 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // -------------------------------------------------------------------
 …
 G4DiscreteGammaTransition::G4DiscreteGammaTransition(const G4NuclearLevel& level):
   _gammaEnergy(0.), _level(level), _excitation(0.), _gammaCreationTime(0.)
+{ }
+{
+  _levelManager = 0;
+}
 //JMQ: now A is also needed in the constructor
 …
   _level(level), _excitation(0.),  _gammaCreationTime(0.),_A(A),_Z(Z)
+{
+  _levelManager = 0;
   _verbose = 0;
   //JMQ: added tolerence in the mismatch
 …
+}
 void G4DiscreteGammaTransition::SetEnergyFrom(const G4double energy)
+void G4DiscreteGammaTransition::SetEnergyFrom(G4double energy)
+{
   _excitation = energy;

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4E1Probability.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4E1Probability.cc,v 1.9 2010/05/25 10:47:24 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4E1Probability.cc,v 1.11 2010/11/23 18:05:07 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //---------------------------------------------------------------------
 …
 // 18.05.2010 V.Ivanchenko trying to speedup the most slow method
 //            by usage of G4Pow, integer A and introduction of const members
+//
+// 17.11.2010 V.Ivanchenko perform general cleanup and simplification
+//            of integration method; low-limit of integration is defined
+//            by gamma energy or is zero (was always zero before)
 //
 #include "G4E1Probability.hh"
-//#include "G4ConstantLevelDensityParameter.hh"
 #include "Randomize.hh"
 #include "G4Pow.hh"
 …
 G4double G4E1Probability::EmissionProbDensity(const G4Fragment& frag,
                                               const G4double gammaE)
+                                              G4double gammaE)
+{
 …
   G4int Afrag = frag.GetA_asInt();
   G4double Uexcite = frag.GetExcitationEnergy();
+  G4double U = std::max(0.0,Uexcite-gammaE);
   if( (Uexcite-gammaE) < 0.0 || gammaE < 0) { return theProb; }
+  if(gammaE < 0.0) { return theProb; }
   // Need a level density parameter.
 …
   //  G4double levelDensAft = std::exp(2*std::sqrt(aLevelDensityParam*(Uexcite-gammaE)));
   // VI reduce number of calls to exp
+  G4double levelDens = 1.0;
+  if( aLevelDensityParam > 0.0 ) {
+    levelDens = std::exp(2*(std::sqrt(aLevelDensityParam*(Uexcite-gammaE))
+      - std::sqrt(aLevelDensityParam*Uexcite)));
+  }
+  G4double levelDens =
+    std::exp(2*(std::sqrt(aLevelDensityParam*U)-std::sqrt(aLevelDensityParam*Uexcite)));
   // Now form the probability density
 …
 G4double G4E1Probability::EmissionProbability(const G4Fragment& frag,
                                                  const G4double gammaE)
+                                              G4double gammaE)
+{
   // From nuclear fragment properties and the excitation energy, calculate
   // the probability for photon evaporation down to last ground level.
   // fragment = nuclear fragment BEFORE de-excitation
+  G4double theProb = 0.0;
+  G4double upperLim = gammaE;
+  G4double lowerLim = 0.0;
+  G4double Uafter = 0.0;
+  const G4double Uexcite = frag.GetExcitationEnergy();
+  G4double normC = 3.0;
+  const G4double upperLim = Uexcite;
+  const G4double lowerLim = Uafter;
+  const G4int numIters = 100;
+  // Fall-back is a uniform random number
+  //G4double uniformNum = G4UniformRand();
+  //theProb = uniformNum;
+  //G4cout << "G4E1Probability::EmissionProbability:  Emin= " << lowerLim
+  //     << " Emax= " << upperLim << G4endl;
+  if( upperLim - lowerLim <= CLHEP::keV ) { return 0.0; }
   // Need to integrate EmissionProbDensity from lowerLim to upperLim
   // and multiply by normC
+  // and multiply by factor 3 (?!)
+  G4double integ = normC *
+           EmissionIntegration(frag,gammaE,lowerLim,upperLim,numIters);
+  if(integ > 0.0) theProb = integ/(upperLim-lowerLim);
+  G4double integ = 3.0 * EmissionIntegration(frag,lowerLim,upperLim);
   return theProb;
+  return integ;
+}
 G4double G4E1Probability::EmissionIntegration(const G4Fragment& frag,
+                             const G4double ,
+                             const G4double lowLim, const G4double upLim,
+                             const G4int numIters)
+                                              G4double lowLim, G4double upLim)
+{
+  // Simple integration
+  // VI replace by direct integration over 100 point
+  // Simple Gaussian quadrature integration
+  const G4int numIters = 100;
+  G4double Step = (upLim-lowLim)/G4double(numIters);
   G4double x;
   G4double root3 = 1.0/std::sqrt(3.0);
+  G4double res = 0.0;
+  G4double x = lowLim - 0.5*Step;
+  G4double Step = (upLim-lowLim)/(2.0*numIters);
+  G4double Delta = Step*root3;
+  G4double mean = 0.0;
+  G4double theInt = 0.0;
+  for(G4int i = 0; i < numIters; i++) {
+    x = (2*i + 1)*Step;
+    G4double E1ProbDensityA = EmissionProbDensity(frag,x+Delta);
+    G4double E1ProbDensityB = EmissionProbDensity(frag,x-Delta);
+    mean += E1ProbDensityA + E1ProbDensityB;
+  for(G4int i = 0; i < numIters; ++i) {
+    x += Step;
+    res += EmissionProbDensity(frag, x);
+  }
+  if(mean*Step > 0.0) theInt = mean*Step;
+  if(res > 0.0) { res /= G4double(numIters); }
+  else { res = 0.0; }
   return theInt;
+  return res;
+}

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4E1SingleProbability1.cc

-              r819
+              r1347
 // ********************************************************************
 //
+// $Id: G4E1SingleProbability1.cc,v 1.5 2010/11/17 16:50:53 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //  Class G4E1SingleProbability1.cc
 …
 #include "G4ConstantLevelDensityParameter.hh"
 #include "Randomize.hh"
+#include "G4Pow.hh"
 // Constructors and operators
 //
+G4E1SingleProbability1::G4E1SingleProbability1(const G4E1SingleProbability1&
+                                               ) : G4VEmissionProbability()
+{
+G4E1SingleProbability1::G4E1SingleProbability1()
+{}
+  throw G4HadronicException(__FILE__, __LINE__, "G4E1SingleProbability1::copy_constructor meant to not be accessible");
+}
+const G4E1SingleProbability1& G4E1SingleProbability1::
+operator=(const G4E1SingleProbability1& )
+{
+  throw G4HadronicException(__FILE__, __LINE__, "G4E1SingleProbability1::operator= meant to not be accessible");
+  return *this;
+}
+G4bool G4E1SingleProbability1::operator==(const G4E1SingleProbability1&
+                                          ) const
+{
+  return false;
+}
+G4bool G4E1SingleProbability1::operator!=(const G4E1SingleProbability1& )
+const
+{
+  return true;
+}
+G4E1SingleProbability1::~G4E1SingleProbability1()
+{}
 // Calculate the emission probability
 …
 G4double G4E1SingleProbability1::EmissionProbDensity(const G4Fragment& frag,
                                                      const G4double exciteE)
+                                                     G4double exciteE)
+{
 …
   G4double theProb = 0.0;
   const G4double Afrag = frag.GetA();
   const G4double Zfrag = frag.GetZ();
   const G4double Uexcite = frag.GetExcitationEnergy();
+  G4int Afrag = frag.GetA_asInt();
+  G4int Zfrag = frag.GetZ_asInt();
+  G4double Uexcite = frag.GetExcitationEnergy();
   if( (Uexcite-exciteE) < 0.0 || exciteE < 0 || Uexcite <= 0) return theProb;
 …
   G4ConstantLevelDensityParameter a;
+  G4double aLevelDensityParam = a.LevelDensityParameter(static_cast<G4int>(Afrag),
+                                                        static_cast<G4int>(Zfrag),
+                                                        Uexcite);
+  G4double aLevelDensityParam = a.LevelDensityParameter(Afrag,Zfrag,Uexcite);
   G4double levelDensBef = std::exp(2.0*std::sqrt(aLevelDensityParam*Uexcite));
 …
   G4double sigma0 = 2.5 * Afrag * millibarn;  // millibarns
   G4double Egdp = (40.3 / std::pow(Afrag,0.2) )*MeV;
+  G4double Egdp = (40.3 / G4Pow::GetInstance()->powZ(Afrag,0.2) )*MeV;
   G4double GammaR = 0.30 * Egdp;
   G4double normC = 1.0 / ((pi * hbarc)*(pi * hbarc));
+  const G4double normC = 1.0 / ((pi * hbarc)*(pi * hbarc));
   // CD
 …
 G4double G4E1SingleProbability1::EmissionProbability(const G4Fragment& frag,
                                                      const G4double exciteE)
+                                                     G4double exciteE)
+{
 …
 G4double G4E1SingleProbability1::EmissionIntegration(const G4Fragment& frag,
                              const G4double ,
                              const G4double lowLim, const G4double upLim,
                              const G4int numIters)
+                                                     G4double ,
+                                                     G4double lowLim, G4double upLim,
+                                                     G4int numIters)
+{
 …
   G4double x;
   G4double root3 = 1.0/std::sqrt(3.0);
+  const G4double root3 = 1.0/std::sqrt(3.0);
   G4double Step = (upLim-lowLim)/(2.0*numIters);
 …
+}
-G4E1SingleProbability1::~G4E1SingleProbability1() {}

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4NeutronRadCapture.cc

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4NeutronRadCapture.cc,v 1.5 2010/09/09 15:40:48 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4NeutronRadCapture.cc,v 1.6 2010/11/17 16:21:32 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
 #include "G4ParticleDefinition.hh"
 #include "G4ParticleTable.hh"
+#include "G4IonTable.hh"
 #include "G4Deuteron.hh"
 #include "G4Triton.hh"
 …
     lv1 -= lv2;
+    if(Z > 2 || A > 4)
+      {
+        theDef = G4ParticleTable::GetParticleTable()->FindIon(Z,A,0,Z);
+      }
+    else if (Z == 1 && A == 2) {theDef = G4Deuteron::Deuteron();}
+    if      (Z == 1 && A == 2) {theDef = G4Deuteron::Deuteron();}
     else if (Z == 1 && A == 3) {theDef = G4Triton::Triton();}
     else if (Z == 2 && A == 3) {theDef = G4He3::He3();}
     else if (Z == 2 && A == 4) {theDef = G4Alpha::Alpha();}
+    else
+      {
+        theDef =
+          G4ParticleTable::GetParticleTable()->GetIonTable()->GetIon(Z,A,0.0);
+      }
     if (verboseLevel > 1) {
 …
         else
+          {
+            theDef = G4ParticleTable::GetParticleTable()->FindIon(Z,A,0,Z);
+            theDef =
+              G4ParticleTable::GetParticleTable()->GetIonTable()->GetIon(Z,A,0.0);
+          }

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4NuclearLevel.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+// $Id: G4NuclearLevel.cc,v 1.5 2010/10/10 23:01:39 mkelsey Exp $
+// $Id: G4NuclearLevel.cc,v 1.7 2010/11/17 16:50:53 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
+//
 // -------------------------------------------------------------------
 //      GEANT 4 class file
 …
 //              reading from experimental data.
 //
+//        28 October 2010, V.Ivanchenko moved copy constructor to source, cleanup
+//
 // -------------------------------------------------------------------
 #include "G4NuclearLevel.hh"
 #include "globals.hh"
 …
+}
 G4NuclearLevel::G4NuclearLevel(const G4double energy, const G4double halfLife,
                                const G4double angularMomentum)
+G4NuclearLevel::G4NuclearLevel(G4double energy, G4double halfLife,
+                               G4double angularMomentum)
   : _energy(energy), _halfLife(halfLife), _angularMomentum(angularMomentum),
     _nGammas(0) {
 …
+}
 G4NuclearLevel::G4NuclearLevel(const G4double energy, const G4double halfLife,
                                const G4double angularMomentum,
                                const std::vector<double>& eGamma,
                                const std::vector<double>& wGamma,
                                const std::vector<double>& polarities,
                                const std::vector<double>& kCC, const std::vector<double>& l1CC,
                                const std::vector<double>& l2CC, const std::vector<double>& l3CC,
                                const std::vector<double>& m1CC, const std::vector<double>& m2CC,
                                const std::vector<double>& m3CC, const std::vector<double>& m4CC,
                                const std::vector<double>& m5CC, const std::vector<double>& nPlusCC,
                                const std::vector<double>& totalCC)
+G4NuclearLevel::G4NuclearLevel(G4double energy, G4double halfLife,
+                               G4double angularMomentum,
+                               const std::vector<G4double>& eGamma,
+                               const std::vector<G4double>& wGamma,
+                               const std::vector<G4double>& polarities,
+                               const std::vector<G4double>& kCC, const std::vector<G4double>& l1CC,
+                               const std::vector<G4double>& l2CC, const std::vector<G4double>& l3CC,
+                               const std::vector<G4double>& m1CC, const std::vector<G4double>& m2CC,
+                               const std::vector<G4double>& m3CC, const std::vector<G4double>& m4CC,
+                               const std::vector<G4double>& m5CC, const std::vector<G4double>& nPlusCC,
+                               const std::vector<G4double>& totalCC)
   : _energies(eGamma), _weights(wGamma), _polarities(polarities),
 …
+}
 G4bool G4NuclearLevel::operator==(const G4NuclearLevel &right) const
+{
 …
   return (this != (G4NuclearLevel *) &right);
+}
 G4bool G4NuclearLevel::operator<(const G4NuclearLevel &right) const
 …
+}
+const std::vector<double>& G4NuclearLevel::GammaEnergies() const
+const std::vector<G4double>& G4NuclearLevel::GammaEnergies() const
+{
   return _energies;
+}
 const std::vector<double>& G4NuclearLevel::GammaWeights() const
+const std::vector<G4double>& G4NuclearLevel::GammaWeights() const
+{
   return _weights;
 …
 const std::vector<double>& G4NuclearLevel::GammaProbabilities() const
+const std::vector<G4double>& G4NuclearLevel::GammaProbabilities() const
+{
   return _prob;
 …
 const std::vector<double>& G4NuclearLevel::GammaCumulativeProbabilities() const
+const std::vector<G4double>& G4NuclearLevel::GammaCumulativeProbabilities() const
+{
   return _cumProb;
 …
 const std::vector<double>& G4NuclearLevel::GammaPolarities() const
+const std::vector<G4double>& G4NuclearLevel::GammaPolarities() const
+{
   return _polarities;
+}
 const std::vector<double>& G4NuclearLevel::KConvertionProbabilities() const
+const std::vector<G4double>& G4NuclearLevel::KConvertionProbabilities() const
+{
   return _kCC;
+}
 const std::vector<double>& G4NuclearLevel::L1ConvertionProbabilities() const
+const std::vector<G4double>& G4NuclearLevel::L1ConvertionProbabilities() const
+{
   return _l1CC;
+}
 const std::vector<double>& G4NuclearLevel::L2ConvertionProbabilities() const
+const std::vector<G4double>& G4NuclearLevel::L2ConvertionProbabilities() const
+{
   return _l2CC;
+}
 const std::vector<double>& G4NuclearLevel::L3ConvertionProbabilities() const
+const std::vector<G4double>& G4NuclearLevel::L3ConvertionProbabilities() const
+{
   return _l3CC;
+}
 const std::vector<double>& G4NuclearLevel::M1ConvertionProbabilities() const
+const std::vector<G4double>& G4NuclearLevel::M1ConvertionProbabilities() const
+{
   return _m1CC;
+}
 const std::vector<double>& G4NuclearLevel::M2ConvertionProbabilities() const
+const std::vector<G4double>& G4NuclearLevel::M2ConvertionProbabilities() const
+{
   return _m2CC;
+}
 const std::vector<double>& G4NuclearLevel::M3ConvertionProbabilities() const
+const std::vector<G4double>& G4NuclearLevel::M3ConvertionProbabilities() const
+{
   return _m3CC;
+}
 const std::vector<double>& G4NuclearLevel::M4ConvertionProbabilities() const
+const std::vector<G4double>& G4NuclearLevel::M4ConvertionProbabilities() const
+{
   return _m4CC;
+}
 const std::vector<double>& G4NuclearLevel::M5ConvertionProbabilities() const
+const std::vector<G4double>& G4NuclearLevel::M5ConvertionProbabilities() const
+{
   return _m5CC;
+}
 const std::vector<double>& G4NuclearLevel::NPlusConvertionProbabilities() const
+const std::vector<G4double>& G4NuclearLevel::NPlusConvertionProbabilities() const
+{
   return _nPlusCC;
+}
 const std::vector<double>& G4NuclearLevel::TotalConvertionProbabilities() const
+const std::vector<G4double>& G4NuclearLevel::TotalConvertionProbabilities() const
+{
   return _totalCC;
 …
+}
 G4int G4NuclearLevel::NumberOfGammas() const
+{
 …
+}
+const G4NuclearLevel& G4NuclearLevel::operator=(const G4NuclearLevel &right)
+{
+  if(this != &right)
+    {
+      _energies = right._energies;
+      _weights =right._weights;
+      _prob =right._prob;
+      _cumProb =right._cumProb;
+      _polarities =right._polarities;
+      _kCC = right._kCC;
+      _l1CC =right._l1CC;
+      _l2CC =right._l2CC;
+      _l3CC =right._l3CC;
+      _m1CC = right._m1CC;
+      _m2CC = right._m2CC;
+      _m3CC = right._m3CC;
+      _m4CC = right._m4CC;
+      _m5CC = right._m5CC;
+      _nPlusCC = right._nPlusCC;
+      _totalCC = right._totalCC;
+      _energy = right._energy;
+      _halfLife = right._halfLife;
+      _angularMomentum = right._angularMomentum;
+      _nGammas = right._nGammas;
+    }
+  return *this;
+}
+G4NuclearLevel::G4NuclearLevel(const G4NuclearLevel &right)
+{
+  _energies = right._energies;
+  _weights =right._weights;
+  _prob =right._prob;
+  _cumProb =right._cumProb;
+  _polarities =right._polarities;
+  _kCC = right._kCC;
+  _l1CC =right._l1CC;
+  _l2CC =right._l2CC;
+  _l3CC =right._l3CC;
+  _m1CC = right._m1CC;
+  _m2CC = right._m2CC;
+  _m3CC = right._m3CC;
+  _m4CC = right._m4CC;
+  _m5CC = right._m5CC;
+  _nPlusCC = right._nPlusCC;
+  _totalCC = right._totalCC;
+  _energy = right._energy;
+  _halfLife = right._halfLife;
+  _angularMomentum = right._angularMomentum;
+  _nGammas = right._nGammas;
+}

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4NuclearLevelManager.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+// $Id: G4NuclearLevelManager.cc,v 1.13 2010/10/10 23:01:39 mkelsey Exp $
+// $Id: G4NuclearLevelManager.cc,v 1.14 2010/11/17 16:50:53 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
+//
 // -------------------------------------------------------------------
 //      GEANT 4 class file
 …
 { }
 G4NuclearLevelManager::G4NuclearLevelManager(const G4int Z, const G4int A, const G4String& filename) :
+G4NuclearLevelManager::G4NuclearLevelManager(G4int Z, G4int A, const G4String& filename) :
     _nucleusA(A), _nucleusZ(Z), _fileName(filename), _validity(false),
     _levels(0), _levelEnergy(0), _gammaEnergy(0), _probability(0)
 …
+}
 void G4NuclearLevelManager::SetNucleus(const G4int Z, const G4int A, const G4String& filename)
+void G4NuclearLevelManager::SetNucleus(G4int Z, G4int A, const G4String& filename)
+{
   if (A <= 0 || Z <= 0 || Z > A )
 …
+}
 const G4NuclearLevel* G4NuclearLevelManager::GetLevel(int i) const {
+const G4NuclearLevel* G4NuclearLevelManager::GetLevel(G4int i) const {
   return (i>=0 && i<NumberOfLevels()) ? (*_levels)[i] : 0;
+}
 …
 const G4NuclearLevel*
+G4NuclearLevelManager::NearestLevel(const G4double energy,
+                                    const G4double eDiffMax) const {
+G4NuclearLevelManager::NearestLevel(G4double energy,
+                                    G4double eDiffMax) const
+{
   if (NumberOfLevels() <= 0) return 0;
 …
+G4bool G4NuclearLevelManager::Read(std::ifstream& dataFile) {
+G4bool G4NuclearLevelManager::Read(std::ifstream& dataFile)
+{
   G4bool goodRead = ReadDataLine(dataFile);
 …
 G4bool
+G4NuclearLevelManager::ReadDataItem(std::istream& dataFile, G4double& x) {
+G4NuclearLevelManager::ReadDataItem(std::istream& dataFile, G4double& x)
+{
   G4bool okay = (dataFile >> buffer);           // Get next token
   if (okay) x = strtod(buffer, NULL);
 …
+}
 void G4NuclearLevelManager::ProcessDataLine() {
+void G4NuclearLevelManager::ProcessDataLine()
+{
   const G4double minProbability = 1e-8;
 …
+}
 void G4NuclearLevelManager::MakeLevels()
+{
 …
 G4NuclearLevel*
+G4NuclearLevelManager::UseLevelOrMakeNew(G4NuclearLevel* level) {
+G4NuclearLevelManager::UseLevelOrMakeNew(G4NuclearLevel* level)
+{
   if (level && _levelEnergy == level->Energy()) return level;   // No change
 …
+}
+void G4NuclearLevelManager::AddDataToLevel(G4NuclearLevel* level) {
+void G4NuclearLevelManager::AddDataToLevel(G4NuclearLevel* level)
+{
   if (!level) return;           // Sanity check
 …
+}
+void G4NuclearLevelManager::FinishLevel(G4NuclearLevel* level) {
+void G4NuclearLevelManager::FinishLevel(G4NuclearLevel* level)
+{
   if (!level || !_levels) return;               // Sanity check
 …
     GetLevel(i)->PrintAll();
+}
 G4NuclearLevelManager::G4NuclearLevelManager(const G4NuclearLevelManager &right)

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4NuclearLevelStore.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+// $Id: G4NuclearLevelStore.cc,v 1.4 2010/10/07 07:50:13 mkelsey Exp $
+// $Id: G4NuclearLevelStore.cc,v 1.5 2010/11/17 16:50:53 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
+// 20101006  M. Kelsey -- Drop static data members.
+// 06-10-2010 M. Kelsey -- Drop static data members.
+// 17-11-2010 V. Ivanchenko - make as a classical singleton.
 #include "G4NuclearLevelStore.hh"
 #include <sstream>
+G4NuclearLevelStore* G4NuclearLevelStore::theInstance = 0;
 G4NuclearLevelStore* G4NuclearLevelStore::GetInstance()
+{
+  static G4NuclearLevelStore theInstance;
+  return &theInstance;
+  if(!theInstance) {
+    static G4NuclearLevelStore store;
+    theInstance = &store;
+  }
+  return theInstance;
+}
 G4NuclearLevelStore::G4NuclearLevelStore()
+{
     char* env = getenv("G4LEVELGAMMADATA");
     if (env == 0)
+  char* env = getenv("G4LEVELGAMMADATA");
+  if (env == 0)
+    {
         G4cout << "G4NuclarLevelStore: please set the G4LEVELGAMMADATA environment variable\n";
         dirName = "";
+      G4cout << "G4NuclarLevelStore: please set the G4LEVELGAMMADATA environment variable\n";
+      dirName = "";
+    }
     else
+  else
+    {
         dirName = env;
         dirName += '/';
+      dirName = env;
+      dirName += '/';
+    }
+}
 G4NuclearLevelStore::~G4NuclearLevelStore()
+{
     ManagersMap::iterator i;
     for (i = theManagers.begin(); i != theManagers.end(); ++i)
       delete i->second;
+  ManagersMap::iterator i;
+  for (i = theManagers.begin(); i != theManagers.end(); ++i)
+    delete i->second;
+}
 G4String
+G4NuclearLevelStore::GenerateFilename(const G4int Z, const G4int A) const {
+    std::ostringstream streamName;
+    streamName << 'z' << Z << ".a" << A;
+    G4String name(streamName.str());
+    return name;
+G4NuclearLevelStore::GenerateFilename(G4int Z, G4int A) const
+{
+  std::ostringstream streamName;
+  streamName << 'z' << Z << ".a" << A;
+  G4String name(streamName.str());
+  return name;
+}
 G4NuclearLevelManager*
+G4NuclearLevelStore::GetManager(const G4int Z, const G4int A) {
+    G4NuclearLevelManager * result = 0;
+    if (A < 1 || Z < 1 || A < Z)
+G4NuclearLevelStore::GetManager(G4int Z, G4int A)
+{
+  G4NuclearLevelManager * result = 0;
+  if (A < 1 || Z < 1 || A < Z)
+    {
         G4cerr << "G4NuclearLevelStore::GetManager: Wrong values Z = " << Z
 …
+    }
     // Generate the key = filename
     G4int key = GenerateKey(Z,A);
+  // Generate the key = filename
+  G4int key = GenerateKey(Z,A);
     // Check if already exists that key
     ManagersMap::iterator idx = theManagers.find(key);
     // If doesn't exists then create it
     if ( idx == theManagers.end() )
+  // Check if already exists that key
+  ManagersMap::iterator idx = theManagers.find(key);
+  // If doesn't exists then create it
+  if ( idx == theManagers.end() )
+    {
         G4String file = GenerateFilename(Z,A);
         result = new G4NuclearLevelManager(Z,A,dirName + file);
         theManagers.insert(std::make_pair(key,result));
+      G4String file = GenerateFilename(Z,A);
+      result = new G4NuclearLevelManager(Z,A,dirName + file);
+      theManagers.insert(std::make_pair(key,result));
+    }
     // But if it exists...
     else
+  // But if it exists...
+  else
+    {
         result = idx->second;
+      result = idx->second;
+    }
     return result;
+  return result;
+}

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4PhotonEvaporation.cc

r1340	r1347
24	24	// ********************************************************************
25	25	//
26		// $Id: G4PhotonEvaporation.cc,v 1.1~~3 2010/05/17 11:47:43 flei~~ Exp $
27		// GEANT4 tag $Name: geant4-09-0~~3-ref-09~~ $
	26	// $Id: G4PhotonEvaporation.cc,v 1.16 2010/11/23 18:03:21 vnivanch Exp $
	27	// GEANT4 tag $Name: geant4-09-04-ref-00 $
28	28	//
29	29	// -------------------------------------------------------------------
…	…
75	75	{
76	76	_probAlgorithm = new G4E1Probability;
77		_discrDeexcitation = new G4DiscreteGammaDeexcitation;
	77	G4DiscreteGammaDeexcitation* p = new G4DiscreteGammaDeexcitation();
	78	p->SetICM(false);
	79	_discrDeexcitation = p;
78	80	_contDeexcitation = new G4ContinuumGammaDeexcitation;
79		(dynamic_cast <G4DiscreteGammaDeexcitation*> (_discrDeexcitation))->SetICM(false);
80		}
81
	81	_nucleus = 0;
	82	}
82	83
83	84	G4PhotonEvaporation::~G4PhotonEvaporation()
…	…
87	88	delete _contDeexcitation;
88	89	}
89
90	90
91	91	void G4PhotonEvaporation::Initialize(const G4Fragment& fragment)
…	…
290	290	G4double G4PhotonEvaporation::GetEmissionProbability() const
291	291	{
292		G4double prob = 0.;
293		if (_probAlgorithm != 0) {
294		prob = _probAlgorithm->EmissionProbability(*_nucleus,_gammaE);
295		}
	292	G4double prob =
	293	_probAlgorithm->EmissionProbability(*_nucleus,_nucleus->GetExcitationEnergy());
296	294	return prob;
297	295	}
…	…
308	306
309	307	_myOwnProbAlgorithm = false;
310
311		~~return;~~
312	308	}
313	309
…	…
318	314	_contDeexcitation->SetVerboseLevel(verbose);
319	315	_discrDeexcitation->SetVerboseLevel(verbose);
320
321		~~return;~~
322	316	}
323	317
…	…
325	319	{
326	320	(dynamic_cast <G4DiscreteGammaDeexcitation*> (_discrDeexcitation))->SetICM(ic);
327		~~return;~~
328	321	}
329	322
…	…
331	324	{
332	325	(dynamic_cast <G4DiscreteGammaDeexcitation*> (_discrDeexcitation))->SetHL(hl);
333		~~return;~~
334	326	}
335	327
…	…
337	329	{
338	330	(dynamic_cast <G4DiscreteGammaDeexcitation*> (_discrDeexcitation))->SetRDM(fromRDM);
339		~~return;~~
340	331	}
341	332
…	…
343	334	{
344	335	_discrDeexcitation->SetEO(eo);
345		~~return;~~
346	336	}
347	337

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4VGammaDeexcitation.cc

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4VGammaDeexcitation.cc,v 1.18 2010/06/25 09:46:13 gunter Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4VGammaDeexcitation.cc,v 1.20 2010/11/17 19:17:17 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // -------------------------------------------------------------------
 …
 G4VGammaDeexcitation::G4VGammaDeexcitation(): _transition(0), _verbose(0),
                                               _electronO (0), _vSN(-1)
+{ }
+{
+  _nucleus = 0;
+}
 G4VGammaDeexcitation::~G4VGammaDeexcitation()
 …
   G4ParticleDefinition* gamma = G4Gamma::Gamma();
   G4DiscreteGammaTransition* dtransition = 0;
   dtransition = dynamic_cast <G4DiscreteGammaTransition*> (_transition);
+  G4DiscreteGammaTransition* dtransition =
+    dynamic_cast <G4DiscreteGammaTransition*> (_transition);
   if ( dtransition && !( dtransition->IsAGamma()) ) {
     gamma = G4Electron::Electron();

trunk/source/processes/hadronic/models/de_excitation/photon_evaporation/src/G4VPhotonEvaporation.cc

-              r1340
+              r1347
 //      Modifications:
 //
+// 17-11-2010 V.Ivanchenko moved constructor an ddestructor to the source
+//
 // -------------------------------------------------------------------
 //
 // $Id: G4VPhotonEvaporation.cc,v 1.3 2010/04/25 18:43:21 vnivanch Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4VPhotonEvaporation.cc,v 1.4 2010/11/17 16:50:53 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 #include "G4VPhotonEvaporation.hh"
+G4VPhotonEvaporation::G4VPhotonEvaporation()
+{}
+G4bool G4VPhotonEvaporation::operator==(const G4VPhotonEvaporation &right) const
+{
+    return (this == (G4VPhotonEvaporation*) &right);
+}
+G4bool G4VPhotonEvaporation::operator!=(const G4VPhotonEvaporation &right) const
+{
+    return (this != (G4VPhotonEvaporation*) &right);
+}
+G4VPhotonEvaporation::~G4VPhotonEvaporation()
+{}

trunk/source/processes/hadronic/models/de_excitation/util/include/G4AlphaCoulombBarrier.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4AlphaCoulombBarrier.hh,v 1.4 2008/09/19 13:32:54 ahoward Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4AlphaCoulombBarrier.hh,v 1.5 2010/11/15 12:44:06 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
+{
 public:
+  G4AlphaCoulombBarrier() : G4CoulombBarrier(4,2) {};
+  ~G4AlphaCoulombBarrier() {};
+  G4AlphaCoulombBarrier();
+  virtual ~G4AlphaCoulombBarrier();
 private:
 …
   G4bool operator!=(const G4AlphaCoulombBarrier & right) const;
+private:
+  virtual G4double BarrierPenetrationFactor(const G4double aZ) const;
+  virtual G4double BarrierPenetrationFactor(G4double aZ) const;
 };

trunk/source/processes/hadronic/models/de_excitation/util/include/G4ConstantLevelDensityParameter.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4ConstantLevelDensityParameter.hh,v 1.5 2009/03/04 11:05:02 gcosmo Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4ConstantLevelDensityParameter.hh,v 1.6 2010/11/15 16:09:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations (photon evaporation)
 …
+{
 public:
+  G4ConstantLevelDensityParameter() :  EvapLevelDensityParameter(0.125*(1./MeV)) {};
+  G4ConstantLevelDensityParameter();
   virtual ~G4ConstantLevelDensityParameter();
 …
 private:
   const G4double EvapLevelDensityParameter;
+  G4double EvapLevelDensityParameter;
 };

trunk/source/processes/hadronic/models/de_excitation/util/include/G4CookPairingCorrections.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4CookPairingCorrections.hh,v 1.5 2009/03/04 11:05:02 gcosmo Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4CookPairingCorrections.hh,v 1.6 2010/11/15 16:09:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
   ~G4CookPairingCorrections();
   G4double GetParingCorrection(const G4int A, const G4int Z) const {
+  G4double GetParingCorrection(G4int A, G4int Z) const {
     return GetPairingZ(Z) + GetPairingN(A-Z);
+  }
   G4double GetPairingZ(const G4int Z) const {
+  G4double GetPairingZ(G4int Z) const {
     if ( this->IsInTableThisZ(Z) ) return PairingZTable[Z-ZTableMin]*MeV;
     else {

trunk/source/processes/hadronic/models/de_excitation/util/include/G4CookShellCorrections.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4CookShellCorrections.hh,v 1.5 2009/03/04 11:05:02 gcosmo Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4CookShellCorrections.hh,v 1.6 2010/11/15 16:09:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
   ~G4CookShellCorrections();
   G4double GetShellCorrection(const G4int A, const G4int Z) const
+  G4double GetShellCorrection(G4int A, G4int Z) const
+  {
     return GetShellZ(Z) + GetShellN(A-Z);

trunk/source/processes/hadronic/models/de_excitation/util/include/G4CoulombBarrier.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4CoulombBarrier.hh,v 1.6 2009/03/04 11:05:02 gcosmo Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4CoulombBarrier.hh,v 1.8 2010/11/15 13:23:27 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Dec 1999)
+//
+// 15-11-2010 V.Ivanchenko cleanup
 #ifndef G4CoulombBarrier_h
 …
 class G4CoulombBarrier : public G4VCoulombBarrier
+{
 public:
   G4CoulombBarrier();
   G4CoulombBarrier(const G4int anA,const G4int aZ);
+  G4CoulombBarrier(G4int anA, G4int aZ);
   virtual ~G4CoulombBarrier();
+  G4double GetCoulombBarrier(G4int ARes, G4int ZRes, G4double U) const;
 private:
 …
   G4bool operator!=(const G4CoulombBarrier & right) const;
+public:
+  G4double GetCoulombBarrier(const G4int ARes, const G4int ZRes,
+                             const G4double U) const;
+  virtual G4double BarrierPenetrationFactor(G4double ) const;
+private:
+  virtual G4double BarrierPenetrationFactor(const G4double ) const {return 1.0;}
+  virtual G4double CalcCompoundRadius(const G4double ZRes) const
+  inline G4double CalcCompoundRadius(const G4double ZRes) const
+  {
     return 2.173*fermi*(1.0+0.006103*static_cast<G4double>(GetZ())*ZRes)/

trunk/source/processes/hadronic/models/de_excitation/util/include/G4DeuteronCoulombBarrier.hh

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4DeuteronCoulombBarrier.hh,v 1.5 2009/03/04 11:05:02 gcosmo Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4DeuteronCoulombBarrier.hh,v 1.6 2010/11/15 12:44:06 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
+{
 public:
+        G4DeuteronCoulombBarrier() : G4CoulombBarrier(2,1) {}
+        ~G4DeuteronCoulombBarrier() {}
+  G4DeuteronCoulombBarrier();
+  virtual ~G4DeuteronCoulombBarrier();
 private:
-        G4DeuteronCoulombBarrier(const G4DeuteronCoulombBarrier & right);
+        const G4DeuteronCoulombBarrier & operator=(const G4DeuteronCoulombBarrier & right);
+        G4bool operator==(const G4DeuteronCoulombBarrier & right) const;
+        G4bool operator!=(const G4DeuteronCoulombBarrier & right) const;
+  G4DeuteronCoulombBarrier(const G4DeuteronCoulombBarrier & right);
+  const G4DeuteronCoulombBarrier & operator=(const G4DeuteronCoulombBarrier & right);
+  G4bool operator==(const G4DeuteronCoulombBarrier & right) const;
+  G4bool operator!=(const G4DeuteronCoulombBarrier & right) const;
+private:
+        G4double BarrierPenetrationFactor(const G4double aZ) const;
+  virtual G4double BarrierPenetrationFactor(G4double aZ) const;
 };

trunk/source/processes/hadronic/models/de_excitation/util/include/G4EvaporationLevelDensityParameter.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4EvaporationLevelDensityParameter.hh,v 1.5 2009/03/04 11:05:02 gcosmo Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4EvaporationLevelDensityParameter.hh,v 1.6 2010/11/15 16:09:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 public:
+  G4double LevelDensityParameter(const G4int A,const G4int Z,const G4double U) const;
+  G4double LevelDensityParameter(G4int A, G4int Z, G4double U) const;
 private:
   G4double ShellCorrection(const G4int Z, const G4int N) const
+  inline G4double ShellCorrection(G4int Z, G4int N) const
+  {
     G4CameronTruranHilfShellCorrections* SPtr = G4CameronTruranHilfShellCorrections::GetInstance();

trunk/source/processes/hadronic/models/de_excitation/util/include/G4He3CoulombBarrier.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4He3CoulombBarrier.hh,v 1.5 2009/03/04 11:05:02 gcosmo Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4He3CoulombBarrier.hh,v 1.6 2010/11/15 12:44:06 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
+{
 public:
+        G4He3CoulombBarrier() : G4CoulombBarrier(3,2) {}
+        ~G4He3CoulombBarrier() {}
+  G4He3CoulombBarrier();
+  virtual ~G4He3CoulombBarrier();
 private:
-        G4He3CoulombBarrier(const G4He3CoulombBarrier & right);
+        const G4He3CoulombBarrier & operator=(const G4He3CoulombBarrier & right);
+        G4bool operator==(const G4He3CoulombBarrier & right) const;
+        G4bool operator!=(const G4He3CoulombBarrier & right) const;
+  G4He3CoulombBarrier(const G4He3CoulombBarrier & right);
+  const G4He3CoulombBarrier & operator=(const G4He3CoulombBarrier & right);
+  G4bool operator==(const G4He3CoulombBarrier & right) const;
+  G4bool operator!=(const G4He3CoulombBarrier & right) const;
+private:
+        G4double BarrierPenetrationFactor(const G4double aZ) const;
+  virtual G4double BarrierPenetrationFactor(G4double aZ) const;
 };

trunk/source/processes/hadronic/models/de_excitation/util/include/G4NeutronCoulombBarrier.hh

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4NeutronCoulombBarrier.hh,v 1.5 2009/03/04 11:05:02 gcosmo Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4NeutronCoulombBarrier.hh,v 1.6 2010/11/15 12:44:06 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
+{
 public:
+        G4NeutronCoulombBarrier() : G4CoulombBarrier(1,0) {}
+        ~G4NeutronCoulombBarrier() {}
+  G4NeutronCoulombBarrier();
+  virtual ~G4NeutronCoulombBarrier();
 private:
         G4NeutronCoulombBarrier(const G4NeutronCoulombBarrier & right);
+  G4NeutronCoulombBarrier(const G4NeutronCoulombBarrier & right);
         const G4NeutronCoulombBarrier & operator=(const G4NeutronCoulombBarrier & right);
         G4bool operator==(const G4NeutronCoulombBarrier & right) const;
         G4bool operator!=(const G4NeutronCoulombBarrier & right) const;
+  const G4NeutronCoulombBarrier & operator=(const G4NeutronCoulombBarrier & right);
+  G4bool operator==(const G4NeutronCoulombBarrier & right) const;
+  G4bool operator!=(const G4NeutronCoulombBarrier & right) const;
-private:
-        G4double BarrierPenetrationFactor(const G4double ) const
-        { return 1.0;}
 };

trunk/source/processes/hadronic/models/de_excitation/util/include/G4PairingCorrection.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4PairingCorrection.hh,v 1.6 2009/03/04 11:05:02 gcosmo Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4PairingCorrection.hh,v 1.8 2010/11/15 12:39:27 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 #include "G4CameronGilbertPairingCorrections.hh"
 //#include "G4CameronTruranHilfPairingCorrections.hh"
 class G4PairingCorrection
 …
   ~G4PairingCorrection();
+  G4double GetPairingCorrection(const G4int A, const G4int Z) const
+  {
+    G4double PCorrection = 0.0;
+    const G4int N = A - Z;
+    if (theCookPairingCorrections->IsInTableThisN(N) &&
+        theCookPairingCorrections->IsInTableThisZ(Z))
+      PCorrection = theCookPairingCorrections->GetParingCorrection(A,Z);
+    else if (theCameronGilbertPairingCorrections->IsInTableThisN(N) &&
+             theCameronGilbertPairingCorrections->IsInTableThisZ(Z))
+      PCorrection = theCameronGilbertPairingCorrections->GetPairingCorrection(A,Z);
+    else {
+      const G4double PairingConstant = 12.0*MeV;
+      G4double Pair = (1.0 - static_cast<G4double>(Z) + 2.0*(Z/2)) + (1.0 - static_cast<G4double>(N) + 2.0*(N/2));
+      PCorrection = Pair*PairingConstant/std::sqrt(static_cast<G4double>(A));
+    }
+    return std::max(PCorrection,0.0);
+  }
+  G4double GetPairingCorrection(G4int A, G4int Z) const;
+  G4double GetFissionPairingCorrection(const G4int A, const G4int Z) const
+  {
+    const G4double PairingConstant = 14.0*MeV;
+    const G4int N = A - Z;
+    G4double Pair = (1.0 - static_cast<G4double>(Z) + 2.0*(Z/2)) + (1.0 - static_cast<G4double>(N) + 2.0*(N/2));
+    G4double PCorrection = Pair*PairingConstant/std::sqrt(static_cast<G4double>(A));
+    return PCorrection;
+  }
+  G4double GetFissionPairingCorrection(G4int A, G4int Z) const;
 private:
 …
   G4CookPairingCorrections* theCookPairingCorrections;
 //  G4CameronTruranHilfPairingCorrections* theCameronTruranHilfPairingCorrections;
+  //  G4CameronTruranHilfPairingCorrections* theCameronTruranHilfPairingCorrections;
   G4CameronGilbertPairingCorrections* theCameronGilbertPairingCorrections;

trunk/source/processes/hadronic/models/de_excitation/util/include/G4ProtonCoulombBarrier.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4ProtonCoulombBarrier.hh,v 1.5 2009/03/04 11:05:02 gcosmo Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4ProtonCoulombBarrier.hh,v 1.6 2010/11/15 12:44:06 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
+{
 public:
+        G4ProtonCoulombBarrier() : G4CoulombBarrier(1,1) {}
+        ~G4ProtonCoulombBarrier() {}
+  G4ProtonCoulombBarrier();
+  virtual ~G4ProtonCoulombBarrier();
 private:
         G4ProtonCoulombBarrier(const G4ProtonCoulombBarrier & right);
+  G4ProtonCoulombBarrier(const G4ProtonCoulombBarrier & right);
         const G4ProtonCoulombBarrier & operator=(const G4ProtonCoulombBarrier & right);
         G4bool operator==(const G4ProtonCoulombBarrier & right) const;
         G4bool operator!=(const G4ProtonCoulombBarrier & right) const;
+  const G4ProtonCoulombBarrier & operator=(const G4ProtonCoulombBarrier & right);
+  G4bool operator==(const G4ProtonCoulombBarrier & right) const;
+  G4bool operator!=(const G4ProtonCoulombBarrier & right) const;
 private:
         G4double BarrierPenetrationFactor(const G4double aZ) const;
+  virtual G4double BarrierPenetrationFactor(G4double aZ) const;
 };

trunk/source/processes/hadronic/models/de_excitation/util/include/G4TritonCoulombBarrier.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4TritonCoulombBarrier.hh,v 1.5 2009/03/04 11:05:02 gcosmo Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4TritonCoulombBarrier.hh,v 1.6 2010/11/15 12:44:06 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
+{
 public:
+    G4TritonCoulombBarrier() : G4CoulombBarrier(3,1) {}
+    ~G4TritonCoulombBarrier() {}
+  G4TritonCoulombBarrier();
+  virtual ~G4TritonCoulombBarrier();
 private:
 …
     G4bool operator!=(const G4TritonCoulombBarrier & right) const;
+private:
+    G4double BarrierPenetrationFactor(const G4double aZ) const;
+    virtual G4double BarrierPenetrationFactor(G4double aZ) const;
 };

trunk/source/processes/hadronic/models/de_excitation/util/include/G4VEmissionProbability.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4VEmissionProbability.hh,v 1.5 2009/03/04 11:05:02 gcosmo Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4VEmissionProbability.hh,v 1.7 2010/11/15 20:30:26 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 #include "globals.hh"
 #include "G4Fragment.hh"
+#include "G4PairingCorrection.hh"
+#include "G4EvaporationLevelDensityParameter.hh"
+#include "G4Pow.hh"
 class G4VEmissionProbability
 …
   // for superimposed Coulomb Barrier for inverse cross sections
   inline void UseSICB(G4bool use) { useSICB = use; }
 protected:
+   G4int OPTxs;
+   G4bool useSICB;
+  G4int OPTxs;
+  G4bool useSICB;
+  G4Pow*   fG4pow;
+  G4PairingCorrection* fPairCorr;
+  G4EvaporationLevelDensityParameter * theEvapLDPptr;
 };

trunk/source/processes/hadronic/models/de_excitation/util/src/G4AlphaCoulombBarrier.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4AlphaCoulombBarrier.cc,v 1.5 2008/09/19 13:32:54 ahoward Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4AlphaCoulombBarrier.cc,v 1.6 2010/11/15 12:44:06 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 #include "G4HadronicException.hh"
+G4AlphaCoulombBarrier::G4AlphaCoulombBarrier(const G4AlphaCoulombBarrier & ) : G4CoulombBarrier()
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4AlphaCoulombBarrier::copy_constructor meant to not be accessable.");
+}
+G4AlphaCoulombBarrier::G4AlphaCoulombBarrier() : G4CoulombBarrier(4,2) {}
+G4AlphaCoulombBarrier::~G4AlphaCoulombBarrier() {}
+const G4AlphaCoulombBarrier & G4AlphaCoulombBarrier::operator=(const G4AlphaCoulombBarrier & )
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4AlphaCoulombBarrier::operator= meant to not be accessable.");
+    return *this;
+}
+G4bool G4AlphaCoulombBarrier::operator==(const G4AlphaCoulombBarrier & ) const
+{
+    return false;
+}
+G4bool G4AlphaCoulombBarrier::operator!=(const G4AlphaCoulombBarrier & ) const
+{
+    return true;
+}
+G4double G4AlphaCoulombBarrier::BarrierPenetrationFactor(const G4double aZ) const
+G4double G4AlphaCoulombBarrier::BarrierPenetrationFactor(G4double aZ) const
+{
     // Data comes from

trunk/source/processes/hadronic/models/de_excitation/util/src/G4CameronGilbertPairingCorrections.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4CameronGilbertPairingCorrections.cc,v 1.6 2009/11/30 10:33:33 gcosmo Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4CameronGilbertPairingCorrections.cc,v 1.7 2010/11/15 16:09:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 G4CameronGilbertPairingCorrections* G4CameronGilbertPairingCorrections::GetInstance()
+{
+  static G4CameronGilbertPairingCorrections theCorrections;
+  if (!theInstance)  { theInstance = &theCorrections; }
+  if (!theInstance)  {
+    static G4CameronGilbertPairingCorrections theCorrections;
+    theInstance = &theCorrections;
+  }
   return theInstance;
+}

trunk/source/processes/hadronic/models/de_excitation/util/src/G4CameronGilbertShellCorrections.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4CameronGilbertShellCorrections.cc,v 1.6 2009/11/30 10:33:33 gcosmo Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4CameronGilbertShellCorrections.cc,v 1.7 2010/11/15 16:09:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 G4CameronGilbertShellCorrections* G4CameronGilbertShellCorrections::GetInstance()
+{
+  static G4CameronGilbertShellCorrections theCorrections;
+  if (!theInstance)  { theInstance = &theCorrections; }
+  if (!theInstance)  {
+    static G4CameronGilbertShellCorrections theCorrections;
+    theInstance = &theCorrections;
+  }
   return theInstance;
+}

trunk/source/processes/hadronic/models/de_excitation/util/src/G4CameronShellPlusPairingCorrections.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4CameronShellPlusPairingCorrections.cc,v 1.6 2009/11/30 10:33:33 gcosmo Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4CameronShellPlusPairingCorrections.cc,v 1.7 2010/11/15 16:09:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 G4CameronShellPlusPairingCorrections* G4CameronShellPlusPairingCorrections::GetInstance()
+{
+  static G4CameronShellPlusPairingCorrections theCorrections;
+  if (!theInstance)  { theInstance = &theCorrections; }
+  if (!theInstance)  {
+    static G4CameronShellPlusPairingCorrections theCorrections;
+    theInstance = &theCorrections;
+  }
   return theInstance;
+}

trunk/source/processes/hadronic/models/de_excitation/util/src/G4CameronTruranHilfPairingCorrections.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4CameronTruranHilfPairingCorrections.cc,v 1.6 2009/11/30 10:33:33 gcosmo Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4CameronTruranHilfPairingCorrections.cc,v 1.7 2010/11/15 16:09:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 G4CameronTruranHilfPairingCorrections* G4CameronTruranHilfPairingCorrections::GetInstance()
+{
+  static G4CameronTruranHilfPairingCorrections theCorrections;
+  if (!theInstance)  { theInstance = &theCorrections; }
+  if (!theInstance)  {
+    static G4CameronTruranHilfPairingCorrections theCorrections;
+    theInstance = &theCorrections;
+  }
   return theInstance;
+}

trunk/source/processes/hadronic/models/de_excitation/util/src/G4CameronTruranHilfShellCorrections.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4CameronTruranHilfShellCorrections.cc,v 1.6 2009/11/30 10:33:33 gcosmo Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4CameronTruranHilfShellCorrections.cc,v 1.7 2010/11/15 16:09:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 G4CameronTruranHilfShellCorrections* G4CameronTruranHilfShellCorrections::GetInstance()
+{
+  static G4CameronTruranHilfShellCorrections theCorrections;
+  if (!theInstance)  { theInstance = &theCorrections; }
+  if (!theInstance)  {
+    static G4CameronTruranHilfShellCorrections theCorrections;
+    theInstance = &theCorrections;
+  }
   return theInstance;
+}

trunk/source/processes/hadronic/models/de_excitation/util/src/G4ConstantLevelDensityParameter.cc

-              r1055
+              r1347
 #include "G4HadronicException.hh"
+G4ConstantLevelDensityParameter::
+G4ConstantLevelDensityParameter(const G4ConstantLevelDensityParameter& ) :
+ G4VLevelDensityParameter(),  EvapLevelDensityParameter(0.125*(1./MeV))
+{
+  throw G4HadronicException(__FILE__, __LINE__, "G4ConstantLevelDensityParameter::copy_constructor meant to not be accessable");
+}
+G4ConstantLevelDensityParameter::G4ConstantLevelDensityParameter()
+  :  EvapLevelDensityParameter(0.125/MeV)
+{}
 G4ConstantLevelDensityParameter::~G4ConstantLevelDensityParameter()
+{
+}
+{}
-const G4ConstantLevelDensityParameter & G4ConstantLevelDensityParameter::
-operator=(const G4ConstantLevelDensityParameter &)
+{
-  throw G4HadronicException(__FILE__, __LINE__, "G4ConstantLevelDensityParameter::operator= meant to not be accessable");
-  return *this;
+}
-G4bool G4ConstantLevelDensityParameter::operator==(const G4ConstantLevelDensityParameter &) const
+{
-  return false;
+}
-G4bool G4ConstantLevelDensityParameter::operator!=(const G4ConstantLevelDensityParameter &) const
+{
-  return true;
+}

trunk/source/processes/hadronic/models/de_excitation/util/src/G4CookPairingCorrections.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4CookPairingCorrections.cc,v 1.6 2009/11/30 10:33:33 gcosmo Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4CookPairingCorrections.cc,v 1.7 2010/11/15 16:09:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 G4CookPairingCorrections* G4CookPairingCorrections::GetInstance()
+{
+  static G4CookPairingCorrections theCorrections;
+  if (!theInstance)  { theInstance = &theCorrections; }
+  if (!theInstance)  {
+    static G4CookPairingCorrections theCorrections;
+    theInstance = &theCorrections;
+  }
   return theInstance;
+}

trunk/source/processes/hadronic/models/de_excitation/util/src/G4CookShellCorrections.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4CookShellCorrections.cc,v 1.6 2009/11/30 10:33:33 gcosmo Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4CookShellCorrections.cc,v 1.7 2010/11/15 16:09:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 G4CookShellCorrections* G4CookShellCorrections::GetInstance()
+{
+  static G4CookShellCorrections theCorrections;
+  if (!theInstance)  { theInstance = &theCorrections; }
+  if (!theInstance) {
+    static G4CookShellCorrections theCorrections;
+    theInstance = &theCorrections;
+  }
   return theInstance;
+}

trunk/source/processes/hadronic/models/de_excitation/util/src/G4CoulombBarrier.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4CoulombBarrier.cc,v 1.9 2009/03/04 11:05:02 gcosmo Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4CoulombBarrier.cc,v 1.10 2010/11/15 12:44:06 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Dec 1999)
+// modified barrier by JMQ (test30) by 14-11-07
+//
+// 14-11-2007 modified barrier by JMQ (test30)
+// 15-11-2010 V.Ivanchenko use G4Pow and cleanup
 #include "G4CoulombBarrier.hh"
 #include "G4HadronicException.hh"
+#include "G4Pow.hh"
 #include <sstream>
 G4CoulombBarrier::G4CoulombBarrier()
   : G4VCoulombBarrier(1,0) {}
+G4CoulombBarrier::G4CoulombBarrier(): G4VCoulombBarrier(1,0)
+{}
+G4CoulombBarrier::G4CoulombBarrier(const G4int anA,const G4int aZ)
+  : G4VCoulombBarrier(anA,aZ) {}
+G4CoulombBarrier::G4CoulombBarrier(G4int anA, G4int aZ)
+  : G4VCoulombBarrier(anA,aZ)
+{}
+G4CoulombBarrier::~G4CoulombBarrier() {}
+G4CoulombBarrier::~G4CoulombBarrier()
+{}
 G4CoulombBarrier::G4CoulombBarrier(const G4CoulombBarrier & ) : G4VCoulombBarrier()
+G4double G4CoulombBarrier::BarrierPenetrationFactor(G4double ) const
+{
   throw G4HadronicException(__FILE__, __LINE__, "G4CoulombBarrier::copy_constructor meant to not be accessable.");
+  return 1.0;
+}
-const G4CoulombBarrier & G4CoulombBarrier::operator=(const G4CoulombBarrier & )
+{
-  throw G4HadronicException(__FILE__, __LINE__, "G4CoulombBarrier::operator= meant to not be accessable.");
-  return *this;
+}
-G4bool G4CoulombBarrier::operator==(const G4CoulombBarrier & ) const
+{
-  return false;
+}
-G4bool G4CoulombBarrier::operator!=(const G4CoulombBarrier & ) const
+{
-  return true;
+}
 G4double G4CoulombBarrier::GetCoulombBarrier(const G4int ARes, const G4int ZRes, const G4double) const
 …
   } else {
 // JMQ: old coulomb barrier commented since it does not agree with Dostrovski's prescription
 // and too low  barriers are obtained (for protons at least)
 // calculation of K penetration factor is correct
 //    G4double CompoundRadius = CalcCompoundRadius(static_cast<G4double>(ZRes));
 //    Barrier = elm_coupling/CompoundRadius * static_cast<G4double>(GetZ())*static_cast<G4double>(ZRes)/
 //      (std::pow(static_cast<G4double>(GetA()),1./3.) + std::pow(static_cast<G4double>(ARes),1./3.));
+    // JMQ: old coulomb barrier commented since it does not agree with Dostrovski's prescription
+    // and too low  barriers are obtained (for protons at least)
+    // calculation of K penetration factor is correct
+    //    G4double CompoundRadius = CalcCompoundRadius(static_cast<G4double>(ZRes));
+    //    Barrier = elm_coupling/CompoundRadius * static_cast<G4double>(GetZ())*static_cast<G4double>(ZRes)/
+    //      (std::pow(static_cast<G4double>(GetA()),1./3.) + std::pow(static_cast<G4double>(ARes),1./3.));
 ///New coulomb Barrier according to original Dostrovski's paper
    G4double rho=1.2*fermi;
    if(GetA()==1 && GetZ()==1){  rho=0.0;}
+    ///New coulomb Barrier according to original Dostrovski's paper
+    G4double rho=1.2*fermi;
+    if(GetA()==1 && GetZ()==1){  rho=0.0;}
+   G4double RN=1.5*fermi;
+Barrier=elm_coupling* static_cast<G4double>(GetZ())*static_cast<G4double>(ZRes)/(RN*std::pow(static_cast<G4double>(ARes),1./3.)+rho);
+    G4double RN=1.5*fermi;
+    // VI cleanup
+    Barrier=elm_coupling*(GetZ()*ZRes)/(RN * G4Pow::GetInstance()->Z13(ARes) + rho);
     // Barrier penetration coeficient
     G4double K = BarrierPenetrationFactor(ZRes);
     Barrier *= K;
-//
 // JMQ : the following statement has unknown origin and dimensionally is meaningless( energy divided by mass number in argument of sqrt function). Energy dependence of Coulomb barrier penetrability should be included in proper way (if needed..)
 //   Barrier /= (1.0 + std::sqrt(U/(2.0*static_cast<G4double>(ARes))));
 //
+    // JMQ : the following statement has unknown origin and dimensionally is meaningless( energy divided by mass number in argument of sqrt function). Energy dependence of Coulomb barrier penetrability should be included in proper way (if needed..)
+    //   Barrier /= (1.0 + std::sqrt(U/(2.0*static_cast<G4double>(ARes))));
+    //
+  }
   return Barrier;

trunk/source/processes/hadronic/models/de_excitation/util/src/G4DeuteronCoulombBarrier.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4DeuteronCoulombBarrier.cc,v 1.5 2008/09/19 13:32:54 ahoward Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4DeuteronCoulombBarrier.cc,v 1.6 2010/11/15 12:44:06 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 #include "G4DeuteronCoulombBarrier.hh"
+G4DeuteronCoulombBarrier::G4DeuteronCoulombBarrier(const G4DeuteronCoulombBarrier & ) : G4CoulombBarrier()
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4DeuteronCoulombBarrier::copy_constructor meant to not be accessable.");
+}
+G4DeuteronCoulombBarrier::G4DeuteronCoulombBarrier() : G4CoulombBarrier(2,1) {}
+G4DeuteronCoulombBarrier::~G4DeuteronCoulombBarrier() {}
+const G4DeuteronCoulombBarrier & G4DeuteronCoulombBarrier::operator=(const G4DeuteronCoulombBarrier & )
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4DeuteronCoulombBarrier::operator= meant to not be accessable.");
+    return *this;
+}
+G4bool G4DeuteronCoulombBarrier::operator==(const G4DeuteronCoulombBarrier & ) const
+{
+    return false;
+}
+G4bool G4DeuteronCoulombBarrier::operator!=(const G4DeuteronCoulombBarrier & ) const
+{
+    return true;
+}
+G4double G4DeuteronCoulombBarrier::BarrierPenetrationFactor(const G4double aZ) const
+G4double G4DeuteronCoulombBarrier::BarrierPenetrationFactor(G4double aZ) const
+{
     // Data comes from

trunk/source/processes/hadronic/models/de_excitation/util/src/G4EvaporationLevelDensityParameter.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4EvaporationLevelDensityParameter.cc,v 1.9 2009/03/04 11:05:02 gcosmo Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4EvaporationLevelDensityParameter.cc,v 1.10 2010/11/15 16:09:46 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 //JMQ 17-04-08 these are not used at present in G4Evaporation
 const G4double G4EvaporationLevelDensityParameter::ConstEvapLevelDensityParameter = 0.125*(1./MeV);
 //const G4double G4EvaporationLevelDensityParameter::ConstEvapLevelDensityParameter= 0.0769231*(1./MeV);
 const G4double G4EvaporationLevelDensityParameter::alpha = 0.072*(1./MeV);
 const G4double G4EvaporationLevelDensityParameter::beta = 0.257*(1./MeV);
 const G4double G4EvaporationLevelDensityParameter::gamma = 0.059*(1./MeV);
+const G4double G4EvaporationLevelDensityParameter::ConstEvapLevelDensityParameter = 0.125/MeV;
+//const G4double G4EvaporationLevelDensityParameter::ConstEvapLevelDensityParameter= 0.0769231/MeV;
+const G4double G4EvaporationLevelDensityParameter::alpha = 0.072/MeV;
+const G4double G4EvaporationLevelDensityParameter::beta = 0.257/MeV;
+const G4double G4EvaporationLevelDensityParameter::gamma = 0.059/MeV;
 const G4double G4EvaporationLevelDensityParameter::Bs = 1.0;
 …
 G4EvaporationLevelDensityParameter::~G4EvaporationLevelDensityParameter() {}
+G4EvaporationLevelDensityParameter::
+G4EvaporationLevelDensityParameter(const G4EvaporationLevelDensityParameter &) : G4VLevelDensityParameter()
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4EvaporationLevelDensityParameter::copy_constructor meant to not be accessable");
+}
+const G4EvaporationLevelDensityParameter & G4EvaporationLevelDensityParameter::
+operator=(const G4EvaporationLevelDensityParameter &)
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4EvaporationLevelDensityParameter::operator= meant to not be accessable");
+    return *this;
+}
+G4bool G4EvaporationLevelDensityParameter::operator==(const G4EvaporationLevelDensityParameter &) const
+{
+    return false;
+}
+G4bool G4EvaporationLevelDensityParameter::operator!=(const G4EvaporationLevelDensityParameter &) const
+{
+    return true;
+}
+G4double G4EvaporationLevelDensityParameter::LevelDensityParameter(const G4int A,const G4int,
+                                                                   const G4double) const
+G4double
+G4EvaporationLevelDensityParameter::LevelDensityParameter(G4int A, G4int, G4double) const
 //JMQ (Apr .08) this is the method used in G4Evaporation
+{
 //JMQ 25/04/08  a=A/10 according to original Gudima's prescription
  G4double a=static_cast<G4double>(A)/10.;
     return a;
+  //JMQ 25/04/08  a=A/10 according to original Gudima's prescription
+  G4double a=static_cast<G4double>(A)/10.;
+  return a;
 //

trunk/source/processes/hadronic/models/de_excitation/util/src/G4He3CoulombBarrier.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4He3CoulombBarrier.cc,v 1.5 2008/09/19 13:32:54 ahoward Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4He3CoulombBarrier.cc,v 1.6 2010/11/15 12:44:06 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 #include "G4He3CoulombBarrier.hh"
+G4He3CoulombBarrier::G4He3CoulombBarrier(const G4He3CoulombBarrier & ) : G4CoulombBarrier()
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4He3CoulombBarrier::copy_constructor meant to not be accessable.");
+}
+G4He3CoulombBarrier::G4He3CoulombBarrier() : G4CoulombBarrier(3,2) {}
+G4He3CoulombBarrier::~G4He3CoulombBarrier() {}
+const G4He3CoulombBarrier & G4He3CoulombBarrier::operator=(const G4He3CoulombBarrier & )
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4He3CoulombBarrier::operator= meant to not be accessable.");
+    return *this;
+}
+G4bool G4He3CoulombBarrier::operator==(const G4He3CoulombBarrier & ) const
+{
+    return false;
+}
+G4bool G4He3CoulombBarrier::operator!=(const G4He3CoulombBarrier & ) const
+{
+    return true;
+}
+G4double G4He3CoulombBarrier::BarrierPenetrationFactor(const G4double aZ) const
+G4double G4He3CoulombBarrier::BarrierPenetrationFactor(G4double aZ) const
+{
     // Data comes from

trunk/source/processes/hadronic/models/de_excitation/util/src/G4NeutronCoulombBarrier.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4NeutronCoulombBarrier.cc,v 1.5 2008/09/19 13:32:54 ahoward Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4NeutronCoulombBarrier.cc,v 1.6 2010/11/15 12:44:06 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 #include "G4NeutronCoulombBarrier.hh"
+G4NeutronCoulombBarrier::G4NeutronCoulombBarrier(const G4NeutronCoulombBarrier & ) : G4CoulombBarrier()
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4NeutronCoulombBarrier::copy_constructor meant to not be accessable.");
+}
+G4NeutronCoulombBarrier::G4NeutronCoulombBarrier() : G4CoulombBarrier(1,0) {}
+G4NeutronCoulombBarrier::~G4NeutronCoulombBarrier() {}
-const G4NeutronCoulombBarrier & G4NeutronCoulombBarrier::operator=(const G4NeutronCoulombBarrier & )
+{
-    throw G4HadronicException(__FILE__, __LINE__, "G4NeutronCoulombBarrier::operator= meant to not be accessable.");
-    return *this;
+}
-G4bool G4NeutronCoulombBarrier::operator==(const G4NeutronCoulombBarrier & ) const
+{
-    return false;
+}
-G4bool G4NeutronCoulombBarrier::operator!=(const G4NeutronCoulombBarrier & ) const
+{
-    return true;
+}

trunk/source/processes/hadronic/models/de_excitation/util/src/G4PairingCorrection.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4PairingCorrection.cc,v 1.6 2009/11/30 10:33:33 gcosmo Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4PairingCorrection.cc,v 1.8 2010/11/15 12:41:58 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 #include "G4PairingCorrection.hh"
 G4PairingCorrection* G4PairingCorrection::theInstance = 0;
 …
 G4PairingCorrection* G4PairingCorrection::GetInstance()
+{
+  static G4PairingCorrection theCorrections;
+  if (!theInstance)  { theInstance = &theCorrections; }
+  if (!theInstance)  {
+    static G4PairingCorrection theCorrections;
+    theInstance = &theCorrections;
+  }
   return theInstance;
+}
+G4double G4PairingCorrection::GetPairingCorrection(G4int A, G4int Z) const
+{
+  G4double PCorrection = 0.0;
+  G4int N = A - Z;
+  if (theCookPairingCorrections->IsInTableThisN(N) &&
+      theCookPairingCorrections->IsInTableThisZ(Z))
+    PCorrection = theCookPairingCorrections->GetParingCorrection(A,Z);
+  else if (theCameronGilbertPairingCorrections->IsInTableThisN(N) &&
+           theCameronGilbertPairingCorrections->IsInTableThisZ(Z))
+    PCorrection = theCameronGilbertPairingCorrections->GetPairingCorrection(A,Z);
+  else {
+    const G4double PairingConstant = 12.0*MeV;
+    G4double Pair = (1 - Z + 2*(Z/2)) + (1 - N + 2*(N/2));
+    PCorrection = Pair*PairingConstant/std::sqrt(static_cast<G4double>(A));
+  }
+  return std::max(PCorrection,0.0);
+}
+G4double G4PairingCorrection::GetFissionPairingCorrection(G4int A, G4int Z) const
+{
+  const G4double PairingConstant = 14.0*MeV;
+  G4int N = A - Z;
+  G4double Pair = (1 - Z + 2*(Z/2)) + (1 - N + 2*(N/2));
+  G4double PCorrection = Pair*PairingConstant/std::sqrt(static_cast<G4double>(A));
+  return PCorrection;
+}

trunk/source/processes/hadronic/models/de_excitation/util/src/G4ProtonCoulombBarrier.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4ProtonCoulombBarrier.cc,v 1.5 2008/09/19 13:32:54 ahoward Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4ProtonCoulombBarrier.cc,v 1.6 2010/11/15 12:44:06 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 #include "G4ProtonCoulombBarrier.hh"
+G4ProtonCoulombBarrier::G4ProtonCoulombBarrier(const G4ProtonCoulombBarrier & ) : G4CoulombBarrier()
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4ProtonCoulombBarrier::copy_constructor meant to not be accessable.");
+}
+G4ProtonCoulombBarrier::G4ProtonCoulombBarrier() : G4CoulombBarrier(1,1)
+{}
+G4ProtonCoulombBarrier::~G4ProtonCoulombBarrier()
+{}
+const G4ProtonCoulombBarrier & G4ProtonCoulombBarrier::operator=(const G4ProtonCoulombBarrier & )
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4ProtonCoulombBarrier::operator= meant to not be accessable.");
+    return *this;
+}
+G4bool G4ProtonCoulombBarrier::operator==(const G4ProtonCoulombBarrier & ) const
+{
+    return false;
+}
+G4bool G4ProtonCoulombBarrier::operator!=(const G4ProtonCoulombBarrier & ) const
+{
+    return true;
+}
+G4double G4ProtonCoulombBarrier::BarrierPenetrationFactor(const G4double aZ) const
+G4double G4ProtonCoulombBarrier::BarrierPenetrationFactor(G4double aZ) const
+{
     // Data comes from

trunk/source/processes/hadronic/models/de_excitation/util/src/G4ShellCorrection.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4ShellCorrection.cc,v 1.6 2009/11/30 10:33:33 gcosmo Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4ShellCorrection.cc,v 1.7 2010/11/15 11:47:18 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara
+//
 #include "G4ShellCorrection.hh"
 …
 G4ShellCorrection* G4ShellCorrection::GetInstance()
+{
+  static G4ShellCorrection theCorrections;
+  if (!theInstance)  { theInstance = &theCorrections; }
+  if (!theInstance)  {
+    static G4ShellCorrection theCorrections;
+    theInstance = &theCorrections;
+  }
   return theInstance;
+}

trunk/source/processes/hadronic/models/de_excitation/util/src/G4TritonCoulombBarrier.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4TritonCoulombBarrier.cc,v 1.5 2008/09/19 13:32:54 ahoward Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4TritonCoulombBarrier.cc,v 1.6 2010/11/15 12:44:06 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 …
 #include "G4TritonCoulombBarrier.hh"
+G4TritonCoulombBarrier::G4TritonCoulombBarrier(const G4TritonCoulombBarrier & ) : G4CoulombBarrier()
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4TritonCoulombBarrier::copy_constructor meant to not be accessable.");
+}
+G4TritonCoulombBarrier::G4TritonCoulombBarrier() : G4CoulombBarrier(3,1) {}
+G4TritonCoulombBarrier::~G4TritonCoulombBarrier() {}
+const G4TritonCoulombBarrier & G4TritonCoulombBarrier::operator=(const G4TritonCoulombBarrier & )
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4TritonCoulombBarrier::operator= meant to not be accessable.");
+    return *this;
+}
+G4bool G4TritonCoulombBarrier::operator==(const G4TritonCoulombBarrier & ) const
+{
+    return false;
+}
+G4bool G4TritonCoulombBarrier::operator!=(const G4TritonCoulombBarrier & ) const
+{
+    return true;
+}
+G4double G4TritonCoulombBarrier::BarrierPenetrationFactor(const G4double aZ) const
+G4double G4TritonCoulombBarrier::BarrierPenetrationFactor(G4double aZ) const
+{
     // Data comes from

trunk/source/processes/hadronic/models/de_excitation/util/src/G4VEmissionProbability.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4VEmissionProbability.cc,v 1.7 2009/03/04 11:05:02 gcosmo Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4VEmissionProbability.cc,v 1.10 2010/11/15 20:30:26 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 // Hadronic Process: Nuclear De-excitations
 // by V. Lara (Oct 1998)
 //
+// Modifications:
+// 28.10.2010 V.Ivanchenko defined members in constructor and cleaned up
 #include "G4VEmissionProbability.hh"
-#include "G4HadronicException.hh"
+G4VEmissionProbability::G4VEmissionProbability() {}
+G4VEmissionProbability::~G4VEmissionProbability() {}
+G4VEmissionProbability::G4VEmissionProbability(const G4VEmissionProbability &)
+G4VEmissionProbability::G4VEmissionProbability():OPTxs(3),useSICB(false)
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4VEmissionProbability::copy_constructor meant to not be accessable");
+  fG4pow = G4Pow::GetInstance();
+  fPairCorr = G4PairingCorrection::GetInstance();
+  theEvapLDPptr = new G4EvaporationLevelDensityParameter;
+}
+const G4VEmissionProbability & G4VEmissionProbability::operator=(const G4VEmissionProbability &)
+G4VEmissionProbability::~G4VEmissionProbability()
+{
+    throw G4HadronicException(__FILE__, __LINE__, "G4VEmissionProbability::operator= meant to not be accessable");
+    return *this;
+  delete theEvapLDPptr;
+}
-G4bool G4VEmissionProbability::operator==(const G4VEmissionProbability &) const
+{
-    return false;
+}
-G4bool G4VEmissionProbability::operator!=(const G4VEmissionProbability &) const
+{
-    return true;
+}

trunk/source/processes/hadronic/models/high_energy/History

-              r1315
+              r1347
   * Please list in reverse chronological order (last date on top)
   ---------------------------------------------------------------
+Dec 2010 - Dennis Wright (hadr-hep-V09-03-03)
+------------------------------------------------
+- more CoVerity bug fixes in G4HEInelastic.cc :
+  array overrun in method QuasiElasticScattering (change pvmx[4] to
+    pvmx[0]
+  dead code due to bools dummy and dum always being false
+  memory leak in methods HighEnergyCascading, MediumEnergyCascading,
+    QuasiElasticScattering
+  use of loop variable outside of for loop
+Nov 2010 - Dennis Wright (hadr-hep-V09-03-02)
+------------------------------------------------
+- more CoVerity bug fixes:  G4HEInelastic.hh (init verboseLevel),
+- make incidentParticle and targetParticle args const &
+Nov 2010 - Dennis Wright (hadr-hep-V09-03-01)
+------------------------------------------------
+- Fix uninitialized variable (vecLength = 0) in header files of
+    G4HEAntiLambdaInelastic, G4HEAntiNeutronInelastic
+    G4HEAntiOmegaMinusInelastic, G4HEAntiProtonInelastic
+    G4HEAntiSigmaMinusInelastic, G4HEAntiSigmaPlusInelastic
+    G4HEAntiXiMinusInelastic, G4HEAntiXiZeroInelastic
+    G4HEKaonMinusInelastic, G4HEKaonPlusInelastic
+    G4HEKaonZeroInelastic, G4HELambdaInelastic
+    G4HENeutronInelastic,  G4HEOmegaMinusInelastic
+    G4HEPionMinusInelastic,  G4HEPionPlusInelastic
+    G4HEProtonInelastic,  G4HESigmaMinusInelastic
+    G4HESigmaPlusInelastic,  G4HEXiMinusInelastic
+    G4HEXiZeroInelastic
+  and remove dead code in .cc files of above
+- Fix uninitialized variable (MAXPART = 0) in header file of
+    G4HEInelastic
+- Initialize theQuarkContent and theAntiQuarkContent
+    in G4HEVector.hh
 Jan 2010 - Dennis Wright (hadr-hep-V09-03-00)

trunk/source/processes/hadronic/models/high_energy/include/G4HEAntiKaonZeroInelastic.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HEAntiKaonZeroInelastic.hh,v 1.14 2007/04/11 18:11:30 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEAntiKaonZeroInelastic.hh,v 1.15 2010/11/27 02:02:19 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HEAntiKaonZeroInelastic() : G4HEInelastic("G4HEAntiKaonZeroInelastic")
+   {
      theMinEnergy =  20*GeV;
+     theMinEnergy = 20*GeV;
      theMaxEnergy = 10*TeV;
      MAXPART      = 2048;
 …
    G4int vecLength;
+   G4HadFinalState * ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus );
+   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                  G4Nucleus& targetNucleus);
    G4int  GetNumberOfSecondaries()
+   G4int GetNumberOfSecondaries()
       { return vecLength; }
+   void   FirstIntInCasAntiKaonZero(G4bool &inElastic, const G4double availableEnergy,
+                                    G4HEVector pv[],
+                                    G4int &vecLen,
+                                    G4HEVector incidentParticle,
+                                    G4HEVector targetParticle);
+   void FirstIntInCasAntiKaonZero(G4bool& inElastic,
+                                  const G4double availableEnergy,
+                                  G4HEVector pv[],
+                                  G4int& vecLen,
+                                  const G4HEVector& incidentParticle,
+                                  const G4HEVector& targetParticle);
 };
 #endif

trunk/source/processes/hadronic/models/high_energy/include/G4HEAntiLambdaInelastic.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HEAntiLambdaInelastic.hh,v 1.14 2007/04/11 18:11:30 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEAntiLambdaInelastic.hh,v 1.16 2010/11/27 02:02:59 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HEAntiLambdaInelastic() : G4HEInelastic("G4HEAntiLambdaInelastic")
+   {
+     vecLength = 0;
      theMinEnergy =  20*GeV;
      theMaxEnergy = 10*TeV;
 …
    G4int vecLength;
+   G4HadFinalState * ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus );
+   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                  G4Nucleus& targetNucleus);
+   G4int  GetNumberOfSecondaries()
+        { return vecLength; }
+   G4int GetNumberOfSecondaries() {return vecLength;}
+   void   FirstIntInCasAntiLambda(G4bool &inElastic, const G4double availableEnergy,
+                                  G4HEVector pv[],
+                                  G4int &vecLen,
+                                  G4HEVector incidentParticle,
+                                  G4HEVector targetParticle,
+                                  const G4double atomicWeight);
+   void FirstIntInCasAntiLambda(G4bool& inElastic,
+                                const G4double availableEnergy,
+                                G4HEVector pv[],
+                                G4int& vecLen,
+                                const G4HEVector& incidentParticle,
+                                const G4HEVector& targetParticle,
+                                const G4double atomicWeight);
 };
 #endif

trunk/source/processes/hadronic/models/high_energy/include/G4HEAntiNeutronInelastic.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HEAntiNeutronInelastic.hh,v 1.14 2007/04/11 18:11:30 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEAntiNeutronInelastic.hh,v 1.16 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HEAntiNeutronInelastic() : G4HEInelastic("G4HEAntiNeutronInelastic")
+   {
+     vecLength = 0;
      theMinEnergy =  20*GeV;
      theMaxEnergy = 10*TeV;
 …
    G4int vecLength;
+   G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus);
+   G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack,
+                                  G4Nucleus &targetNucleus);
+   G4int GetNumberOfSecondaries()
+        { return vecLength; }
+   G4int GetNumberOfSecondaries() {return vecLength;}
+   void FirstIntInCasAntiNeutron(G4bool &inElastic, const G4double availableEnergy,
+   void FirstIntInCasAntiNeutron(G4bool &inElastic,
+                                 const G4double availableEnergy,
                                  G4HEVector pv[],
                                  G4int &vecLen,
                                  G4HEVector incidentParticle,
                                  G4HEVector targetParticle,
+                                 const G4HEVector& incidentParticle,
+                                 const G4HEVector& targetParticle,
                                  const G4double atomicWeight);
 };

trunk/source/processes/hadronic/models/high_energy/include/G4HEAntiOmegaMinusInelastic.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HEAntiOmegaMinusInelastic.hh,v 1.14 2007/04/11 18:11:30 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEAntiOmegaMinusInelastic.hh,v 1.16 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HEAntiOmegaMinusInelastic() : G4HEInelastic("G4HEAntiOmegaMinusInelastic")
+   {
+     vecLength = 0;
      theMinEnergy =  20*GeV;
      theMaxEnergy = 10*TeV;
 …
    G4int vecLength;
+   G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus);
+   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                  G4Nucleus& targetNucleus);
+   G4int GetNumberOfSecondaries()
+       { return vecLength; }
+   G4int GetNumberOfSecondaries() {return vecLength;}
+   void FirstIntInCasAntiOmegaMinus(G4bool &inElastic, const G4double availableEnergy,
+   void FirstIntInCasAntiOmegaMinus(G4bool& inElastic,
+                                    const G4double availableEnergy,
                                     G4HEVector pv[],
                                     G4int &vecLen,
                                     G4HEVector incidentParticle,
                                     G4HEVector targetParticle,
+                                    G4int& vecLen,
+                                    const G4HEVector& incidentParticle,
+                                    const G4HEVector& targetParticle,
                                     const G4double atomicWeight);
 };
+#endif
+#endif

trunk/source/processes/hadronic/models/high_energy/include/G4HEAntiProtonInelastic.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HEAntiProtonInelastic.hh,v 1.15 2007/04/11 18:11:30 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEAntiProtonInelastic.hh,v 1.17 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HEAntiProtonInelastic() : G4HEInelastic("G4HEAntiProtonInelastic")
+   {
+     vecLength = 0;
      theMinEnergy =  20*GeV;
      theMaxEnergy = 10*TeV;
 …
    G4int vecLength;
+   G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus);
+   G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack,
+                                  G4Nucleus &targetNucleus);
+   G4int GetNumberOfSecondaries()
+      { return vecLength; }
+   G4int GetNumberOfSecondaries() {return vecLength;}
+   void FirstIntInCasAntiProton(G4bool &inElastic, const G4double availableEnergy,
+   void FirstIntInCasAntiProton(G4bool& inElastic,
+                                const G4double availableEnergy,
                                 G4HEVector pv[],
                                 G4int &vecLen,
                                 G4HEVector incidentParticle,
                                 G4HEVector targetParticle,
+                                G4int& vecLen,
+                                const G4HEVector& incidentParticle,
+                                const G4HEVector& targetParticle,
                                 const G4double atomicWeight);
 };
+#endif
+#endif

trunk/source/processes/hadronic/models/high_energy/include/G4HEAntiSigmaMinusInelastic.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HEAntiSigmaMinusInelastic.hh,v 1.14 2007/04/11 18:11:30 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEAntiSigmaMinusInelastic.hh,v 1.16 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HEAntiSigmaMinusInelastic() : G4HEInelastic("G4HEAntiSigmaMinusInelastic")
+   {
+     vecLength = 0;
      theMinEnergy =  20*GeV;
      theMaxEnergy = 10*TeV;
 …
    G4int vecLength;
+   G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus);
+   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                  G4Nucleus& targetNucleus);
+   G4int GetNumberOfSecondaries()
+      { return vecLength; }
+   G4int GetNumberOfSecondaries() {return vecLength;}
+   void FirstIntInCasAntiSigmaMinus(G4bool &inElastic, const G4double availableEnergy,
+   void FirstIntInCasAntiSigmaMinus(G4bool& inElastic,
+                                    const G4double availableEnergy,
                                     G4HEVector pv[],
                                     G4int &vecLen,
                                     G4HEVector incidentParticle,
                                     G4HEVector targetParticle,
+                                    G4int& vecLen,
+                                    const G4HEVector& incidentParticle,
+                                    const G4HEVector& targetParticle,
                                     const G4double atomicWeight);
 };
+#endif
+#endif

trunk/source/processes/hadronic/models/high_energy/include/G4HEAntiSigmaPlusInelastic.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HEAntiSigmaPlusInelastic.hh,v 1.14 2007/04/11 18:11:30 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEAntiSigmaPlusInelastic.hh,v 1.16 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HEAntiSigmaPlusInelastic() : G4HEInelastic("G4HEAntiSigmaPlusInelastic")
+   {
+     theMinEnergy =  20*GeV;
+     vecLength = 0;
+     theMinEnergy = 20*GeV;
      theMaxEnergy = 10*TeV;
      MAXPART      = 2048;
 …
    G4int vecLength;
+   G4HadFinalState* ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus );
+   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                  G4Nucleus& targetNucleus);
+   G4int GetNumberOfSecondaries()
+       { return vecLength; }
+   G4int GetNumberOfSecondaries() {return vecLength;}
+   void FirstIntInCasAntiSigmaPlus(G4bool &inElastic, const G4double availableEnergy,
+   void FirstIntInCasAntiSigmaPlus(G4bool& inElastic,
+                                   const G4double availableEnergy,
                                    G4HEVector pv[],
                                    G4int &vecLen,
                                    G4HEVector incidentParticle,
                                    G4HEVector targetParticle,
+                                   G4int& vecLen,
+                                   const G4HEVector& incidentParticle,
+                                   const G4HEVector& targetParticle,
                                    const G4double atomicWeight);
 };
+#endif
+#endif

trunk/source/processes/hadronic/models/high_energy/include/G4HEAntiSigmaZeroInelastic.hh

r1340	r1347
26	26	//
27	27	// $Id: G4HEAntiSigmaZeroInelastic.hh,v 1.14 2007/04/11 18:11:30 dennis Exp $
28		// GEANT4 tag $Name: geant4-09-0~~3-ref-09~~ $
	28	// GEANT4 tag $Name: geant4-09-04-ref-00 $
29	29	//
30	30	//

trunk/source/processes/hadronic/models/high_energy/include/G4HEAntiXiMinusInelastic.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HEAntiXiMinusInelastic.hh,v 1.14 2007/04/11 18:11:30 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEAntiXiMinusInelastic.hh,v 1.16 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HEAntiXiMinusInelastic() : G4HEInelastic("G4HEAntiXiMinusInelastic")
+   {
+     theMinEnergy =  20*GeV;
+     vecLength = 0;
+     theMinEnergy = 20*GeV;
      theMaxEnergy = 10*TeV;
      MAXPART      = 2048;
 …
    G4int vecLength;
+   G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus);
+   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                  G4Nucleus& targetNucleus);
+   G4int GetNumberOfSecondaries()
+        { return vecLength; }
+   G4int GetNumberOfSecondaries() {return vecLength;}
+   void FirstIntInCasAntiXiMinus(G4bool &inElastic, const G4double availableEnergy,
+   void FirstIntInCasAntiXiMinus(G4bool& inElastic,
+                                 const G4double availableEnergy,
                                  G4HEVector pv[],
                                  G4int &vecLen,
                                  G4HEVector incidentParticle,
                                  G4HEVector targetParticle,
+                                 G4int& vecLen,
+                                 const G4HEVector& incidentParticle,
+                                 const G4HEVector& targetParticle,
                                  const G4double atomicWeight);
 };
+#endif
+#endif

trunk/source/processes/hadronic/models/high_energy/include/G4HEAntiXiZeroInelastic.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HEAntiXiZeroInelastic.hh,v 1.14 2007/04/11 18:11:30 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEAntiXiZeroInelastic.hh,v 1.16 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HEAntiXiZeroInelastic() : G4HEInelastic("G4HEAntiXiZeroInelastic")
+   {
+     theMinEnergy =  20*GeV;
+     vecLength = 0;
+     theMinEnergy = 20*GeV;
      theMaxEnergy = 10*TeV;
      MAXPART      = 2048;
 …
    G4int vecLength;
+   G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus);
+   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                  G4Nucleus& targetNucleus);
+   G4int GetNumberOfSecondaries()
+       { return vecLength; }
+   G4int GetNumberOfSecondaries() {return vecLength;}
+   void FirstIntInCasAntiXiZero(G4bool &inElastic, const G4double availableEnergy,
+   void FirstIntInCasAntiXiZero(G4bool& inElastic,
+                                const G4double availableEnergy,
                                 G4HEVector pv[],
                                 G4int &vecLen,
                                 G4HEVector incidentParticle,
                                 G4HEVector targetParticle,
+                                G4int& vecLen,
+                                const G4HEVector& incidentParticle,
+                                const G4HEVector& targetParticle,
                                 const G4double atomicWeight);
 };
+#endif
+#endif

trunk/source/processes/hadronic/models/high_energy/include/G4HEInelastic.hh

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HEInelastic.hh,v 1.14 2007/04/11 18:11:30 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEInelastic.hh,v 1.17 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
+   {
      SetParticles();
+     verboseLevel = 0;
+     MAXPART = 0;
      conserveEnergy = true;
    };
 …
    ~G4HEInelastic(){ };
    void       SetMaxNumberOfSecondaries( const G4int maxnumber )
                    { MAXPART = maxnumber;}
+   void SetMaxNumberOfSecondaries(const G4int maxnumber)
+            {MAXPART = maxnumber;}
+   void       SetVerboseLevel( const G4int level)
+                   { verboseLevel = level;}
+   G4int      verboseLevel;
+   G4int      MAXPART;
+   G4bool     conserveEnergy;
+   void       ForceEnergyConservation(G4bool energyConservation)
+                   { conserveEnergy = energyConservation;}
+   G4bool     EnergyConservation(void)
+                   { return conserveEnergy;}
+   G4double   Amin(G4double a, G4double b);
+   G4double   Amax(G4double a, G4double b);
+   G4int      Imin(G4int a, G4int b);
+   G4int      Imax(G4int a, G4int b);
+   void SetVerboseLevel(const G4int level) {verboseLevel = level;}
+   G4int verboseLevel;
+   G4int MAXPART;
+   G4bool conserveEnergy;
+   void ForceEnergyConservation(G4bool energyConservation)
+              {conserveEnergy = energyConservation;}
+   G4bool EnergyConservation(void) {return conserveEnergy;}
+   G4double Amin(G4double a, G4double b);
+   G4double Amax(G4double a, G4double b);
+   G4int Imin(G4int a, G4int b);
+   G4int Imax(G4int a, G4int b);
+   void       FillParticleChange(G4HEVector pv[], G4int aVecLength);
+   G4double   pmltpc(G4int np, G4int nm, G4int nz, G4int n, G4double b, G4double c);
+   G4int      Factorial(G4int n);
+   G4double   NuclearInelasticity(G4double incidentKineticEnergy,
+                                  G4double atomicWeight,
+                                  G4double atomicNumber);
+   G4double   NuclearExcitation(G4double  incidentKineticEnergy,
+                                G4double  atomicWeight,
+                                G4double  atomicNumber,
+                                G4double& excitationEnergyCascade,
+                                G4double& excitationEnergyEvaporation);
+   void FillParticleChange(G4HEVector pv[], G4int aVecLength);
+   G4double pmltpc(G4int np, G4int nm, G4int nz,
+                   G4int n, G4double b, G4double c);
+   G4int Factorial(G4int n);
+   G4double NuclearInelasticity(G4double incidentKineticEnergy,
+                                G4double atomicWeight,
+                                G4double atomicNumber);
+   G4double NuclearExcitation(G4double  incidentKineticEnergy,
+                              G4double  atomicWeight,
+                              G4double  atomicNumber,
+                              G4double& excitationEnergyCascade,
+                              G4double& excitationEnergyEvaporation);
+   void       HighEnergyCascading(G4bool &successful,
+                                  G4HEVector pv[],
+                                  G4int &vecLen,
+                                  G4double &excitationEnergyGNP,
+                                  G4double &excitationEnergyDTA,
+                                  G4HEVector incidentParticle,
+                                  G4HEVector targetParticle,
+                                  G4double atomicWeight,
+                                  G4double atomicNumber);
+   void       HighEnergyClusterProduction(G4bool &successful,
+                                          G4HEVector pv[],
+                                          G4int &vecLen,
+                                          G4double &excitationEnergyGNP,
+                                          G4double &excitationEnergyDTA,
+                                          G4HEVector incidentParticle,
+                                          G4HEVector targetParticle,
+                                          G4double atomicWeight,
+                                          G4double atomicNumber);
+   void       TuningOfHighEnergyCascading(G4HEVector pv[],
+                                          G4int &vecLen,
+                                          G4HEVector incidentParticle,
+                                          G4HEVector targetParticle,
+                                          G4double atomicWeight,
+                                          G4double atomicNumber);
+   void       MediumEnergyCascading(G4bool &successful,
+   void HighEnergyCascading(G4bool& successful,
+                            G4HEVector pv[],
+                            G4int& vecLen,
+                            G4double& excitationEnergyGNP,
+                            G4double& excitationEnergyDTA,
+                            const G4HEVector& incidentParticle,
+                            const G4HEVector& targetParticle,
+                            G4double atomicWeight,
+                            G4double atomicNumber);
+   void HighEnergyClusterProduction(G4bool& successful,
                                     G4HEVector pv[],
                                     G4int &vecLen,
                                     G4double &excitationEnergyGNP,
                                     G4double &excitationEnergyDTA,
                                     G4HEVector incidentParticle,
                                     G4HEVector targetParticle,
+                                    G4int& vecLen,
+                                    G4double& excitationEnergyGNP,
+                                    G4double& excitationEnergyDTA,
+                                    const G4HEVector& incidentParticle,
+                                    const G4HEVector& targetParticle,
                                     G4double atomicWeight,
+                                    G4double atomicNumber);
+   void       MediumEnergyClusterProduction(G4bool &successful,
+                                            G4HEVector pv[],
+                                            G4int &vecLen,
+                                            G4double &excitationEnergyGNP,
+                                            G4double &excitationEnergyDTA,
+                                            G4HEVector incidentParticle,
+                                            G4HEVector targetParticle,
+                                            G4double atomicWeight,
+                                            G4double atomicNumber);
+   void       QuasiElasticScattering(G4bool &successful,
+                                     G4HEVector pv[],
+                                     G4int &vecLen,
+                                     G4double &excitationEnergyGNP,
+                                     G4double &excitationEnergyDTA,
+                                     G4HEVector incidentParticle,
+                                     G4HEVector targetParticle,
+                                     G4double atomicWeight,
+                                     G4double atomicNumber);
+   void       ElasticScattering(G4bool &successful,
+                                G4HEVector pv[],
+                                G4int &vecLen,
+                                G4HEVector incidentParticle,
+                                G4double atomicWeight,
+                                G4double atomicNumber);
+   G4int      rtmi(G4double *x, G4double xli, G4double xri, G4double eps,
+                   G4int iend, G4double aa, G4double bb, G4double cc,
+                   G4double dd, G4double rr);
+   G4double   fctcos(G4double t, G4double aa, G4double bb,G4double cc,
+                     G4double dd, G4double rr);
+                                    G4double atomicNumber);
+   void TuningOfHighEnergyCascading(G4HEVector pv[],
+                                    G4int& vecLen,
+                                    const G4HEVector& incidentParticle,
+                                    const G4HEVector& targetParticle,
+                                    G4double atomicWeight,
+                                    G4double atomicNumber);
+   void MediumEnergyCascading(G4bool& successful,
+                              G4HEVector pv[],
+                              G4int& vecLen,
+                              G4double& excitationEnergyGNP,
+                              G4double& excitationEnergyDTA,
+                              const G4HEVector& incidentParticle,
+                              const G4HEVector& targetParticle,
+                              G4double atomicWeight,
+                              G4double atomicNumber);
+   void MediumEnergyClusterProduction(G4bool& successful,
+                                      G4HEVector pv[],
+                                      G4int& vecLen,
+                                      G4double& excitationEnergyGNP,
+                                      G4double& excitationEnergyDTA,
+                                      const G4HEVector& incidentParticle,
+                                      const G4HEVector& targetParticle,
+                                      G4double atomicWeight,
+                                      G4double atomicNumber);
+   void QuasiElasticScattering(G4bool& successful,
+                               G4HEVector pv[],
+                               G4int& vecLen,
+                               G4double& excitationEnergyGNP,
+                               G4double& excitationEnergyDTA,
+                               const G4HEVector& incidentParticle,
+                               const G4HEVector& targetParticle,
+                               G4double atomicWeight,
+                               G4double atomicNumber);
+   void ElasticScattering(G4bool& successful,
+                          G4HEVector pv[],
+                          G4int& vecLen,
+                          const G4HEVector& incidentParticle,
+                          G4double atomicWeight,
+                          G4double atomicNumber);
+   G4int rtmi(G4double *x, G4double xli, G4double xri, G4double eps,
+              G4int iend, G4double aa, G4double bb, G4double cc,
+              G4double dd, G4double rr);
+   G4double fctcos(G4double t, G4double aa, G4double bb,G4double cc,
+                   G4double dd, G4double rr);
    void       StrangeParticlePairProduction(const G4double availableEnergy,
                                             const G4double centerOfMassEnergy,
                                             G4HEVector pv[],
                                             G4int &vecLen,
                                             G4HEVector incidentParticle,
                                             G4HEVector targetParticle);
    G4double   NBodyPhaseSpace(const G4double totalEnergy,
                               const G4bool   constantCrossSection,
                               G4HEVector pv[],
                               G4int &vecLen);
+   void StrangeParticlePairProduction(const G4double availableEnergy,
+                                      const G4double centerOfMassEnergy,
+                                      G4HEVector pv[],
+                                      G4int& vecLen,
+                                      const G4HEVector& incidentParticle,
+                                      const G4HEVector& targetParticle);
+   G4double NBodyPhaseSpace(const G4double totalEnergy,
+                            const G4bool   constantCrossSection,
+                            G4HEVector pv[],
+                            G4int &vecLen);
    G4double   NBodyPhaseSpace(G4int npart,
                               G4HEVector pv[],
                               G4double wmax,
                               G4double wfcn,
                               G4int maxtrial,
                               G4int ntrial);
    G4double   gpdk(G4double a, G4double b, G4double c);
    void       QuickSort(G4double arr[], const G4int lidx, const G4int ridx);
    G4double   Alam(G4double a, G4double b, G4double c);
+   G4double NBodyPhaseSpace(G4int npart,
+                            G4HEVector pv[],
+                            G4double wmax,
+                            G4double wfcn,
+                            G4int maxtrial,
+                            G4int ntrial);
+   G4double gpdk(G4double a, G4double b, G4double c);
+   void QuickSort(G4double arr[], const G4int lidx, const G4int ridx);
+   G4double Alam(G4double a, G4double b, G4double c);
    G4double   CalculatePhaseSpaceWeight( G4int npart);
+   G4double CalculatePhaseSpaceWeight( G4int npart);
    G4double   normal(void);
    G4double   GammaRand(G4double avalue);
    G4double   Erlang(G4int mvalue);
    G4int      Poisson(G4double x);
    void       SetParticles(void);
+   G4double normal(void);
+   G4double GammaRand(G4double avalue);
+   G4double Erlang(G4int mvalue);
+   G4int Poisson(G4double x);
+   void SetParticles(void);
    G4HEVector PionPlus;
 …
 };
+#endif
+#endif

trunk/source/processes/hadronic/models/high_energy/include/G4HEKaonMinusInelastic.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HEKaonMinusInelastic.hh,v 1.14 2007/04/11 18:11:30 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEKaonMinusInelastic.hh,v 1.16 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HEKaonMinusInelastic() : G4HEInelastic("G4HEKaonMinusInelastic")
+   {
+     theMinEnergy =  20*GeV;
+     vecLength = 0;
+     theMinEnergy = 20*GeV;
      theMaxEnergy = 10*TeV;
      MAXPART      = 2048;
 …
    G4int vecLength;
+   G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus);
+   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                  G4Nucleus& targetNucleus);
+   G4int GetNumberOfSecondaries()
+       { return vecLength; }
+   G4int GetNumberOfSecondaries() {return vecLength;}
+   void FirstIntInCasKaonMinus(G4bool &inElastic, const G4double availableEnergy,
+   void FirstIntInCasKaonMinus(G4bool& inElastic,
+                               const G4double availableEnergy,
                                G4HEVector pv[],
                                G4int &vecLen,
                                G4HEVector incidentParticle,
                                G4HEVector targetParticle);
+                               G4int& vecLen,
+                               const G4HEVector& incidentParticle,
+                               const G4HEVector& targetParticle);
 };
+#endif
+#endif

trunk/source/processes/hadronic/models/high_energy/include/G4HEKaonPlusInelastic.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HEKaonPlusInelastic.hh,v 1.14 2007/04/11 18:11:30 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEKaonPlusInelastic.hh,v 1.16 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HEKaonPlusInelastic() : G4HEInelastic("G4HEKaonPlusInelastic")
+   {
+     theMinEnergy =  20*GeV;
+     vecLength = 0;
+     theMinEnergy = 20*GeV;
      theMaxEnergy = 10*TeV;
      MAXPART      = 2048;
 …
    G4int vecLength;
+   G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus);
+   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                  G4Nucleus& targetNucleus);
+   G4int GetNumberOfSecondaries()
+       { return vecLength; }
+   G4int GetNumberOfSecondaries() {return vecLength;}
+   void FirstIntInCasKaonPlus(G4bool &inElastic, const G4double availableEnergy,
+   void FirstIntInCasKaonPlus(G4bool& inElastic,
+                              const G4double availableEnergy,
                               G4HEVector pv[],
                               G4int &vecLen,
                               G4HEVector incidentParticle,
                               G4HEVector targetParticle,
+                              G4int& vecLen,
+                              const G4HEVector& incidentParticle,
+                              const G4HEVector& targetParticle,
                               const G4double atomicWeight);
 };
+#endif
+#endif

trunk/source/processes/hadronic/models/high_energy/include/G4HEKaonZeroInelastic.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HEKaonZeroInelastic.hh,v 1.13 2007/04/11 18:11:30 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEKaonZeroInelastic.hh,v 1.15 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HEKaonZeroInelastic() : G4HEInelastic("G4HEKaonZeroInelastic")
+   {
+     theMinEnergy =  20*GeV;
+     vecLength = 0;
+     theMinEnergy = 20*GeV;
      theMaxEnergy = 10*TeV;
      MAXPART      = 2048;
 …
    G4int vecLength;
+   G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus);
+   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                  G4Nucleus& targetNucleus);
+   G4int GetNumberOfSecondaries()
+        { return vecLength; }
+   G4int GetNumberOfSecondaries() {return vecLength;}
+   void FirstIntInCasKaonZero(G4bool &inElastic, const G4double availableEnergy,
+   void FirstIntInCasKaonZero(G4bool& inElastic,
+                              const G4double availableEnergy,
                               G4HEVector pv[],
                               G4int &vecLen,
                               G4HEVector incidentParticle,
                               G4HEVector targetParticle,
+                              G4int& vecLen,
+                              const G4HEVector& incidentParticle,
+                              const G4HEVector& targetParticle,
                               const G4double atomicWeight);
 };
+#endif
+#endif

trunk/source/processes/hadronic/models/high_energy/include/G4HEKaonZeroLongInelastic.hh

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4HEKaonZeroLongInelastic.hh,v 1.15 2010/02/09 21:58:09 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEKaonZeroLongInelastic.hh,v 1.16 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HEKaonZeroLongInelastic() : G4HEInelastic("G4HEKaonZeroLongInelastic")
+   {
      theMinEnergy =  20*GeV;
+     theMinEnergy = 20*GeV;
      theMaxEnergy = 10*TeV;
      MAXPART      = 2048;
 …
    ~G4HEKaonZeroLongInelastic(){ };
-  //   G4int verboseLevel;
    G4int vecLength;
+   G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus);
+   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                  G4Nucleus& targetNucleus);
    G4int GetNumberOfSecondaries()
         { return vecLength;};
+   void FirstIntInCasKaonZero(G4bool &inElastic, const G4double availableEnergy,
+   void FirstIntInCasKaonZero(G4bool& inElastic,
+                              const G4double availableEnergy,
                               G4HEVector pv[],
                               G4int &vecLen,
                               G4HEVector incidentParticle,
                               G4HEVector targetParticle,
+                              G4int& vecLen,
+                              const G4HEVector& incidentParticle,
+                              const G4HEVector& targetParticle,
                               const G4double atomicWeight);
+   void FirstIntInCasAntiKaonZero(G4bool &inElastic, const G4double availableEnergy,
+   void FirstIntInCasAntiKaonZero(G4bool& inElastic,
+                                  const G4double availableEnergy,
                                   G4HEVector pv[],
+                                  G4int &vecLen,
+                                  G4HEVector incidentParticle,
+                                  G4HEVector targetParticle);
+                                  G4int& vecLen,
+                                  const G4HEVector& incidentParticle,
+                                  const G4HEVector& targetParticle);
+};
+#endif
-  //   void SetVerboseLevel(G4int verbose)
-  //        { verboseLevel = verbose;};
-};
-#endif

trunk/source/processes/hadronic/models/high_energy/include/G4HEKaonZeroShortInelastic.hh

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4HEKaonZeroShortInelastic.hh,v 1.15 2010/02/09 21:58:33 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEKaonZeroShortInelastic.hh,v 1.16 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HEKaonZeroShortInelastic() : G4HEInelastic("G4HEKaonZeroShortInelastic")
+   {
      theMinEnergy =  20*GeV;
+     theMinEnergy = 20*GeV;
      theMaxEnergy = 10*TeV;
      MAXPART      = 2048;
 …
    G4int vecLength;
+   G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus);
+   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                  G4Nucleus& targetNucleus);
    G4int GetNumberOfSecondaries()
         { return vecLength;};
+   void FirstIntInCasKaonZero(G4bool &inElastic, const G4double availableEnergy,
+   void FirstIntInCasKaonZero(G4bool& inElastic,
+                              const G4double availableEnergy,
                               G4HEVector pv[],
                               G4int &vecLen,
                               G4HEVector incidentParticle,
                               G4HEVector targetParticle,
+                              G4int& vecLen,
+                              const G4HEVector& incidentParticle,
+                              const G4HEVector& targetParticle,
                               const G4double atomicWeight);
+   void FirstIntInCasAntiKaonZero(G4bool &inElastic, const G4double availableEnergy,
+   void FirstIntInCasAntiKaonZero(G4bool& inElastic,
+                                  const G4double availableEnergy,
                                   G4HEVector pv[],
+                                  G4int &vecLen,
+                                  G4HEVector incidentParticle,
+                                  G4HEVector targetParticle);
+                                  G4int& vecLen,
+                                  const G4HEVector& incidentParticle,
+                                  const G4HEVector& targetParticle);
+};
+#endif
-};
-#endif

trunk/source/processes/hadronic/models/high_energy/include/G4HELambdaInelastic.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HELambdaInelastic.hh,v 1.14 2007/04/11 18:11:30 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HELambdaInelastic.hh,v 1.16 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HELambdaInelastic() : G4HEInelastic("G4HELambdaInelastic")
+   {
+     theMinEnergy =  20*GeV;
+     vecLength = 0;
+     theMinEnergy = 20*GeV;
      theMaxEnergy = 10*TeV;
      MAXPART      = 2048;
 …
    G4int vecLength;
+   G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus);
+   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                  G4Nucleus& targetNucleus);
+   G4int GetNumberOfSecondaries()
+        { return vecLength; }
+   G4int GetNumberOfSecondaries() {return vecLength;}
+   void FirstIntInCasLambda(G4bool &inElastic, const G4double availableEnergy,
+   void FirstIntInCasLambda(G4bool& inElastic,
+                            const G4double availableEnergy,
                             G4HEVector pv[],
                             G4int &vecLen,
                             G4HEVector incidentParticle,
                             G4HEVector targetParticle,
+                            G4int& vecLen,
+                            const G4HEVector& incidentParticle,
+                            const G4HEVector& targetParticle,
                             const G4double atomicWeight);
 };
+#endif
+#endif

trunk/source/processes/hadronic/models/high_energy/include/G4HENeutronInelastic.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HENeutronInelastic.hh,v 1.15 2007/04/11 18:11:30 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HENeutronInelastic.hh,v 1.17 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
   G4HENeutronInelastic() : G4HEInelastic("G4HENeutronInelastic")
+  {
+    theMinEnergy =  45*GeV;
+    vecLength = 0;
+    theMinEnergy = 45*GeV;
     theMaxEnergy = 10*TeV;
     MAXPART      = 2048;
 …
   G4int vecLength;
+  G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus);
+  G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                 G4Nucleus& targetNucleus);
+  G4int GetNumberOfSecondaries()
+      { return vecLength; }
+  G4int GetNumberOfSecondaries() {return vecLength;}
+  void FirstIntInCasNeutron(G4bool &inElastic, const G4double availableEnergy,
+  void FirstIntInCasNeutron(G4bool& inElastic,
+                            const G4double availableEnergy,
                             G4HEVector pv[],
                             G4int &vecLen,
                             G4HEVector incidentParticle,
                             G4HEVector targetParticle,
+                            G4int& vecLen,
+                            const G4HEVector& incidentParticle,
+                            const G4HEVector& targetParticle,
                             const G4double atomicWeight);
 };
+#endif
+#endif

trunk/source/processes/hadronic/models/high_energy/include/G4HEOmegaMinusInelastic.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HEOmegaMinusInelastic.hh,v 1.14 2007/04/11 18:11:30 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEOmegaMinusInelastic.hh,v 1.16 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HEOmegaMinusInelastic() : G4HEInelastic("G4HEOmegaMinusInelastic")
+   {
+     theMinEnergy =  20*GeV;
+     vecLength = 0;
+     theMinEnergy = 20*GeV;
      theMaxEnergy = 10*TeV;
      MAXPART      = 2048;
 …
    G4int vecLength;
+   G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus);
+   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                  G4Nucleus& targetNucleus);
+   G4int GetNumberOfSecondaries()
+        { return vecLength; }
+   G4int GetNumberOfSecondaries() {return vecLength;}
+   void FirstIntInCasOmegaMinus(G4bool &inElastic, const G4double availableEnergy,
+   void FirstIntInCasOmegaMinus(G4bool& inElastic,
+                                const G4double availableEnergy,
                                 G4HEVector pv[],
                                 G4int &vecLen,
                                 G4HEVector incidentParticle,
                                 G4HEVector targetParticle,
+                                G4int& vecLen,
+                                const G4HEVector& incidentParticle,
+                                const G4HEVector& targetParticle,
                                 const G4double atomicWeight);
 };
+#endif
+#endif

trunk/source/processes/hadronic/models/high_energy/include/G4HEPionMinusInelastic.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HEPionMinusInelastic.hh,v 1.15 2007/04/11 18:11:30 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEPionMinusInelastic.hh,v 1.17 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HEPionMinusInelastic() : G4HEInelastic("G4HEPionMinusInelastic")
+   {
+     theMinEnergy =  45*GeV;
+     vecLength = 0;
+     theMinEnergy = 45*GeV;
      theMaxEnergy = 10*TeV;
      MAXPART      = 2048;
 …
    G4int vecLength;
+   G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus);
+   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                  G4Nucleus& targetNucleus);
+   G4int GetNumberOfSecondaries()
+        { return vecLength; }
+   G4int GetNumberOfSecondaries() {return vecLength;}
+   void FirstIntInCasPionMinus(G4bool &inElastic, const G4double availableEnergy,
+   void FirstIntInCasPionMinus(G4bool& inElastic,
+                               const G4double availableEnergy,
                                G4HEVector pv[],
                                G4int &vecLen,
                                G4HEVector incidentParticle,
                                G4HEVector targetParticle);
+                               G4int& vecLen,
+                               const G4HEVector& incidentParticle,
+                               const G4HEVector& targetParticle);
 };
+#endif
+#endif

trunk/source/processes/hadronic/models/high_energy/include/G4HEPionPlusInelastic.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HEPionPlusInelastic.hh,v 1.15 2007/04/11 18:11:30 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEPionPlusInelastic.hh,v 1.17 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HEPionPlusInelastic() : G4HEInelastic("G4HEPionPlusInelastic")
+   {
+     theMinEnergy =  45*GeV;
+     vecLength = 0;
+     theMinEnergy = 45*GeV;
      theMaxEnergy = 10*TeV;
      MAXPART      = 2048;
 …
    G4int vecLength;
+   G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus);
+   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                  G4Nucleus& targetNucleus);
+   G4int GetNumberOfSecondaries()
+       { return vecLength; }
+   G4int GetNumberOfSecondaries() {return vecLength;}
+   void FirstIntInCasPionPlus(G4bool &inElastic, const G4double availableEnergy,
+   void FirstIntInCasPionPlus(G4bool& inElastic,
+                              const G4double availableEnergy,
                               G4HEVector pv[],
                               G4int &vecLen,
                               G4HEVector incidentParticle,
                               G4HEVector targetParticle,
+                              G4int& vecLen,
+                              const G4HEVector& incidentParticle,
+                              const G4HEVector& targetParticle,
                               const G4double atomicWeight);
 };
+#endif
+#endif

trunk/source/processes/hadronic/models/high_energy/include/G4HEProtonInelastic.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HEProtonInelastic.hh,v 1.15 2007/04/11 18:11:30 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEProtonInelastic.hh,v 1.17 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HEProtonInelastic() : G4HEInelastic("G4HEProtonInelastic")
+   {
+     theMinEnergy =  45*GeV;
+     vecLength = 0;
+     theMinEnergy = 45*GeV;
      theMaxEnergy = 10*TeV;
      MAXPART      = 2048;
 …
    G4int vecLength;
+   G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus);
+   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                  G4Nucleus& targetNucleus);
+   G4int  GetNumberOfSecondaries()
+        { return vecLength; }
+   G4int GetNumberOfSecondaries() {return vecLength;}
+   void   FirstIntInCasProton(G4bool &inElastic, const G4double availableEnergy,
+                              G4HEVector pv[],
+                              G4int &vecLen,
+                              G4HEVector incidentParticle,
+                              G4HEVector targetParticle,
+                              const G4double atomicWeight);
+   void FirstIntInCasProton(G4bool& inElastic,
+                            const G4double availableEnergy,
+                            G4HEVector pv[],
+                            G4int& vecLen,
+                            const G4HEVector& incidentParticle,
+                            const G4HEVector& targetParticle,
+                            const G4double atomicWeight);
 };
+#endif
+#endif

trunk/source/processes/hadronic/models/high_energy/include/G4HESigmaMinusInelastic.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HESigmaMinusInelastic.hh,v 1.14 2007/04/11 18:11:30 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HESigmaMinusInelastic.hh,v 1.16 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HESigmaMinusInelastic() : G4HEInelastic("G4HESigmaMinusInelastic")
+   {
+     theMinEnergy =  20*GeV;
+     vecLength = 0;
+     theMinEnergy = 20*GeV;
      theMaxEnergy = 10*TeV;
      MAXPART      = 2048;
 …
    G4int vecLength;
+   G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus);
+   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                  G4Nucleus& targetNucleus);
+   G4int GetNumberOfSecondaries()
+        { return vecLength; }
+   G4int GetNumberOfSecondaries() {return vecLength;}
+   void FirstIntInCasSigmaMinus(G4bool &inElastic, const G4double availableEnergy,
+   void FirstIntInCasSigmaMinus(G4bool& inElastic,
+                                const G4double availableEnergy,
                                 G4HEVector pv[],
                                 G4int &vecLen,
                                 G4HEVector incidentParticle,
                                 G4HEVector targetParticle,
+                                G4int& vecLen,
+                                const G4HEVector& incidentParticle,
+                                const G4HEVector& targetParticle,
                                 const G4double atomicWeight);
 };
+#endif
+#endif

trunk/source/processes/hadronic/models/high_energy/include/G4HESigmaPlusInelastic.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HESigmaPlusInelastic.hh,v 1.14 2007/04/11 18:11:30 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HESigmaPlusInelastic.hh,v 1.16 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HESigmaPlusInelastic() : G4HEInelastic("G4HESigmaPlusInelastic")
+   {
+     theMinEnergy =  20*GeV;
+     vecLength = 0;
+     theMinEnergy = 20*GeV;
      theMaxEnergy = 10*TeV;
      MAXPART      = 2048;
 …
    G4int vecLength;
+   G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus);
+   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                  G4Nucleus& targetNucleus);
+   G4int GetNumberOfSecondaries()
+        { return vecLength; }
+   G4int GetNumberOfSecondaries() {return vecLength;}
+   void FirstIntInCasSigmaPlus(G4bool &inElastic, const G4double availableEnergy,
+   void FirstIntInCasSigmaPlus(G4bool& inElastic,
+                               const G4double availableEnergy,
                                G4HEVector pv[],
                                G4int &vecLen,
                                G4HEVector incidentParticle,
                                G4HEVector targetParticle,
+                               G4int& vecLen,
+                               const G4HEVector& incidentParticle,
+                               const G4HEVector& targetParticle,
                                const G4double atomicWeight);
 };
+#endif
+#endif

trunk/source/processes/hadronic/models/high_energy/include/G4HESigmaZeroInelastic.hh

r1340	r1347
26	26	//
27	27	// $Id: G4HESigmaZeroInelastic.hh,v 1.14 2007/04/11 18:11:30 dennis Exp $
28		// GEANT4 tag $Name: geant4-09-0~~3-ref-09~~ $
	28	// GEANT4 tag $Name: geant4-09-04-ref-00 $
29	29	//
30	30	//

trunk/source/processes/hadronic/models/high_energy/include/G4HEVector.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HEVector.hh,v 1.12 2006/06/29 20:29:48 gunter Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEVector.hh,v 1.15 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
      baryon           = 0;
      strangeness      = 0;
+     for (G4int i = 0; i < NumberOfQuarkFlavor; i++) {
+       theQuarkContent[i] = 0;
+       theAntiQuarkContent[i] = 0;
+     }
+   }
 …
    const G4ParticleMomentum getMomentum() const ;
    G4double getTotalMomentum();
+   G4double getTotalMomentum() const;
    void setMomentum( G4double x, G4double y, G4double z);
 …
    void setKineticEnergyAndUpdate(G4double ekin);
    G4double getEnergy();
    G4double getKineticEnergy();
+   G4double getEnergy() const;
+   G4double getKineticEnergy() const;
    void setMass( G4double m );
 …
    void setMassAndUpdate( G4double m );
    G4double getMass();
+   G4double getMass() const;
    void setCharge( G4double c );
    G4double getCharge();
+   G4double getCharge() const;
    void setTOF( G4double t );
 …
    void setCode( G4int c );
    G4int getCode();
    G4String getName();
    G4int getBaryonNumber();
    G4int getStrangenessNumber();
+   G4int getCode() const;
+   G4String getName() const;
+   G4int getBaryonNumber() const;
+   G4int getStrangenessNumber() const;
    G4int getQuarkContent(G4int flavor);
 …
    void setZero();
    G4String getType();
+   G4String getType() const;
    void Add( const G4HEVector & p1, const G4HEVector & p2 );
 …
    void Lor( const G4HEVector & p1, const G4HEVector & p2 );
    G4double CosAng( const G4HEVector & p );
+   G4double CosAng(const G4HEVector& p) const;
    G4double Ang(const G4HEVector & p );
 …
    void Norz( const G4HEVector & p );
    G4double Length();
+   G4double Length() const;
    void Exch( G4HEVector & p1);
 …
    G4int FillQuarkContent();
    void Print( G4int L);
+   void Print(G4int L) const;
 };
 #endif

trunk/source/processes/hadronic/models/high_energy/include/G4HEXiMinusInelastic.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HEXiMinusInelastic.hh,v 1.14 2007/04/11 18:11:30 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEXiMinusInelastic.hh,v 1.16 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HEXiMinusInelastic() : G4HEInelastic("G4HEXiMinusInelastic")
+   {
+     theMinEnergy =  20*GeV;
+     vecLength = 0;
+     theMinEnergy = 20*GeV;
      theMaxEnergy = 10*TeV;
      MAXPART      = 2048;
 …
    G4int vecLength;
+   G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus);
+   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                  G4Nucleus& targetNucleus);
+   G4int GetNumberOfSecondaries()
+       { return vecLength; }
+   G4int GetNumberOfSecondaries() {return vecLength;}
+   void FirstIntInCasXiMinus(G4bool &inElastic, const G4double availableEnergy,
+   void FirstIntInCasXiMinus(G4bool& inElastic,
+                             const G4double availableEnergy,
                              G4HEVector pv[],
                              G4int &vecLen,
                              G4HEVector incidentParticle,
                              G4HEVector targetParticle,
+                             G4int& vecLen,
+                             const G4HEVector& incidentParticle,
+                             const G4HEVector& targetParticle,
                              const G4double atomicWeight);
 };
+#endif
+#endif

trunk/source/processes/hadronic/models/high_energy/include/G4HEXiZeroInelastic.hh

-              r1340
+              r1347
 //
 //
 // $Id: G4HEXiZeroInelastic.hh,v 1.14 2007/04/11 18:11:30 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEXiZeroInelastic.hh,v 1.16 2010/11/29 05:45:06 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
    G4HEXiZeroInelastic() : G4HEInelastic("G4HEXiZeroInelastic")
+   {
+     theMinEnergy =  20*GeV;
+     vecLength = 0;
+     theMinEnergy = 20*GeV;
      theMaxEnergy = 10*TeV;
      MAXPART      = 2048;
 …
    G4int vecLength;
+   G4HadFinalState* ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus);
+   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
+                                  G4Nucleus& targetNucleus);
+   G4int GetNumberOfSecondaries()
+       { return vecLength; }
+   G4int GetNumberOfSecondaries() {return vecLength;}
+   void FirstIntInCasXiZero(G4bool &inElastic, const G4double availableEnergy,
+   void FirstIntInCasXiZero(G4bool& inElastic,
+                            const G4double availableEnergy,
                             G4HEVector pv[],
                             G4int &vecLen,
                             G4HEVector incidentParticle,
                             G4HEVector targetParticle,
+                            G4int& vecLen,
+                            const G4HEVector& incidentParticle,
+                            const G4HEVector& targetParticle,
                             const G4double atomicWeight);
 };
+#endif
+#endif

trunk/source/processes/hadronic/models/high_energy/src/G4HEAntiKaonZeroInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HEAntiKaonZeroInelastic.cc,v 1.16 2010/02/09 22:02:04 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HEAntiKaonZeroInelastic.cc,v 1.18 2010/11/27 00:06:50 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
+// and the low energy two-body model. Not included is the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
 …
 #include "G4HEAntiKaonZeroInelastic.hh"
+G4HadFinalState *  G4HEAntiKaonZeroInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
+    const G4HadProjectile *aParticle = &aTrack;
+//    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
+    const G4double atomicWeight = targetNucleus.GetN();
+    const G4double atomicNumber = targetNucleus.GetZ();
+    G4HEVector incidentParticle(aParticle);
+    G4int    incidentCode          = incidentParticle.getCode();
+    G4double incidentMass          = incidentParticle.getMass();
+    G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+    if(incidentKineticEnergy < 1.)
+      {
+        G4cout << "GHEAntiKaonZeroInelastic: incident energy < 1 GeV" << G4endl;
+      }
+    if(verboseLevel > 1)
+      {
+        G4cout << "G4HEAntiKaonZeroInelastic::ApplyYourself" << G4endl;
+        G4cout << "incident particle " << incidentParticle.getName()
+             << "mass "              << incidentMass
+             << "kinetic energy "    << incidentKineticEnergy
+             << G4endl;
+        G4cout << "target material with (A,Z) = ("
+             << atomicWeight << "," << atomicNumber << ")" << G4endl;
+      }
+G4HadFinalState*
+G4HEAntiKaonZeroInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                         G4Nucleus& targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
+  const G4double atomicWeight = targetNucleus.GetN();
+  const G4double atomicNumber = targetNucleus.GetZ();
+  G4HEVector incidentParticle(aParticle);
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+  if (incidentKineticEnergy < 1.)
+    G4cout << "GHEAntiKaonZeroInelastic: incident energy < 1 GeV" << G4endl;
+  if (verboseLevel > 1) {
+    G4cout << "G4HEAntiKaonZeroInelastic::ApplyYourself" << G4endl;
+    G4cout << "incident particle " << incidentParticle.getName()
+           << "mass "              << incidentMass
+           << "kinetic energy "    << incidentKineticEnergy
+           << G4endl;
+    G4cout << "target material with (A,Z) = ("
+           << atomicWeight << "," << atomicNumber << ")" << G4endl;
+  }
     G4double inelasticity  = NuclearInelasticity(incidentKineticEnergy,
                                                  atomicWeight, atomicNumber);
     if(verboseLevel > 1)
         G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+  G4double inelasticity = NuclearInelasticity(incidentKineticEnergy,
+                                              atomicWeight, atomicNumber);
+  if (verboseLevel > 1)
+    G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
     incidentKineticEnergy -= inelasticity;
+  incidentKineticEnergy -= inelasticity;
     G4double excitationEnergyGNP = 0.;
     G4double excitationEnergyDTA = 0.;
     G4double excitation    = NuclearExcitation(incidentKineticEnergy,
                                                atomicWeight, atomicNumber,
                                                excitationEnergyGNP,
                                                excitationEnergyDTA);
     if(verboseLevel > 1)
       G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+  G4double excitationEnergyGNP = 0.;
+  G4double excitationEnergyDTA = 0.;
+  G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                          atomicWeight, atomicNumber,
+                                          excitationEnergyGNP,
+                                          excitationEnergyDTA);
+  if (verboseLevel > 1)
+    G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
            << excitationEnergyDTA << G4endl;
+    incidentKineticEnergy -= excitation;
+    incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+    G4HEVector targetParticle;
+    if(G4UniformRand() < atomicNumber/atomicWeight)
+      {
+        targetParticle.setDefinition("Proton");
+      }
+    else
+      {
+        targetParticle.setDefinition("Neutron");
+      }
+    G4double targetMass         = targetParticle.getMass();
+    G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+    G4double availableEnergy    = centerOfMassEnergy - targetMass - incidentMass;
+                                                                // this was the meaning of inElastic in the
+                                                                // original Gheisha stand-alone version.
+//    G4bool   inElastic          = InElasticCrossSectionInFirstInt
+//                                    (availableEnergy, incidentCode, incidentTotalMomentum);
+                                                                // by unknown reasons, it has been replaced
+                                                                // to the following code in Geant???
+    G4bool inElastic = true;
+//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+    vecLength = 0;
+  incidentKineticEnergy -= excitation;
+  incidentTotalEnergy = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                    *(incidentTotalEnergy+incidentMass));
+  G4HEVector targetParticle;
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
+    targetParticle.setDefinition("Proton");
+  } else {
+    targetParticle.setDefinition("Neutron");
+  }
+  G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                         + targetMass*targetMass
+                                         + 2.0*targetMass*incidentTotalEnergy);
+  G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
+  vecLength = 0;
     if(verboseLevel > 1)
       G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
            << incidentCode << G4endl;
+    G4bool successful = false;
+    if(inElastic || (!inElastic && atomicWeight < 1.5))
+      {
+        FirstIntInCasAntiKaonZero(inElastic, availableEnergy, pv, vecLength,
+                                  incidentParticle, targetParticle );
+        if(verboseLevel > 1)
+           G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+        if ((vecLength > 0) && (availableEnergy > 1.))
+                   StrangeParticlePairProduction( availableEnergy, centerOfMassEnergy,
+                                                  pv, vecLength,
+                                                  incidentParticle, targetParticle);
+            HighEnergyCascading( successful, pv, vecLength,
+                                 excitationEnergyGNP, excitationEnergyDTA,
+                                 incidentParticle, targetParticle,
+                                 atomicWeight, atomicNumber);
+        if (!successful)
+            HighEnergyClusterProduction( successful, pv, vecLength,
+                                         excitationEnergyGNP, excitationEnergyDTA,
+                                         incidentParticle, targetParticle,
+                                         atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyCascading( successful, pv, vecLength,
+                                   excitationEnergyGNP, excitationEnergyDTA,
+                                   incidentParticle, targetParticle,
+                                   atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyClusterProduction( successful, pv, vecLength,
+                                           excitationEnergyGNP, excitationEnergyDTA,
+                                           incidentParticle, targetParticle,
+                                           atomicWeight, atomicNumber);
+        if (!successful)
+            QuasiElasticScattering( successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+            ElasticScattering( successful, pv, vecLength,
+                               incidentParticle,
+                               atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+             << G4endl;
+      FillParticleChange(pv,  vecLength);
+      delete [] pv;
+      theParticleChange.SetStatusChange(stopAndKill);
+      return & theParticleChange;
+  }
+  G4bool successful = false;
+  G4bool inElastic = true;
+  FirstIntInCasAntiKaonZero(inElastic, availableEnergy, pv, vecLength,
+                            incidentParticle, targetParticle );
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+                                  incidentParticle, targetParticle,
+                                  atomicWeight, atomicNumber);
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
+  if (!successful)
+    ElasticScattering(successful, pv, vecLength,
+                      incidentParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+           << G4endl;
+  FillParticleChange(pv,  vecLength);
+  delete [] pv;
+  theParticleChange.SetStatusChange(stopAndKill);
+  return &theParticleChange;
+}
 void
+G4HEAntiKaonZeroInelastic::FirstIntInCasAntiKaonZero( G4bool &inElastic,
+                                                      const G4double availableEnergy,
+                                                      G4HEVector pv[],
+                                                      G4int &vecLen,
+                                                      G4HEVector incidentParticle,
+                                                      G4HEVector targetParticle )
+// AntiKaon0 undergoes interaction with nucleon within a nucleus.  Check if it is
+// energetically possible to produce pions/kaons.  In not, assume nuclear excitation
+// occurs and input particle is degraded in energy. No other particles are produced.
+G4HEAntiKaonZeroInelastic::FirstIntInCasAntiKaonZero(G4bool& inElastic,
+                                                     const G4double availableEnergy,
+                                                     G4HEVector pv[],
+                                                     G4int &vecLen,
+                                                     const G4HEVector& incidentParticle,
+                                                     const G4HEVector& targetParticle)
+// AntiKaon0 undergoes interaction with nucleon within a nucleus.  Check if it
+// is energetically possible to produce pions/kaons.  In not, assume nuclear
+// excitation occurs and input particle is degraded in energy.  No other
+// particles are produced.
 // If reaction is possible, find the correct number of pions/protons/neutrons
 // produced using an interpolation to multiplicity data.  Replace some pions or
 // protons/neutrons by kaons or strange baryons according to the average
 // multiplicity per inelastic reaction.
+ {
+   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
+   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+   static const G4double protb = 0.7;
+   static const G4double neutb = 0.7;
+   static const G4double     c = 1.25;
+   static const G4int   numMul = 1200;
+   static const G4int   numSec = 60;
+   G4int              neutronCode = Neutron.getCode();
+   G4int               protonCode = Proton.getCode();
+   G4int            kaonMinusCode = KaonMinus.getCode();
+   G4int             kaonZeroCode = KaonZero.getCode();
+   G4int         antiKaonZeroCode = AntiKaonZero.getCode();
+   G4int               targetCode = targetParticle.getCode();
+//   G4double          incidentMass = incidentParticle.getMass();
+//   G4double        incidentEnergy = incidentParticle.getEnergy();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   static G4bool first = true;
+   static G4double protmul[numMul], protnorm[numSec];  // proton constants
+   static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+//                                misc. local variables
+//                                np = number of pi+,  nm = number of pi-,  nz = number of pi0
+   G4int i, counter, nt, np, nm, nz;
+{
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
+  static const G4double protb = 0.7;
+  static const G4double neutb = 0.7;
+  static const G4double     c = 1.25;
+  static const G4int numMul = 1200;
+  static const G4int numSec = 60;
+  G4int neutronCode = Neutron.getCode();
+  G4int protonCode = Proton.getCode();
+  G4int kaonMinusCode = KaonMinus.getCode();
+  G4int kaonZeroCode = KaonZero.getCode();
+  G4int antiKaonZeroCode = AntiKaonZero.getCode();
+  G4int targetCode = targetParticle.getCode();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  static G4bool first = true;
+  static G4double protmul[numMul], protnorm[numSec];  // proton constants
+  static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+  // misc. local variables
+  // np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  G4int i, counter, nt, np, nm, nz;
    if( first )
      {                         // compute normalization constants, this will only be done once
+     {                   // compute normalization constants, this will only be done once
        first = false;
        for( i=0; i<numMul; i++ )protmul[i]  = 0.0;

trunk/source/processes/hadronic/models/high_energy/src/G4HEAntiLambdaInelastic.cc

-              r1340
+              r1347
 //
 //
+// $Id: G4HEAntiLambdaInelastic.cc,v 1.15 2008/03/17 20:49:17 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HEAntiLambdaInelastic.cc,v 1.17 2010/11/27 02:00:07 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model. Not included are the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 // First work done by J.L.Chuma and F.W.Jones, TRIUMF, June 96.
 // H. Fesefeldt, RWTH-Aachen, 23-October-1996
 …
 #include "G4HEAntiLambdaInelastic.hh"
+G4HadFinalState *  G4HEAntiLambdaInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
+    const G4HadProjectile *aParticle = &aTrack;
+//    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
+    const G4double atomicWeight = targetNucleus.GetN();
+    const G4double atomicNumber = targetNucleus.GetZ();
+    G4HEVector incidentParticle(aParticle);
+    G4int    incidentCode          = incidentParticle.getCode();
+    G4double incidentMass          = incidentParticle.getMass();
+    G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+    if(incidentKineticEnergy < 1.)
+      {
+        G4cout << "GHEAntiLambdaInelastic: incident energy < 1 GeV" << G4endl;
+      }
+    if(verboseLevel > 1)
+      {
+        G4cout << "G4HEAntiLambdaInelastic::ApplyYourself" << G4endl;
+        G4cout << "incident particle " << incidentParticle.getName()
+             << "mass "              << incidentMass
+             << "kinetic energy "    << incidentKineticEnergy
+             << G4endl;
+        G4cout << "target material with (A,Z) = ("
+             << atomicWeight << "," << atomicNumber << ")" << G4endl;
+      }
+    G4double inelasticity  = NuclearInelasticity(incidentKineticEnergy,
+                                                 atomicWeight, atomicNumber);
+    if(verboseLevel > 1)
+        G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+G4HadFinalState*
+G4HEAntiLambdaInelastic::ApplyYourself(const G4HadProjectile &aTrack,
+                                       G4Nucleus &targetNucleus)
+{
+  G4HEVector * pv = new G4HEVector[MAXPART];
+  const G4HadProjectile *aParticle = &aTrack;
+  const G4double atomicWeight = targetNucleus.GetN();
+  const G4double atomicNumber = targetNucleus.GetZ();
+  G4HEVector incidentParticle(aParticle);
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+  if (incidentKineticEnergy < 1.)
+    G4cout << "GHEAntiLambdaInelastic: incident energy < 1 GeV" << G4endl;
+  if (verboseLevel > 1) {
+    G4cout << "G4HEAntiLambdaInelastic::ApplyYourself" << G4endl;
+    G4cout << "incident particle " << incidentParticle.getName()
+           << "mass "              << incidentMass
+           << "kinetic energy "    << incidentKineticEnergy
+           << G4endl;
+    G4cout << "target material with (A,Z) = ("
+           << atomicWeight << "," << atomicNumber << ")" << G4endl;
+  }
+  G4double inelasticity = NuclearInelasticity(incidentKineticEnergy,
+                                              atomicWeight, atomicNumber);
+  if (verboseLevel > 1)
+    G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
     incidentKineticEnergy -= inelasticity;
+  incidentKineticEnergy -= inelasticity;
     G4double excitationEnergyGNP = 0.;
     G4double excitationEnergyDTA = 0.;
     G4double excitation    = NuclearExcitation(incidentKineticEnergy,
                                                atomicWeight, atomicNumber,
                                                excitationEnergyGNP,
                                                excitationEnergyDTA);
     if(verboseLevel > 1)
       G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+  G4double excitationEnergyGNP = 0.;
+  G4double excitationEnergyDTA = 0.;
+  G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                          atomicWeight, atomicNumber,
+                                          excitationEnergyGNP,
+                                          excitationEnergyDTA);
+  if (verboseLevel > 1)
+    G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
            << excitationEnergyDTA << G4endl;
+    incidentKineticEnergy -= excitation;
+    incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+    G4HEVector targetParticle;
+    if(G4UniformRand() < atomicNumber/atomicWeight)
+      {
+        targetParticle.setDefinition("Proton");
+      }
+    else
+      {
+        targetParticle.setDefinition("Neutron");
+      }
+    G4double targetMass         = targetParticle.getMass();
+    G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+    G4double availableEnergy    = centerOfMassEnergy - targetMass - incidentMass;
+                                                                // this was the meaning of inElastic in the
+                                                                // original Gheisha stand-alone version.
+//    G4bool   inElastic          = InElasticCrossSectionInFirstInt
+//                                    (availableEnergy, incidentCode, incidentTotalMomentum);
+                                                                // by unknown reasons, it has been replaced
+                                                                // to the following code in Geant???
+    G4bool inElastic = true;
+//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+    vecLength = 0;
+  incidentKineticEnergy -= excitation;
+  incidentTotalEnergy = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt( (incidentTotalEnergy-incidentMass)
+                         *(incidentTotalEnergy+incidentMass));
+  G4HEVector targetParticle;
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
+    targetParticle.setDefinition("Proton");
+  } else {
+    targetParticle.setDefinition("Neutron");
+  }
+  G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy =
+       std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+       + 2.0*targetMass*incidentTotalEnergy);
+  G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
+  G4bool inElastic = true;
+  vecLength = 0;
     if(verboseLevel > 1)
       G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
            << incidentCode << G4endl;
     G4bool successful = false;
+  G4bool successful = false;
+    if(inElastic || (!inElastic && atomicWeight < 1.5))
+      {
+        FirstIntInCasAntiLambda(inElastic, availableEnergy, pv, vecLength,
+                                incidentParticle, targetParticle, atomicWeight);
+        if(verboseLevel > 1)
+           G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+        if ((vecLength > 0) && (availableEnergy > 1.))
+                   StrangeParticlePairProduction( availableEnergy, centerOfMassEnergy,
+                                                  pv, vecLength,
+                                                  incidentParticle, targetParticle);
+            HighEnergyCascading( successful, pv, vecLength,
+                                 excitationEnergyGNP, excitationEnergyDTA,
+                                 incidentParticle, targetParticle,
+                                 atomicWeight, atomicNumber);
+        if (!successful)
+            HighEnergyClusterProduction( successful, pv, vecLength,
+                                         excitationEnergyGNP, excitationEnergyDTA,
+                                         incidentParticle, targetParticle,
+                                         atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyCascading( successful, pv, vecLength,
+                                   excitationEnergyGNP, excitationEnergyDTA,
+                                   incidentParticle, targetParticle,
+                                   atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyClusterProduction( successful, pv, vecLength,
+                                           excitationEnergyGNP, excitationEnergyDTA,
+                                           incidentParticle, targetParticle,
+                                           atomicWeight, atomicNumber);
+        if (!successful)
+            QuasiElasticScattering( successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+            ElasticScattering( successful, pv, vecLength,
+                               incidentParticle,
+                               atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+        G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles" << G4endl;
+      }
+      FillParticleChange(pv,  vecLength);
+      delete [] pv;
+      theParticleChange.SetStatusChange(stopAndKill);
+      return & theParticleChange;
+  }
+  FirstIntInCasAntiLambda(inElastic, availableEnergy, pv, vecLength,
+                          incidentParticle, targetParticle, atomicWeight);
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+                                  incidentParticle, targetParticle,
+                                  atomicWeight, atomicNumber);
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
+  if (!successful)
+    ElasticScattering(successful, pv, vecLength,
+                      incidentParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+           << G4endl;
+  FillParticleChange(pv, vecLength);
+  delete [] pv;
+  theParticleChange.SetStatusChange(stopAndKill);
+  return & theParticleChange;
+}
 void
+G4HEAntiLambdaInelastic::FirstIntInCasAntiLambda( G4bool &inElastic,
+                                                  const G4double availableEnergy,
+                                                  G4HEVector pv[],
+                                                  G4int &vecLen,
+                                                  G4HEVector incidentParticle,
+                                                  G4HEVector targetParticle,
+                                                  const G4double atomicWeight)
+// AntiLambda undergoes interaction with nucleon within a nucleus.  Check if it is
+// energetically possible to produce pions/kaons.  In not, assume nuclear excitation
+// occurs and input particle is degraded in energy. No other particles are produced.
+G4HEAntiLambdaInelastic::FirstIntInCasAntiLambda(G4bool& inElastic,
+                                                 const G4double availableEnergy,
+                                                 G4HEVector pv[],
+                                                 G4int &vecLen,
+                                                 const G4HEVector& incidentParticle,
+                                                 const G4HEVector& targetParticle,
+                                                 const G4double atomicWeight)
+// AntiLambda undergoes interaction with nucleon within a nucleus.
+// Check if it is energetically possible to produce pions/kaons.  If not,
+// assume nuclear excitation occurs and input particle is degraded in
+// energy. No other particles are produced.
 // If reaction is possible, find the correct number of pions/protons/neutrons
 // produced using an interpolation to multiplicity data.  Replace some pions or
 // protons/neutrons by kaons or strange baryons according to the average
 // multiplicity per inelastic reaction.
+ {
+   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
+   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+   static const G4double protb = 0.7;
+   static const G4double neutb = 0.7;
+   static const G4double     c = 1.25;
+   static const G4int   numMul   = 1200;
+   static const G4int   numMulAn = 400;
+   static const G4int   numSec   = 60;
+//   G4int              neutronCode = Neutron.getCode();
+   G4int              protonCode  = Proton.getCode();
+   G4int               targetCode = targetParticle.getCode();
+//   G4double          incidentMass = incidentParticle.getMass();
+//   G4double        incidentEnergy = incidentParticle.getEnergy();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   static G4bool first = true;
+   static G4double protmul[numMul],  protnorm[numSec];   // proton constants
+   static G4double protmulAn[numMulAn],protnormAn[numSec];
+   static G4double neutmul[numMul],  neutnorm[numSec];   // neutron constants
+   static G4double neutmulAn[numMulAn],neutnormAn[numSec];
+                              //  misc. local variables
+                              //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+   G4int i, counter, nt, np, nm, nz;
+{
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
+  static const G4double protb = 0.7;
+  static const G4double neutb = 0.7;
+  static const G4double     c = 1.25;
+  static const G4int   numMul   = 1200;
+  static const G4int   numMulAn = 400;
+  static const G4int   numSec   = 60;
+  G4int protonCode = Proton.getCode();
+  G4int targetCode = targetParticle.getCode();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  static G4bool first = true;
+  static G4double protmul[numMul],  protnorm[numSec];   // proton constants
+  static G4double protmulAn[numMulAn],protnormAn[numSec];
+  static G4double neutmul[numMul],  neutnorm[numSec];   // neutron constants
+  static G4double neutmulAn[numMulAn],neutnormAn[numSec];
+  //  misc. local variables
+  //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  G4int i, counter, nt, np, nm, nz;
    if( first )
      {                         // compute normalization constants, this will only be done once
+     {                 // compute normalization constants, this will only be done once
        first = false;
        for( i=0; i<numMul  ; i++ ) protmul[i]  = 0.0;

trunk/source/processes/hadronic/models/high_energy/src/G4HEAntiNeutronInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HEAntiNeutronInelastic.cc,v 1.15 2008/03/17 20:49:17 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HEAntiNeutronInelastic.cc,v 1.17 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model.  Not included is the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 // First work done by J.L.Chuma and F.W.Jones, TRIUMF, June 96.
 // H. Fesefeldt, RWTH-Aachen, 23-October-1996
 …
 #include "G4HEAntiNeutronInelastic.hh"
+G4HadFinalState *  G4HEAntiNeutronInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
+    const G4HadProjectile *aParticle = &aTrack;
+//    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
+    const G4double atomicWeight = targetNucleus.GetN();
+    const G4double atomicNumber = targetNucleus.GetZ();
+    G4HEVector incidentParticle(aParticle);
+    G4int    incidentCode          = incidentParticle.getCode();
+    G4double incidentMass          = incidentParticle.getMass();
+    G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+    if(incidentKineticEnergy < 1.)
+      {
+        G4cout << "GHEAntiNeutronInelastic: incident energy < 1 GeV" << G4endl;;
+      }
+    if(verboseLevel > 1)
+      {
+        G4cout << "G4HEAntiNeutronInelastic::ApplyYourself" << G4endl;
+        G4cout << "incident particle " << incidentParticle.getName()
+             << "mass "              << incidentMass
+             << "kinetic energy "    << incidentKineticEnergy
+             << G4endl;
+        G4cout << "target material with (A,Z) = ("
+             << atomicWeight << "," << atomicNumber << ")" << G4endl;
+      }
+    G4double inelasticity  = NuclearInelasticity(incidentKineticEnergy,
+                                                 atomicWeight, atomicNumber);
+    if(verboseLevel > 1)
+        G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+G4HadFinalState*
+G4HEAntiNeutronInelastic::ApplyYourself(const G4HadProjectile &aTrack,
+                                        G4Nucleus &targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
+  const G4double atomicWeight = targetNucleus.GetN();
+  const G4double atomicNumber = targetNucleus.GetZ();
+  G4HEVector incidentParticle(aParticle);
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+  if (incidentKineticEnergy < 1.)
+    G4cout << "GHEAntiNeutronInelastic: incident energy < 1 GeV" << G4endl;;
+  if (verboseLevel > 1) {
+    G4cout << "G4HEAntiNeutronInelastic::ApplyYourself" << G4endl;
+    G4cout << "incident particle " << incidentParticle.getName()
+           << "mass "              << incidentMass
+           << "kinetic energy "    << incidentKineticEnergy
+           << G4endl;
+    G4cout << "target material with (A,Z) = ("
+           << atomicWeight << "," << atomicNumber << ")" << G4endl;
+  }
+  G4double inelasticity = NuclearInelasticity(incidentKineticEnergy,
+                                              atomicWeight, atomicNumber);
+  if (verboseLevel > 1)
+    G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
     incidentKineticEnergy -= inelasticity;
+  incidentKineticEnergy -= inelasticity;
     G4double excitationEnergyGNP = 0.;
     G4double excitationEnergyDTA = 0.;
     G4double excitation    = NuclearExcitation(incidentKineticEnergy,
                                                atomicWeight, atomicNumber,
                                                excitationEnergyGNP,
                                                excitationEnergyDTA);
     if(verboseLevel > 1)
       G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+  G4double excitationEnergyGNP = 0.;
+  G4double excitationEnergyDTA = 0.;
+  G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                          atomicWeight, atomicNumber,
+                                          excitationEnergyGNP,
+                                          excitationEnergyDTA);
+  if (verboseLevel > 1)
+    G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
            << excitationEnergyDTA << G4endl;
+    incidentKineticEnergy -= excitation;
+    incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+    G4HEVector targetParticle;
+    if(G4UniformRand() < atomicNumber/atomicWeight)
+      {
+        targetParticle.setDefinition("Proton");
+      }
+    else
+      {
+        targetParticle.setDefinition("Neutron");
+      }
+    G4double targetMass         = targetParticle.getMass();
+    G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+    G4double availableEnergy    = centerOfMassEnergy - targetMass - incidentMass;
+                                                                // this was the meaning of inElastic in the
+                                                                // original Gheisha stand-alone version.
+//    G4bool   inElastic          = InElasticCrossSectionInFirstInt
+//                                    (availableEnergy, incidentCode, incidentTotalMomentum);
+                                                                // by unknown reasons, it has been replaced
+                                                                // to the following code in Geant???
+    G4bool inElastic = true;
+//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+    vecLength = 0;
+  incidentKineticEnergy -= excitation;
+  incidentTotalEnergy = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                    *(incidentTotalEnergy+incidentMass));
+  G4HEVector targetParticle;
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
+    targetParticle.setDefinition("Proton");
+  } else {
+    targetParticle.setDefinition("Neutron");
+  }
+  G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                        + targetMass*targetMass
+                                        + 2.0*targetMass*incidentTotalEnergy);
+  G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
+  G4bool inElastic = true;
+  vecLength = 0;
     if(verboseLevel > 1)
       G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
            << incidentCode << G4endl;
     G4bool successful = false;
+  G4bool successful = false;
+    if(inElastic || (!inElastic && atomicWeight < 1.5))
+      {
+        FirstIntInCasAntiNeutron(inElastic, availableEnergy, pv, vecLength,
+                                 incidentParticle, targetParticle, atomicWeight);
+        if(verboseLevel > 1)
+           G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+        if ((vecLength > 0) && (availableEnergy > 1.))
+                   StrangeParticlePairProduction( availableEnergy, centerOfMassEnergy,
+                                                  pv, vecLength,
+                                                  incidentParticle, targetParticle);
+            HighEnergyCascading( successful, pv, vecLength,
+                                 excitationEnergyGNP, excitationEnergyDTA,
+                                 incidentParticle, targetParticle,
+                                 atomicWeight, atomicNumber);
+        if (!successful)
+            HighEnergyClusterProduction( successful, pv, vecLength,
+                                         excitationEnergyGNP, excitationEnergyDTA,
+                                         incidentParticle, targetParticle,
+                                         atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyCascading( successful, pv, vecLength,
+                                   excitationEnergyGNP, excitationEnergyDTA,
+                                   incidentParticle, targetParticle,
+                                   atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyClusterProduction( successful, pv, vecLength,
+                                           excitationEnergyGNP, excitationEnergyDTA,
+                                           incidentParticle, targetParticle,
+                                           atomicWeight, atomicNumber);
+        if (!successful)
+            QuasiElasticScattering( successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+            ElasticScattering( successful, pv, vecLength,
+                               incidentParticle,
+                               atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+        G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles" << G4endl;
+      }
+      FillParticleChange(pv,  vecLength);
+      delete [] pv;
+      theParticleChange.SetStatusChange(stopAndKill);
+      return & theParticleChange;
+  }
+  FirstIntInCasAntiNeutron(inElastic, availableEnergy, pv, vecLength,
+                           incidentParticle, targetParticle, atomicWeight);
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+                                  incidentParticle, targetParticle,
+                                  atomicWeight, atomicNumber);
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
+  if (!successful)
+    ElasticScattering(successful, pv, vecLength,
+                      incidentParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+           << G4endl;
+  FillParticleChange(pv,  vecLength);
+  delete [] pv;
+  theParticleChange.SetStatusChange(stopAndKill);
+  return &theParticleChange;
+}
 void
+  G4HEAntiNeutronInelastic::FirstIntInCasAntiNeutron( G4bool &inElastic,
+                                                      const G4double availableEnergy,
+                                                      G4HEVector pv[],
+                                                      G4int &vecLen,
+                                                      G4HEVector incidentParticle,
+                                                      G4HEVector targetParticle,
+                                                      const G4double atomicWeight)
+// AntiNeutron undergoes interaction with nucleon within a nucleus.  Check if it is
+// energetically possible to produce pions/kaons.  In not, assume nuclear excitation
+// occurs and input particle is degraded in energy. No other particles are produced.
+G4HEAntiNeutronInelastic::FirstIntInCasAntiNeutron(G4bool& inElastic,
+                                                   const G4double availableEnergy,
+                                                   G4HEVector pv[],
+                                                   G4int& vecLen,
+                                                   const G4HEVector& incidentParticle,
+                                                   const G4HEVector& targetParticle,
+                                                   const G4double atomicWeight)
+// AntiNeutron undergoes interaction with nucleon within a nucleus.  Check if
+// it is energetically possible to produce pions/kaons.  If not, assume
+// nuclear excitation occurs and input particle is degraded in energy.  No
+// other particles are produced.
 // If reaction is possible, find the correct number of pions/protons/neutrons
 // produced using an interpolation to multiplicity data.  Replace some pions or
 // protons/neutrons by kaons or strange baryons according to the average
 // multiplicity per inelastic reaction.
+ {
+   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
+   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+   static const G4double protb = 0.7;
+   static const G4double neutb = 0.7;
+   static const G4double     c = 1.25;
+   static const G4int   numMul   = 1200;
+   static const G4int   numMulAn = 400;
+   static const G4int   numSec   = 60;
+   G4int              neutronCode = Neutron.getCode();
+   G4int              protonCode  = Proton.getCode();
+   G4int               targetCode = targetParticle.getCode();
+//   G4double          incidentMass = incidentParticle.getMass();
+//   G4double        incidentEnergy = incidentParticle.getEnergy();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   static G4bool first = true;
+   static G4double protmul[numMul],  protnorm[numSec];   // proton constants
+   static G4double protmulAn[numMulAn],protnormAn[numSec];
+   static G4double neutmul[numMul],  neutnorm[numSec];   // neutron constants
+   static G4double neutmulAn[numMulAn],neutnormAn[numSec];
+                              //  misc. local variables
+                              //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+   G4int i, counter, nt, np, nm, nz;
+{
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
+  static const G4double protb = 0.7;
+  static const G4double neutb = 0.7;
+  static const G4double     c = 1.25;
+  static const G4int numMul   = 1200;
+  static const G4int numMulAn = 400;
+  static const G4int numSec   = 60;
+  G4int neutronCode = Neutron.getCode();
+  G4int protonCode = Proton.getCode();
+  G4int targetCode = targetParticle.getCode();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  static G4bool first = true;
+  static G4double protmul[numMul],  protnorm[numSec];   // proton constants
+  static G4double protmulAn[numMulAn],protnormAn[numSec];
+  static G4double neutmul[numMul],  neutnorm[numSec];   // neutron constants
+  static G4double neutmulAn[numMulAn],neutnormAn[numSec];
+  //  misc. local variables
+  //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  G4int i, counter, nt, np, nm, nz;
    if( first )
      {                         // compute normalization constants, this will only be done once
+     {                 // compute normalization constants, this will only be done once
        first = false;
        for( i=0; i<numMul  ; i++ ) protmul[i]  = 0.0;

trunk/source/processes/hadronic/models/high_energy/src/G4HEAntiOmegaMinusInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HEAntiOmegaMinusInelastic.cc,v 1.15 2008/03/17 20:49:17 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HEAntiOmegaMinusInelastic.cc,v 1.17 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model.  Not included is the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 // First work done by J.L.Chuma and F.W.Jones, TRIUMF, June 96.
 // H. Fesefeldt, RWTH-Aachen, 23-October-1996
 …
 #include "G4HEAntiOmegaMinusInelastic.hh"
+G4HadFinalState *  G4HEAntiOmegaMinusInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
+    const G4HadProjectile *aParticle = &aTrack;
+//    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
+    const G4double atomicWeight = targetNucleus.GetN();
+    const G4double atomicNumber = targetNucleus.GetZ();
+    G4HEVector incidentParticle(aParticle);
+    G4int    incidentCode          = incidentParticle.getCode();
+    G4double incidentMass          = incidentParticle.getMass();
+    G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+    if(incidentKineticEnergy < 1.)
+      {
+        G4cout << "GHEAntiOmegaMinusInelastic: incident energy < 1 GeV" << G4endl;
+      }
+    if(verboseLevel > 1)
+      {
+G4HadFinalState*
+G4HEAntiOmegaMinusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                           G4Nucleus& targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
+  const G4double atomicWeight = targetNucleus.GetN();
+  const G4double atomicNumber = targetNucleus.GetZ();
+  G4HEVector incidentParticle(aParticle);
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+  if (incidentKineticEnergy < 1.)
+    G4cout << "GHEAntiOmegaMinusInelastic: incident energy < 1 GeV" << G4endl;
+  if (verboseLevel > 1) {
         G4cout << "G4HEAntiOmegaMinusInelastic::ApplyYourself" << G4endl;
         G4cout << "incident particle " << incidentParticle.getName()
 …
         G4cout << "target material with (A,Z) = ("
              << atomicWeight << "," << atomicNumber << ")" << G4endl;
+      }
+  }
     G4double inelasticity  = NuclearInelasticity(incidentKineticEnergy,
                                                  atomicWeight, atomicNumber);
     if(verboseLevel > 1)
         G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+  G4double inelasticity = NuclearInelasticity(incidentKineticEnergy,
+                                              atomicWeight, atomicNumber);
+  if (verboseLevel > 1)
+    G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
     incidentKineticEnergy -= inelasticity;
+  incidentKineticEnergy -= inelasticity;
     G4double excitationEnergyGNP = 0.;
     G4double excitationEnergyDTA = 0.;
     G4double excitation    = NuclearExcitation(incidentKineticEnergy,
                                                atomicWeight, atomicNumber,
                                                excitationEnergyGNP,
                                                excitationEnergyDTA);
     if(verboseLevel > 1)
       G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+  G4double excitationEnergyGNP = 0.;
+  G4double excitationEnergyDTA = 0.;
+  G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                          atomicWeight, atomicNumber,
+                                          excitationEnergyGNP,
+                                          excitationEnergyDTA);
+  if (verboseLevel > 1)
+    G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
            << excitationEnergyDTA << G4endl;
+    incidentKineticEnergy -= excitation;
+    incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+    G4HEVector targetParticle;
+    if(G4UniformRand() < atomicNumber/atomicWeight)
+      {
+        targetParticle.setDefinition("Proton");
+      }
+    else
+      {
+        targetParticle.setDefinition("Neutron");
+      }
+    G4double targetMass         = targetParticle.getMass();
+    G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+    G4double availableEnergy    = centerOfMassEnergy - targetMass - incidentMass;
+                                                                // this was the meaning of inElastic in the
+                                                                // original Gheisha stand-alone version.
+//    G4bool   inElastic          = InElasticCrossSectionInFirstInt
+//                                    (availableEnergy, incidentCode, incidentTotalMomentum);
+                                                                // by unknown reasons, it has been replaced
+                                                                // to the following code in Geant???
+    G4bool inElastic = true;
+//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+    vecLength = 0;
+  incidentKineticEnergy -= excitation;
+  incidentTotalEnergy = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                    *(incidentTotalEnergy+incidentMass));
+  G4HEVector targetParticle;
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
+    targetParticle.setDefinition("Proton");
+  } else {
+    targetParticle.setDefinition("Neutron");
+  }
+  G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                        + targetMass*targetMass
+                                        + 2.0*targetMass*incidentTotalEnergy);
+  G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
+  G4bool inElastic = true;
+  vecLength = 0;
     if(verboseLevel > 1)
       G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
            << incidentCode << G4endl;
     G4bool successful = false;
+  G4bool successful = false;
+    if(inElastic || (!inElastic && atomicWeight < 1.5))
+      {
+        FirstIntInCasAntiOmegaMinus(inElastic, availableEnergy, pv, vecLength,
+                                    incidentParticle, targetParticle, atomicWeight);
+        if(verboseLevel > 1)
+           G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+        if ((vecLength > 0) && (availableEnergy > 1.))
+                   StrangeParticlePairProduction( availableEnergy, centerOfMassEnergy,
+                                                  pv, vecLength,
+                                                  incidentParticle, targetParticle);
+            HighEnergyCascading( successful, pv, vecLength,
+                                 excitationEnergyGNP, excitationEnergyDTA,
+                                 incidentParticle, targetParticle,
+                                 atomicWeight, atomicNumber);
+        if (!successful)
+            HighEnergyClusterProduction( successful, pv, vecLength,
+                                         excitationEnergyGNP, excitationEnergyDTA,
+                                         incidentParticle, targetParticle,
+                                         atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyCascading( successful, pv, vecLength,
+                                   excitationEnergyGNP, excitationEnergyDTA,
+                                   incidentParticle, targetParticle,
+                                   atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyClusterProduction( successful, pv, vecLength,
+                                           excitationEnergyGNP, excitationEnergyDTA,
+                                           incidentParticle, targetParticle,
+                                           atomicWeight, atomicNumber);
+        if (!successful)
+            QuasiElasticScattering( successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+            ElasticScattering( successful, pv, vecLength,
+                               incidentParticle,
+                               atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+        G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles" << G4endl;
+      }
+      FillParticleChange(pv,  vecLength);
+      delete [] pv;
+      theParticleChange.SetStatusChange(stopAndKill);
+      return & theParticleChange;
+  }
+  FirstIntInCasAntiOmegaMinus(inElastic, availableEnergy, pv, vecLength,
+                              incidentParticle, targetParticle, atomicWeight);
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+                                  incidentParticle, targetParticle,
+                                  atomicWeight, atomicNumber);
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
+  if (!successful)
+    ElasticScattering(successful, pv, vecLength,
+                      incidentParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+           << G4endl;
+  FillParticleChange(pv,  vecLength);
+  delete [] pv;
+  theParticleChange.SetStatusChange(stopAndKill);
+  return &theParticleChange;
+}
 void
 G4HEAntiOmegaMinusInelastic::FirstIntInCasAntiOmegaMinus( G4bool &inElastic,
                                                           const G4double availableEnergy,
                                                           G4HEVector pv[],
                                                           G4int &vecLen,
                                                           G4HEVector incidentParticle,
                                                           G4HEVector targetParticle,
                                                           const G4double atomicWeight )
+G4HEAntiOmegaMinusInelastic::FirstIntInCasAntiOmegaMinus(G4bool& inElastic,
+                                                         const G4double availableEnergy,
+                                                         G4HEVector pv[],
+                                                         G4int& vecLen,
+                                                         const G4HEVector& incidentParticle,
+                                                         const G4HEVector& targetParticle,
+                                                         const G4double atomicWeight)
 // AntiOmega undergoes interaction with nucleon within a nucleus.
 // As in Geant3, we think that this routine has absolutely no influence
 // on the whole performance of the program. Take AntiLambda instaed.
+ {
+   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
+   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+   static const G4double protb = 0.7;
+   static const G4double neutb = 0.7;
+   static const G4double     c = 1.25;
+   static const G4int   numMul   = 1200;
+   static const G4int   numMulAn = 400;
+   static const G4int   numSec   = 60;
+//   G4int              neutronCode = Neutron.getCode();
+   G4int              protonCode  = Proton.getCode();
+   G4int               targetCode = targetParticle.getCode();
+//   G4double          incidentMass = incidentParticle.getMass();
+//   G4double        incidentEnergy = incidentParticle.getEnergy();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   static G4bool first = true;
+   static G4double protmul[numMul],  protnorm[numSec];   // proton constants
+   static G4double protmulAn[numMulAn],protnormAn[numSec];
+   static G4double neutmul[numMul],  neutnorm[numSec];   // neutron constants
+   static G4double neutmulAn[numMulAn],neutnormAn[numSec];
+                              //  misc. local variables
+                              //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+{
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
+  static const G4double protb = 0.7;
+  static const G4double neutb = 0.7;
+  static const G4double     c = 1.25;
+  static const G4int numMul   = 1200;
+  static const G4int numMulAn = 400;
+  static const G4int numSec   = 60;
+  G4int protonCode = Proton.getCode();
+  G4int targetCode = targetParticle.getCode();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  static G4bool first = true;
+  static G4double protmul[numMul],  protnorm[numSec];   // proton constants
+  static G4double protmulAn[numMulAn],protnormAn[numSec];
+  static G4double neutmul[numMul],  neutnorm[numSec];   // neutron constants
+  static G4double neutmulAn[numMulAn],neutnormAn[numSec];
+  //  misc. local variables
+  //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
    G4int i, counter, nt, np, nm, nz;
    if( first )
      {                         // compute normalization constants, this will only be done once
+     {             // compute normalization constants, this will only be done once
        first = false;
        for( i=0; i<numMul  ; i++ ) protmul[i]  = 0.0;

trunk/source/processes/hadronic/models/high_energy/src/G4HEAntiProtonInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HEAntiProtonInelastic.cc,v 1.14 2008/03/17 20:49:17 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HEAntiProtonInelastic.cc,v 1.16 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model. Not included are the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 // First work done by J.L.Chuma and F.W.Jones, TRIUMF, June 96.
 // H. Fesefeldt, RWTH-Aachen, 23-October-1996
 …
 #include "G4HEAntiProtonInelastic.hh"
 G4HadFinalState *  G4HEAntiProtonInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
     const G4HadProjectile *aParticle = &aTrack;
 //    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
     const G4double atomicWeight = targetNucleus.GetN();
     const G4double atomicNumber  = targetNucleus.GetZ();
     G4HEVector incidentParticle(aParticle);
     G4int    incidentCode          = incidentParticle.getCode();
     G4double incidentMass          = incidentParticle.getMass();
     G4double incidentTotalEnergy   = incidentParticle.getEnergy();
     G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
     G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
     if(incidentKineticEnergy < 1.)
+      {
+        G4cout << "GHEAntiProtonInelastic: incident energy < 1 GeV" << G4endl;
+      }
     if(verboseLevel > 1)
+      {
         G4cout << "G4HEAntiProtonInelastic::ApplyYourself" << G4endl;
         G4cout << "incident particle " << incidentParticle.getName()
              << "mass "              << incidentMass
              << "kinetic energy "    << incidentKineticEnergy
              << G4endl;
         G4cout << "target material with (A,Z) = ("
+             << atomicWeight << "," << atomicNumber << ")" << G4endl;
+      }
     G4double inelasticity  = NuclearInelasticity(incidentKineticEnergy,
                                                  atomicWeight, atomicNumber);
+    if(verboseLevel > 1)
         G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+G4HadFinalState*
+G4HEAntiProtonInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                       G4Nucleus& targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
+  const G4double atomicWeight = targetNucleus.GetN();
+  const G4double atomicNumber = targetNucleus.GetZ();
+  G4HEVector incidentParticle(aParticle);
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+  if (incidentKineticEnergy < 1.)
+    G4cout << "GHEAntiProtonInelastic: incident energy < 1 GeV" << G4endl;
+  if (verboseLevel > 1) {
+    G4cout << "G4HEAntiProtonInelastic::ApplyYourself" << G4endl;
+    G4cout << "incident particle " << incidentParticle.getName()
+           << "mass "              << incidentMass
+           << "kinetic energy "    << incidentKineticEnergy
+           << G4endl;
+    G4cout << "target material with (A,Z) = ("
+           << atomicWeight << "," << atomicNumber << ")" << G4endl;
+  }
+  G4double inelasticity = NuclearInelasticity(incidentKineticEnergy,
+                                              atomicWeight, atomicNumber);
+  if (verboseLevel > 1)
+    G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+  incidentKineticEnergy -= inelasticity;
+    incidentKineticEnergy -= inelasticity;
+  G4double excitationEnergyGNP = 0.;
+  G4double excitationEnergyDTA = 0.;
+  G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                          atomicWeight, atomicNumber,
+                                          excitationEnergyGNP,
+                                          excitationEnergyDTA);
+  if (verboseLevel > 1)
+    G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+           << excitationEnergyDTA << G4endl;
+  incidentKineticEnergy -= excitation;
+  incidentTotalEnergy = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                    *(incidentTotalEnergy+incidentMass));
+  G4HEVector targetParticle;
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
+    targetParticle.setDefinition("Proton");
+  } else {
+    targetParticle.setDefinition("Neutron");
+  }
+  G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                        + targetMass*targetMass
+                                        + 2.0*targetMass*incidentTotalEnergy);
+  G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
+  G4bool inElastic = true;
+  vecLength = 0;
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+           << incidentCode << G4endl;
+  G4bool successful = false;
+    G4double excitationEnergyGNP = 0.;
+    G4double excitationEnergyDTA = 0.;
+    G4double excitation    = NuclearExcitation(incidentKineticEnergy,
+                                               atomicWeight, atomicNumber,
+                                               excitationEnergyGNP,
+                                               excitationEnergyDTA);
+    if(verboseLevel > 1)
+      G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+           << excitationEnergyDTA << G4endl;
+    incidentKineticEnergy -= excitation;
+    incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+    G4HEVector targetParticle;
+    if(G4UniformRand() < atomicNumber/atomicWeight)
+      {
+        targetParticle.setDefinition("Proton");
+      }
+    else
+      {
+        targetParticle.setDefinition("Neutron");
+      }
+    G4double targetMass         = targetParticle.getMass();
+    G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+    G4double availableEnergy    = centerOfMassEnergy - targetMass - incidentMass;
+                                                                // this was the meaning of inElastic in the
+                                                                // original Gheisha stand-alone version.
+//    G4bool   inElastic          = InElasticCrossSectionInFirstInt
+//                                    (availableEnergy, incidentCode, incidentTotalMomentum);
+                                                                // by unknown reasons, it has been replaced
+                                                                // to the following code in Geant???
+    G4bool inElastic = true;
+//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+    vecLength  = 0;
+    if(verboseLevel > 1)
+      G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+           << incidentCode << G4endl;
+    G4bool successful = false;
+    if(inElastic || (!inElastic && atomicWeight < 1.5))
+      {
+        FirstIntInCasAntiProton(inElastic, availableEnergy, pv, vecLength,
+                                incidentParticle, targetParticle, atomicWeight);
+        if(verboseLevel > 1)
+           G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+        if ((vecLength > 0) && (availableEnergy > 1.))
+                   StrangeParticlePairProduction( availableEnergy, centerOfMassEnergy,
+                                                  pv, vecLength,
+                                                  incidentParticle, targetParticle);
+            HighEnergyCascading( successful, pv, vecLength,
+                                 excitationEnergyGNP, excitationEnergyDTA,
+                                 incidentParticle, targetParticle,
+                                 atomicWeight, atomicNumber);
+        if (!successful)
+            HighEnergyClusterProduction( successful, pv, vecLength,
+                                         excitationEnergyGNP, excitationEnergyDTA,
+                                         incidentParticle, targetParticle,
+                                         atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyCascading( successful, pv, vecLength,
+                                   excitationEnergyGNP, excitationEnergyDTA,
+                                   incidentParticle, targetParticle,
+                                   atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyClusterProduction( successful, pv, vecLength,
+                                           excitationEnergyGNP, excitationEnergyDTA,
+                                           incidentParticle, targetParticle,
+                                           atomicWeight, atomicNumber);
+        if (!successful)
+            QuasiElasticScattering( successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+            ElasticScattering( successful, pv, vecLength,
+                               incidentParticle,
+                               atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+        G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles" << G4endl;
+      }
+      FillParticleChange(pv,  vecLength);
+      delete [] pv;
+      theParticleChange.SetStatusChange(stopAndKill);
+      return & theParticleChange;
+  }
+  FirstIntInCasAntiProton(inElastic, availableEnergy, pv, vecLength,
+                          incidentParticle, targetParticle, atomicWeight);
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+                                  incidentParticle, targetParticle,
+                                  atomicWeight, atomicNumber);
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
+  if (!successful)
+    ElasticScattering(successful, pv, vecLength,
+                      incidentParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+           << G4endl;
+  FillParticleChange(pv,  vecLength);
+  delete [] pv;
+  theParticleChange.SetStatusChange(stopAndKill);
+  return & theParticleChange;
+}
 void
 G4HEAntiProtonInelastic::FirstIntInCasAntiProton( G4bool &inElastic,
                                                   const G4double availableEnergy,
                                                   G4HEVector pv[],
                                                   G4int &vecLen,
                                                   G4HEVector incidentParticle,
                                                   G4HEVector targetParticle,
                                                   const G4double atomicWeight)
+G4HEAntiProtonInelastic::FirstIntInCasAntiProton(G4bool& inElastic,
+                                                 const G4double availableEnergy,
+                                                 G4HEVector pv[],
+                                                 G4int& vecLen,
+                                                 const G4HEVector& incidentParticle,
+                                                 const G4HEVector& targetParticle,
+                                                 const G4double atomicWeight)
 // AntiProton undergoes interaction with nucleon within a nucleus.  Check if it is
 …
 // protons/neutrons by kaons or strange baryons according to the average
 // multiplicity per inelastic reaction.
+ {
+   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
+   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+   static const G4double protb = 0.7;
+   static const G4double neutb = 0.7;
+   static const G4double     c = 1.25;
+   static const G4int   numMul   = 1200;
+   static const G4int   numMulAn = 400;
+   static const G4int   numSec   = 60;
+   G4int              neutronCode = Neutron.getCode();
+   G4int              protonCode  = Proton.getCode();
+   G4int               targetCode = targetParticle.getCode();
+//   G4double          incidentMass = incidentParticle.getMass();
+//   G4double        incidentEnergy = incidentParticle.getEnergy();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   static G4bool first = true;
+   static G4double protmul[numMul],  protnorm[numSec];   // proton constants
+   static G4double protmulAn[numMulAn],protnormAn[numSec];
+   static G4double neutmul[numMul],  neutnorm[numSec];   // neutron constants
+   static G4double neutmulAn[numMulAn],neutnormAn[numSec];
+                              //  misc. local variables
+                              //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+   G4int i, counter, nt, np, nm, nz;
+{
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
+  static const G4double protb = 0.7;
+  static const G4double neutb = 0.7;
+  static const G4double     c = 1.25;
+  static const G4int numMul   = 1200;
+  static const G4int numMulAn = 400;
+  static const G4int numSec   = 60;
+  G4int neutronCode = Neutron.getCode();
+  G4int protonCode  = Proton.getCode();
+  G4int targetCode = targetParticle.getCode();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  static G4bool first = true;
+  static G4double protmul[numMul],  protnorm[numSec];   // proton constants
+  static G4double protmulAn[numMulAn],protnormAn[numSec];
+  static G4double neutmul[numMul],  neutnorm[numSec];   // neutron constants
+  static G4double neutmulAn[numMulAn],neutnormAn[numSec];
+  //  misc. local variables
+  //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  G4int i, counter, nt, np, nm, nz;
    if( first )
      {                         // compute normalization constants, this will only be done once
+     {             // compute normalization constants, this will only be done once
        first = false;
        for( i=0; i<numMul  ; i++ ) protmul[i]  = 0.0;

trunk/source/processes/hadronic/models/high_energy/src/G4HEAntiSigmaMinusInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HEAntiSigmaMinusInelastic.cc,v 1.15 2008/03/17 20:49:17 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HEAntiSigmaMinusInelastic.cc,v 1.17 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model. Not included are the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 // First work done by J.L.Chuma and F.W.Jones, TRIUMF, June 96.
 // H. Fesefeldt, RWTH-Aachen, 23-October-1996
 …
 #include "G4HEAntiSigmaMinusInelastic.hh"
+G4HadFinalState *  G4HEAntiSigmaMinusInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
+    const G4HadProjectile *aParticle = &aTrack;
+//    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
+    const G4double atomicWeight = targetNucleus.GetN();
+    const G4double atomicNumber = targetNucleus.GetZ();
+    G4HEVector incidentParticle(aParticle);
+    G4int    incidentCode          = incidentParticle.getCode();
+    G4double incidentMass          = incidentParticle.getMass();
+    G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+    if(incidentKineticEnergy < 1.)
+      {
+        G4cout << "GHEAntiSigmaMinusInelastic: incident energy < 1 GeV" << G4endl;
+      }
+    if(verboseLevel > 1)
+      {
+        G4cout << "G4HEAntiSigmaMinusInelastic::ApplyYourself" << G4endl;
+        G4cout << "incident particle " << incidentParticle.getName()
+             << "mass "              << incidentMass
+             << "kinetic energy "    << incidentKineticEnergy
+             << G4endl;
+        G4cout << "target material with (A,Z) = ("
+             << atomicWeight << "," << atomicNumber << ")" << G4endl;
+      }
+G4HadFinalState*
+G4HEAntiSigmaMinusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                           G4Nucleus& targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
+  const G4double atomicWeight = targetNucleus.GetN();
+  const G4double atomicNumber = targetNucleus.GetZ();
+  G4HEVector incidentParticle(aParticle);
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+  if (incidentKineticEnergy < 1.)
+    G4cout << "GHEAntiSigmaMinusInelastic: incident energy < 1 GeV" << G4endl;
+  if (verboseLevel > 1) {
+    G4cout << "G4HEAntiSigmaMinusInelastic::ApplyYourself" << G4endl;
+    G4cout << "incident particle " << incidentParticle.getName()
+           << "mass "              << incidentMass
+           << "kinetic energy "    << incidentKineticEnergy
+           << G4endl;
+    G4cout << "target material with (A,Z) = ("
+           << atomicWeight << "," << atomicNumber << ")" << G4endl;
+  }
     G4double inelasticity  = NuclearInelasticity(incidentKineticEnergy,
                                                  atomicWeight, atomicNumber);
     if(verboseLevel > 1)
         G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+  G4double inelasticity = NuclearInelasticity(incidentKineticEnergy,
+                                              atomicWeight, atomicNumber);
+  if (verboseLevel > 1)
+    G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
     incidentKineticEnergy -= inelasticity;
+  incidentKineticEnergy -= inelasticity;
+    G4double excitationEnergyGNP = 0.;
+    G4double excitationEnergyDTA = 0.;
+    G4double excitation    = NuclearExcitation(incidentKineticEnergy,
+                                               atomicWeight, atomicNumber,
+                                               excitationEnergyGNP,
+                                               excitationEnergyDTA);
+    if(verboseLevel > 1)
+      G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+           << excitationEnergyDTA << G4endl;
+    incidentKineticEnergy -= excitation;
+    incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+    G4HEVector targetParticle;
+    if(G4UniformRand() < atomicNumber/atomicWeight)
+      {
+        targetParticle.setDefinition("Proton");
+      }
+    else
+      {
+        targetParticle.setDefinition("Neutron");
+      }
+    G4double targetMass         = targetParticle.getMass();
+    G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+    G4double availableEnergy    = centerOfMassEnergy - targetMass - incidentMass;
+                                                                // this was the meaning of inElastic in the
+                                                                // original Gheisha stand-alone version.
+//    G4bool   inElastic          = InElasticCrossSectionInFirstInt
+//                                    (availableEnergy, incidentCode, incidentTotalMomentum);
+                                                                // by unknown reasons, it has been replaced
+                                                                // to the following code in Geant???
+    G4bool inElastic = true;
+//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+    vecLength  = 0;
+  G4double excitationEnergyGNP = 0.;
+  G4double excitationEnergyDTA = 0.;
+  G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                          atomicWeight, atomicNumber,
+                                          excitationEnergyGNP,
+                                          excitationEnergyDTA);
+ if (verboseLevel > 1)
+   G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+          << excitationEnergyDTA << G4endl;
+  incidentKineticEnergy -= excitation;
+  incidentTotalEnergy = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                    *(incidentTotalEnergy+incidentMass));
+  G4HEVector targetParticle;
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
+    targetParticle.setDefinition("Proton");
+  } else {
+    targetParticle.setDefinition("Neutron");
+  }
+  G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                        + targetMass*targetMass
+                                        + 2.0*targetMass*incidentTotalEnergy);
+  G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
+  G4bool inElastic = true;
+  vecLength  = 0;
     if(verboseLevel > 1)
       G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
            << incidentCode << G4endl;
     G4bool successful = false;
+  G4bool successful = false;
+    if(inElastic || (!inElastic && atomicWeight < 1.5))
+      {
+        FirstIntInCasAntiSigmaMinus(inElastic, availableEnergy, pv, vecLength,
+                                    incidentParticle, targetParticle, atomicWeight);
+        if(verboseLevel > 1)
+           G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+        if ((vecLength > 0) && (availableEnergy > 1.))
+                   StrangeParticlePairProduction( availableEnergy, centerOfMassEnergy,
+                                                  pv, vecLength,
+                                                  incidentParticle, targetParticle);
+            HighEnergyCascading( successful, pv, vecLength,
+                                 excitationEnergyGNP, excitationEnergyDTA,
+                                 incidentParticle, targetParticle,
+                                 atomicWeight, atomicNumber);
+        if (!successful)
+            HighEnergyClusterProduction( successful, pv, vecLength,
+                                         excitationEnergyGNP, excitationEnergyDTA,
+                                         incidentParticle, targetParticle,
+                                         atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyCascading( successful, pv, vecLength,
+                                   excitationEnergyGNP, excitationEnergyDTA,
+                                   incidentParticle, targetParticle,
+                                   atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyClusterProduction( successful, pv, vecLength,
+                                           excitationEnergyGNP, excitationEnergyDTA,
+                                           incidentParticle, targetParticle,
+                                           atomicWeight, atomicNumber);
+        if (!successful)
+            QuasiElasticScattering( successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+            ElasticScattering( successful, pv, vecLength,
+                               incidentParticle,
+                               atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+         G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles" << G4endl;
+      }
+      FillParticleChange(pv,  vecLength);
+      delete [] pv;
+      theParticleChange.SetStatusChange(stopAndKill);
+      return & theParticleChange;
+  }
+  FirstIntInCasAntiSigmaMinus(inElastic, availableEnergy, pv, vecLength,
+                              incidentParticle, targetParticle, atomicWeight);
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+                                  incidentParticle, targetParticle,
+                                  atomicWeight, atomicNumber);
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
+  if (!successful)
+    ElasticScattering(successful, pv, vecLength,
+                      incidentParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+           << G4endl;
+  FillParticleChange(pv,  vecLength);
+  delete [] pv;
+  theParticleChange.SetStatusChange(stopAndKill);
+  return &theParticleChange;
+}
 void
 G4HEAntiSigmaMinusInelastic::FirstIntInCasAntiSigmaMinus( G4bool &inElastic,
                                                           const G4double availableEnergy,
                                                           G4HEVector pv[],
                                                           G4int &vecLen,
                                                           G4HEVector incidentParticle,
                                                           G4HEVector targetParticle,
                                                           const G4double atomicWeight)
+G4HEAntiSigmaMinusInelastic::FirstIntInCasAntiSigmaMinus(G4bool& inElastic,
+                                                         const G4double availableEnergy,
+                                                         G4HEVector pv[],
+                                                         G4int& vecLen,
+                                                         const G4HEVector& incidentParticle,
+                                                         const G4HEVector& targetParticle,
+                                                         const G4double atomicWeight)
 // AntiSigma- undergoes interaction with nucleon within a nucleus.  Check if it is
 …
 // protons/neutrons by kaons or strange baryons according to the average
 // multiplicity per inelastic reaction.
+ {
+   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
+   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+   static const G4double protb = 0.7;
+   static const G4double neutb = 0.7;
+   static const G4double     c = 1.25;
+   static const G4int   numMul   = 1200;
+   static const G4int   numMulAn = 400;
+   static const G4int   numSec   = 60;
+   G4int              neutronCode = Neutron.getCode();
+   G4int              protonCode  = Proton.getCode();
+   G4int               targetCode = targetParticle.getCode();
+//   G4double          incidentMass = incidentParticle.getMass();
+//   G4double        incidentEnergy = incidentParticle.getEnergy();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   static G4bool first = true;
+   static G4double protmul[numMul],  protnorm[numSec];   // proton constants
+   static G4double protmulAn[numMulAn],protnormAn[numSec];
+   static G4double neutmul[numMul],  neutnorm[numSec];   // neutron constants
+   static G4double neutmulAn[numMulAn],neutnormAn[numSec];
+                              //  misc. local variables
+                              //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+   G4int i, counter, nt, np, nm, nz;
+{
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
+  static const G4double protb = 0.7;
+  static const G4double neutb = 0.7;
+  static const G4double     c = 1.25;
+  static const G4int numMul   = 1200;
+  static const G4int numMulAn = 400;
+  static const G4int numSec   = 60;
+  G4int neutronCode = Neutron.getCode();
+  G4int protonCode  = Proton.getCode();
+  G4int targetCode = targetParticle.getCode();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  static G4bool first = true;
+  static G4double protmul[numMul],  protnorm[numSec];   // proton constants
+  static G4double protmulAn[numMulAn],protnormAn[numSec];
+  static G4double neutmul[numMul],  neutnorm[numSec];   // neutron constants
+  static G4double neutmulAn[numMulAn],neutnormAn[numSec];
+  //  misc. local variables
+  //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  G4int i, counter, nt, np, nm, nz;
    if( first )
      {                         // compute normalization constants, this will only be done once
+     {               // compute normalization constants, this will only be done once
        first = false;
        for( i=0; i<numMul  ; i++ ) protmul[i]  = 0.0;

trunk/source/processes/hadronic/models/high_energy/src/G4HEAntiSigmaPlusInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HEAntiSigmaPlusInelastic.cc,v 1.15 2008/03/17 20:49:17 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HEAntiSigmaPlusInelastic.cc,v 1.17 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model. Not included are the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 // First work done by J.L.Chuma and F.W.Jones, TRIUMF, June 96.
 // H. Fesefeldt, RWTH-Aachen, 23-October-1996
 …
 #include "G4HEAntiSigmaPlusInelastic.hh"
+G4HadFinalState *  G4HEAntiSigmaPlusInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
+    const G4HadProjectile *aParticle = &aTrack;
+//    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
+    const G4double atomicWeight = targetNucleus.GetN();
+    const G4double atomicNumber = targetNucleus.GetZ();
+    G4HEVector incidentParticle(aParticle);
+    G4int    incidentCode          = incidentParticle.getCode();
+    G4double incidentMass          = incidentParticle.getMass();
+    G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+    if(incidentKineticEnergy < 1.)
+      {
+        G4cout << "GHEAntiSigmaPlusInelastic: incident energy < 1 GeV" << G4endl;
+      }
+    if(verboseLevel > 1)
+      {
+        G4cout << "G4HEAntiSigmaPlusInelastic::ApplyYourself" << G4endl;
+        G4cout << "incident particle " << incidentParticle.getName()
+             << "mass "              << incidentMass
+             << "kinetic energy "    << incidentKineticEnergy
+             << G4endl;
+        G4cout << "target material with (A,Z) = ("
+             << atomicWeight << "," << atomicNumber << ")" << G4endl;
+      }
+    G4double inelasticity  = NuclearInelasticity(incidentKineticEnergy,
+                                                 atomicWeight, atomicNumber);
+    if(verboseLevel > 1)
+        G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+    incidentKineticEnergy -= inelasticity;
+G4HadFinalState*
+G4HEAntiSigmaPlusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                          G4Nucleus& targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
+  const G4double atomicWeight = targetNucleus.GetN();
+  const G4double atomicNumber = targetNucleus.GetZ();
+  G4HEVector incidentParticle(aParticle);
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+  if (incidentKineticEnergy < 1.)
+    G4cout << "GHEAntiSigmaPlusInelastic: incident energy < 1 GeV" << G4endl;
+  if (verboseLevel > 1) {
+    G4cout << "G4HEAntiSigmaPlusInelastic::ApplyYourself" << G4endl;
+    G4cout << "incident particle " << incidentParticle.getName()
+           << "mass "              << incidentMass
+           << "kinetic energy "    << incidentKineticEnergy
+           << G4endl;
+    G4cout << "target material with (A,Z) = ("
+           << atomicWeight << "," << atomicNumber << ")" << G4endl;
+  }
+  G4double inelasticity = NuclearInelasticity(incidentKineticEnergy,
+                                              atomicWeight, atomicNumber);
+  if (verboseLevel > 1)
+    G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+  incidentKineticEnergy -= inelasticity;
     G4double excitationEnergyGNP = 0.;
     G4double excitationEnergyDTA = 0.;
     G4double excitation    = NuclearExcitation(incidentKineticEnergy,
                                                atomicWeight, atomicNumber,
                                                excitationEnergyGNP,
                                                excitationEnergyDTA);
     if(verboseLevel > 1)
       G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+  G4double excitationEnergyGNP = 0.;
+  G4double excitationEnergyDTA = 0.;
+  G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                          atomicWeight, atomicNumber,
+                                          excitationEnergyGNP,
+                                          excitationEnergyDTA);
+  if (verboseLevel > 1)
+    G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
            << excitationEnergyDTA << G4endl;
+    incidentKineticEnergy -= excitation;
+    incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+    G4HEVector targetParticle;
+    if(G4UniformRand() < atomicNumber/atomicWeight)
+      {
+        targetParticle.setDefinition("Proton");
+      }
+    else
+      {
+        targetParticle.setDefinition("Neutron");
+      }
+    G4double targetMass         = targetParticle.getMass();
+    G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+    G4double availableEnergy    = centerOfMassEnergy - targetMass - incidentMass;
+                                                                // this was the meaning of inElastic in the
+                                                                // original Gheisha stand-alone version.
+//    G4bool   inElastic          = InElasticCrossSectionInFirstInt
+//                                    (availableEnergy, incidentCode, incidentTotalMomentum);
+                                                                // by unknown reasons, it has been replaced
+                                                                // to the following code in Geant???
+    G4bool inElastic = true;
+//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+    vecLength = 0;
+  incidentKineticEnergy -= excitation;
+  incidentTotalEnergy = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                    *(incidentTotalEnergy+incidentMass));
+  G4HEVector targetParticle;
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
+    targetParticle.setDefinition("Proton");
+  } else {
+    targetParticle.setDefinition("Neutron");
+  }
+  G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                        + targetMass*targetMass
+                                        + 2.0*targetMass*incidentTotalEnergy);
+  G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
+  G4bool inElastic = true;
+  vecLength = 0;
     if(verboseLevel > 1)
       G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
            << incidentCode << G4endl;
     G4bool successful = false;
+  G4bool successful = false;
+    if(inElastic || (!inElastic && atomicWeight < 1.5))
+      {
+        FirstIntInCasAntiSigmaPlus(inElastic, availableEnergy, pv, vecLength,
+                                   incidentParticle, targetParticle, atomicWeight);
+        if(verboseLevel > 1)
+           G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+        if ((vecLength > 0) && (availableEnergy > 1.))
+                   StrangeParticlePairProduction( availableEnergy, centerOfMassEnergy,
+                                                  pv, vecLength,
+                                                  incidentParticle, targetParticle);
+            HighEnergyCascading( successful, pv, vecLength,
+                                 excitationEnergyGNP, excitationEnergyDTA,
+                                 incidentParticle, targetParticle,
+                                 atomicWeight, atomicNumber);
+        if (!successful)
+            HighEnergyClusterProduction( successful, pv, vecLength,
+                                         excitationEnergyGNP, excitationEnergyDTA,
+                                         incidentParticle, targetParticle,
+                                         atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyCascading( successful, pv, vecLength,
+                                   excitationEnergyGNP, excitationEnergyDTA,
+                                   incidentParticle, targetParticle,
+                                   atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyClusterProduction( successful, pv, vecLength,
+                                           excitationEnergyGNP, excitationEnergyDTA,
+                                           incidentParticle, targetParticle,
+                                           atomicWeight, atomicNumber);
+        if (!successful)
+            QuasiElasticScattering( successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+            ElasticScattering( successful, pv, vecLength,
+                               incidentParticle,
+                               atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+        G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles" << G4endl;
+      }
+      FillParticleChange(pv,  vecLength);
+      delete [] pv;
+      theParticleChange.SetStatusChange(stopAndKill);
+      return & theParticleChange;
+  }
+  FirstIntInCasAntiSigmaPlus(inElastic, availableEnergy, pv, vecLength,
+                             incidentParticle, targetParticle, atomicWeight);
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+                                  incidentParticle, targetParticle,
+                                  atomicWeight, atomicNumber);
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
+  if (!successful)
+    ElasticScattering(successful, pv, vecLength,
+                      incidentParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+           << G4endl;
+  FillParticleChange(pv,  vecLength);
+  delete [] pv;
+  theParticleChange.SetStatusChange(stopAndKill);
+  return &theParticleChange;
+}
 void
 G4HEAntiSigmaPlusInelastic::FirstIntInCasAntiSigmaPlus( G4bool &inElastic,
                                                         const G4double availableEnergy,
                                                         G4HEVector pv[],
                                                         G4int &vecLen,
                                                         G4HEVector incidentParticle,
                                                         G4HEVector targetParticle,
                                                         const G4double atomicWeight)
+G4HEAntiSigmaPlusInelastic::FirstIntInCasAntiSigmaPlus(G4bool& inElastic,
+                                                       const G4double availableEnergy,
+                                                       G4HEVector pv[],
+                                                       G4int& vecLen,
+                                                       const G4HEVector& incidentParticle,
+                                                       const G4HEVector& targetParticle,
+                                                       const G4double atomicWeight)
 // AntiSigma+ undergoes interaction with nucleon within a nucleus.  Check if it is
 …
 // protons/neutrons by kaons or strange baryons according to the average
 // multiplicity per inelastic reaction.
+ {
+   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
+   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+   static const G4double protb = 0.7;
+   static const G4double neutb = 0.7;
+   static const G4double     c = 1.25;
+   static const G4int   numMul   = 1200;
+   static const G4int   numMulAn = 400;
+   static const G4int   numSec   = 60;
+//   G4int              neutronCode = Neutron.getCode();
+   G4int              protonCode  = Proton.getCode();
+   G4int               targetCode = targetParticle.getCode();
+//   G4double          incidentMass = incidentParticle.getMass();
+//   G4double        incidentEnergy = incidentParticle.getEnergy();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   static G4bool first = true;
+   static G4double protmul[numMul],  protnorm[numSec];   // proton constants
+   static G4double protmulAn[numMulAn],protnormAn[numSec];
+   static G4double neutmul[numMul],  neutnorm[numSec];   // neutron constants
+   static G4double neutmulAn[numMulAn],neutnormAn[numSec];
+                              //  misc. local variables
+                              //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+   G4int i, counter, nt, np, nm, nz;
+{
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
+  static const G4double protb = 0.7;
+  static const G4double neutb = 0.7;
+  static const G4double     c = 1.25;
+  static const G4int numMul   = 1200;
+  static const G4int numMulAn = 400;
+  static const G4int numSec   = 60;
+  G4int protonCode  = Proton.getCode();
+  G4int targetCode = targetParticle.getCode();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  static G4bool first = true;
+  static G4double protmul[numMul],  protnorm[numSec];   // proton constants
+  static G4double protmulAn[numMulAn],protnormAn[numSec];
+  static G4double neutmul[numMul],  neutnorm[numSec];   // neutron constants
+  static G4double neutmulAn[numMulAn],neutnormAn[numSec];
+  //  misc. local variables
+  //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  G4int i, counter, nt, np, nm, nz;
    if( first )
      {                         // compute normalization constants, this will only be done once
+     {         // compute normalization constants, this will only be done once
        first = false;
        for( i=0; i<numMul  ; i++ ) protmul[i]  = 0.0;

trunk/source/processes/hadronic/models/high_energy/src/G4HEAntiSigmaZeroInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HEAntiSigmaZeroInelastic.cc,v 1.10 2006/06/29 20:30:08 gunter Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HEAntiSigmaZeroInelastic.cc,v 1.11 2010/11/20 04:01:33 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model.  Not included is the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 // First work done by J.L.Chuma and F.W.Jones, TRIUMF, June 96.
 // H. Fesefeldt, RWTH-Aachen, 23-October-1996
 …
 #include "G4Gamma.hh"
+G4HadFinalState *  G4HEAntiSigmaZeroInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
+    const G4HadProjectile *aParticle = &aTrack;
+    G4HEVector incidentParticle(aParticle);
+    G4HEAntiLambdaInelastic theAntiLambdaInelastic;
+    theAntiLambdaInelastic.SetMaxNumberOfSecondaries(MAXPART);
+    theAntiLambdaInelastic.SetVerboseLevel(verboseLevel);
+G4HadFinalState*
+G4HEAntiSigmaZeroInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                          G4Nucleus& targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile *aParticle = &aTrack;
+  G4HEVector incidentParticle(aParticle);
+  G4HEAntiLambdaInelastic theAntiLambdaInelastic;
+  theAntiLambdaInelastic.SetMaxNumberOfSecondaries(MAXPART);
+  theAntiLambdaInelastic.SetVerboseLevel(verboseLevel);
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double pgam = G4UniformRand()*incidentTotalMomentum*0.75;
+    G4HEVector incidentAntiLambda;
+    incidentAntiLambda.SmulAndUpdate( incidentParticle,
+                                     (incidentTotalMomentum - pgam)/incidentTotalMomentum);
+    G4DynamicParticle * aLambda = new G4DynamicParticle();
+    aLambda->SetDefinition(G4AntiLambda::AntiLambda());
+    aLambda->SetMomentum(incidentAntiLambda.getMomentum());
+    G4HadProjectile aLambdaTrack(*aLambda);
+    G4HadFinalState * result = theAntiLambdaInelastic.ApplyYourself(aLambdaTrack, targetNucleus);
+    vecLength = theAntiLambdaInelastic.GetNumberOfSecondaries();
+    pv[vecLength] = Gamma;
+    pv[vecLength].setMomentum(incidentParticle.getMomentum());
+    pv[vecLength].SmulAndUpdate( pv[vecLength],pgam/incidentTotalMomentum);
+    G4DynamicParticle * aPhoton = new G4DynamicParticle();
+    aPhoton->SetDefinition(G4Gamma::Gamma());
+    aPhoton->SetMomentum(pv[vecLength].getMomentum());
+    result->AddSecondary(aPhoton);
+      delete [] pv;
+    return result;
+  }
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double pgam = G4UniformRand()*incidentTotalMomentum*0.75;
+  G4HEVector incidentAntiLambda;
+  incidentAntiLambda.SmulAndUpdate(incidentParticle,
+                                   (incidentTotalMomentum - pgam)/incidentTotalMomentum);
+  G4DynamicParticle* aLambda = new G4DynamicParticle();
+  aLambda->SetDefinition(G4AntiLambda::AntiLambda());
+  aLambda->SetMomentum(incidentAntiLambda.getMomentum());
+  G4HadProjectile aLambdaTrack(*aLambda);
+  G4HadFinalState* result = theAntiLambdaInelastic.ApplyYourself(aLambdaTrack, targetNucleus);
+  vecLength = theAntiLambdaInelastic.GetNumberOfSecondaries();
+  pv[vecLength] = Gamma;
+  pv[vecLength].setMomentum(incidentParticle.getMomentum());
+  pv[vecLength].SmulAndUpdate( pv[vecLength],pgam/incidentTotalMomentum);
+  G4DynamicParticle * aPhoton = new G4DynamicParticle();
+  aPhoton->SetDefinition(G4Gamma::Gamma());
+  aPhoton->SetMomentum(pv[vecLength].getMomentum());
+  result->AddSecondary(aPhoton);
+  delete [] pv;
+  return result;
+}

trunk/source/processes/hadronic/models/high_energy/src/G4HEAntiXiMinusInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HEAntiXiMinusInelastic.cc,v 1.15 2008/03/17 20:49:17 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HEAntiXiMinusInelastic.cc,v 1.17 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model. Not included are the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 // First work done by J.L.Chuma and F.W.Jones, TRIUMF, June 96.
 // H. Fesefeldt, RWTH-Aachen, 23-October-1996
 …
 #include "G4HEAntiXiMinusInelastic.hh"
 G4HadFinalState *  G4HEAntiXiMinusInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
     const G4HadProjectile *aParticle = &aTrack;
 //    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
     const G4double A = targetNucleus.GetN();
     const G4double Z = targetNucleus.GetZ();
     G4HEVector incidentParticle(aParticle);
+G4HadFinalState*
+G4HEAntiXiMinusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                        G4Nucleus& targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
+  const G4double A = targetNucleus.GetN();
+  const G4double Z = targetNucleus.GetZ();
+  G4HEVector incidentParticle(aParticle);
+    G4double atomicNumber = Z;
+    G4double atomicWeight = A;
+    G4int    incidentCode          = incidentParticle.getCode();
+    G4double incidentMass          = incidentParticle.getMass();
+    G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+    if(incidentKineticEnergy < 1.)
+      {
+        G4cout << "GHEAntiXiMinusInelastic: incident energy < 1 GeV" << G4endl;
+      }
+    if(verboseLevel > 1)
+      {
+        G4cout << "G4HEAntiXiMinusInelastic::ApplyYourself" << G4endl;
+        G4cout << "incident particle " << incidentParticle.getName()
+             << "mass "              << incidentMass
+             << "kinetic energy "    << incidentKineticEnergy
+             << G4endl;
+        G4cout << "target material with (A,Z) = ("
+             << atomicWeight << "," << atomicNumber << ")" << G4endl;
+      }
+    G4double inelasticity  = NuclearInelasticity(incidentKineticEnergy,
+                                                 atomicWeight, atomicNumber);
+    if(verboseLevel > 1)
+        G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+  G4double atomicNumber = Z;
+  G4double atomicWeight = A;
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+  if (incidentKineticEnergy < 1.)
+    G4cout << "GHEAntiXiMinusInelastic: incident energy < 1 GeV" << G4endl;
+  if (verboseLevel > 1) {
+    G4cout << "G4HEAntiXiMinusInelastic::ApplyYourself" << G4endl;
+    G4cout << "incident particle " << incidentParticle.getName()
+           << "mass "              << incidentMass
+           << "kinetic energy "    << incidentKineticEnergy
+           << G4endl;
+    G4cout << "target material with (A,Z) = ("
+           << atomicWeight << "," << atomicNumber << ")" << G4endl;
+  }
+  G4double inelasticity = NuclearInelasticity(incidentKineticEnergy,
+                                              atomicWeight, atomicNumber);
+  if (verboseLevel > 1)
+    G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
     incidentKineticEnergy -= inelasticity;
+  incidentKineticEnergy -= inelasticity;
+    G4double excitationEnergyGNP = 0.;
+    G4double excitationEnergyDTA = 0.;
+    G4double excitation    = NuclearExcitation(incidentKineticEnergy,
+                                               atomicWeight, atomicNumber,
+                                               excitationEnergyGNP,
+                                               excitationEnergyDTA);
+    if(verboseLevel > 1)
+      G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+           << excitationEnergyDTA << G4endl;
+    incidentKineticEnergy -= excitation;
+    incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+    G4HEVector targetParticle;
+    if(G4UniformRand() < atomicNumber/atomicWeight)
+      {
+        targetParticle.setDefinition("Proton");
+      }
+    else
+      {
+        targetParticle.setDefinition("Neutron");
+      }
+    G4double targetMass         = targetParticle.getMass();
+    G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+    G4double availableEnergy    = centerOfMassEnergy - targetMass - incidentMass;
+                                                                // this was the meaning of inElastic in the
+                                                                // original Gheisha stand-alone version.
+//    G4bool   inElastic          = InElasticCrossSectionInFirstInt
+//                                    (availableEnergy, incidentCode, incidentTotalMomentum);
+                                                                // by unknown reasons, it has been replaced
+                                                                // to the following code in Geant???
+    G4bool inElastic = true;
+//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+    vecLength = 0;
+  G4double excitationEnergyGNP = 0.;
+  G4double excitationEnergyDTA = 0.;
+  G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                          atomicWeight, atomicNumber,
+                                          excitationEnergyGNP,
+                                          excitationEnergyDTA);
+  if (verboseLevel > 1)
+    G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+           << excitationEnergyDTA << G4endl;
+  incidentKineticEnergy -= excitation;
+  incidentTotalEnergy = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                    *(incidentTotalEnergy+incidentMass));
+  G4HEVector targetParticle;
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
+    targetParticle.setDefinition("Proton");
+  } else {
+    targetParticle.setDefinition("Neutron");
+  }
+  G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                        + targetMass*targetMass
+                                        + 2.0*targetMass*incidentTotalEnergy);
+  G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
+  G4bool inElastic = true;
+  vecLength = 0;
     if(verboseLevel > 1)
       G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
            << incidentCode << G4endl;
     G4bool successful = false;
+  G4bool successful = false;
+    if(inElastic || (!inElastic && atomicWeight < 1.5))
+      {
+        FirstIntInCasAntiXiMinus(inElastic, availableEnergy, pv, vecLength,
+                                 incidentParticle, targetParticle, atomicWeight);
+        if(verboseLevel > 1)
+           G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+        if ((vecLength > 0) && (availableEnergy > 1.))
+                   StrangeParticlePairProduction( availableEnergy, centerOfMassEnergy,
+                                                  pv, vecLength,
+                                                  incidentParticle, targetParticle);
+            HighEnergyCascading( successful, pv, vecLength,
+                                 excitationEnergyGNP, excitationEnergyDTA,
+                                 incidentParticle, targetParticle,
+                                 atomicWeight, atomicNumber);
+        if (!successful)
+            HighEnergyClusterProduction( successful, pv, vecLength,
+                                         excitationEnergyGNP, excitationEnergyDTA,
+                                         incidentParticle, targetParticle,
+                                         atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyCascading( successful, pv, vecLength,
+                                   excitationEnergyGNP, excitationEnergyDTA,
+                                   incidentParticle, targetParticle,
+                                   atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyClusterProduction( successful, pv, vecLength,
+                                           excitationEnergyGNP, excitationEnergyDTA,
+                                           incidentParticle, targetParticle,
+                                           atomicWeight, atomicNumber);
+        if (!successful)
+            QuasiElasticScattering( successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+            ElasticScattering( successful, pv, vecLength,
+                               incidentParticle,
+                               atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+        G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles";
+      }
+      FillParticleChange(pv,  vecLength);
+      delete [] pv;
+      theParticleChange.SetStatusChange(stopAndKill);
+      return & theParticleChange;
+  }
+  FirstIntInCasAntiXiMinus(inElastic, availableEnergy, pv, vecLength,
+                           incidentParticle, targetParticle, atomicWeight);
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+                                  incidentParticle, targetParticle,
+                                  atomicWeight, atomicNumber);
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
+  if (!successful)
+    ElasticScattering(successful, pv, vecLength,
+                      incidentParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+           << G4endl;
+  FillParticleChange(pv, vecLength);
+  delete [] pv;
+  theParticleChange.SetStatusChange(stopAndKill);
+  return &theParticleChange;
+}
 void
 G4HEAntiXiMinusInelastic::FirstIntInCasAntiXiMinus( G4bool &inElastic,
                                                     const G4double availableEnergy,
                                                     G4HEVector pv[],
                                                     G4int &vecLen,
                                                     G4HEVector incidentParticle,
                                                     G4HEVector targetParticle,
                                                     const G4double atomicWeight)
+G4HEAntiXiMinusInelastic::FirstIntInCasAntiXiMinus(G4bool& inElastic,
+                                                   const G4double availableEnergy,
+                                                   G4HEVector pv[],
+                                                   G4int& vecLen,
+                                                   const G4HEVector& incidentParticle,
+                                                   const G4HEVector& targetParticle,
+                                                   const G4double atomicWeight)
 // AntiXi- undergoes interaction with nucleon within a nucleus.
 // As in Geant3, we think that this routine has absolutely no influence
 // on the whole performance of the program. Take AntiLambda instaed.
+ {
+   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
+   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+   static const G4double protb = 0.7;
+   static const G4double neutb = 0.7;
+   static const G4double     c = 1.25;
+   static const G4int   numMul   = 1200;
+   static const G4int   numMulAn = 400;
+   static const G4int   numSec   = 60;
+//   G4int              neutronCode = Neutron.getCode();
+   G4int              protonCode  = Proton.getCode();
+   G4int               targetCode = targetParticle.getCode();
+//   G4double          incidentMass = incidentParticle.getMass();
+//   G4double        incidentEnergy = incidentParticle.getEnergy();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   static G4bool first = true;
+   static G4double protmul[numMul],  protnorm[numSec];   // proton constants
+   static G4double protmulAn[numMulAn],protnormAn[numSec];
+   static G4double neutmul[numMul],  neutnorm[numSec];   // neutron constants
+   static G4double neutmulAn[numMulAn],neutnormAn[numSec];
+                              //  misc. local variables
+                              //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+   G4int i, counter, nt, np, nm, nz;
+{
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
+  static const G4double protb = 0.7;
+  static const G4double neutb = 0.7;
+  static const G4double     c = 1.25;
+  static const G4int numMul   = 1200;
+  static const G4int numMulAn = 400;
+  static const G4int numSec   = 60;
+  G4int protonCode = Proton.getCode();
+  G4int targetCode = targetParticle.getCode();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  static G4bool first = true;
+  static G4double protmul[numMul],  protnorm[numSec];   // proton constants
+  static G4double protmulAn[numMulAn],protnormAn[numSec];
+  static G4double neutmul[numMul],  neutnorm[numSec];   // neutron constants
+  static G4double neutmulAn[numMulAn],neutnormAn[numSec];
+  //  misc. local variables
+  //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  G4int i, counter, nt, np, nm, nz;
    if( first )
      {                         // compute normalization constants, this will only be done once
+     {           // compute normalization constants, this will only be done once
        first = false;
        for( i=0; i<numMul  ; i++ ) protmul[i]  = 0.0;

trunk/source/processes/hadronic/models/high_energy/src/G4HEAntiXiZeroInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HEAntiXiZeroInelastic.cc,v 1.15 2008/03/17 20:49:17 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HEAntiXiZeroInelastic.cc,v 1.17 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model. Not included are the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 // First work done by J.L.Chuma and F.W.Jones, TRIUMF, June 96.
 // H. Fesefeldt, RWTH-Aachen, 23-October-1996
 …
 #include "G4HEAntiXiZeroInelastic.hh"
 G4HadFinalState *  G4HEAntiXiZeroInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
     const G4HadProjectile *aParticle = &aTrack;
 //    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
     const G4double A = targetNucleus.GetN();
     const G4double Z = targetNucleus.GetZ();
     G4HEVector incidentParticle(aParticle);
+G4HadFinalState*
+G4HEAntiXiZeroInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                       G4Nucleus& targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
+  const G4double A = targetNucleus.GetN();
+  const G4double Z = targetNucleus.GetZ();
+  G4HEVector incidentParticle(aParticle);
+    G4double atomicNumber = Z;
+    G4double atomicWeight = A;
+    G4int    incidentCode          = incidentParticle.getCode();
+    G4double incidentMass          = incidentParticle.getMass();
+    G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+    if(incidentKineticEnergy < 1.)
+      {
+        G4cout << "GHEAntiXiZeroInelastic: incident energy < 1 GeV" << G4endl;
+      }
+    if(verboseLevel > 1)
+      {
+        G4cout << "G4HEAntiXiZeroInelastic::ApplyYourself" << G4endl;
+        G4cout << "incident particle " << incidentParticle.getName()
+             << "mass "              << incidentMass
+             << "kinetic energy "    << incidentKineticEnergy
+             << G4endl;
+        G4cout << "target material with (A,Z) = ("
+             << atomicWeight << "," << atomicNumber << ")" << G4endl;
+      }
+  G4double atomicNumber = Z;
+  G4double atomicWeight = A;
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+  if (incidentKineticEnergy < 1.)
+    G4cout << "GHEAntiXiZeroInelastic: incident energy < 1 GeV" << G4endl;
+  if (verboseLevel > 1) {
+    G4cout << "G4HEAntiXiZeroInelastic::ApplyYourself" << G4endl;
+    G4cout << "incident particle " << incidentParticle.getName()
+           << "mass "              << incidentMass
+           << "kinetic energy "    << incidentKineticEnergy
+           << G4endl;
+    G4cout << "target material with (A,Z) = ("
+           << atomicWeight << "," << atomicNumber << ")" << G4endl;
+  }
     G4double inelasticity  = NuclearInelasticity(incidentKineticEnergy,
                                                  atomicWeight, atomicNumber);
     if(verboseLevel > 1)
         G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+  G4double inelasticity = NuclearInelasticity(incidentKineticEnergy,
+                                              atomicWeight, atomicNumber);
+  if (verboseLevel > 1)
+    G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
     incidentKineticEnergy -= inelasticity;
+  incidentKineticEnergy -= inelasticity;
     G4double excitationEnergyGNP = 0.;
     G4double excitationEnergyDTA = 0.;
     G4double excitation    = NuclearExcitation(incidentKineticEnergy,
                                                atomicWeight, atomicNumber,
                                                excitationEnergyGNP,
                                                excitationEnergyDTA);
     if(verboseLevel > 1)
       G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+  G4double excitationEnergyGNP = 0.;
+  G4double excitationEnergyDTA = 0.;
+  G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                          atomicWeight, atomicNumber,
+                                          excitationEnergyGNP,
+                                          excitationEnergyDTA);
+  if (verboseLevel > 1)
+    G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
            << excitationEnergyDTA << G4endl;
+    incidentKineticEnergy -= excitation;
+    incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+    G4HEVector targetParticle;
+    if(G4UniformRand() < atomicNumber/atomicWeight)
+      {
+        targetParticle.setDefinition("Proton");
+      }
+    else
+      {
+        targetParticle.setDefinition("Neutron");
+      }
+    G4double targetMass         = targetParticle.getMass();
+    G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+    G4double availableEnergy    = centerOfMassEnergy - targetMass - incidentMass;
+                                                                // this was the meaning of inElastic in the
+                                                                // original Gheisha stand-alone version.
+//    G4bool   inElastic          = InElasticCrossSectionInFirstInt
+//                                    (availableEnergy, incidentCode, incidentTotalMomentum);
+                                                                // by unknown reasons, it has been replaced
+                                                                // to the following code in Geant???
+    G4bool inElastic = true;
+//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+    vecLength = 0;
+  incidentKineticEnergy -= excitation;
+  incidentTotalEnergy = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt((incidentTotalEnergy-incidentMass)
+                                   *(incidentTotalEnergy+incidentMass));
+  G4HEVector targetParticle;
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
+    targetParticle.setDefinition("Proton");
+  } else {
+    targetParticle.setDefinition("Neutron");
+  }
+  G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                        + targetMass*targetMass
+                                        + 2.0*targetMass*incidentTotalEnergy);
+  G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
+  G4bool inElastic = true;
+  vecLength = 0;
     if(verboseLevel > 1)
       G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
            << incidentCode << G4endl;
     G4bool successful = false;
+  G4bool successful = false;
+    if(inElastic || (!inElastic && atomicWeight < 1.5))
+      {
+        FirstIntInCasAntiXiZero(inElastic, availableEnergy, pv, vecLength,
+                                incidentParticle, targetParticle, atomicWeight);
+        if(verboseLevel > 1)
+           G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+        if ((vecLength > 0) && (availableEnergy > 1.))
+                   StrangeParticlePairProduction( availableEnergy, centerOfMassEnergy,
+                                                  pv, vecLength,
+                                                  incidentParticle, targetParticle);
+            HighEnergyCascading( successful, pv, vecLength,
+                                 excitationEnergyGNP, excitationEnergyDTA,
+                                 incidentParticle, targetParticle,
+                                 atomicWeight, atomicNumber);
+        if (!successful)
+            HighEnergyClusterProduction( successful, pv, vecLength,
+                                         excitationEnergyGNP, excitationEnergyDTA,
+                                         incidentParticle, targetParticle,
+                                         atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyCascading( successful, pv, vecLength,
+                                   excitationEnergyGNP, excitationEnergyDTA,
+                                   incidentParticle, targetParticle,
+                                   atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyClusterProduction( successful, pv, vecLength,
+                                           excitationEnergyGNP, excitationEnergyDTA,
+                                           incidentParticle, targetParticle,
+                                           atomicWeight, atomicNumber);
+        if (!successful)
+            QuasiElasticScattering( successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+            ElasticScattering( successful, pv, vecLength,
+                               incidentParticle,
+                               atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+        G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles" << G4endl;
+      }
+      FillParticleChange(pv,  vecLength);
+      delete [] pv;
+      theParticleChange.SetStatusChange(stopAndKill);
+      return & theParticleChange;
+  }
+  FirstIntInCasAntiXiZero(inElastic, availableEnergy, pv, vecLength,
+                          incidentParticle, targetParticle, atomicWeight);
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+                                  incidentParticle, targetParticle,
+                                  atomicWeight, atomicNumber);
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
+  if (!successful)
+    ElasticScattering(successful, pv, vecLength,
+                      incidentParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+           << G4endl;
+  FillParticleChange(pv, vecLength);
+  delete [] pv;
+  theParticleChange.SetStatusChange(stopAndKill);
+  return &theParticleChange;
+}
 void
 G4HEAntiXiZeroInelastic::FirstIntInCasAntiXiZero( G4bool &inElastic,
                                                   const G4double availableEnergy,
                                                   G4HEVector pv[],
                                                   G4int &vecLen,
                                                   G4HEVector incidentParticle,
                                                   G4HEVector targetParticle,
                                                   const G4double atomicWeight)
+G4HEAntiXiZeroInelastic::FirstIntInCasAntiXiZero(G4bool& inElastic,
+                                                 const G4double availableEnergy,
+                                                 G4HEVector pv[],
+                                                 G4int& vecLen,
+                                                 const G4HEVector& incidentParticle,
+                                                 const G4HEVector& targetParticle,
+                                                 const G4double atomicWeight)
 // AntiXi0 undergoes interaction with nucleon within a nucleus.
 …
 // on the whole performance of the program. Take AntiLambda instaed.
 // ( decay Xi0 -> L Pi > 99 % )
+ {
+   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
+   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+   static const G4double protb = 0.7;
+   static const G4double neutb = 0.7;
+   static const G4double     c = 1.25;
+   static const G4int   numMul   = 1200;
+   static const G4int   numMulAn = 400;
+   static const G4int   numSec   = 60;
+//   G4int              neutronCode = Neutron.getCode();
+   G4int              protonCode  = Proton.getCode();
+   G4int               targetCode = targetParticle.getCode();
+//   G4double          incidentMass = incidentParticle.getMass();
+//   G4double        incidentEnergy = incidentParticle.getEnergy();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   static G4bool first = true;
+   static G4double protmul[numMul],  protnorm[numSec];   // proton constants
+   static G4double protmulAn[numMulAn],protnormAn[numSec];
+   static G4double neutmul[numMul],  neutnorm[numSec];   // neutron constants
+   static G4double neutmulAn[numMulAn],neutnormAn[numSec];
+                              //  misc. local variables
+                              //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+   G4int i, counter, nt, np, nm, nz;
+{
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
+  static const G4double protb = 0.7;
+  static const G4double neutb = 0.7;
+  static const G4double     c = 1.25;
+  static const G4int numMul   = 1200;
+  static const G4int numMulAn = 400;
+  static const G4int numSec   = 60;
+  G4int protonCode  = Proton.getCode();
+  G4int targetCode = targetParticle.getCode();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  static G4bool first = true;
+  static G4double protmul[numMul],  protnorm[numSec];   // proton constants
+  static G4double protmulAn[numMulAn],protnormAn[numSec];
+  static G4double neutmul[numMul],  neutnorm[numSec];   // neutron constants
+  static G4double neutmulAn[numMulAn],neutnormAn[numSec];
+  //  misc. local variables
+  //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  G4int i, counter, nt, np, nm, nz;
    if( first )
      {                         // compute normalization constants, this will only be done once
+     {           // compute normalization constants, this will only be done once
        first = false;
        for( i=0; i<numMul  ; i++ ) protmul[i]  = 0.0;

trunk/source/processes/hadronic/models/high_energy/src/G4HEInelastic.cc

-              r962
+              r1347
 //
 //
-//
 #include "globals.hh"
 …
 #include "G4Alpha.hh"
 void  G4HEInelastic::FillParticleChange(G4HEVector pv[], G4int aVecLength)
+void G4HEInelastic::FillParticleChange(G4HEVector pv[], G4int aVecLength)
+{
   theParticleChange.Clear();
 …
     aParticle->SetMomentum(pv[i].getMomentum()*GeV);
     theParticleChange.AddSecondary(aParticle);
-    G4ParticleDefinition * dummy = G4KaonZero::KaonZero();
-    dummy = G4AntiKaonZero::AntiKaonZero();
+  }
+}
+void
+G4HEInelastic::SetParticles()
+  {
+    PionPlus.setDefinition("PionPlus");
+    PionZero.setDefinition("PionZero");
+    PionMinus.setDefinition("PionMinus");
+    KaonPlus.setDefinition("KaonPlus");
+    KaonZero.setDefinition("KaonZero");
+    AntiKaonZero.setDefinition("AntiKaonZero");
+    KaonMinus.setDefinition("KaonMinus");
+    KaonZeroShort.setDefinition("KaonZeroShort");
+    KaonZeroLong.setDefinition("KaonZeroLong");
+    Proton.setDefinition("Proton");
+    AntiProton.setDefinition("AntiProton");
+    Neutron.setDefinition("Neutron");
+    AntiNeutron.setDefinition("AntiNeutron");
+    Lambda.setDefinition("Lambda");
+    AntiLambda.setDefinition("AntiLambda");
+    SigmaPlus.setDefinition("SigmaPlus");
+    SigmaZero.setDefinition("SigmaZero");
+    SigmaMinus.setDefinition("SigmaMinus");
+    AntiSigmaPlus.setDefinition("AntiSigmaPlus");
+    AntiSigmaZero.setDefinition("AntiSigmaZero");
+    AntiSigmaMinus.setDefinition("AntiSigmaMinus");
+    XiZero.setDefinition("XiZero");
+    XiMinus.setDefinition("XiMinus");
+    AntiXiZero.setDefinition("AntiXiZero");
+    AntiXiMinus.setDefinition("AntiXiMinus");
+    OmegaMinus.setDefinition("OmegaMinus");
+    AntiOmegaMinus.setDefinition("AntiOmegaMinus");
+    Deuteron.setDefinition("Deuteron");
+    Triton.setDefinition("Triton");
+    Alpha.setDefinition("Alpha");
+    Gamma.setDefinition("Gamma");
+    return;
+  }
+void G4HEInelastic::SetParticles()
+{
+  PionPlus.setDefinition("PionPlus");
+  PionZero.setDefinition("PionZero");
+  PionMinus.setDefinition("PionMinus");
+  KaonPlus.setDefinition("KaonPlus");
+  KaonZero.setDefinition("KaonZero");
+  AntiKaonZero.setDefinition("AntiKaonZero");
+  KaonMinus.setDefinition("KaonMinus");
+  KaonZeroShort.setDefinition("KaonZeroShort");
+  KaonZeroLong.setDefinition("KaonZeroLong");
+  Proton.setDefinition("Proton");
+  AntiProton.setDefinition("AntiProton");
+  Neutron.setDefinition("Neutron");
+  AntiNeutron.setDefinition("AntiNeutron");
+  Lambda.setDefinition("Lambda");
+  AntiLambda.setDefinition("AntiLambda");
+  SigmaPlus.setDefinition("SigmaPlus");
+  SigmaZero.setDefinition("SigmaZero");
+  SigmaMinus.setDefinition("SigmaMinus");
+  AntiSigmaPlus.setDefinition("AntiSigmaPlus");
+  AntiSigmaZero.setDefinition("AntiSigmaZero");
+  AntiSigmaMinus.setDefinition("AntiSigmaMinus");
+  XiZero.setDefinition("XiZero");
+  XiMinus.setDefinition("XiMinus");
+  AntiXiZero.setDefinition("AntiXiZero");
+  AntiXiMinus.setDefinition("AntiXiMinus");
+  OmegaMinus.setDefinition("OmegaMinus");
+  AntiOmegaMinus.setDefinition("AntiOmegaMinus");
+  Deuteron.setDefinition("Deuteron");
+  Triton.setDefinition("Triton");
+  Alpha.setDefinition("Alpha");
+  Gamma.setDefinition("Gamma");
+  return;
+}
 G4double
+G4HEInelastic::Amin(G4double a, G4double b)
+  {
     G4double c = a;
     if(b < a) c = b;
+    return c;
+  }
 G4double
+G4HEInelastic::Amax(G4double a, G4double b)
+  {
     G4double c = a;
     if(b > a) c = b;
+    return c;
+  }
+G4double G4HEInelastic::Amin(G4double a, G4double b)
+{
+  G4double c = a;
+  if(b < a) c = b;
+  return c;
+}
+G4double G4HEInelastic::Amax(G4double a, G4double b)
+{
+  G4double c = a;
+  if(b > a) c = b;
+  return c;
+}
 G4int
 G4HEInelastic::Imin(G4int a, G4int b)
 …
                        G4HEVector pv[],
                        G4int &vecLen,
                        G4HEVector incidentParticle,
                        G4HEVector targetParticle )
+                       const G4HEVector& incidentParticle,
+                       const G4HEVector& targetParticle)
    // Choose charge combinations K+ K-, K+ K0, K0 K0, K0 K-,
 …
 void
 G4HEInelastic::HighEnergyCascading(G4bool &successful,
+G4HEInelastic::HighEnergyCascading(G4bool& successful,
                                    G4HEVector pv[],
                                    G4int &vecLen,
                                    G4double &excitationEnergyGNP,
                                    G4double &excitationEnergyDTA,
                                    G4HEVector incidentParticle,
                                    G4HEVector targetParticle,
+                                   G4int& vecLen,
+                                   G4double& excitationEnergyGNP,
+                                   G4double& excitationEnergyDTA,
+                                   const G4HEVector& incidentParticle,
+                                   const G4HEVector& targetParticle,
                                    G4double atomicWeight,
                                    G4double atomicNumber)
+ {
+//
+//  The multiplicity of particles produced in the first interaction has been
+//  calculated in one of the FirstIntInNuc.... routines. The nuclear
+//  cascading particles are parameterized from experimental data.
+//  A simple single variable description E D3S/DP3= F(Q) with
+//  Q^2 = (M*X)^2 + PT^2 is used. Final state kinematics are produced
+//  by an FF-type iterative cascade method.
+//  Nuclear evaporation particles are added at the end of the routine.
+//  All quantities in the G4HEVector Array pv are in GeV- units.
+//  The method is a copy of MediumEnergyCascading with some special tuning
+//  for high energy interactions.
+   G4int protonCode       = Proton.getCode();
+   G4double protonMass    = Proton.getMass();
+   G4int neutronCode      = Neutron.getCode();
+   G4double neutronMass   = Neutron.getMass();
+   G4double kaonPlusMass  = KaonPlus.getMass();
+   G4int kaonPlusCode     = KaonPlus.getCode();
+   G4int kaonMinusCode    = KaonMinus.getCode();
+   G4int kaonZeroSCode    = KaonZeroShort.getCode();
+   G4int kaonZeroLCode    = KaonZeroLong.getCode();
+   G4int kaonZeroCode     = KaonZero.getCode();
+   G4int antiKaonZeroCode = AntiKaonZero.getCode();
+   G4int pionPlusCode     = PionPlus.getCode();
+   G4int pionZeroCode     = PionZero.getCode();
+   G4int pionMinusCode    = PionMinus.getCode();
+   G4String mesonType     = PionPlus.getType();
+   G4String baryonType    = Proton.getType();
+   G4String antiBaryonType= AntiProton.getType();
+   G4double targetMass   = targetParticle.getMass();
+   G4int    incidentCode          = incidentParticle.getCode();
+   G4double incidentMass          = incidentParticle.getMass();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   G4double incidentEnergy        = incidentParticle.getEnergy();
+   G4double incidentKineticEnergy = incidentParticle.getKineticEnergy();
+   G4String incidentType          = incidentParticle.getType();
+{
+  //  The multiplicity of particles produced in the first interaction has been
+  //  calculated in one of the FirstIntInNuc.... routines. The nuclear
+  //  cascading particles are parameterized from experimental data.
+  //  A simple single variable description E D3S/DP3= F(Q) with
+  //  Q^2 = (M*X)^2 + PT^2 is used. Final state kinematics are produced
+  //  by an FF-type iterative cascade method.
+  //  Nuclear evaporation particles are added at the end of the routine.
+  //  All quantities in the G4HEVector Array pv are in GeV- units.
+  //  The method is a copy of MediumEnergyCascading with some special tuning
+  //  for high energy interactions.
+  G4int protonCode = Proton.getCode();
+  G4double protonMass = Proton.getMass();
+  G4int neutronCode = Neutron.getCode();
+  G4double neutronMass = Neutron.getMass();
+  G4double kaonPlusMass = KaonPlus.getMass();
+  G4int kaonPlusCode = KaonPlus.getCode();
+  G4int kaonMinusCode = KaonMinus.getCode();
+  G4int kaonZeroSCode = KaonZeroShort.getCode();
+  G4int kaonZeroLCode = KaonZeroLong.getCode();
+  G4int kaonZeroCode = KaonZero.getCode();
+  G4int antiKaonZeroCode = AntiKaonZero.getCode();
+  G4int pionPlusCode = PionPlus.getCode();
+  G4int pionZeroCode = PionZero.getCode();
+  G4int pionMinusCode = PionMinus.getCode();
+  G4String mesonType = PionPlus.getType();
+  G4String baryonType = Proton.getType();
+  G4String antiBaryonType = AntiProton.getType();
+  G4double targetMass = targetParticle.getMass();
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentEnergy = incidentParticle.getEnergy();
+  G4double incidentKineticEnergy = incidentParticle.getKineticEnergy();
+  G4String incidentType = incidentParticle.getType();
 //   G4double incidentTOF           = incidentParticle.getTOF();
    G4double incidentTOF           = 0.;
      // some local variables
    G4int i, j, l;
    if (verboseLevel > 1)
             G4cout << " G4HEInelastic::HighEnergyCascading " << G4endl;
    successful = false;
    if(incidentTotalMomentum < 25. + G4UniformRand()*25.) return;
+  G4double incidentTOF = 0.;
+  // some local variables
+  G4int i, j, l;
+  if (verboseLevel > 1) G4cout << " G4HEInelastic::HighEnergyCascading "
+                               << G4endl;
+  successful = false;
+  if (incidentTotalMomentum < 25. + G4UniformRand()*25.) return;
      // define annihilation channels.
+  // define annihilation channels.
+   G4bool annihilation = false;
+   if (incidentCode < 0 && incidentType == antiBaryonType &&
+       pv[0].getType() != antiBaryonType &&
+       pv[1].getType() != antiBaryonType   )
+         {
+           annihilation = true;
+         }
+   G4double twsup[] = { 1., 1., 0.7, 0.5, 0.3, 0.2, 0.1, 0.0 };
+   if( annihilation ) goto start;
+   if( vecLen >= 8)   goto start;
+   if( incidentKineticEnergy < 1.) return;
+   if(   (   incidentCode == kaonPlusCode  || incidentCode == kaonMinusCode
+          || incidentCode == kaonZeroCode  || incidentCode == antiKaonZeroCode
+          || incidentCode == kaonZeroSCode || incidentCode == kaonZeroLCode )
+      && (   G4UniformRand() < 0.5) ) goto start;
+   if( G4UniformRand() > twsup[vecLen-1]) goto start;
+   if( incidentKineticEnergy > (G4UniformRand()*200 + 50.) ) goto start;
+   return;
+   start:
+   if (annihilation)
+      {                  // do some corrections of incident particle kinematic
+        G4double ekcor = Amax( 1., 1./incidentKineticEnergy);
+        incidentKineticEnergy = 2*targetMass + incidentKineticEnergy*(1.+ekcor/atomicWeight);
+        G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                                atomicWeight,
+                                                atomicNumber,
+                                                excitationEnergyGNP,
+                                                excitationEnergyDTA);
+        incidentKineticEnergy -= excitation;
+        if (incidentKineticEnergy < excitationEnergyDTA) incidentKineticEnergy = 0.;
+        incidentEnergy = incidentKineticEnergy + incidentMass;
+        incidentTotalMomentum =
+                 std::sqrt( Amax(0., incidentEnergy*incidentEnergy - incidentMass*incidentMass));
+      }
+  G4bool annihilation = false;
+  if (incidentCode < 0 && incidentType == antiBaryonType &&
+      pv[0].getType() != antiBaryonType &&
+      pv[1].getType() != antiBaryonType) {
+    annihilation = true;
+  }
+  G4double twsup[] = { 1., 1., 0.7, 0.5, 0.3, 0.2, 0.1, 0.0 };
+  if (annihilation) goto start;
+  if (vecLen >= 8)   goto start;
+  if( incidentKineticEnergy < 1.) return;
+  if(   (   incidentCode == kaonPlusCode  || incidentCode == kaonMinusCode
+         || incidentCode == kaonZeroCode  || incidentCode == antiKaonZeroCode
+         || incidentCode == kaonZeroSCode || incidentCode == kaonZeroLCode )
+     && (   G4UniformRand() < 0.5) ) goto start;
+  if( G4UniformRand() > twsup[vecLen-1]) goto start;
+  if( incidentKineticEnergy > (G4UniformRand()*200 + 50.) ) goto start;
+  return;
+  start:
+  if (annihilation) {
+    // do some corrections of incident particle kinematic
+    G4double ekcor = Amax( 1., 1./incidentKineticEnergy);
+    incidentKineticEnergy = 2*targetMass + incidentKineticEnergy*(1.+ekcor/atomicWeight);
+    G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                            atomicWeight,
+                                            atomicNumber,
+                                            excitationEnergyGNP,
+                                            excitationEnergyDTA);
+    incidentKineticEnergy -= excitation;
+    if (incidentKineticEnergy < excitationEnergyDTA) incidentKineticEnergy = 0.;
+    incidentEnergy = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum =
+         std::sqrt( Amax(0., incidentEnergy*incidentEnergy - incidentMass*incidentMass));
+  }
+   G4HEVector pTemp;
+   for (i = 2; i<vecLen; i++)
+     {
+       j = Imin( vecLen-1, (G4int)(2. + G4UniformRand()*(vecLen - 2)));
+       pTemp = pv[j];
+       pv[j] = pv[i];
+       pv[i] = pTemp;
+     }
+         // randomize the first two leading particles
+         // for kaon induced reactions only
+         // (need from experimental data)
+  G4HEVector pTemp;
+  for (i = 2; i < vecLen; i++) {
+    j = Imin( vecLen-1, (G4int)(2. + G4UniformRand()*(vecLen - 2)));
+    pTemp = pv[j];
+    pv[j] = pv[i];
+    pv[i] = pTemp;
+  }
+  // randomize the first two leading particles
+  // for kaon induced reactions only
+  // (need from experimental data)
    if(   (incidentCode==kaonPlusCode  || incidentCode==kaonMinusCode    ||
 …
+         }
+     // Distribute particles in forward and backward hemispheres in center
+     // of mass system.  Incident particle goes in forward hemisphere.
+   G4HEVector pvI = incidentParticle;  // for the incident particle
+   pvI.setSide( 1 );
+   G4HEVector pvT = targetParticle;   // for the target particle
+   pvT.setMomentumAndUpdate( 0.0, 0.0, 0.0 );
+   pvT.setSide( -1 );
+   pvT.setTOF( -1.);
+   G4double centerOfMassEnergy = std::sqrt( sqr(incidentMass)+sqr(targetMass)
+  // Distribute particles in forward and backward hemispheres in center
+  // of mass system.  Incident particle goes in forward hemisphere.
+  G4HEVector pvI = incidentParticle;  // for the incident particle
+  pvI.setSide( 1 );
+  G4HEVector pvT = targetParticle;   // for the target particle
+  pvT.setMomentumAndUpdate( 0.0, 0.0, 0.0 );
+  pvT.setSide( -1 );
+  pvT.setTOF( -1.);
+  G4double centerOfMassEnergy = std::sqrt( sqr(incidentMass)+sqr(targetMass)
                                       +2.0*targetMass*incidentEnergy );
+//   G4double availableEnergy    = centerOfMassEnergy - ( targetMass + incidentMass );
+   G4double tavai1      = centerOfMassEnergy/2.0 - incidentMass;
+   G4double tavai2      = centerOfMassEnergy/2.0 - targetMass;
+    // define G4HEVector- array for kinematic manipulations,
+    // with a one by one correspondence to the pv-Array.
+   G4int ntb = 1;
+   for( i=0; i < vecLen; i++ )
+      {
+        if      (i == 0) pv[i].setSide(  1 );
+        else if (i == 1) pv[i].setSide( -1 );
+        else
+           { if( G4UniformRand() < 0.5 )
+               {
+                 pv[i].setSide( -1 );
+                 ntb++;
+                }
+             else
+                 pv[i].setSide( 1 );
+           }
+        pv[i].setTOF(    incidentTOF);
+      }
+   G4double tb = 2. * ntb;
+   if (centerOfMassEnergy < (2. + G4UniformRand()))
+       tb = (2. * ntb + vecLen)/2.;
+   if (verboseLevel > 1)
+      { G4cout << " pv Vector after Randomization " << vecLen << G4endl;
+        pvI.Print(-1);
+        pvT.Print(-1);
+        for (i=0; i < vecLen ; i++) pv[i].Print(i);
+      }
+    // Add particles from intranuclear cascade
+    // nuclearCascadeCount = number of new secondaries produced by nuclear
+    // cascading.
+    // extraCount = number of nucleons within these new secondaries
+//  G4double availableEnergy    = centerOfMassEnergy - ( targetMass + incidentMass );
+  G4double tavai1 = centerOfMassEnergy/2.0 - incidentMass;
+  G4double tavai2 = centerOfMassEnergy/2.0 - targetMass;
+  // define G4HEVector- array for kinematic manipulations,
+  // with a one by one correspondence to the pv-Array.
+  G4int ntb = 1;
+  for (i = 0; i < vecLen; i++) {
+    if (i == 0) pv[i].setSide(1);
+    else if (i == 1) pv[i].setSide(-1);
+    else {
+      if (G4UniformRand() < 0.5) {
+        pv[i].setSide(-1);
+        ntb++;
+      } else {
+        pv[i].setSide(1);
+      }
+    }
+    pv[i].setTOF(incidentTOF);
+  }
+  G4double tb = 2. * ntb;
+  if (centerOfMassEnergy < (2. + G4UniformRand()))
+    tb = (2. * ntb + vecLen)/2.;
+  if (verboseLevel > 1) {
+    G4cout << " pv Vector after Randomization " << vecLen << G4endl;
+    pvI.Print(-1);
+    pvT.Print(-1);
+    for (i = 0; i < vecLen; i++) pv[i].Print(i);
+  }
+  // Add particles from intranuclear cascade
+  // nuclearCascadeCount = number of new secondaries produced by nuclear
+  // cascading.
+  // extraCount = number of nucleons within these new secondaries
    G4double s, xtarg, ran;
 …
+     }
      //  assume conservation of kinetic energy
      //  in forward & backward hemispheres
    G4int is, iskip, iavai1;
    if(vecLen <= 1) return;
    tavai1 = centerOfMassEnergy/2.;
    iavai1 = 0;
+  //  assume conservation of kinetic energy
+  //  in forward & backward hemispheres
+  G4int is, iskip, iavai1;
+  if (vecLen <= 1) return;
+  tavai1 = centerOfMassEnergy/2.;
+  iavai1 = 0;
    for (i = 0; i < vecLen; i++)
+  for (i = 0; i < vecLen; i++)
+       {
          if (pv[i].getSide() > 0)
 …
+            }
+       }
+   if ( iavai1 == 0) return;
+   while( tavai1 <= 0.0 )
+        {                   // must eliminate a particle from the forward side
+           iskip = G4int(G4UniformRand()*iavai1) + 1;
+           is = 0;
+           for( i=vecLen-1; i>=0; i-- )
+              {
+                if( pv[i].getSide() > 0 )
+                  {
+                    if (++is == iskip)
+                        {
+                           tavai1 += pv[i].getMass();
+                           iavai1--;
+                           if ( i != vecLen-1)
+                              {
+                                 for( j=i; j<vecLen; j++ )
+                                    {
+                                       pv[j] = pv[j+1];
+                                    }
+                              }
+                           if( --vecLen == 0 ) return;     // all the secondaries except of the
+                           break;            // --+
+                        }                    //   |
+                  }                          //   v
+              }                              // break goes down to here
+        }                                    // to the end of the for- loop.
+     tavai2 = (targ+1)*centerOfMassEnergy/2.;
+     G4int iavai2 = 0;
+  if ( iavai1 == 0) return;
+  while (tavai1 <= 0.0) {
+    // must eliminate a particle from the forward side
+    iskip = G4int(G4UniformRand()*iavai1) + 1;
+    is = 0;
+    for (i = vecLen-1; i >= 0; i--) {
+      if (pv[i].getSide() > 0) {
+        if (++is == iskip) {
+          tavai1 += pv[i].getMass();
+          iavai1--;
+          if (i != vecLen-1) {
+            for (j = i; j < vecLen; j++) pv[j] = pv[j+1];
+          }
+          if (--vecLen == 0) return;  // all the secondaries except the
+          break;                 // --+
+        }                        //   |
+      }                          //   v
+    }                            // break goes down to here
+  }                              // to the end of the for- loop.
+  tavai2 = (targ+1)*centerOfMassEnergy/2.;
+  G4int iavai2 = 0;
      for (i = 0; i < vecLen; i++)
 …
+        }
+   if (verboseLevel > 1)
+      { G4cout << " pv Vector after Energy checks "
+             << vecLen << " " << tavai1 << " " << iavai1 << " " << tavai2
+             << " " <<  iavai2 << " " << ntarg << G4endl;
+        pvI.Print(-1);
+        pvT.Print(-1);
+        for (i=0; i < vecLen ; i++) pv[i].Print(i);
+      }
+    //  define some vectors for Lorentz transformations
+   G4HEVector* pvmx = new G4HEVector [10];
+   pvmx[0].setMass( incidentMass );
+   pvmx[0].setMomentumAndUpdate( 0.0, 0.0, incidentTotalMomentum );
+   pvmx[1].setMass( protonMass);
+   pvmx[1].setMomentumAndUpdate( 0.0, 0.0, 0.0 );
+   pvmx[3].setMass( protonMass*(1+targ));
+   pvmx[3].setMomentumAndUpdate( 0.0, 0.0, 0.0 );
+   pvmx[4].setZero();
+   pvmx[5].setZero();
+   pvmx[7].setZero();
+   pvmx[8].setZero();
+   pvmx[8].setMomentum( 1.0, 0.0 );
+   pvmx[2].Add( pvmx[0], pvmx[1] );
+   pvmx[3].Add( pvmx[3], pvmx[0] );
+   pvmx[0].Lor( pvmx[0], pvmx[2] );
+   pvmx[1].Lor( pvmx[1], pvmx[2] );
+   if (verboseLevel > 1)
+     { G4cout << " General Vectors after Definition " << G4endl;
+       for (i=0; i<10; i++) pvmx[i].Print(i);
+     }
+   // Main loop for 4-momentum generation - see Pitha-report (Aachen)
+   // for a detailed description of the method.
+   // Process the secondary particles in reverse order.
+   G4double dndl[20];
+   G4double binl[20];
+   G4double pvMass(0), pvEnergy(0);
+   G4int    pvCode;
+   G4double aspar, pt, phi, et, xval;
+   G4double ekin  = 0.;
+   G4double ekin1 = 0.;
+   G4double ekin2 = 0.;
+   G4int npg   = 0;
+   G4double rmg0 = 0.;
+   G4int targ1 = 0;                // No fragmentation model for nucleons from
+   phi = G4UniformRand()*twopi;
+   for( i=vecLen-1; i>=0; i-- )    // the intranuclear cascade. Mark them with
+      {                            // -3 and leave the loop
+  if (verboseLevel > 1) {
+    G4cout << " pv Vector after Energy checks "
+           << vecLen << " " << tavai1 << " " << iavai1 << " " << tavai2
+           << " " <<  iavai2 << " " << ntarg << G4endl;
+    pvI.Print(-1);
+    pvT.Print(-1);
+    for (i=0; i < vecLen ; i++) pv[i].Print(i);
+  }
+  //  define some vectors for Lorentz transformations
+  G4HEVector* pvmx = new G4HEVector [10];
+  pvmx[0].setMass( incidentMass );
+  pvmx[0].setMomentumAndUpdate( 0.0, 0.0, incidentTotalMomentum );
+  pvmx[1].setMass( protonMass);
+  pvmx[1].setMomentumAndUpdate( 0.0, 0.0, 0.0 );
+  pvmx[3].setMass( protonMass*(1+targ));
+  pvmx[3].setMomentumAndUpdate( 0.0, 0.0, 0.0 );
+  pvmx[4].setZero();
+  pvmx[5].setZero();
+  pvmx[7].setZero();
+  pvmx[8].setZero();
+  pvmx[8].setMomentum( 1.0, 0.0 );
+  pvmx[2].Add( pvmx[0], pvmx[1] );
+  pvmx[3].Add( pvmx[3], pvmx[0] );
+  pvmx[0].Lor( pvmx[0], pvmx[2] );
+  pvmx[1].Lor( pvmx[1], pvmx[2] );
+  if (verboseLevel > 1) {
+    G4cout << " General Vectors after Definition " << G4endl;
+    for (i=0; i<10; i++) pvmx[i].Print(i);
+  }
+  // Main loop for 4-momentum generation - see Pitha-report (Aachen)
+  // for a detailed description of the method.
+  // Process the secondary particles in reverse order.
+  G4double dndl[20];
+  G4double binl[20];
+  G4double pvMass(0), pvEnergy(0);
+  G4int pvCode;
+  G4double aspar, pt, phi, et, xval;
+  G4double ekin  = 0.;
+  G4double ekin1 = 0.;
+  G4double ekin2 = 0.;
+  G4int npg   = 0;
+  G4double rmg0 = 0.;
+  G4int targ1 = 0;                // No fragmentation model for nucleons from
+  phi = G4UniformRand()*twopi;
+  for (i = vecLen-1; i >= 0; i--) {
+        // Intranuclear cascade: mark them with -3 and leave the loop
         if( i == 1)
+          {
 …
              }                                  // closes outer iteration
+        if( eliminateThisParticle )             // not enough energy,
+          {                                     // eliminate this particle
+            if (verboseLevel > 1) {
+                  G4cout << " Eliminate particle index " << i << G4endl;
+                  pv[i].Print(i);
+            }
+            if(i != vecLen-1)
+               {
+                 for( j=i; j < vecLen-1; j++ )
+                   {                            // shift down
+                     pv[j] = pv[j+1];
+                   }
+               }
+            vecLen--;
+            if(vecLen < 2) return;
+            i++;
+            pvmx[6].Add( pvmx[4], pvmx[5] );
+            pvmx[6].setMomentum( 0.0 );          // set z-momentum
+          }
+      }                                          // closes main for loop
+   if (verboseLevel > 1)
+      { G4cout << " pv Vector after lambda fragmentation " << vecLen << G4endl;
+        pvI.Print(-1);
+        pvT.Print(-1);
+        for (i=0; i < vecLen ; i++) pv[i].Print(i);
+        for (i=0; i < 10; i++) pvmx[i].Print(i);
+      }
+   // Backward nucleons produced with a cluster model
+   G4double gpar[] = {2.6, 2.6, 1.80, 1.30, 1.20};
+   G4double cpar[] = {0.6, 0.6, 0.35, 0.15, 0.10};
+    if (eliminateThisParticle) {
+      // Not enough energy - eliminate this particle
+      if (verboseLevel > 1) {
+        G4cout << " Eliminate particle index " << i << G4endl;
+        pv[i].Print(i);
+      }
+      if (i != vecLen-1) {
+        // shift down
+        for (j = i; j < vecLen-1; j++) pv[j] = pv[j+1];
+      }
+      vecLen--;
+      if (vecLen < 2) {
+        delete [] pvmx;
+        return;
+      }
+      i++;
+      pvmx[6].Add( pvmx[4], pvmx[5] );
+      pvmx[6].setMomentum( 0.0 );          // set z-momentum
+    }
+  }                                   // closes main for loop
+  if (verboseLevel > 1) {
+    G4cout << " pv Vector after lambda fragmentation " << vecLen << G4endl;
+    pvI.Print(-1);
+    pvT.Print(-1);
+    for (i=0; i < vecLen ; i++) pv[i].Print(i);
+    for (i=0; i < 10; i++) pvmx[i].Print(i);
+  }
+  // Backward nucleons produced with a cluster model
+  G4double gpar[] = {2.6, 2.6, 1.80, 1.30, 1.20};
+  G4double cpar[] = {0.6, 0.6, 0.35, 0.15, 0.10};
+   if (npg > 0)
+     {
+       G4double rmg = rmg0;
+       if (npg > 1)
+          {
+            G4int npg1 = npg-1;
+            if (npg1 >4) npg1 = 4;
+            rmg += std::pow( -std::log(1.-G4UniformRand()), cpar[npg1])/gpar[npg1];
+          }
+       G4double ga = 1.2;
+       G4double ekit1 = 0.04, ekit2 = 0.6;
+       if(incidentKineticEnergy < 5.)
+         {
+           ekit1 *= sqr(incidentKineticEnergy)/25.;
+           ekit2 *= sqr(incidentKineticEnergy)/25.;
+         }
+       G4double avalue = (1.-ga)/(std::pow(ekit2,1.-ga)-std::pow(ekit1,1.-ga));
+       for (i = 0; i < vecLen; i++)
+          {
+            if (pv[i].getSide() == -3)
+              {
+                G4double ekit = std::pow(G4UniformRand()*(1.-ga)/avalue + std::pow(ekit1,1.-ga), 1./(1.-ga) );
+                G4double cost = Amax(-1., Amin(1., std::log(2.23*G4UniformRand()+0.383)/0.96));
+                G4double sint = std::sqrt(1. - cost*cost);
+                G4double phi  = twopi*G4UniformRand();
+                G4double pp   = std::sqrt(ekit*(ekit+2*pv[i].getMass()));
+                pv[i].setMomentum( pp*sint*std::sin(phi),
+                                   pp*sint*std::cos(phi),
+                                   pp*cost          );
+                pv[i].Lor( pv[i], pvmx[2] );
+                pvmx[5].Add( pvmx[5], pv[i] );
+              }
+          }
+     }
+  if (npg > 0) {
+    G4double rmg = rmg0;
+    if (npg > 1) {
+      G4int npg1 = npg-1;
+      if (npg1 >4) npg1 = 4;
+      rmg += std::pow( -std::log(1.-G4UniformRand()), cpar[npg1])/gpar[npg1];
+    }
+    G4double ga = 1.2;
+    G4double ekit1 = 0.04, ekit2 = 0.6;
+    if (incidentKineticEnergy < 5.) {
+      ekit1 *= sqr(incidentKineticEnergy)/25.;
+      ekit2 *= sqr(incidentKineticEnergy)/25.;
+    }
+    G4double avalue = (1.-ga)/(std::pow(ekit2,1.-ga)-std::pow(ekit1,1.-ga));
+    for (i = 0; i < vecLen; i++) {
+      if (pv[i].getSide() == -3) {
+        G4double ekit = std::pow(G4UniformRand()*(1.-ga)/avalue + std::pow(ekit1,1.-ga), 1./(1.-ga) );
+        G4double cost = Amax(-1., Amin(1., std::log(2.23*G4UniformRand()+0.383)/0.96));
+        G4double sint = std::sqrt(1. - cost*cost);
+        G4double phi  = twopi*G4UniformRand();
+        G4double pp   = std::sqrt(ekit*(ekit+2*pv[i].getMass()));
+        pv[i].setMomentum(pp*sint*std::sin(phi),
+                          pp*sint*std::cos(phi),
+                          pp*cost);
+        pv[i].Lor( pv[i], pvmx[2] );
+        pvmx[5].Add( pvmx[5], pv[i] );
+      }
+    }
+  }
+   if (vecLen <= 2) {
+     successful = false;
+     return;
+   }
+   // Lorentz transformation in lab system
+  if (vecLen <= 2) {
+    successful = false;
+    delete [] pvmx;
+    return;
+  }
+  // Lorentz transformation in lab system
    targ = 0;
 …
+     }
    pvmx[3].setMass( incidentMass);
    pvmx[3].setMomentumAndUpdate( 0.0, 0.0, incidentTotalMomentum );
    G4double ekin0 = pvmx[3].getKineticEnergy();
    pvmx[4].setMass( protonMass * targ);
    pvmx[4].setEnergy( protonMass * targ);
    pvmx[4].setKineticEnergy(0.);
    pvmx[4].setMomentum(0., 0., 0.);
    ekin = pvmx[3].getEnergy() + pvmx[4].getEnergy();
+  pvmx[3].setMass( incidentMass);
+  pvmx[3].setMomentumAndUpdate( 0.0, 0.0, incidentTotalMomentum );
+  G4double ekin0 = pvmx[3].getKineticEnergy();
+  pvmx[4].setMass( protonMass * targ);
+  pvmx[4].setEnergy( protonMass * targ);
+  pvmx[4].setKineticEnergy(0.);
+  pvmx[4].setMomentum(0., 0., 0.);
+  ekin = pvmx[3].getEnergy() + pvmx[4].getEnergy();
    pvmx[5].Add( pvmx[3], pvmx[4] );
 …
+     }
    // Do some smearing in the transverse direction due to Fermi motion
+  // Do some smearing in the transverse direction due to Fermi motion
    G4double ry   = G4UniformRand();
 …
+   }
+   // Rotate in the direction of the primary particle momentum (z-axis).
+   // This does disturb our inclusive distributions somewhat, but it is
+   // necessary for momentum conservation
+   // Also subtract binding energies and make some further corrections
+   // if required
+   G4double dekin = 0.0;
+   G4int npions = 0;
+   G4double ek1 = 0.0;
+   G4double alekw, xxh;
+   G4double cfa = 0.025*((atomicWeight-1.)/120.)*std::exp(-(atomicWeight-1.)/120.);
+   G4double alem[] = {1.40, 2.30, 2.70, 3.00, 3.40, 4.60, 7.00, 10.00};
+   G4double val0[] = {0.00, 0.40, 0.48, 0.51, 0.54, 0.60, 0.65,  0.70};
+   if (verboseLevel > 1)
+     G4cout << " Rotation in Direction  of primary particle (Defs1)" << G4endl;
+   for (i = 0; i < vecLen; i++)
+      {
+        if(verboseLevel > 1) pv[i].Print(i);
+        pv[i].Defs1( pv[i], pvI );
+        if(verboseLevel > 1) pv[i].Print(i);
+        if (atomicWeight > 1.5)
+           {
+             ekin  = Amax( 1.e-6,pv[i].getKineticEnergy() - cfa*( 1. + 0.5*normal()));
+             alekw = std::log( incidentKineticEnergy );
+             xxh   = 1.;
+             if(incidentCode == pionPlusCode || incidentCode == pionMinusCode)
+               {
+                 if(pv[i].getCode() == pionZeroCode)
+                   {
+                     if(G4UniformRand() < std::log(atomicWeight))
+                       {
+                         if (alekw > alem[0])
+                           {
+                              for (j = 1; j < 8; j++)
+                                 {
+                                    if(alekw < alem[j]) break;
+                                 }
+                              xxh =   (val0[j]-val0[j-1])/(alem[j]-alem[j-1])*alekw
+                                     + val0[j-1] - (val0[j]-val0[j-1])/(alem[j]-alem[j-1])*alem[j-1];
+                              xxh = 1. - xxh;
+                           }
+                       }
+                    }
+               }
+             dekin += ekin*(1.-xxh);
+             ekin *= xxh;
+             pv[i].setKineticEnergyAndUpdate( ekin );
+             pvCode = pv[i].getCode();
+             if ((pvCode == pionPlusCode) || (pvCode == pionMinusCode) || (pvCode == pionZeroCode))
+                {
+                  npions += 1;
+                  ek1 += ekin;
+  // Rotate in the direction of the primary particle momentum (z-axis).
+  // This does disturb our inclusive distributions somewhat, but it is
+  // necessary for momentum conservation
+  // Also subtract binding energies and make some further corrections
+  // if required
+  G4double dekin = 0.0;
+  G4int npions = 0;
+  G4double ek1 = 0.0;
+  G4double alekw, xxh;
+  G4double cfa = 0.025*((atomicWeight-1.)/120.)*std::exp(-(atomicWeight-1.)/120.);
+  G4double alem[] = {1.40, 2.30, 2.70, 3.00, 3.40, 4.60, 7.00, 10.00};
+  G4double val0[] = {0.00, 0.40, 0.48, 0.51, 0.54, 0.60, 0.65,  0.70};
+  if (verboseLevel > 1)
+    G4cout << " Rotation in Direction  of primary particle (Defs1)" << G4endl;
+  for (i = 0; i < vecLen; i++) {
+    if(verboseLevel > 1) pv[i].Print(i);
+    pv[i].Defs1( pv[i], pvI );
+    if(verboseLevel > 1) pv[i].Print(i);
+    if (atomicWeight > 1.5) {
+      ekin = Amax( 1.e-6,pv[i].getKineticEnergy() - cfa*( 1. + 0.5*normal()));
+      alekw = std::log( incidentKineticEnergy );
+      xxh = 1.;
+      if (incidentCode == pionPlusCode || incidentCode == pionMinusCode) {
+        if (pv[i].getCode() == pionZeroCode) {
+          if (G4UniformRand() < std::log(atomicWeight)) {
+            if (alekw > alem[0]) {
+              G4int jmax = 1;
+              for (j = 1; j < 8; j++) {
+                if (alekw < alem[j]) {
+                  jmax = j;
+                  break;
+                }
+           }
+      }
-   if( (ek1 > 0.0) && (npions > 0) )
+      {
-        dekin = 1.+dekin/ek1;
-        for (i = 0; i < vecLen; i++)
+          {
-            pvCode = pv[i].getCode();
-            if((pvCode == pionPlusCode) || (pvCode == pionMinusCode) || (pvCode == pionZeroCode))
+              {
-                ekin = Amax( 1.0e-6, pv[i].getKineticEnergy() * dekin );
-                pv[i].setKineticEnergyAndUpdate( ekin );
+              }
+          }
+      }
+   if (verboseLevel > 1)
+      { G4cout << " Lab-System " <<  ek1 << " " << npions << G4endl;
+        incidentParticle.Print(0);
+        targetParticle.Print(1);
+        for (i=0; i<vecLen; i++) pv[i].Print(i);
+      }
+   // Add black track particles
+   // the total number of particles produced is restricted to 198
+   // this may have influence on very high energies
+              xxh = (val0[jmax]-val0[jmax-1])/(alem[jmax]-alem[jmax-1])*alekw
+                   + val0[jmax-1] - (val0[jmax]-val0[jmax-1])/(alem[jmax]-alem[jmax-1])*alem[jmax-1];
+              xxh = 1. - xxh;
+            }
+          }
+        }
+      }
+      dekin += ekin*(1.-xxh);
+      ekin *= xxh;
+      pv[i].setKineticEnergyAndUpdate( ekin );
+      pvCode = pv[i].getCode();
+      if ((pvCode == pionPlusCode) ||
+          (pvCode == pionMinusCode) ||
+          (pvCode == pionZeroCode)) {
+        npions += 1;
+        ek1 += ekin;
+      }
+    }
+  }
+  if ( (ek1 > 0.0) && (npions > 0) ) {
+    dekin = 1.+dekin/ek1;
+    for (i = 0; i < vecLen; i++) {
+      pvCode = pv[i].getCode();
+      if ((pvCode == pionPlusCode) ||
+          (pvCode == pionMinusCode) ||
+          (pvCode == pionZeroCode)) {
+        ekin = Amax(1.0e-6, pv[i].getKineticEnergy() * dekin);
+        pv[i].setKineticEnergyAndUpdate( ekin );
+      }
+    }
+  }
+  if (verboseLevel > 1) {
+    G4cout << " Lab-System " <<  ek1 << " " << npions << G4endl;
+    incidentParticle.Print(0);
+    targetParticle.Print(1);
+    for (i = 0; i < vecLen; i++) pv[i].Print(i);
+  }
+  // Add black track particles
+  // the total number of particles produced is restricted to 198
+  // this may have influence on very high energies
    if (verboseLevel > 1)
 …
+   }
    return;
+ }
+  return;
+}
 void
 G4HEInelastic::TuningOfHighEnergyCascading(G4HEVector pv[],
                                            G4int &vecLen,
                                            G4HEVector incidentParticle,
                                            G4HEVector targetParticle,
+                                           G4int& vecLen,
+                                           const G4HEVector& incidentParticle,
+                                           const G4HEVector& targetParticle,
                                            G4double atomicWeight,
                                            G4double atomicNumber)
 …
 void
 G4HEInelastic::HighEnergyClusterProduction(G4bool &successful,
+G4HEInelastic::HighEnergyClusterProduction(G4bool& successful,
                                            G4HEVector pv[],
                                            G4int &vecLen,
                                            G4double &excitationEnergyGNP,
                                            G4double &excitationEnergyDTA,
                                            G4HEVector incidentParticle,
                                            G4HEVector targetParticle,
+                                           G4int& vecLen,
+                                           G4double& excitationEnergyGNP,
+                                           G4double& excitationEnergyDTA,
+                                           const G4HEVector& incidentParticle,
+                                           const G4HEVector& targetParticle,
                                            G4double atomicWeight,
                                            G4double atomicNumber)
+ {
+{
 // For low multiplicity in the first intranuclear interaction the cascading process
 // as described in G4HEInelastic::MediumEnergyCascading does not work
 …
 //  All quantities on the G4HEVector Array pv are in GeV- units.
    G4int protonCode       = Proton.getCode();
    G4double protonMass    = Proton.getMass();
    G4int neutronCode      = Neutron.getCode();
    G4double kaonPlusMass  = KaonPlus.getMass();
    G4int pionPlusCode     = PionPlus.getCode();
    G4int pionZeroCode     = PionZero.getCode();
    G4int pionMinusCode    = PionMinus.getCode();
    G4String mesonType     = PionPlus.getType();
    G4String baryonType    = Proton.getType();
    G4String antiBaryonType= AntiProton.getType();
+  G4int protonCode       = Proton.getCode();
+  G4double protonMass    = Proton.getMass();
+  G4int neutronCode      = Neutron.getCode();
+  G4double kaonPlusMass  = KaonPlus.getMass();
+  G4int pionPlusCode     = PionPlus.getCode();
+  G4int pionZeroCode     = PionZero.getCode();
+  G4int pionMinusCode    = PionMinus.getCode();
+  G4String mesonType = PionPlus.getType();
+  G4String baryonType = Proton.getType();
+  G4String antiBaryonType = AntiProton.getType();
    G4double targetMass   = targetParticle.getMass();
+  G4double targetMass = targetParticle.getMass();
    G4int    incidentCode          = incidentParticle.getCode();
 …
    G4double incidentTOF           = 0.;
+                                                              // some local variables
+   G4int i, j;
+   if(verboseLevel > 1) G4cout << " G4HEInelastic::HighEnergyClusterProduction " << G4endl;
+   successful = false;
+   if(incidentTotalMomentum < 25. + G4UniformRand()*25.) return;
+   G4double centerOfMassEnergy = std::sqrt( sqr(incidentMass) + sqr(targetMass)
+                                       +2.*targetMass*incidentEnergy);
+   G4HEVector pvI = incidentParticle;  // for the incident particle
+   pvI.setSide( 1 );
+   G4HEVector pvT = targetParticle;   // for the target particle
+   pvT.setMomentumAndUpdate( 0.0, 0.0, 0.0 );
+   pvT.setSide( -1 );
+   pvT.setTOF( -1.);
+                              // distribute particles in forward and backward
+                              // hemispheres. Note that only low multiplicity
+                              // events from FirstIntInNuc.... should go into
+                              // this routine.
+   G4int targ  = 0;
+   G4int ifor  = 0;
+   G4int iback = 0;
+   G4int pvCode;
+   G4double pvMass, pvEnergy;
+   pv[0].setSide(  1 );
+   pv[1].setSide( -1 );
+   for(i = 0; i < vecLen; i++)
+      {
+        if (i > 1)
+           {
+              if( G4UniformRand() < 0.5)
+                {
+                  pv[i].setSide( 1 );
+                  if (++ifor > 18)
+                     {
+                       pv[i].setSide( -1 );
+                       ifor--;
+                       iback++;
+                     }
+                }
+              else
+                {
+                  pv[i].setSide( -1 );
+                  if (++iback > 18)
+                     {
+                       pv[i].setSide( 1 );
+                       ifor++;
+                       iback--;
+                     }
+                }
+           }
+        pvCode = pv[i].getCode();
+        if (   (    (incidentCode == protonCode) || (incidentCode == neutronCode)
+                 || (incidentType == mesonType) )
+            && (    (pvCode == pionPlusCode) || (pvCode == pionMinusCode) )
+            && (    (G4UniformRand() < (10.-incidentTotalMomentum)/6.) )
+            && (    (G4UniformRand() < atomicWeight/300.) ) )
+           {
+               if (G4UniformRand() > atomicNumber/atomicWeight)
+                  pv[i].setDefinition( "Neutron" );
+               else
+                  pv[i].setDefinition( "Proton" );
+               targ++;
+           }
+        pv[i].setTOF( incidentTOF );
+      }
+   G4double tb = 2. * iback;
+   if (centerOfMassEnergy < (2+G4UniformRand())) tb = (2.*iback + vecLen)/2.;
+   G4double nucsup[] = { 1.0, 0.7, 0.5, 0.4, 0.35, 0.3};
+   G4double  psup[]   = { 3. , 6. , 20., 50., 100.,1000.};
+   G4double s = centerOfMassEnergy*centerOfMassEnergy;
+   G4double xtarg = Amax(0.01, Amin(0.50, 0.312+0.2*std::log(std::log(s))+std::pow(s,1.5)/6000.)
+  // some local variables
+  G4int i, j;
+  if (verboseLevel > 1)
+    G4cout << " G4HEInelastic::HighEnergyClusterProduction " << G4endl;
+  successful = false;
+  if (incidentTotalMomentum < 25. + G4UniformRand()*25.) return;
+  G4double centerOfMassEnergy = std::sqrt( sqr(incidentMass) + sqr(targetMass)
+                                         +2.*targetMass*incidentEnergy);
+  G4HEVector pvI = incidentParticle;  // for the incident particle
+  pvI.setSide(1);
+  G4HEVector pvT = targetParticle;   // for the target particle
+  pvT.setMomentumAndUpdate( 0.0, 0.0, 0.0 );
+  pvT.setSide( -1 );
+  pvT.setTOF( -1.);
+                    // distribute particles in forward and backward
+                    // hemispheres. Note that only low multiplicity
+                    // events from FirstIntInNuc.... should go into
+                    // this routine.
+  G4int targ  = 0;
+  G4int ifor  = 0;
+  G4int iback = 0;
+  G4int pvCode;
+  G4double pvMass, pvEnergy;
+  pv[0].setSide(1);
+  pv[1].setSide(-1);
+  for (i = 0; i < vecLen; i++) {
+    if (i > 1) {
+      if (G4UniformRand() < 0.5) {
+        pv[i].setSide( 1 );
+        if (++ifor > 18) {
+          pv[i].setSide(-1);
+          ifor--;
+          iback++;
+        }
+      } else {
+        pv[i].setSide( -1 );
+        if (++iback > 18) {
+          pv[i].setSide(1);
+          ifor++;
+          iback--;
+        }
+      }
+    }
+    pvCode = pv[i].getCode();
+    if (   (    (incidentCode == protonCode) || (incidentCode == neutronCode)
+             || (incidentType == mesonType) )
+        && (    (pvCode == pionPlusCode) || (pvCode == pionMinusCode) )
+        && (    (G4UniformRand() < (10.-incidentTotalMomentum)/6.) )
+        && (    (G4UniformRand() < atomicWeight/300.) ) ) {
+      if (G4UniformRand() > atomicNumber/atomicWeight)
+        pv[i].setDefinition("Neutron");
+      else
+        pv[i].setDefinition("Proton");
+      targ++;
+    }
+    pv[i].setTOF( incidentTOF );
+  }
+  G4double tb = 2. * iback;
+  if (centerOfMassEnergy < (2+G4UniformRand())) tb = (2.*iback + vecLen)/2.;
+  G4double nucsup[] = {1.0, 0.7, 0.5, 0.4, 0.35, 0.3};
+  G4double psup[] = {3. , 6. , 20., 50., 100.,1000.};
+  G4double s = centerOfMassEnergy*centerOfMassEnergy;
+  G4double xtarg = Amax(0.01, Amin(0.50, 0.312+0.2*std::log(std::log(s))+std::pow(s,1.5)/6000.)
                              * (std::pow(atomicWeight,0.33)-1.) * tb);
    G4int momentumBin = 0;
+  G4int momentumBin = 0;
    while( (momentumBin < 6) && (incidentTotalMomentum > psup[momentumBin])) momentumBin++;
    momentumBin = Imin(5, momentumBin);
 …
+     }
+   // Do some smearing in the transverse direction due to Fermi motion
+   G4double ry   = G4UniformRand();
+   G4double rz   = G4UniformRand();
+   G4double rx   = twopi*rz;
+   G4double a1   = std::sqrt(-2.0*std::log(ry));
+   G4double rantarg1 = a1*std::cos(rx)*0.02*targ/G4double(vecLen);
+   G4double rantarg2 = a1*std::sin(rx)*0.02*targ/G4double(vecLen);
+   for (i = 0; i < vecLen; i++)
+     pv[i].setMomentum( pv[i].getMomentum().x()+rantarg1,
+                        pv[i].getMomentum().y()+rantarg2 );
+   if (verboseLevel > 1) {
+     pvmx[7].setZero();
+     for (i = 0; i < vecLen; i++) pvmx[7].Add( pvmx[7], pv[i] );
+     teta = pvmx[7].Ang( pvmx[4] );
+     G4cout << " After smearing " << teta << G4endl;
+   }
+   // Rotate in the direction of the primary particle momentum (z-axis).
+   // This does disturb our inclusive distributions somewhat, but it is
+   // necessary for momentum conservation
+   // Also subtract binding energies and make some further corrections
+   // if required
+   G4double dekin = 0.0;
+   G4int npions = 0;
+   G4double ek1 = 0.0;
+   G4double alekw, xxh;
+   G4double cfa = 0.025*((atomicWeight-1.)/120.)*std::exp(-(atomicWeight-1.)/120.);
+   G4double alem[] = {1.40, 2.30, 2.70, 3.00, 3.40, 4.60, 7.00, 10.0};
+   G4double val0[] = {0.00, 0.40, 0.48, 0.51, 0.54, 0.60, 0.65, 0.70};
+   for (i = 0; i < vecLen; i++)
+      {
+        pv[i].Defs1( pv[i], pvI );
+        if (atomicWeight > 1.5)
+           {
+             ekin  = Amax( 1.e-6,pv[i].getKineticEnergy() - cfa*( 1. + 0.5*normal()));
+             alekw = std::log( incidentKineticEnergy );
+             xxh   = 1.;
+             xxh   = 1.;
+             if(incidentCode == pionPlusCode || incidentCode == pionMinusCode)
+               {
+                 if(pv[i].getCode() == pionZeroCode)
+                   {
+                     if(G4UniformRand() < std::log(atomicWeight))
+                       {
+                         if (alekw > alem[0])
+                           {
+                              for (j = 1; j < 8; j++)
+                                 {
+                                    if(alekw < alem[j]) break;
+                                 }
+                              xxh =   (val0[j]-val0[j-1])/(alem[j]-alem[j-1])*alekw
+                                     + val0[j-1] - (val0[j]-val0[j-1])/(alem[j]-alem[j-1])*alem[j-1];
+                              xxh = 1. - xxh;
+                           }
+                       }
+                    }
+               }
+             dekin += ekin*(1.-xxh);
+             ekin *= xxh;
+             pv[i].setKineticEnergyAndUpdate( ekin );
+             pvCode = pv[i].getCode();
+             if ((pvCode == pionPlusCode) || (pvCode == pionMinusCode) || (pvCode == pionZeroCode))
+                {
+                  npions += 1;
+                  ek1 += ekin;
+  // Do some smearing in the transverse direction due to Fermi motion
+  G4double ry   = G4UniformRand();
+  G4double rz   = G4UniformRand();
+  G4double rx   = twopi*rz;
+  G4double a1   = std::sqrt(-2.0*std::log(ry));
+  G4double rantarg1 = a1*std::cos(rx)*0.02*targ/G4double(vecLen);
+  G4double rantarg2 = a1*std::sin(rx)*0.02*targ/G4double(vecLen);
+  for (i = 0; i < vecLen; i++)
+    pv[i].setMomentum(pv[i].getMomentum().x()+rantarg1,
+                      pv[i].getMomentum().y()+rantarg2);
+  if (verboseLevel > 1) {
+    pvmx[7].setZero();
+    for (i = 0; i < vecLen; i++) pvmx[7].Add( pvmx[7], pv[i] );
+    teta = pvmx[7].Ang( pvmx[4] );
+    G4cout << " After smearing " << teta << G4endl;
+  }
+  // Rotate in the direction of the primary particle momentum (z-axis).
+  // This does disturb our inclusive distributions somewhat, but it is
+  // necessary for momentum conservation
+  // Also subtract binding energies and make some further corrections
+  // if required
+  G4double dekin = 0.0;
+  G4int npions = 0;
+  G4double ek1 = 0.0;
+  G4double alekw, xxh;
+  G4double cfa = 0.025*((atomicWeight-1.)/120.)*std::exp(-(atomicWeight-1.)/120.);
+  G4double alem[] = {1.40, 2.30, 2.70, 3.00, 3.40, 4.60, 7.00, 10.0};
+  G4double val0[] = {0.00, 0.40, 0.48, 0.51, 0.54, 0.60, 0.65, 0.70};
+  for (i = 0; i < vecLen; i++) {
+    pv[i].Defs1( pv[i], pvI );
+    if (atomicWeight > 1.5) {
+      ekin  = Amax( 1.e-6,pv[i].getKineticEnergy() - cfa*( 1. + 0.5*normal()));
+      alekw = std::log( incidentKineticEnergy );
+      xxh   = 1.;
+      if (incidentCode == pionPlusCode || incidentCode == pionMinusCode) {
+        if (pv[i].getCode() == pionZeroCode) {
+          if (G4UniformRand() < std::log(atomicWeight)) {
+            if (alekw > alem[0]) {
+              G4int jmax = 1;
+              for (j = 1; j < 8; j++) {
+                if (alekw < alem[j]) {
+                  jmax = j;
+                  break;
+                }
+           }
+      }
+              }
+              xxh = (val0[jmax]-val0[jmax-1])/(alem[jmax]-alem[jmax-1])*alekw
+                     + val0[jmax-1] - (val0[jmax]-val0[jmax-1])/(alem[jmax]-alem[jmax-1])*alem[jmax-1];
+              xxh = 1. - xxh;
+            }
+          }
+        }
+      }
+      dekin += ekin*(1.-xxh);
+      ekin *= xxh;
+      pv[i].setKineticEnergyAndUpdate( ekin );
+      pvCode = pv[i].getCode();
+      if ((pvCode == pionPlusCode) ||
+          (pvCode == pionMinusCode) ||
+          (pvCode == pionZeroCode)) {
+        npions += 1;
+        ek1 += ekin;
+      }
+    }
+  }
    if( (ek1 > 0.0) && (npions > 0) )
+      {
 …
+   }
    successful = true;
    delete [] pvmx;
    delete [] tempV;
    return;
+ }
+  successful = true;
+  delete [] pvmx;
+  delete [] tempV;
+  return;
+}
 void
 G4HEInelastic::MediumEnergyCascading(G4bool &successful,
+G4HEInelastic::MediumEnergyCascading(G4bool& successful,
                                      G4HEVector pv[],
                                      G4int &vecLen,
                                      G4double &excitationEnergyGNP,
                                      G4double &excitationEnergyDTA,
                                      G4HEVector incidentParticle,
                                      G4HEVector targetParticle,
+                                     G4int& vecLen,
+                                     G4double& excitationEnergyGNP,
+                                     G4double& excitationEnergyDTA,
+                                     const G4HEVector& incidentParticle,
+                                     const G4HEVector& targetParticle,
                                      G4double atomicWeight,
                                      G4double atomicNumber)
+ {
+//
+//  The multiplicity of particles produced in the first interaction has been
+//  calculated in one of the FirstIntInNuc.... routines. The nuclear
+//  cascading particles are parametrized from experimental data.
+//  A simple single variable description E D3S/DP3= F(Q) with
+//  Q^2 = (M*X)^2 + PT^2 is used. Final state kinematic is produced
+//  by an FF-type iterative cascade method.
+//  Nuclear evaporation particles are added at the end of the routine.
+//  All quantities on the G4HEVector Array pv are in GeV- units.
+   G4int protonCode       = Proton.getCode();
+   G4double protonMass    = Proton.getMass();
+   G4int neutronCode      = Neutron.getCode();
+   G4double kaonPlusMass  = KaonPlus.getMass();
+   G4int kaonPlusCode     = KaonPlus.getCode();
+   G4int kaonMinusCode    = KaonMinus.getCode();
+   G4int kaonZeroSCode    = KaonZeroShort.getCode();
+   G4int kaonZeroLCode    = KaonZeroLong.getCode();
+   G4int kaonZeroCode     = KaonZero.getCode();
+   G4int antiKaonZeroCode = AntiKaonZero.getCode();
+   G4int pionPlusCode     = PionPlus.getCode();
+   G4int pionZeroCode     = PionZero.getCode();
+   G4int pionMinusCode    = PionMinus.getCode();
+   G4String mesonType     = PionPlus.getType();
+   G4String baryonType    = Proton.getType();
+   G4String antiBaryonType= AntiProton.getType();
+   G4double targetMass   = targetParticle.getMass();
+   G4int    incidentCode          = incidentParticle.getCode();
+   G4double incidentMass          = incidentParticle.getMass();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   G4double incidentEnergy        = incidentParticle.getEnergy();
+   G4double incidentKineticEnergy = incidentParticle.getKineticEnergy();
+   G4String incidentType          = incidentParticle.getType();
+//   G4double incidentTOF           = incidentParticle.getTOF();
+   G4double incidentTOF           = 0.;
+   // some local variables
+   G4int i, j, l;
+   if(verboseLevel > 1)
+{
+  // The multiplicity of particles produced in the first interaction has been
+  // calculated in one of the FirstIntInNuc.... routines. The nuclear
+  // cascading particles are parametrized from experimental data.
+  // A simple single variable description E D3S/DP3= F(Q) with
+  // Q^2 = (M*X)^2 + PT^2 is used. Final state kinematic is produced
+  // by an FF-type iterative cascade method.
+  // Nuclear evaporation particles are added at the end of the routine.
+  // All quantities on the G4HEVector Array pv are in GeV- units.
+  G4int protonCode       = Proton.getCode();
+  G4double protonMass    = Proton.getMass();
+  G4int neutronCode      = Neutron.getCode();
+  G4double kaonPlusMass  = KaonPlus.getMass();
+  G4int kaonPlusCode     = KaonPlus.getCode();
+  G4int kaonMinusCode    = KaonMinus.getCode();
+  G4int kaonZeroSCode    = KaonZeroShort.getCode();
+  G4int kaonZeroLCode    = KaonZeroLong.getCode();
+  G4int kaonZeroCode     = KaonZero.getCode();
+  G4int antiKaonZeroCode = AntiKaonZero.getCode();
+  G4int pionPlusCode     = PionPlus.getCode();
+  G4int pionZeroCode     = PionZero.getCode();
+  G4int pionMinusCode = PionMinus.getCode();
+  G4String mesonType = PionPlus.getType();
+  G4String baryonType = Proton.getType();
+  G4String antiBaryonType = AntiProton.getType();
+  G4double targetMass = targetParticle.getMass();
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentEnergy = incidentParticle.getEnergy();
+  G4double incidentKineticEnergy = incidentParticle.getKineticEnergy();
+  G4String incidentType = incidentParticle.getType();
+//  G4double incidentTOF           = incidentParticle.getTOF();
+  G4double incidentTOF = 0.;
+  // some local variables
+  G4int i, j, l;
+  if(verboseLevel > 1)
      G4cout << " G4HEInelastic::MediumEnergyCascading " << G4endl;
    // define annihilation channels.
+  // define annihilation channels.
+   G4bool annihilation = false;
+   if (incidentCode < 0 && incidentType == antiBaryonType &&
+       pv[0].getType() != antiBaryonType &&
+       pv[1].getType() != antiBaryonType   )
+         {
+           annihilation = true;
+         }
+   successful = false;
+   G4double twsup[] = { 1., 1., 0.7, 0.5, 0.3, 0.2, 0.1, 0.0 };
+  G4bool annihilation = false;
+  if (incidentCode < 0 && incidentType == antiBaryonType &&
+      pv[0].getType() != antiBaryonType &&
+      pv[1].getType() != antiBaryonType) {
+    annihilation = true;
+  }
+  successful = false;
+  G4double twsup[] = { 1., 1., 0.7, 0.5, 0.3, 0.2, 0.1, 0.0 };
    if(annihilation) goto start;
 …
+               }
             vecLen--;
+            if(vecLen < 2) return;
+            if (vecLen < 2) {
+              delete [] pvmx;
+              return;
+            }
             i++;
             pvmx[6].Add( pvmx[4], pvmx[5] );
 …
+   }
+   // Rotate in the direction of the primary particle momentum (z-axis).
+   // This does disturb our inclusive distributions somewhat, but it is
+   // necessary for momentum conservation.
+   // Also subtract binding energies and make some further corrections
+   // if required.
+   G4double dekin = 0.0;
+   G4int npions = 0;
+   G4double ek1 = 0.0;
+   G4double alekw, xxh;
+   G4double cfa = 0.025*((atomicWeight-1.)/120.)*std::exp(-(atomicWeight-1.)/120.);
+   G4double alem[] = {1.40, 2.30, 2.70, 3.00, 3.40, 4.60, 7.00, 10.00};
+   G4double val0[] = {0.00, 0.40, 0.48, 0.51, 0.54, 0.60, 0.65,  0.70};
+   for (i = 0; i < vecLen; i++)
+      {
+        pv[i].Defs1( pv[i], pvI );
+        if (atomicWeight > 1.5)
+           {
+             ekin  = Amax( 1.e-6,pv[i].getKineticEnergy() - cfa*( 1. + 0.5*normal()));
+             alekw = std::log( incidentKineticEnergy );
+             xxh   = 1.;
+             if(incidentCode == pionPlusCode || incidentCode == pionMinusCode)
+               {
+                 if(pv[i].getCode() == pionZeroCode)
+                   {
+                     if(G4UniformRand() < std::log(atomicWeight))
+                       {
+                         if (alekw > alem[0])
+                           {
+                             for (j = 1; j < 8; j++)
+                                {
+                                  if(alekw < alem[j]) break;
+                                }
+                             xxh =   (val0[j]-val0[j-1])/(alem[j]-alem[j-1])*alekw
+                                    + val0[j-1] - (val0[j]-val0[j-1])/(alem[j]-alem[j-1])*alem[j-1];
+                             xxh = 1. - xxh;
+                           }
+                       }
+                    }
+               }
+             dekin += ekin*(1.-xxh);
+             ekin *= xxh;
+             pv[i].setKineticEnergyAndUpdate( ekin );
+             pvCode = pv[i].getCode();
+             if ((pvCode == pionPlusCode) || (pvCode == pionMinusCode) || (pvCode == pionZeroCode))
+                {
+                  npions += 1;
+                  ek1 += ekin;
+  // Rotate in the direction of the primary particle momentum (z-axis).
+  // This does disturb our inclusive distributions somewhat, but it is
+  // necessary for momentum conservation.
+  // Also subtract binding energies and make some further corrections
+  // if required.
+  G4double dekin = 0.0;
+  G4int npions = 0;
+  G4double ek1 = 0.0;
+  G4double alekw, xxh;
+  G4double cfa = 0.025*((atomicWeight-1.)/120.)*std::exp(-(atomicWeight-1.)/120.);
+  G4double alem[] = {1.40, 2.30, 2.70, 3.00, 3.40, 4.60, 7.00, 10.00};
+  G4double val0[] = {0.00, 0.40, 0.48, 0.51, 0.54, 0.60, 0.65,  0.70};
+  for (i = 0; i < vecLen; i++) {
+    pv[i].Defs1( pv[i], pvI );
+    if (atomicWeight > 1.5) {
+      ekin = Amax( 1.e-6,pv[i].getKineticEnergy() - cfa*( 1. + 0.5*normal()));
+      alekw = std::log( incidentKineticEnergy );
+      xxh = 1.;
+      if (incidentCode == pionPlusCode || incidentCode == pionMinusCode) {
+        if (pv[i].getCode() == pionZeroCode) {
+          if (G4UniformRand() < std::log(atomicWeight)) {
+            if (alekw > alem[0]) {
+              G4int jmax = 1;
+              for (j = 1; j < 8; j++) {
+                if (alekw < alem[j]) {
+                  jmax = j;
+                  break;
+                }
+           }
+      }
+              }
+              xxh = (val0[jmax] - val0[jmax-1])/(alem[jmax]-alem[jmax-1])*alekw
+                   + val0[jmax-1] - (val0[jmax]-val0[jmax-1])/(alem[jmax]-alem[jmax-1])*alem[jmax-1];
+              xxh = 1. - xxh;
+            }
+          }
+        }
+      }
+      dekin += ekin*(1.-xxh);
+      ekin *= xxh;
+      pv[i].setKineticEnergyAndUpdate( ekin );
+      pvCode = pv[i].getCode();
+      if ((pvCode == pionPlusCode) ||
+          (pvCode == pionMinusCode) ||
+          (pvCode == pionZeroCode)) {
+        npions += 1;
+        ek1 += ekin;
+      }
+    }
+  }
    if( (ek1 > 0.0) && (npions > 0) )
+      {
 …
 void
 G4HEInelastic::MediumEnergyClusterProduction(G4bool &successful,
+G4HEInelastic::MediumEnergyClusterProduction(G4bool& successful,
                                              G4HEVector pv[],
                                              G4int &vecLen,
                                              G4double &excitationEnergyGNP,
                                              G4double &excitationEnergyDTA,
                                              G4HEVector incidentParticle,
                                              G4HEVector targetParticle,
+                                             G4int& vecLen,
+                                             G4double& excitationEnergyGNP,
+                                             G4double& excitationEnergyDTA,
+                                             const G4HEVector& incidentParticle,
+                                             const G4HEVector& targetParticle,
                                              G4double atomicWeight,
                                              G4double atomicNumber)
+ {
+{
 // For low multiplicity in the first intranuclear interaction the cascading
 // process as described in G4HEInelastic::MediumEnergyCascading does not work
 …
 //  All quantities on the G4HEVector Array pv are in GeV- units.
    G4int protonCode       = Proton.getCode();
    G4double protonMass    = Proton.getMass();
    G4int neutronCode      = Neutron.getCode();
    G4double kaonPlusMass  = KaonPlus.getMass();
    G4int pionPlusCode     = PionPlus.getCode();
    G4int pionZeroCode     = PionZero.getCode();
    G4int pionMinusCode    = PionMinus.getCode();
    G4String mesonType     = PionPlus.getType();
    G4String baryonType    = Proton.getType();
    G4String antiBaryonType= AntiProton.getType();
    G4double targetMass   = targetParticle.getMass();
    G4int    incidentCode          = incidentParticle.getCode();
    G4double incidentMass          = incidentParticle.getMass();
    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
    G4double incidentEnergy        = incidentParticle.getEnergy();
    G4double incidentKineticEnergy = incidentParticle.getKineticEnergy();
    G4String incidentType          = incidentParticle.getType();
+  G4int protonCode       = Proton.getCode();
+  G4double protonMass    = Proton.getMass();
+  G4int neutronCode      = Neutron.getCode();
+  G4double kaonPlusMass  = KaonPlus.getMass();
+  G4int pionPlusCode     = PionPlus.getCode();
+  G4int pionZeroCode     = PionZero.getCode();
+  G4int pionMinusCode = PionMinus.getCode();
+  G4String mesonType = PionPlus.getType();
+  G4String baryonType = Proton.getType();
+  G4String antiBaryonType = AntiProton.getType();
+  G4double targetMass = targetParticle.getMass();
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentEnergy = incidentParticle.getEnergy();
+  G4double incidentKineticEnergy = incidentParticle.getKineticEnergy();
+  G4String incidentType = incidentParticle.getType();
 //   G4double incidentTOF           = incidentParticle.getTOF();
    G4double incidentTOF           = 0.;
    // some local variables
    G4int i, j;
    if(verboseLevel > 1) G4cout << " G4HEInelastic::MediumEnergyClusterProduction " << G4endl;
+   if (incidentTotalMomentum < 0.01)
+      {
         successful = false;
         return;
+      }
    G4double centerOfMassEnergy = std::sqrt( sqr(incidentMass) + sqr(targetMass)
                                        +2.*targetMass*incidentEnergy);
    G4HEVector pvI = incidentParticle;  // for the incident particle
    pvI.setSide( 1 );
    G4HEVector pvT = targetParticle;   // for the target particle
    pvT.setMomentumAndUpdate( 0.0, 0.0, 0.0 );
    pvT.setSide( -1 );
    pvT.setTOF( -1.);
+  G4double incidentTOF = 0.;
+  // some local variables
+  G4int i, j;
+  if (verboseLevel > 1)
+    G4cout << " G4HEInelastic::MediumEnergyClusterProduction " << G4endl;
+  if (incidentTotalMomentum < 0.01) {
+    successful = false;
+    return;
+  }
+  G4double centerOfMassEnergy = std::sqrt( sqr(incidentMass) + sqr(targetMass)
+                                        +2.*targetMass*incidentEnergy);
+  G4HEVector pvI = incidentParticle;  // for the incident particle
+  pvI.setSide( 1 );
+  G4HEVector pvT = targetParticle;   // for the target particle
+  pvT.setMomentumAndUpdate( 0.0, 0.0, 0.0 );
+  pvT.setSide( -1 );
+  pvT.setTOF( -1.);
    // Distribute particles in forward and backward hemispheres. Note that
    // only low multiplicity events from FirstIntInNuc.... should go into
    // this routine.
+  // Distribute particles in forward and backward hemispheres. Note that
+  // only low multiplicity events from FirstIntInNuc.... should go into
+  // this routine.
    G4int targ  = 0;
    G4int ifor  = 0;
    G4int iback = 0;
    G4int pvCode;
    G4double pvMass, pvEnergy;
+  G4int targ = 0;
+  G4int ifor = 0;
+  G4int iback = 0;
+  G4int pvCode;
+  G4double pvMass, pvEnergy;
    pv[0].setSide(  1 );
 …
    G4double nucsup[] = { 1.0, 0.8, 0.6, 0.5, 0.4};
    G4double xtarg = Amax(0.01,  (0.312+0.2*std::log(std::log(centerOfMassEnergy*centerOfMassEnergy)))
+   G4double xtarg = Amax(0.01, (0.312+0.2*std::log(std::log(centerOfMassEnergy*centerOfMassEnergy)))
                              * (std::pow(atomicWeight,0.33)-1.) * tb);
    G4int ntarg = Poisson(xtarg);
 …
+   }
+   G4bool dum(0);
+   G4double ekin, teta;
+   if( lead )
+     {
+       for( i=0; i<vecLen; i++ )
+          {
+            if( pv[i].getCode() == lead )
+              {
+                dum = false;
+                break;
+              }
+          }
+       if( dum )
+         {
+           i = 0;
+  G4bool dum(0);
+  G4double ekin, teta;
+  if (lead) {
+    for (i = 0; i < vecLen; i++) {
+      if (pv[i].getCode() == lead) {
+        dum = false;
+        break;
+      }
+    }
+    // At this point dum is always false, so the following code
+    // cannot be executed.  For now, comment it out.
+    /*
+    if (dum) {
+      i = 0;
            if(   (    (leadParticle.getType() == baryonType ||
                        leadParticle.getType() == antiBaryonType)
                    && (pv[1].getType() == baryonType ||
                        pv[1].getType() == antiBaryonType))
               || (    (leadParticle.getType() == mesonType)
                    && (pv[1].getType() == mesonType)))
+             {
                i = 1;
+             }
             ekin = pv[i].getKineticEnergy();
             pv[i] = leadParticle;
             if( pv[i].getFlag() )
                 pv[i].setTOF( -1.0 );
             else
                 pv[i].setTOF( 1.0 );
             pv[i].setKineticEnergyAndUpdate( ekin );
+         }
+     }
+      if ( ( (leadParticle.getType() == baryonType ||
+              leadParticle.getType() == antiBaryonType)
+            && (pv[1].getType() == baryonType ||
+                pv[1].getType() == antiBaryonType))
+            || ( (leadParticle.getType() == mesonType)
+              && (pv[1].getType() == mesonType))) {
+        i = 1;
+      }
+      ekin = pv[i].getKineticEnergy();
+      pv[i] = leadParticle;
+      if (pv[i].getFlag() )
+         pv[i].setTOF( -1.0 );
+      else
+          pv[i].setTOF( 1.0 );
+      pv[i].setKineticEnergyAndUpdate( ekin );
+    }
+    */
+  }
    pvmx[4].setMass( incidentMass);
 …
+   }
+   // Rotate in the direction of the primary particle momentum (z-axis).
+   // This does disturb our inclusive distributions somewhat, but it is
+   // necessary for momentum conservation.
+   // Also subtract binding energies and make some further corrections
+   // if required.
+   G4double dekin = 0.0;
+   G4int npions = 0;
+   G4double ek1 = 0.0;
+   G4double alekw, xxh;
+   G4double cfa = 0.025*((atomicWeight-1.)/120.)*std::exp(-(atomicWeight-1.)/120.);
+   G4double alem[] = {1.40, 2.30, 2.70, 3.00, 3.40, 4.60, 7.00};
+   G4double val0[] = {0.00, 0.40, 0.48, 0.51, 0.54, 0.60, 0.65};
+   for (i = 0; i < vecLen; i++)
+      {
+        pv[i].Defs1( pv[i], pvI );
+        if (atomicWeight > 1.5)
+           {
+             ekin  = Amax( 1.e-6,pv[i].getKineticEnergy() - cfa*( 1. + 0.5*normal()));
+             alekw = std::log( incidentKineticEnergy );
+             xxh   = 1.;
+             xxh   = 1.;
+             if(incidentCode == pionPlusCode || incidentCode == pionMinusCode)
+               {
+                 if(pv[i].getCode() == pionZeroCode)
+                   {
+                     if(G4UniformRand() < std::log(atomicWeight))
+                       {
+                         if (alekw > alem[0])
+                           {
+                              for (j = 1; j < 8; j++)
+                                 {
+                                    if(alekw < alem[j]) break;
+                                 }
+                              xxh =   (val0[j]-val0[j-1])/(alem[j]-alem[j-1])*alekw
+                                     + val0[j-1] - (val0[j]-val0[j-1])/(alem[j]-alem[j-1])*alem[j-1];
+                              xxh = 1. - xxh;
+                           }
+                       }
+                    }
+               }
+             dekin += ekin*(1.-xxh);
+             ekin *= xxh;
+             pv[i].setKineticEnergyAndUpdate( ekin );
+             pvCode = pv[i].getCode();
+             if ((pvCode == pionPlusCode) || (pvCode == pionMinusCode) || (pvCode == pionZeroCode))
+                {
+                  npions += 1;
+                  ek1 += ekin;
+  // Rotate in the direction of the primary particle momentum (z-axis).
+  // This does disturb our inclusive distributions somewhat, but it is
+  // necessary for momentum conservation.
+  // Also subtract binding energies and make some further corrections
+  // if required.
+  G4double dekin = 0.0;
+  G4int npions = 0;
+  G4double ek1 = 0.0;
+  G4double alekw, xxh;
+  G4double cfa = 0.025*((atomicWeight-1.)/120.)*std::exp(-(atomicWeight-1.)/120.);
+  G4double alem[] = {1.40, 2.30, 2.70, 3.00, 3.40, 4.60, 7.00};
+  G4double val0[] = {0.00, 0.40, 0.48, 0.51, 0.54, 0.60, 0.65};
+  for (i = 0; i < vecLen; i++) {
+    pv[i].Defs1( pv[i], pvI );
+    if (atomicWeight > 1.5) {
+      ekin  = Amax( 1.e-6,pv[i].getKineticEnergy() - cfa*( 1. + 0.5*normal()));
+      alekw = std::log( incidentKineticEnergy );
+      xxh = 1.;
+      xxh = 1.;
+      if (incidentCode == pionPlusCode || incidentCode == pionMinusCode) {
+        if (pv[i].getCode() == pionZeroCode) {
+          if (G4UniformRand() < std::log(atomicWeight)) {
+            if (alekw > alem[0]) {
+              G4int jmax = 1;
+              for (j = 1; j < 8; j++) {
+                if (alekw < alem[j]) {
+                  jmax = j;
+                  break;
+                }
+           }
+      }
+              }
+              xxh = (val0[jmax]-val0[jmax-1])/(alem[jmax]-alem[jmax-1])*alekw
+                   + val0[jmax-1] - (val0[jmax]-val0[jmax-1])/(alem[jmax]-alem[jmax-1])*alem[jmax-1];
+              xxh = 1. - xxh;
+            }
+          }
+        }
+      }
+      dekin += ekin*(1.-xxh);
+      ekin *= xxh;
+      pv[i].setKineticEnergyAndUpdate( ekin );
+      pvCode = pv[i].getCode();
+      if ((pvCode == pionPlusCode) ||
+          (pvCode == pionMinusCode) ||
+          (pvCode == pionZeroCode)) {
+        npions += 1;
+        ek1 += ekin;
+      }
+    }
+  }
    if( (ek1 > 0.0) && (npions > 0) )
+      {
 …
 void
+G4HEInelastic::QuasiElasticScattering(G4bool &successful,
+                                            G4HEVector pv[],
+                                            G4int &vecLen,
+                                            G4double &excitationEnergyGNP,
+                                            G4double &excitationEnergyDTA,
+                                            G4HEVector incidentParticle,
+                                            G4HEVector targetParticle,
+                                            G4double atomicWeight,
+                                            G4double atomicNumber )
+ {
+// if the Cascading or Resonance - model fails, we try this,
+// QuasiElasticScattering.
+//
+//  All quantities on the G4HEVector Array pv are in GeV- units.
+   G4int protonCode       = Proton.getCode();
+   G4String mesonType     = PionPlus.getType();
+   G4String baryonType    = Proton.getType();
+   G4String antiBaryonType= AntiProton.getType();
+   G4double targetMass   = targetParticle.getMass();
+   G4double incidentMass          = incidentParticle.getMass();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   G4double incidentEnergy        = incidentParticle.getEnergy();
+   G4double incidentKineticEnergy = incidentParticle.getKineticEnergy();
+   G4String incidentType          = incidentParticle.getType();
+G4HEInelastic::QuasiElasticScattering(G4bool& successful,
+                                      G4HEVector pv[],
+                                      G4int& vecLen,
+                                      G4double& excitationEnergyGNP,
+                                      G4double& excitationEnergyDTA,
+                                      const G4HEVector& incidentParticle,
+                                      const G4HEVector& targetParticle,
+                                      G4double atomicWeight,
+                                      G4double atomicNumber)
+{
+  // if the Cascading or Resonance - model fails, we try this,
+  // QuasiElasticScattering.
+  //
+  //  All quantities on the G4HEVector Array pv are in GeV- units.
+  G4int protonCode = Proton.getCode();
+  G4String mesonType = PionPlus.getType();
+  G4String baryonType = Proton.getType();
+  G4String antiBaryonType = AntiProton.getType();
+  G4double targetMass = targetParticle.getMass();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentEnergy = incidentParticle.getEnergy();
+  G4double incidentKineticEnergy = incidentParticle.getKineticEnergy();
+  G4String incidentType = incidentParticle.getType();
 //   G4double incidentTOF           = incidentParticle.getTOF();
+   G4double incidentTOF           = 0.;
+   // some local variables
+   G4int i;
+   if(verboseLevel > 1)
+     G4cout << " G4HEInelastic::QuasiElasticScattering " << G4endl;
+   if (incidentTotalMomentum < 0.01 || vecLen < 2 )
+      {
+        successful = false;
+        return;
+      }
+   G4double centerOfMassEnergy = std::sqrt( sqr(incidentMass) + sqr(targetMass)
+                                       +2.*targetMass*incidentEnergy);
+   G4HEVector pvI = incidentParticle;  // for the incident particle
+   pvI.setSide( 1 );
+   G4HEVector pvT = targetParticle;   // for the target particle
+   pvT.setMomentumAndUpdate( 0.0, 0.0, 0.0 );
+   pvT.setSide( -1 );
+   pvT.setTOF( -1.);
+   G4HEVector* pvmx = new G4HEVector[3];
+   if (atomicWeight > 1.5)   // for the following case better use ElasticScattering.
+      {
+        if (    (pvI.getCode() == pv[0].getCode() )
+             && (pvT.getCode() == pv[1].getCode() )
+             && (excitationEnergyGNP < 0.001)
+             && (excitationEnergyDTA < 0.001)                            )
+           {
+             successful = false;
+             return;
+           }
+      }
+   pv[0].setSide( 1 );
+   pv[0].setFlag( false );
+   pv[0].setTOF( incidentTOF);
+   pv[0].setMomentumAndUpdate( incidentParticle.getMomentum() );
+   pv[1].setSide( -1 );
+   pv[1].setFlag( false );
+   pv[1].setTOF( incidentTOF);
+   pv[1].setMomentumAndUpdate(targetParticle.getMomentum() );
+   if ( (incidentTotalMomentum > 0.1) && (centerOfMassEnergy > 0.01) )
+      {
+        if ( pv[1].getType() == mesonType )
+           {
+             if (G4UniformRand() < 0.5)
+                 pv[1].setDefinition( "Proton");
+             else
+                 pv[1].setDefinition( "Neutron");
+           }
+        pvmx[0].Add( pvI, pvT );
+        pvmx[1].Lor( pvI, pvmx[0] );
+        pvmx[2].Lor( pvT, pvmx[0] );
+        G4double pin = pvmx[1].Length();
+        G4double bvalue = Amax(0.01 , 4.225+1.795*std::log(incidentTotalMomentum));
+        G4double pf =   sqr( sqr(centerOfMassEnergy) + sqr(pv[1].getMass()) - sqr(pv[0].getMass()))
+                      - 4 * sqr(centerOfMassEnergy) * sqr(pv[1].getMass());
+        if ( pf < 0.001)
+           {
+             successful = false;
+             return;
+           }
+        pf = std::sqrt(pf)/(2.*centerOfMassEnergy);
+        G4double btrang = 4. * bvalue * pin * pf;
+        G4double exindt = -1.;
+        if (btrang < 46.) exindt += std::exp(-btrang);
+        G4double tdn = std::log(1. + G4UniformRand()*exindt)/btrang;
+        G4double ctet = Amax( -1., Amin(1., 1. + 2.*tdn));
+        G4double stet = std::sqrt((1.-ctet)*(1.+ctet));
+        G4double phi  = twopi * G4UniformRand();
+        pv[0].setMomentumAndUpdate( pf*stet*std::sin(phi),
+                                    pf*stet*std::cos(phi),
+                                    pf*ctet         );
+        pv[1].SmulAndUpdate( pv[0], -1.);
+        for (i = 0; i < 2; i++)
+           {
+             pv[i].Lor( pv[i], pvmx[4] );
+             pv[i].Defs1( pv[i], pvI );
+             if (atomicWeight > 1.5)
+               {
+                 G4double ekin =    pv[i].getKineticEnergy()
+                                 -  0.025*((atomicWeight-1.)/120.)*std::exp(-(atomicWeight-1.)/120.)
+                                   *(1. + 0.5*normal());
+                 ekin = Amax(0.0001, ekin);
+                 pv[i].setKineticEnergyAndUpdate( ekin );
+               }
+           }
+      }
+   vecLen = 2;
+   //  add black track particles
+   //  the total number of particles produced is restricted to 198
+   //  this may have influence on very high energies
+   if (verboseLevel > 1)
+     G4cout << " Evaporation " << atomicWeight << " " <<
+               excitationEnergyGNP << " " <<  excitationEnergyDTA << G4endl;
+  G4double incidentTOF = 0.;
+  // some local variables
+  G4int i;
+  if (verboseLevel > 1)
+    G4cout << " G4HEInelastic::QuasiElasticScattering " << G4endl;
+  if (incidentTotalMomentum < 0.01 || vecLen < 2) {
+    successful = false;
+    return;
+  }
+  G4double centerOfMassEnergy = std::sqrt( sqr(incidentMass) + sqr(targetMass)
+                                        +2.*targetMass*incidentEnergy);
+  G4HEVector pvI = incidentParticle;  // for the incident particle
+  pvI.setSide( 1 );
+  G4HEVector pvT = targetParticle;   // for the target particle
+  pvT.setMomentumAndUpdate( 0.0, 0.0, 0.0 );
+  pvT.setSide( -1 );
+  pvT.setTOF( -1.);
+  G4HEVector* pvmx = new G4HEVector[3];
+  if (atomicWeight > 1.5) {
+    // for the following case better use ElasticScattering
+    if (   (pvI.getCode() == pv[0].getCode() )
+        && (pvT.getCode() == pv[1].getCode() )
+        && (excitationEnergyGNP < 0.001)
+        && (excitationEnergyDTA < 0.001) ) {
+      successful = false;
+      delete [] pvmx;
+      return;
+    }
+  }
+  pv[0].setSide( 1 );
+  pv[0].setFlag( false );
+  pv[0].setTOF( incidentTOF);
+  pv[0].setMomentumAndUpdate( incidentParticle.getMomentum() );
+  pv[1].setSide( -1 );
+  pv[1].setFlag( false );
+  pv[1].setTOF( incidentTOF);
+  pv[1].setMomentumAndUpdate(targetParticle.getMomentum() );
+  if ((incidentTotalMomentum > 0.1) && (centerOfMassEnergy > 0.01) ) {
+    if (pv[1].getType() == mesonType) {
+      if (G4UniformRand() < 0.5)
+        pv[1].setDefinition( "Proton");
+      else
+        pv[1].setDefinition( "Neutron");
+    }
+    pvmx[0].Add( pvI, pvT );
+    pvmx[1].Lor( pvI, pvmx[0] );
+    pvmx[2].Lor( pvT, pvmx[0] );
+    G4double pin = pvmx[1].Length();
+    G4double bvalue = Amax(0.01 , 4.225+1.795*std::log(incidentTotalMomentum));
+    G4double pf = sqr(sqr(centerOfMassEnergy) + sqr(pv[1].getMass()) - sqr(pv[0].getMass()))
+                  - 4 * sqr(centerOfMassEnergy) * sqr(pv[1].getMass());
+    if (pf < 0.001) {
+      successful = false;
+      delete [] pvmx;
+      return;
+    }
+    pf = std::sqrt(pf)/(2.*centerOfMassEnergy);
+    G4double btrang = 4. * bvalue * pin * pf;
+    G4double exindt = -1.;
+    if (btrang < 46.) exindt += std::exp(-btrang);
+    G4double tdn = std::log(1. + G4UniformRand()*exindt)/btrang;
+    G4double ctet = Amax( -1., Amin(1., 1. + 2.*tdn));
+    G4double stet = std::sqrt((1.-ctet)*(1.+ctet));
+    G4double phi  = twopi * G4UniformRand();
+    pv[0].setMomentumAndUpdate( pf*stet*std::sin(phi),
+                                pf*stet*std::cos(phi),
+                                pf*ctet         );
+    pv[1].SmulAndUpdate( pv[0], -1.);
+    for (i = 0; i < 2; i++) {
+      // **  pv[i].Lor( pv[i], pvmx[4] );
+      // ** DHW 1 Dec 2010 : index 4 out of range : use 0
+      pv[i].Lor(pv[i], pvmx[0]);
+      pv[i].Defs1(pv[i], pvI);
+      if (atomicWeight > 1.5) {
+        G4double ekin = pv[i].getKineticEnergy()
+                     -  0.025*((atomicWeight-1.)/120.)*std::exp(-(atomicWeight-1.)/120.)
+                       *(1. + 0.5*normal());
+        ekin = Amax(0.0001, ekin);
+        pv[i].setKineticEnergyAndUpdate( ekin );
+      }
+    }
+  }
+  vecLen = 2;
+  //  add black track particles
+  //  the total number of particles produced is restricted to 198
+  //  this may have influence on very high energies
+  if (verboseLevel > 1)
+    G4cout << " Evaporation " << atomicWeight << " "
+           << excitationEnergyGNP << " " <<  excitationEnergyDTA << G4endl;
    if( atomicWeight > 1.5 )
 …
+   }
    successful = true;
    delete [] pvmx;
    return;
+ }
+  successful = true;
+  delete [] pvmx;
+  return;
+}
 void
 G4HEInelastic::ElasticScattering(G4bool &successful,
+G4HEInelastic::ElasticScattering(G4bool& successful,
                                  G4HEVector pv[],
                                  G4int &vecLen,
                                  G4HEVector incidentParticle,
+                                 G4int& vecLen,
+                                 const G4HEVector& incidentParticle,
                                  G4double atomicWeight,
                                  G4double /* atomicNumber*/)
+ {
    if(verboseLevel > 1)
      G4cout << " G4HEInelastic::ElasticScattering " << G4endl;
    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
    if (verboseLevel > 1)
      G4cout << "DoIt: Incident particle momentum="
             << incidentTotalMomentum << " GeV" << G4endl;
    if (incidentTotalMomentum < 0.01)
+      {
         successful = false;
         return;
+      }
+{
+  if (verboseLevel > 1)
+    G4cout << " G4HEInelastic::ElasticScattering " << G4endl;
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  if (verboseLevel > 1)
+    G4cout << "DoIt: Incident particle momentum="
+           << incidentTotalMomentum << " GeV" << G4endl;
+  if (incidentTotalMomentum < 0.01) {
+      successful = false;
+      return;
+  }
    if (atomicWeight < 0.5)
+      {

trunk/source/processes/hadronic/models/high_energy/src/G4HEKaonMinusInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HEKaonMinusInelastic.cc,v 1.14 2008/03/17 20:49:17 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HEKaonMinusInelastic.cc,v 1.16 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff
+// and the low energy two-body model.  Not included is the low energy stuff
 // like nuclear reactions, nuclear fission without any cascading and all
 // processes for particles at rest.
 …
 #include "G4HEKaonMinusInelastic.hh"
 G4HadFinalState *  G4HEKaonMinusInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
     const G4HadProjectile *aParticle = &aTrack;
 //    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
     const G4double A = targetNucleus.GetN();
     const G4double Z = targetNucleus.GetZ();
     G4HEVector incidentParticle(aParticle);
+G4HadFinalState*
+G4HEKaonMinusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                      G4Nucleus& targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
+  const G4double A = targetNucleus.GetN();
+  const G4double Z = targetNucleus.GetZ();
+  G4HEVector incidentParticle(aParticle);
+    G4double atomicNumber = Z;
+    G4double atomicWeight = A;
+    G4int    incidentCode          = incidentParticle.getCode();
+    G4double incidentMass          = incidentParticle.getMass();
+    G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+    if(incidentKineticEnergy < 1.)
+      {
+        G4cout << "GHEKaonMinusInelastic: incident energy < 1 GeV" << G4endl;
+      }
+    if(verboseLevel > 1)
+      {
+        G4cout << "G4HEKaonMinusInelastic::ApplyYourself" << G4endl;
+        G4cout << "incident particle " << incidentParticle.getName()
+             << "mass "              << incidentMass
+             << "kinetic energy "    << incidentKineticEnergy
+             << G4endl;
+        G4cout << "target material with (A,Z) = ("
+             << atomicWeight << "," << atomicNumber << ")" << G4endl;
+      }
+    G4double inelasticity  = NuclearInelasticity(incidentKineticEnergy,
+                                                 atomicWeight, atomicNumber);
+    if(verboseLevel > 1)
+        G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+    incidentKineticEnergy -= inelasticity;
+  G4double atomicNumber = Z;
+  G4double atomicWeight = A;
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+  if (incidentKineticEnergy < 1.)
+    G4cout << "GHEKaonMinusInelastic: incident energy < 1 GeV" << G4endl;
+  if (verboseLevel > 1) {
+    G4cout << "G4HEKaonMinusInelastic::ApplyYourself" << G4endl;
+    G4cout << "incident particle " << incidentParticle.getName()
+           << "mass "              << incidentMass
+           << "kinetic energy "    << incidentKineticEnergy
+           << G4endl;
+    G4cout << "target material with (A,Z) = ("
+           << atomicWeight << "," << atomicNumber << ")" << G4endl;
+  }
+  G4double inelasticity = NuclearInelasticity(incidentKineticEnergy,
+                                            atomicWeight, atomicNumber);
+  if (verboseLevel > 1)
+    G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+  incidentKineticEnergy -= inelasticity;
     G4double excitationEnergyGNP = 0.;
     G4double excitationEnergyDTA = 0.;
     G4double excitation    = NuclearExcitation(incidentKineticEnergy,
                                                atomicWeight, atomicNumber,
                                                excitationEnergyGNP,
                                                excitationEnergyDTA);
     if(verboseLevel > 1)
       G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+  G4double excitationEnergyGNP = 0.;
+  G4double excitationEnergyDTA = 0.;
+  G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                          atomicWeight, atomicNumber,
+                                          excitationEnergyGNP,
+                                          excitationEnergyDTA);
+  if (verboseLevel > 1)
+    G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
            << excitationEnergyDTA << G4endl;
+    incidentKineticEnergy -= excitation;
+    incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+    G4HEVector targetParticle;
+    if(G4UniformRand() < atomicNumber/atomicWeight)
+      {
+        targetParticle.setDefinition("Proton");
+      }
+    else
+      {
+        targetParticle.setDefinition("Neutron");
+      }
+    G4double targetMass         = targetParticle.getMass();
+    G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+    G4double availableEnergy    = centerOfMassEnergy - targetMass - incidentMass;
+                                                                // this was the meaning of inElastic in the
+                                                                // original Gheisha stand-alone version.
+//    G4bool   inElastic          = InElasticCrossSectionInFirstInt
+//                                    (availableEnergy, incidentCode, incidentTotalMomentum);
+                                                                // by unknown reasons, it has been replaced
+                                                                // to the following code in Geant???
+    G4bool inElastic = true;
+//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+    vecLength  = 0;
+    if(verboseLevel > 1)
+      G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+  incidentKineticEnergy -= excitation;
+  incidentTotalEnergy = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                    *(incidentTotalEnergy+incidentMass));
+  G4HEVector targetParticle;
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
+    targetParticle.setDefinition("Proton");
+  } else {
+    targetParticle.setDefinition("Neutron");
+  }
+  G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                        + targetMass*targetMass
+                                        + 2.0*targetMass*incidentTotalEnergy);
+  G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
+  G4bool inElastic = true;
+  vecLength = 0;
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
            << incidentCode << G4endl;
     G4bool successful = false;
+  G4bool successful = false;
+    if(inElastic || (!inElastic && atomicWeight < 1.5))
+      {
+        FirstIntInCasKaonMinus(inElastic, availableEnergy, pv, vecLength,
+                               incidentParticle, targetParticle);
+        if(verboseLevel > 1)
+           G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+        if ((vecLength > 0) && (availableEnergy > 1.))
+                   StrangeParticlePairProduction( availableEnergy, centerOfMassEnergy,
+                                                  pv, vecLength,
+                                                  incidentParticle, targetParticle);
+            HighEnergyCascading( successful, pv, vecLength,
+                                 excitationEnergyGNP, excitationEnergyDTA,
+                                 incidentParticle, targetParticle,
+                                 atomicWeight, atomicNumber);
+        if (!successful)
+            HighEnergyClusterProduction( successful, pv, vecLength,
+                                         excitationEnergyGNP, excitationEnergyDTA,
+                                         incidentParticle, targetParticle,
+                                         atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyCascading( successful, pv, vecLength,
+                                   excitationEnergyGNP, excitationEnergyDTA,
+                                   incidentParticle, targetParticle,
+                                   atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyClusterProduction( successful, pv, vecLength,
+                                           excitationEnergyGNP, excitationEnergyDTA,
+                                           incidentParticle, targetParticle,
+                                           atomicWeight, atomicNumber);
+        if (!successful)
+            QuasiElasticScattering( successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+            ElasticScattering( successful, pv, vecLength,
+                               incidentParticle,
+                               atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+        G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles" << G4endl;
+      }
+      FillParticleChange(pv,  vecLength);
+      delete [] pv;
+      theParticleChange.SetStatusChange(stopAndKill);
+      return & theParticleChange;
+  }
+  FirstIntInCasKaonMinus(inElastic, availableEnergy, pv, vecLength,
+                         incidentParticle, targetParticle);
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+                                  incidentParticle, targetParticle,
+                                  atomicWeight, atomicNumber);
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
+  if (!successful)
+    ElasticScattering(successful, pv, vecLength,
+                      incidentParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+           << G4endl;
+  FillParticleChange(pv,  vecLength);
+  delete [] pv;
+  theParticleChange.SetStatusChange(stopAndKill);
+  return &theParticleChange;
+}
 void
   G4HEKaonMinusInelastic::FirstIntInCasKaonMinus( G4bool &inElastic,
                                                   const G4double availableEnergy,
                                                   G4HEVector pv[],
                                                   G4int &vecLen,
                                                   G4HEVector incidentParticle,
                                                   G4HEVector targetParticle)
+G4HEKaonMinusInelastic::FirstIntInCasKaonMinus(G4bool& inElastic,
+                                               const G4double availableEnergy,
+                                               G4HEVector pv[],
+                                               G4int& vecLen,
+                                               const G4HEVector& incidentParticle,
+                                               const G4HEVector& targetParticle)
 // Kaon- undergoes interaction with nucleon within a nucleus.  Check if it is
 …
 // protons/neutrons by kaons or strange baryons according to the average
 // multiplicity per inelastic reaction.
+ {
+   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
+   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+   static const G4double protb = 0.7;
+   static const G4double neutb = 0.7;
+   static const G4double     c = 1.25;
+   static const G4int   numMul = 1200;
+   static const G4int   numSec = 60;
+   G4int              neutronCode = Neutron.getCode();
+   G4int               protonCode = Proton.getCode();
+   G4int            kaonMinusCode = KaonMinus.getCode();
+   G4int             kaonZeroCode = KaonZero.getCode();
+   G4int         antiKaonZeroCode = AntiKaonZero.getCode();
+   G4int               targetCode = targetParticle.getCode();
+//   G4double          incidentMass = incidentParticle.getMass();
+//   G4double        incidentEnergy = incidentParticle.getEnergy();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   static G4bool first = true;
+   static G4double protmul[numMul], protnorm[numSec];  // proton constants
+   static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+//                                misc. local variables
+//                                np = number of pi+,  nm = number of pi-,  nz = number of pi0
+   G4int i, counter, nt, np, nm, nz;
+{
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;         // lower bound for arg. of exp
+  static const G4double protb = 0.7;
+  static const G4double neutb = 0.7;
+  static const G4double     c = 1.25;
+  static const G4int numMul = 1200;
+  static const G4int numSec = 60;
+  G4int neutronCode = Neutron.getCode();
+  G4int protonCode = Proton.getCode();
+  G4int kaonMinusCode = KaonMinus.getCode();
+  G4int kaonZeroCode = KaonZero.getCode();
+  G4int antiKaonZeroCode = AntiKaonZero.getCode();
+  G4int targetCode = targetParticle.getCode();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  static G4bool first = true;
+  static G4double protmul[numMul], protnorm[numSec];  // proton constants
+  static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+  // misc. local variables
+  // np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  G4int i, counter, nt, np, nm, nz;
    if( first )
      {                         // compute normalization constants, this will only be done once
+     {       // compute normalization constants, this will only be done once
        first = false;
        for( i=0; i<numMul; i++ )protmul[i]  = 0.0;

trunk/source/processes/hadronic/models/high_energy/src/G4HEKaonPlusInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HEKaonPlusInelastic.cc,v 1.14 2008/03/17 20:49:17 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HEKaonPlusInelastic.cc,v 1.16 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model. Not included are the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 // First work done by J.L.Chuma and F.W.Jones, TRIUMF, June 96.
 // H. Fesefeldt, RWTH-Aachen, 23-October-1996
 …
 #include "G4HEKaonPlusInelastic.hh"
 G4HadFinalState *  G4HEKaonPlusInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
     const G4HadProjectile *aParticle = &aTrack;
 //    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
     const G4double A = targetNucleus.GetN();
     const G4double Z = targetNucleus.GetZ();
     G4HEVector incidentParticle(aParticle);
+G4HadFinalState*
+G4HEKaonPlusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                     G4Nucleus& targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
+  const G4double A = targetNucleus.GetN();
+  const G4double Z = targetNucleus.GetZ();
+  G4HEVector incidentParticle(aParticle);
+    G4double atomicNumber = Z;
+    G4double atomicWeight = A;
+    G4int    incidentCode          = incidentParticle.getCode();
+    G4double incidentMass          = incidentParticle.getMass();
+    G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+    if(incidentKineticEnergy < 1.)
+      {
+        G4cout << "GHEKaonPlusInelastic: incident energy < 1 GeV" << G4endl;
+      }
+    if(verboseLevel > 1)
+      {
+        G4cout << "G4HEKaonPlusInelastic::ApplyYourself" << G4endl;
+        G4cout << "incident particle " << incidentParticle.getName()
+             << "mass "              << incidentMass
+             << "kinetic energy "    << incidentKineticEnergy
+             << G4endl;
+        G4cout << "target material with (A,Z) = ("
+             << atomicWeight << "," << atomicNumber << ")" << G4endl;
+      }
+    G4double inelasticity  = NuclearInelasticity(incidentKineticEnergy,
+                                                 atomicWeight, atomicNumber);
+    if(verboseLevel > 1)
+        G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+  G4double atomicNumber = Z;
+  G4double atomicWeight = A;
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+  if (incidentKineticEnergy < 1.)
+    G4cout << "GHEKaonPlusInelastic: incident energy < 1 GeV" << G4endl;
+  if (verboseLevel > 1) {
+    G4cout << "G4HEKaonPlusInelastic::ApplyYourself" << G4endl;
+    G4cout << "incident particle " << incidentParticle.getName()
+           << "mass "              << incidentMass
+           << "kinetic energy "    << incidentKineticEnergy
+           << G4endl;
+    G4cout << "target material with (A,Z) = ("
+           << atomicWeight << "," << atomicNumber << ")" << G4endl;
+  }
+  G4double inelasticity = NuclearInelasticity(incidentKineticEnergy,
+                                              atomicWeight, atomicNumber);
+  if (verboseLevel > 1)
+    G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
     incidentKineticEnergy -= inelasticity;
+  incidentKineticEnergy -= inelasticity;
     G4double excitationEnergyGNP = 0.;
     G4double excitationEnergyDTA = 0.;
     G4double excitation    = NuclearExcitation(incidentKineticEnergy,
                                                atomicWeight, atomicNumber,
                                                excitationEnergyGNP,
                                                excitationEnergyDTA);
     if(verboseLevel > 1)
       G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+  G4double excitationEnergyGNP = 0.;
+  G4double excitationEnergyDTA = 0.;
+  G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                          atomicWeight, atomicNumber,
+                                          excitationEnergyGNP,
+                                          excitationEnergyDTA);
+  if (verboseLevel > 1)
+    G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
            << excitationEnergyDTA << G4endl;
+    incidentKineticEnergy -= excitation;
+    incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+    G4HEVector targetParticle;
+    if(G4UniformRand() < atomicNumber/atomicWeight)
+      {
+        targetParticle.setDefinition("Proton");
+      }
+    else
+      {
+        targetParticle.setDefinition("Neutron");
+      }
+    G4double targetMass         = targetParticle.getMass();
+    G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+    G4double availableEnergy    = centerOfMassEnergy - targetMass - incidentMass;
+                                                                // this was the meaning of inElastic in the
+                                                                // original Gheisha stand-alone version.
+//    G4bool   inElastic          = InElasticCrossSectionInFirstInt
+//                                    (availableEnergy, incidentCode, incidentTotalMomentum);
+                                                                // by unknown reasons, it has been replaced
+                                                                // to the following code in Geant???
+    G4bool inElastic = true;
+//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+    vecLength  = 0;
+  incidentKineticEnergy -= excitation;
+  incidentTotalEnergy = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                    *(incidentTotalEnergy+incidentMass));
+  G4HEVector targetParticle;
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
+    targetParticle.setDefinition("Proton");
+  } else {
+    targetParticle.setDefinition("Neutron");
+  }
+  G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                        + targetMass*targetMass
+                                        + 2.0*targetMass*incidentTotalEnergy);
+  G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
+  G4bool inElastic = true;
+  vecLength = 0;
     if(verboseLevel > 1)
       G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
            << incidentCode << G4endl;
     G4bool successful = false;
+  G4bool successful = false;
+    if(inElastic || (!inElastic && atomicWeight < 1.5))
+      {
+        FirstIntInCasKaonPlus(inElastic, availableEnergy, pv, vecLength,
+                              incidentParticle, targetParticle, atomicWeight);
+        if(verboseLevel > 1)
+           G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+        if ((vecLength > 0) && (availableEnergy > 1.))
+                   StrangeParticlePairProduction( availableEnergy, centerOfMassEnergy,
+                                                  pv, vecLength,
+                                                  incidentParticle, targetParticle);
+            HighEnergyCascading( successful, pv, vecLength,
+                                 excitationEnergyGNP, excitationEnergyDTA,
+                                 incidentParticle, targetParticle,
+                                 atomicWeight, atomicNumber);
+        if (!successful)
+            HighEnergyClusterProduction( successful, pv, vecLength,
+                                         excitationEnergyGNP, excitationEnergyDTA,
+                                         incidentParticle, targetParticle,
+                                         atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyCascading( successful, pv, vecLength,
+                                   excitationEnergyGNP, excitationEnergyDTA,
+                                   incidentParticle, targetParticle,
+                                   atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyClusterProduction( successful, pv, vecLength,
+                                           excitationEnergyGNP, excitationEnergyDTA,
+                                           incidentParticle, targetParticle,
+                                           atomicWeight, atomicNumber);
+        if (!successful)
+            QuasiElasticScattering( successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+            ElasticScattering( successful, pv, vecLength,
+                               incidentParticle,
+                               atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+        G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles" << G4endl;
+      }
+      FillParticleChange(pv,  vecLength);
+      delete [] pv;
+      theParticleChange.SetStatusChange(stopAndKill);
+      return & theParticleChange;
+  }
+  FirstIntInCasKaonPlus(inElastic, availableEnergy, pv, vecLength,
+                        incidentParticle, targetParticle, atomicWeight);
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+                                  incidentParticle, targetParticle,
+                                  atomicWeight, atomicNumber);
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
+  if (!successful)
+    ElasticScattering(successful, pv, vecLength,
+                      incidentParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+           << G4endl;
+  FillParticleChange(pv,  vecLength);
+  delete [] pv;
+  theParticleChange.SetStatusChange(stopAndKill);
+  return &theParticleChange;
+}
 void
 G4HEKaonPlusInelastic::FirstIntInCasKaonPlus( G4bool &inElastic,
                                               const G4double availableEnergy,
                                               G4HEVector pv[],
                                               G4int &vecLen,
                                               G4HEVector incidentParticle,
                                               G4HEVector targetParticle,
                                               const G4double atomicWeight)
+G4HEKaonPlusInelastic::FirstIntInCasKaonPlus(G4bool& inElastic,
+                                             const G4double availableEnergy,
+                                             G4HEVector pv[],
+                                             G4int& vecLen,
+                                             const G4HEVector& incidentParticle,
+                                             const G4HEVector& targetParticle,
+                                             const G4double atomicWeight)
 // Kaon+ undergoes interaction with nucleon within a nucleus.  Check if it is
 …
 // protons/neutrons by kaons or strange baryons according to the average
 // multiplicity per inelastic reaction.
+ {
+   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
+   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+   static const G4double protb = 0.7;
+   static const G4double neutb = 0.7;
+   static const G4double     c = 1.25;
+   static const G4int   numMul = 1200;
+   static const G4int   numSec = 60;
+   G4int              neutronCode = Neutron.getCode();
+   G4int              protonCode  = Proton.getCode();
+   G4int               targetCode = targetParticle.getCode();
+//   G4double          incidentMass = incidentParticle.getMass();
+//   G4double        incidentEnergy = incidentParticle.getEnergy();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   static G4bool first = true;
+   static G4double protmul[numMul], protnorm[numSec];  // proton constants
+   static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+//                                misc. local variables
+//                                np = number of pi+,  nm = number of pi-,  nz = number of pi0
+   G4int i, counter, nt, np, nm, nz;
+{
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
+  static const G4double protb = 0.7;
+  static const G4double neutb = 0.7;
+  static const G4double     c = 1.25;
+  static const G4int   numMul = 1200;
+  static const G4int   numSec = 60;
+  G4int neutronCode = Neutron.getCode();
+  G4int protonCode = Proton.getCode();
+  G4int targetCode = targetParticle.getCode();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  static G4bool first = true;
+  static G4double protmul[numMul], protnorm[numSec];  // proton constants
+  static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+  // misc. local variables
+  // np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  G4int i, counter, nt, np, nm, nz;
    if( first )
      {                         // compute normalization constants, this will only be done once
+     {         // compute normalization constants, this will only be done once
        first = false;
        for( i=0; i<numMul; i++ )protmul[i]  = 0.0;

trunk/source/processes/hadronic/models/high_energy/src/G4HEKaonZeroInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HEKaonZeroInelastic.cc,v 1.16 2010/02/09 22:02:20 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HEKaonZeroInelastic.cc,v 1.18 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model. Not included are the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 // First work done by J.L.Chuma and F.W.Jones, TRIUMF, June 96.
 // H. Fesefeldt, RWTH-Aachen, 23-October-1996
 …
 #include "G4HEKaonZeroInelastic.hh"
 G4HadFinalState *  G4HEKaonZeroInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
     const G4HadProjectile *aParticle = &aTrack;
 //    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
     const G4double A = targetNucleus.GetN();
     const G4double Z = targetNucleus.GetZ();
     G4HEVector incidentParticle(aParticle);
+G4HadFinalState*
+G4HEKaonZeroInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                     G4Nucleus& targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
+  const G4double A = targetNucleus.GetN();
+  const G4double Z = targetNucleus.GetZ();
+  G4HEVector incidentParticle(aParticle);
+    G4double atomicNumber = Z;
+    G4double atomicWeight = A;
+    G4int    incidentCode          = incidentParticle.getCode();
+    G4double incidentMass          = incidentParticle.getMass();
+    G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+    if(incidentKineticEnergy < 1.)
+      {
+        G4cout << "GHEKaonZeroInelastic: incident energy < 1 GeV" << G4endl;;
+      }
+    if(verboseLevel > 1)
+      {
+        G4cout << "G4HEKaonZeroInelastic::ApplyYourself" << G4endl;
+        G4cout << "incident particle " << incidentParticle.getName()
+             << "mass "              << incidentMass
+             << "kinetic energy "    << incidentKineticEnergy
+             << G4endl;
+        G4cout << "target material with (A,Z) = ("
+             << atomicWeight << "," << atomicNumber << ")" << G4endl;
+      }
+  G4double atomicNumber = Z;
+  G4double atomicWeight = A;
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+  if (incidentKineticEnergy < 1.)
+    G4cout << "GHEKaonZeroInelastic: incident energy < 1 GeV" << G4endl;;
+  if (verboseLevel > 1) {
+    G4cout << "G4HEKaonZeroInelastic::ApplyYourself" << G4endl;
+    G4cout << "incident particle " << incidentParticle.getName()
+           << "mass "              << incidentMass
+           << "kinetic energy "    << incidentKineticEnergy
+           << G4endl;
+    G4cout << "target material with (A,Z) = ("
+           << atomicWeight << "," << atomicNumber << ")" << G4endl;
+  }
     G4double inelasticity  = NuclearInelasticity(incidentKineticEnergy,
                                                  atomicWeight, atomicNumber);
     if(verboseLevel > 1)
         G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+  G4double inelasticity = NuclearInelasticity(incidentKineticEnergy,
+                                              atomicWeight, atomicNumber);
+  if (verboseLevel > 1)
+    G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
     incidentKineticEnergy -= inelasticity;
+  incidentKineticEnergy -= inelasticity;
     G4double excitationEnergyGNP = 0.;
     G4double excitationEnergyDTA = 0.;
     G4double excitation    = NuclearExcitation(incidentKineticEnergy,
                                                atomicWeight, atomicNumber,
                                                excitationEnergyGNP,
                                                excitationEnergyDTA);
     if(verboseLevel > 1)
       G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+  G4double excitationEnergyGNP = 0.;
+  G4double excitationEnergyDTA = 0.;
+  G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                          atomicWeight, atomicNumber,
+                                          excitationEnergyGNP,
+                                          excitationEnergyDTA);
+  if (verboseLevel > 1)
+    G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
            << excitationEnergyDTA << G4endl;
+    incidentKineticEnergy -= excitation;
+    incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+    G4HEVector targetParticle;
+    if(G4UniformRand() < atomicNumber/atomicWeight)
+      {
+        targetParticle.setDefinition("Proton");
+      }
+    else
+      {
+        targetParticle.setDefinition("Neutron");
+      }
+    G4double targetMass         = targetParticle.getMass();
+    G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+    G4double availableEnergy    = centerOfMassEnergy - targetMass - incidentMass;
+                                                                // this was the meaning of inElastic in the
+                                                                // original Gheisha stand-alone version.
+//    G4bool   inElastic          = InElasticCrossSectionInFirstInt
+//                                    (availableEnergy, incidentCode, incidentTotalMomentum);
+                                                                // by unknown reasons, it has been replaced
+                                                                // to the following code in Geant???
+    G4bool inElastic = true;
+//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+    vecLength = 0;
+    if(verboseLevel > 1)
+      G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+  incidentKineticEnergy -= excitation;
+  incidentTotalEnergy = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                    *(incidentTotalEnergy+incidentMass));
+  G4HEVector targetParticle;
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
+    targetParticle.setDefinition("Proton");
+  } else {
+    targetParticle.setDefinition("Neutron");
+  }
+  G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                        + targetMass*targetMass
+                                        + 2.0*targetMass*incidentTotalEnergy);
+  G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
+  G4bool inElastic = true;
+  vecLength = 0;
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
            << incidentCode << G4endl;
     G4bool successful = false;
+  G4bool successful = false;
+    if(inElastic || (!inElastic && atomicWeight < 1.5))
+      {
+        FirstIntInCasKaonZero(inElastic, availableEnergy, pv, vecLength,
+                              incidentParticle, targetParticle, atomicWeight);
+        if(verboseLevel > 1)
+           G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+        if ((vecLength > 0) && (availableEnergy > 1.))
+                   StrangeParticlePairProduction( availableEnergy, centerOfMassEnergy,
+                                                  pv, vecLength,
+                                                  incidentParticle, targetParticle);
+            HighEnergyCascading( successful, pv, vecLength,
+                                 excitationEnergyGNP, excitationEnergyDTA,
+                                 incidentParticle, targetParticle,
+                                 atomicWeight, atomicNumber);
+        if (!successful)
+            HighEnergyClusterProduction( successful, pv, vecLength,
+                                         excitationEnergyGNP, excitationEnergyDTA,
+                                         incidentParticle, targetParticle,
+                                         atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyCascading( successful, pv, vecLength,
+                                   excitationEnergyGNP, excitationEnergyDTA,
+                                   incidentParticle, targetParticle,
+                                   atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyClusterProduction( successful, pv, vecLength,
+                                           excitationEnergyGNP, excitationEnergyDTA,
+                                           incidentParticle, targetParticle,
+                                           atomicWeight, atomicNumber);
+        if (!successful)
+            QuasiElasticScattering( successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+            ElasticScattering( successful, pv, vecLength,
+                               incidentParticle,
+                               atomicWeight, atomicNumber);
+      }
+    if (!successful)
+        G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+               << G4endl;
+    FillParticleChange(pv,  vecLength);
+    delete [] pv;
+    theParticleChange.SetStatusChange(stopAndKill);
+    return & theParticleChange;
+  }
+  FirstIntInCasKaonZero(inElastic, availableEnergy, pv, vecLength,
+                        incidentParticle, targetParticle, atomicWeight);
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+                                  incidentParticle, targetParticle,
+                                  atomicWeight, atomicNumber);
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
+  if (!successful)
+    ElasticScattering(successful, pv, vecLength,
+                      incidentParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+           << G4endl;
+  FillParticleChange(pv,  vecLength);
+  delete [] pv;
+  theParticleChange.SetStatusChange(stopAndKill);
+  return &theParticleChange;
+}
 void
 G4HEKaonZeroInelastic::FirstIntInCasKaonZero( G4bool &inElastic,
                                               const G4double availableEnergy,
                                               G4HEVector pv[],
                                               G4int &vecLen,
                                               G4HEVector incidentParticle,
                                               G4HEVector targetParticle,
                                               const G4double atomicWeight)
+G4HEKaonZeroInelastic::FirstIntInCasKaonZero(G4bool& inElastic,
+                                             const G4double availableEnergy,
+                                             G4HEVector pv[],
+                                             G4int& vecLen,
+                                             const G4HEVector& incidentParticle,
+                                             const G4HEVector& targetParticle,
+                                             const G4double atomicWeight)
 // Kaon0 undergoes interaction with nucleon within a nucleus.  Check if it is
 …
 // protons/neutrons by kaons or strange baryons according to the average
 // multiplicity per inelastic reaction.
+ {
+   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
+   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+   static const G4double protb = 0.7;
+   static const G4double neutb = 0.7;
+   static const G4double     c = 1.25;
+   static const G4int   numMul = 1200;
+   static const G4int   numSec = 60;
+   G4int              neutronCode = Neutron.getCode();
+   G4int              protonCode  = Proton.getCode();
+   G4int               targetCode = targetParticle.getCode();
+//   G4double          incidentMass = incidentParticle.getMass();
+//   G4double        incidentEnergy = incidentParticle.getEnergy();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   static G4bool first = true;
+   static G4double protmul[numMul], protnorm[numSec];  // proton constants
+   static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+//                                misc. local variables
+//                                np = number of pi+,  nm = number of pi-,  nz = number of pi0
+   G4int i, counter, nt, np, nm, nz;
+{
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
+  static const G4double protb = 0.7;
+  static const G4double neutb = 0.7;
+  static const G4double     c = 1.25;
+  static const G4int numMul = 1200;
+  static const G4int numSec = 60;
+  G4int neutronCode = Neutron.getCode();
+  G4int protonCode  = Proton.getCode();
+  G4int targetCode = targetParticle.getCode();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  static G4bool first = true;
+  static G4double protmul[numMul], protnorm[numSec];  // proton constants
+  static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+  // misc. local variables
+  // np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  G4int i, counter, nt, np, nm, nz;
    if( first )
      {                         // compute normalization constants, this will only be done once
+     {     // compute normalization constants, this will only be done once
        first = false;
        for( i=0; i<numMul; i++ )protmul[i]  = 0.0;

trunk/source/processes/hadronic/models/high_energy/src/G4HEKaonZeroLongInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+// $Id: G4HEKaonZeroLongInelastic.cc,v 1.11 2010/02/09 21:59:10 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HEKaonZeroLongInelastic.cc,v 1.13 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model. Not included are the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 //
 // New version by D.H. Wright (SLAC) to fix seg fault in old version
 …
 #include "G4HEKaonZeroLongInelastic.hh"
+G4HadFinalState* G4HEKaonZeroLongInelastic::
+ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus)
+G4HadFinalState*
+G4HEKaonZeroLongInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                         G4Nucleus& targetNucleus)
+{
   G4HEVector * pv = new G4HEVector[MAXPART];
   const G4HadProjectile *aParticle = &aTrack;
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
   const G4double atomicWeight = targetNucleus.GetN();
   const G4double atomicNumber = targetNucleus.GetZ();
   G4HEVector incidentParticle(aParticle);
   G4int    incidentCode          = incidentParticle.getCode();
   G4double incidentMass          = incidentParticle.getMass();
   G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
   G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
 …
   incidentKineticEnergy -= excitation;
   incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+  incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                     *(incidentTotalEnergy+incidentMass));
   G4HEVector targetParticle;
   if(G4UniformRand() < atomicNumber/atomicWeight) {
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
     targetParticle.setDefinition("Proton");
   } else {
 …
   G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                        + targetMass*targetMass
+                                        + 2.0*targetMass*incidentTotalEnergy);
   G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
-                                    // this was the meaning of inElastic in the
-                                    // original Gheisha stand-alone version.
-//  G4bool inElastic = InElasticCrossSectionInFirstInt
-//                      (availableEnergy, incidentCode, incidentTotalMomentum);
-// for unknown reasons, it has been replaced by the following code in Geant???
   G4bool inElastic = true;
-//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
   vecLength = 0;
 …
   G4bool successful = false;
+  if(inElastic || (!inElastic && atomicWeight < 1.5)) {
+    // Split K0L into K0 and K0bar
+    if (G4UniformRand() < 0.5)
+      FirstIntInCasAntiKaonZero(inElastic, availableEnergy, pv, vecLength,
+                                incidentParticle, targetParticle );
+    else
+      FirstIntInCasKaonZero(inElastic, availableEnergy, pv, vecLength,
+                            incidentParticle, targetParticle, atomicWeight );
+    // Do nuclear interaction with either K0 or K0bar
+    if ((vecLength > 0) && (availableEnergy > 1.))
+      StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                    pv, vecLength,
+                                    incidentParticle, targetParticle);
+    HighEnergyCascading(successful, pv, vecLength,
+                        excitationEnergyGNP, excitationEnergyDTA,
+                        incidentParticle, targetParticle,
+                        atomicWeight, atomicNumber);
+    if (!successful)
+      HighEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+  // Split K0L into K0 and K0bar
+  if (G4UniformRand() < 0.5)
+    FirstIntInCasAntiKaonZero(inElastic, availableEnergy, pv, vecLength,
+                              incidentParticle, targetParticle);
+  else
+    FirstIntInCasKaonZero(inElastic, availableEnergy, pv, vecLength,
+                          incidentParticle, targetParticle, atomicWeight);
+  // Do nuclear interaction with either K0 or K0bar
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
                                   incidentParticle, targetParticle,
                                   atomicWeight, atomicNumber);
+    if (!successful)
+      MediumEnergyCascading(successful, pv, vecLength,
+                            excitationEnergyGNP, excitationEnergyDTA,
+                            incidentParticle, targetParticle,
+                            atomicWeight, atomicNumber);
+    if (!successful)
+      MediumEnergyClusterProduction(successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+    if (!successful)
+      QuasiElasticScattering(successful, pv, vecLength,
+                             excitationEnergyGNP, excitationEnergyDTA,
+                             incidentParticle, targetParticle,
+                             atomicWeight, atomicNumber);
+  }
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
   if (!successful)
 …
   delete [] pv;
   theParticleChange.SetStatusChange(stopAndKill);
   return & theParticleChange;
+  return &theParticleChange;
+}
 void
 G4HEKaonZeroLongInelastic::FirstIntInCasKaonZero(G4bool &inElastic,
+G4HEKaonZeroLongInelastic::FirstIntInCasKaonZero(G4bool& inElastic,
                                                  const G4double availableEnergy,
                                                  G4HEVector pv[],
                                                  G4int &vecLen,
                                                  G4HEVector incidentParticle,
                                                  G4HEVector targetParticle,
+                                                 G4int& vecLen,
+                                                 const G4HEVector& incidentParticle,
+                                                 const G4HEVector& targetParticle,
                                                  const G4double atomicWeight)
 …
 // protons/neutrons by kaons or strange baryons according to the average
 // multiplicity per inelastic reaction.
+{
   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
   static const G4double protb = 0.7;
 …
 void
 G4HEKaonZeroLongInelastic::FirstIntInCasAntiKaonZero(G4bool &inElastic,
+G4HEKaonZeroLongInelastic::FirstIntInCasAntiKaonZero(G4bool& inElastic,
                                                      const G4double availableEnergy,
                                                      G4HEVector pv[],
                                                      G4int &vecLen,
                                                      G4HEVector incidentParticle,
                                                      G4HEVector targetParticle )
+                                                     G4int& vecLen,
+                                                     const G4HEVector& incidentParticle,
+                                                     const G4HEVector& targetParticle)
 // AntiKaon0 undergoes interaction with nucleon within a nucleus.  Check if it is
 …
   static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
 //  misc. local variables
 //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  //  misc. local variables
+  //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
   G4int i, counter, nt, np, nm, nz;
   if(first) {
+  if (first) {
     // compute normalization constants, this will only be done once
     first = false;

trunk/source/processes/hadronic/models/high_energy/src/G4HEKaonZeroShortInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+// $Id: G4HEKaonZeroShortInelastic.cc,v 1.11 2010/02/09 21:58:57 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HEKaonZeroShortInelastic.cc,v 1.13 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model. Not included are the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 //
 // New version by D.H. Wright (SLAC) to fix seg fault in old version
 …
 #include "G4HEKaonZeroShortInelastic.hh"
+G4HadFinalState* G4HEKaonZeroShortInelastic::
+ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus)
+G4HadFinalState*
+G4HEKaonZeroShortInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                          G4Nucleus& targetNucleus)
+{
   G4HEVector * pv = new G4HEVector[MAXPART];
   const G4HadProjectile *aParticle = &aTrack;
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
   const G4double atomicWeight = targetNucleus.GetN();
   const G4double atomicNumber = targetNucleus.GetZ();
   G4HEVector incidentParticle(aParticle);
   G4int    incidentCode          = incidentParticle.getCode();
   G4double incidentMass          = incidentParticle.getMass();
   G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
   G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
 …
   incidentKineticEnergy -= excitation;
+  incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+  incidentTotalEnergy = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                    *(incidentTotalEnergy+incidentMass));
   G4HEVector targetParticle;
 …
   G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                        + targetMass*targetMass
+                                        + 2.0*targetMass*incidentTotalEnergy);
   G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
-                                    // this was the meaning of inElastic in the
-                                    // original Gheisha stand-alone version.
-//  G4bool inElastic = InElasticCrossSectionInFirstInt
-//                      (availableEnergy, incidentCode, incidentTotalMomentum);
-// for unknown reasons, it has been replaced by the following code in Geant???
   G4bool inElastic = true;
-//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
   vecLength = 0;
 …
   G4bool successful = false;
+  if(inElastic || (!inElastic && atomicWeight < 1.5)) {
+    // Split K0L into K0 and K0bar
+    if (G4UniformRand() < 0.5)
+      FirstIntInCasAntiKaonZero(inElastic, availableEnergy, pv, vecLength,
+                                incidentParticle, targetParticle );
+    else
+      FirstIntInCasKaonZero(inElastic, availableEnergy, pv, vecLength,
+                            incidentParticle, targetParticle, atomicWeight );
+    // Do nuclear interaction with either K0 or K0bar
+    if ((vecLength > 0) && (availableEnergy > 1.))
+      StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                    pv, vecLength,
+                                    incidentParticle, targetParticle);
+    HighEnergyCascading(successful, pv, vecLength,
+                        excitationEnergyGNP, excitationEnergyDTA,
+                        incidentParticle, targetParticle,
+                        atomicWeight, atomicNumber);
+    if (!successful)
+      HighEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+  // Split K0L into K0 and K0bar
+  if (G4UniformRand() < 0.5)
+    FirstIntInCasAntiKaonZero(inElastic, availableEnergy, pv, vecLength,
+                              incidentParticle, targetParticle );
+  else
+    FirstIntInCasKaonZero(inElastic, availableEnergy, pv, vecLength,
+                          incidentParticle, targetParticle, atomicWeight );
+  // Do nuclear interaction with either K0 or K0bar
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
                                   incidentParticle, targetParticle,
                                   atomicWeight, atomicNumber);
+    if (!successful)
+      MediumEnergyCascading(successful, pv, vecLength,
+                            excitationEnergyGNP, excitationEnergyDTA,
+                            incidentParticle, targetParticle,
+                            atomicWeight, atomicNumber);
+    if (!successful)
+      MediumEnergyClusterProduction(successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+    if (!successful)
+      QuasiElasticScattering(successful, pv, vecLength,
+                             excitationEnergyGNP, excitationEnergyDTA,
+                             incidentParticle, targetParticle,
+                             atomicWeight, atomicNumber);
+  }
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
   if (!successful)
 …
   delete [] pv;
   theParticleChange.SetStatusChange(stopAndKill);
   return & theParticleChange;
+  return &theParticleChange;
+}
 void
 G4HEKaonZeroShortInelastic::FirstIntInCasKaonZero(G4bool &inElastic,
                                                  const G4double availableEnergy,
                                                  G4HEVector pv[],
                                                  G4int &vecLen,
                                                  G4HEVector incidentParticle,
                                                  G4HEVector targetParticle,
                                                  const G4double atomicWeight)
+G4HEKaonZeroShortInelastic::FirstIntInCasKaonZero(G4bool& inElastic,
+                                                  const G4double availableEnergy,
+                                                  G4HEVector pv[],
+                                                  G4int& vecLen,
+                                                  const G4HEVector& incidentParticle,
+                                                  const G4HEVector& targetParticle,
+                                                  const G4double atomicWeight)
 // Kaon0 undergoes interaction with nucleon within a nucleus.  Check if it is
 …
 // protons/neutrons by kaons or strange baryons according to the average
 // multiplicity per inelastic reaction.
+{
   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
   static const G4double protb = 0.7;
 …
 void
 G4HEKaonZeroShortInelastic::FirstIntInCasAntiKaonZero(G4bool &inElastic,
                                                      const G4double availableEnergy,
                                                      G4HEVector pv[],
                                                      G4int &vecLen,
                                                      G4HEVector incidentParticle,
                                                      G4HEVector targetParticle )
+G4HEKaonZeroShortInelastic::FirstIntInCasAntiKaonZero(G4bool& inElastic,
+                                                      const G4double availableEnergy,
+                                                      G4HEVector pv[],
+                                                      G4int& vecLen,
+                                                      const G4HEVector& incidentParticle,
+                                                      const G4HEVector& targetParticle)
 // AntiKaon0 undergoes interaction with nucleon within a nucleus.  Check if it is
 …
 // protons/neutrons by kaons or strange baryons according to the average
 // multiplicity per inelastic reaction.
+{
   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
   static const G4double protb = 0.7;
 …
   static const G4double     c = 1.25;
   static const G4int   numMul = 1200;
   static const G4int   numSec = 60;
+  static const G4int numMul = 1200;
+  static const G4int numSec = 60;
   G4int neutronCode = Neutron.getCode();
 …
   static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
 //  misc. local variables
 //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  // misc. local variables
+  // np = number of pi+,  nm = number of pi-,  nz = number of pi0
   G4int i, counter, nt, np, nm, nz;
   if(first) {
+  if (first) {
     // compute normalization constants, this will only be done once
     first = false;

trunk/source/processes/hadronic/models/high_energy/src/G4HELambdaInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HELambdaInelastic.cc,v 1.15 2008/03/17 20:49:17 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HELambdaInelastic.cc,v 1.17 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model. Not included are the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 // First work done by J.L.Chuma and F.W.Jones, TRIUMF, June 96.
 // H. Fesefeldt, RWTH-Aachen, 23-October-1996
 …
 #include "G4HELambdaInelastic.hh"
 G4HadFinalState *  G4HELambdaInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
     const G4HadProjectile *aParticle = &aTrack;
 //    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
     const G4double A = targetNucleus.GetN();
     const G4double Z = targetNucleus.GetZ();
     G4HEVector incidentParticle(aParticle);
+G4HadFinalState*
+G4HELambdaInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                   G4Nucleus& targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
+  const G4double A = targetNucleus.GetN();
+  const G4double Z = targetNucleus.GetZ();
+  G4HEVector incidentParticle(aParticle);
+    G4double atomicNumber = Z;
+    G4double atomicWeight = A;
+    G4int    incidentCode          = incidentParticle.getCode();
+    G4double incidentMass          = incidentParticle.getMass();
+    G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+    if(incidentKineticEnergy < 1.)
+      {
+        G4cout << "GHELambdaInelastic: incident energy < 1 GeV" << G4endl;
+      }
+    if(verboseLevel > 1)
+      {
+        G4cout << "G4HELambdaInelastic::ApplyYourself" << G4endl;
+        G4cout << "incident particle " << incidentParticle.getName()
+             << "mass "              << incidentMass
+             << "kinetic energy "    << incidentKineticEnergy
+             << G4endl;
+        G4cout << "target material with (A,Z) = ("
+             << atomicWeight << "," << atomicNumber << ")" << G4endl;
+      }
+    G4double inelasticity  = NuclearInelasticity(incidentKineticEnergy,
+                                                 atomicWeight, atomicNumber);
+    if(verboseLevel > 1)
+        G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+  G4double atomicNumber = Z;
+  G4double atomicWeight = A;
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+  if (incidentKineticEnergy < 1.)
+    G4cout << "GHELambdaInelastic: incident energy < 1 GeV" << G4endl;
+  if (verboseLevel > 1) {
+    G4cout << "G4HELambdaInelastic::ApplyYourself" << G4endl;
+    G4cout << "incident particle " << incidentParticle.getName()
+           << "mass "              << incidentMass
+           << "kinetic energy "    << incidentKineticEnergy
+           << G4endl;
+    G4cout << "target material with (A,Z) = ("
+           << atomicWeight << "," << atomicNumber << ")" << G4endl;
+  }
+  G4double inelasticity = NuclearInelasticity(incidentKineticEnergy,
+                                              atomicWeight, atomicNumber);
+  if (verboseLevel > 1)
+    G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
     incidentKineticEnergy -= inelasticity;
+  incidentKineticEnergy -= inelasticity;
     G4double excitationEnergyGNP = 0.;
     G4double excitationEnergyDTA = 0.;
     G4double excitation    = NuclearExcitation(incidentKineticEnergy,
                                                atomicWeight, atomicNumber,
                                                excitationEnergyGNP,
                                                excitationEnergyDTA);
     if(verboseLevel > 1)
       G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+  G4double excitationEnergyGNP = 0.;
+  G4double excitationEnergyDTA = 0.;
+  G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                          atomicWeight, atomicNumber,
+                                          excitationEnergyGNP,
+                                          excitationEnergyDTA);
+  if (verboseLevel > 1)
+    G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
            << excitationEnergyDTA << G4endl;
+    incidentKineticEnergy -= excitation;
+    incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+    G4HEVector targetParticle;
+    if(G4UniformRand() < atomicNumber/atomicWeight)
+      {
+        targetParticle.setDefinition("Proton");
+      }
+    else
+      {
+        targetParticle.setDefinition("Neutron");
+      }
+    G4double targetMass         = targetParticle.getMass();
+    G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+    G4double availableEnergy    = centerOfMassEnergy - targetMass - incidentMass;
+                                                                // this was the meaning of inElastic in the
+                                                                // original Gheisha stand-alone version.
+//    G4bool   inElastic          = InElasticCrossSectionInFirstInt
+//                                    (availableEnergy, incidentCode, incidentTotalMomentum);
+                                                                // by unknown reasons, it has been replaced
+                                                                // to the following code in Geant???
+    G4bool inElastic = true;
+//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+    vecLength = 0;
+  incidentKineticEnergy -= excitation;
+  incidentTotalEnergy = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                    *(incidentTotalEnergy+incidentMass));
+  G4HEVector targetParticle;
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
+    targetParticle.setDefinition("Proton");
+  } else {
+    targetParticle.setDefinition("Neutron");
+  }
+  G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                        + targetMass*targetMass
+                                        + 2.0*targetMass*incidentTotalEnergy);
+  G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
+  G4bool inElastic = true;
+  vecLength = 0;
     if(verboseLevel > 1)
       G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
            << incidentCode << G4endl;
     G4bool successful = false;
+  G4bool successful = false;
+    if(inElastic || (!inElastic && atomicWeight < 1.5))
+      {
+        FirstIntInCasLambda(inElastic, availableEnergy, pv, vecLength,
+                            incidentParticle, targetParticle, atomicWeight);
+        if(verboseLevel > 1)
+           G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+        if ((vecLength > 0) && (availableEnergy > 1.))
+                   StrangeParticlePairProduction( availableEnergy, centerOfMassEnergy,
+                                                  pv, vecLength,
+                                                  incidentParticle, targetParticle);
+            HighEnergyCascading( successful, pv, vecLength,
+                                 excitationEnergyGNP, excitationEnergyDTA,
+                                 incidentParticle, targetParticle,
+                                 atomicWeight, atomicNumber);
+        if (!successful)
+            HighEnergyClusterProduction( successful, pv, vecLength,
+                                         excitationEnergyGNP, excitationEnergyDTA,
+                                         incidentParticle, targetParticle,
+                                         atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyCascading( successful, pv, vecLength,
+                                   excitationEnergyGNP, excitationEnergyDTA,
+                                   incidentParticle, targetParticle,
+                                   atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyClusterProduction( successful, pv, vecLength,
+                                           excitationEnergyGNP, excitationEnergyDTA,
+                                           incidentParticle, targetParticle,
+                                           atomicWeight, atomicNumber);
+        if (!successful)
+            QuasiElasticScattering( successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+            ElasticScattering( successful, pv, vecLength,
+                               incidentParticle,
+                               atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+        G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles" << G4endl;
+      }
+      FillParticleChange(pv,  vecLength);
+      delete [] pv;
+      theParticleChange.SetStatusChange(stopAndKill);
+      return & theParticleChange;
+  }
+  FirstIntInCasLambda(inElastic, availableEnergy, pv, vecLength,
+                      incidentParticle, targetParticle, atomicWeight);
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+                                  incidentParticle, targetParticle,
+                                  atomicWeight, atomicNumber);
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
+  if (!successful)
+    ElasticScattering(successful, pv, vecLength,
+                      incidentParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+           << G4endl;
+  FillParticleChange(pv, vecLength);
+  delete [] pv;
+  theParticleChange.SetStatusChange(stopAndKill);
+  return &theParticleChange;
+}
 void
 G4HELambdaInelastic::FirstIntInCasLambda( G4bool &inElastic,
                                           const G4double availableEnergy,
                                           G4HEVector pv[],
                                           G4int &vecLen,
                                           G4HEVector incidentParticle,
                                           G4HEVector targetParticle,
                                           const G4double atomicWeight)
+G4HELambdaInelastic::FirstIntInCasLambda(G4bool& inElastic,
+                                         const G4double availableEnergy,
+                                         G4HEVector pv[],
+                                         G4int& vecLen,
+                                         const G4HEVector& incidentParticle,
+                                         const G4HEVector& targetParticle,
+                                         const G4double atomicWeight)
 // Lambda undergoes interaction with nucleon within a nucleus.  Check if it is
 …
 // data.  Replace some pions or protons/neutrons by kaons or strange baryons
 // according to the average multiplicity per inelastic reaction.
+ {
+   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
+   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+   static const G4double protb = 0.7;
+   static const G4double neutb = 0.7;
+   static const G4double     c = 1.25;
+   static const G4int   numMul = 1200;
+   static const G4int   numSec = 60;
+//   G4int              neutronCode = Neutron.getCode();
+   G4int              protonCode  = Proton.getCode();
+   G4int               targetCode = targetParticle.getCode();
+//   G4double          incidentMass = incidentParticle.getMass();
+//   G4double        incidentEnergy = incidentParticle.getEnergy();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   static G4bool first = true;
+   static G4double protmul[numMul], protnorm[numSec];  // proton constants
+   static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+   //  misc. local variables
+   //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+   G4int i, counter, nt, np, nm, nz;
+{
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
+  static const G4double protb = 0.7;
+  static const G4double neutb = 0.7;
+  static const G4double     c = 1.25;
+  static const G4int numMul = 1200;
+  static const G4int numSec = 60;
+  G4int protonCode  = Proton.getCode();
+  G4int targetCode = targetParticle.getCode();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  static G4bool first = true;
+  static G4double protmul[numMul], protnorm[numSec];  // proton constants
+  static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+  //  misc. local variables
+  //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  G4int i, counter, nt, np, nm, nz;
    if( first )

trunk/source/processes/hadronic/models/high_energy/src/G4HENeutronInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HENeutronInelastic.cc,v 1.15 2008/03/17 20:49:17 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HENeutronInelastic.cc,v 1.17 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model. Not included are the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 // First work done by J.L.Chuma and F.W.Jones, TRIUMF, June 96.
 // H. Fesefeldt, RWTH-Aachen, 23-October-1996
 …
 #include "G4HENeutronInelastic.hh"
 G4HadFinalState *  G4HENeutronInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
     const G4HadProjectile *aParticle = &aTrack;
 //    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
     const G4double A = targetNucleus.GetN();
     const G4double Z = targetNucleus.GetZ();
     G4HEVector incidentParticle(aParticle);
+G4HadFinalState*
+G4HENeutronInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                    G4Nucleus& targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
+  const G4double A = targetNucleus.GetN();
+  const G4double Z = targetNucleus.GetZ();
+  G4HEVector incidentParticle(aParticle);
+    G4double atomicNumber = Z;
+    G4double atomicWeight = A;
+    G4int    incidentCode          = incidentParticle.getCode();
+    G4double incidentMass          = incidentParticle.getMass();
+    G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+    if(incidentKineticEnergy < 1.)
+      {
+        G4cout << "GHENeutronInelastic: incident energy < 1 GeV" << G4endl;
+      }
+    if(verboseLevel > 1)
+      {
+        G4cout << "G4HENeutronInelastic::ApplyYourself" << G4endl;
+        G4cout << "incident particle " << incidentParticle.getName()
+             << "mass "              << incidentMass
+             << "kinetic energy "    << incidentKineticEnergy
+             << G4endl;
+        G4cout << "target material with (A,Z) = ("
+             << atomicWeight << "," << atomicNumber << ")" << G4endl;
+      }
+  G4double atomicNumber = Z;
+  G4double atomicWeight = A;
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+  if (incidentKineticEnergy < 1.)
+    G4cout << "GHENeutronInelastic: incident energy < 1 GeV" << G4endl;
+    G4double inelasticity  = NuclearInelasticity(incidentKineticEnergy,
+                                                 atomicWeight, atomicNumber);
+    if(verboseLevel > 1)
+        G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+  if (verboseLevel > 1) {
+    G4cout << "G4HENeutronInelastic::ApplyYourself" << G4endl;
+    G4cout << "incident particle " << incidentParticle.getName()
+           << "mass "              << incidentMass
+           << "kinetic energy "    << incidentKineticEnergy
+           << G4endl;
+    G4cout << "target material with (A,Z) = ("
+           << atomicWeight << "," << atomicNumber << ")" << G4endl;
+  }
+    incidentKineticEnergy -= inelasticity;
+  G4double inelasticity = NuclearInelasticity(incidentKineticEnergy,
+                                              atomicWeight, atomicNumber);
+  if (verboseLevel > 1)
+    G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+    G4double excitationEnergyGNP = 0.;
+    G4double excitationEnergyDTA = 0.;
+    G4double excitation    = NuclearExcitation(incidentKineticEnergy,
+                                               atomicWeight, atomicNumber,
+                                               excitationEnergyGNP,
+                                               excitationEnergyDTA);
+    if(verboseLevel > 1)
+      G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+  incidentKineticEnergy -= inelasticity;
+  G4double excitationEnergyGNP = 0.;
+  G4double excitationEnergyDTA = 0.;
+  G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                          atomicWeight, atomicNumber,
+                                          excitationEnergyGNP,
+                                          excitationEnergyDTA);
+  if (verboseLevel > 1)
+    G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
            << excitationEnergyDTA << G4endl;
+    incidentKineticEnergy -= excitation;
+    incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+    G4HEVector targetParticle;
+    if(G4UniformRand() < atomicNumber/atomicWeight)
+      {
+        targetParticle.setDefinition("Proton");
+      }
+    else
+      {
+        targetParticle.setDefinition("Neutron");
+      }
+    G4double targetMass         = targetParticle.getMass();
+    G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+    G4double availableEnergy    = centerOfMassEnergy - targetMass - incidentMass;
+                                                                // this was the meaning of inElastic in the
+                                                                // original Gheisha stand-alone version.
+//    G4bool   inElastic          = InElasticCrossSectionInFirstInt
+//                                    (availableEnergy, incidentCode, incidentTotalMomentum);
+                                                                // by unknown reasons, it has been replaced
+                                                                // to the following code in Geant???
+    G4bool inElastic = true;
+//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+    vecLength = 0;
+    if(verboseLevel > 1)
+      G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+  incidentKineticEnergy -= excitation;
+  incidentTotalEnergy  = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                    *(incidentTotalEnergy+incidentMass));
+  G4HEVector targetParticle;
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
+    targetParticle.setDefinition("Proton");
+  } else {
+    targetParticle.setDefinition("Neutron");
+  }
+  G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                        + targetMass*targetMass
+                                        + 2.0*targetMass*incidentTotalEnergy);
+  G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
+  // In the original Gheisha code the inElastic flag was set as follows
+  //   G4bool inElastic = InElasticCrossSectionInFirstInt
+  //                      (availableEnergy, incidentCode, incidentTotalMomentum);
+  // For unknown reasons, it has been replaced by the following code in Geant???
+  //
+  G4bool inElastic = true;
+  //   if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+  vecLength = 0;
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
            << incidentCode << G4endl;
     G4bool successful = false;
+  G4bool successful = false;
+    if(inElastic || (!inElastic && atomicWeight < 1.5))
+      {
+        FirstIntInCasNeutron(inElastic, availableEnergy, pv, vecLength,
+                             incidentParticle, targetParticle, atomicWeight);
+        if(verboseLevel > 1)
+           G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+        if ((vecLength > 0) && (availableEnergy > 1.))
+                   StrangeParticlePairProduction( availableEnergy, centerOfMassEnergy,
+                                                  pv, vecLength,
+                                                  incidentParticle, targetParticle);
+            HighEnergyCascading( successful, pv, vecLength,
+                                 excitationEnergyGNP, excitationEnergyDTA,
+                                 incidentParticle, targetParticle,
+                                 atomicWeight, atomicNumber);
+        if (!successful)
+            HighEnergyClusterProduction( successful, pv, vecLength,
+                                         excitationEnergyGNP, excitationEnergyDTA,
+                                         incidentParticle, targetParticle,
+                                         atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyCascading( successful, pv, vecLength,
+                                   excitationEnergyGNP, excitationEnergyDTA,
+                                   incidentParticle, targetParticle,
+                                   atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyClusterProduction( successful, pv, vecLength,
+                                           excitationEnergyGNP, excitationEnergyDTA,
+                                           incidentParticle, targetParticle,
+                                           atomicWeight, atomicNumber);
+        if (!successful)
+            QuasiElasticScattering( successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+            ElasticScattering( successful, pv, vecLength,
+                               incidentParticle,
+                               atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+        G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles" << G4endl;
+      }
+      FillParticleChange(pv,  vecLength);
+      delete [] pv;
+      theParticleChange.SetStatusChange(stopAndKill);
+      return & theParticleChange;
+  }
+  FirstIntInCasNeutron(inElastic, availableEnergy, pv, vecLength,
+                       incidentParticle, targetParticle, atomicWeight);
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+                                  incidentParticle, targetParticle,
+                                  atomicWeight, atomicNumber);
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
+  if (!successful)
+    ElasticScattering(successful, pv, vecLength,
+                      incidentParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+           << G4endl;
+  FillParticleChange(pv, vecLength);
+  delete [] pv;
+  theParticleChange.SetStatusChange(stopAndKill);
+  return &theParticleChange;
+}
 void
 G4HENeutronInelastic::FirstIntInCasNeutron( G4bool &inElastic,
                                             const G4double availableEnergy,
                                             G4HEVector pv[],
                                             G4int &vecLen,
                                             G4HEVector incidentParticle,
                                             G4HEVector targetParticle,
                                             const G4double atomicWeight)
+G4HENeutronInelastic::FirstIntInCasNeutron(G4bool& inElastic,
+                                           const G4double availableEnergy,
+                                           G4HEVector pv[],
+                                           G4int& vecLen,
+                                           const G4HEVector& incidentParticle,
+                                           const G4HEVector& targetParticle,
+                                           const G4double atomicWeight)
 // Neutron undergoes interaction with nucleon within a nucleus.  Check if it is
 …
 // protons/neutrons by kaons or strange baryons according to the average
 // multiplicity per inelastic reaction.
+ {
+   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
+   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+   static const G4double protb = 0.35;
+   static const G4double neutb = 0.35;
+   static const G4double     c = 1.25;
+   static const G4int   numMul = 1200;
+   static const G4int   numSec = 60;
+   G4int              neutronCode = Neutron.getCode();
+   G4int              protonCode  = Proton.getCode();
+   G4int               targetCode = targetParticle.getCode();
+//   G4double          incidentMass = incidentParticle.getMass();
+//   G4double        incidentEnergy = incidentParticle.getEnergy();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   static G4bool first = true;
+   static G4double protmul[numMul], protnorm[numSec];  // proton constants
+   static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+                              //  misc. local variables
+                              //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+   G4int i, counter, nt, np, nm, nz;
+{
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
+  static const G4double protb = 0.35;
+  static const G4double neutb = 0.35;
+  static const G4double     c = 1.25;
+  static const G4int   numMul = 1200;
+  static const G4int   numSec = 60;
+  G4int neutronCode = Neutron.getCode();
+  G4int protonCode  = Proton.getCode();
+  G4int targetCode = targetParticle.getCode();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  static G4bool first = true;
+  static G4double protmul[numMul], protnorm[numSec];  // proton constants
+  static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+  //  misc. local variables
+  //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  G4int i, counter, nt, np, nm, nz;
    if( first )
      {                         // compute normalization constants, this will only be done once
+     {     // compute normalization constants, this will only be done once
        first = false;
        for( i=0; i<numMul; i++ )protmul[i]  = 0.0;

trunk/source/processes/hadronic/models/high_energy/src/G4HEOmegaMinusInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HEOmegaMinusInelastic.cc,v 1.15 2008/03/17 20:49:17 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HEOmegaMinusInelastic.cc,v 1.17 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model. Not included are the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 // First work done by J.L.Chuma and F.W.Jones, TRIUMF, June 96.
 // H. Fesefeldt, RWTH-Aachen, 23-October-1996
 …
 #include "G4HEOmegaMinusInelastic.hh"
 G4HadFinalState *  G4HEOmegaMinusInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
     const G4HadProjectile *aParticle = &aTrack;
 //    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
     const G4double A = targetNucleus.GetN();
     const G4double Z = targetNucleus.GetZ();
     G4HEVector incidentParticle(aParticle);
+G4HadFinalState*
+G4HEOmegaMinusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                       G4Nucleus& targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
+  const G4double A = targetNucleus.GetN();
+  const G4double Z = targetNucleus.GetZ();
+  G4HEVector incidentParticle(aParticle);
+    G4double atomicNumber = Z;
+    G4double atomicWeight = A;
+    G4int    incidentCode          = incidentParticle.getCode();
+    G4double incidentMass          = incidentParticle.getMass();
+    G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+    if(incidentKineticEnergy < 1.)
+      {
+        G4cout << "GHEOmegaMinusInelastic: incident energy < 1 GeV" << G4endl;
+      }
+    if(verboseLevel > 1)
+      {
+        G4cout << "G4HEOmegaMinusInelastic::ApplyYourself" << G4endl;
+        G4cout << "incident particle " << incidentParticle.getName()
+             << "mass "              << incidentMass
+             << "kinetic energy "    << incidentKineticEnergy
+             << G4endl;
+        G4cout << "target material with (A,Z) = ("
+             << atomicWeight << "," << atomicNumber << ")" << G4endl;
+      }
+  G4double atomicNumber = Z;
+  G4double atomicWeight = A;
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+  if (incidentKineticEnergy < 1.)
+    G4cout << "GHEOmegaMinusInelastic: incident energy < 1 GeV" << G4endl;
+  if (verboseLevel > 1) {
+    G4cout << "G4HEOmegaMinusInelastic::ApplyYourself" << G4endl;
+    G4cout << "incident particle " << incidentParticle.getName()
+           << "mass "              << incidentMass
+           << "kinetic energy "    << incidentKineticEnergy
+           << G4endl;
+    G4cout << "target material with (A,Z) = ("
+           << atomicWeight << "," << atomicNumber << ")" << G4endl;
+  }
     G4double inelasticity  = NuclearInelasticity(incidentKineticEnergy,
                                                  atomicWeight, atomicNumber);
     if(verboseLevel > 1)
         G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+  G4double inelasticity = NuclearInelasticity(incidentKineticEnergy,
+                                              atomicWeight, atomicNumber);
+  if (verboseLevel > 1)
+    G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
     incidentKineticEnergy -= inelasticity;
+  incidentKineticEnergy -= inelasticity;
     G4double excitationEnergyGNP = 0.;
     G4double excitationEnergyDTA = 0.;
     G4double excitation    = NuclearExcitation(incidentKineticEnergy,
                                                atomicWeight, atomicNumber,
                                                excitationEnergyGNP,
                                                excitationEnergyDTA);
     if(verboseLevel > 1)
       G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+  G4double excitationEnergyGNP = 0.;
+  G4double excitationEnergyDTA = 0.;
+  G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                          atomicWeight, atomicNumber,
+                                          excitationEnergyGNP,
+                                          excitationEnergyDTA);
+  if (verboseLevel > 1)
+    G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
            << excitationEnergyDTA << G4endl;
+    incidentKineticEnergy -= excitation;
+    incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+    G4HEVector targetParticle;
+    if(G4UniformRand() < atomicNumber/atomicWeight)
+      {
+        targetParticle.setDefinition("Proton");
+      }
+    else
+      {
+        targetParticle.setDefinition("Neutron");
+      }
+    G4double targetMass         = targetParticle.getMass();
+    G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+    G4double availableEnergy    = centerOfMassEnergy - targetMass - incidentMass;
+                                                                // this was the meaning of inElastic in the
+                                                                // original Gheisha stand-alone version.
+//    G4bool   inElastic          = InElasticCrossSectionInFirstInt
+//                                    (availableEnergy, incidentCode, incidentTotalMomentum);
+                                                                // by unknown reasons, it has been replaced
+                                                                // to the following code in Geant???
+    G4bool inElastic = true;
+//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+    vecLength = 0;
+  incidentKineticEnergy -= excitation;
+  incidentTotalEnergy = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                    *(incidentTotalEnergy+incidentMass));
+  G4HEVector targetParticle;
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
+    targetParticle.setDefinition("Proton");
+  } else {
+    targetParticle.setDefinition("Neutron");
+  }
+  G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                        + targetMass*targetMass
+                                        + 2.0*targetMass*incidentTotalEnergy);
+  G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
+  G4bool inElastic = true;
+  vecLength = 0;
     if(verboseLevel > 1)
       G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
            << incidentCode << G4endl;
     G4bool successful = false;
+  G4bool successful = false;
+    if(inElastic || (!inElastic && atomicWeight < 1.5))
+      {
+        FirstIntInCasOmegaMinus(inElastic, availableEnergy, pv, vecLength,
+                                incidentParticle, targetParticle, atomicWeight);
+        if(verboseLevel > 1)
+           G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+        if ((vecLength > 0) && (availableEnergy > 1.))
+                   StrangeParticlePairProduction( availableEnergy, centerOfMassEnergy,
+                                                  pv, vecLength,
+                                                  incidentParticle, targetParticle);
+            HighEnergyCascading( successful, pv, vecLength,
+                                 excitationEnergyGNP, excitationEnergyDTA,
+                                 incidentParticle, targetParticle,
+                                 atomicWeight, atomicNumber);
+        if (!successful)
+            HighEnergyClusterProduction( successful, pv, vecLength,
+                                         excitationEnergyGNP, excitationEnergyDTA,
+                                         incidentParticle, targetParticle,
+                                         atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyCascading( successful, pv, vecLength,
+                                   excitationEnergyGNP, excitationEnergyDTA,
+                                   incidentParticle, targetParticle,
+                                   atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyClusterProduction( successful, pv, vecLength,
+                                           excitationEnergyGNP, excitationEnergyDTA,
+                                           incidentParticle, targetParticle,
+                                           atomicWeight, atomicNumber);
+        if (!successful)
+            QuasiElasticScattering( successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+            ElasticScattering( successful, pv, vecLength,
+                               incidentParticle,
+                               atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+        G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles" << G4endl;
+      }
+      FillParticleChange(pv,  vecLength);
+      delete [] pv;
+      theParticleChange.SetStatusChange(stopAndKill);
+      return & theParticleChange;
+  }
+  FirstIntInCasOmegaMinus(inElastic, availableEnergy, pv, vecLength,
+                          incidentParticle, targetParticle, atomicWeight);
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+                                  incidentParticle, targetParticle,
+                                  atomicWeight, atomicNumber);
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
+  if (!successful)
+    ElasticScattering(successful, pv, vecLength,
+                      incidentParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+           << G4endl;
+  FillParticleChange(pv,  vecLength);
+  delete [] pv;
+  theParticleChange.SetStatusChange(stopAndKill);
+  return &theParticleChange;
+}
 void
 G4HEOmegaMinusInelastic::FirstIntInCasOmegaMinus( G4bool &inElastic,
                                                   const G4double availableEnergy,
                                                   G4HEVector pv[],
                                                   G4int &vecLen,
                                                   G4HEVector incidentParticle,
                                                   G4HEVector targetParticle,
                                                   const G4double atomicWeight)
+G4HEOmegaMinusInelastic::FirstIntInCasOmegaMinus(G4bool& inElastic,
+                                                 const G4double availableEnergy,
+                                                 G4HEVector pv[],
+                                                 G4int& vecLen,
+                                                 const G4HEVector& incidentParticle,
+                                                 const G4HEVector& targetParticle,
+                                                 const G4double atomicWeight)
 // Xi0 undergoes interaction with nucleon within a nucleus.  Check if it is
 …
 // protons/neutrons by kaons or strange baryons according to the average
 // multiplicity per inelastic reaction.
+ {
+   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
+   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+   static const G4double protb = 0.7;
+   static const G4double neutb = 0.7;
+   static const G4double     c = 1.25;
+   static const G4int   numMul = 1200;
+   static const G4int   numSec = 60;
+//   G4int              neutronCode = Neutron.getCode();
+   G4int              protonCode  = Proton.getCode();
+   G4int               targetCode = targetParticle.getCode();
+//   G4double          incidentMass = incidentParticle.getMass();
+//   G4double        incidentEnergy = incidentParticle.getEnergy();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   static G4bool first = true;
+   static G4double protmul[numMul], protnorm[numSec];  // proton constants
+   static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+                              //  misc. local variables
+                              //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+   G4int i, counter, nt, np, nm, nz;
+{
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
+  static const G4double protb = 0.7;
+  static const G4double neutb = 0.7;
+  static const G4double     c = 1.25;
+  static const G4int numMul = 1200;
+  static const G4int numSec = 60;
+  G4int protonCode  = Proton.getCode();
+  G4int targetCode = targetParticle.getCode();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  static G4bool first = true;
+  static G4double protmul[numMul], protnorm[numSec];  // proton constants
+  static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+  //  misc. local variables
+  //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  G4int i, counter, nt, np, nm, nz;
    if( first )
      {                         // compute normalization constants, this will only be done once
+     {    // compute normalization constants, this will only be done once
        first = false;
        for( i=0; i<numMul; i++ )protmul[i]  = 0.0;

trunk/source/processes/hadronic/models/high_energy/src/G4HEPionMinusInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+// $Id: G4HEPionMinusInelastic.cc,v 1.17 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
-// $Id: G4HEPionMinusInelastic.cc,v 1.15 2008/03/17 20:49:17 dennis Exp $
-// GEANT4 tag $Name: geant4-09-03-ref-09 $
 // 11-OCT-2007 F.W. Jones: fixed incorrect Imax (should be Imin) in
 //             sampling of charge exchange.
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model. Not included are the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 // First work done by J.L.Chuma and F.W.Jones, TRIUMF, June 96.
 // H. Fesefeldt, RWTH-Aachen, 23-October-1996
 …
 #include "G4HEPionMinusInelastic.hh"
 G4HadFinalState * G4HEPionMinusInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
     const G4HadProjectile *aParticle = &aTrack;
 //    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
     const G4double A = targetNucleus.GetN();
     const G4double Z = targetNucleus.GetZ();
     G4HEVector incidentParticle(aParticle);
+G4HadFinalState*
+G4HEPionMinusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                      G4Nucleus& targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
+  const G4double A = targetNucleus.GetN();
+  const G4double Z = targetNucleus.GetZ();
+  G4HEVector incidentParticle(aParticle);
+    G4double atomicNumber = Z;
+    G4double atomicWeight = A;
+    G4int    incidentCode          = incidentParticle.getCode();
+    G4double incidentMass          = incidentParticle.getMass();
+    G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+    if(incidentKineticEnergy < 1.)
+      {
+        G4cout << "GHEPionMinusInelastic: incident energy < 1 GeV" << G4endl ;
+      }
+    if(verboseLevel > 1)
+      {
+        G4cout << "G4HEPionMinusInelastic::ApplyYourself" << G4endl;
+        G4cout << "incident particle " << incidentParticle.getName()
+             << "mass "              << incidentMass
+             << "kinetic energy "    << incidentKineticEnergy
+             << G4endl;
+        G4cout << "target material with (A,Z) = ("
+             << atomicWeight << "," << atomicNumber << ")" << G4endl;
+      }
+    G4double inelasticity  = NuclearInelasticity(incidentKineticEnergy,
+                                                 atomicWeight, atomicNumber);
+    if(verboseLevel > 1)
+        G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+    incidentKineticEnergy -= inelasticity;
+  G4double atomicNumber = Z;
+  G4double atomicWeight = A;
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+  if (incidentKineticEnergy < 1.)
+    G4cout << "GHEPionMinusInelastic: incident energy < 1 GeV" << G4endl;
+  if (verboseLevel > 1) {
+    G4cout << "G4HEPionMinusInelastic::ApplyYourself" << G4endl;
+    G4cout << "incident particle " << incidentParticle.getName()
+           << "mass "              << incidentMass
+           << "kinetic energy "    << incidentKineticEnergy
+           << G4endl;
+    G4cout << "target material with (A,Z) = ("
+           << atomicWeight << "," << atomicNumber << ")" << G4endl;
+  }
+  G4double inelasticity = NuclearInelasticity(incidentKineticEnergy,
+                                              atomicWeight, atomicNumber);
+  if (verboseLevel > 1)
+    G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+  incidentKineticEnergy -= inelasticity;
+    G4double excitationEnergyGNP = 0.;
+    G4double excitationEnergyDTA = 0.;
+    G4double excitation    = NuclearExcitation(incidentKineticEnergy,
+                                               atomicWeight, atomicNumber,
+                                               excitationEnergyGNP,
+                                               excitationEnergyDTA);
+    if(verboseLevel > 1)
+      G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+           << excitationEnergyDTA << G4endl;
+    incidentKineticEnergy -= excitation;
+    incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+    G4HEVector targetParticle;
+  G4double excitationEnergyGNP = 0.;
+  G4double excitationEnergyDTA = 0.;
+  G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                          atomicWeight, atomicNumber,
+                                          excitationEnergyGNP,
+                                          excitationEnergyDTA);
+  if (verboseLevel > 1)
+    G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+           << excitationEnergyDTA << G4endl;
+  incidentKineticEnergy -= excitation;
+  incidentTotalEnergy = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                    *(incidentTotalEnergy+incidentMass));
+  G4HEVector targetParticle;
+    if(G4UniformRand() < atomicNumber/atomicWeight)
+      {
+        targetParticle.setDefinition("Proton");
+      }
+    else
+      {
+        targetParticle.setDefinition("Neutron");
+      }
+    G4double targetMass         = targetParticle.getMass();
+    G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+    G4double availableEnergy    = centerOfMassEnergy - targetMass - incidentMass;
+                                                                // this was the meaning of inElastic in the
+                                                                // original Gheisha stand-alone version.
+//    G4bool   inElastic          = InElasticCrossSectionInFirstInt
+//                                    (availableEnergy, incidentCode, incidentTotalMomentum);
+                                                                // by unknown reasons, it has been replaced
+                                                                // to the following code in Geant???
+    G4bool inElastic = true;
+//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+    vecLength = 0;
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
+    targetParticle.setDefinition("Proton");
+  } else {
+    targetParticle.setDefinition("Neutron");
+  }
+  G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                        + targetMass*targetMass
+                                        + 2.0*targetMass*incidentTotalEnergy);
+  G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
+  // The value of the inElastic flag was originally defined in the Gheisha
+  // stand-alone code as follows:
+  //   G4bool inElastic = InElasticCrossSectionInFirstInt
+  //                      (availableEnergy, incidentCode, incidentTotalMomentum);
+  // For unknown reasons, it was replaced by the following code in Geant
+  G4bool inElastic = true;
+  //    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+  vecLength = 0;
     if(verboseLevel > 1)
       G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
            << incidentCode << G4endl;
     G4bool successful = false;
+  G4bool successful = false;
+    if(inElastic || (!inElastic && atomicWeight < 1.5))
+      {
+        FirstIntInCasPionMinus(inElastic, availableEnergy, pv, vecLength,
+                               incidentParticle, targetParticle);
+        if(verboseLevel > 1)
+           G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+        if ((vecLength > 0) && (availableEnergy > 1.))
+                   StrangeParticlePairProduction( availableEnergy, centerOfMassEnergy,
+                                                  pv, vecLength,
+                                                  incidentParticle, targetParticle);
+            HighEnergyCascading( successful, pv, vecLength,
+                                 excitationEnergyGNP, excitationEnergyDTA,
+                                 incidentParticle, targetParticle,
+                                 atomicWeight, atomicNumber);
+        if (!successful)
+            HighEnergyClusterProduction( successful, pv, vecLength,
+                                         excitationEnergyGNP, excitationEnergyDTA,
+                                         incidentParticle, targetParticle,
+                                         atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyCascading( successful, pv, vecLength,
+                                   excitationEnergyGNP, excitationEnergyDTA,
+                                   incidentParticle, targetParticle,
+                                   atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyClusterProduction( successful, pv, vecLength,
+                                           excitationEnergyGNP, excitationEnergyDTA,
+                                           incidentParticle, targetParticle,
+                                           atomicWeight, atomicNumber);
+        if (!successful)
+            QuasiElasticScattering( successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+            ElasticScattering( successful, pv, vecLength,
+                               incidentParticle,
+                               atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+        G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles" << G4endl;
+      }
+      FillParticleChange(pv,  vecLength);
+      delete [] pv;
+      theParticleChange.SetStatusChange(stopAndKill);
+      return & theParticleChange;
+  }
+  FirstIntInCasPionMinus(inElastic, availableEnergy, pv, vecLength,
+                         incidentParticle, targetParticle);
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+                                  incidentParticle, targetParticle,
+                                  atomicWeight, atomicNumber);
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
+  if (!successful)
+    ElasticScattering(successful, pv, vecLength,
+                      incidentParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+           << G4endl;
+  FillParticleChange(pv,  vecLength);
+  delete [] pv;
+  theParticleChange.SetStatusChange(stopAndKill);
+  return &theParticleChange;
+}
 void
 G4HEPionMinusInelastic::FirstIntInCasPionMinus( G4bool &inElastic,
                                                 const G4double availableEnergy,
                                                 G4HEVector pv[],
                                                 G4int &vecLen,
                                                 G4HEVector incidentParticle,
                                                 G4HEVector targetParticle)
+G4HEPionMinusInelastic::FirstIntInCasPionMinus(G4bool& inElastic,
+                                               const G4double availableEnergy,
+                                               G4HEVector pv[],
+                                               G4int& vecLen,
+                                               const G4HEVector& incidentParticle,
+                                               const G4HEVector& targetParticle)
 // Pion- undergoes interaction with nucleon within a nucleus.  Check if it is
 …
 // protons/neutrons by kaons or strange baryons according to the average
 // multiplicity per inelastic reaction.
+ {
+   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
+   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+   static const G4double protb = 0.7;
+   static const G4double neutb = 0.7;
+   static const G4double     c = 1.25;
+   static const G4int   numMul = 1200;
+   static const G4int   numSec = 60;
+//   G4int              neutronCode = Neutron.getCode();
+   G4int              protonCode  = Proton.getCode();
+   G4int               targetCode = targetParticle.getCode();
+//   G4double          incidentMass = incidentParticle.getMass();
+//   G4double        incidentEnergy = incidentParticle.getEnergy();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   static G4bool first = true;
+   static G4double protmul[numMul], protnorm[numSec];  // proton constants
+   static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+//                                misc. local variables
+//                                np = number of pi+,  nm = number of pi-,  nz = number of pi0
+   G4int i, counter, nt, np, nm, nz;
+{
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
+  static const G4double protb = 0.7;
+  static const G4double neutb = 0.7;
+  static const G4double     c = 1.25;
+  static const G4int numMul = 1200;
+  static const G4int numSec = 60;
+  G4int protonCode  = Proton.getCode();
+  G4int targetCode = targetParticle.getCode();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  static G4bool first = true;
+  static G4double protmul[numMul], protnorm[numSec];  // proton constants
+  static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+  // misc. local variables
+  // np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  G4int i, counter, nt, np, nm, nz;
    if( first )
      {                         // compute normalization constants, this will only be done once
+     {    // compute normalization constants, this will only be done once
        first = false;
        for( i=0; i<numMul; i++ )protmul[i]  = 0.0;

trunk/source/processes/hadronic/models/high_energy/src/G4HEPionPlusInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HEPionPlusInelastic.cc,v 1.15 2008/03/17 20:49:17 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HEPionPlusInelastic.cc,v 1.17 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model. Not included are the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 // First work done by J.L.Chuma and F.W.Jones, TRIUMF, June 96.
 // H. Fesefeldt, RWTH-Aachen, 23-October-1996
 …
 #include "G4HEPionPlusInelastic.hh"
 G4HadFinalState *  G4HEPionPlusInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
     const G4HadProjectile *aParticle = &aTrack;
 //    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
     const G4double A = targetNucleus.GetN();
     const G4double Z = targetNucleus.GetZ();
     G4HEVector incidentParticle(aParticle);
+G4HadFinalState*
+G4HEPionPlusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                     G4Nucleus& targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
+  const G4double A = targetNucleus.GetN();
+  const G4double Z = targetNucleus.GetZ();
+  G4HEVector incidentParticle(aParticle);
+    G4double atomicNumber = Z;
+    G4double atomicWeight = A;
+    G4int    incidentCode          = incidentParticle.getCode();
+    G4double incidentMass          = incidentParticle.getMass();
+    G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+    if(incidentKineticEnergy < 1.)
+      {
+        G4cout << "G4HEPionPlusInelastic: incident energy < 1 GeV" << G4endl;
+      }
+    if(verboseLevel > 1)
+      {
+        G4cout << "G4HEPionPlusInelastic::ApplyYourself" << G4endl;
+        G4cout << "incident particle " << incidentParticle.getName()
+             << "mass "              << incidentMass
+             << "kinetic energy "    << incidentKineticEnergy
+             << G4endl;
+        G4cout << "target material with (A,Z) = ("
+             << atomicWeight << "," << atomicNumber << ")" << G4endl;
+      }
+    G4double inelasticity  = NuclearInelasticity(incidentKineticEnergy,
+                                                 atomicWeight, atomicNumber);
+    if(verboseLevel > 1)
+        G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+  G4double atomicNumber = Z;
+  G4double atomicWeight = A;
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+  if (incidentKineticEnergy < 1.)
+    G4cout << "G4HEPionPlusInelastic: incident energy < 1 GeV" << G4endl;
+  if (verboseLevel > 1) {
+    G4cout << "G4HEPionPlusInelastic::ApplyYourself" << G4endl;
+    G4cout << "incident particle " << incidentParticle.getName()
+           << "mass "              << incidentMass
+           << "kinetic energy "    << incidentKineticEnergy
+           << G4endl;
+    G4cout << "target material with (A,Z) = ("
+           << atomicWeight << "," << atomicNumber << ")" << G4endl;
+  }
+  G4double inelasticity = NuclearInelasticity(incidentKineticEnergy,
+                                              atomicWeight, atomicNumber);
+  if (verboseLevel > 1)
+    G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
     incidentKineticEnergy -= inelasticity;
+  incidentKineticEnergy -= inelasticity;
     G4double excitationEnergyGNP = 0.;
     G4double excitationEnergyDTA = 0.;
     G4double excitation    = NuclearExcitation(incidentKineticEnergy,
                                                atomicWeight, atomicNumber,
                                                excitationEnergyGNP,
                                                excitationEnergyDTA);
     if(verboseLevel > 1)
       G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+  G4double excitationEnergyGNP = 0.;
+  G4double excitationEnergyDTA = 0.;
+  G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                          atomicWeight, atomicNumber,
+                                          excitationEnergyGNP,
+                                          excitationEnergyDTA);
+  if (verboseLevel > 1)
+    G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
            << excitationEnergyDTA << G4endl;
+    incidentKineticEnergy -= excitation;
+    incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+    G4HEVector targetParticle;
+    if(G4UniformRand() < atomicNumber/atomicWeight)
+      {
+        targetParticle.setDefinition("Proton");
+      }
+    else
+      {
+        targetParticle.setDefinition("Neutron");
+      }
+    G4double targetMass         = targetParticle.getMass();
+    G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+    G4double availableEnergy    = centerOfMassEnergy - targetMass - incidentMass;
+                                                                // this was the meaning of inElastic in the
+                                                                // original Gheisha stand-alone version.
+//    G4bool   inElastic          = InElasticCrossSectionInFirstInt
+//                                    (availableEnergy, incidentCode, incidentTotalMomentum);
+                                                                // by unknown reasons, it has been replaced
+                                                                // to the following code in Geant???
+    G4bool inElastic = true;
+//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+    vecLength      = 0;
+  incidentKineticEnergy -= excitation;
+  incidentTotalEnergy = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                    *(incidentTotalEnergy+incidentMass));
+  G4HEVector targetParticle;
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
+    targetParticle.setDefinition("Proton");
+  } else {
+    targetParticle.setDefinition("Neutron");
+  }
+  G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                        + targetMass*targetMass
+                                        + 2.0*targetMass*incidentTotalEnergy);
+  G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
+  G4bool inElastic = true;
+  vecLength = 0;
     if(verboseLevel > 1)
       G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
            << incidentCode << G4endl;
     G4bool successful = false;
+  G4bool successful = false;
+    if(inElastic || (!inElastic && atomicWeight < 1.5))
+      {
+        FirstIntInCasPionPlus(inElastic, availableEnergy, pv, vecLength,
+                              incidentParticle, targetParticle, atomicWeight);
+        if(verboseLevel > 1)
+           G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+        if ((vecLength > 0) && (availableEnergy > 1.))
+                   StrangeParticlePairProduction( availableEnergy, centerOfMassEnergy,
+                                                  pv, vecLength,
+                                                  incidentParticle, targetParticle);
+            HighEnergyCascading( successful, pv, vecLength,
+                                 excitationEnergyGNP, excitationEnergyDTA,
+                                 incidentParticle, targetParticle,
+                                 atomicWeight, atomicNumber);
+        if (!successful)
+            HighEnergyClusterProduction( successful, pv, vecLength,
+                                         excitationEnergyGNP, excitationEnergyDTA,
+                                         incidentParticle, targetParticle,
+                                         atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyCascading( successful, pv, vecLength,
+                                   excitationEnergyGNP, excitationEnergyDTA,
+                                   incidentParticle, targetParticle,
+                                   atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyClusterProduction( successful, pv, vecLength,
+                                           excitationEnergyGNP, excitationEnergyDTA,
+                                           incidentParticle, targetParticle,
+                                           atomicWeight, atomicNumber);
+        if (!successful)
+            QuasiElasticScattering( successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+            ElasticScattering( successful, pv, vecLength,
+                               incidentParticle,
+                               atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+        G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles" << G4endl;
+      }
+      FillParticleChange(pv,  vecLength);
+      delete [] pv;
+      theParticleChange.SetStatusChange(stopAndKill);
+      return & theParticleChange;
+  }
+  FirstIntInCasPionPlus(inElastic, availableEnergy, pv, vecLength,
+                        incidentParticle, targetParticle, atomicWeight);
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+                                  incidentParticle, targetParticle,
+                                  atomicWeight, atomicNumber);
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
+  if (!successful)
+    ElasticScattering(successful, pv, vecLength,
+                      incidentParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+           << G4endl;
+  FillParticleChange(pv, vecLength);
+  delete [] pv;
+  theParticleChange.SetStatusChange(stopAndKill);
+  return &theParticleChange;
+}
 void
 G4HEPionPlusInelastic::FirstIntInCasPionPlus( G4bool &inElastic,
                                               const G4double availableEnergy,
                                               G4HEVector pv[],
                                               G4int &vecLen,
                                               G4HEVector incidentParticle,
                                               G4HEVector targetParticle,
                                               const G4double atomicWeight)
+G4HEPionPlusInelastic::FirstIntInCasPionPlus(G4bool& inElastic,
+                                             const G4double availableEnergy,
+                                             G4HEVector pv[],
+                                             G4int& vecLen,
+                                             const G4HEVector& incidentParticle,
+                                             const G4HEVector& targetParticle,
+                                             const G4double atomicWeight)
 // Pion+ undergoes interaction with nucleon within a nucleus.  Check if it is
 …
 // protons/neutrons by kaons or strange baryons according to the average
 // multiplicity per inelastic reaction.
+ {
+   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
+   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+   static const G4double protb = 0.7;
+   static const G4double neutb = 0.7;
+   static const G4double     c = 1.25;
+   static const G4int   numMul = 1200;
+   static const G4int   numSec = 60;
+   G4int              neutronCode = Neutron.getCode();
+   G4int              protonCode  = Proton.getCode();
+   G4double           pionMass    = PionPlus.getMass();
+   G4int               targetCode = targetParticle.getCode();
+//   G4double          incidentMass = incidentParticle.getMass();
+//   G4double        incidentEnergy = incidentParticle.getEnergy();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   static G4bool first = true;
+   static G4double protmul[numMul], protnorm[numSec];  // proton constants
+   static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+//                                misc. local variables
+//                                np = number of pi+,  nm = number of pi-,  nz = number of pi0
+   G4int i, counter, nt, np, nm, nz;
+{
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
+  static const G4double protb = 0.7;
+  static const G4double neutb = 0.7;
+  static const G4double     c = 1.25;
+  static const G4int numMul = 1200;
+  static const G4int numSec = 60;
+  G4int neutronCode = Neutron.getCode();
+  G4int protonCode = Proton.getCode();
+  G4double pionMass = PionPlus.getMass();
+  G4int targetCode = targetParticle.getCode();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  static G4bool first = true;
+  static G4double protmul[numMul], protnorm[numSec];  // proton constants
+  static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+  // misc. local variables
+  // np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  G4int i, counter, nt, np, nm, nz;
    if( first )
      {                         // compute normalization constants, this will only be done once
+     {   // compute normalization constants, this will only be done once
        first = false;
        for( i=0; i<numMul; i++ )protmul[i]  = 0.0;

trunk/source/processes/hadronic/models/high_energy/src/G4HEProtonInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HEProtonInelastic.cc,v 1.14 2008/03/17 20:49:17 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HEProtonInelastic.cc,v 1.16 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model. Not included are the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 // First work done by J.L.Chuma and F.W.Jones, TRIUMF, June 96.
 // H. Fesefeldt, RWTH-Aachen, 23-October-1996
 …
 #include "G4HEProtonInelastic.hh"
 G4HadFinalState *  G4HEProtonInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
     const G4HadProjectile *aParticle = &aTrack;
 //    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
     const G4double A = targetNucleus.GetN();
     const G4double Z = targetNucleus.GetZ();
     G4HEVector incidentParticle(aParticle);
+G4HadFinalState*
+G4HEProtonInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                   G4Nucleus& targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
+  const G4double A = targetNucleus.GetN();
+  const G4double Z = targetNucleus.GetZ();
+  G4HEVector incidentParticle(aParticle);
+    G4double atomicNumber = Z;
+    G4double atomicWeight = A;
+    if(verboseLevel > 1)
+      G4cout << "Z , A = " << atomicNumber << "  " << atomicWeight << G4endl;
+    G4int    incidentCode          = incidentParticle.getCode();
+    G4double incidentMass          = incidentParticle.getMass();
+    G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double incidentKineticEnergy = incidentParticle.getKineticEnergy();
+    if(incidentKineticEnergy < 1.)
+      {
+        G4cout << "GHEProtonInelastic: incident energy < 1 GeV" << G4endl;
+      }
+    if(verboseLevel > 1)
+      {
+        G4cout << "G4HEProtonInelastic::ApplyYourself" << G4endl;
+        G4cout << "incident particle " << incidentParticle.getName() << " "
+             << "mass "              << incidentMass << " "
+             << "kinetic energy "    << incidentKineticEnergy
+             << G4endl;
+        G4cout << "target material with (A,Z) = ("
+             << atomicWeight << "," << atomicNumber << ")" << G4endl;
+      }
+  G4double atomicNumber = Z;
+  G4double atomicWeight = A;
+  if (verboseLevel > 1)
+    G4cout << "Z , A = " << atomicNumber << "  " << atomicWeight << G4endl;
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentKineticEnergy = incidentParticle.getKineticEnergy();
+  if (incidentKineticEnergy < 1.)
+    G4cout << "GHEProtonInelastic: incident energy < 1 GeV" << G4endl;
+  if (verboseLevel > 1) {
+    G4cout << "G4HEProtonInelastic::ApplyYourself" << G4endl;
+    G4cout << "incident particle " << incidentParticle.getName() << " "
+           << "mass "              << incidentMass << " "
+           << "kinetic energy "    << incidentKineticEnergy
+           << G4endl;
+    G4cout << "target material with (A,Z) = ("
+           << atomicWeight << "," << atomicNumber << ")" << G4endl;
+  }
     G4double inelasticity  = NuclearInelasticity(incidentKineticEnergy,
                                                  atomicWeight, atomicNumber);
     if(verboseLevel > 1)
         G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
     incidentKineticEnergy -= inelasticity;
+  G4double inelasticity = NuclearInelasticity(incidentKineticEnergy,
+                                              atomicWeight, atomicNumber);
+  if (verboseLevel > 1)
+    G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+  incidentKineticEnergy -= inelasticity;
+    G4double excitationEnergyGNP = 0.;
+    G4double excitationEnergyDTA = 0.;
+    G4double excitation    = NuclearExcitation(incidentKineticEnergy,
+                                               atomicWeight, atomicNumber,
+                                               excitationEnergyGNP,
+                                               excitationEnergyDTA);
+    if(verboseLevel > 1)
+      G4cout << "nuclear excitation = " << excitation << " " << excitationEnergyGNP << " "
+           << excitationEnergyDTA << G4endl;
+    incidentKineticEnergy -= excitation;
+    incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+    G4HEVector targetParticle;
+    if(G4UniformRand() < atomicNumber/atomicWeight)
+      {
+        targetParticle.setDefinition("Proton");
+      }
+    else
+      {
+        targetParticle.setDefinition("Neutron");
+      }
+    G4double targetMass         = targetParticle.getMass();
+    G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+    G4double availableEnergy    = centerOfMassEnergy - targetMass - incidentMass;
+                                                                // this was the meaning of inElastic in the
+                                                                // original Gheisha stand-alone version.
+//    G4bool   inElastic          = InElasticCrossSectionInFirstInt
+//                                    (availableEnergy, incidentCode, incidentTotalMomentum);
+                                                                // by unknown reasons, it has been replaced
+                                                                // to the following code in Geant???
+    G4bool inElastic = true;
+//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+    vecLength = 0;
+  G4double excitationEnergyGNP = 0.;
+  G4double excitationEnergyDTA = 0.;
+  G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                          atomicWeight, atomicNumber,
+                                          excitationEnergyGNP,
+                                          excitationEnergyDTA);
+  if (verboseLevel > 1)
+    G4cout << "nuclear excitation = " << excitation << " "
+           << excitationEnergyGNP << " " << excitationEnergyDTA << G4endl;
+  incidentKineticEnergy -= excitation;
+  incidentTotalEnergy = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                    *(incidentTotalEnergy+incidentMass));
+  G4HEVector targetParticle;
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
+    targetParticle.setDefinition("Proton");
+  } else {
+    targetParticle.setDefinition("Neutron");
+  }
+  G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                        + targetMass*targetMass
+                                        + 2.0*targetMass*incidentTotalEnergy);
+  G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
+  // In the original Gheisha code, the inElastic flag was defined as follows:
+  //   G4bool inElastic = InElasticCrossSectionInFirstInt
+  //              (availableEnergy, incidentCode, incidentTotalMomentum);
+  // For unknown reasons, it was replaced by the following code in Geant???
+  G4bool inElastic = true;
+  //  if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+  vecLength = 0;
     if(verboseLevel > 1)
       G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
            << incidentCode << G4endl;
     G4bool successful = false;
+  G4bool successful = false;
+    if(inElastic || (!inElastic && atomicWeight < 1.5))
+      {
+        FirstIntInCasProton(inElastic, availableEnergy, pv, vecLength,
+                            incidentParticle, targetParticle, atomicWeight);
+        if(verboseLevel > 1)
+           G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+        if ((vecLength > 0) && (availableEnergy > 1.))
+                   StrangeParticlePairProduction( availableEnergy, centerOfMassEnergy,
+                                                  pv, vecLength,
+                                                  incidentParticle, targetParticle);
+            HighEnergyCascading( successful, pv, vecLength,
+                                 excitationEnergyGNP, excitationEnergyDTA,
+                                 incidentParticle, targetParticle,
+                                 atomicWeight, atomicNumber);
+        if (!successful)
+            HighEnergyClusterProduction( successful, pv, vecLength,
+                                         excitationEnergyGNP, excitationEnergyDTA,
+                                         incidentParticle, targetParticle,
+                                         atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyCascading( successful, pv, vecLength,
+                                   excitationEnergyGNP, excitationEnergyDTA,
+                                   incidentParticle, targetParticle,
+                                   atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyClusterProduction( successful, pv, vecLength,
+                                           excitationEnergyGNP, excitationEnergyDTA,
+                                           incidentParticle, targetParticle,
+                                           atomicWeight, atomicNumber);
+        if (!successful)
+            QuasiElasticScattering( successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+            ElasticScattering( successful, pv, vecLength,
+                               incidentParticle,
+                               atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+        G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles" << G4endl;
+      }
+      FillParticleChange(pv,  vecLength);
+      delete [] pv;
+      theParticleChange.SetStatusChange(stopAndKill);
+      return & theParticleChange;
+  }
+  FirstIntInCasProton(inElastic, availableEnergy, pv, vecLength,
+                      incidentParticle, targetParticle, atomicWeight);
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+                                  incidentParticle, targetParticle,
+                                  atomicWeight, atomicNumber);
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
+  if (!successful)
+    ElasticScattering(successful, pv, vecLength,
+                      incidentParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+           << G4endl;
+  FillParticleChange(pv, vecLength);
+  delete [] pv;
+  theParticleChange.SetStatusChange(stopAndKill);
+  return &theParticleChange;
+}
 void
 G4HEProtonInelastic::FirstIntInCasProton( G4bool &inElastic,
                                           const G4double availableEnergy,
                                           G4HEVector pv[],
                                           G4int &vecLen,
                                           G4HEVector incidentParticle,
                                           G4HEVector targetParticle,
                                           const G4double atomicWeight)
+G4HEProtonInelastic::FirstIntInCasProton(G4bool& inElastic,
+                                         const G4double availableEnergy,
+                                         G4HEVector pv[],
+                                         G4int& vecLen,
+                                         const G4HEVector& incidentParticle,
+                                         const G4HEVector& targetParticle,
+                                         const G4double atomicWeight)
 // Proton undergoes interaction with nucleon within a nucleus.  Check if it is
 …
 // protons/neutrons by kaons or strange baryons according to the average
 // multiplicity per inelastic reaction.
+ {
+   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
+   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+   static const G4double protb = 0.7;
+   static const G4double neutb = 0.35;
+   static const G4double     c = 1.25;
+   static const G4int   numMul = 1200;
+   static const G4int   numSec = 60;
+   G4int              neutronCode = Neutron.getCode();
+   G4int              protonCode  = Proton.getCode();
+   G4double           pionMass    = PionPlus.getMass();
+   G4int               targetCode = targetParticle.getCode();
+//   G4double          incidentMass = incidentParticle.getMass();
+//   G4double        incidentEnergy = incidentParticle.getEnergy();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   static G4bool first = true;
+   static G4double protmul[numMul], protnorm[numSec];  // proton constants
+   static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+                              //  misc. local variables
+                              //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+   G4int i, counter, nt, np, nm, nz;
+   if( first )
+     {                         // compute normalization constants, this will only be done once
+       first = false;
+       for( i=0; i<numMul; i++ )protmul[i]  = 0.0;
+       for( i=0; i<numSec; i++ )protnorm[i] = 0.0;
+       counter = -1;
+       for( np=0; np<(numSec/3); np++ )
+          {
+            for( nm=Imax(0,np-2); nm<=np; nm++ )
+               {
+                 for( nz=0; nz<numSec/3; nz++ )
+                    {
+                      if( ++counter < numMul )
+                        {
+                          nt = np+nm+nz;
+                          if( (nt>0) && (nt<=numSec) )
+                            {
+                              protmul[counter] = pmltpc(np,nm,nz,nt,protb,c)
+                                                 /(Factorial(2-np+nm)*Factorial(np-nm)) ;
+                              protnorm[nt-1] += protmul[counter];
+                            }
+                        }
+                    }
+               }
+{
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
+  static const G4double protb = 0.7;
+  static const G4double neutb = 0.35;
+  static const G4double     c = 1.25;
+  static const G4int numMul = 1200;
+  static const G4int numSec = 60;
+  G4int neutronCode = Neutron.getCode();
+  G4int protonCode = Proton.getCode();
+  G4double pionMass = PionPlus.getMass();
+  G4int targetCode = targetParticle.getCode();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  static G4bool first = true;
+  static G4double protmul[numMul], protnorm[numSec];  // proton constants
+  static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+  //  misc. local variables
+  //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  G4int i, counter, nt, np, nm, nz;
+  if (first) {
+    // compute normalization constants, this will only be done once
+    first = false;
+    for (i=0; i<numMul; i++) protmul[i] = 0.0;
+    for (i=0; i<numSec; i++) protnorm[i] = 0.0;
+    counter = -1;
+    for (np=0; np<(numSec/3); np++) {
+      for (nm=Imax(0,np-2); nm<=np; nm++) {
+        for (nz=0; nz<numSec/3; nz++) {
+          if (++counter < numMul) {
+            nt = np+nm+nz;
+            if ( (nt>0) && (nt<=numSec) ) {
+              protmul[counter] = pmltpc(np,nm,nz,nt,protb,c)
+                                 /(Factorial(2-np+nm)*Factorial(np-nm)) ;
+              protnorm[nt-1] += protmul[counter];
+            }
+          }
+       for( i=0; i<numMul; i++ )neutmul[i]  = 0.0;
+       for( i=0; i<numSec; i++ )neutnorm[i] = 0.0;
+       counter = -1;
+       for( np=0; np<numSec/3; np++ )
+          {
+            for( nm=Imax(0,np-1); nm<=(np+1); nm++ )
+               {
+                 for( nz=0; nz<numSec/3; nz++ )
+                    {
+                      if( ++counter < numMul )
+                        {
+                          nt = np+nm+nz;
+                          if( (nt>0) && (nt<=numSec) )
+                            {
+                               neutmul[counter] = pmltpc(np,nm,nz,nt,neutb,c)
+                                                  /(Factorial(1-np+nm)*Factorial(1+np-nm));
+                               neutnorm[nt-1] += neutmul[counter];
+                            }
+                        }
+                    }
+               }
+        }
+      }
+    }
+    for( i=0; i<numMul; i++ )neutmul[i]  = 0.0;
+    for( i=0; i<numSec; i++ )neutnorm[i] = 0.0;
+    counter = -1;
+    for (np=0; np<numSec/3; np++) {
+      for (nm=Imax(0,np-1); nm<=(np+1); nm++) {
+        for (nz=0; nz<numSec/3; nz++) {
+          if (++counter < numMul) {
+            nt = np+nm+nz;
+            if ( (nt>0) && (nt<=numSec) ) {
+              neutmul[counter] = pmltpc(np,nm,nz,nt,neutb,c)
+                                 /(Factorial(1-np+nm)*Factorial(1+np-nm));
+              neutnorm[nt-1] += neutmul[counter];
+            }
+          }
+       for( i=0; i<numSec; i++ )
+          {
+            if( protnorm[i] > 0.0 )protnorm[i] = 1.0/protnorm[i];
+            if( neutnorm[i] > 0.0 )neutnorm[i] = 1.0/neutnorm[i];
+          }
+     }                                          // end of initialization
+        }
+      }
+    }
+    for (i=0; i<numSec; i++) {
+      if( protnorm[i] > 0.0 )protnorm[i] = 1.0/protnorm[i];
+      if( neutnorm[i] > 0.0 )neutnorm[i] = 1.0/neutnorm[i];
+    }
+  }                   // end of initialization
                                               // initialize the first two places
                                               // the same as beam and target
    pv[0] = incidentParticle;
    pv[1] = targetParticle;
    vecLen = 2;
+  // initialize the first two places
+  // the same as beam and target
+  pv[0] = incidentParticle;
+  pv[1] = targetParticle;
+  vecLen = 2;
    if( !inElastic )

trunk/source/processes/hadronic/models/high_energy/src/G4HESigmaMinusInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HESigmaMinusInelastic.cc,v 1.15 2008/03/17 20:49:17 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HESigmaMinusInelastic.cc,v 1.17 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model. Not included are the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 // First work done by J.L.Chuma and F.W.Jones, TRIUMF, June 96.
 // H. Fesefeldt, RWTH-Aachen, 23-October-1996
 …
 #include "G4HESigmaMinusInelastic.hh"
 G4HadFinalState *  G4HESigmaMinusInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
     const G4HadProjectile *aParticle = &aTrack;
 //    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
     const G4double A = targetNucleus.GetN();
     const G4double Z = targetNucleus.GetZ();
     G4HEVector incidentParticle(aParticle);
+G4HadFinalState*
+G4HESigmaMinusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                       G4Nucleus& targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
+  const G4double A = targetNucleus.GetN();
+  const G4double Z = targetNucleus.GetZ();
+  G4HEVector incidentParticle(aParticle);
+    G4double atomicNumber = Z;
+    G4double atomicWeight = A;
+    G4int    incidentCode          = incidentParticle.getCode();
+    G4double incidentMass          = incidentParticle.getMass();
+    G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+    if(incidentKineticEnergy < 1.)
+      {
+        G4cout << "GHESigmaMinusInelastic: incident energy < 1 GeV" << G4endl;
+      }
+    if(verboseLevel > 1)
+      {
+        G4cout << "G4HESigmaMinusInelastic::ApplyYourself" << G4endl;
+        G4cout << "incident particle " << incidentParticle.getName()
+             << "mass "              << incidentMass
+             << "kinetic energy "    << incidentKineticEnergy
+             << G4endl;
+        G4cout << "target material with (A,Z) = ("
+             << atomicWeight << "," << atomicNumber << ")" << G4endl;
+      }
+    G4double inelasticity  = NuclearInelasticity(incidentKineticEnergy,
+                                                 atomicWeight, atomicNumber);
+    if(verboseLevel > 1)
+        G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+    incidentKineticEnergy -= inelasticity;
+  G4double atomicNumber = Z;
+  G4double atomicWeight = A;
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+  if (incidentKineticEnergy < 1.)
+    G4cout << "GHESigmaMinusInelastic: incident energy < 1 GeV" << G4endl;
+  if (verboseLevel > 1) {
+    G4cout << "G4HESigmaMinusInelastic::ApplyYourself" << G4endl;
+    G4cout << "incident particle " << incidentParticle.getName()
+           << "mass "              << incidentMass
+           << "kinetic energy "    << incidentKineticEnergy
+           << G4endl;
+    G4cout << "target material with (A,Z) = ("
+           << atomicWeight << "," << atomicNumber << ")" << G4endl;
+  }
+  G4double inelasticity = NuclearInelasticity(incidentKineticEnergy,
+                                              atomicWeight, atomicNumber);
+  if (verboseLevel > 1)
+    G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+  incidentKineticEnergy -= inelasticity;
+    G4double excitationEnergyGNP = 0.;
+    G4double excitationEnergyDTA = 0.;
+    G4double excitation    = NuclearExcitation(incidentKineticEnergy,
+                                               atomicWeight, atomicNumber,
+                                               excitationEnergyGNP,
+                                               excitationEnergyDTA);
+    if(verboseLevel > 1)
+      G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+           << excitationEnergyDTA << G4endl;
+    incidentKineticEnergy -= excitation;
+    incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+    G4HEVector targetParticle;
+    if(G4UniformRand() < atomicNumber/atomicWeight)
+      {
+        targetParticle.setDefinition("Proton");
+      }
+    else
+      {
+        targetParticle.setDefinition("Neutron");
+      }
+    G4double targetMass         = targetParticle.getMass();
+    G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+    G4double availableEnergy    = centerOfMassEnergy - targetMass - incidentMass;
+                                                                // this was the meaning of inElastic in the
+                                                                // original Gheisha stand-alone version.
+//    G4bool   inElastic          = InElasticCrossSectionInFirstInt
+//                                    (availableEnergy, incidentCode, incidentTotalMomentum);
+                                                                // by unknown reasons, it has been replaced
+                                                                // to the following code in Geant???
+    G4bool inElastic = true;
+//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+    vecLength = 0;
+  G4double excitationEnergyGNP = 0.;
+  G4double excitationEnergyDTA = 0.;
+  G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                          atomicWeight, atomicNumber,
+                                          excitationEnergyGNP,
+                                          excitationEnergyDTA);
+  if (verboseLevel > 1)
+    G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+           << excitationEnergyDTA << G4endl;
+  incidentKineticEnergy -= excitation;
+  incidentTotalEnergy = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                    *(incidentTotalEnergy+incidentMass));
+  G4HEVector targetParticle;
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
+    targetParticle.setDefinition("Proton");
+  } else {
+    targetParticle.setDefinition("Neutron");
+  }
+  G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                        + targetMass*targetMass
+                                        + 2.0*targetMass*incidentTotalEnergy);
+  G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
+  G4bool inElastic = true;
+  vecLength = 0;
     if(verboseLevel > 1)
       G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
            << incidentCode << G4endl;
     G4bool successful = false;
+  G4bool successful = false;
+    if(inElastic || (!inElastic && atomicWeight < 1.5))
+      {
+        FirstIntInCasSigmaMinus(inElastic, availableEnergy, pv, vecLength,
+                                incidentParticle, targetParticle, atomicWeight);
+        if(verboseLevel > 1)
+           G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+        if ((vecLength > 0) && (availableEnergy > 1.))
+                   StrangeParticlePairProduction( availableEnergy, centerOfMassEnergy,
+                                                  pv, vecLength,
+                                                  incidentParticle, targetParticle);
+            HighEnergyCascading( successful, pv, vecLength,
+                                 excitationEnergyGNP, excitationEnergyDTA,
+                                 incidentParticle, targetParticle,
+                                 atomicWeight, atomicNumber);
+        if (!successful)
+            HighEnergyClusterProduction( successful, pv, vecLength,
+                                         excitationEnergyGNP, excitationEnergyDTA,
+                                         incidentParticle, targetParticle,
+                                         atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyCascading( successful, pv, vecLength,
+                                   excitationEnergyGNP, excitationEnergyDTA,
+                                   incidentParticle, targetParticle,
+                                   atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyClusterProduction( successful, pv, vecLength,
+                                           excitationEnergyGNP, excitationEnergyDTA,
+                                           incidentParticle, targetParticle,
+                                           atomicWeight, atomicNumber);
+        if (!successful)
+            QuasiElasticScattering( successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+            ElasticScattering( successful, pv, vecLength,
+                               incidentParticle,
+                               atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+        G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles" << G4endl;
+      }
+      FillParticleChange(pv,  vecLength);
+      delete [] pv;
+      theParticleChange.SetStatusChange(stopAndKill);
+      return & theParticleChange;
+  }
+  FirstIntInCasSigmaMinus(inElastic, availableEnergy, pv, vecLength,
+                          incidentParticle, targetParticle, atomicWeight);
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+                                  incidentParticle, targetParticle,
+                                  atomicWeight, atomicNumber);
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
+  if (!successful)
+    ElasticScattering(successful, pv, vecLength,
+                      incidentParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+           << G4endl;
+  FillParticleChange(pv, vecLength);
+  delete [] pv;
+  theParticleChange.SetStatusChange(stopAndKill);
+  return &theParticleChange;
+}
 void
 G4HESigmaMinusInelastic::FirstIntInCasSigmaMinus( G4bool &inElastic,
                                                   const G4double availableEnergy,
                                                   G4HEVector pv[],
                                                   G4int &vecLen,
                                                   G4HEVector incidentParticle,
                                                   G4HEVector targetParticle,
                                                   const G4double atomicWeight)
+G4HESigmaMinusInelastic::FirstIntInCasSigmaMinus(G4bool& inElastic,
+                                                 const G4double availableEnergy,
+                                                 G4HEVector pv[],
+                                                 G4int& vecLen,
+                                                 const G4HEVector& incidentParticle,
+                                                 const G4HEVector& targetParticle,
+                                                 const G4double atomicWeight)
 // Sigma- undergoes interaction with nucleon within a nucleus.  Check if it is
 …
 // protons/neutrons by kaons or strange baryons according to the average
 // multiplicity per inelastic reaction.
+ {
+   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
+   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+   static const G4double protb = 0.7;
+   static const G4double neutb = 0.7;
+   static const G4double     c = 1.25;
+   static const G4int   numMul = 1200;
+   static const G4int   numSec = 60;
+   G4int              neutronCode = Neutron.getCode();
+   G4int              protonCode  = Proton.getCode();
+   G4int               targetCode = targetParticle.getCode();
+//   G4double          incidentMass = incidentParticle.getMass();
+//   G4double        incidentEnergy = incidentParticle.getEnergy();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   static G4bool first = true;
+   static G4double protmul[numMul], protnorm[numSec];  // proton constants
+   static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+                              //  misc. local variables
+                              //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+   G4int i, counter, nt, np, nm, nz;
+{
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
+  static const G4double protb = 0.7;
+  static const G4double neutb = 0.7;
+  static const G4double     c = 1.25;
+  static const G4int numMul = 1200;
+  static const G4int numSec = 60;
+  G4int neutronCode = Neutron.getCode();
+  G4int protonCode = Proton.getCode();
+  G4int targetCode = targetParticle.getCode();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  static G4bool first = true;
+  static G4double protmul[numMul], protnorm[numSec];  // proton constants
+  static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+  //  misc. local variables
+  //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  G4int i, counter, nt, np, nm, nz;
    if( first )
      {                         // compute normalization constants, this will only be done once
+     {     // compute normalization constants, this will only be done once
        first = false;
        for( i=0; i<numMul; i++ )protmul[i]  = 0.0;

trunk/source/processes/hadronic/models/high_energy/src/G4HESigmaPlusInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HESigmaPlusInelastic.cc,v 1.15 2008/03/17 20:49:17 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HESigmaPlusInelastic.cc,v 1.17 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model. Not included are the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 // First work done by J.L.Chuma and F.W.Jones, TRIUMF, June 96.
 // H. Fesefeldt, RWTH-Aachen, 23-October-1996
 …
 #include "G4HESigmaPlusInelastic.hh"
 G4HadFinalState *  G4HESigmaPlusInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
     const G4HadProjectile *aParticle = &aTrack;
 //    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
     const G4double A = targetNucleus.GetN();
     const G4double Z = targetNucleus.GetZ();
     G4HEVector incidentParticle(aParticle);
+G4HadFinalState*
+G4HESigmaPlusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                      G4Nucleus& targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
+  const G4double A = targetNucleus.GetN();
+  const G4double Z = targetNucleus.GetZ();
+  G4HEVector incidentParticle(aParticle);
+    G4double atomicNumber = Z;
+    G4double atomicWeight = A;
+    G4int    incidentCode          = incidentParticle.getCode();
+    G4double incidentMass          = incidentParticle.getMass();
+    G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+    if(incidentKineticEnergy < 1.)
+      {
+        G4cout << "GHESigmaPlusInelastic: incident energy < 1 GeV" << G4endl;
+      }
+    if(verboseLevel > 1)
+      {
+        G4cout << "G4HESigmaPlusInelastic::ApplyYourself" << G4endl;
+        G4cout << "incident particle " << incidentParticle.getName()
+             << "mass "              << incidentMass
+             << "kinetic energy "    << incidentKineticEnergy
+             << G4endl;
+        G4cout << "target material with (A,Z) = ("
+             << atomicWeight << "," << atomicNumber << ")" << G4endl;
+      }
+    G4double inelasticity  = NuclearInelasticity(incidentKineticEnergy,
+                                                 atomicWeight, atomicNumber);
+    if(verboseLevel > 1)
+        G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+    incidentKineticEnergy -= inelasticity;
+  G4double atomicNumber = Z;
+  G4double atomicWeight = A;
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+  if (incidentKineticEnergy < 1.)
+    G4cout << "GHESigmaPlusInelastic: incident energy < 1 GeV" << G4endl;
+  if (verboseLevel > 1) {
+    G4cout << "G4HESigmaPlusInelastic::ApplyYourself" << G4endl;
+    G4cout << "incident particle " << incidentParticle.getName()
+           << "mass "              << incidentMass
+           << "kinetic energy "    << incidentKineticEnergy
+           << G4endl;
+    G4cout << "target material with (A,Z) = ("
+           << atomicWeight << "," << atomicNumber << ")" << G4endl;
+  }
+  G4double inelasticity = NuclearInelasticity(incidentKineticEnergy,
+                                              atomicWeight, atomicNumber);
+  if (verboseLevel > 1)
+    G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+  incidentKineticEnergy -= inelasticity;
+    G4double excitationEnergyGNP = 0.;
+    G4double excitationEnergyDTA = 0.;
+    G4double excitation    = NuclearExcitation(incidentKineticEnergy,
+                                               atomicWeight, atomicNumber,
+                                               excitationEnergyGNP,
+                                               excitationEnergyDTA);
+    if(verboseLevel > 1)
+      G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+           << excitationEnergyDTA << G4endl;
+    incidentKineticEnergy -= excitation;
+    incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+    G4HEVector targetParticle;
+    if(G4UniformRand() < atomicNumber/atomicWeight)
+      {
+        targetParticle.setDefinition("Proton");
+      }
+    else
+      {
+        targetParticle.setDefinition("Neutron");
+      }
+    G4double targetMass         = targetParticle.getMass();
+    G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+    G4double availableEnergy    = centerOfMassEnergy - targetMass - incidentMass;
+                                                                // this was the meaning of inElastic in the
+                                                                // original Gheisha stand-alone version.
+//    G4bool   inElastic          = InElasticCrossSectionInFirstInt
+//                                    (availableEnergy, incidentCode, incidentTotalMomentum);
+                                                                // by unknown reasons, it has been replaced
+                                                                // to the following code in Geant???
+    G4bool inElastic = true;
+//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+    vecLength  = 0;
+  G4double excitationEnergyGNP = 0.;
+  G4double excitationEnergyDTA = 0.;
+  G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                          atomicWeight, atomicNumber,
+                                          excitationEnergyGNP,
+                                          excitationEnergyDTA);
+  if (verboseLevel > 1)
+    G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+           << excitationEnergyDTA << G4endl;
+  incidentKineticEnergy -= excitation;
+  incidentTotalEnergy = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                    *(incidentTotalEnergy+incidentMass));
+  G4HEVector targetParticle;
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
+    targetParticle.setDefinition("Proton");
+  } else {
+    targetParticle.setDefinition("Neutron");
+  }
+  G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                        + targetMass*targetMass
+                                        + 2.0*targetMass*incidentTotalEnergy);
+  G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
+  G4bool inElastic = true;
+  vecLength = 0;
     if(verboseLevel > 1)
       G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
            << incidentCode << G4endl;
     G4bool successful = false;
+  G4bool successful = false;
+    if(inElastic || (!inElastic && atomicWeight < 1.5))
+      {
+        FirstIntInCasSigmaPlus(inElastic, availableEnergy, pv, vecLength,
+                               incidentParticle, targetParticle, atomicWeight);
+        if(verboseLevel > 1)
+           G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+        if ((vecLength > 0) && (availableEnergy > 1.))
+                   StrangeParticlePairProduction( availableEnergy, centerOfMassEnergy,
+                                                  pv, vecLength,
+                                                  incidentParticle, targetParticle);
+            HighEnergyCascading( successful, pv, vecLength,
+                                 excitationEnergyGNP, excitationEnergyDTA,
+                                 incidentParticle, targetParticle,
+                                 atomicWeight, atomicNumber);
+        if (!successful)
+            HighEnergyClusterProduction( successful, pv, vecLength,
+                                         excitationEnergyGNP, excitationEnergyDTA,
+                                         incidentParticle, targetParticle,
+                                         atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyCascading( successful, pv, vecLength,
+                                   excitationEnergyGNP, excitationEnergyDTA,
+                                   incidentParticle, targetParticle,
+                                   atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyClusterProduction( successful, pv, vecLength,
+                                           excitationEnergyGNP, excitationEnergyDTA,
+                                           incidentParticle, targetParticle,
+                                           atomicWeight, atomicNumber);
+        if (!successful)
+            QuasiElasticScattering( successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+            ElasticScattering( successful, pv, vecLength,
+                               incidentParticle,
+                               atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+        G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles" << G4endl;
+      }
+      FillParticleChange(pv,  vecLength);
+      delete [] pv;
+      theParticleChange.SetStatusChange(stopAndKill);
+      return & theParticleChange;
+  }
+  FirstIntInCasSigmaPlus(inElastic, availableEnergy, pv, vecLength,
+                         incidentParticle, targetParticle, atomicWeight);
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+                                  incidentParticle, targetParticle,
+                                  atomicWeight, atomicNumber);
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
+  if (!successful)
+    ElasticScattering(successful, pv, vecLength,
+                      incidentParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+           << G4endl;
+  FillParticleChange(pv, vecLength);
+  delete [] pv;
+  theParticleChange.SetStatusChange(stopAndKill);
+  return &theParticleChange;
+}
 void
 G4HESigmaPlusInelastic::FirstIntInCasSigmaPlus( G4bool &inElastic,
                                                 const G4double availableEnergy,
                                                 G4HEVector pv[],
                                                 G4int &vecLen,
                                                 G4HEVector incidentParticle,
                                                 G4HEVector targetParticle,
                                                 const G4double atomicWeight)
+G4HESigmaPlusInelastic::FirstIntInCasSigmaPlus(G4bool& inElastic,
+                                               const G4double availableEnergy,
+                                               G4HEVector pv[],
+                                               G4int& vecLen,
+                                               const G4HEVector& incidentParticle,
+                                               const G4HEVector& targetParticle,
+                                               const G4double atomicWeight)
 // Sigma+ undergoes interaction with nucleon within a nucleus.  Check if it is
 …
 // protons/neutrons by kaons or strange baryons according to the average
 // multiplicity per inelastic reaction.
+ {
+   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
+   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+   static const G4double protb = 0.7;
+   static const G4double neutb = 0.7;
+   static const G4double     c = 1.25;
+   static const G4int   numMul = 1200;
+   static const G4int   numSec = 60;
+//   G4int              neutronCode = Neutron.getCode();
+   G4int              protonCode  = Proton.getCode();
+   G4int               targetCode = targetParticle.getCode();
+//   G4double          incidentMass = incidentParticle.getMass();
+//   G4double        incidentEnergy = incidentParticle.getEnergy();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   static G4bool first = true;
+   static G4double protmul[numMul], protnorm[numSec];  // proton constants
+   static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+                              //  misc. local variables
+                              //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+   G4int i, counter, nt, np, nm, nz;
+{
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
+  static const G4double protb = 0.7;
+  static const G4double neutb = 0.7;
+  static const G4double     c = 1.25;
+  static const G4int numMul = 1200;
+  static const G4int numSec = 60;
+  G4int protonCode  = Proton.getCode();
+  G4int targetCode = targetParticle.getCode();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  static G4bool first = true;
+  static G4double protmul[numMul], protnorm[numSec];  // proton constants
+  static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+  //  misc. local variables
+  //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  G4int i, counter, nt, np, nm, nz;
    if( first )
      {                         // compute normalization constants, this will only be done once
+     {   // compute normalization constants, this will only be done once
        first = false;
        for( i=0; i<numMul; i++ )protmul[i]  = 0.0;

trunk/source/processes/hadronic/models/high_energy/src/G4HESigmaZeroInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HESigmaZeroInelastic.cc,v 1.11 2006/06/29 20:30:44 gunter Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HESigmaZeroInelastic.cc,v 1.12 2010/11/20 04:01:33 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model. Not included are the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 // First work done by J.L.Chuma and F.W.Jones, TRIUMF, June 96.
 // H. Fesefeldt, RWTH-Aachen, 23-October-1996
 …
 #include "G4Gamma.hh"
 G4HadFinalState *  G4HESigmaZeroInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
     const G4HadProjectile *aParticle = &aTrack;
 //    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
     G4HEVector incidentParticle(aParticle);
+G4HadFinalState*
+G4HESigmaZeroInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                      G4Nucleus& targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
+  G4HEVector incidentParticle(aParticle);
     G4HELambdaInelastic theLambdaInelastic;
     theLambdaInelastic.SetMaxNumberOfSecondaries(MAXPART);
     theLambdaInelastic.SetVerboseLevel(verboseLevel);
+  G4HELambdaInelastic theLambdaInelastic;
+  theLambdaInelastic.SetMaxNumberOfSecondaries(MAXPART);
+  theLambdaInelastic.SetVerboseLevel(verboseLevel);
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double pgam = G4UniformRand()*incidentTotalMomentum*0.75;
+    G4HEVector incidentLambda;
+    incidentLambda.SmulAndUpdate( incidentParticle,
+                                 (incidentTotalMomentum - pgam)/incidentTotalMomentum);
+    G4DynamicParticle * aLambda = new G4DynamicParticle();
+    aLambda->SetDefinition(G4Lambda::Lambda());
+    aLambda->SetMomentum(incidentLambda.getMomentum());
+    G4HadProjectile aLambdaTrack(*aLambda);
+    G4HadFinalState * result = theLambdaInelastic.ApplyYourself(aLambdaTrack, targetNucleus);
+    vecLength = theLambdaInelastic.GetNumberOfSecondaries();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double pgam = G4UniformRand()*incidentTotalMomentum*0.75;
+  G4HEVector incidentLambda;
+  incidentLambda.SmulAndUpdate(incidentParticle,
+                      (incidentTotalMomentum - pgam)/incidentTotalMomentum);
+  G4DynamicParticle* aLambda = new G4DynamicParticle();
+  aLambda->SetDefinition(G4Lambda::Lambda());
+  aLambda->SetMomentum(incidentLambda.getMomentum());
+  G4HadProjectile aLambdaTrack(*aLambda);
+  G4HadFinalState* result =
+          theLambdaInelastic.ApplyYourself(aLambdaTrack, targetNucleus);
+  vecLength = theLambdaInelastic.GetNumberOfSecondaries();
+    pv[vecLength] = Gamma;
+    pv[vecLength].setMomentum(incidentParticle.getMomentum());
+    pv[vecLength].SmulAndUpdate( pv[vecLength],pgam/incidentTotalMomentum);
+    G4DynamicParticle * aPhoton = new G4DynamicParticle();
+    aPhoton->SetDefinition(G4Gamma::Gamma());
+    aPhoton->SetMomentum(pv[vecLength].getMomentum());
+    result->AddSecondary(aPhoton);
+    delete [] pv;
+    return result;
+  }
+  pv[vecLength] = Gamma;
+  pv[vecLength].setMomentum(incidentParticle.getMomentum());
+  pv[vecLength].SmulAndUpdate( pv[vecLength],pgam/incidentTotalMomentum);
+  G4DynamicParticle* aPhoton = new G4DynamicParticle();
+  aPhoton->SetDefinition(G4Gamma::Gamma());
+  aPhoton->SetMomentum(pv[vecLength].getMomentum());
+  result->AddSecondary(aPhoton);
+  delete [] pv;
+  return result;
+}

trunk/source/processes/hadronic/models/high_energy/src/G4HEVector.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4HEVector.cc,v 1.20 2006/11/22 23:52:32 dennis Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4HEVector.cc,v 1.22 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 //
 …
+   }
+G4double
+G4HEVector::getTotalMomentum()
+   {
+     return std::sqrt(px*px + py*py + pz*pz);
+   }
+G4double G4HEVector::getTotalMomentum() const
+{
+  return std::sqrt(px*px + py*py + pz*pz);
+}
 void
 G4HEVector::setMomentum( G4double x, G4double y, G4double z)
+   {
      px = x;
      py = y;
      pz = z;
      return;
+   }
 void
 G4HEVector::setMomentumAndUpdate( G4double x, G4double y, G4double z )
+   {
      px = x;
      py = y;
      pz = z;
      energy        = std::sqrt(mass*mass + px*px + py*py + pz*pz);
      kineticEnergy = Amax(0.,energy-mass);
      return;
+   }
 void
 G4HEVector::setMomentum( G4double x, G4double y )
+   {
      px = x;
      py = y;
      return;
+   }
+G4HEVector::setMomentum(G4double x, G4double y, G4double z)
+{
+  px = x;
+  py = y;
+  pz = z;
+  return;
+}
+void
+G4HEVector::setMomentumAndUpdate(G4double x, G4double y, G4double z)
+{
+  px = x;
+  py = y;
+  pz = z;
+  energy = std::sqrt(mass*mass + px*px + py*py + pz*pz);
+  kineticEnergy = Amax(0.,energy-mass);
+  return;
+}
+void
+G4HEVector::setMomentum(G4double x, G4double y)
+{
+  px = x;
+  py = y;
+  return;
+}
 void
 …
+   }
+G4double
+G4HEVector::getEnergy()
+   {
+     return energy;
+   }
+G4double
+G4HEVector::getKineticEnergy()
+   {
+     return kineticEnergy;
+   }
+G4double G4HEVector::getEnergy() const
+{
+  return energy;
+}
+G4double G4HEVector::getKineticEnergy() const
+{
+  return kineticEnergy;
+}
 void
 …
+   }
+G4double
+G4HEVector::getMass()
+   {
+     return mass;
+   }
+G4double G4HEVector::getMass() const
+{
+  return mass;
+}
 void
 …
+   }
+G4double
+G4HEVector::getCharge()
+   {
+     return charge;
+   }
+G4double G4HEVector::getCharge() const
+{
+  return charge;
+}
 void
 …
+   }
+G4int
+G4HEVector::getCode()
+   {
+     return code;
+   }
+G4String
+G4HEVector::getName()
+   {
+     return particleName;
+   }
+G4String
+G4HEVector::getType()
+   {
+     return particleType;
+   }
+G4int G4HEVector::getCode() const
+{
+  return code;
+}
+G4String G4HEVector::getName() const
+{
+  return particleName;
+}
+G4String G4HEVector::getType() const
+{
+  return particleType;
+}
+G4int
+G4HEVector::getBaryonNumber()
+   {
+     return baryon;
+   }
+G4int
+G4HEVector::getStrangenessNumber()
+   {
+     return strangeness;
+   }
+G4int G4HEVector::getBaryonNumber() const
+{
+  return baryon;
+}
+G4int G4HEVector::getStrangenessNumber() const
+{
+  return strangeness;
+}
 G4int
 G4HEVector::getQuarkContent(G4int flavor)
 …
+   }
+G4double
+G4HEVector::CosAng( const G4HEVector & p )
+   {
+     G4double a = std::sqrt( (px*px + py*py + pz*pz)*(p.px*p.px + p.py*p.py + p.pz*p.pz) );
+     if( a != 0.0 )
+       {
+         a = (px*p.px + py*p.py + pz*p.pz)/a;
+         if( std::fabs(a) > 1.0 )
+         {
+           if(a<0.0) a=-1.0;
+           else a=1.0;
+         }
+       }
+     return a;
+   }
+G4double G4HEVector::CosAng(const G4HEVector& p) const
+{
+  G4double a = std::sqrt( (px*px + py*py + pz*pz)*(p.px*p.px + p.py*p.py + p.pz*p.pz) );
+  if (a != 0.0) {
+    a = (px*p.px + py*p.py + pz*p.pz)/a;
+    if (std::fabs(a) > 1.0) {
+      if (a < 0.0) a = -1.0;
+      else a = 1.0;
+    }
+  }
+  return a;
+}
 G4double
 …
+   }
+G4double
+G4HEVector::Length()
+   {
+     return  std::sqrt(px*px + py*py + pz*pz);
+   }
+G4double G4HEVector::Length() const
+{
+  return std::sqrt(px*px + py*py + pz*pz);
+}
 void
 …
+}
+void
+G4HEVector::Print( G4int L)
+   {
+     G4cout << "HEV: "
+          << L << " " << px << " " <<  py << " " <<  pz << " "
+          << energy << " " << mass << " " << charge << " "
+          << timeOfFlight << " " << side << " " << flag << " "
+          << code << " " << baryon << " " << particleName << G4endl;
+     /*
+     printf("HEV: %3d %6f.2 %6f.2 %6f.2 %6f.2 %6f.2 %3f.0 %4f.1 %3d
+             %3d %6d %6d %s \n", L, px, py, pz, energy, mass, charge,
+             timeOfFlight, side, flag, code, baryon, particleName);
+             */
+     return;
+   }
+void G4HEVector::Print(G4int L) const
+{
+  G4cout << "HEV: "
+         << L << " " << px << " " <<  py << " " <<  pz << " "
+         << energy << " " << mass << " " << charge << " "
+         << timeOfFlight << " " << side << " " << flag << " "
+         << code << " " << baryon << " " << particleName << G4endl;
+  return;
+}

trunk/source/processes/hadronic/models/high_energy/src/G4HEXiMinusInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HEXiMinusInelastic.cc,v 1.15 2008/03/17 20:49:17 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HEXiMinusInelastic.cc,v 1.17 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model. Not included are the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 // First work done by J.L.Chuma and F.W.Jones, TRIUMF, June 96.
 // H. Fesefeldt, RWTH-Aachen, 23-October-1996
 …
 #include "G4HEXiMinusInelastic.hh"
 G4HadFinalState *  G4HEXiMinusInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
     const G4HadProjectile *aParticle = &aTrack;
 //    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
     const G4double A = targetNucleus.GetN();
     const G4double Z = targetNucleus.GetZ();
     G4HEVector incidentParticle(aParticle);
+G4HadFinalState*
+G4HEXiMinusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                    G4Nucleus& targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
+  const G4double A = targetNucleus.GetN();
+  const G4double Z = targetNucleus.GetZ();
+  G4HEVector incidentParticle(aParticle);
+    G4double atomicNumber = Z;
+    G4double atomicWeight = A;
+    G4int    incidentCode          = incidentParticle.getCode();
+    G4double incidentMass          = incidentParticle.getMass();
+    G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+    if(incidentKineticEnergy < 1.)
+      {
+        G4cout << "GHEXiMinusInelastic: incident energy < 1 GeV" << G4endl;
+      }
+    if(verboseLevel > 1)
+      {
+        G4cout << "G4HEXiMinusInelastic::ApplyYourself" << G4endl;
+        G4cout << "incident particle " << incidentParticle.getName()
+             << "mass "              << incidentMass
+             << "kinetic energy "    << incidentKineticEnergy
+             << G4endl;
+        G4cout << "target material with (A,Z) = ("
+             << atomicWeight << "," << atomicNumber << ")" << G4endl;
+      }
+  G4double atomicNumber = Z;
+  G4double atomicWeight = A;
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+  if (incidentKineticEnergy < 1.)
+    G4cout << "GHEXiMinusInelastic: incident energy < 1 GeV" << G4endl;
+  if (verboseLevel > 1) {
+    G4cout << "G4HEXiMinusInelastic::ApplyYourself" << G4endl;
+    G4cout << "incident particle " << incidentParticle.getName()
+           << "mass "              << incidentMass
+           << "kinetic energy "    << incidentKineticEnergy
+           << G4endl;
+    G4cout << "target material with (A,Z) = ("
+           << atomicWeight << "," << atomicNumber << ")" << G4endl;
+  }
     G4double inelasticity  = NuclearInelasticity(incidentKineticEnergy,
                                                  atomicWeight, atomicNumber);
     if(verboseLevel > 1)
         G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+  G4double inelasticity = NuclearInelasticity(incidentKineticEnergy,
+                                              atomicWeight, atomicNumber);
+  if (verboseLevel > 1)
+    G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
     incidentKineticEnergy -= inelasticity;
+  incidentKineticEnergy -= inelasticity;
     G4double excitationEnergyGNP = 0.;
     G4double excitationEnergyDTA = 0.;
     G4double excitation    = NuclearExcitation(incidentKineticEnergy,
                                                atomicWeight, atomicNumber,
                                                excitationEnergyGNP,
                                                excitationEnergyDTA);
     if(verboseLevel > 1)
       G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+  G4double excitationEnergyGNP = 0.;
+  G4double excitationEnergyDTA = 0.;
+  G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                          atomicWeight, atomicNumber,
+                                          excitationEnergyGNP,
+                                          excitationEnergyDTA);
+  if (verboseLevel > 1)
+    G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
            << excitationEnergyDTA << G4endl;
+    incidentKineticEnergy -= excitation;
+    incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+    G4HEVector targetParticle;
+    if(G4UniformRand() < atomicNumber/atomicWeight)
+      {
+        targetParticle.setDefinition("Proton");
+      }
+    else
+      {
+        targetParticle.setDefinition("Neutron");
+      }
+    G4double targetMass         = targetParticle.getMass();
+    G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+    G4double availableEnergy    = centerOfMassEnergy - targetMass - incidentMass;
+                                                                // this was the meaning of inElastic in the
+                                                                // original Gheisha stand-alone version.
+//    G4bool   inElastic          = InElasticCrossSectionInFirstInt
+//                                    (availableEnergy, incidentCode, incidentTotalMomentum);
+                                                                // by unknown reasons, it has been replaced
+                                                                // to the following code in Geant???
+    G4bool inElastic = true;
+//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+    vecLength = 0;
+  incidentKineticEnergy -= excitation;
+  incidentTotalEnergy = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                    *(incidentTotalEnergy+incidentMass));
+  G4HEVector targetParticle;
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
+    targetParticle.setDefinition("Proton");
+  } else {
+    targetParticle.setDefinition("Neutron");
+  }
+  G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                        + targetMass*targetMass
+                                        + 2.0*targetMass*incidentTotalEnergy);
+  G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
+  G4bool inElastic = true;
+  vecLength = 0;
     if(verboseLevel > 1)
       G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
            << incidentCode << G4endl;
     G4bool successful = false;
+  G4bool successful = false;
+    if(inElastic || (!inElastic && atomicWeight < 1.5))
+      {
+        FirstIntInCasXiMinus(inElastic, availableEnergy, pv, vecLength,
+                             incidentParticle, targetParticle, atomicWeight);
+        if(verboseLevel > 1)
+           G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+        if ((vecLength > 0) && (availableEnergy > 1.))
+                   StrangeParticlePairProduction( availableEnergy, centerOfMassEnergy,
+                                                  pv, vecLength,
+                                                  incidentParticle, targetParticle);
+            HighEnergyCascading( successful, pv, vecLength,
+                                 excitationEnergyGNP, excitationEnergyDTA,
+                                 incidentParticle, targetParticle,
+                                 atomicWeight, atomicNumber);
+        if (!successful)
+            HighEnergyClusterProduction( successful, pv, vecLength,
+                                         excitationEnergyGNP, excitationEnergyDTA,
+                                         incidentParticle, targetParticle,
+                                         atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyCascading( successful, pv, vecLength,
+                                   excitationEnergyGNP, excitationEnergyDTA,
+                                   incidentParticle, targetParticle,
+                                   atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyClusterProduction( successful, pv, vecLength,
+                                           excitationEnergyGNP, excitationEnergyDTA,
+                                           incidentParticle, targetParticle,
+                                           atomicWeight, atomicNumber);
+        if (!successful)
+            QuasiElasticScattering( successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+            ElasticScattering( successful, pv, vecLength,
+                               incidentParticle,
+                               atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+        G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles" << G4endl;
+      }
+      FillParticleChange(pv,  vecLength);
+      delete [] pv;
+      theParticleChange.SetStatusChange(stopAndKill);
+      return & theParticleChange;
+  }
+  FirstIntInCasXiMinus(inElastic, availableEnergy, pv, vecLength,
+                       incidentParticle, targetParticle, atomicWeight);
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+                                  incidentParticle, targetParticle,
+                                  atomicWeight, atomicNumber);
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
+  if (!successful)
+    ElasticScattering(successful, pv, vecLength,
+                      incidentParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+           << G4endl;
+  FillParticleChange(pv, vecLength);
+  delete [] pv;
+  theParticleChange.SetStatusChange(stopAndKill);
+  return &theParticleChange;
+}
 void
 G4HEXiMinusInelastic::FirstIntInCasXiMinus( G4bool &inElastic,
                                             const G4double availableEnergy,
                                             G4HEVector pv[],
                                             G4int &vecLen,
                                             G4HEVector incidentParticle,
                                             G4HEVector targetParticle,
                                             const G4double atomicWeight)
+G4HEXiMinusInelastic::FirstIntInCasXiMinus(G4bool& inElastic,
+                                           const G4double availableEnergy,
+                                           G4HEVector pv[],
+                                           G4int& vecLen,
+                                           const G4HEVector& incidentParticle,
+                                           const G4HEVector& targetParticle,
+                                           const G4double atomicWeight)
 // Xi0 undergoes interaction with nucleon within a nucleus.  Check if it is
 …
 // protons/neutrons by kaons or strange baryons according to the average
 // multiplicity per inelastic reaction.
+ {
+   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
+   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+   static const G4double protb = 0.7;
+   static const G4double neutb = 0.7;
+   static const G4double     c = 1.25;
+   static const G4int   numMul = 1200;
+   static const G4int   numSec = 60;
+   G4int              neutronCode = Neutron.getCode();
+   G4int              protonCode  = Proton.getCode();
+   G4int               targetCode = targetParticle.getCode();
+//   G4double          incidentMass = incidentParticle.getMass();
+//   G4double        incidentEnergy = incidentParticle.getEnergy();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   static G4bool first = true;
+   static G4double protmul[numMul], protnorm[numSec];  // proton constants
+   static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+                              //  misc. local variables
+                              //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+   G4int i, counter, nt, np, nm, nz;
+{
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
+  static const G4double protb = 0.7;
+  static const G4double neutb = 0.7;
+  static const G4double     c = 1.25;
+  static const G4int numMul = 1200;
+  static const G4int numSec = 60;
+  G4int neutronCode = Neutron.getCode();
+  G4int protonCode = Proton.getCode();
+  G4int targetCode = targetParticle.getCode();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  static G4bool first = true;
+  static G4double protmul[numMul], protnorm[numSec];  // proton constants
+  static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+  //  misc. local variables
+  //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  G4int i, counter, nt, np, nm, nz;
    if( first )
      {                         // compute normalization constants, this will only be done once
+     {   // compute normalization constants, this will only be done once
        first = false;
        for( i=0; i<numMul; i++ )protmul[i]  = 0.0;

trunk/source/processes/hadronic/models/high_energy/src/G4HEXiZeroInelastic.cc

-              r1340
+              r1347
 // ********************************************************************
 //
+//
+// $Id: G4HEXiZeroInelastic.cc,v 1.15 2008/03/17 20:49:17 dennis Exp $
+// GEANT4 tag $Name: geant4-09-03-ref-09 $
+//
+// $Id: G4HEXiZeroInelastic.cc,v 1.17 2010/11/29 05:44:44 dennis Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 #include "G4ios.hh"
-//
 // G4 Process: Gheisha High Energy Collision model.
 // This includes the high energy cascading model, the two-body-resonance model
 // and the low energy two-body model. Not included are the low energy stuff like
 // nuclear reactions, nuclear fission without any cascading and all processes for
 // particles at rest.
+// and the low energy two-body model. Not included are the low energy stuff
+// like nuclear reactions, nuclear fission without any cascading and all
+// processes for particles at rest.
 // First work done by J.L.Chuma and F.W.Jones, TRIUMF, June 96.
 // H. Fesefeldt, RWTH-Aachen, 23-October-1996
 …
 #include "G4HEXiZeroInelastic.hh"
 G4HadFinalState *  G4HEXiZeroInelastic::
+ApplyYourself( const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
+  {
+    G4HEVector * pv = new G4HEVector[MAXPART];
     const G4HadProjectile *aParticle = &aTrack;
 //    G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
     const G4double A = targetNucleus.GetN();
     const G4double Z = targetNucleus.GetZ();
     G4HEVector incidentParticle(aParticle);
+G4HadFinalState*
+G4HEXiZeroInelastic::ApplyYourself(const G4HadProjectile& aTrack,
+                                   G4Nucleus& targetNucleus)
+{
+  G4HEVector* pv = new G4HEVector[MAXPART];
+  const G4HadProjectile* aParticle = &aTrack;
+  const G4double A = targetNucleus.GetN();
+  const G4double Z = targetNucleus.GetZ();
+  G4HEVector incidentParticle(aParticle);
+    G4double atomicNumber = Z;
+    G4double atomicWeight = A;
+    G4int    incidentCode          = incidentParticle.getCode();
+    G4double incidentMass          = incidentParticle.getMass();
+    G4double incidentTotalEnergy   = incidentParticle.getEnergy();
+    G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+    G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+    if(incidentKineticEnergy < 1.)
+      {
+        G4cout << "GHEXiZeroInelastic: incident energy < 1 GeV" << G4endl;
+      }
+    if(verboseLevel > 1)
+      {
+        G4cout << "G4HEXiZeroInelastic::ApplyYourself" << G4endl;
+        G4cout << "incident particle " << incidentParticle.getName()
+             << "mass "              << incidentMass
+             << "kinetic energy "    << incidentKineticEnergy
+             << G4endl;
+        G4cout << "target material with (A,Z) = ("
+             << atomicWeight << "," << atomicNumber << ")" << G4endl;
+      }
+    G4double inelasticity  = NuclearInelasticity(incidentKineticEnergy,
+                                                 atomicWeight, atomicNumber);
+    if(verboseLevel > 1)
+        G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
+  G4double atomicNumber = Z;
+  G4double atomicWeight = A;
+  G4int incidentCode = incidentParticle.getCode();
+  G4double incidentMass = incidentParticle.getMass();
+  G4double incidentTotalEnergy = incidentParticle.getEnergy();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  G4double incidentKineticEnergy = incidentTotalEnergy - incidentMass;
+  if (incidentKineticEnergy < 1.)
+    G4cout << "GHEXiZeroInelastic: incident energy < 1 GeV" << G4endl;
+  if (verboseLevel > 1) {
+    G4cout << "G4HEXiZeroInelastic::ApplyYourself" << G4endl;
+    G4cout << "incident particle " << incidentParticle.getName()
+           << "mass "              << incidentMass
+           << "kinetic energy "    << incidentKineticEnergy
+           << G4endl;
+    G4cout << "target material with (A,Z) = ("
+           << atomicWeight << "," << atomicNumber << ")" << G4endl;
+  }
+  G4double inelasticity = NuclearInelasticity(incidentKineticEnergy,
+                                              atomicWeight, atomicNumber);
+  if (verboseLevel > 1)
+    G4cout << "nuclear inelasticity = " << inelasticity << G4endl;
     incidentKineticEnergy -= inelasticity;
+  incidentKineticEnergy -= inelasticity;
     G4double excitationEnergyGNP = 0.;
     G4double excitationEnergyDTA = 0.;
     G4double excitation    = NuclearExcitation(incidentKineticEnergy,
                                                atomicWeight, atomicNumber,
                                                excitationEnergyGNP,
                                                excitationEnergyDTA);
     if(verboseLevel > 1)
       G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
+  G4double excitationEnergyGNP = 0.;
+  G4double excitationEnergyDTA = 0.;
+  G4double excitation = NuclearExcitation(incidentKineticEnergy,
+                                          atomicWeight, atomicNumber,
+                                          excitationEnergyGNP,
+                                          excitationEnergyDTA);
+  if (verboseLevel > 1)
+    G4cout << "nuclear excitation = " << excitation << excitationEnergyGNP
            << excitationEnergyDTA << G4endl;
+    incidentKineticEnergy -= excitation;
+    incidentTotalEnergy    = incidentKineticEnergy + incidentMass;
+    incidentTotalMomentum  = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                  *(incidentTotalEnergy+incidentMass));
+    G4HEVector targetParticle;
+    if(G4UniformRand() < atomicNumber/atomicWeight)
+      {
+        targetParticle.setDefinition("Proton");
+      }
+    else
+      {
+        targetParticle.setDefinition("Neutron");
+      }
+    G4double targetMass         = targetParticle.getMass();
+    G4double centerOfMassEnergy = std::sqrt( incidentMass*incidentMass + targetMass*targetMass
+                                       + 2.0*targetMass*incidentTotalEnergy);
+    G4double availableEnergy    = centerOfMassEnergy - targetMass - incidentMass;
+                                                                // this was the meaning of inElastic in the
+                                                                // original Gheisha stand-alone version.
+//    G4bool   inElastic          = InElasticCrossSectionInFirstInt
+//                                    (availableEnergy, incidentCode, incidentTotalMomentum);
+                                                                // by unknown reasons, it has been replaced
+                                                                // to the following code in Geant???
+    G4bool inElastic = true;
+//    if (G4UniformRand() < elasticCrossSection/totalCrossSection) inElastic = false;
+    vecLength = 0;
+  incidentKineticEnergy -= excitation;
+  incidentTotalEnergy = incidentKineticEnergy + incidentMass;
+  incidentTotalMomentum = std::sqrt( (incidentTotalEnergy-incidentMass)
+                                    *(incidentTotalEnergy+incidentMass));
+  G4HEVector targetParticle;
+  if (G4UniformRand() < atomicNumber/atomicWeight) {
+    targetParticle.setDefinition("Proton");
+  } else {
+    targetParticle.setDefinition("Neutron");
+  }
+  G4double targetMass = targetParticle.getMass();
+  G4double centerOfMassEnergy = std::sqrt(incidentMass*incidentMass
+                                         + targetMass*targetMass
+                                         + 2.0*targetMass*incidentTotalEnergy);
+  G4double availableEnergy = centerOfMassEnergy - targetMass - incidentMass;
+  G4bool inElastic = true;
+  vecLength = 0;
     if(verboseLevel > 1)
       G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself: CallFirstIntInCascade for particle "
            << incidentCode << G4endl;
     G4bool successful = false;
+  G4bool successful = false;
+    if(inElastic || (!inElastic && atomicWeight < 1.5))
+      {
+        FirstIntInCasXiZero(inElastic, availableEnergy, pv, vecLength,
+                            incidentParticle, targetParticle, atomicWeight);
+        if(verboseLevel > 1)
+           G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+        if ((vecLength > 0) && (availableEnergy > 1.))
+                   StrangeParticlePairProduction( availableEnergy, centerOfMassEnergy,
+                                                  pv, vecLength,
+                                                  incidentParticle, targetParticle);
+            HighEnergyCascading( successful, pv, vecLength,
+                                 excitationEnergyGNP, excitationEnergyDTA,
+                                 incidentParticle, targetParticle,
+                                 atomicWeight, atomicNumber);
+        if (!successful)
+            HighEnergyClusterProduction( successful, pv, vecLength,
+                                         excitationEnergyGNP, excitationEnergyDTA,
+                                         incidentParticle, targetParticle,
+                                         atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyCascading( successful, pv, vecLength,
+                                   excitationEnergyGNP, excitationEnergyDTA,
+                                   incidentParticle, targetParticle,
+                                   atomicWeight, atomicNumber);
+        if (!successful)
+            MediumEnergyClusterProduction( successful, pv, vecLength,
+                                           excitationEnergyGNP, excitationEnergyDTA,
+                                           incidentParticle, targetParticle,
+                                           atomicWeight, atomicNumber);
+        if (!successful)
+            QuasiElasticScattering( successful, pv, vecLength,
+                                    excitationEnergyGNP, excitationEnergyDTA,
+                                    incidentParticle, targetParticle,
+                                    atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+            ElasticScattering( successful, pv, vecLength,
+                               incidentParticle,
+                               atomicWeight, atomicNumber);
+      }
+    if (!successful)
+      {
+        G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles" << G4endl;
+      }
+      FillParticleChange(pv,  vecLength);
+      delete [] pv;
+      theParticleChange.SetStatusChange(stopAndKill);
+      return & theParticleChange;
+  }
+  FirstIntInCasXiZero(inElastic, availableEnergy, pv, vecLength,
+                      incidentParticle, targetParticle, atomicWeight);
+  if (verboseLevel > 1)
+    G4cout << "ApplyYourself::StrangeParticlePairProduction" << G4endl;
+  if ((vecLength > 0) && (availableEnergy > 1.))
+    StrangeParticlePairProduction(availableEnergy, centerOfMassEnergy,
+                                  pv, vecLength,
+                                  incidentParticle, targetParticle);
+  HighEnergyCascading(successful, pv, vecLength,
+                      excitationEnergyGNP, excitationEnergyDTA,
+                      incidentParticle, targetParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    HighEnergyClusterProduction(successful, pv, vecLength,
+                                excitationEnergyGNP, excitationEnergyDTA,
+                                incidentParticle, targetParticle,
+                                atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyCascading(successful, pv, vecLength,
+                          excitationEnergyGNP, excitationEnergyDTA,
+                          incidentParticle, targetParticle,
+                          atomicWeight, atomicNumber);
+  if (!successful)
+    MediumEnergyClusterProduction(successful, pv, vecLength,
+                                  excitationEnergyGNP, excitationEnergyDTA,
+                                  incidentParticle, targetParticle,
+                                  atomicWeight, atomicNumber);
+  if (!successful)
+    QuasiElasticScattering(successful, pv, vecLength,
+                           excitationEnergyGNP, excitationEnergyDTA,
+                           incidentParticle, targetParticle,
+                           atomicWeight, atomicNumber);
+  if (!successful)
+    ElasticScattering(successful, pv, vecLength,
+                      incidentParticle,
+                      atomicWeight, atomicNumber);
+  if (!successful)
+    G4cout << "GHEInelasticInteraction::ApplyYourself fails to produce final state particles"
+           << G4endl;
+  FillParticleChange(pv, vecLength);
+  delete [] pv;
+  theParticleChange.SetStatusChange(stopAndKill);
+  return &theParticleChange;
+}
 void
 G4HEXiZeroInelastic::FirstIntInCasXiZero( G4bool &inElastic,
                                           const G4double availableEnergy,
                                           G4HEVector pv[],
                                           G4int &vecLen,
                                           G4HEVector incidentParticle,
                                           G4HEVector targetParticle,
                                           const G4double atomicWeight)
+G4HEXiZeroInelastic::FirstIntInCasXiZero(G4bool& inElastic,
+                                         const G4double availableEnergy,
+                                         G4HEVector pv[],
+                                         G4int& vecLen,
+                                         const G4HEVector& incidentParticle,
+                                         const G4HEVector& targetParticle,
+                                         const G4double atomicWeight)
 // Xi0 undergoes interaction with nucleon within a nucleus.  Check if it is
 …
 // protons/neutrons by kaons or strange baryons according to the average
 // multiplicity per inelastic reaction.
+ {
+   static const G4double expxu =  std::log(MAXFLOAT); // upper bound for arg. of exp
+   static const G4double expxl = -expxu;         // lower bound for arg. of exp
+   static const G4double protb = 0.7;
+   static const G4double neutb = 0.7;
+   static const G4double     c = 1.25;
+   static const G4int   numMul = 1200;
+   static const G4int   numSec = 60;
+//   G4int              neutronCode = Neutron.getCode();
+   G4int              protonCode  = Proton.getCode();
+   G4int               targetCode = targetParticle.getCode();
+//   G4double          incidentMass = incidentParticle.getMass();
+//   G4double        incidentEnergy = incidentParticle.getEnergy();
+   G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+   static G4bool first = true;
+   static G4double protmul[numMul], protnorm[numSec];  // proton constants
+   static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+                              //  misc. local variables
+                              //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+   G4int i, counter, nt, np, nm, nz;
+{
+  static const G4double expxu = std::log(MAXFLOAT); // upper bound for arg. of exp
+  static const G4double expxl = -expxu;             // lower bound for arg. of exp
+  static const G4double protb = 0.7;
+  static const G4double neutb = 0.7;
+  static const G4double     c = 1.25;
+  static const G4int numMul = 1200;
+  static const G4int numSec = 60;
+  G4int protonCode = Proton.getCode();
+  G4int targetCode = targetParticle.getCode();
+  G4double incidentTotalMomentum = incidentParticle.getTotalMomentum();
+  static G4bool first = true;
+  static G4double protmul[numMul], protnorm[numSec];  // proton constants
+  static G4double neutmul[numMul], neutnorm[numSec];  // neutron constants
+  //  misc. local variables
+  //  np = number of pi+,  nm = number of pi-,  nz = number of pi0
+  G4int i, counter, nt, np, nm, nz;
    if( first )
      {                         // compute normalization constants, this will only be done once
+     {     // compute normalization constants, this will only be done once
        first = false;
        for( i=0; i<numMul; i++ )protmul[i]  = 0.0;

trunk/source/processes/hadronic/models/incl/GNUmakefile

-              r1340
+              r1347
 # $Id: GNUmakefile,v 1.11 2010/10/26 02:47:58 kaitanie Exp $
+# $Id: GNUmakefile,v 1.13 2010/11/13 00:08:36 kaitanie Exp $
 # -----------------------------------------------------------
 # GNUmakefile for hadronic library.  Gabriele Cosmo, 18/9/96.
 …
             -I$(G4BASE)/processes/hadronic/models/management/include \
             -I$(G4BASE)/processes/hadronic/models/util/include \
+            -I$(G4BASE)/processes/hadronic/models/de_excitation/util/include \
             -I$(G4BASE)/processes/hadronic/models/de_excitation/evaporation/include \
             -I$(G4BASE)/processes/hadronic/models/de_excitation/fermi_breakup/include \
+            -I$(G4BASE)/processes/hadronic/models/de_excitation/photon_evaporation/include \
+            -I$(G4BASE)/processes/hadronic/models/de_excitation/multifragmentation/include \
+            -I$(G4BASE)/processes/hadronic/models/de_excitation/handler/include \
+            -I$(G4BASE)/processes/hadronic/models/de_excitation/management/include \
+            -I$(G4BASE)/processes/hadronic/models/pre_equilibrium/exciton_model/include/ \
             -I$(G4BASE)/particles/management/include \
             -I$(G4BASE)/particles/leptons/include \

trunk/source/processes/hadronic/models/incl/History

-              r1340
+              r1347
      Geant4 - an Object-Oriented Toolkit for Physics Simulation
      ==========================================================
 $Id: History,v 1.32 2010/10/29 06:54:23 gunter Exp $
+$Id: History,v 1.37 2010/11/17 20:19:09 kaitanie Exp $
 ---------------------------------------------------------------------
 …
    ---------------------------------------------------------------
+November 2010 - Pekka Kaitaniemi (hadr-incl-V09-03-10)
+---------------------------------------------------------
+- Fixed several issues reported by Coverity:
+  o Fix: Fragment vector and Fermi break-up related emory leaks in
+  INCL/ABLA interfaces
+  o Initialize INCL internal variables properly
+  o Check array boundaries in datafile reader
+November 2010 - Gabriele Cosmo (hadr-incl-V09-03-09)
+-------------------------------------------------------
+- More minor fixes from Coverity reports...
+November 2010 - Pekka Kaitaniemi (hadr-incl-V09-03-08)
+---------------------------------------------------------
+- Fixed several minor variable initialization issues reported by Coverity
+November 2010 - Pekka Kaitaniemi (hadr-incl-V09-03-07)
+---------------------------------------------------------
+- Fixed some minor variable initialization issues reported by Coverity
+- Updated interfaces:
+  o INCL + built-in ABLA de-excitation: G4InclAblaCascadeInterface and
+  G4InclAblaLightIonInterface
+  o INCL + PreCompound model: G4InclCascadeInterface and
+  G4InclLightIonInterface
+November 2010 - Pekka Kaitaniemi (hadr-incl-V09-03-06)
+---------------------------------------------------------
+- Fixed insufficient array index safeguard in ABLA
+- Silenced debugging output printed by G4InclAblaCascadeInterface
 October 2010 - Gunter Folger (hadr-incl-V09-03-05)
+-----------------------------------------------------
 - Fixed several more compilation warnings for conversion of double to int
    in  G4Incl.cc, G4InclAblaCascadeInterface.cc, and G4InclAblaLightIonInterface.cc.

trunk/source/processes/hadronic/models/incl/include/G4Abla.hh

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4Abla.hh,v 1.13 2010/10/26 02:47:59 kaitanie Exp $
+// $Id: G4Abla.hh,v 1.14 2010/11/17 20:19:09 kaitanie Exp $
 // Translation of INCL4.2/ABLA V3
 // Pekka Kaitaniemi, HIP (translation)
 …
 public:
   /**
-   * Basic constructor.
-   */
-  G4Abla();
-  /**
    * This constructor is used by standalone test driver and the Geant4 interface.
+   *
 …
    */
   G4Abla(G4Hazard *aHazard, G4Volant *aVolant, G4VarNtp *aVarntp);
-  /**
-   * Constructor that is to be used only for testing purposes.
-   * @param aHazard random seeds
-   * @param aVolant data structure for ABLA output
-   */
-  G4Abla(G4Hazard *hazard, G4Volant *volant);
   /**
 …
               G4double *probp_par, G4double *probn_par, G4double *proba_par,
               G4double *probf_par, G4double *ptotl_par, G4double *sn_par, G4double *sbp_par, G4double *sba_par, G4double *ecn_par,
               G4double *ecp_par,G4double *eca_par, G4double *bp_par, G4double *ba_par, G4int inttype, G4int inum, G4int itest);
+              G4double *ecp_par,G4double *eca_par, G4double *bp_par, G4double *ba_par, G4int, G4int inum, G4int itest);
   /**

trunk/source/processes/hadronic/models/incl/include/G4AblaDataDefs.hh

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4AblaDataDefs.hh,v 1.11 2010/10/26 02:47:59 kaitanie Exp $
+// $Id: G4AblaDataDefs.hh,v 1.13 2010/11/13 00:08:36 kaitanie Exp $
 // Translation of INCL4.2/ABLA V3
 // Pekka Kaitaniemi, HIP (translation)
 …
+   *
    */
+  G4Ald() {};
+  G4Ald()
+    :av(0.0), as(0.0), ak(0.0), optafan(0.0)
+  {};
   ~G4Ald() {};
 …
 public:
+  G4Fiss() {};
+  G4Fiss()
+    :akap(0.0), bet(0.0), homega(0.0), koeff(0.0), ifis(0.0),
+     optshp(0), optxfis(0), optles(0), optcol(0)
+  {};
   ~G4Fiss() {};
 …
 public:
+  G4Opt() {};
+  G4Opt()
+    :optemd(0), optcha(0), eefac(0.0)
+  {};
   ~G4Opt() {};
 …
 class G4Eenuc {
 public:
+  G4Eenuc() {};
+  G4Eenuc() {
+    for(G4int i = 0; i < EENUCSIZE; ++i) {
+      she[i] = 0.0;
+    }
+    for(G4int i = 0; i < XHESIZE; ++i) {
+      for(G4int j = 0; j < EENUCSIZE; ++j) {
+        xhe[i][j] = 0.0;
+      }
+    }
+  };
   ~G4Eenuc() {};

trunk/source/processes/hadronic/models/incl/include/G4Incl.hh

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4Incl.hh,v 1.18 2010/10/26 02:47:59 kaitanie Exp $
+// $Id: G4Incl.hh,v 1.19 2010/11/13 00:08:36 kaitanie Exp $
 // Translation of INCL4.2/ABLA V3
 // Pekka Kaitaniemi, HIP (translation)
 …
    private:
+  /*
+   * (Re)Initialize INCL internal variables
+   */
+  void clearState();
   /**
    * Random seeds for INCL4 internal random number generators.

trunk/source/processes/hadronic/models/incl/include/G4InclAblaCascadeInterface.hh

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4InclAblaCascadeInterface.hh,v 1.9 2010/10/26 02:47:59 kaitanie Exp $
+// $Id: G4InclAblaCascadeInterface.hh,v 1.11 2010/11/13 00:08:36 kaitanie Exp $
 // Translation of INCL4.2/ABLA V3
 // Pekka Kaitaniemi, HIP (translation)
 …
+ *
  * @see G4InclAblaLightIonInterface
+ * @see G4InclCascadeInterface
  */

trunk/source/processes/hadronic/models/incl/include/G4InclAblaDataFile.hh

-              r1337
+              r1347
 // ********************************************************************
 //
 // $Id: G4InclAblaDataFile.hh,v 1.3 2010/06/14 16:10:01 gcosmo Exp $
+// $Id: G4InclAblaDataFile.hh,v 1.4 2010/11/17 20:19:09 kaitanie Exp $
 // Translation of INCL4.2/ABLA V3
 // Pekka Kaitaniemi, HIP (translation)
 …
 private:
   G4int verboseLevel;
-  G4String *dataPath;
 };

trunk/source/processes/hadronic/models/incl/include/G4InclCascadeInterface.hh

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4InclCascadeInterface.hh,v 1.6 2010/10/26 02:47:59 kaitanie Exp $
+// $Id: G4InclCascadeInterface.hh,v 1.8 2010/11/13 00:08:36 kaitanie Exp $
 // Translation of INCL4.2/ABLA V3
 // Pekka Kaitaniemi, HIP (translation)
 …
 #include "G4AblaDataDefs.hh"
 #include "G4Incl.hh"
+#include "G4InclInput.hh"
+// Geant4 de-excitation
+#include "G4ExcitationHandler.hh"
+#include "G4PreCompoundModel.hh"
 #include <fstream>
 …
 /**
+ * <h1>INCL intra-nuclear cascade with Geant4 PreCompound for de-excitation</h1>
+ *
  * Interface for INCL. This interface handles basic hadron
  * bullet particles (protons, neutrons, pions).
+ * @see G4InclAblaLightIonInterface
+ *
+ * Example usage in case of protons:
+ * @code
+ * G4InclCascadeInterface* inclModel = new G4InclCascadeInterface;
+ * inclModel -> SetMinEnergy(0.0 * MeV); // Set the energy limits
+ * inclModel -> SetMaxEnergy(3.0 * GeV);
+ *
+ * G4ProtonInelasticProcess* protonInelasticProcess = new G4ProtonInelasticProcess();
+ * G4ProtonInelasticCrossSection* protonInelasticCrossSection =  new G4ProtonInelasticCrossSection();
+ *
+ * protonInelasticProcess -> RegisterMe(inclModel);
+ * protonInelasticProcess -> AddDataSet(protonInelasticCrossSection);
+ *
+ * particle = G4Proton::Proton();
+ * processManager = particle -> GetProcessManager();
+ * processManager -> AddDiscreteProcess(protonInelasticProcess);
+ * @endcode
+ * The same setup procedure is needed for neutron and pion inelastic processes
+ * as well.
+ *
+ * @see G4InclLightIonInterface
  */
 …
    * Basic constructor.
    */
   G4InclCascadeInterface();
+  G4InclCascadeInterface(const G4String& name = "INCL Cascade with Geant4 PreCompound");
 …
   /**
    * Main method to apply the INCL/ABLA physics model.
+   * Main method to apply the INCL physics model.
    * @param aTrack the projectile particle
    * @param theNucleus target nucleus
    * @return the output of the INCL/ABLA physics model
+   * @return the output of the INCL physics model
    */
   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,  G4Nucleus& theNucleus);
 …
   G4Hazard *hazard; // The random seeds used by INCL.
   G4VarNtp *varntp;
   G4InclInput *inclInput;
+  G4InclInput *calincl;
   G4Ws *ws;
   G4Mat *mat;
   G4Incl *incl;
   G4HadFinalState theResult;
   ofstream diagdata;
 …
   G4double previousTargetA;
   G4double previousTargetZ;
+  G4ExcitationHandler *theExcitationHandler;
+  G4PreCompoundModel *thePrecoModel;
 };
 #endif // G4INCLCASCADEINTERFACE_H
+#endif // G4INCLABLACASCADEINTERFACE_H

trunk/source/processes/hadronic/models/incl/include/G4InclDataDefs.hh

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4InclDataDefs.hh,v 1.10 2010/10/28 15:35:50 gcosmo Exp $
+// $Id: G4InclDataDefs.hh,v 1.12 2010/11/17 20:19:09 kaitanie Exp $
 // Translation of INCL4.2/ABLA V3
 // Pekka Kaitaniemi, HIP (translation)
 …
 class G4QuadvectProjo {
 public:
+  G4QuadvectProjo() {};
+  G4QuadvectProjo() {
+    for(G4int i = 0; i < max_a_proj; ++i) {
+      eps_c[i] = 0.0;
+      t_c[i] = 0.0;
+      p3_c[i] = 0.0;
+      p1_s[i] = 0.0;
+      p2_s[i] = 0.0;
+      p3_s[i] = 0.0;
+    }
+  };
   ~G4QuadvectProjo() {};
 …
 class G4VBe {
 public:
+  G4VBe() {};
+  G4VBe()
+    :ia_be(0), iz_be(0),
+     rms_be(0.0), pms_be(0.0), bind_be(0.0)
+  { };
   ~G4VBe() {};
 …
   G4InclProjSpect() {
     //    G4cout <<"Projectile spectator data structure created!" << G4endl;
+    clear();
   };
   ~G4InclProjSpect() {};
 …
     a_projspec = 0;
     z_projspec = 0;
     m_projspec = 0.0;
+    t_projspec = 0.0;
     ex_projspec = 0.0;
     p1_projspec = 0.0;
     p2_projspec = 0.0;
     p3_projspec = 0.0;
+    m_projspec = 0.0;
   };
 …
 };
-#define FSIZE 15
-/**
- * Initial values of a hadronic cascade problem.
- */
-class G4Calincl {
-public:
-  G4Calincl() {
-    isExtendedProjectile = false;
-  };
-  G4Calincl(const G4HadProjectile &aTrack, const G4Nucleus &theNucleus, G4bool inverseKinematics = false) {
-    for(int i = 0; i < 15; i++) {
-      f[i] = 0.0; // Initialize INCL input data
+    }
-    usingInverseKinematics = inverseKinematics;
-    f[0] = theNucleus.GetA_asInt(); // Target mass number
-    f[1] = theNucleus.GetZ_asInt(); // Target charge number
-    f[6] = getBulletType(aTrack.GetDefinition()); // Projectile type (INCL particle code)
-    f[2] = aTrack.GetKineticEnergy() / MeV; // Projectile energy (total, in MeV)
-    f[5] = 1.0; // Time scaling
-    f[4] = 45.0; // Nuclear potential
-    setExtendedProjectileInfo(aTrack.GetDefinition());
-    //    G4cout <<"Projectile type = " << f[6] << G4endl;
-    //    G4cout <<"Energy = " << f[2] << G4endl;
-    //    G4cout <<"Target A = " << f[0] << " Z = " << f[1] << G4endl;
-  };
-  ~G4Calincl() {};
-  static void printProjectileTargetInfo(const G4HadProjectile &aTrack, const G4Nucleus &theNucleus) {
-    G4cout <<"Projectile = " << aTrack.GetDefinition()->GetParticleName() << G4endl;
-    G4cout <<"    four-momentum: " << aTrack.Get4Momentum() << G4endl;
-    G4cout <<"Energy = " << aTrack.GetKineticEnergy() / MeV << G4endl;
-    G4cout <<"Target A = " << theNucleus.GetA_asInt() << " Z = " << theNucleus.GetZ_asInt() << G4endl;
+  }
-  static G4bool canUseInverseKinematics(const G4HadProjectile &aTrack, const G4Nucleus &theNucleus) {
-    G4int targetA = theNucleus.GetA_asInt();
-    const G4ParticleDefinition *projectileDef = aTrack.GetDefinition();
-    G4int projectileA = projectileDef->GetAtomicMass();
-    //    G4int projectileZ = projectileDef->GetAtomicNumber();
-    if(targetA > 0 && targetA < 18 && (projectileDef != G4Proton::Proton() &&
-                                       projectileDef != G4Neutron::Neutron() &&
-                                       projectileDef != G4PionPlus::PionPlus() &&
-                                       projectileDef != G4PionZero::PionZero() &&
-                                       projectileDef != G4PionMinus::PionMinus()) &&
-       projectileA > 1) {
-      return true;
-    } else {
-      return false;
+    }
+  }
-  G4double bulletE() {
-    return f[2];
+  }
-  G4int getBulletType() {
-    return G4int(f[6]);
-  };
-  void setExtendedProjectileInfo(const G4ParticleDefinition *pd) {
-    if(getBulletType(pd) == -666) {
-      extendedProjectileA = pd->GetAtomicMass();
-      extendedProjectileZ = pd->GetAtomicNumber();
-      isExtendedProjectile = true;
-    } else {
-      isExtendedProjectile = false;
+    }
-  };
-  G4int getBulletType(const G4ParticleDefinition *pd) {
-    G4ParticleTable *pt = G4ParticleTable::GetParticleTable();
-    if(pd == G4Proton::Proton()) {
-      return 1;
-    } else if(pd == G4Neutron::Neutron()) {
-      return 2;
-    } else if(pd == G4PionPlus::PionPlus()) {
-      return 3;
-    } else if(pd == G4PionMinus::PionMinus()) {
-      return 5;
-    } else if(pd == G4PionZero::PionZero()) {
-      return 4;
-    } else if(pd == G4Deuteron::Deuteron()) {
-      return 6;
-    } else if(pd == G4Triton::Triton()) {
-      return 7;
-    } else if(pd == G4He3::He3()) {
-      return 8;
-    } else if(pd == G4Alpha::Alpha()) {
-      return 9;
-    } else if(pd == pt->GetIon(6, 12, 0.0)) { // C12 special case. This should be phased-out in favor of "extended projectile"
-      return -12;
-    } else { // Is this extended projectile?
-      G4int A = pd->GetAtomicMass();
-      G4int Z = pd->GetAtomicNumber();
-      if(A > 4 && A <= 16 && Z > 2 && Z <= 8) { // Ions from Lithium to Oxygen
-        return -666; // Code of an extended projectile
+      }
+    }
-    G4cout <<"Error! Projectile " << pd->GetParticleName() << " not defined!" << G4endl;
-    return 0;
-  };
-  G4bool isInverseKinematics() {
-    return usingInverseKinematics;
-  };
-  G4double targetA() { return f[0]; };
-  G4double targetZ() { return f[1]; };
-  G4int extendedProjectileA;
-  G4int extendedProjectileZ;
-  G4bool isExtendedProjectile;
-  /**
-   * Here f is an array containing the following initial values:
-   * - f[0] : target mass number
-   * - f[1] : target charge number
-   * - f[2] : bullet energy
-   * - f[3] : minimum proton energy to leave the target (default: 0.0)
-   * - f[4] : nuclear potential (default: 45.0 MeV)
-   * - f[5] : time scale (default: 1.0)
-   * - f[6] : bullet type (1: proton, 2: neutron, 3: pi+, 4: pi0 5: pi-, 6:H2, 7: H3, 8: He3, 9: He4
-   * - f[7] : minimum neutron energy to leave the target (default: 0.0)
-   * - f[8] : target material identifier (G4Mat)
-   * - f[9] : not used
-   * - f[10] : not used
-   * - f[11] : not used
-   * - f[12] : not used
-   * - f[13] : not used
-   * - f[14] : not used
-   */
-  G4double f[FSIZE];
-  /**
-   * Number of events to be processed.
-   */
-  G4int icoup;
-  G4bool usingInverseKinematics;
-};
 #define IGRAINESIZE 19
 /**
 …
 class G4Hazard{
 public:
+  G4Hazard() {};
+  G4Hazard() {
+    ial = 0;
+    for(G4int i = 0; i < IGRAINESIZE; ++i) {
+      igraine[i] = 0;
+    }
+  };
   ~G4Hazard() {};
 …
 class G4Mat {
 public:
+  G4Mat() { };
+  G4Mat() {
+    nbmat = 0;
+    for(G4int i = 0; i < MATSIZE; ++i) {
+      zmat[i] = 0;
+      amat[i] = 0;
+    }
+    for(G4int i = 0; i < MATGEOSIZE; ++i) {
+      for(G4int j = 0; j < MATSIZE; ++j) {
+        bmax_geo[i][j] = 0;
+      }
+    }
+};
   ~G4Mat() { };
 …
 class G4LightGausNuc {
 public:
+  G4LightGausNuc() {};
+  G4LightGausNuc() {
+    for(G4int i = 0; i < LGNSIZE; ++i) {
+      rms1t[i] = 0.0;
+      pf1t[i] = 0.0;
+      pfln[i] = 0.0;
+      tfln[i] = 0.0;
+      vnuc[i] = 0.0;
+    }
+  };
   ~G4LightGausNuc() {};
 …
 class G4LightNuc {
 public:
+  G4LightNuc() {};
+  G4LightNuc() {
+    for(G4int i = 0; i < LNSIZE; ++i) {
+      r[i] = 0.0;
+      a[i] = 0.0;
+    }
+  };
   ~G4LightNuc() {};
 …
 class G4Saxw {
 public:
+  G4Saxw() {};
+  G4Saxw() {
+    for(G4int i = 0; i < SAXWROWS; ++i) {
+      for(G4int j = 0; j < SAXWCOLS; ++j) {
+        x[i][j] = 0.0;
+        y[i][j] = 0.0;
+        s[i][j] = 0.0;
+      }
+    }
+    imat = 0; n = 0; k = 0;
+  };
   ~G4Saxw() {};
 …
   G4Ws() {
     fneck = 0.0;
+  };
+    r0 = 0.0;
+    adif = 0.0;
+    rmaxws = 0.0;
+    drws = 0.0;
+    nosurf = 0.0;
+    xfoisa = 0.0;
+    bmax = 0.0;
+    npaulstr = 0.0;
+  };
   ~G4Ws() {};
 …
 class G4Dton {
 public:
+  G4Dton() {};
+  G4Dton() {
+    fn = 0.0;
+    for(G4int i = 0; i < DTONSIZE; ++i) {
+      c[i] = 0.0;
+      d[i] = 0.0;
+    }
+  };
   ~G4Dton() {};
 …
 class G4Spl2 {
 public:
+  G4Spl2() {};
+  G4Spl2() {
+    for(G4int i = 0; i < SPL2SIZE; ++i) {
+      x[i] = 0.0; y[i] = 0.0;
+      a[i] = 0.0; b[i] = 0.0; c[i] = 0.0;
+    }
+    n = 0;
+  };
   ~G4Spl2() {};
 …
 class G4Bl1 {
 public:
+  G4Bl1() {};
+  G4Bl1() {
+    ta = 0.0;
+    for(G4int i = 0; i < BL1SIZE; ++i) {
+      p1[i] = 0.0; p2[i] = 0.0; p3[i] = 0.0; eps[i] = 0.0;
+      ind1[i] = 0; ind2[i] = 0;
+    }
+  };
   ~G4Bl1() {};
 …
 };
+#define BL2CROISSIZE 19900
+#define BL2INDSIZE 19900
+#define BL2SIZE 19900
 /**
+ *
 …
 class G4Bl2 {
 public:
+  G4Bl2() {};
+  G4Bl2() {
+    k = 0;
+    for(G4int i = 0; i < BL2SIZE; ++i) {
+      crois[i] = 0.0;
+      ind[i] = 0;
+      jnd[i] = 0;
+    }
+  };
   ~G4Bl2() {};
 …
+   *
    */
   G4double crois[BL2CROISSIZE];
+  G4double crois[BL2SIZE];
   /**
 …
+   *
    */
   G4int ind[BL2INDSIZE];
   /**
+   *
    */
   G4int jnd[BL2INDSIZE];
+  G4int ind[BL2SIZE];
+  /**
+   *
+   */
+  G4int jnd[BL2SIZE];
 };
 …
 class G4Bl3 {
 public:
+  G4Bl3() {};
+  G4Bl3() {
+    r1 = 0.0; r2 = 0.0;
+    ia1 = 0; ia2 = 0;
+    rab2 = 0.0;
+    for(G4int i = 0; i < BL3SIZE; ++i) {
+      x1[i] = 0.0; x2[i] = 0.0; x3[i] = 0.0;
+    }
+  };
   ~G4Bl3() {};
 …
 class G4Bl4 {
 public:
+  G4Bl4() {};
+  G4Bl4()
+    :tmax5(0.0)
+  {};
   ~G4Bl4() {};
 …
 class G4Bl5 {
 public:
+  G4Bl5() {};
+  G4Bl5() {
+    for(G4int i = 0; i < BL5SIZE; ++i) {
+      tlg[i] = 0.0;
+      nesc[i] = 0;
+    }
+  };
   ~G4Bl5() {};
 …
 class G4Bl6 {
 public:
+  G4Bl6() {};
+  G4Bl6()
+    :xx10(0.0), isa(0.0)
+  {};
   ~G4Bl6() {};
 …
 class G4Bl8 {
 public:
+  G4Bl8() {};
+  G4Bl8()
+    :rathr(0.0), ramass(0.0)
+  {};
   ~G4Bl8() {};
 …
     l1 = 0;
     l2 = 0;
+    for(G4int i = 0; i < BL9SIZE; ++i) {
+      hel[i] = 0.0;
+    }
   };
   ~G4Bl9() {};
 …
 class G4Bl10 {
 public:
+  G4Bl10() {};
+  G4Bl10()
+    :ri4(0.0), rs4(0.0), r2i(0.0), r2s(0.0), pdummy(0.0), pf(0.0)
+  {};
   ~G4Bl10() {};
 …
 class G4Kind {
 public:
+  G4Kind() {};
+  G4Kind()
+    :kindf7(0)
+  {};
   ~G4Kind() {};
 …
 class G4VarAvat {
 public:
+  G4VarAvat() {};
+  G4VarAvat() {
+    kveux = 0;
+    bavat = 0.0;
+    nopartavat = 0; ncolavat = 0;
+    nb_avat = 0;
+    for(G4int i = 0; i < VARSIZE; ++i) {
+      r1_in[i] = 0.0;
+      r1_first_avat[i] = 0.0;
+    }
+    for(G4int i = 0; i < VAEPSSIZE; ++i) {
+      epsd[i] = 0.0;
+      eps2[i] = 0.0;
+      eps4[i] = 0.0;
+      eps6[i] = 0.0;
+      epsf[i] = 0.0;
+    }
+    for(G4int i = 0; i < VAAVM; ++i) {
+      timeavat[i] = 0.0;
+      l1avat[i] = 0.0;
+      l2avat[i] = 0.0;
+      jpartl1[i] = 0.0;
+      jpartl2[i] = 0.0;
+      del1avat[i] = 0.0;
+      del2avat[i] = 0.0;
+      energyavat[i] = 0.0;
+      bloc_paul[i] = 0.0;
+      bloc_cdpp[i] = 0.0;
+      go_out[i] = 0.0;
+    }
+  };
   ~G4VarAvat() {};
 …
 class G4VarNtp {
 public:
+  G4VarNtp() {};
+  G4VarNtp() {
+    clear();
+  };
   ~G4VarNtp() {};
 …
     targetA = 0;
     targetZ = 0;
     masp = 0.0; mzsp = 0.0; exsp = 0.0;
+    masp = 0.0; mzsp = 0.0; exsp = 0.0; mrem = 0.0;
     // To be deleted?
     spectatorA = 0;
 …
 class G4Paul {
 public:
+  G4Paul() {};
+  G4Paul()
+    :ct0(0.0), ct1(0.0), ct2(0.0), ct3(0.0), ct4(0.0), ct5(0.0), ct6(0.0),
+     pr(0.0), pr2(0.0), xrr(0.0), xrr2(0.0),
+     cp0(0.0), cp1(0.0), cp2(0.0), cp3(0.0), cp4(0.0), cp5(0.0), cp6(0.0)
+  {};
   ~G4Paul() {};

trunk/source/processes/hadronic/models/incl/include/G4InclLightIonInterface.hh

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4InclLightIonInterface.hh,v 1.6 2010/10/26 02:47:59 kaitanie Exp $
+// $Id: G4InclLightIonInterface.hh,v 1.8 2010/11/13 00:08:36 kaitanie Exp $
 // Translation of INCL4.2/ABLA V3
 // Pekka Kaitaniemi, HIP (translation)
 …
 #define G4INCLLIGHTIONINTERFACE_H 1
-#include "G4Nucleon.hh"
-#include "G4Nucleus.hh"
-#include "G4HadronicInteraction.hh"
 #include "G4VIntraNuclearTransportModel.hh"
 #include "G4KineticTrackVector.hh"
 …
 #include "G4Incl.hh"
+// Geant4 de-excitation
+#include "G4ExcitationHandler.hh"
+#include "G4PreCompoundModel.hh"
 #include <fstream>
 #include <iostream>
 …
 /**
  * Interface for INCL. This interface handles basic light ion
  * bullet particles (deuterons, tritons, he3 and alphas).
  * @see G4InclAblaLightIonInterface
+ * Interface for INCL with Geant4 PreCompound de-excitation. This
+ * interface handles basic light ion bullet particles from deuterons
+ * up to carbon-12. @see G4InclAblaLightIonInterface
  */
 …
   /**
    * Main method to apply the INCL/ABLA physics model.
+   * Main method to apply the INCL physics model.
    * @param aTrack the projectile particle
    * @param theNucleus target nucleus
    * @return the output of the INCL/ABLA physics model
+   * @return the output of the INCL physics model
    */
   G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,  G4Nucleus& theNucleus);
 …
   G4double previousTargetA;
   G4double previousTargetZ;
+  G4bool useProjectileSpectator;
+  G4bool useFermiBreakup;
+  G4ExcitationHandler *theExcitationHandler;
+  G4PreCompoundModel *thePrecoModel;
 };
 #endif // G4INCLLIGHTIONINTERFACE_H
+#endif // G4INCLABLALIGHTIONINTERFACE_H

trunk/source/processes/hadronic/models/incl/include/G4InclRandomNumbers.hh

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4InclRandomNumbers.hh,v 1.6 2010/10/26 02:47:59 kaitanie Exp $
+// $Id: G4InclRandomNumbers.hh,v 1.8 2010/11/13 00:08:36 kaitanie Exp $
 // Translation of INCL4.2/ABLA V3
 // Pekka Kaitaniemi, HIP (translation)
 …
 public:
+  G4InclRandomInterface() { }
+  G4InclRandomInterface() {
+    this->seed = 1337; // Default seed, this is never actually used.
+  }
   G4InclRandomInterface(G4long seed) {
     this->seed = seed;

trunk/source/processes/hadronic/models/incl/src/G4Abla.cc

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4Abla.cc,v 1.22 2010/10/26 02:47:59 kaitanie Exp $
+// $Id: G4Abla.cc,v 1.27 2010/11/17 20:19:09 kaitanie Exp $
 // Translation of INCL4.2/ABLA V3
 // Pekka Kaitaniemi, HIP (translation)
 …
 #include "G4AblaFissionSimfis18.hh"
 #include "G4AblaFission.hh"
-G4Abla::G4Abla()
+{
-  verboseLevel = 0;
-  ilast = 0;
+}
-G4Abla::G4Abla(G4Hazard *hazard, G4Volant *volant)
+{
-  verboseLevel = 0;
-  ilast = 0;
-  volant = volant; // ABLA internal particle data
-  volant->iv = 0;
-  hazard = hazard; // Random seeds
-  randomGenerator = new G4InclGeant4Random();
-  //randomGenerator = new G4Ranecu();
-  varntp = new G4VarNtp();
-  pace = new G4Pace();
-  ald = new G4Ald();
-  eenuc = new G4Eenuc();
-  ec2sub = new G4Ec2sub();
-  ecld = new G4Ecld();
-  fb = new G4Fb();
-  fiss = new G4Fiss();
-  opt = new G4Opt();
+}
 G4Abla::G4Abla(G4Hazard *aHazard, G4Volant *aVolant, G4VarNtp *aVarntp)
 …
 G4Abla::~G4Abla()
+{
+  delete fissionModel;
   delete randomGenerator;
   delete pace;
 …
       //               G4double *pleva_par, G4double *pxeva_par, G4double *pyeva_par,
       //               G4double *ff_par, G4int *inttype_par, G4int *inum_par);
       G4double zf1, af1, malpha1, ffpleva1, ffpxeva1, ffpyeva1;
       G4int ff1, ftype1;
+      G4double zf1 = 0.0, af1 = 0.0, malpha1 = 0.0, ffpleva1 = 0.0, ffpxeva1 = 0.0, ffpyeva1 = 0.0;
+      G4int ff1 = 0, ftype1 = 0;
       evapora(zff1, aff1, epf1_out, 0.0, &zf1, &af1, &malpha1, &ffpleva1,
               &ffpxeva1, &ffpyeva1, &ff1, &ftype1, &inum);
 …
       //               G4double *pleva_par, G4double *pxeva_par, G4double *pyeva_par,
       //               G4double *ff_par, G4int *inttype_par, G4int *inum_par);
       G4double zf2, af2, malpha2, ffpleva2, ffpxeva2, ffpyeva2;
       G4int ff2, ftype2;
+      G4double zf2 = 0.0, af2 = 0.0, malpha2 = 0.0, ffpleva2 = 0.0, ffpxeva2 = 0.0, ffpyeva2 = 0.0;
+      G4int ff2 = 0, ftype2 = 0;
       evapora(zff2,aff2,epf2_out,0.0,&zf2,&af2,&malpha2,&ffpleva2,
               &ffpxeva2,&ffpyeva2,&ff2,&ftype2,&inum);
 …
                     G4double *sbp_par, G4double *sba_par, G4double *ecn_par,
                     G4double *ecp_par,G4double *eca_par, G4double *bp_par,
                     G4double *ba_par, G4int inttype, G4int inum, G4int itest)
+                    G4double *ba_par, G4int, G4int inum, G4int itest)
+{
   G4int dummy0 = 0;
 …
   imaxwell = 1;
-  inttype = 0;
   // limiting of excitation energy where fission occurs
 …
   i = idint(y/(2.0e-02)) + 1;
   if(i >= bsbkSize) {
+  if((i + 1) >= bsbkSize) {
     if(verboseLevel > 2) {
       G4cout <<"G4Abla error: index i = " << i << " is greater than array size permits." << G4endl;
+      G4cout <<"G4Abla error: index " << i + 1 << " is greater than array size permits." << G4endl;
+    }
     bipolResult = 0.0;
 …
 // own class
+void G4Abla::standardRandom(G4double *rndm, G4long *seed)
+{
+  (*seed) = (*seed); // Avoid warning during compilation.
+void G4Abla::standardRandom(G4double *rndm, G4long*)
+{
   // Use Geant4 G4UniformRand
   (*rndm) = randomGenerator->getRandom();

trunk/source/processes/hadronic/models/incl/src/G4AblaFission.cc

-              r968
+              r1347
 // ********************************************************************
 //
 // $Id: G4AblaFission.cc,v 1.3 2008/11/06 08:42:00 gcosmo Exp $
+// $Id: G4AblaFission.cc,v 1.5 2010/11/17 20:19:09 kaitanie Exp $
 // Translation of INCL4.2/ABLA V3
 // Pekka Kaitaniemi, HIP (translation)
 …
 G4AblaFission::G4AblaFission()
+{
+  hazard = 0;
+  randomGenerator = 0;
+}
 …
+}
+void G4AblaFission::standardRandom(G4double *rndm, G4long *seed)
+{
+  (*seed) = (*seed); // Avoid warning during compilation.
+void G4AblaFission::standardRandom(G4double *rndm, G4long*)
+{
   // Use Geant4 G4UniformRand
   (*rndm) = randomGenerator->getRandom();

trunk/source/processes/hadronic/models/incl/src/G4AblaFissionSimfis18.cc

-              r968
+              r1347
 // ********************************************************************
 //
 // $Id: G4AblaFissionSimfis18.cc,v 1.3 2008/11/06 08:42:00 gcosmo Exp $
+// $Id: G4AblaFissionSimfis18.cc,v 1.5 2010/11/17 20:19:09 kaitanie Exp $
 // Translation of INCL4.2/ABLA V3
 // Pekka Kaitaniemi, HIP (translation)
 …
 G4AblaFissionSimfis18::G4AblaFissionSimfis18()
+{
+  hazard = 0;
+  randomGenerator = 0;
+}
 …
+}
+void G4AblaFissionSimfis18::standardRandom(G4double *rndm, G4long *seed)
+{
+  (*seed) = (*seed); // Avoid warning during compilation.
+void G4AblaFissionSimfis18::standardRandom(G4double *rndm, G4long*)
+{
   // Use Geant4 G4UniformRand
   (*rndm) = randomGenerator->getRandom();

trunk/source/processes/hadronic/models/incl/src/G4Incl.cc

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4Incl.cc,v 1.33 2010/10/29 06:48:43 gunter Exp $
+// $Id: G4Incl.cc,v 1.37 2010/12/15 07:41:31 gunter Exp $
 // Translation of INCL4.2/ABLA V3
 // Pekka Kaitaniemi, HIP (translation)
 …
   randomGenerator = new G4InclGeant4Random();
   //  randomGenerator = new G4Ranecu();
+  clearState();
+}
 …
   //  randomGenerator = new G4Ranecu();
   randomGenerator = new G4InclGeant4Random();
+  clearState();
+}
 …
   theLogger = 0;
+  clearState();
+}
 G4Incl::~G4Incl()
+{
+  delete be;
+  delete ps;
+  delete fermi;
+  delete qvp;
   delete randomGenerator;
   delete light_gaus_nuc;
 …
 void G4Incl::processEventIncl(G4InclInput *input)
+{
+  //G4cout <<"Starting event " << eventnumber << G4endl;
   if(input == 0) {
     G4cerr <<"G4Incl fatal error: NULL pointer passed as input!" << G4endl;
 …
   const G4double uma = 931.4942;
   const G4double melec = 0.511;
+  G4double   pcorem = 0.0;
+  G4double   pxrem = 0.0;
+  G4double   pyrem = 0.0;
+  G4double   pzrem = 0.0;
+  const G4double fmp = 938.2796;
+  G4double pcorem = 0.0;
+  G4double pxrem = 0.0;
+  G4double pyrem = 0.0;
+  G4double pzrem = 0.0;
   G4double ap = 0.0, zp = 0.0, mprojo = 0.0, pbeam = 0.0;
   varntp->clear();
+  if(calincl->bulletType() == 3) { // pi+
+  if(calincl->bulletType() == -12) {
+    be->ia_be = std::abs(calincl->bulletType());
+    be->iz_be = 6;
+  } else if(calincl->bulletType() == -666) {
+    be->iz_be = calincl->extendedProjectileZ();
+    be->ia_be = calincl->extendedProjectileA();
+  }
+  if(calincl->isExtendedProjectile() == false && calincl->bulletType() < -max_a_proj) {
+  //  if(calincl->bulletType() < -max_a_proj) {
+    G4cout <<"max a of composite projectile is: " << max_a_proj << G4endl;
+    exit(0);
+  }
+  if(calincl->bulletType() < 0) {
+    //    calincl->bulletType() = std::floor(calincl->bulletType() + 0.1); WTF???
+    be->pms_be=100.;
+    G4int i_tabled=0;
+    if(be->iz_be == 3 && be->ia_be == 6) {
+      be->rms_be=2.56;
+      be->bind_be=32.0;
+      i_tabled=1;
+    } else if(be->iz_be == 3 && be->ia_be == 7) { // TODO: Check the values!
+      be->rms_be=2.56;
+      be->bind_be=32.0;
+      i_tabled=1;
+    } else if(be->iz_be == 3 && be->ia_be == 8) {
+      be->rms_be=2.40;
+      be->bind_be=39.25;
+      i_tabled=1;
+    } else if(be->iz_be == 4 && be->ia_be == 7) {
+      be->rms_be=2.51;
+      be->bind_be=58.17;
+      i_tabled=1;
+    } else if(be->iz_be == 4 && be->ia_be == 9) {
+      be->rms_be=2.51;
+      be->bind_be=58.17;
+      i_tabled=1;
+    } else if(be->iz_be == 4 && be->ia_be == 10) {
+      be->rms_be=2.45;
+      be->bind_be=64.75;
+      i_tabled=1;
+    } else if(be->iz_be == 5 && be->ia_be == 10) {
+      be->rms_be=2.45;
+      be->bind_be=64.75;
+      i_tabled=1;
+    } else if(be->iz_be == 5 && be->ia_be == 11) {
+      be->rms_be=2.40;
+      be->bind_be=76.21;
+      i_tabled=1;
+    } else if(be->iz_be == 6 && be->ia_be == 9) { // TODO: Check the values!
+      be->rms_be=2.44;
+      be->bind_be=92.17;
+      i_tabled=1;
+    } else if(be->iz_be == 6 && be->ia_be == 10) { // TODO: Check the values!
+      be->rms_be=2.44;
+      be->bind_be=92.17;
+      i_tabled=1;
+    } else if(be->iz_be == 6 && be->ia_be == 11) { // TODO: Check the values!
+      be->rms_be=2.44;
+      be->bind_be=92.17;
+      i_tabled=1;
+    } else if(be->iz_be == 6 && calincl->bulletType() == -12) { // Special Carbon case
+      G4cout <<"Carbon 12 (special) selected." << G4endl;
+      be->rms_be=2.44;
+      be->bind_be=92.17;
+      i_tabled=1;
+    } else if(be->iz_be == 6 && be->ia_be == 12) {
+      be->rms_be=2.44;
+      be->bind_be=92.17;
+      i_tabled=1;
+    } else if(be->iz_be == 7 && be->ia_be == 16) {
+      be->rms_be=2.73;
+      be->bind_be=127.62;
+      i_tabled=1;
+    } else {
+      G4cout <<"Warning: No rms and binding for projectile ion A = " << be->ia_be << " Z = " << be->iz_be << G4endl;
+      be->rms_be=2.44;
+      be->bind_be=92.17;
+      G4cout <<"Warning: Using probably bad values rms = " << be->rms_be << " binding = " << be->bind_be << G4endl;
+      i_tabled=1;
+    }
+    if(i_tabled == 0) {
+      G4cout <<"This heavy ion (a,z)= " << be->ia_be << " " << be->iz_be << " is not defined as beam in INCL" << G4endl;
+      exit(0);
+    }
+    //    G4cout <<"z projectile, rms_r, rms_p (gaussian model)" << be->iz_be << " " << be->rms_be << " " << be->pms_be << G4endl;
+    //    G4cout <<"binding energy (mev):" << be->bind_be << G4endl;
+    //    G4cout <<"fermi-breakup dresner below a=" << calincl->f[11] << G4endl;
+  }
+  //  G4cout <<"Target Mass and Charge: " << calincl->targetA() << " " << calincl->targetZ() << G4endl;
+  //  calincl->f[10] = 0; // No clusters
+  if(calincl->bulletType() == -12) {  // C12 special case
+    mprojo=fmp*std::abs(calincl->bulletType()) - be->bind_be;
+    pbeam=std::sqrt(calincl->bulletE()*(calincl->bulletE()+2.*mprojo));
+    ap=std::abs(calincl->bulletType());
+    zp=be->iz_be;
+  } else if(calincl->bulletType() == -666) { // Generic extended projectile
+    mprojo=fmp*be->ia_be - be->bind_be;
+    pbeam=std::sqrt(calincl->bulletE()*(calincl->bulletE()+2.*mprojo));
+    ap=be->ia_be;
+    zp=be->iz_be;
+  }
+  // pi+
+  if(calincl->bulletType() == 3) {
     mprojo = 139.56995;
     ap = 0.0;
 …
+  }
+  if(calincl->bulletType() == 4) { // pi0
+  // pi0
+  if(calincl->bulletType() == 4) {
     mprojo = 134.9764;
     ap = 0.0;
 …
+  }
+  if(calincl->bulletType() == 5) { // pi-
+  // pi-
+  if(calincl->bulletType() == 5) {
     mprojo = 139.56995;
     ap = 0.0;
 …
+  }
+  // Coulomb en entree seulement pour les particules ci-dessous.
+  if(calincl->bulletType() == 1) { // proton
+  // coulomb en entree seulement pour les particules ci-dessous
+  // proton
+  if(calincl->bulletType() == 1) {
     mprojo = 938.27231;
     ap = 1.0;
     zp = 1.0;
+  }
+  if(calincl->bulletType() == 2) { // neutron
+  // neutron
+  if(calincl->bulletType() == 2) {
     mprojo = 939.56563;
     ap = 1.0;
     zp = 0.0;
+  }
+  if(calincl->bulletType() == 6) { // deuteron
+  // deuteron
+  if(calincl->bulletType() == 6) {
     mprojo = 1875.61276;
     ap = 2.0;
     zp = 1.0;
+  }
+  if(calincl->bulletType() == 7) { // triton
+  // triton
+  if(calincl->bulletType() == 7) {
     mprojo = 2808.95;
     ap = 3.0;
     zp = 1.0;
+  }
+  if(calincl->bulletType() == 8) { // He3
+  // He3
+  if(calincl->bulletType() == 8) {
     mprojo = 2808.42;
     ap = 3.0;
 …
+  }
+  if(calincl->bulletType() == 9) { // Alpha
+  // Alpha
+  if(calincl->bulletType() == 9) {
     mprojo = 3727.42;
     ap = 4.0;
 …
+  }
+  if(calincl->bulletType() == -12) { // Carbon
+    mprojo = 12.0 * 938.27231;
+  // Carbon
+  if(calincl->bulletType() == -12) {
+    mprojo = 6.0*938.27231 + 6.0*939.56563;
     ap = 12.0;
     zp = 6.0;
-  } else if(calincl->bulletType() == -666) { // Generic extended ion projectile
-    mprojo = calincl->extendedProjectileA() * 938.27231;
-    ap = calincl->extendedProjectileA();
-    zp = calincl->extendedProjectileZ();
+  }
 …
   G4double bimpac = 0.0;
   G4int jrem = 0;
+  G4double xjrem = 0.0, yjrem = 0.0, zjrem = 0.0;
   G4double alrem = 0.0;
+  /**
+   * Coulomb barrier treatment.
+   */
+  // Coulomb barrier
   G4double probaTrans = 0.0;
   G4double rndm = 0.0;
   if((calincl->bulletType() == 1) || (calincl->bulletType() >= 6)) {
+    //    probaTrans = coulombTransm(calincl->bulletE(),apro,zpro,calincl->targetA(),calincl->targetZ());
     probaTrans = coulombTransm(calincl->bulletE(),ap,zp,calincl->targetA(),calincl->targetZ());
     standardRandom(&rndm, &(hazard->ial));
 …
+  }
+  /**
+   * Call the actual INCL routine.
+   */
+  //  G4cout <<"Before PNU:" << G4endl;
   //  randomGenerator->printSeeds();
+  G4double jremx, jremy, jremz;
+  pnu(&ibert, &nopart,&izrem,&iarem,&esrem,&erecrem,&alrem,&berem,&garem,&bimpac,&jrem,
+      &jremx, &jremy, &jremz);
+  // Call the actual INCL routine:
+  pnu(&ibert, &nopart,&izrem,&iarem,&esrem,&erecrem,&alrem,&berem,&garem,&bimpac,
+      &jrem, &xjrem, &yjrem, &zjrem);
+  //  G4cout <<"After PNU:" << G4endl;
+  //  randomGenerator->printSeeds();
+  G4double mrem = int(zjrem/197.328); // CHECK
+  if (mrem > jrem) mrem=jrem;
+  if (mrem < -jrem) mrem=-jrem;
+//   nopart=1;
+//   kind[0]=1;
+//   ep[0]=799.835;
+//   alpha[0]=0.08716;
+//   beta[0]=0.;
+//   gam[0]=0.99619;
+//   izrem=82;
+//   iarem=208;
+//   esrem=200.;
+//   erecrem=0.18870;
+//   alrem=-0.47101;
+//   berem=0.;
+//   garem=0.88213;
+//   bimpac=2.;
   forceAbsor(&nopart, &iarem, &izrem, &esrem, &erecrem, &alrem, &berem, &garem, &jrem);
   G4double aprf = double(iarem); // mass number of the prefragment
   G4double jprf = 0.0;           // angular momentum of the prefragment
   // Mean angular momentum of prefragment.
   jprf = 0.165 * std::pow(at,(2.0/3.0)) * aprf * (at - aprf) / (at - 1.0);
+  G4double aprf = double(iarem);    // mass number of the prefragment
+  G4double jprf = 0.0;                // angular momentum of the prefragment
+  // Mean angular momentum of prefragment
+  jprf = 0.165 * std::pow(at,(2.0/3.0)) * aprf*(at - aprf)/(at - 1.0);
   if (jprf < 0) {
     jprf = 0.0;
+  }
   // Reference M. de Jong, Ignatyuk, Schmidt Nuc. Phys A 613, p442, 7th line
+  // check m.de jong, ignatyuk, schmidt nuc.phys a 613, pg442, 7th line
   jprf = std::sqrt(2*jprf);
   jprf = jrem;
+  varntp->jremn = jrem; // Copy jrem to output tuple.
+  G4double numpi = 0;  // Number  of pions.
+  G4double multn = 0;  // Number (multiplicity) of neutrons.
+  G4double multp = 0;  // Number (multiplicity) of protons.
+  // Ecriture dans le ntuple des particules de cascade (sauf remnant).
+  varntp->ntrack = nopart; // Nombre de particules pour ce tir.
+  varntp->jremn = jrem;      // jrem copie dans le ntuple
+  G4double numpi = 0;  // compteurs de pions, neutrons protons
+  G4double multn = 0;
+  G4double multp = 0;
+  // ecriture dans le ntuple des particules de cascade (sauf remnant)
+  varntp->ntrack = nopart;          // nombre de particules pour ce tir
+  if(varntp->ntrack >= VARNTPSIZE) {
+    if(verboseLevel > 2) {
+      G4cout <<"G4Incl error: Output data structure not big enough." << G4endl;
+    }
+  }
   varntp->massini = iarem;
   varntp->mzini = izrem;
 …
   varntp->bimpact = bimpac;
+  /**
+   * Three ways to compute the mass of the remnant:
+   * -from the output of the cascade and the canonic mass
+   * -from energy balance (input - all emitted energies)
+   * -following the approximations of the cugnon code (esrem...)
+   */
+  G4double f0 = calincl->targetA();
+  G4double f1 = calincl->targetZ();
+  G4double f2 = calincl->bulletE();
+  G4double mcorem = mprojo + f2 + abla->pace2(f0, f1) + f0 * uma - f1 * melec;
+  //  three ways to compute the mass of the remnant:
+  //                -from the output of the cascade and the canonic mass
+  //                -from energy balance (input - all emitted energies)
+  //                -following the approximations of the cugnon code (esrem...)
+  G4double mcorem = mprojo + calincl->bulletE() + abla->pace2(double(calincl->targetA()),double(calincl->targetZ()))
+    + calincl->targetA()*uma - calincl->targetZ()*melec;
   G4double pxbil = 0.0;
 …
   if(nopart > -1) {
+    for(G4int j = 0; j < nopart; j++) {
+      varntp->itypcasc[j] = 1;
+    // Fill the projectile spectator variables
+    varntp->masp = ps->a_projspec;
+    varntp->mzsp = ps->z_projspec;
+    varntp->exsp = ps->ex_projspec;
+    varntp->spectatorP1 = ps->p1_projspec;
+    varntp->spectatorP2 = ps->p2_projspec;
+    varntp->spectatorP3 = ps->p3_projspec;
+    varntp->spectatorT = ps->t_projspec;
+    for(G4int j = 0; j <= nopart; j++) {
+      if(ep[j] < 0.0) { // Workaround to avoid negative energies (and taking std::sqrt of a negative number).
+        G4cout <<"G4Incl: Not registering particle with energy: " << ep[j] << G4endl;
+        continue;
+      }
+      if(kind[j] == 0) continue; // Empty particle rows are sometimes produced by lurking indexing problems. We can simply skip those "bad" entries...
+      if(gam[j] > CLHEP::pi) {
+        if(verboseLevel > 2) {
+          G4cout <<"G4Incl: Just avoided floating point exception by using an ugly hack..." << G4endl;
+        }
+        continue; // Avoid floating point exception
+      }
+      varntp->itypcasc[j] = 1; // Particle was produced by the cascade
+      // Spectators of composite projectiles (7/2006, AB)
+      // (kind is negative in that case)
+      if(kind[j] <= 0) { // Particle is a projectile spectator that comes directly from the cascade
+        kind[j] *= -1;
+        varntp->itypcasc[j]=-1;
+        //      G4cout <<"Spectator registered!" << G4endl;
+        //      continue;
+      }
       // kind(): 1=proton, 2=neutron, 3=pi+, 4=pi0, 5=pi -
       if(kind[j] == 1) {
         varntp->avv[j] = 1;
         varntp->zvv[j] = 1;
         varntp->plab[j] = std::sqrt(ep[j] * (ep[j] + 1876.5592)); // cugnon
+        varntp->plab[j] = std::sqrt(ep[j]*(ep[j]+1876.5592)); // cugnon
         multp = multp + 1;
         mcorem = mcorem - ep[j] - 938.27231;
 …
         varntp->zvv[j] = 0;
         varntp->plab[j] = std::sqrt(ep[j]*(ep[j]+1876.5592)); // cugnon
-        //varntp->plab[j] = std::sqrt(ep[j] * (ep[j] + 1879.13126)); // PK mass check
         multn = multn + 1;
         mcorem = mcorem - ep[j] - 939.56563;
 …
+        }
+      }
       if(kind[j] == 3) {
         varntp->avv[j] = -1;
 …
         mcorem = mcorem - ep[j] - 3724.818;
         if(verboseLevel > 3) {
           G4cout <<"G4Incl: He4 produced! " << G4endl;
+          G4cout <<"G4Incl: He3 produced! " << G4endl;
           G4cout <<"G4Incl: Momentum: "<< varntp->plab[j] << G4endl;
+        }
 …
       if(verboseLevel > 3) {
         G4cout <<"Momentum: " << varntp->plab[j] << G4endl;
         G4cout <<"Theta: " << varntp->tetlab[j] << G4endl;
         G4cout <<"Phi: " << varntp->philab[j] << G4endl;
+        G4cout <<"Momentum: " << varntp->plab[j]   << G4endl;
+        G4cout <<"Theta: "    << varntp->tetlab[j] << G4endl;
+        G4cout <<"Phi: "      << varntp->philab[j] << G4endl;
+      }
+    }
     // calcul de la masse (impulsion) du remnant coherente avec la conservation d'energie:
+    pcorem=std::sqrt(erecrem*(erecrem +2.*938.2796*iarem));   // cugnon
+    mcorem = 938.2796*iarem;                               // cugnon
+    pcorem = std::sqrt(erecrem*(erecrem + 2.0 * 938.2796 * iarem));   // cugnon
+    mcorem = 938.2796 * iarem;                               // cugnon
+    varntp->pcorem = pcorem;
+    varntp->mcorem = mcorem;
     // Note: Il faut negliger l'energie d'excitation (ESREM) pour que le bilan
     // d'impulsion soit correct a la sortie de la cascade.....et prendre la
     // masse MCOREM comme ci-dessus (fausse de ~1GeV par rapport aux tables...)
+    pxrem=pcorem*alrem;
+    pyrem=pcorem*berem;
+    pzrem=pcorem*garem;
+    pxbil=pxbil+pxrem;
+    pybil=pybil+pyrem;
+    pzbil=pzbil+pzrem;
+    if((std::fabs(pzbil-pbeam) > 5.0) || (std::sqrt(std::pow(pxbil,2)+std::pow(pybil,2)) >= 3.0)) {
+    pxrem = pcorem * alrem;
+    pyrem = pcorem * berem;
+    pzrem = pcorem * garem;
+    varntp->pxrem = pxrem;
+    varntp->pyrem = pyrem;
+    varntp->pzrem = pzrem;
+    pxbil = pxbil + pxrem;
+    pybil = pybil + pyrem;
+    pzbil = pzbil + pzrem;
+    // If on purpose, add here the spectator nuclei:
+    if(calincl->bulletType() < 0 && ps->a_projspec != 0) {
+      pxbil=pxbil+ps->p1_projspec;
+      pybil=pybil+ps->p2_projspec;
+      pzbil=pzbil+ps->p3_projspec;
+    }
+    if((std::fabs(pzbil - pbeam) > 5.0) || (std::sqrt(std::pow(pxbil,2) + std::pow(pybil,2)) >= 3.0)) {
       if(verboseLevel > 3) {
         G4cout <<"Bad momentum conservation after INCL:" << G4endl;
 …
     varntp->iafis = 0;
+    //  varntp->ntrack = varntp->ntrack + 1;  // on recopie le remnant dans le ntuple
+    // on recopie le remnant dans le ntuple
+    varntp->ntrack = varntp->ntrack + 1;
     varntp->massini = iarem;
     varntp->mzini = izrem;
     varntp->exini = esrem;
+    varntp->itypcasc[varntp->ntrack] = 1;
+    varntp->avv[varntp->ntrack] = iarem;
+    varntp->zvv[varntp->ntrack]= izrem;
+    varntp->plab[varntp->ntrack] = pcorem;
+    varntp->enerj[varntp->ntrack] = std::sqrt(std::pow(pcorem,2) + std::pow(mcorem,2)) - mcorem;
+    varntp->tetlab[varntp->ntrack] = 180.0*std::acos(garem)/3.141592654;
+    varntp->philab[varntp->ntrack] = 180.0*std::atan2(berem,alrem)/3.141592654;
+    varntp->ntrack++;
+    varntp->mulncasc = varntp->ntrack;
+    varntp->mulnevap = 0;
+    varntp->mulntot = varntp->mulncasc + varntp->mulnevap;
+    if(verboseLevel > 3) {
+      G4cout <<"G4Incl: Returning nucleus fragment. " << G4endl;
+      G4cout <<"G4Incl: Fragment A = " << varntp->avv[varntp->ntrack] << " Z = " << varntp->zvv[varntp->ntrack] << G4endl;
+      G4cout <<"Energy: " << varntp->enerj[varntp->ntrack] << G4endl;
+      G4cout <<"Momentum: " << varntp->plab[varntp->ntrack] << G4endl;
+      G4cout <<"Theta: " << varntp->tetlab[varntp->ntrack] << G4endl;
+      G4cout <<"Phi: " << varntp->philab[varntp->ntrack] << G4endl;
+    }
+  }
+  else {
+    if(nopart == -2) {
+      varntp->ntrack = -2; //FIX: Error flag to remove events containing unphysical events (Ekin > Ebullet).
+    }
+    else {
+      varntp->ntrack = -1;
+    }
+    varntp->pxrem = pxrem;
+    varntp->pyrem = pyrem;
+    varntp->pzrem = pzrem;
+    varntp->mcorem = mcorem;
+    varntp->erecrem = pcorem;
+    varntp->erecrem = erecrem;
+#ifdef G4INCLDEBUG
+    theLogger->fillHistogram1D("bimpact", varntp->bimpact);
+#endif
+#ifdef G4INCLDEBUG
+    theLogger->fillHistogram1D("mzini", varntp->mzini);
+#endif
+  }
+  if(nopart == -2) {
+    varntp->ntrack = -2; //FIX: Error flag to remove events containing unphysical events (Ekin > Ebullet).
+    evaporationResult->ntrack = -2; //FIX: Error flag to remove events containing unphysical events (Ekin > Ebullet).
+  }
+  else if(nopart == -1) {
+    varntp->ntrack = -1;
+    evaporationResult->ntrack = -1;
+  }
+  if(verboseLevel > 2) {
+    G4cout << __FILE__ << ":" << __LINE__ << "Dump varntp after combining: " << G4endl;
+    varntp->dump();
+  }
+}
 …
+}
+void G4Incl::standardRandom(G4double *rndm, G4long *seed)
+{
+  (*seed) = (*seed); // Avoid warning during compilation.
+void G4Incl::standardRandom(G4double *rndm, G4long*)
+{
   // Use Geant4 G4UniformRand
   //  (*rndm) = G4UniformRand();
 …
     } // enddo
     G4double p_spec2=std::pow(p1_spec,2)+std::pow(p2_spec,2)+std::pow(p3_spec,2);
     G4double s_spec = sqrt(std::pow(e_spec,2)-p_spec2);
+    G4double s_spec = std::sqrt(std::pow(e_spec,2)-p_spec2);
     // no projectile spectator if a>=4 and a=z or a=n (no dresner breakup)
 …
+}
+// Initialization helper
+void G4Incl::clearState() {
+  G4int epSize = 300;
+  for(G4int i = 0; i < epSize; ++i) {
+    kind[i] = 0;
+    ep[i] = 0.0;
+    alpha[i] = 0.0;
+    beta[i] = 0.0;
+    gam[i] = 0.0;
+  }
+  inside_step = 0;
+}
 // C------------------------------------------------------------------------
 // C Logging
 …
 //       COMMON/BL2/CROIS(19900),K,IND(20000),JND(20000)
 //       COMMON/BL3/R1,R2,X1(300),X2(300),X3(300),IA1,IA2,RAB2             P-N22270
+  if(index < 0) {
+    G4cout <<";; Error! index < 0! index = " << index << G4endl;
+    return;
+  }
   G4int i_ind1 = bl1->ind1[bl2->ind[index]];

trunk/source/processes/hadronic/models/incl/src/G4InclAblaCascadeInterface.cc

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4InclAblaCascadeInterface.cc,v 1.16 2010/10/29 06:48:43 gunter Exp $
+// $Id: G4InclAblaCascadeInterface.cc,v 1.20 2010/11/17 20:19:09 kaitanie Exp $
 // Translation of INCL4.2/ABLA V3
 // Pekka Kaitaniemi, HIP (translation)
 …
   incl->setInput(calincl);
   G4InclInput::printProjectileTargetInfo(aTrack, theNucleus);
   calincl->printInfo();
+  //  G4InclInput::printProjectileTargetInfo(aTrack, theNucleus);
+  //  calincl->printInfo();
 #ifdef DEBUGINCL
 …
+        }
+      }
+      delete theFermiBreakupResult;
+      theFermiBreakupResult = 0;
       if(std::abs(fourMomentumBalance.mag() / MeV) > 0.1 * MeV) {
         G4cout <<"Four-momentum balance after remnant nucleus Fermi break-up:" << G4endl;

trunk/source/processes/hadronic/models/incl/src/G4InclAblaDataFile.cc

-              r1337
+              r1347
 // ********************************************************************
 //
 // $Id: G4InclAblaDataFile.cc,v 1.9 2010/06/14 16:10:01 gcosmo Exp $
+// $Id: G4InclAblaDataFile.cc,v 1.10 2010/11/17 20:19:09 kaitanie Exp $
 // Translation of INCL4.2/ABLA V3
 // Pekka Kaitaniemi, HIP (translation)
 …
   vgsldin.close();
-  int A = 0, Zbegin = 0, Zend = 0;
   G4String str1, str2, str3;
   for(int i = 0; i < 500; i++) {
 …
+  }
+  int A = 0, Zbegin = 0, Zend = 0;
   for(int i = 0; i < massnumbers; i++) {
     pace2in >> str1 >> A >> str2 >> Zbegin >> str3 >> Zend;
+    for(int j = Zbegin; j <= Zend; j++) {
+      pace2in >> pace2;
+      setPace2(A, j, pace2);
+    if(Zbegin >= 0 && Zbegin < getPaceCols() &&
+       A >= 0 && A < getPaceRows()) {
+      for(int j = Zbegin; j <= Zend; j++) {
+        pace2in >> pace2;
+        setPace2(A, j, pace2);
+      }
+    }
+  }

trunk/source/processes/hadronic/models/incl/src/G4InclAblaLightIonInterface.cc

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4InclAblaLightIonInterface.cc,v 1.14 2010/10/29 06:48:43 gunter Exp $
+// $Id: G4InclAblaLightIonInterface.cc,v 1.16 2010/11/17 20:19:09 kaitanie Exp $
 // Translation of INCL4.2/ABLA V3
 // Pekka Kaitaniemi, HIP (translation)
 …
+  }
-  if(verboseLevel > 1) {
-    G4Calincl::printProjectileTargetInfo(aTrack, theNucleus);
+  }
   // Inverse kinematics for targets with Z = 1 and A = 1
   //  if(false) {
   G4LorentzRotation toBreit = aTrack.Get4Momentum().boostVector();
   if(theNucleus.GetZ_asInt() == 1 && theNucleus.GetA_asInt() == 1 && G4Calincl::canUseInverseKinematics(aTrack, theNucleus)) {
+  if(theNucleus.GetZ_asInt() == 1 && theNucleus.GetA_asInt() == 1 && G4InclInput::canUseInverseKinematics(aTrack, theNucleus)) {
     G4ParticleDefinition *oldTargetDef = theTableOfParticles->GetIon(theNucleus.GetA_asInt(), theNucleus.GetZ_asInt(), 0.0);
     const G4ParticleDefinition *oldProjectileDef = aTrack.GetDefinition();
+    if(oldProjectileDef != 0 && oldTargetDef != 0) {
     G4int oldTargetA = oldTargetDef->GetAtomicMass();
     G4int newTargetA = oldProjectileDef->GetAtomicMass();
     G4int newTargetZ = oldProjectileDef->GetAtomicNumber();
     if(newTargetA > 0 && newTargetZ > 0 && oldTargetDef != 0 && oldProjectileDef != 0) {
+    if(newTargetA > 0 && newTargetZ > 0) {
       G4Nucleus swappedTarget(oldProjectileDef->GetAtomicMass(), oldProjectileDef->GetAtomicNumber());
 …
       G4cout <<"Badly defined target after swapping. Falling back to normal (non-swapped) mode." << G4endl;
       calincl = new G4InclInput(aTrack, theNucleus, false);
+    }
+    }
   } else {
 …
+        }
+      }
+      delete theSpectatorFermiBreakupResult;
+      theSpectatorFermiBreakupResult = 0;
       if(std::abs(fourMomentumBalance.mag() / MeV) > 0.1 * MeV) {
         G4cout <<"Four-momentum balance after spectator nucleus Fermi break-up:" << G4endl;
 …
+        }
+      }
+      delete theFermiBreakupResult;
+      theFermiBreakupResult = 0;
       if(std::abs(fourMomentumBalance.mag() / MeV) > 0.1 * MeV) {
         G4cout <<"Four-momentum balance after remnant nucleus Fermi break-up:" << G4endl;
 …
+  }
+  delete fermiBreakUp;
   delete calincl;
   calincl = 0;

trunk/source/processes/hadronic/models/incl/src/G4InclCascadeInterface.cc

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4InclCascadeInterface.cc,v 1.12 2010/10/26 02:47:59 kaitanie Exp $
+// $Id: G4InclCascadeInterface.cc,v 1.15 2010/11/17 20:19:09 kaitanie Exp $
 // Translation of INCL4.2/ABLA V3
 // Pekka Kaitaniemi, HIP (translation)
 …
 #include "G4InclCascadeInterface.hh"
+#include "G4FermiBreakUp.hh"
 #include "math.h"
 #include "G4GenericIon.hh"
 #include "CLHEP/Random/Random.h"
+G4InclCascadeInterface::G4InclCascadeInterface()
+G4InclCascadeInterface::G4InclCascadeInterface(const G4String& nam)
+  :G4VIntraNuclearTransportModel(nam)
+{
   hazard = new G4Hazard();
 …
   varntp = new G4VarNtp();
   inclInput = 0;
+  calincl = 0;
   ws = new G4Ws();
   mat = new G4Mat();
+  incl = new G4Incl(hazard, inclInput, ws, mat, varntp);
+  incl = new G4Incl(hazard, calincl, ws, mat, varntp);
+  theExcitationHandler = new G4ExcitationHandler;
+  thePrecoModel = new G4PreCompoundModel(theExcitationHandler);
+  if(!getenv("G4INCLABLANOFERMIBREAKUP")) { // Use Fermi Break-up by default if it is NOT explicitly disabled
+    incl->setUseFermiBreakUp(true);
+  }
   verboseLevel = 0;
 …
 G4InclCascadeInterface::~G4InclCascadeInterface()
+{
+  delete thePrecoModel;
+  delete theExcitationHandler;
   delete hazard;
   delete varntp;
-  delete inclInput;
   delete ws;
   delete mat;
 …
   G4int particleI;
+  G4int bulletType = 0;
   // Print diagnostic messages: 0 = silent, 1 and 2 = verbose
 …
   G4DynamicParticle *cascadeParticle = 0;
   G4ParticleDefinition *aParticleDefinition = 0;
+  G4ReactionProductVector *thePrecoResult = 0;
+  G4ParticleTable *theTableOfParticles = G4ParticleTable::GetParticleTable();
   // INCL assumes the projectile particle is going in the direction of
 …
   G4LorentzRotation toLabFrame = toZ.inverse();
-  inclInput = new G4InclInput(aTrack, theNucleus, false);
   theResult.Clear(); // Make sure the output data structure is clean.
+  calincl = new G4InclInput(aTrack, theNucleus, false);
+  incl->setInput(calincl);
+  //  G4InclInput::printProjectileTargetInfo(aTrack, theNucleus);
+  //  calincl->printInfo();
 #ifdef DEBUGINCL
 …
   G4double eKinSum = bulletE;
   G4LorentzVector labv = G4LorentzVector(0.0, 0.0, std::sqrt(bulletE*(bulletE + 2.*mass)), bulletE + mass + amass);
+  G4LorentzVector labvA = G4LorentzVector(0.0, 0.0, 0.0, 0.0);
   G4cout <<"Energy in the beginning = " << labv.e() / MeV << G4endl;
 #endif
   // Check wheter the input is acceptable.
   if((inclInput->bulletType() != 0) && ((inclInput->targetA() != 1) && (inclInput->targetZ() != 1))) {
+  if((calincl->bulletType() != 0) && ((calincl->targetA() != 1) && (calincl->targetZ() != 1))) {
     ws->nosurf = -2;  // Nucleus surface, -2 = Woods-Saxon
     ws->xfoisa = 8;
 …
     mat->nbmat = 1;
     mat->amat[0] = int(inclInput->targetA());
     mat->zmat[0] = int(inclInput->targetZ());
+    mat->amat[0] = int(calincl->targetA());
+    mat->zmat[0] = int(calincl->targetZ());
     incl->initIncl(true);
 …
         G4cout <<"G4InclCascadeInterface: Try number = " << nTries << G4endl;
+      }
       incl->processEventIncl(inclInput);
+      incl->processEventIncl(calincl);
       if(verboseLevel > 1) {
 …
        * Diagnostic output
        */
       G4cout <<"G4InclCascadeInterface: Bullet type: " << inclInput->bulletType() << G4endl;
       G4cout <<"G4Incl4AblaCascadeInterface: Bullet energy: " << inclInput->bulletE() << " MeV" << G4endl;
       G4cout <<"G4InclCascadeInterface: Target A:  " << inclInput->targetA() << G4endl;
       G4cout <<"G4InclCascadeInterface: Target Z:  " << inclInput->targetZ() << G4endl;
+      G4cout <<"G4InclCascadeInterface: Bullet type: " << calincl->bulletType() << G4endl;
+      G4cout <<"G4Incl4AblaCascadeInterface: Bullet energy: " << calincl->bulletE() << " MeV" << G4endl;
+      G4cout <<"G4InclCascadeInterface: Target A:  " << calincl->targetA() << G4endl;
+      G4cout <<"G4InclCascadeInterface: Target Z:  " << calincl->targetZ() << G4endl;
       if(verboseLevel > 3) {
         diagdata <<"G4InclCascadeInterface: Bullet type: " << inclInput->bulletType() << G4endl;
         diagdata <<"G4InclCascadeInterface: Bullet energy: " << inclInput->bulletE() << " MeV" << G4endl;
+        diagdata <<"G4InclCascadeInterface: Bullet type: " << calincl->bulletType() << G4endl;
+        diagdata <<"G4InclCascadeInterface: Bullet energy: " << calincl->bulletE() << " MeV" << G4endl;
+        diagdata <<"G4InclCascadeInterface: Target A:  " << inclInput->targetA() << G4endl;
+        diagdata <<"G4InclCascadeInterface: Target Z:  " << inclInput->targetZ() << G4endl;
+      }
+      // for(particleI = 0; particleI < varntp->ntrack; particleI++) {
+      //   G4cout << n                       << " " << inclInput->f[6]             << " " << inclInput->f[2] << " ";
+      //   G4cout << varntp->massini         << " " << varntp->mzini             << " ";
+      //   G4cout << varntp->exini           << " " << varntp->mulncasc          << " " << varntp->mulnevap          << " " << varntp->mulntot << " ";
+      //   G4cout << varntp->bimpact         << " " << varntp->jremn             << " " << varntp->kfis              << " " << varntp->estfis << " ";
+      //   G4cout << varntp->izfis           << " " << varntp->iafis             << " " << varntp->ntrack            << " " << varntp->itypcasc[particleI] << " ";
+      //   G4cout << varntp->avv[particleI]  << " " << varntp->zvv[particleI]    << " " << varntp->enerj[particleI]  << " ";
+      //   G4cout << varntp->plab[particleI] << " " << varntp->tetlab[particleI] << " " << varntp->philab[particleI] << G4endl;
+      //   // For diagnostic output
+      //   if(verboseLevel > 3) {
+      //     diagdata << n                       << " " << inclInput->f[6]             << " " << inclInput->f[2] << " ";
+      //     diagdata << varntp->massini         << " " << varntp->mzini             << " ";
+      //     diagdata << varntp->exini           << " " << varntp->mulncasc          << " " << varntp->mulnevap          << " " << varntp->mulntot << " ";
+      //     diagdata << varntp->bimpact         << " " << varntp->jremn             << " " << varntp->kfis              << " " << varntp->estfis << " ";
+      //     diagdata << varntp->izfis           << " " << varntp->iafis             << " " << varntp->ntrack            << " ";
+      //          diagdata                                                                       << varntp->itypcasc[particleI] << " ";
+      //     diagdata << varntp->avv[particleI]  << " " << varntp->zvv[particleI]    << " " << varntp->enerj[particleI]  << " ";
+      //     diagdata << varntp->plab[particleI] << " " << varntp->tetlab[particleI] << " " << varntp->philab[particleI] << G4endl;
+      //   }
+      // }
+        diagdata <<"G4InclCascadeInterface: Target A:  " << calincl->targetA() << G4endl;
+        diagdata <<"G4InclCascadeInterface: Target Z:  " << calincl->targetZ() << G4endl;
+      }
+    }
 …
       theResult.SetStatusChange(stopAndKill);
+      aParticleDefinition = G4InclInput::getParticleDefinition(inclInput->bulletType());
+      cascadeParticle = new G4DynamicParticle();
+      cascadeParticle->SetDefinition(aParticleDefinition);
+      cascadeParticle->Set4Momentum(aTrack.Get4Momentum());
+      theResult.AddSecondary(cascadeParticle);
+      G4int bulletType = calincl->bulletType();
+      aParticleDefinition = G4InclInput::getParticleDefinition(bulletType);
+      if(aParticleDefinition != 0) {
+        cascadeParticle = new G4DynamicParticle();
+        cascadeParticle->SetDefinition(aParticleDefinition);
+        cascadeParticle->Set4Momentum(aTrack.Get4Momentum());
+        theResult.AddSecondary(cascadeParticle);
+      }
+    }
 …
 #ifdef DEBUGINCL
+    G4cout << "E [MeV]" << std::setw(12) << " Ekin [MeV]" << std::setw(12) << " E* [MeV]" << std::setw(12) << "Px [MeV]" << std::setw(12) << " Py [MeV]" << std::setw(12) << "Pz [MeV]" << std::setw(12) << "Pt [MeV]" << std::setw(12) << "A" << std::setw(12) << "Z" << G4endl;
+    G4cout << "E [MeV]" << std::setw(12)
+           << " Ekin [MeV]" << std::setw(12)
+           << "Px [MeV]" << std::setw(12)
+           << " Py [MeV]" << std::setw(12)
+           << "Pz [MeV]" << std::setw(12)
+           << "Pt [MeV]" << std::setw(12)
+           << "A" << std::setw(12)
+           << "Z" << G4endl;
 #endif
 …
       if((varntp->avv[particleI] > 1) && (varntp->zvv[particleI] >= 1)) { // Nucleus fragment
         G4ParticleDefinition * aIonDef = 0;
-        G4ParticleTable *theTableOfParticles = G4ParticleTable::GetParticleTable();
         G4int A = G4int(varntp->avv[particleI]);
 …
         G4double p = mom.mag();
         labv -= fm;
+        G4double px = mom.x() * MeV;
+        G4double py = mom.y() * MeV;
+        G4double pz = mom.z() * MeV;
+        if(varntp->avv[particleI] > 1) {
+          labvA += fm;
+        }
+        G4double px = mom.x() * MeV;
+        G4double py = mom.y() * MeV;
+        G4double pz = mom.z() * MeV;
         G4double pt = std::sqrt(px*px+py*py);
         G4double e  = fm.e();
 …
         G4cout << fm.e() / MeV
                << std::setw(12) << cascadeParticle->GetKineticEnergy() / MeV
-               << std::setw(12) << exE / MeV
                << std::setw(12) << mom.x() / MeV
                << std::setw(12) << mom.y() / MeV
 …
+      }
+    }
+      G4double nuclearMass = G4NucleiProperties::GetNuclearMass(G4int(varntp->massini), G4int(varntp->mzini)) + varntp->exini * MeV;
+      G4LorentzVector fragmentMomentum(varntp->pxrem * MeV, varntp->pyrem * MeV, varntp->pzrem * MeV,
+                                       varntp->erecrem * MeV + nuclearMass);
+      G4double momentumScaling = G4InclUtils::calculate4MomentumScaling(G4int(varntp->massini), G4int(varntp->mzini),
+                                                                        varntp->exini,
+                                                                        varntp->erecrem,
+                                                                        varntp->pxrem,
+                                                                        varntp->pyrem,
+                                                                        varntp->pzrem);
+      G4LorentzVector p4(momentumScaling * varntp->pxrem * MeV, momentumScaling * varntp->pyrem * MeV,
+                         momentumScaling * varntp->pzrem * MeV,
+                         varntp->erecrem + nuclearMass);
+      // For four-momentum, baryon number and charge conservation check:
+      G4LorentzVector fourMomentumBalance = p4;
+      G4int baryonNumberBalance = G4int(varntp->massini);
+      G4int chargeBalance = G4int(varntp->mzini);
+      G4LorentzRotation toFragmentZ;
+      toFragmentZ.rotateZ(-p4.theta());
+      toFragmentZ.rotateY(-p4.phi());
+      G4LorentzRotation toFragmentLab = toFragmentZ.inverse();
+      p4 *= toFragmentZ;
+      G4LorentzVector p4rest = p4;
+      p4rest.boost(-p4.boostVector());
+      if(verboseLevel > 0) {
+        G4cout <<"Cascade remnant nucleus:" << G4endl;
+        G4cout <<"p4: " << G4endl;
+        G4cout <<" px: " << p4.px() <<" py: " << p4.py() <<" pz: " << p4.pz() << G4endl;
+        G4cout <<" E = " << p4.e() << G4endl;
+        G4cout <<"p4rest: " << G4endl;
+        G4cout <<" px: " << p4rest.px() <<" py: " << p4rest.py() <<" pz: " << p4rest.pz() << G4endl;
+        G4cout <<" E = " << p4rest.e() << G4endl;
+      }
+      G4Fragment theCascadeRemnant(G4int(varntp->massini), G4int(varntp->mzini), p4rest);
+      thePrecoResult = thePrecoModel->DeExcite(theCascadeRemnant);
+      if(thePrecoResult != 0) {
+      G4ReactionProductVector::iterator fragment;
+      for(fragment = thePrecoResult->begin(); fragment != thePrecoResult->end(); fragment++) {
+        G4ParticleDefinition *theFragmentDefinition = (*fragment)->GetDefinition();
+        if(theFragmentDefinition != 0) {
+          G4DynamicParticle *theFragment = new G4DynamicParticle(theFragmentDefinition, (*fragment)->GetMomentum());
+          G4LorentzVector labMomentum = theFragment->Get4Momentum();
+          labMomentum.boost(p4.boostVector());
+          labMomentum *= toFragmentLab;
+          labMomentum *= toLabFrame;
+          theFragment->Set4Momentum(labMomentum);
+          fourMomentumBalance -= theFragment->Get4Momentum();
+          baryonNumberBalance -= theFragmentDefinition->GetAtomicMass();
+          chargeBalance -= theFragmentDefinition->GetAtomicNumber();
+          if(verboseLevel > 0) {
+            G4cout <<"Resulting fragment: " << G4endl;
+            G4cout <<" kinetic energy = " << theFragment->GetKineticEnergy() / MeV << " MeV" << G4endl;
+            G4cout <<" momentum = " << theFragment->GetMomentum().mag() / MeV << " MeV" << G4endl;
+          }
+          theResult.AddSecondary(theFragment);
+        } else {
+          G4cout <<"G4InclCascadeInterface: Error. Fragment produced by Fermi break-up does not exist." << G4endl;
+          G4cout <<"Resulting fragment: " << G4endl;
+          G4cout <<" momentum = " << (*fragment)->GetMomentum().mag() / MeV << " MeV" << G4endl;
+        }
+      }
+      delete thePrecoResult;
+      thePrecoResult = 0;
+      if(verboseLevel > 1 && std::abs(fourMomentumBalance.mag() / MeV) > 0.1 * MeV) {
+        G4cout <<"Four-momentum balance after remnant nucleus Fermi break-up:" << G4endl;
+        G4cout <<"Magnitude: " << fourMomentumBalance.mag() / MeV << " MeV" << G4endl;
+        G4cout <<"Vector components (px, py, pz, E) = ("
+               << fourMomentumBalance.px() << ", "
+               << fourMomentumBalance.py() << ", "
+               << fourMomentumBalance.pz() << ", "
+               << fourMomentumBalance.e() << ")" << G4endl;
+      }
+      if(baryonNumberBalance != 0 && verboseLevel > 1) {
+        G4cout <<"Baryon number balance after remnant nucleus Fermi break-up: " << baryonNumberBalance << G4endl;
+      }
+      if(chargeBalance != 0 && verboseLevel > 1) {
+        G4cout <<"Charge balance after remnant nucleus Fermi break-up: " << chargeBalance << G4endl;
+      }
+      }
+      //    } // if(needsFermiBreakUp)
 #ifdef DEBUGINCL
     G4cout <<"--------------------------------------------------------------------------------" << G4endl;
     G4double pt = std::sqrt(std::pow(labv.x(), 2) + std::pow(labv.y(), 2));
+    G4cout << labv.e() / MeV << std::setw(12) << eKinSum / MeV << std::setw(12) << labv.x() << std::setw(12) << labv.y() << std::setw(12) << labv.z() << std::setw(12) <<  pt / MeV << std::setw(12) << baryonNumber << std::setw(12) << chargeNumber << " totals" << G4endl;
+    G4double ptA = std::sqrt(std::pow(labvA.x(), 2) + std::pow(labvA.y(), 2));
+    G4cout << labv.e() / MeV << std::setw(12)
+           << eKinSum  / MeV << std::setw(12)
+           << labv.x() / MeV << std::setw(12)
+           << labv.y() / MeV << std::setw(12)
+           << labv.z() / MeV << std::setw(12)
+           << pt       / MeV << std::setw(12)
+           << baryonNumber << std::setw(12)
+           << chargeNumber << " totals" << G4endl;
+    G4cout << " - " << std::setw(12)
+           << " - " << std::setw(12)
+           << labvA.x() / MeV << std::setw(12)
+           << labvA.y() / MeV << std::setw(12)
+           << labvA.z() / MeV << std::setw(12)
+           << ptA       / MeV << std::setw(12)
+           << " - " << std::setw(12) << " - " << " totals ABLA" << G4endl;
     G4cout << G4endl;
     if(verboseLevel > 3) {
       if(baryonNumber != 0) {
 …
+    }
 #endif
     varntp->ntrack = 0; // Clean up the number of generated particles in the event.
+  }
 …
     theResult.SetStatusChange(stopAndKill);
-    G4ParticleTable *theTableOfParticles = G4ParticleTable::GetParticleTable();
     cascadeParticle = new G4DynamicParticle(theTableOfParticles->FindParticle(aTrack.GetDefinition()), aTrack.Get4Momentum());
 …
+    }
     if(verboseLevel > 3) {
       diagdata <<"ERROR G4InclCascadeInterface: Processing event number (internal) failed " << eventNumber << G4endl;
+    }
     if(inclInput->bulletType() == 0) {
+      diagdata <<"ERROR G4InclCascadeInterface: Error processing event number (internal) failed " << eventNumber << G4endl;
+    }
+    if(bulletType == 0) {
       if(verboseLevel > 1) {
         G4cout <<"G4InclCascadeInterface: Unknown bullet type" << G4endl;
 …
+    }
     if((inclInput->targetA() == 1) && (inclInput->targetZ() == 1)) { // Unsupported target
+    if((calincl->targetA() == 1) && (calincl->targetZ() == 1)) { // Unsupported target
       if(verboseLevel > 1) {
         G4cout <<"Unsupported target: " << G4endl;
         G4cout <<"Target A: " << inclInput->targetA() << G4endl;
         G4cout <<"TargetZ: " << inclInput->targetZ() << G4endl;
+        G4cout <<"Target A: " << calincl->targetA() << G4endl;
+        G4cout <<"TargetZ: " << calincl->targetZ() << G4endl;
+      }
       if(verboseLevel > 3) {
         diagdata <<"Unsupported target: " << G4endl;
         diagdata <<"Target A: " << inclInput->targetA() << G4endl;
         diagdata <<"TargetZ: " << inclInput->targetZ() << G4endl;
+      }
+    }
     if(inclInput->bulletE() < 100) { // INCL does not support E < 100 MeV.
+        diagdata <<"Target A: " << calincl->targetA() << G4endl;
+        diagdata <<"TargetZ: " << calincl->targetZ() << G4endl;
+      }
+    }
+    if(calincl->bulletE() < 100) { // INCL does not support E < 100 MeV.
       if(verboseLevel > 1) {
         G4cout <<"Unsupported bullet energy: " << inclInput->bulletE() << " MeV. (Lower limit is 100 MeV)." << G4endl;
+        G4cout <<"Unsupported bullet energy: " << calincl->bulletE() << " MeV. (Lower limit is 100 MeV)." << G4endl;
         G4cout <<"WARNING: Returning the original bullet with original energy back to Geant4." << G4endl;
+      }
       if(verboseLevel > 3) {
         diagdata <<"Unsupported bullet energy: " << inclInput->bulletE() << " MeV. (Lower limit is 100 MeV)." << G4endl;
+        diagdata <<"Unsupported bullet energy: " << calincl->bulletE() << " MeV. (Lower limit is 100 MeV)." << G4endl;
+      }
+    }
 …
+  }
+  delete calincl;
+  calincl = 0;
   return &theResult;
+}

trunk/source/processes/hadronic/models/incl/src/G4InclLightIonInterface.cc

-              r1340
+              r1347
 // ********************************************************************
 //
 // $Id: G4InclLightIonInterface.cc,v 1.12 2010/10/26 02:47:59 kaitanie Exp $
+// $Id: G4InclLightIonInterface.cc,v 1.15 2010/11/17 20:19:09 kaitanie Exp $
 // Translation of INCL4.2/ABLA V3
 // Pekka Kaitaniemi, HIP (translation)
 …
 // Aatos Heikkinen, HIP (project coordination)
+#include <vector>
 #include "G4InclLightIonInterface.hh"
+#include "G4FermiBreakUp.hh"
 #include "math.h"
 #include "G4GenericIon.hh"
 …
+{
   hazard = new G4Hazard();
   const G4long* table_entry = CLHEP::HepRandom::getTheSeeds(); // Get random seed from CLHEP.
   hazard->ial = (*table_entry);
+  theExcitationHandler = new G4ExcitationHandler;
+  thePrecoModel = new G4PreCompoundModel(theExcitationHandler);
   varntp = new G4VarNtp();
 …
   mat = new G4Mat();
   incl = new G4Incl(hazard, calincl, ws, mat, varntp);
+  useProjectileSpectator = true;
+  useFermiBreakup = true;
+  incl->setUseProjectileSpectators(useProjectileSpectator);
+  if(!getenv("G4INCLABLANOFERMIBREAKUP")) { // Use Fermi Break-up by default if it is NOT explicitly disabled
+    incl->setUseFermiBreakUp(true);
+    useFermiBreakup = true;
+  }
   verboseLevel = 0;
+  if(getenv("G4INCLVERBOSE")) {
+    verboseLevel = 1;
+  }
+}
 G4InclLightIonInterface::~G4InclLightIonInterface()
+{
+  delete thePrecoModel;
+  delete theExcitationHandler;
   delete hazard;
   delete varntp;
 …
 G4HadFinalState* G4InclLightIonInterface::ApplyYourself(const G4HadProjectile& aTrack, G4Nucleus& theNucleus)
+{
+  //  const G4bool useFermiBreakup = false;
   G4int maxTries = 200;
-  G4int bulletType = 0;
   G4int particleI;
+  // Print diagnostic messages: 0 = silent, 1 and 2 = verbose
+  verboseLevel = 0;
+  G4int baryonNumberBalanceInINCL = 0;
+  G4int chargeNumberBalanceInINCL = 0;
+  G4ParticleTable *theTableOfParticles = G4ParticleTable::GetParticleTable();
   // Increase the event number:
   eventNumber++;
+  // Clean up the INCL input
+  if(calincl != 0) {
+    delete calincl;
+    calincl = 0;
+  }
   if (verboseLevel > 1) {
     G4cout << " >>> G4InclLightIonInterface::ApplyYourself called" << G4endl;
 …
+  }
+  // INCL4 needs the energy in units MeV
+  G4double bulletE = aTrack.GetKineticEnergy() / MeV;
+  G4int targetA = theNucleus.GetA_asInt();
+  G4int targetZ = theNucleus.GetZ_asInt();
+  // Inverse kinematics for targets with Z = 1 and A = 1
+  //  if(false) {
+  G4LorentzRotation toBreit = aTrack.Get4Momentum().boostVector();
+  if(theNucleus.GetZ_asInt() == 1 && theNucleus.GetA_asInt() == 1 && G4InclInput::canUseInverseKinematics(aTrack, theNucleus)) {
+    G4ParticleDefinition *oldTargetDef = theTableOfParticles->GetIon(theNucleus.GetA_asInt(), theNucleus.GetZ_asInt(), 0.0);
+    const G4ParticleDefinition *oldProjectileDef = aTrack.GetDefinition();
+    if(oldTargetDef != 0 && oldProjectileDef != 0) {
+    G4int oldTargetA = oldTargetDef->GetAtomicMass();
+    G4int newTargetA = oldProjectileDef->GetAtomicMass();
+    G4int newTargetZ = oldProjectileDef->GetAtomicNumber();
+    if(newTargetA > 0 && newTargetZ > 0) {
+      G4Nucleus swappedTarget(oldProjectileDef->GetAtomicMass(), oldProjectileDef->GetAtomicNumber());
+      //      G4cout <<"Original projectile kinE = " << aTrack.GetKineticEnergy() / MeV << G4endl;
+      // We need the same energy/nucleon.
+      G4double projectileE = ((aTrack.GetKineticEnergy() / MeV) / newTargetA) * oldTargetA * MeV;
+      //    G4cout <<"projectileE = " << projectileE << G4endl;
+      G4DynamicParticle swappedProjectileParticle(oldTargetDef, G4ThreeVector(0.0, 0.0, 1.0), projectileE);
+      const G4LorentzVector swapped4Momentum = (swappedProjectileParticle.Get4Momentum()*=toBreit);
+      swappedProjectileParticle.Set4Momentum(swapped4Momentum);
+      const G4HadProjectile swappedProjectile(swappedProjectileParticle);
+      //  G4cout <<"New projectile kinE = " << swappedProjectile.GetKineticEnergy() / MeV << G4endl;
+      calincl = new G4InclInput(swappedProjectile, swappedTarget, true);
+    } else {
+      G4cout <<"Badly defined target after swapping. Falling back to normal (non-swapped) mode." << G4endl;
+      calincl = new G4InclInput(aTrack, theNucleus, false);
+    }
+    }
+  } else {
+    calincl = new G4InclInput(aTrack, theNucleus, false);
+  }
   G4double eKin;
 …
   G4LorentzRotation toLabFrame = toZ.inverse();
+  /*
+  G4cout <<"Projectile theta = " << projectileMomentum.theta() << " phi = " << projectileMomentum.phi() << G4endl;
+  G4cout <<"Projectile momentum "
+         << "(px = " << projectileMomentum.px()
+         << ", py = " << projectileMomentum.py()
+         << ", pz = " << projectileMomentum.pz() << ")" << G4endl;
+  G4cout << "Projectile energy = " << bulletE << " MeV" << G4endl;
+  */
+  G4ReactionProductVector *thePrecoResult = 0;
+  G4ReactionProductVector *theSpectatorPrecoResult = 0;
   theResult.Clear(); // Make sure the output data structure is clean.
+  std::vector<G4DynamicParticle*> result; // Temporary list for the results
   // Map Geant4 particle types to corresponding INCL4 types.
   enum bulletParticleType {nucleus = 0, proton = 1, neutron = 2, pionPlus = 3, pionZero = 4,
+                           pionMinus = 5, deuteron = 6, triton = 7, he3 = 8, he4 = 9};
+  // Coding particles for use with INCL4 and ABLA
+  if (aTrack.GetDefinition() == G4Deuteron::Deuteron()   ) bulletType = deuteron;
+  if (aTrack.GetDefinition() == G4Triton::Triton()       ) bulletType = triton;
+  if (aTrack.GetDefinition() == G4He3::He3()             ) bulletType = he3;
+  if (aTrack.GetDefinition() == G4Alpha::Alpha()         ) bulletType = he4;
+  calincl = new G4InclInput();
+                           pionMinus = 5, deuteron = 6, triton = 7, he3 = 8, he4 = 9,
+                           c12 = -12}; // Carbon beam support.
+  G4int bulletType = calincl->bulletType();
+  chargeNumberBalanceInINCL = calincl->targetZ();
+  baryonNumberBalanceInINCL = calincl->targetA();
+  //  G4cout <<"Type of the projectile (INCL projectile code): " << bulletType << G4endl;
+  if(bulletType == proton) {
+    chargeNumberBalanceInINCL += 1;
+    baryonNumberBalanceInINCL += 1;
+  } else if(bulletType == neutron) {
+    baryonNumberBalanceInINCL += 1;
+  } else if(bulletType == pionPlus) { //Note: positive pion doesn't contribute to the baryon and charge number counters
+    chargeNumberBalanceInINCL += 1;
+  } else if(bulletType == pionMinus) {
+    chargeNumberBalanceInINCL -= 1;
+  } else if(bulletType == deuteron) {
+    chargeNumberBalanceInINCL += 1;
+    baryonNumberBalanceInINCL += 2;
+  } else if(bulletType == triton) {
+    chargeNumberBalanceInINCL += 1;
+    baryonNumberBalanceInINCL += 3;
+  } else if(bulletType == he3) {
+    chargeNumberBalanceInINCL += 2;
+    baryonNumberBalanceInINCL += 3;
+  } else if(bulletType == he4) {
+    chargeNumberBalanceInINCL += 2;
+    baryonNumberBalanceInINCL += 4;
+  } if(bulletType == c12) {
+    chargeNumberBalanceInINCL += 6;
+    baryonNumberBalanceInINCL += 12;
+  } if(bulletType == -666) {
+    chargeNumberBalanceInINCL += calincl->extendedProjectileZ();
+    baryonNumberBalanceInINCL += calincl->extendedProjectileA();
+  }
   // Check wheter the input is acceptable.
   if((bulletType != 0) && ((targetA != 1) && (targetZ != 1))) {
+  if((bulletType != 0) && ((calincl->targetA() != 1) && (calincl->targetZ() != 1))) {
     ws->nosurf = -2;  // Nucleus surface, -2 = Woods-Saxon
     ws->xfoisa = 8;
 …
     mat->nbmat = 1;
     mat->amat[0] = int(calincl->targetA());
+    mat->zmat[0] = int(calincl->targetZ());
+    mat->zmat[0] = int(calincl->targetA());
+    incl->setInput(calincl);
     incl->initIncl(true);
 …
        * Diagnostic output
        */
+      G4cout <<"G4InclLightIonInterface: Bullet type: " << bulletType << G4endl;
+      G4cout <<"G4Incl4AblaCascadeInterface: Bullet energy: " << bulletE << " MeV" << G4endl;
+      G4cout <<"G4InclLightIonInterface: Target A:  " << targetA << G4endl;
+      G4cout <<"G4InclLightIonInterface: Target Z:  " << targetZ << G4endl;
+      G4cout <<"G4InclLightIonInterface: Bullet type: " << calincl->bulletType() << G4endl;
+      G4cout <<"G4Incl4AblaCascadeInterface: Bullet energy: " << calincl->bulletE() << " MeV" << G4endl;
+      if(bulletType == -666) {
+        G4cout <<"   Extended projectile: A = " << calincl->extendedProjectileA()
+               <<" Z = " << calincl->extendedProjectileZ() << G4endl;
+      }
+      G4cout <<"G4InclLightIonInterface: Target A:  " << calincl->targetA() << G4endl;
+      G4cout <<"G4InclLightIonInterface: Target Z:  " << calincl->targetZ() << G4endl;
       if(verboseLevel > 3) {
         diagdata <<"G4InclLightIonInterface: Bullet type: " << bulletType << G4endl;
         diagdata <<"G4InclLightIonInterface: Bullet energy: " << bulletE << " MeV" << G4endl;
+        diagdata <<"G4InclLightIonInterface: Bullet type: " << calincl->bulletType() << G4endl;
+        diagdata <<"G4InclLightIonInterface: Bullet energy: " << calincl->bulletE() << " MeV" << G4endl;
         diagdata <<"G4InclLightIonInterface: Target A:  " << targetA << G4endl;
         diagdata <<"G4InclLightIonInterface: Target Z:  " << targetZ << G4endl;
+        diagdata <<"G4InclLightIonInterface: Target A:  " << calincl->targetA() << G4endl;
+        diagdata <<"G4InclLightIonInterface: Target Z:  " << calincl->targetZ() << G4endl;
+      }
+    }
 …
       if(bulletType == proton) {
         aParticleDefinition = G4Proton::ProtonDefinition();
+      }
+      if(bulletType == neutron) {
+      } else if(bulletType == neutron) {
         aParticleDefinition = G4Neutron::NeutronDefinition();
+      }
+      if(bulletType == pionPlus) {
+      } else if(bulletType == pionPlus) {
         aParticleDefinition = G4PionPlus::PionPlusDefinition();
+      }
+      if(bulletType == pionZero) {
+      } else if(bulletType == pionZero) {
         aParticleDefinition = G4PionZero::PionZeroDefinition();
+      }
+      if(bulletType == pionMinus) {
+      } else if(bulletType == pionMinus) {
         aParticleDefinition = G4PionMinus::PionMinusDefinition();
+      }
+      cascadeParticle = new G4DynamicParticle();
+      cascadeParticle->SetDefinition(aParticleDefinition);
+      cascadeParticle->Set4Momentum(aTrack.Get4Momentum());
+      theResult.AddSecondary(cascadeParticle);
+      } else if(bulletType == deuteron) {
+        aParticleDefinition = G4Deuteron::DeuteronDefinition();
+      } else if(bulletType == triton) {
+        aParticleDefinition = G4Triton::TritonDefinition();
+      } else if(bulletType == he3) {
+        aParticleDefinition = G4He3::He3Definition();
+      } else if(bulletType == he4) {
+        aParticleDefinition = G4Alpha::AlphaDefinition();
+      } else { // Particle was not recognized. Probably an unsupported particle was given as input
+        aParticleDefinition = 0;
+      }
+      if(aParticleDefinition != 0) {
+        cascadeParticle = new G4DynamicParticle();
+        cascadeParticle->SetDefinition(aParticleDefinition);
+        cascadeParticle->Set4Momentum(aTrack.Get4Momentum());
+        result.push_back(cascadeParticle);
+      }
+    }
 …
     theResult.SetStatusChange(stopAndKill);
     for(particleI = 0; particleI < varntp->ntrack; particleI++) { // Loop through the INCL4+ABLA output.
+    for(particleI = 0; particleI <= varntp->ntrack; particleI++) { // Loop through the INCL4+ABLA output.
       // Get energy/momentum and construct momentum vector in INCL4 coordinates.
+      //      if(varntp->itypcasc[particleI] == -1) continue; // Avoid nucleons that are part of the spectator
+      if(varntp->avv[particleI] == 0 && varntp->zvv[particleI] == 0) continue;
       momx = varntp->plab[particleI]*std::sin(varntp->tetlab[particleI]*CLHEP::pi/180.0)*std::cos(varntp->philab[particleI]*CLHEP::pi/180.0)*MeV;
       momy = varntp->plab[particleI]*std::sin(varntp->tetlab[particleI]*CLHEP::pi/180.0)*std::sin(varntp->philab[particleI]*CLHEP::pi/180.0)*MeV;
 …
           new G4DynamicParticle(G4Proton::ProtonDefinition(), momDirection, eKin);
         particleIdentified++;
+        baryonNumberBalanceInINCL -= 1;
+        chargeNumberBalanceInINCL -= 1;
+      }
 …
           new G4DynamicParticle(G4Neutron::NeutronDefinition(), momDirection, eKin);
         particleIdentified++;
+        baryonNumberBalanceInINCL -= 1;
+      }
 …
           new G4DynamicParticle(G4PionPlus::PionPlusDefinition(), momDirection, eKin);
         particleIdentified++;
+        chargeNumberBalanceInINCL -= 1;
+      }
 …
           new G4DynamicParticle(G4PionZero::PionZeroDefinition(), momDirection, eKin);
         particleIdentified++;
+        chargeNumberBalanceInINCL -= 0;
+      }
 …
           new G4DynamicParticle(G4PionMinus::PionMinusDefinition(), momDirection, eKin);
         particleIdentified++;
+        chargeNumberBalanceInINCL -= -1;
+      }
       if((varntp->avv[particleI] > 1) && (varntp->zvv[particleI] >= 1)) { // Nucleus fragment
+        G4ParticleDefinition * aIonDef = 0;
+        G4ParticleTable *theTableOfParticles = G4ParticleTable::GetParticleTable();
+        G4ParticleDefinition * aIonDef = 0;
         G4int A = G4int(varntp->avv[particleI]);
 …
             new G4DynamicParticle(aIonDef, momDirection, eKin);
           particleIdentified++;
+          baryonNumberBalanceInINCL -= A;
+          chargeNumberBalanceInINCL -= Z;
+        }
+      }
       if(particleIdentified == 1) { // Particle identified properly.
         cascadeParticle->Set4Momentum(cascadeParticle->Get4Momentum()*=toLabFrame);
         theResult.AddSecondary(cascadeParticle); // Put data into G4HadFinalState.
+        cascadeParticle->Set4Momentum(cascadeParticle->Get4Momentum()*=toLabFrame);
+        result.push_back(cascadeParticle);
+      }
       else { // Particle identification failed.
 …
+    }
+    // Spectator nucleus Fermi break-up
+    if(useFermiBreakup && useProjectileSpectator && varntp->masp > 1) {
+      baryonNumberBalanceInINCL -= G4int(varntp->masp);
+      G4double nuclearMass = G4NucleiProperties::GetNuclearMass(G4int(varntp->masp), G4int(varntp->mzsp)) + varntp->exsp * MeV;
+      // Use momentum scaling to compensate for different masses in G4 and INCL:
+      G4double momentumScaling = G4InclUtils::calculate4MomentumScaling(G4int(varntp->masp),
+                                                                        G4int(varntp->mzsp),
+                                                                        varntp->exsp,
+                                                                        varntp->spectatorT,
+                                                                        varntp->spectatorP1,
+                                                                        varntp->spectatorP2,
+                                                                        varntp->spectatorP3);
+      G4LorentzVector p4(momentumScaling * varntp->spectatorP1 * MeV, momentumScaling * varntp->spectatorP2 * MeV,
+                         momentumScaling * varntp->spectatorP3 * MeV,
+                         varntp->spectatorT * MeV + nuclearMass);
+      // Four-momentum, baryon number and charge balance:
+      G4LorentzVector fourMomentumBalance = p4;
+      G4int baryonNumberBalance = G4int(varntp->masp);
+      chargeNumberBalanceInINCL -= G4int(varntp->mzsp);
+      G4int chargeBalance = G4int(varntp->mzsp);
+      G4LorentzRotation toFragmentZ;
+      // Assume that Fermi breakup uses Z as the direction of the projectile
+      toFragmentZ.rotateZ(-p4.theta());
+      toFragmentZ.rotateY(-p4.phi());
+      G4LorentzRotation toFragmentLab = toFragmentZ.inverse();
+      p4 *= toFragmentZ;
+      G4LorentzVector p4rest = p4;
+      p4rest.boost(-p4.boostVector());
+      if(verboseLevel > 0) {
+        G4cout <<"Spectator nucleus:" << G4endl;
+        G4cout <<"p4: " << G4endl;
+        G4cout <<" px: " << p4.px() <<" py: " << p4.py() <<" pz: " << p4.pz() << G4endl;
+        G4cout <<" E = " << p4.e() << G4endl;
+        G4cout <<"p4rest: " << G4endl;
+        G4cout <<" px: " << p4rest.px() <<" py: " << p4rest.py() <<" pz: " << p4rest.pz() << G4endl;
+        G4cout <<" E = " << p4rest.e() << G4endl;
+      }
+      G4Fragment theSpectatorNucleus(G4int(varntp->masp), G4int(varntp->mzsp), p4rest);
+      theSpectatorPrecoResult = thePrecoModel->DeExcite(theSpectatorNucleus);
+      if(theSpectatorPrecoResult != 0) {
+      G4ReactionProductVector::iterator fragment;
+      for(fragment = theSpectatorPrecoResult->begin(); fragment != theSpectatorPrecoResult->end(); fragment++) {
+        G4ParticleDefinition *theFragmentDefinition = (*fragment)->GetDefinition();
+        if(theFragmentDefinition != 0) {
+          G4DynamicParticle *theFragment = new G4DynamicParticle(theFragmentDefinition, (*fragment)->GetMomentum());
+          G4LorentzVector labMomentum = theFragment->Get4Momentum();
+          labMomentum.boost(p4.boostVector());
+          labMomentum *= toFragmentLab;
+          labMomentum *= toLabFrame;
+          theFragment->Set4Momentum(labMomentum);
+          fourMomentumBalance -= theFragment->Get4Momentum();
+          baryonNumberBalance -= theFragmentDefinition->GetAtomicMass();
+          chargeBalance -= theFragmentDefinition->GetAtomicNumber();
+          if(verboseLevel > 0) {
+            G4cout <<"Resulting fragment: " << G4endl;
+            G4cout <<" kinetic energy = " << theFragment->GetKineticEnergy() / MeV << " MeV" << G4endl;
+            G4cout <<" momentum = " << theFragment->GetMomentum().mag() / MeV << " MeV" << G4endl;
+          }
+          theResult.AddSecondary(theFragment);
+        } else {
+          G4cout <<"G4InclCascadeInterface: Error. Fragment produced by Fermi break-up does not exist." << G4endl;
+          G4cout <<"Resulting fragment: " << G4endl;
+          G4cout <<" momentum = " << (*fragment)->GetMomentum().mag() / MeV << " MeV" << G4endl;
+        }
+      }
+      delete theSpectatorPrecoResult;
+      theSpectatorPrecoResult = 0;
+      if(verboseLevel > 1 && std::abs(fourMomentumBalance.mag() / MeV) > 0.1 * MeV) {
+        G4cout <<"Four-momentum balance after remnant nucleus Fermi break-up:" << G4endl;
+        G4cout <<"Magnitude: " << fourMomentumBalance.mag() / MeV << " MeV" << G4endl;
+        G4cout <<"Vector components (px, py, pz, E) = ("
+               << fourMomentumBalance.px() << ", "
+               << fourMomentumBalance.py() << ", "
+               << fourMomentumBalance.pz() << ", "
+               << fourMomentumBalance.e() << ")" << G4endl;
+      }
+      if(baryonNumberBalance != 0 && verboseLevel > 1) {
+        G4cout <<"Baryon number balance after remnant nucleus Fermi break-up: " << baryonNumberBalance << G4endl;
+      }
+      if(chargeBalance != 0 && verboseLevel > 1) {
+        G4cout <<"Charge balance after remnant nucleus Fermi break-up: " << chargeBalance << G4endl;
+      }
+      }
+    }
+    // Finally do Fermi break-up if needed
+    if(varntp->massini > 0) {
+      baryonNumberBalanceInINCL -= G4int(varntp->massini);
+      chargeNumberBalanceInINCL -= G4int(varntp->mzini);
+      // Call Fermi Break-up
+      G4double nuclearMass = G4NucleiProperties::GetNuclearMass(G4int(varntp->massini), G4int(varntp->mzini)) + varntp->exini * MeV;
+      G4LorentzVector fragmentMomentum(varntp->pxrem * MeV, varntp->pyrem * MeV, varntp->pzrem * MeV,
+                                       varntp->erecrem * MeV + nuclearMass);
+      G4double momentumScaling = G4InclUtils::calculate4MomentumScaling(G4int(varntp->massini), G4int(varntp->mzini),
+                                                                        varntp->exini,
+                                                                        varntp->erecrem,
+                                                                        varntp->pxrem,
+                                                                        varntp->pyrem,
+                                                                        varntp->pzrem);
+      G4LorentzVector p4(momentumScaling * varntp->pxrem * MeV, momentumScaling * varntp->pyrem * MeV,
+                         momentumScaling * varntp->pzrem * MeV,
+                         varntp->erecrem + nuclearMass);
+      // For four-momentum, baryon number and charge conservation check:
+      G4LorentzVector fourMomentumBalance = p4;
+      G4int baryonNumberBalance = G4int(varntp->massini);
+      G4int chargeBalance = G4int(varntp->mzini);
+      G4LorentzRotation toFragmentZ;
+      toFragmentZ.rotateZ(-p4.theta());
+      toFragmentZ.rotateY(-p4.phi());
+      G4LorentzRotation toFragmentLab = toFragmentZ.inverse();
+      p4 *= toFragmentZ;
+      G4LorentzVector p4rest = p4;
+      p4rest.boost(-p4.boostVector());
+      if(verboseLevel > 0) {
+        G4cout <<"Cascade remnant nucleus:" << G4endl;
+        G4cout <<"p4: " << G4endl;
+        G4cout <<" px: " << p4.px() <<" py: " << p4.py() <<" pz: " << p4.pz() << G4endl;
+        G4cout <<" E = " << p4.e() << G4endl;
+        G4cout <<"p4rest: " << G4endl;
+        G4cout <<" px: " << p4rest.px() <<" py: " << p4rest.py() <<" pz: " << p4rest.pz() << G4endl;
+        G4cout <<" E = " << p4rest.e() << G4endl;
+      }
+      G4Fragment theCascadeRemnant(G4int(varntp->massini), G4int(varntp->mzini), p4rest);
+      thePrecoResult = thePrecoModel->DeExcite(theCascadeRemnant);
+      if(thePrecoResult != 0) {
+      G4ReactionProductVector::iterator fragment;
+      for(fragment = thePrecoResult->begin(); fragment != thePrecoResult->end(); fragment++) {
+        G4ParticleDefinition *theFragmentDefinition = (*fragment)->GetDefinition();
+        if(theFragmentDefinition != 0) {
+          G4DynamicParticle *theFragment = new G4DynamicParticle(theFragmentDefinition, (*fragment)->GetMomentum());
+          G4LorentzVector labMomentum = theFragment->Get4Momentum();
+          labMomentum.boost(p4.boostVector());
+          labMomentum *= toFragmentLab;
+          labMomentum *= toLabFrame;
+          theFragment->Set4Momentum(labMomentum);
+          fourMomentumBalance -= theFragment->Get4Momentum();
+          baryonNumberBalance -= theFragmentDefinition->GetAtomicMass();
+          chargeBalance -= theFragmentDefinition->GetAtomicNumber();
+          if(verboseLevel > 0) {
+            G4cout <<"Resulting fragment: " << G4endl;
+            G4cout <<" kinetic energy = " << theFragment->GetKineticEnergy() / MeV << " MeV" << G4endl;
+            G4cout <<" momentum = " << theFragment->GetMomentum().mag() / MeV << " MeV" << G4endl;
+          }
+          theResult.AddSecondary(theFragment);
+        } else {
+          G4cout <<"G4InclCascadeInterface: Error. Fragment produced by Fermi break-up does not exist." << G4endl;
+          G4cout <<"Resulting fragment: " << G4endl;
+          G4cout <<" momentum = " << (*fragment)->GetMomentum().mag() / MeV << " MeV" << G4endl;
+        }
+      }
+      delete thePrecoResult;
+      thePrecoResult = 0;
+      if(verboseLevel > 1 && std::abs(fourMomentumBalance.mag() / MeV) > 0.1 * MeV) {
+        G4cout <<"Four-momentum balance after remnant nucleus Fermi break-up:" << G4endl;
+        G4cout <<"Magnitude: " << fourMomentumBalance.mag() / MeV << " MeV" << G4endl;
+        G4cout <<"Vector components (px, py, pz, E) = ("
+               << fourMomentumBalance.px() << ", "
+               << fourMomentumBalance.py() << ", "
+               << fourMomentumBalance.pz() << ", "
+               << fourMomentumBalance.e() << ")" << G4endl;
+      }
+      if(baryonNumberBalance != 0 && verboseLevel > 1) {
+        G4cout <<"Baryon number balance after remnant nucleus Fermi break-up: " << baryonNumberBalance << G4endl;
+      }
+      if(chargeBalance != 0 && verboseLevel > 1) {
+        G4cout <<"Charge balance after remnant nucleus Fermi break-up: " << chargeBalance << G4endl;
+      }
+      }
+    }
     varntp->ntrack = 0; // Clean up the number of generated particles in the event.
+    if(baryonNumberBalanceInINCL != 0 && verboseLevel > 1) {
+      G4cout <<"Event " << eventNumber <<": G4InclLightIonInterface: Baryon number conservation problem in INCL detected!" << G4endl;
+      G4cout <<"Baryon number balance: " << baryonNumberBalanceInINCL << G4endl;
+      if(baryonNumberBalanceInINCL < 0) {
+        G4cout <<"Event " << eventNumber <<": Too many outcoming baryons!" << G4endl;
+      } else if(baryonNumberBalanceInINCL > 0) {
+        G4cout <<"Event " << eventNumber <<": Too few outcoming baryons!" << G4endl;
+      }
+    }
+    if(chargeNumberBalanceInINCL != 0 && verboseLevel > 1) {
+      G4cout <<"Event " << eventNumber <<": G4InclLightIonInterface: Charge number conservation problem in INCL detected!" << G4endl;
+      G4cout <<"Event " << eventNumber <<": Charge number balance: " << chargeNumberBalanceInINCL << G4endl;
+    }
+  }
   /**
 …
     cascadeParticle = new G4DynamicParticle(theTableOfParticles->FindParticle(aTrack.GetDefinition()), aTrack.Get4Momentum());
     theResult.AddSecondary(cascadeParticle);
+    result.push_back(cascadeParticle);
     if(verboseLevel > 1) {
 …
         G4cout <<"G4InclLightIonInterface: Unknown bullet type" << G4endl;
         G4cout <<"Bullet particle name: " << cascadeParticle->GetDefinition()->GetParticleName() << G4endl;
+      }
+      }
       if(verboseLevel > 3) {
         diagdata <<"G4InclLightIonInterface: Unknown bullet type" << G4endl;
 …
+    }
     if((targetA == 1) && (targetZ == 1)) { // Unsupported target
+    if((calincl->targetA() == 1) && (calincl->targetZ() == 1)) { // Unsupported target
       if(verboseLevel > 1) {
         G4cout <<"Unsupported target: " << G4endl;
         G4cout <<"Target A: " << targetA << G4endl;
         G4cout <<"TargetZ: " << targetZ << G4endl;
+        G4cout <<"Target A: " << calincl->targetA() << G4endl;
+        G4cout <<"TargetZ: " << calincl->targetZ() << G4endl;
+      }
       if(verboseLevel > 3) {
         diagdata <<"Unsupported target: " << G4endl;
         diagdata <<"Target A: " << targetA << G4endl;
        diagdata <<"TargetZ: " << targetZ << G4endl;
+      }
+    }
     if(bulletE < 100) { // INCL does not support E < 100 MeV.
+        diagdata <<"Target A: " << calincl->targetA() << G4endl;
+        diagdata <<"TargetZ: " << calincl->targetZ() << G4endl;
+      }
+    }
+    if(calincl->bulletE() < 100) { // INCL does not support E < 100 MeV.
       if(verboseLevel > 1) {
         G4cout <<"Unsupported bullet energy: " << bulletE << " MeV. (Lower limit is 100 MeV)." << G4endl;
+        G4cout <<"Unsupported bullet energy: " << calincl->bulletE() << " MeV. (Lower limit is 100 MeV)." << G4endl;
         G4cout <<"WARNING: Returning the original bullet with original energy back to Geant4." << G4endl;
+      }
       if(verboseLevel > 3) {
+        diagdata <<"Unsupported bullet energy: " << bulletE << " MeV. (Lower limit is 100 MeV)." << G4endl;
+      }
+    }
+        diagdata <<"Unsupported bullet energy: " << calincl->bulletE() << " MeV. (Lower limit is 100 MeV)." << G4endl;
+      }
+    }
     if(verboseLevel > 3) {
       diagdata <<"WARNING: returning the original bullet with original energy back to Geant4." << G4endl;
 …
+  }
+  // Finally copy the accumulated secondaries into the result collection:
+  G4ThreeVector boostVector = aTrack.Get4Momentum().boostVector();
+  G4LorentzRotation boostBack = toBreit.inverse();
+  for(std::vector<G4DynamicParticle*>::iterator i = result.begin(); i != result.end(); ++i) {
+    // If the calculation was performed in inverse kinematics we have to
+    // convert the result back...
+    if(calincl->isInverseKinematics()) {
+      G4LorentzVector mom = (*i)->Get4Momentum();
+      mom.setPz(-1.0 * mom.pz()); // Reverse the z-component of the momentum vector
+      mom *= boostBack;
+      (*i)->Set4Momentum(mom);
+    }
+    theResult.AddSecondary((*i));
+  }
+  delete calincl;
+  calincl = 0;
   return &theResult;
+}

trunk/source/processes/hadronic/models/management/History

-              r1340
+              r1347
      * Please list in reverse chronological order (last date on top)
      ---------------------------------------------------------------
+November 2010  - G.Folger   (hadr-modman-V09-03-05)
+- G4VNuclearDensity: coverity warning: init data member in ctor
 September 2010 - G.Folger   (hadr-modman-V09-03-04)

trunk/source/processes/hadronic/models/neutron_hp/History

-              r1340
+              r1347
      ---------------------------------------------------------------
+December 2010  Tatsumi Koi (hadr-hpn-V09-03-12)
+-Bug fix Bugzilla/Geant4 Problem 1155
+        G4NeutronHPCaptureFS.cc
+December 2010  Tatsumi Koi (hadr-hpn-V09-03-11)
+-Delete Unnecessary warnings
+        G4NeutronHPInelasticBaseFS.cc
+November 2010  Tatsumi Koi (hadr-hpn-V09-03-10)
+-Change warning message for "repFlag == 2 && isoFlag != 1" case
+        G4NeutronHPPhotonDist.cc
+November 2010  Tatsumi Koi (hadr-hpn-V09-03-09)
+-Add Special treatment in Be9(n,2n)Be8(2a) case
+        G4NeutronHPInelasticBaseFS.cc
+-Add Safty for _nat_ data
+        G4NeutronHPInelasticCompFS.cc
+November 2010  Tatsumi Koi (hadr-hpn-V09-03-08)
+-Set lower limit for gamma energy
+        G4NeutronHPFinalState.cc
+November 2010  Tatsumi Koi (hadr-hpn-V09-03-07)
+-Bug fix in MF=6, LAW=2 case; contribution from E. Mendoza, D. Cano-Ott (CIEMAT)
+        G4NeutronHPDiscreteTwoBody.cc
 September 2010  Tatsumi Koi (hadr-hpn-V09-03-06)

trunk/source/processes/hadronic/models/neutron_hp/src/G4NeutronHPCaptureFS.cc

-              r962
+              r1347
 // 26-January-07 Add G4NEUTRONHP_USE_ONLY_PHOTONEVAPORATION flag
 // 081024 G4NucleiPropertiesTable:: to G4NucleiProperties::
+// 101203 Bugzilla/Geant4 Problem 1155 Lack of residual in some case
 //
 #include "G4NeutronHPCaptureFS.hh"
 …
   G4HadFinalState * G4NeutronHPCaptureFS::ApplyYourself(const G4HadProjectile & theTrack)
+  {
     G4int i;
     theResult.Clear();
 …
+    }
 // add them to the final state
 …
     G4int nParticles = nPhotons;
     if(1==nPhotons) nParticles = 2;
+//Make at least one photon
+//101203 TK
+    if ( nPhotons == 0 )
+    {
+       G4ReactionProduct * theOne = new G4ReactionProduct;
+       theOne->SetDefinition( G4Gamma::Gamma() );
+       G4double theta = pi*G4UniformRand();
+       G4double phi = twopi*G4UniformRand();
+       G4double sinth = std::sin(theta);
+       G4ThreeVector direction( sinth*std::cos(phi), sinth*std::sin(phi), std::cos(theta) );
+       theOne->SetMomentum( direction ) ;
+       thePhotons->push_back(theOne);
+       nPhotons++; // 0 -> 1
+    }
+//One photon case: energy set to Q-value
+//101203 TK
+    if ( nPhotons == 1 )
+    {
+       G4ThreeVector direction = thePhotons->operator[](0)->GetMomentum().unit();
+       G4double Q = G4ParticleTable::GetParticleTable()->FindIon(static_cast<G4int>(theBaseZ), static_cast<G4int>(theBaseA), 0, static_cast<G4int>(theBaseZ))->GetPDGMass() + G4Neutron::Neutron()->GetPDGMass()
+         - G4ParticleTable::GetParticleTable()->FindIon(static_cast<G4int>(theBaseZ), static_cast<G4int>(theBaseA+1), 0, static_cast<G4int>(theBaseZ))->GetPDGMass();
+       thePhotons->operator[](0)->SetMomentum( Q*direction );
+    }
+//
     // back to lab system
 …
+    }
     delete thePhotons;
+//101203TK
+    G4bool residual = false;
+    G4ParticleDefinition * aRecoil = G4ParticleTable::GetParticleTable()
+                                   ->FindIon(static_cast<G4int>(theBaseZ), static_cast<G4int>(theBaseA+1), 0, static_cast<G4int>(theBaseZ));
+    for ( G4int i = 0 ; i != theResult.GetNumberOfSecondaries() ; i++ )
+    {
+       if ( theResult.GetSecondary(i)->GetParticle()->GetDefinition() == aRecoil ) residual = true;
+    }
+    if ( residual == false )
+    {
+       G4ParticleDefinition * aRecoil = G4ParticleTable::GetParticleTable()
+                                        ->FindIon(static_cast<G4int>(theBaseZ), static_cast<G4int>(theBaseA+1), 0, static_cast<G4int>(theBaseZ));
+       G4int nNonZero = 0;
+       G4LorentzVector p_photons(0,0,0,0);
+       for ( G4int i = 0 ; i != theResult.GetNumberOfSecondaries() ; i++ )
+       {
+          p_photons += theResult.GetSecondary(i)->GetParticle()->Get4Momentum();
+          // To many 0 momentum photons -> Check PhotonDist
+          if ( theResult.GetSecondary(i)->GetParticle()->Get4Momentum() > 0 ) nNonZero++;
+       }
+       // Can we include kinetic energy here?
+       G4double deltaE = ( theTrack.Get4Momentum().e() + theTarget.GetTotalEnergy() )
+                       - ( p_photons.e() + aRecoil->GetPDGMass() );
+//Add photons
+       if ( nPhotons - nNonZero > 0 )
+       {
+              //G4cout << "TKDB G4NeutronHPCaptureFS::ApplyYourself we will create additional " << nPhotons - nNonZero << " photons" << G4endl;
+          std::vector<G4double> vRand;
+          vRand.push_back( 0.0 );
+          for ( G4int i = 0 ; i != nPhotons - nNonZero - 1 ; i++ )
+          {
+             vRand.push_back( G4UniformRand() );
+          }
+          vRand.push_back( 1.0 );
+          std::sort( vRand.begin(), vRand.end() );
+          std::vector<G4double> vEPhoton;
+          for ( G4int i = 0 ; i < (G4int)vRand.size() - 1 ; i++ )
+          {
+             vEPhoton.push_back( deltaE * ( vRand[i+1] - vRand[i] ) );
+          }
+          std::sort( vEPhoton.begin(), vEPhoton.end() );
+          for ( G4int i = 0 ; i < nPhotons - nNonZero - 1 ; i++ )
+          {
+             //Isotopic in LAB OK?
+             G4double theta = pi*G4UniformRand();
+             G4double phi = twopi*G4UniformRand();
+             G4double sinth = std::sin(theta);
+             G4double en = vEPhoton[i];
+             G4ThreeVector tempVector(en*sinth*std::cos(phi), en*sinth*std::sin(phi), en*std::cos(theta) );
+             p_photons += G4LorentzVector ( tempVector, tempVector.mag() );
+             G4DynamicParticle * theOne = new G4DynamicParticle;
+             theOne->SetDefinition( G4Gamma::Gamma() );
+             theOne->SetMomentum( tempVector );
+             theResult.AddSecondary(theOne);
+          }
+//        Add last photon
+          G4DynamicParticle * theOne = new G4DynamicParticle;
+          theOne->SetDefinition( G4Gamma::Gamma() );
+//        For better momentum conservation
+          G4ThreeVector lastPhoton = -p_photons.vect().unit()*vEPhoton.back();
+          p_photons += G4LorentzVector( lastPhoton , lastPhoton.mag() );
+          theOne->SetMomentum( lastPhoton );
+          theResult.AddSecondary(theOne);
+       }
+//Add residual
+       G4DynamicParticle * theOne = new G4DynamicParticle;
+       G4ThreeVector aMomentum = theTrack.Get4Momentum().vect() + theTarget.GetMomentum()
+                               - p_photons.vect();
+       theOne->SetDefinition(aRecoil);
+       theOne->SetMomentum( aMomentum );
+       theResult.AddSecondary(theOne);
+    }
+//101203TK END
 // clean up the primary neutron
     theResult.SetStatusChange(stopAndKill);

trunk/source/processes/hadronic/models/neutron_hp/src/G4NeutronHPDiscreteTwoBody.cc

-              r962
+              r1347
 //080612 Bug fix contribution from Benoit Pirard and Laurent Desorgher (Univ. Bern) #2,3
 //080709 Bug fix Sampling Legendre expansion by T. Koi
+//101110 Bug fix in MF=6, LAW=2 case; contribution from E. Mendoza, D. Cano-Ott (CIEMAT)
 //
 #include "G4NeutronHPDiscreteTwoBody.hh"
 …
        for(i=0;i<theCoeff[it].GetNumberOfPoly(); i++)
+       {
+         theStore.SetX(i, theCoeff[it].GetCoeff(i));
+         theStore.SetY(i, theCoeff[it].GetCoeff(i));
+         //101110
+         //theStore.SetX(i, theCoeff[it].GetCoeff(i));
+         //theStore.SetY(i, theCoeff[it].GetCoeff(i));
+         theStore.SetX(i/2, theCoeff[it].GetCoeff(i));
+         theStore.SetY(i/2, theCoeff[it].GetCoeff(i+1));
          i++;
+       }
 …
        for(i=0;i<theCoeff[it].GetNumberOfPoly(); i++)
+       {
+         theStore.SetX(i, theCoeff[it].GetCoeff(i));
+         theStore.SetY(i, theCoeff[it].GetCoeff(i));
+         //101110
+         //theStore.SetX(i, theCoeff[it].GetCoeff(i));
+         //theStore.SetY(i, theCoeff[it].GetCoeff(i));
+         theStore.SetX(i/2, theCoeff[it].GetCoeff(i));
+         theStore.SetY(i/2, theCoeff[it].GetCoeff(i+1));
          i++;
+       }
 …
          for(i=0;i<theCoeff[it-1].GetNumberOfPoly(); i++)
+         {
+           theBuff1.SetX(i, theCoeff[it-1].GetCoeff(i));
+           theBuff1.SetY(i, theCoeff[it-1].GetCoeff(i));
+           //101110
+           //theBuff1.SetX(i, theCoeff[it-1].GetCoeff(i));
+           //theBuff1.SetY(i, theCoeff[it-1].GetCoeff(i));
+           theBuff1.SetX(i/2, theCoeff[it-1].GetCoeff(i));
+           theBuff1.SetY(i/2, theCoeff[it-1].GetCoeff(i+1));
            i++;
+         }
 …
          for(i=0;i<theCoeff[it].GetNumberOfPoly(); i++)
+         {
+           //theBuff2.SetX(i, theCoeff[it].GetCoeff(i));
+           //theBuff2.SetY(i, theCoeff[it].GetCoeff(i));
            theBuff2.SetX(i, theCoeff[it].GetCoeff(i));
            theBuff2.SetY(i, theCoeff[it].GetCoeff(i));
+           theBuff2.SetY(i, theCoeff[it].GetCoeff(i+1));
            i++;
+         }
 …
          for(i=0;i<theCoeff[it-1].GetNumberOfPoly(); i++)
+         {
+           theBuff1.SetX(i, theCoeff[it-1].GetCoeff(i));
+           theBuff1.SetY(i, theCoeff[it-1].GetCoeff(i));
+           //101110
+           //theBuff1.SetX(i, theCoeff[it-1].GetCoeff(i));
+           //theBuff1.SetY(i, theCoeff[it-1].GetCoeff(i));
+           theBuff1.SetX(i/2, theCoeff[it-1].GetCoeff(i));
+           theBuff1.SetY(i/2, theCoeff[it-1].GetCoeff(i+1));
            i++;
+         }
 …
          for(i=0;i<theCoeff[it].GetNumberOfPoly(); i++)
+         {
+           theBuff2.SetX(i, theCoeff[it].GetCoeff(i));
+           theBuff2.SetY(i, theCoeff[it].GetCoeff(i));
+           //101110
+           //theBuff2.SetX(i, theCoeff[it].GetCoeff(i));
+           //theBuff2.SetY(i, theCoeff[it].GetCoeff(i));
+           theBuff2.SetX(i/2, theCoeff[it].GetCoeff(i));
+           theBuff2.SetY(i/2, theCoeff[it].GetCoeff(i+1));
            i++;
+         }

trunk/source/processes/hadronic/models/neutron_hp/src/G4NeutronHPFinalState.cc

-              r968
+              r1347
 //080721 Create adjust_final_state method by T. Koi
 //080801 Residual reconstruction with theNDLDataA,Z (A, Z, and momentum are adjusted) by T. Koi
+//101110 Set lower limit for gamma energy(1keV) by T. Koi
 #include "G4NeutronHPFinalState.hh"
 …
 void G4NeutronHPFinalState::adjust_final_state ( G4LorentzVector init_4p_lab )
+{
+   G4double minimum_energy = 1*keV;
    if ( adjustResult != true ) return;
 …
       // Adjust p
+      if ( dif_4p.v().mag() < 1*MeV )
+      //if ( dif_4p.v().mag() < 1*MeV )
+      if ( minimum_energy < dif_4p.v().mag() && dif_4p.v().mag() < 1*MeV )
+      {
 …
       else
+      {
          //G4cout << "HP_DB Difference in dif_p is too large (>1MeV) to adjust, so that give up tuning" << G4endl;
+         //G4cout << "HP_DB Difference in dif_p is too large (>1MeV) or too small(<1keV) to adjust, so that give up tuning" << G4endl;
+      }
 …
       nSecondaries += 2;
       G4double e1 = ( dif_4p.e() -dif_4p.v().mag() ) / 2;
+      G4double costh = 2.*G4UniformRand()-1.;
+      G4double phi = twopi*G4UniformRand();
+      G4ThreeVector dir( std::sin(std::acos(costh))*std::cos(phi),
+                         std::sin(std::acos(costh))*std::sin(phi),
+                         costh);
+      theResult.AddSecondary ( new G4DynamicParticle ( G4Gamma::Gamma() , e1*dir ) );
+      theResult.AddSecondary ( new G4DynamicParticle ( G4Gamma::Gamma() , -e1*dir ) );
+      if ( minimum_energy < e1 )
+      {
+         G4double costh = 2.*G4UniformRand()-1.;
+         G4double phi = twopi*G4UniformRand();
+         G4ThreeVector dir( std::sin(std::acos(costh))*std::cos(phi),
+                            std::sin(std::acos(costh))*std::sin(phi),
+                            costh);
+         theResult.AddSecondary ( new G4DynamicParticle ( G4Gamma::Gamma() , e1*dir ) );
+         theResult.AddSecondary ( new G4DynamicParticle ( G4Gamma::Gamma() , -e1*dir ) );
+      }
+      else
+      {
+         //G4cout << "HP_DB Difference is too small(<1keV) to adjust, so that neglect it" << G4endl;
+      }
+   }

trunk/source/processes/hadronic/models/neutron_hp/src/G4NeutronHPInelasticBaseFS.cc

-              r962
+              r1347
 //        Introduce theNDLDataA,Z which has A and Z of NDL data by T. Koi
 // 081024 G4NucleiPropertiesTable:: to G4NucleiProperties::
+// 101111 Add Special treatment for Be9(n,2n)Be8(2a) case by T. Koi
 //
 #include "G4NeutronHPInelasticBaseFS.hh"
 …
   else if(theEnergyAngData!=0)
+  {
     G4double theGammaEnergy = theEnergyAngData->GetTotalMeanEnergy();
     G4double anEnergy = boosted.GetKineticEnergy();
 …
     G4double eBindHe3 = G4NucleiProperties::GetBindingEnergy(3,2);
     G4double eBindA = G4NucleiProperties::GetBindingEnergy(4,2);
+    G4int ia=0;
     for(i=0; i<tmpHadrons->size(); i++)
+    {
 …
+      {
         eBindProducts+=eBindA;
+      }
+    }
+        ia++;
+      }
+    }
     theGammaEnergy += eBindProducts;
+//101111
+//Special treatment for Be9 + n -> 2n + Be8 -> 2n + a + a
+if ( (G4int)(theBaseZ+eps) == 4 && (G4int)(theBaseA+eps) == 9 )
+{
+   // This only valid for G4NDL3.13,,,
+   if ( std::abs( theNuclearMassDifference -
+        ( G4NucleiProperties::GetBindingEnergy( 8 , 4 ) -
+        G4NucleiProperties::GetBindingEnergy( 9 , 4 ) ) ) < 1*keV
+      && ia == 2 )
+   {
+      theGammaEnergy -= (2*eBindA);
+   }
+}
     G4ReactionProductVector * theOtherPhotons = 0;

trunk/source/processes/hadronic/models/neutron_hp/src/G4NeutronHPInelasticCompFS.cc

-              r1340
+              r1347
 //        add two_body_reaction
 // 100909 add safty
+// 101111 add safty for _nat_ data case in Binary reaction, but break conservation
 //
 #include "G4NeutronHPInelasticCompFS.hh"
 …
    G4double AA = hadron->GetDefinition()->GetPDGMass() / proj->GetDefinition()->GetPDGMass();
    G4double E1 = proj->GetKineticEnergy();
+   G4double beta = std::sqrt ( A*(A+1-AA)/AA*(1+(1+A)/A*Q/E1) );
+// 101111
+// In _nat_ data (Q+E1) could become negative value, following line is safty for this case.
+   //if ( (Q+E1) < 0 )
+   if ( ( 1 + (1+A)/A*Q/E1 ) < 0 )
+   {
+// 1.0e-6 eV is additional safty for numeric precision
+      Q = -( A/(1+A)*E1 ) + 1.0e-6*eV;
+   }
+   G4double beta = std::sqrt ( A*(A+1-AA)/AA*( 1 + (1+A)/A*Q/E1 ) );
    G4double gamma = AA/(A+1-AA)*beta;
    G4double E3 = AA/std::pow((1+A),2)*(beta*beta+1+2*beta*mu)*E1;

trunk/source/processes/hadronic/models/neutron_hp/src/G4NeutronHPPhotonDist.cc

-              r1055
+              r1347
 //        Contribution from Chao Zhang (Chao.Zhang@usd.edu) and Dongming Mei(Dongming.Mei@usd.edu)
 //        But it looks like never cause real effect in G4NDL3.13 (at least Natural elements) TK
+// 101111 Change warning message for "repFlag == 2 && isoFlag != 1" case
 //
 // there is a lot of unused (and undebugged) code in this file. Kept for the moment just in case. @@
 …
   if (isoFlag != 1)
+  {
 if ( repFlag == 2 ) G4cout << "TKDB repFlag == 2 && isoFlag !=1  " << G4endl;
+if ( repFlag == 2 ) G4cout << "G4NeutronHPPhotonDist: repFlag == 2 && isoFlag != 1 is unexpected! If you use G4ND3.x, then please report to Geant4 Hyper News. Thanks." << G4endl;
     aDataFile >> tabulationType >> nDiscrete2 >> nIso;
 //080731

trunk/source/processes/hadronic/models/parton_string/History

-              r1196
+              r1347
      * Please list in reverse chronological order (last date on top)
      ---------------------------------------------------------------
+  Dec. 2009, V. Uzhinsky         (hadr-prtn-V09-03-00)
+   Crush found by Alberto with AveragePt2=0 is erased in FTF.
+--------------------------------------------------------
+  December 2009, V. Uzhinsky     (hadr-prtn-V09-02-10)
+   Some correstions are made in diffr., hadronization and managment
+   to treat kinky string fragmentation.
 November 2009, Gunter Folger   (hadr-prtn-V09-02-09)

trunk/source/processes/hadronic/models/parton_string/diffraction/History

-              r1340
+              r1347
 $Id: History,v 1.33 2010/09/20 15:55:33 vuzhinsk Exp $
+$Id: History,v 1.34 2010/11/15 10:10:16 vuzhinsk Exp $
 -------------------------------------------------------------------
 …
      * Please list in reverse chronological order (last date on top)
      ---------------------------------------------------------------
+Nov. 2010, V. Uzhinsky (hadr-string-diff-V09-03-04)
+FTF with tuned parameters for pA and PiA interactions.
+    Quark exchange is tuned.
+    Low mass string fragmentation is improved.
+    Reggeon cascade parameters are tuned.
+--------------------------------------------------------
 Sept. 2010, V, Uzhinsky (hadr-string-diff-V09-03-03)
 FTF with new tuned parameters of nuclear destrustion is implemented.

trunk/source/processes/hadronic/models/parton_string/diffraction/include/G4DiffractiveSplitableHadron.hh

r1340	r1347
26	26	//
27	27	// $Id: G4DiffractiveSplitableHadron.hh,v 1.6 2010/09/20 15:50:46 vuzhinsk Exp $
28		// GEANT4 tag $Name: geant4-09-0~~3-ref-09~~ $
	28	// GEANT4 tag $Name: geant4-09-04-ref-00 $
29	29	//
30	30

trunk/source/processes/hadronic/models/parton_string/diffraction/include/G4FTFModel.hh

r1340	r1347
26	26	//
27	27	// $Id: G4FTFModel.hh,v 1.11 2010/09/20 15:50:46 vuzhinsk Exp $
28		// GEANT4 tag $Name: geant4-09-0~~3-ref-09~~ $
	28	// GEANT4 tag $Name: geant4-09-04-ref-00 $
29	29	//
30	30	// Class Description

trunk/source/processes/hadronic/models/parton_string/diffraction/include/G4FTFParameters.hh

-              r1340
+              r1347
 #define G4FTFParameters_h 1
 //
 // $Id: G4FTFParameters.hh,v 1.8 2010/09/20 15:50:46 vuzhinsk Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4FTFParameters.hh,v 1.9 2010/11/15 10:05:19 vuzhinsk Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 #include "G4Proton.hh"
 …
   public:
         G4FTFParameters(const G4ParticleDefinition * , G4double theA,
                                                        G4double theZ,
+        G4FTFParameters(const G4ParticleDefinition * , G4int theA,
+                                                       G4int theZ,
                                                        G4double s);
+//      G4FTFParameters(const G4ParticleDefinition * , G4double theA,
+//                                                       G4double theZ,
+//                                                       G4double s);
         ~G4FTFParameters();
 …
         void SetSlopeQuarkExchange(const G4double aValue);
         void SetDeltaProbAtQuarkExchange(const G4double aValue);
+        void SetProbOfSameQuarkExchange(const G4double aValue);
         void SetProjMinDiffMass(const G4double aValue);
 …
         G4double GetSlopeQuarkExchange();
         G4double GetDeltaProbAtQuarkExchange();
+        G4double GetProbOfSameQuarkExchange();
         G4double GetProjMinDiffMass();
 …
         G4double SlopeQuarkExchange;
         G4double DeltaProbAtQuarkExchange;
+        G4double ProbOfSameQuarkExchange;
         G4double ProjMinDiffMass;
 …
 inline  void G4FTFParameters::SetDeltaProbAtQuarkExchange(const G4double aValue)
              {DeltaProbAtQuarkExchange = aValue;}
+inline void G4FTFParameters::SetProbOfSameQuarkExchange(const G4double aValue)
+             {ProbOfSameQuarkExchange = aValue;}
 inline  void G4FTFParameters::SetProjMinDiffMass(const G4double aValue)
 …
 inline  G4double G4FTFParameters::GetMagQuarkExchange()       {return MagQuarkExchange;}
 inline  G4double G4FTFParameters::GetSlopeQuarkExchange()     {return SlopeQuarkExchange;}
 inline  G4double G4FTFParameters::GetDeltaProbAtQuarkExchange()
                                                               {return DeltaProbAtQuarkExchange;}
+inline  G4double G4FTFParameters::GetDeltaProbAtQuarkExchange(){return
+                                                                DeltaProbAtQuarkExchange;}
+inline  G4double G4FTFParameters::GetProbOfSameQuarkExchange(){return ProbOfSameQuarkExchange;}
 inline  G4double G4FTFParameters::GetProjMinDiffMass()        {return ProjMinDiffMass;}

trunk/source/processes/hadronic/models/parton_string/diffraction/include/G4FTFParticipants.hh

r1340	r1347
26	26	//
27	27	// $Id: G4FTFParticipants.hh,v 1.7 2010/09/20 15:50:46 vuzhinsk Exp $
28		// GEANT4 tag $Name: geant4-09-0~~3-ref-09~~ $
	28	// GEANT4 tag $Name: geant4-09-04-ref-00 $
29	29	//
30	30

trunk/source/processes/hadronic/models/parton_string/diffraction/src/G4DiffractiveExcitation.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4DiffractiveExcitation.cc,v 1.22 2010/09/20 15:50:46 vuzhinsk Exp $
+// $Id: G4DiffractiveExcitation.cc,v 1.23 2010/11/15 10:02:38 vuzhinsk Exp $
 // ------------------------------------------------------------
 //      GEANT 4 class implemetation file
 …
      G4double SqrtS=std::sqrt(S);
+//G4cout<<"SqrtS < 2300*MeV "<<SqrtS<<G4endl;
      if(absProjectilePDGcode > 1000 && (SqrtS < 2300*MeV || SqrtS < SumMasses))
      {target->SetStatus(2);  return false;}  // The model cannot work for
 …
 G4cout<<"Targ "<<M0target    <<" "<<TargetDiffStateMinMass    <<" "<<TargetNonDiffStateMinMass<<G4endl;
 G4cout<<"SqrtS "<<SqrtS<<G4endl;
 G4cout<<"Rapid "<<ProjectileRapidity<<" "<<TargetRapidity<<G4endl;
+G4cout<<"Rapid "<<ProjectileRapidity<<G4endl; //" "<<TargetRapidity<<G4endl;
 */
 // Charge exchange can be possible for baryons -----------------
 …
      G4double DeltaProbAtQuarkExchange=theParameters->GetDeltaProbAtQuarkExchange();
-//G4cout<<"Q exc "<<MagQuarkExchange<<" "<<SlopeQuarkExchange<<" "<<DeltaProbAtQuarkExchange<<G4endl;
 //     G4double NucleonMass=
 //              (G4ParticleTable::GetParticleTable()->FindParticle(2112))->GetPDGMass();
 …
 //G4cout<<MagQuarkExchange*std::exp(-SlopeQuarkExchange*(ProjectileRapidity - TargetRapidity))<<G4endl;
+//G4cout<<"Q exc Mag Slop Wdelta"<<MagQuarkExchange<<" "<<SlopeQuarkExchange<<" "<<DeltaProbAtQuarkExchange<<G4endl;
+//G4cout<<"ProjectileRapidity "<<ProjectileRapidity<<G4endl;
 //G4cout<<MagQuarkExchange*std::exp(-SlopeQuarkExchange*(ProjectileRapidity))<<G4endl;
-//G4cout<<MagQuarkExchange*std::exp(-SlopeQuarkExchange*(ProjectileRapidity - 1.36))<<G4endl;
 //G4int Uzhi; G4cin>>Uzhi;
 // Check for possible quark exchange -----------------------------------
 …
       if(absProjectilePDGcode < 1000 )
       {    // projectile is meson -----------------
        if(ProjQ1 > 0 ) // ProjQ1 is quark
+       {
 …
          TargExchangeQ = TargQ3;  TargQ3=ProjExchangeQ; ProjQ2=TargExchangeQ;
+        }
        } // End of if(ProjQ1 > 0 ) // ProjQ1 is quark
        G4int aProjQ1=std::abs(ProjQ1);
        G4int aProjQ2=std::abs(ProjQ2);
        if(aProjQ1 == aProjQ2)          {NewProjCode = 111;} // Pi0-meson
+       if(aProjQ1 == aProjQ2)          {NewProjCode = 111;} // Pi0-meson
        else  // |ProjQ1| # |ProjQ2|
+       {
         if(aProjQ1 > aProjQ2)          {NewProjCode = aProjQ1*100+aProjQ2*10+1;}
         else                           {NewProjCode = aProjQ2*100+aProjQ1*10+1;}
+        NewProjCode *=(ProjectilePDGcode/absProjectilePDGcode);
+       }
+G4bool ProjExcited=false;
+        if(G4UniformRand() < 0.5)
+        {
+         NewProjCode +=2; // Excited Pi0-meson
+         ProjExcited=true;
+        }
+//G4cout<<G4endl<<"NewProjCode "<<NewProjCode<<G4endl;
+G4ParticleDefinition* TestParticle=0;
+TestParticle=G4ParticleTable::GetParticleTable()->FindParticle(NewProjCode);
+if(TestParticle)
+{
+ M0projectile=
+ (G4ParticleTable::GetParticleTable()->FindParticle(NewProjCode))->GetPDGMass();
+ M0projectile2 = M0projectile * M0projectile;
+ ProjectileDiffStateMinMass   =M0projectile+210.*MeV; //210 MeV=m_pi+70 MeV
+ ProjectileNonDiffStateMinMass=M0projectile+210.*MeV; //210 MeV=m_pi+70 MeV
+} else
+{return false;}
+//G4cout<<"New TrQ "<<TargQ1<<" "<<TargQ2<<" "<<TargQ3<<G4endl;
        NewTargCode = NewNucleonId(TargQ1, TargQ2, TargQ3);
+//G4cout<<"NewTargCode "<<NewTargCode<<G4endl;
        if( (TargQ1 == TargQ2) && (TargQ1 == TargQ3) &&
+           (SqrtS > M0projectile+DeltaMass))           {NewTargCode +=2;} //Create Delta isobar
+       else if( target->GetDefinition()->GetPDGiIsospin() == 3 )         //Delta was the target
+       { if(G4UniformRand() > DeltaProbAtQuarkExchange){NewTargCode +=2;} //Save   Delta isobar
+           (SqrtS > M0projectile+DeltaMass))           {NewTargCode +=2;  //Create Delta isobar
+                                                        ProjExcited=true;}
+       else if( target->GetDefinition()->GetPDGiIsospin() == 3 )          //Delta was the target
+       { if(G4UniformRand() > DeltaProbAtQuarkExchange){NewTargCode +=2;  //Save   Delta isobar
+                                                        ProjExcited=true;}
          else                                          {}     // De-excite initial Delta isobar
+       }
+       else if((G4UniformRand() < DeltaProbAtQuarkExchange) &&         //Nucleon was the target
+//       else if((!CreateDelta)                               &&
+       else if((!ProjExcited)                               &&
+               (G4UniformRand() < DeltaProbAtQuarkExchange) &&         //Nucleon was the target
                (SqrtS > M0projectile+DeltaMass))      {NewTargCode +=2;}  //Create Delta isobar
+//       else if( CreateDelta)                          {NewTargCode +=2;}
        else                                           {}                 //Save initial nucleon
 //       target->SetDefinition(                                          // Fix 15.12.09
 //       G4ParticleTable::GetParticleTable()->FindParticle(NewTargCode));// Fix 15.12.09
+//G4cout<<"NewTargCode "<<NewTargCode<<G4endl;
+//G4int Uzhi; G4cin>>Uzhi;
+TestParticle=G4ParticleTable::GetParticleTable()->FindParticle(NewTargCode);
+if(TestParticle)
+{
+ M0target=
+ (G4ParticleTable::GetParticleTable()->FindParticle(NewTargCode))->GetPDGMass();
+ M0target2 = M0target * M0target;
+ TargetDiffStateMinMass   =M0target+220.*MeV;         //220 MeV=m_pi+80 MeV;
+ TargetNonDiffStateMinMass=M0target+220.*MeV;         //220 MeV=m_pi+80 MeV;
+} else
+{return false;}
       } else
       {    // projectile is baryon ----------------
+       G4double Same=0.; //0.3; //0.5;
+//=========================================================================
+       G4double Same=theParameters->GetProbOfSameQuarkExchange(); //0.3; //0.5; 0.
        G4bool ProjDeltaHasCreated(false);
        G4bool TargDeltaHasCreated(false);
 …
       } // End of if projectile is baryon ---------------------------
+//G4cout<<"At end// NewProjCode "<<NewProjCode<<G4endl;
+//G4cout<<"At end// NewTargCode "<<NewTargCode<<G4endl;
 // If we assume that final state hadrons after the charge exchange will be
 // in the ground states, we have to put ----------------------------------
+/*
+//      if(M0projectile <
+//         (G4ParticleTable::GetParticleTable()->FindParticle(NewProjCode))->GetPDGMass())
+      if(ProjDeltaHasCreated)
+      {
+       M0projectile=
+         (G4ParticleTable::GetParticleTable()->FindParticle(NewProjCode))->GetPDGMass();
+       M0projectile2 = M0projectile * M0projectile;
+       ProjectileDiffStateMinMass   =M0projectile+160.*MeV; //160 MeV=m_pi+20 MeV
+       ProjectileNonDiffStateMinMass=M0projectile+160.*MeV; //160 MeV=m_pi+20 MeV
+      }
+//      if(M0target <
+//         (G4ParticleTable::GetParticleTable()->FindParticle(NewTargCode))->GetPDGMass())
+      if(TargDeltaHasCreated)
+      {
+       M0target=
+         (G4ParticleTable::GetParticleTable()->FindParticle(NewTargCode))->GetPDGMass();
+       M0target2 = M0target * M0target;
+       TargetDiffStateMinMass   =M0target+160.*MeV;         //160 MeV=m_pi+20 MeV;
+       TargetNonDiffStateMinMass=M0target+160.*MeV;         //160 MeV=m_pi+20 MeV;
+      }
+*/
+//G4cout<<"M0pr M0tr SqS "<<M0projectile<<" "<<M0target<<" "<<SqrtS<<G4endl;
       PZcms2=(S*S+M0projectile2*M0projectile2+M0target2*M0target2-
 *S*M0projectile2 - 2*S*M0target2 - 2*M0projectile2*M0target2)
              /4./S;
 //G4cout<<"PZcms2 1 "<<PZcms2<<G4endl;
+//G4cout<<"PZcms2 1 "<<PZcms2<<G4endl<<G4endl;
       if(PZcms2 < 0) {return false;}  // It can be if energy is not sufficient for Delta
 //----------------------------------------------------------
 …
 // ----------------------------------------------------------
+//      G4double Wexcit=1.-1.97*std::exp(-0.5*ProjectileRapidity);
+      G4double Wexcit=1.-2.256*std::exp(-0.6*ProjectileRapidity);
+//G4cout<<ProjectileRapidity<<" "<<1.72*std::exp(-0.4*ProjectileRapidity)<<" "<<std::exp(0.4*ProjectileRapidity)<<G4endl;
+//G4int Uzhi;G4cin>>Uzhi;
+//Wexcit=0.;
+      if(G4UniformRand() > Wexcit)
+      {                             // Make elastic scattering
+//G4cout<<"Make elastic scattering"<<G4endl;
+       Pprojectile.transform(toLab);
+       Ptarget.transform(toLab);
+       projectile->SetTimeOfCreation(target->GetTimeOfCreation());
+       projectile->SetPosition(target->GetPosition());
+       projectile->Set4Momentum(Pprojectile);
+       target->Set4Momentum(Ptarget);
+       G4bool Result= theElastic->ElasticScattering (projectile,target,theParameters);
+       return Result;
+      } // end of if(G4UniformRand() > Wexcit)
+      if(absProjectilePDGcode < 1000)
+      { // For projectile meson
+       G4double Wexcit=1.-2.256*std::exp(-0.6*ProjectileRapidity);
+       Wexcit=0.;
+       if(G4UniformRand() > Wexcit)
+       {                             // Make elastic scattering
+//G4cout<<"Make elastic scattering of new hadrons"<<G4endl;
+        Pprojectile.transform(toLab);
+        Ptarget.transform(toLab);
+        projectile->SetTimeOfCreation(target->GetTimeOfCreation());
+        projectile->SetPosition(target->GetPosition());
+        projectile->Set4Momentum(Pprojectile);
+        target->Set4Momentum(Ptarget);
+        G4bool Result= theElastic->ElasticScattering (projectile,target,theParameters);
+        return Result;
+       } // end of if(Make elastic scattering for projectile meson?)
+      } else
+      { // For projectile baryon
+       G4double Wexcit=1.-2.256*std::exp(-0.6*ProjectileRapidity);
+       //Wexcit=0.;
+       if(G4UniformRand() > Wexcit)
+       {                             // Make elastic scattering
+//G4cout<<"Make elastic scattering of new hadrons"<<G4endl;
+        Pprojectile.transform(toLab);
+        Ptarget.transform(toLab);
+        projectile->SetTimeOfCreation(target->GetTimeOfCreation());
+        projectile->SetPosition(target->GetPosition());
+        projectile->Set4Momentum(Pprojectile);
+        target->Set4Momentum(Ptarget);
+        G4bool Result= theElastic->ElasticScattering (projectile,target,theParameters);
+        return Result;
+       } // end of if(Make elastic scattering for projectile baryon?)
+      }
+//G4cout<<"Make excitation of new hadrons"<<G4endl;
      }  // End of charge exchange part ------------------------------
 …
 G4cout<<"Prob ProjDiff TargDiff "<<ProbProjectileDiffraction<<" "<<ProbTargetDiffraction<<" "<<ProbOfDiffraction<<G4endl;
 G4cout<<"Pr Y "<<Pprojectile.rapidity()<<" Tr Y "<<Ptarget.rapidity()<<G4endl;
 //G4int Uzhi; G4cin>>Uzhi;
+G4int Uzhi; G4cin>>Uzhi;
 */
 /*

trunk/source/processes/hadronic/models/parton_string/diffraction/src/G4DiffractiveSplitableHadron.cc

r1340	r1347
26	26	//
27	27	// $Id: G4DiffractiveSplitableHadron.cc,v 1.9 2010/09/20 15:50:46 vuzhinsk Exp $
28		// GEANT4 tag $Name: geant4-09-0~~3-ref-09~~ $
	28	// GEANT4 tag $Name: geant4-09-04-ref-00 $
29	29	//
30	30

trunk/source/processes/hadronic/models/parton_string/diffraction/src/G4FTFModel.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4FTFModel.cc,v 1.36 2010/09/20 15:50:46 vuzhinsk Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4FTFModel.cc,v 1.37 2010/11/15 10:02:38 vuzhinsk Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
+{
         theProjectile = aProjectile;
+//G4cout<<"FTF init Pro "<<theProjectile.GetMass()<<" "<<theProjectile.GetMomentum()<<G4endl;
+//G4cout<<"FTF init A Z "<<aNucleus.GetA_asInt()<<" "<<aNucleus.GetZ_asInt()<<G4endl;
+//G4cout<<"             "<<aNucleus.GetN()<<" "<<aNucleus.GetZ()<<G4endl;
+//G4int Uzhi; G4cin>>Uzhi;
         theParticipants.Init(aNucleus.GetA_asInt(),aNucleus.GetZ_asInt());
+//G4cout<<"End nucl init"<<G4endl;
 // ----------- N-mass number Z-charge -------------------------
 …
       if( theParameters != 0 ) delete theParameters;
       theParameters = new G4FTFParameters(theProjectile.GetDefinition(),
                                           aNucleus.GetN(),aNucleus.GetZ(),
+                                          aNucleus.GetA_asInt(),aNucleus.GetZ_asInt(),
                                           s);
+//      theParameters = new G4FTFParameters(theProjectile.GetDefinition(),
+//                                          aNucleus.GetN(),aNucleus.GetZ(),
+//                                          s);
 //theParameters->SetProbabilityOfElasticScatt(0.);
 …
         G4int ResidualMassNumber=theNucleus->GetMassNumber();
         G4int ResidualCharge    =theNucleus->GetCharge();
         ResidualExcitationEnergy=0.;
         G4LorentzVector PnuclearResidual(0.,0.,0.,0.);
 …
 //      ResidualMass +=ResidualExcitationEnergy; // Will be given after checks
 //G4cout<<"SumMasses End ResidualMass "<<SumMasses<<" "<<ResidualMass<<G4endl;
+//G4cout<<"SumMasses And ResidualMass "<<SumMasses<<" "<<ResidualMass<<G4endl;
         SumMasses += ResidualMass;
 //G4cout<<"SumMasses + ResM "<<SumMasses<<G4endl;
 …
         Pprojectile.transform(toLab);       // The work with the projectile
         primary->Set4Momentum(Pprojectile); // is finished at the moment.
+//G4cout<<"Final proj mom "<<primary->Get4Momentum()<<G4endl;
 //-------------------------------------------------------------
 …
         }   // end of for(G4int i=0; i < NumberOfInvolvedNucleon; i++ )
+//G4cout<<"ResidualMassNumber and Mom "<<ResidualMassNumber<<" "<<Residual3Momentum<<G4endl;
         G4double Mt2Residual=sqr(ResidualMass) +
                                  sqr(Residual3Momentum.x())+sqr(Residual3Momentum.y());
+        G4double PzResidual=-WminusTarget*Residual3Momentum.z()/2. +
+//==========================
+//G4cout<<"WminusTarget Residual3Momentum.z() "<<WminusTarget<<" "<<Residual3Momentum.z()<<G4endl;
+        G4double PzResidual=0.;
+        G4double EResidual =0.;
+        if(ResidualMassNumber != 0)
+        {
+         PzResidual=-WminusTarget*Residual3Momentum.z()/2. +
                              Mt2Residual/(2.*WminusTarget*Residual3Momentum.z());
         G4double EResidual = WminusTarget*Residual3Momentum.z()/2. +
+         EResidual = WminusTarget*Residual3Momentum.z()/2. +
                              Mt2Residual/(2.*WminusTarget*Residual3Momentum.z());
+        }
+//==========================
         Residual4Momentum.setPx(Residual3Momentum.x());
         Residual4Momentum.setPy(Residual3Momentum.y());
         Residual4Momentum.setPz(PzResidual);
         Residual4Momentum.setE(EResidual);
+//G4cout<<"Residual4Momentum "<<Residual4Momentum<<G4endl;
         Residual4Momentum.transform(toLab);
 //-------------------------------------------------------------

trunk/source/processes/hadronic/models/parton_string/diffraction/src/G4FTFParameters.cc

-              r1340
+              r1347
 //
 //
 // $Id: G4FTFParameters.cc,v 1.14 2010/09/20 15:50:46 vuzhinsk Exp $
 // GEANT4 tag $Name: geant4-09-03-ref-09 $
+// $Id: G4FTFParameters.cc,v 1.15 2010/11/15 10:02:38 vuzhinsk Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
 //
 …
 //**********************************************************************************************
+//G4FTFParameters::G4FTFParameters(const G4ParticleDefinition * particle,
+//                                                   G4double   theA,
+//                                                   G4double   theZ,
+//                                                   G4double   s)
 G4FTFParameters::G4FTFParameters(const G4ParticleDefinition * particle,
                                                    G4double   theA,
                                                    G4double   theZ,
+                                                   G4int   theA,
+                                                   G4int   theZ,
                                                    G4double   s)
+{
 …
     G4double sqrLogPlab = LogPlab * LogPlab;
+    G4int NumberOfTargetProtons  = (G4int) theZ;
+    G4int NumberOfTargetNeutrons = (G4int) theA- (G4int) theZ;
+    G4int NumberOfTargetProtons  = theZ;
+    G4int NumberOfTargetNeutrons = theA-theZ;
+//    G4int NumberOfTargetProtons  = (G4int) theZ;
+//    G4int NumberOfTargetNeutrons = (G4int) theA- (G4int) theZ;
     G4int NumberOfTargetNucleons = NumberOfTargetProtons + NumberOfTargetNeutrons;
     G4double Xtotal, Xelastic;
     if( absPDGcode > 1000 )                        //------Projectile is baryon --------
+    if( PDGcode > 1000 )                        //------Projectile is baryon --------
+      {
        G4double XtotPP = 48.0 +  0. *std::pow(Plab, 0.  ) + 0.522*sqrLogPlab - 4.51*LogPlab;
 …
        G4double XelPP  = 11.9 + 26.9*std::pow(Plab,-1.21) + 0.169*sqrLogPlab - 1.85*LogPlab;
        G4double XelPN  = 11.9 + 26.9*std::pow(Plab,-1.21) + 0.169*sqrLogPlab - 1.85*LogPlab;
+       Xtotal          = ( NumberOfTargetProtons  * XtotPP +
+                           NumberOfTargetNeutrons * XtotPN  ) / NumberOfTargetNucleons;
+       Xelastic        = ( NumberOfTargetProtons  * XelPP  +
+                           NumberOfTargetNeutrons * XelPN   ) / NumberOfTargetNucleons;
+      }
+    else if( PDGcode < -1000 )                 //------Projectile is anti_baryon --------
+      {
+       G4double XtotPP = 38.4 +  77.6*std::pow(Plab,-0.64) + 0.26*sqrLogPlab - 1.2*LogPlab;
+       G4double XtotPN =  0.  + 133.6*std::pow(Plab,-0.70) + 1.22*sqrLogPlab +13.7*LogPlab;
+       G4double XelPP  = 10.2 + 52.7*std::pow(Plab,-1.16) + 0.125*sqrLogPlab - 1.28*LogPlab;
+       G4double XelPN  = 36.5 +  0. *std::pow(Plab, 0.  ) + 0.   *sqrLogPlab -11.9 *LogPlab;
        Xtotal          = ( NumberOfTargetProtons  * XtotPP +
 …
 //      Xtotal and Xelastic in mb
+// For Pi- P interactions only!
+if(std::abs(Plab-1.4) < 0.05) {Xtotal=3.500599e+01; Xelastic= 1.150032e+01;}
+if(std::abs(Plab-1.5) < 0.05) {Xtotal=3.450591e+01; Xelastic= 1.050038e+01;}
+if(std::abs(Plab-1.6) < 0.05) {Xtotal=3.430576e+01; Xelastic= 9.800433e+00;}
+if(std::abs(Plab-1.7) < 0.05) {Xtotal=3.455560e+01; Xelastic= 9.300436e+00;}
+if(std::abs(Plab-1.8) < 0.05) {Xtotal=3.480545e+01; Xelastic= 8.800438e+00;}
+if(std::abs(Plab-2.0) < 0.05) {Xtotal=3.570503e+01; Xelastic= 8.200370e+00;}
+if(std::abs(Plab-2.2) < 0.05) {Xtotal=3.530495e+01; Xelastic= 7.800362e+00;}
+if(std::abs(Plab-2.5) < 0.05) {Xtotal=3.410484e+01; Xelastic= 7.350320e+00;}
+if(std::abs(Plab-2.75) < 0.05){Xtotal=3.280479e+01; Xelastic= 7.050273e+00;}
+if(std::abs(Plab-3.0) < 0.05) {Xtotal=3.180473e+01; Xelastic= 6.800258e+00;}
+if(std::abs(Plab-4.0) < 0.05) {Xtotal=2.910441e+01; Xelastic= 6.100229e+00;}
+if(std::abs(Plab-5.0) < 0.05) {Xtotal=2.820372e+01; Xelastic= 5.700275e+00;}
+if(std::abs(Plab-6.0) < 0.05) {Xtotal=2.760367e+01; Xelastic= 5.400255e+00;}
+if(std::abs(Plab-7.0) < 0.05) {Xtotal=2.725366e+01; Xelastic= 5.150256e+00;}
+if(std::abs(Plab-8.0) < 0.05) {Xtotal=2.690365e+01; Xelastic= 4.900258e+00;}
+if(std::abs(Plab-10.0) < 0.05){Xtotal=2.660342e+01; Xelastic= 4.600237e+00;}
+if(std::abs(Plab-12.0) < 0.05){Xtotal=2.632341e+01; Xelastic= 4.480229e+00;}
+if(std::abs(Plab-14.0) < 0.05){Xtotal=2.604340e+01; Xelastic= 4.360221e+00;}
+if(std::abs(Plab-20.0) < 0.05){Xtotal=2.520337e+01; Xelastic= 4.000197e+00;}
+if(std::abs(Plab-30.0) < 0.05){Xtotal=2.505334e+01; Xelastic= 3.912679e+00;}
+//
 //----------- Geometrical parameters ------------------------------------------------
       SetTotalCrossSection(Xtotal);
 …
       SetInelasticCrossSection(Xtotal-Xelastic);
 //G4cout<<"Xtotal, Xelastic "<<Xtotal<<" "<<Xelastic<<G4endl;
+//G4cout<<"Plab Xtotal, Xelastic Xinel "<<Plab<<" "<<Xtotal<<" "<<Xelastic<<Xtotal-Xelastic)<<G4endl;
 //  // Interactions with elastic and inelastic collisions
       SetProbabilityOfElasticScatt(Xtotal, Xelastic);
 …
 //----------- Parameters of excitations ---------------------------------------------
            if( absPDGcode > 1000 )                        //------Projectile is baryon --------
+           if( PDGcode > 1000 )                        //------Projectile is baryon --------
+             {
               SetMagQuarkExchange(1.84);//(3.63);
               SetSlopeQuarkExchange(0.7);//(1.2);
               SetDeltaProbAtQuarkExchange(0.);
+              if(NumberOfTargetNucleons > 26) {SetProbOfSameQuarkExchange(1.);}
+              else                            {SetProbOfSameQuarkExchange(0.);}
+              SetProjMinDiffMass(1.16);                   // GeV
+              SetProjMinNonDiffMass(1.16);                // GeV
+              SetProbabilityOfProjDiff(0.805*std::exp(-0.35*Ylab));// 0.5
+              SetTarMinDiffMass(1.16);                    // GeV
+              SetTarMinNonDiffMass(1.16);                 // GeV
+              SetProbabilityOfTarDiff(0.805*std::exp(-0.35*Ylab));// 0.5
+              SetAveragePt2(0.15);                        // 0.15 GeV^2
+             }
+           if( PDGcode < -1000 )                  //------Projectile is anti_baryon --------
+             {
+              SetMagQuarkExchange(0.);
+              SetSlopeQuarkExchange(0.);
+              SetDeltaProbAtQuarkExchange(0.);
+              SetProbOfSameQuarkExchange(0.);
               SetProjMinDiffMass(1.16);                   // GeV
               SetProjMinNonDiffMass(1.16);                // GeV
+SetProbabilityOfProjDiff(0.805*std::exp(-0.35*Ylab));// 0.5
+              SetProbabilityOfProjDiff(0.805*std::exp(-0.35*Ylab));// 0.5
               SetTarMinDiffMass(1.16);                    // GeV
               SetTarMinNonDiffMass(1.16);                 // GeV
+SetProbabilityOfTarDiff(0.805*std::exp(-0.35*Ylab));// 0.5
+              SetProbabilityOfTarDiff(0.805*std::exp(-0.35*Ylab));// 0.5
               SetAveragePt2(0.15);                        // 0.15 GeV^2
 …
            else if( absPDGcode == 211 || PDGcode ==  111) //------Projectile is Pion -----------
+             {
               SetMagQuarkExchange(120.); // 210.
               SetSlopeQuarkExchange(2.0);
               SetDeltaProbAtQuarkExchange(0.6);
+              SetMagQuarkExchange(240.);
+              SetSlopeQuarkExchange(2.);
+              SetDeltaProbAtQuarkExchange(0.56); //(0.35);
               SetProjMinDiffMass(0.5);                    // GeV
+              SetProjMinNonDiffMass(0.3);                 // GeV
+              SetProbabilityOfProjDiff(0.*0.62*std::pow(s/GeV/GeV,-0.51)); // 40/32 X-dif/X-inel
+              SetTarMinDiffMass(1.1);                     // GeV
+              SetTarMinNonDiffMass(1.1);                  // GeV
+              SetProbabilityOfTarDiff(2.*0.62*std::pow(s/GeV/GeV,-0.51)); // 40/32 X-dif/X-inel
+              SetProjMinNonDiffMass(0.5);                 // GeV 0.3
+              SetProbabilityOfProjDiff(0.);//(0.*0.62*std::pow(s/GeV/GeV,-0.51)); // 40/32 X-dif/X-inel
+              SetTarMinDiffMass(1.16);                     // GeV
+              SetTarMinNonDiffMass(1.16);                  // GeV
+//              SetProbabilityOfTarDiff(1.);//(2.*0.62*std::pow(s/GeV/GeV,-0.51));
+//              SetProbabilityOfTarDiff(2.6*std::exp(-0.46*Ylab));
+              SetProbabilityOfTarDiff(0.8*std::exp(-0.6*(Ylab-3.)));
               SetAveragePt2(0.3);                         // GeV^2
 …
       SetMaxNumberOfCollisions(1000.,1.); //(Plab,2.); //3.); ##############################
       SetCofNuclearDestruction(0.3); //1.0);           // for meson projectile
       SetDofNuclearDestruction(0.4);
       SetPt2ofNuclearDestruction(0.17*GeV*GeV);
+      SetMaxPt2ofNuclearDestruction(1.0*GeV*GeV);
+      SetExcitationEnergyPerWoundedNucleon(100*MeV);
     } else                                             // for baryon projectile
+    {
 //      SetMaxNumberOfCollisions(Plab,0.1); //6.); // ##############################
+      SetMaxNumberOfCollisions(Plab,4.); //6.); // ##############################
+      SetCofNuclearDestruction(0.62*std::exp(4.*(Ylab-2.1))/(1.+std::exp(4.*(Ylab-2.1))));
+//      SetCofNuclearDestruction(0.); //1.0);           // for meson projectile
+//      SetCofNuclearDestruction(1.*std::exp(4.*(Ylab-2.1))/(1.+std::exp(4.*(Ylab-2.1))));
+//G4cout<<Ylab<<" "<<0.62*std::exp(4.*(Ylab-4.5))/(1.+std::exp(4.*(Ylab-4.5)))<<G4endl;
+//G4int Uzhi; G4cin>>Uzhi;
+//      SetMaxNumberOfCollisions(Plab,2.); //4.); // ##############################
+      SetCofNuclearDestruction(1.*std::exp(4.*(Ylab-2.1))/(1.+std::exp(4.*(Ylab-2.1)))); //0.62 1.0
+//------------------------------------------
+//      SetDofNuclearDestruction(0.4);
+//      SetPt2ofNuclearDestruction(0.17*GeV*GeV);
+//      SetMaxPt2ofNuclearDestruction(1.0*GeV*GeV);
+//      SetExcitationEnergyPerWoundedNucleon(100*MeV);
       SetDofNuclearDestruction(0.4);
       SetPt2ofNuclearDestruction((0.035+
 …
       SetExcitationEnergyPerWoundedNucleon(75.*MeV);
+    } else                                             // for baryon projectile
+    {
+      SetMaxNumberOfCollisions(Plab,2.); //4.); // ##############################
+      SetCofNuclearDestruction(1.*std::exp(4.*(Ylab-2.1))/(1.+std::exp(4.*(Ylab-2.1)))); //0.62 1.0
+//G4cout<<Ylab<<" "<<0.62*std::exp(4.*(Ylab-2.1))/(1.+std::exp(4.*(Ylab-2.1)))<<G4endl;
+//G4int Uzhi; G4cin>>Uzhi;
+      SetDofNuclearDestruction(0.4);
+      SetPt2ofNuclearDestruction((0.035+
+.04*std::exp(4.*(Ylab-2.5))/(1.+std::exp(4.*(Ylab-2.5))))*GeV*GeV); //0.09
+      SetMaxPt2ofNuclearDestruction(1.0*GeV*GeV);
+      SetExcitationEnergyPerWoundedNucleon(75.*MeV);
+    }
 …
 //SetPt2ofNuclearDestruction((0.035+0.1*std::exp(4.*(Ylab-3.))/(1.+std::exp(4.*(Ylab-3.))))*GeV*GeV);
+//SetMagQuarkExchange(120.); // 210. PipP
+//SetSlopeQuarkExchange(2.0);
+//SetDeltaProbAtQuarkExchange(0.6);
+//SetProjMinDiffMass(0.7);                    // GeV 1.1
+//SetProjMinNonDiffMass(0.7);                 // GeV
+//SetProbabilityOfProjDiff(0.85*std::pow(s/GeV/GeV,-0.5)); // 40/32 X-dif/X-inel
+//SetTarMinDiffMass(1.1);                     // GeV
+//SetTarMinNonDiffMass(1.1);                  // GeV
+//SetProbabilityOfTarDiff(0.85*std::pow(s/GeV/GeV,-0.5)); // 40/32 X-dif/X-inel
+//
+//SetAveragePt2(0.3);                         // GeV^2
+//------------------------------------
 //SetProbabilityOfElasticScatt(1.,1.); //(Xtotal, Xelastic);
 //SetProbabilityOfProjDiff(1.*0.62*std::pow(s/GeV/GeV,-0.51)); // 0->1
 …
 //SetAvaragePt2ofElasticScattering(0.);
+//SetCofNuclearDestruction(0.6); //(0.4);
+SetExcitationEnergyPerWoundedNucleon(75.*MeV); //(75.*MeV);
+//SetDofNuclearDestruction(0.6); //(0.4);
+//SetPt2ofNuclearDestruction(0.12*GeV*GeV); //(0.168*GeV*GeV);
+//SetMaxNumberOfCollisions(4.*(Plab+0.01),Plab); //6.); // ##############################
+//SetCofNuclearDestruction(0.2); //(0.4);
+//SetExcitationEnergyPerWoundedNucleon(0.*MeV); //(75.*MeV);
+//SetDofNuclearDestruction(0.4); //(0.4);
+//SetPt2ofNuclearDestruction(0.1*GeV*GeV); //(0.168*GeV*GeV);
+}

trunk/source/processes/hadronic/models/parton_string/diffraction/src/G4FTFParticipants.cc

r1340	r1347
26	26	//
27	27	// $Id: G4FTFParticipants.cc,v 1.17 2010/09/20 15:50:46 vuzhinsk Exp $
28		// GEANT4 tag $Name: geant4-09-0~~3-ref-09~~ $
	28	// GEANT4 tag $Name: geant4-09-04-ref-00 $
29	29	//
30	30	// ------------------------------------------------------------

trunk/source/processes/hadronic/models/parton_string/hadronization/History

-              r1340
+              r1347
 $Id: History,v 1.17 2010/09/28 09:03:07 gcosmo Exp $
+$Id: History,v 1.18 2010/11/03 17:11:31 gunter Exp $
 -------------------------------------------------------------------
 …
      * Please list in reverse chronological order (last date on top)
      ---------------------------------------------------------------
+Nov 2010, Gunter Folger               (had-hadronization-V09-03-02)
+- fix minor coverity warnings in G4HadronBuilder
 -September-2010  V. Uzhinsky          (had-hadronization-V09-03-01)

trunk/source/processes/hadronic/models/parton_string/management/History

-              r1340
+              r1347
 $Id: History,v 1.9 2010/09/08 16:57:50 gunter Exp $
+$Id: History,v 1.10 2010/11/30 16:11:25 vuzhinsk Exp $
 -------------------------------------------------------------------
 …
      * Please list in reverse chronological order (last date on top)
      ---------------------------------------------------------------
+Nov. 2010 V. Uzhinsky (had-partonstring-mgt-V09-03-01)
+   Member G4int Status in G4VSplitableHadron was changed
+   into G4int curStatus
 -Sept-2010, G.Folger       (had-partonstring-mgt-V09-03-00)

trunk/source/processes/hadronic/models/pre_equilibrium/History

-              r1340
+              r1347
      * Please list in reverse chronological order (last date on top)
      ---------------------------------------------------------------
+-November 2010 V.Ivanchenko   hadr-pre-V09-03-17
+---------------------------------------------------
+G4PreCompoundFragment, G4PreCompoundEmission, G4PreCompoundModel -
+  return back ref-09 computations
+-November 2010 V.Ivanchenko   hadr-pre-V09-03-16
+---------------------------------------------------
+G4PreCompoundModel - change number of excitons to be as in 9.3
+  affects tail of neutron stectrum for low-energy projectile
+-November 2010 V.Ivanchenko   hadr-pre-V09-03-15
+---------------------------------------------------
+G4PreCompoundProton, G4PreCompoundNeutron, G4PreCompoundHe3 - fixed
+  usage of integer Z and A
+-November 2010 V.Ivanchenko   hadr-pre-V09-03-14
+---------------------------------------------------
+- Fixed Coverity warnings - pedantic initialisation in constructors
+-October 2010 V.Ivanchenko   hadr-pre-V09-03-13
+---------------------------------------------------
+G4PreCompoundModel - use more safe constructor of G4DynamicParticle
+G4LowEIonFragmentation - complete transition to integar Z and A,
+                         use of updated methods for G4Fragment
 -October 2010 V.Ivanchenko   hadr-pre-V09-03-12

trunk/source/processes/hadronic/models/qmd/History

-              r1228
+              r1347
      * Please list in reverse chronological order (last date on top)
      ---------------------------------------------------------------
+-November-2010 Tatsumi Koi (hadr-qmd-V09-03-00)
+- Enable RQMD
+        include/G4QMDReaction.hh
+        src/G4QMDReaction.cc
+        include/G4QMDMeanField.hh
+        src/G4QMDMeanField.cc
 -November-2009 Tatsumi Koi (hadr-qmd-V09-02-03)

trunk/source/processes/hadronic/models/qmd/include/G4QMDMeanField.hh

r962	r1347
60	60
61	61	G4double GetTotalPotential();
	62	G4double GetPotential( G4int );
62	63
63	64	void DoPropagation( G4double );

trunk/source/processes/hadronic/models/qmd/include/G4QMDReaction.hh

-              r1228
+              r1347
       void EnableFermiG(){ heg = true; setHighEnergyModel(); };
+      void SetTMAX( G4int i ){ maxTime = i; };
+      void SetDT( G4double t ){ deltaT = t; };
+      void SetEF( G4double x ){ envelopF = x; };
    private:
 …
       G4double deltaT;
       G4int maxTime;
+      G4double envelopF;
       G4Evaporation* evaporation;

trunk/source/processes/hadronic/models/qmd/src/G4QMDMeanField.cc

-              r962
+              r1347
       G4ThreeVector ri = system->GetParticipant( i )->GetPosition();
       G4LorentzVector p4i = system->GetParticipant( i )->Get4Momentum();
       G4ThreeVector betai = p4i.v()/p4i.e();
+      ffr[i] = betai;
+//    R-JQMD
+      G4double Vi = GetPotential( i );
+      G4double p_zero = std::sqrt( p4i.e()*p4i.e() + 2*p4i.m()*Vi);
+      G4ThreeVector betai_R = p4i.v()/p_zero;
+      G4double mi_R = p4i.m()/p_zero;
+//
+      ffr[i] = betai_R;
       ffp[i] = G4ThreeVector( 0.0 );
+      if ( false )
+      {
+         ffr[i] = betai;
+         mi_R = 1.0;
+      }
       for ( G4int j = 0 ; j < system->GetTotalNumberOfParticipant() ; j ++ )
 …
                            * ( 1. - 2. * std::abs( jcharge - icharge ) )
                        + cl * rhc[j][i];
+         ccpp *= mi_R;
 /*
 …
            G4ThreeVector rij = ri - rj;
            G4ThreeVector betaij =  ( p4i + p4j ).v()/eij;
            G4ThreeVector cij = betaij - betai;
            ffr[i] = ffr[i] + 2*ccrr* ( rij + grbb*cij );
+         G4ThreeVector rij = ri - rj;
+         G4ThreeVector betaij =  ( p4i + p4j ).v()/eij;
+         G4ThreeVector cij = betaij - betai;
+         ffr[i] = ffr[i] + 2*ccrr* ( rij + grbb*cij );
            ffp[i] = ffp[i] - 2*ccpp* ( rij + grbb*betaij );
+         ffp[i] = ffp[i] - 2*ccpp* ( rij + grbb*betaij );
+      }
 …
    //std::cout << "gradu 1 " << ffr[1] << " " << ffp[1] << std::endl;
+}
+G4double G4QMDMeanField::GetPotential( G4int i )
+{
+   G4int n = system->GetTotalNumberOfParticipant();
+   G4double rhoa = 0.0;
+   G4double rho3 = 0.0;
+   G4double rhos = 0.0;
+   G4double rhoc = 0.0;
+   G4int icharge = system->GetParticipant(i)->GetChargeInUnitOfEplus();
+   G4int inuc = system->GetParticipant(i)->GetNuc();
+   for ( G4int j = 0 ; j < n ; j ++ )
+   {
+      G4int jcharge = system->GetParticipant(j)->GetChargeInUnitOfEplus();
+      G4int jnuc = system->GetParticipant(j)->GetNuc();
+      rhoa += rha[j][i];
+      rhoc += rhe[j][i];
+      rhos += rha[j][i] * jnuc * inuc
+                * ( 1 - 2 * std::abs ( jcharge - icharge ) );
+   }
+   rho3 = std::pow ( rhoa , gamm );
+   G4double potential = c0 * rhoa
+                      + c3 * rho3
+                      + cs * rhos
+                      + cl * rhoc;
+   return potential;
+}

trunk/source/processes/hadronic/models/qmd/src/G4QMDReaction.cc

-              r1228
+              r1347
 G4QMDReaction::G4QMDReaction()
 : system ( NULL )
 , deltaT ( 1 ) // in fsec
+, deltaT ( 1 ) // in fsec (c=1)
 , maxTime ( 100 ) // will have maxTime-th time step
+, envelopF ( 1.05 ) // 10% for Peripheral reactions
 , gem ( true )
 , frag ( false )
 …
 // impact parameter
+      G4double bmax = 1.05*(bmax_0/fermi);  // 10% for Peripheral reactions
+      //G4double bmax = 1.05*(bmax_0/fermi);  // 10% for Peripheral reactions
+      G4double bmax = envelopF*(bmax_0/fermi);
       G4double b = bmax * std::sqrt ( G4UniformRand() );
 //071112

trunk/source/processes/hadronic/models/radioactive_decay/History

-              r1340
+              r1347
      * Reverse chronological order (last date on top), please *
      ----------------------------------------------------------
+November 2010  F.Lei (radioactive_decay-V09-03-04)
+- src/G4RadioactiveDecay.cc:1593 get rid of the compalition warning with gcc4.5.1
+November 2010  F.Lei (radioactive_decay-V09-03-03)
+- Completed the implementation of generating the activity table in VR mode
+- Set the default h-l threshold to 1 micros in VR mode.
+- General improvement in VR mode implementation.
+- G4RadioactiveDecaymessenger.cc: icmCMD,armCMD & hlThreshold are available at all states.
+November 2010  F.Lei
+- further updates to G4RadioactivityTable.hh .cc and G4RadioactiveDecay.hh .cc
+November 2010  Dennis Wright (radioactive_decay-V09-03-02)
+-------------------------------------------------------------
+- G4RadioactiveDecay.cc : replaced incorrect use of "->" with "." for G4Track
+  in DecayIt(const G4Track&, )
+- G4RadioactivityTable.cc : add include file for <map> and replace map
+  with std::map in method AddIsotope
+Oct 2010 F. Lei
+------------------
+- Added G4RadioactivityTable.hh .cc files for tallying the accumulated radioactivitties in VR mode
+- Added in G4RadioactiveDecay.hh:
+        std::vector<G4RadioactivityTable*> GetTheRadioactivityTables() {return theRadioactivityTables;}
+        // this is how the radioactivity tables can be retrieved by the user
+        std::vector<G4RadioactivityTable*>      theRadioactivityTables;
+        std::map<G4int,G4int>             decayWindows;
+- In G4RadioactiveDecay.cc:
+        starting line 1291: changes need to setup the radioactivity tables
+        line 1624: include the track weight in the weight calculation
+        line 1627: add the rate to the radioactivity tables
+- improved formatting of all the class files
 Oct 2010 F. Lei (radioactive_decay-V09-03-01)

trunk/source/processes/hadronic/models/radioactive_decay/include/G4RadioactiveDecay.hh

-              r1315
+              r1347
 #include "G4RadioactiveDecayRateVector.hh"
 #include "G4RIsotopeTable.hh"
+#include "G4RadioactivityTable.hh"
 #include <vector>
 //class G4UserlimitsForRD;
 …
 class G4RadioactiveDecay : public G4VRestDiscreteProcess
+{
   // class description
   // Implementation of nuclear radioactive decay process.
   // It simulates the decays of radioactive nuclei, which is submitted to RDM in the form
   // of G4Ions. Half-liffe and decay schemes are hold in the Radioactivity database
   // All decay products are submitted back to the particle tracking process through
   // the G4ParticleChangeForRadDecay object.
   // class description - end
+        // class description
+        // Implementation of nuclear radioactive decay process.
+        // It simulates the decays of radioactive nuclei, which is submitted to RDM in the form
+        // of G4Ions. Half-liffe and decay schemes are hold in the Radioactivity database
+        // All decay products are submitted back to the particle tracking process through
+        // the G4ParticleChangeForRadDecay object.
+        // class description - end
 public: // with description
+  G4RadioactiveDecay (const G4String& processName="RadioactiveDecay");
+  ~G4RadioactiveDecay();
+  // constructor and destructor
+  //
+  G4bool IsApplicable(const G4ParticleDefinition &);
+  // Returns true if the specified isotope is
+  //  1) defined as "nucleus" and
+  //  2) it is within theNucleusLimit
+  //
+  G4bool IsLoaded (const G4ParticleDefinition &);
+  // Returns true if the decay table of the specified nuclei is ready.
+  //
+  void SelectAVolume(const G4String aVolume);
+  // Select a logical volume in which RDM applies.
+  //
+  void DeselectAVolume(const G4String aVolume);
+  // remove a logical volume from the RDM applied list
+  //
+  void SelectAllVolumes();
+  // Select all logical volumes for the application of RDM.
+  //
+  void DeselectAllVolumes();
+  // Remove all logical volumes from RDM applications.
+  //
+  void SetDecayBias (G4String filename);
+  //   Sets the decay biasing scheme using the data in "filename"
+  //
+  void SetHLThreshold (G4double hl) {halflifethreshold = hl;}
+  // Set the half-life threshold for isomer production
+  //
+  void SetICM (G4bool icm) {applyICM = icm;}
+  // Enable/disable ICM
+  //
+  void SetARM (G4bool arm) {applyARM = arm;}
+  // Enable/disable ARM
+  //
+  void SetSourceTimeProfile (G4String filename) ;
+  //  Sets source exposure function using histograms in "filename"
+  //
+  G4bool IsRateTableReady(const G4ParticleDefinition &);
+  // Returns true if the coefficient and decay time table for all the
+  // descendants of the specified isotope are ready.
+  //
+  // used in VR decay mode only
+  //
+  void AddDecayRateTable(const G4ParticleDefinition &);
+  // Calculates the coefficient and decay time table for all the descendants
+  // of the specified isotope.  Adds the calculated table to the private data
+  // member "theDecayRateTableVector".
+  //
+  //
+  // used in VR decay mode only
+  //
+  void GetDecayRateTable(const G4ParticleDefinition &);
+  // Used to retrieve the coefficient and decay time table for all the
+  // descendants of the specified isotope from "theDecayRateTableVector"
+  // and place it in "theDecayRateTable".
+  //
+  //
+  // used in VR decay mode only
+  //
+  void SetDecayRate(G4int,G4int,G4double, G4int, std::vector<G4double>,
+                    std::vector<G4double>);
+  // Sets "theDecayRate" with data supplied in the arguements.
+  //
+  //  //
+  // used in VR decay mode only
+  //
+  G4DecayTable *LoadDecayTable (G4ParticleDefinition & theParentNucleus);
+  // Load the decay data of isotope theParentNucleus.
+  //
+  inline void  SetVerboseLevel(G4int value) {verboseLevel = value;}
+  // Sets the VerboseLevel which controls duggering display.
+  //
+  inline G4int GetVerboseLevel() const {return verboseLevel;}
+  // Returns the VerboseLevel which controls level of debugging output.
+  //
+  inline void SetNucleusLimits(G4NucleusLimits theNucleusLimits1)
+  {theNucleusLimits = theNucleusLimits1 ;}
+  //  Sets theNucleusLimits which specifies the range of isotopes
+  //  the G4RadioactiveDecay applies.
+  //
+  inline G4NucleusLimits GetNucleusLimits() const
+  {return theNucleusLimits;}
+  //  Returns theNucleusLimits which specifies the range of isotopes
+  //  the G4RadioactiveDecay applies.
+  //
+  inline void SetAnalogueMonteCarlo (G4bool r ) { AnalogueMC  = r; }
+  //   Controls whether G4RadioactiveDecay runs in analogue mode or
+  //   variance reduction mode.
+  inline void SetFBeta (G4bool r ) { FBeta  = r; }
+  //   Controls whether G4RadioactiveDecay uses fast beta simulation mode
+  //
+  inline G4bool IsAnalogueMonteCarlo () {return AnalogueMC;}
+  //   Returns true if the simulation is an analogue Monte Carlo, and false if
+  //   any of the biassing schemes have been selected.
+  //
+  inline void SetBRBias (G4bool r ) { BRBias  = r;
+  SetAnalogueMonteCarlo(0);}
+  //   Sets whether branching ration bias scheme applies.
+  //
+  inline void SetSplitNuclei (G4int r) { NSplit = r; SetAnalogueMonteCarlo(0); }
+  //  Sets the N number for the Nuclei spliting bias scheme
+  //
+  inline G4int GetSplitNuclei () {return NSplit;}
+  //  Returns the N number used for the Nuclei spliting bias scheme
+  //
+        G4RadioactiveDecay (const G4String& processName="RadioactiveDecay");
+        ~G4RadioactiveDecay();
+        // constructor and destructor
+        //
+        G4bool IsApplicable(const G4ParticleDefinition &);
+        // Returns true if the specified isotope is
+        //  1) defined as "nucleus" and
+        //  2) it is within theNucleusLimit
+        //
+        G4bool IsLoaded (const G4ParticleDefinition &);
+        // Returns true if the decay table of the specified nuclei is ready.
+        //
+        void SelectAVolume(const G4String aVolume);
+        // Select a logical volume in which RDM applies.
+        //
+        void DeselectAVolume(const G4String aVolume);
+        // remove a logical volume from the RDM applied list
+        //
+        void SelectAllVolumes();
+        // Select all logical volumes for the application of RDM.
+        //
+        void DeselectAllVolumes();
+        // Remove all logical volumes from RDM applications.
+        //
+        void SetDecayBias (G4String filename);
+        //   Sets the decay biasing scheme using the data in "filename"
+        //
+        void SetHLThreshold (G4double hl) {halflifethreshold = hl;}
+        // Set the half-life threshold for isomer production
+        //
+        void SetICM (G4bool icm) {applyICM = icm;}
+        // Enable/disable ICM
+        //
+        void SetARM (G4bool arm) {applyARM = arm;}
+        // Enable/disable ARM
+        //
+        void SetSourceTimeProfile (G4String filename) ;
+        //  Sets source exposure function using histograms in "filename"
+        //
+        G4bool IsRateTableReady(const G4ParticleDefinition &);
+        // Returns true if the coefficient and decay time table for all the
+        // descendants of the specified isotope are ready.
+        //
+        // used in VR decay mode only
+        //
+        void AddDecayRateTable(const G4ParticleDefinition &);
+        // Calculates the coefficient and decay time table for all the descendants
+        // of the specified isotope.  Adds the calculated table to the private data
+        // member "theDecayRateTableVector".
+        //
+        //
+        // used in VR decay mode only
+        //
+        void GetDecayRateTable(const G4ParticleDefinition &);
+        // Used to retrieve the coefficient and decay time table for all the
+        // descendants of the specified isotope from "theDecayRateTableVector"
+        // and place it in "theDecayRateTable".
+        //
+        //
+        // used in VR decay mode only
+        //
+        void SetDecayRate(G4int,G4int,G4double, G4int, std::vector<G4double>,
+                std::vector<G4double>);
+        // Sets "theDecayRate" with data supplied in the arguements.
+        //
+        //  //
+        // used in VR decay mode only
+        //
+        std::vector<G4RadioactivityTable*> GetTheRadioactivityTables() {return theRadioactivityTables;}
+        // return the vector of G4Radioactivity map
+        // should be used in VR mode only
+        G4DecayTable *LoadDecayTable (G4ParticleDefinition & theParentNucleus);
+        // Load the decay data of isotope theParentNucleus.
+        //
+        inline void  SetVerboseLevel(G4int value) {verboseLevel = value;}
+        // Sets the VerboseLevel which controls duggering display.
+        //
+        inline G4int GetVerboseLevel() const {return verboseLevel;}
+        // Returns the VerboseLevel which controls level of debugging output.
+        //
+        inline void SetNucleusLimits(G4NucleusLimits theNucleusLimits1)
+        {theNucleusLimits = theNucleusLimits1 ;}
+        //  Sets theNucleusLimits which specifies the range of isotopes
+        //  the G4RadioactiveDecay applies.
+        //
+        inline G4NucleusLimits GetNucleusLimits() const
+        {return theNucleusLimits;}
+        //  Returns theNucleusLimits which specifies the range of isotopes
+        //  the G4RadioactiveDecay applies.
+        //
+        inline void SetAnalogueMonteCarlo (G4bool r ) {
+          AnalogueMC  = r;
+          if (!AnalogueMC) halflifethreshold = 1e-6*s;
+        }
+        //   Controls whether G4RadioactiveDecay runs in analogue mode or
+        //   variance reduction mode.
+        inline void SetFBeta (G4bool r ) { FBeta  = r; }
+        //   Controls whether G4RadioactiveDecay uses fast beta simulation mode
+        //
+        inline G4bool IsAnalogueMonteCarlo () {return AnalogueMC;}
+        //   Returns true if the simulation is an analogue Monte Carlo, and false if
+        //   any of the biassing schemes have been selected.
+        //
+        inline void SetBRBias (G4bool r ) { BRBias  = r;
+        SetAnalogueMonteCarlo(0);}
+        //   Sets whether branching ration bias scheme applies.
+        //
+        inline void SetSplitNuclei (G4int r) { NSplit = r; SetAnalogueMonteCarlo(0); }
+        //  Sets the N number for the Nuclei spliting bias scheme
+        //
+        inline G4int GetSplitNuclei () {return NSplit;}
+        //  Returns the N number used for the Nuclei spliting bias scheme
+        //
 public:
   void BuildPhysicsTable(const G4ParticleDefinition &);
+        void BuildPhysicsTable(const G4ParticleDefinition &);
 protected:
   G4VParticleChange* DecayIt( const G4Track& theTrack,
                               const G4Step&  theStep);
   G4DecayProducts* DoDecay(G4ParticleDefinition& theParticleDef);
   G4double GetMeanFreePath(const G4Track& theTrack,
                            G4double previousStepSize,
                            G4ForceCondition* condition);
   G4double GetMeanLifeTime(const G4Track& theTrack,
                            G4ForceCondition* condition);
   G4double GetTaoTime(G4double,G4double);
   G4double GetDecayTime();
   G4int GetDecayTimeBin(const G4double aDecayTime);
+        G4VParticleChange* DecayIt( const G4Track& theTrack,
+                const G4Step&  theStep);
+        G4DecayProducts* DoDecay(G4ParticleDefinition& theParticleDef);
+        G4double GetMeanFreePath(const G4Track& theTrack,
+                G4double previousStepSize,
+                G4ForceCondition* condition);
+        G4double GetMeanLifeTime(const G4Track& theTrack,
+                G4ForceCondition* condition);
+        G4double GetTaoTime(G4double,G4double);
+        G4double GetDecayTime();
+        G4int GetDecayTimeBin(const G4double aDecayTime);
 private:
   G4RadioactiveDecay(const G4RadioactiveDecay &right);
   G4RadioactiveDecay & operator=(const G4RadioactiveDecay &right);
+        G4RadioactiveDecay(const G4RadioactiveDecay &right);
+        G4RadioactiveDecay & operator=(const G4RadioactiveDecay &right);
 private:
+  G4RadioactiveDecaymessenger  *theRadioactiveDecaymessenger;
+  G4PhysicsTable               *aPhysicsTable;
+  G4RIsotopeTable              *theIsotopeTable;
+  G4NucleusLimits               theNucleusLimits;
+  const G4double                HighestBinValue;
+  const G4double                LowestBinValue;
+  const G4int                   TotBin;
+  G4bool                        AnalogueMC;
+  G4bool                        BRBias;
+  G4bool                        FBeta;
+  G4int                         NSplit;
+  G4double                      halflifethreshold;
+  G4bool                        applyICM;
+  G4bool                        applyARM;
+  G4int                         NSourceBin;
+  G4double                      SBin[99];
+  G4double                      SProfile[99];
+  G4int                         NDecayBin;
+  G4double                      DBin[99];
+  G4double                      DProfile[99];
+  std::vector<G4String>         LoadedNuclei;
+  std::vector<G4String>         ValidVolumes;
+  G4RadioactiveDecayRate        theDecayRate;
+  G4RadioactiveDecayRates       theDecayRateVector;
+  G4RadioactiveDecayRateVector  theDecayRateTable;
+  G4RadioactiveDecayRateTable   theDecayRateTableVector;
+  static const G4double         levelTolerance;
+  // Remainder of life time at rest
+  G4double                      fRemainderLifeTime;
+  G4int                         verboseLevel;
+  // ParticleChange for decay process
+  G4ParticleChangeForRadDecay   fParticleChangeForRadDecay;
+  inline G4double AtRestGetPhysicalInteractionLength
+    (const G4Track& track, G4ForceCondition* condition)
+  {fRemainderLifeTime = G4VRestDiscreteProcess::
+    AtRestGetPhysicalInteractionLength(track, condition );
+  return fRemainderLifeTime;}
+  inline G4VParticleChange* AtRestDoIt
+    (const G4Track& theTrack, const G4Step& theStep)
+  {return DecayIt(theTrack, theStep);}
+  inline G4VParticleChange* PostStepDoIt
+    (const G4Track& theTrack, const G4Step& theStep)
+  {return DecayIt(theTrack, theStep);}
+        G4RadioactiveDecaymessenger  *theRadioactiveDecaymessenger;
+        G4PhysicsTable               *aPhysicsTable;
+        G4RIsotopeTable              *theIsotopeTable;
+        G4NucleusLimits               theNucleusLimits;
+        const G4double                HighestBinValue;
+        const G4double                LowestBinValue;
+        const G4int                   TotBin;
+        G4bool                        AnalogueMC;
+        G4bool                        BRBias;
+        G4bool                        FBeta;
+        G4int                         NSplit;
+        G4double                      halflifethreshold;
+        G4bool                        applyICM;
+        G4bool                        applyARM;
+        G4int                         NSourceBin;
+        G4double                      SBin[99];
+        G4double                      SProfile[99];
+        G4int                         NDecayBin;
+        G4double                      DBin[99];
+        G4double                      DProfile[99];
+        std::vector<G4String>         LoadedNuclei;
+        std::vector<G4String>         ValidVolumes;
+        G4RadioactiveDecayRate        theDecayRate;
+        G4RadioactiveDecayRates       theDecayRateVector;
+        G4RadioactiveDecayRateVector  theDecayRateTable;
+        G4RadioactiveDecayRateTable   theDecayRateTableVector;
+        // for the radioactivity tables
+        std::vector<G4RadioactivityTable*>      theRadioactivityTables;
+        G4int                         decayWindows[99];
+        //
+        static const G4double             levelTolerance;
+        // Remainder of life time at rest
+        G4double                      fRemainderLifeTime;
+        G4int                         verboseLevel;
+        // ParticleChange for decay process
+        G4ParticleChangeForRadDecay   fParticleChangeForRadDecay;
+        inline G4double AtRestGetPhysicalInteractionLength
+                (const G4Track& track, G4ForceCondition* condition)
+        {fRemainderLifeTime = G4VRestDiscreteProcess::
+        AtRestGetPhysicalInteractionLength(track, condition );
+        return fRemainderLifeTime;}
+        inline G4VParticleChange* AtRestDoIt
+                (const G4Track& theTrack, const G4Step& theStep)
+        {return DecayIt(theTrack, theStep);}
+        inline G4VParticleChange* PostStepDoIt
+                (const G4Track& theTrack, const G4Step& theStep)
+        {return DecayIt(theTrack, theStep);}
 };

trunk/source/processes/hadronic/models/radioactive_decay/src/G4RadioactiveDecay.cc

-              r1340
+              r1347
 // Constructor
 //
+G4RadioactiveDecay::G4RadioactiveDecay
+  (const G4String& processName)
+  :G4VRestDiscreteProcess(processName, fDecay), HighestBinValue(10.0),
+   LowestBinValue(1.0e-3), TotBin(200), verboseLevel(0)
+G4RadioactiveDecay::G4RadioactiveDecay (const G4String& processName)
+ :G4VRestDiscreteProcess(processName, fDecay), HighestBinValue(10.0),
+  LowestBinValue(1.0e-3), TotBin(200), verboseLevel(0)
+{
 #ifdef G4VERBOSE
 …
   aPhysicsTable                = 0;
   pParticleChange              = &fParticleChangeForRadDecay;
   //
   // Now register the Isotopetable with G4IonTable.
 …
   NSourceBin  = 1;
   SBin[0]     = 0.* s;
   SBin[1]     = 1e10 * s;
+  SBin[1]     = 1.* s;
   SProfile[0] = 1.;
   SProfile[1] = 1.;
+  SProfile[1] = 0.;
   NDecayBin   = 1;
   DBin[0]     = 9.9e9 * s ;
   DBin[1]     = 1e10 * s;
+  DBin[0]     = 0. * s ;
+  DBin[1]     = 1. * s;
   DProfile[0] = 1.;
   DProfile[1] = 0.;
+  decayWindows[0] = 0;
+  G4RadioactivityTable* rTable = new G4RadioactivityTable() ;
+  theRadioactivityTables.push_back(rTable);
   NSplit      = 1;
   AnalogueMC  = true ;
 …
       delete aPhysicsTable;
+    }
   //  delete theIsotopeTable;
   delete theRadioactiveDecaymessenger;
+  //    delete theIsotopeTable;
+    delete theRadioactiveDecaymessenger;
+}
 …
 //
 G4bool G4RadioactiveDecay::IsApplicable( const G4ParticleDefinition &
   aParticle)
+                                         aParticle)
+{
   //
 …
 //
 G4bool G4RadioactiveDecay::IsLoaded(const G4ParticleDefinition &
   aParticle)
+                                    aParticle)
+{
   //
 …
   //
   return std::binary_search(LoadedNuclei.begin(),
                        LoadedNuclei.end(),
                        aParticle.GetParticleName());
+                            LoadedNuclei.end(),
+                            aParticle.GetParticleName());
+}
 ////////////////////////////////////////////////////////////////////////////////
 …
 void G4RadioactiveDecay::SelectAVolume(const G4String aVolume)
+{
   G4LogicalVolumeStore *theLogicalVolumes;
   G4LogicalVolume *volume;
 …
     G4cout << " RDM removed from all volumes" << G4endl;
 #endif
+}
 …
 //
 G4bool G4RadioactiveDecay::IsRateTableReady(const G4ParticleDefinition &
   aParticle)
+                                            aParticle)
+{
   //
 …
+    {
       if (theDecayRateTableVector[i].GetIonName() == aParticleName)
         return true ;
+        return true ;
+    }
   return false;
 …
 //
 void G4RadioactiveDecay::GetDecayRateTable(const G4ParticleDefinition &
   aParticle)
+                                           aParticle)
+{
 …
+    }
 #ifdef G4VERBOSE
         if (GetVerboseLevel()>0)
+          {
             G4cout <<"The DecayRate Table for "
                    << aParticleName << " is selected." <<  G4endl;
+          }
+  if (GetVerboseLevel()>0)
+    {
+      G4cout <<"The DecayRate Table for "
+             << aParticleName << " is selected." <<  G4endl;
+    }
 #endif
+}
 …
 // GetTaoTime
 //
 // to perform the convilution of the sourcetimeprofile function with the
+// to perform the convolution of the source time profile function with the
 // decay constants in the decay chain.
 //
 …
+  }
   taotime +=  SProfile[nbin] * (1-std::exp(-(t-SBin[nbin])/tao));
+  if (taotime < 0.)  {
+    G4cout <<" Tao time: " <<taotime << " reset to zero!"<<G4endl;
+    taotime = 0.;
+  }
 #ifdef G4VERBOSE
   if (GetVerboseLevel()>1)
     {G4cout <<" Tao time: " <<taotime <<G4endl;}
 #endif
   return  taotime ;
+}
+  return taotime ;
+}
 ////////////////////////////////////////////////////////////////////////////////
 //
 …
 #ifdef G4VERBOSE
   if (GetVerboseLevel()>1)
     {G4cout <<" Decay time: " <<decaytime <<"[ns]" <<G4endl;}
+    {G4cout <<" Decay time: " <<decaytime/s <<"[s]" <<G4endl;}
 #endif
   return  decaytime;
 …
 G4int G4RadioactiveDecay::GetDecayTimeBin(const G4double aDecayTime)
+{
+  for (G4int i = 0; i < NDecayBin; i++)
+    {
+      if ( aDecayTime > DBin[i]) return i+1;
+    }
+  return  1;
+  G4int i = 0;
+  while ( aDecayTime > DBin[i] ) i++;
+  return  i;
+}
 ////////////////////////////////////////////////////////////////////////////////
 …
     G4ParticleDefinition* theParticleDef = theParticle->GetDefinition();
     G4double theLife = theParticleDef->GetPDGLifeTime();
 #ifdef G4VERBOSE
     if (GetVerboseLevel()>2)
 …
     else if (theLife < 0.0) {meanlife = DBL_MAX;}
     else {meanlife = theLife;}
   // set the meanlife to zero for excited istopes which is not in the RDM database
+    // set the meanlife to zero for excited istopes which is not in the RDM database
     if (((const G4Ions*)(theParticleDef))->GetExcitationEnergy() > 0. && meanlife == DBL_MAX) {meanlife = 0.;}
+  }
 #ifdef G4VERBOSE
   if (GetVerboseLevel()>1)
     {G4cout <<"mean life time: " <<meanlife <<"[ns]" <<G4endl;}
 #endif
+    {G4cout <<"mean life time: " <<meanlife/s <<"[s]" <<G4endl;}
+#endif
   return  meanlife;
+}
 …
   // constants
   G4bool isOutRange ;
   // get particle
   const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
   // returns the mean free path in GEANT4 internal units
   G4double pathlength;
 …
   G4double aCtau = c_light * aParticleDef->GetPDGLifeTime();
   G4double aMass = aParticle->GetMass();
 #ifdef G4VERBOSE
   if (GetVerboseLevel()>2) {
 …
+  }
 #endif
   // check if the particle is stable?
   if (aParticleDef->GetPDGStable()) {
     pathlength = DBL_MAX;
   } else if (aCtau < 0.0) {
     pathlength =  DBL_MAX;
     //check if the particle has very short life time ?
   } else if (aCtau < DBL_MIN) {
     pathlength =  DBL_MIN;
     //check if zero mass
   } else if (aMass <  DBL_MIN)  {
 …
+    }
 #endif
    } else {
      //calculate the mean free path
      // by using normalized kinetic energy (= Ekin/mass)
      G4double   rKineticEnergy = aParticle->GetKineticEnergy()/aMass;
      if ( rKineticEnergy > HighestBinValue) {
        // beta >> 1
        pathlength = ( rKineticEnergy + 1.0)* aCtau;
      } else if ( rKineticEnergy > LowestBinValue) {
        // check if aPhysicsTable exists
        if (aPhysicsTable == 0) BuildPhysicsTable(*aParticleDef);
        // beta is in the range valid for PhysicsTable
        pathlength = aCtau *
          ((*aPhysicsTable)(0))-> GetValue(rKineticEnergy,isOutRange);
      } else if ( rKineticEnergy < DBL_MIN ) {
        // too slow particle
 #ifdef G4VERBOSE
        if (GetVerboseLevel()>2) {
          G4cout << "G4Decay::GetMeanFreePath()   !!particle stops!!";
          G4cout << aParticleDef->GetParticleName() << G4endl;
          G4cout << "KineticEnergy:" << aParticle->GetKineticEnergy()/GeV <<"[GeV]";
+       }
 #endif
        pathlength = DBL_MIN;
      } else {
        // beta << 1
        pathlength = (aParticle->GetTotalMomentum())/aMass*aCtau ;
+     }
+   }
 #ifdef G4VERBOSE
    if (GetVerboseLevel()>1) {
      G4cout << "mean free path: "<< pathlength/m << "[m]" << G4endl;
+   }
 #endif
    return  pathlength;
+  } else {
+    //calculate the mean free path
+    // by using normalized kinetic energy (= Ekin/mass)
+    G4double   rKineticEnergy = aParticle->GetKineticEnergy()/aMass;
+    if ( rKineticEnergy > HighestBinValue) {
+      // beta >> 1
+      pathlength = ( rKineticEnergy + 1.0)* aCtau;
+    } else if ( rKineticEnergy > LowestBinValue) {
+      // check if aPhysicsTable exists
+      if (aPhysicsTable == 0) BuildPhysicsTable(*aParticleDef);
+      // beta is in the range valid for PhysicsTable
+      pathlength = aCtau *
+        ((*aPhysicsTable)(0))-> GetValue(rKineticEnergy,isOutRange);
+    } else if ( rKineticEnergy < DBL_MIN ) {
+      // too slow particle
+#ifdef G4VERBOSE
+      if (GetVerboseLevel()>2) {
+        G4cout << "G4Decay::GetMeanFreePath()   !!particle stops!!";
+        G4cout << aParticleDef->GetParticleName() << G4endl;
+        G4cout << "KineticEnergy:" << aParticle->GetKineticEnergy()/GeV <<"[GeV]";
+      }
+#endif
+      pathlength = DBL_MIN;
+    } else {
+      // beta << 1
+      pathlength = (aParticle->GetTotalMomentum())/aMass*aCtau ;
+    }
+  }
+#ifdef G4VERBOSE
+  if (GetVerboseLevel()>1) {
+    G4cout << "mean free path: "<< pathlength/m << "[m]" << G4endl;
+  }
+#endif
+  return  pathlength;
+}
 ////////////////////////////////////////////////////////////////////////////////
 …
   G4int i;
   for ( i = 0 ; i < TotBin ; i++ ) {
       gammainv = 1.0/(aVector->GetLowEdgeEnergy(i) + 1.0);
       beta  = std::sqrt((1.0 - gammainv)*(1.0 +gammainv));
       aVector->PutValue(i, beta/gammainv);
+    gammainv = 1.0/(aVector->GetLowEdgeEnergy(i) + 1.0);
+    beta  = std::sqrt((1.0 - gammainv)*(1.0 +gammainv));
+    aVector->PutValue(i, beta/gammainv);
+  }
   aPhysicsTable->insert(aVector);
 …
     G4cout << "Please setenv G4RADIOACTIVEDATA to point to the radioactive decay data files." << G4endl;
     throw G4HadronicException(__FILE__, __LINE__,
               "Please setenv G4RADIOACTIVEDATA to point to the radioactive decay data files.");
+                              "Please setenv G4RADIOACTIVEDATA to point to the radioactive decay data files.");
+  }
   G4String dirName = getenv("G4RADIOACTIVEDATA");
 …
   G4String file = os.str();
   std::ifstream DecaySchemeFile(file);
   G4bool found(false);
 …
       modeSumBR[i]       = 0.0;
+    }
     G4bool complete(false);
     char inputChars[80]={' '};
 …
             a/=1000.;
             c/=1000.;
             //  cout<< "The decay mode is [LoadTable] "<<theDecayMode<<G4endl;
             switch (theDecayMode) {
             case IT:
 …
                     e0 = c*MeV/0.511;
                     n = aBetaFermiFunction->GetFFN(e0);
                     // now to work out the histogram and initialise the random generator
                     G4int npti = 100;
 …
                       // Special treatment for K-40 (problem #1068) (flei,06/05/2010)
                       if (theParentNucleus.GetParticleName() == "K40[0.0]") f *=
                         (std::pow((g*g-1),3)+std::pow((ee-g),6)+7*(g*g-1)*std::pow((ee-g),2)*(g*g-1+std::pow((ee-g),2)));
+                                                                              (std::pow((g*g-1),3)+std::pow((ee-g),6)+7*(g*g-1)*std::pow((ee-g),2)*(g*g-1+std::pow((ee-g),2)));
                       pdf[ptn] = f*aBetaFermiFunction->GetFF(e);
+                    }
 …
                   if (e0 > 0.) {
                     G4BetaFermiFunction* aBetaFermiFunction = new G4BetaFermiFunction (A, -(Z-1));
                     n = aBetaFermiFunction->GetFFN(e0);
                     // now to work out the histogram and initialise the random generator
                     G4int npti = 100;
 …
                     theDecayTable->Insert(aBetaPlusChannel);
                     modeSumBR[2] += b;
                     delete[] pdf;
                     delete aBetaFermiFunction;
 …
                 G4Exception("G4RadioactiveDecay::LoadDecayTable()", "601",
                             FatalException, "Error in decay mode selection");
+              }
+            }
 …
 //
 void G4RadioactiveDecay::SetDecayRate(G4int theZ, G4int theA, G4double theE,
                                        G4int theG, std::vector<G4double> theRates,
                                        std::vector<G4double> theTaos)
+                                      G4int theG, std::vector<G4double> theRates,
+                                      std::vector<G4double> theTaos)
+{
   //fill the decay rate vector
 …
   // 2) Add the coefficiencies to the decay rate table vector
   //
   //
   // Create and initialise variables used in the method.
 …
   theDecayRateVector.clear();
   G4int nGeneration = 0;
   std::vector<G4double> rates;
   std::vector<G4double> taos;
   // start rate is -1.
+  // Eq.4.26 of the Technical Note
   rates.push_back(-1.);
   //
 …
   G4double E = ((const G4Ions*)(&theParentNucleus))->GetExcitationEnergy();
   G4double tao = theParentNucleus.GetPDGLifeTime();
+  if (tao < 0.) tao = 1e-30;
   taos.push_back(tao);
   G4int nEntry = 0;
   //fill the decay rate with the intial isotope data
   SetDecayRate(Z,A,E,nGeneration,rates,taos);
 …
   G4AlphaDecayChannel *theAlphaChannel = 0;
   G4RadioactiveDecayMode theDecayMode;
-  //  G4NuclearLevelManager levelManager;
-  //const G4NuclearLevel* level;
   G4double theBR = 0.0;
   G4int AP = 0;
 …
   //
   theIonTable = (G4IonTable *)(G4ParticleTable::GetParticleTable()->GetIonTable());
   while (!stable) {
     nGeneration++;
 …
         aParentNucleus->SetDecayTable(LoadDecayTable(*aParentNucleus));
+      }
+      G4DecayTable *theDecayTable = new G4DecayTable();
       aTempDecayTable = aParentNucleus->GetDecayTable();
+      for (i=0; i< 7; i++) brs[i] = 0.0;
       //
       //
       // Go through the decay table and to combine the same decay channels
       //
-      for (i=0; i< 7; i++) brs[i] = 0.0;
-      G4DecayTable *theDecayTable = new G4DecayTable();
       for (i=0; i<aTempDecayTable->entries(); i++) {
         theChannel             = aTempDecayTable->GetDecayChannel(i);
 …
           if (std::abs(daughterExcitation - level->Energy()) < levelTolerance) {
+            // Level hafe life is in ns and the gate as 1 micros by default
+            if ( theDecayMode == 0 && level->HalfLife()*ns >= halflifethreshold ){
+              // some further though may needed here
+            // Level half-life is in ns and the threshold is set to 1 micros by default, user can set it via the UI command
+            if (level->HalfLife()*ns >= halflifethreshold ){
+              // save the metastable nucleus
               theDecayTable->Insert(theChannel);
+            }
 …
       brs[3] = brs[4] =brs[5] =  0.0;
       for (i= 0; i<7; i++){
         if (brs[i] > 0) {
+        if (brs[i] > 0.) {
           switch ( i ) {
           case 0:
 …
             // Decay mode is isomeric transition.
             //
             theITChannel =  new G4ITDecayChannel
               (0, (const G4Ions*) aParentNucleus, brs[0]);
             theDecayTable->Insert(theITChannel);
             break;
           case 1:
             //
 …
                                                                brs[1], 0.*MeV, 0.*MeV, 1, false, 0);
             theDecayTable->Insert(theBetaMinusChannel);
             break;
           case 2:
             //
 …
             theDecayTable->Insert(theBetaPlusChannel);
             break;
           case 6:
             //
 …
             theDecayTable->Insert(theAlphaChannel);
             break;
           default:
             break;
 …
+        }
+      }
       //
       // loop over all braches in theDecayTable
 …
         theBR = theChannel->GetBR();
         theDaughterNucleus = theNuclearDecayChannel->GetDaughterNucleus();
+        //
+        // now test if the daughterNucleus is a valid one
+        //
+        if (IsApplicable(*theDaughterNucleus) && theBR
+            && aParentNucleus != theDaughterNucleus ) {
+        //  first check if the decay of the original nucleus is an IT channel, if true create a new groud-level nucleus
+        if (theNuclearDecayChannel->GetDecayMode() == IT && nGeneration == 1 ) {
+            A = ((const G4Ions*)(theDaughterNucleus))->GetAtomicMass();
+            Z = ((const G4Ions*)(theDaughterNucleus))->GetAtomicNumber();
+            theDaughterNucleus=theIonTable->GetIon(Z,A,0.);
+        }
+        if (IsApplicable(*theDaughterNucleus) && theBR && aParentNucleus != theDaughterNucleus) {
           // need to make sure daugher has decaytable
           if (!IsLoaded(*theDaughterNucleus)){
 …
             Z = ((const G4Ions*)(theDaughterNucleus))->GetAtomicNumber();
             E = ((const G4Ions*)(theDaughterNucleus))->GetExcitationEnergy();
             TaoPlus = theDaughterNucleus->GetPDGLifeTime();
             //          cout << TaoPlus <<G4endl;
+            if (TaoPlus > 0.) {
+              // first set the taos, one simply need to add to the parent ones
+              taos.clear();
+              taos = TP;
+              taos.push_back(TaoPlus);
+              // now calculate the coefficiencies
+              //
+              // they are in two parts, first the les than n ones
+              rates.clear();
+              size_t k;
+              for (k = 0; k < RP.size(); k++){
+            if (TaoPlus <= 0.)  TaoPlus = 1e-30;
+            // first set the taos, one simply need to add to the parent ones
+            taos.clear();
+            taos = TP;
+            taos.push_back(TaoPlus);
+            // now calculate the coefficiencies
+            //
+            // they are in two parts, first the less than n ones
+            // Eq 4.24 of the TN
+            rates.clear();
+            size_t k;
+            for (k = 0; k < RP.size(); k++){
+              if ((TP[k]-TaoPlus) == 0.) {
+                theRate =  1e30;
+              } else {
                 theRate = TP[k]/(TP[k]-TaoPlus) * theBR * RP[k];
-                rates.push_back(theRate);
+              }
+              //
+              // the sencond part: the n:n coefficiency
+              theRate = 0.;
+              for (k = 0; k < RP.size(); k++){
+                theRate -=TaoPlus/(TP[k]-TaoPlus) * theBR * RP[k];
+              rates.push_back(theRate);
+            }
+            //
+            // the sencond part: the n:n coefficiency
+            // Eq 4.25 of the TN.  Note Yn+1 is zero apart from Y1 which is -1 as treated at line 1013
+            //
+            theRate = 0.;
+            G4double aRate;
+            for (k = 0; k < RP.size(); k++){
+              if ((TP[k]-TaoPlus) == 0.) {
+                aRate =  1e30;
+              } else {
+                aRate = TaoPlus/(TP[k]-TaoPlus) * theBR * RP[k];
+              }
+              rates.push_back(theRate);
+              SetDecayRate (Z,A,E,nGeneration,rates,taos);
+              theDecayRateVector.push_back(theDecayRate);
+              nEntry++;
+            }
+              theRate -= aRate;
+            }
+            rates.push_back(theRate);
+            SetDecayRate (Z,A,E,nGeneration,rates,taos);
+            theDecayRateVector.push_back(theDecayRate);
+            nEntry++;
+          }
+        }
 …
     if (nS == nT) stable = true;
+  }
   //end of while loop
   // the calculation completed here
   // fill the first part of the decay rate table
   // which is the name of the original particle (isotope)
 …
   // now fill the decay table with the newly completed decay rate vector
   //
   theDecayRateTable.SetItsRates(theDecayRateVector);
   //
   // finally add the decayratetable to the tablevector
 …
   theDecayRateTableVector.push_back(theDecayRateTable);
+}
 ////////////////////////////////////////////////////////////////////////////////
 //
 …
   std::ifstream infile ( filename, std::ios::in );
   if ( !infile ) G4Exception(__FILE__, G4inttostring(__LINE__), FatalException,  "Unable to open source data file" );
   float bin, flux;
+  G4double bin, flux;
   NSourceBin = -1;
   while (infile >> bin >> flux ) {
 …
+  }
   SetAnalogueMonteCarlo(0);
+  infile.close();
 #ifdef G4VERBOSE
   if (GetVerboseLevel()>1)
 …
   std::ifstream infile ( filename, std::ios::in);
   if ( !infile ) G4Exception(__FILE__, G4inttostring(__LINE__), FatalException,  "Unable to open bias data file" );
+  float bin, flux;
+  G4double bin, flux;
+  G4int dWindows = 0;
+  G4int i ;
+  theRadioactivityTables.clear();
+  //  for (i = 0; i<100; i++) decayWindows[i] = -1;
   NDecayBin = -1;
   while (infile >> bin >> flux ) {
 …
     DBin[NDecayBin] = bin * s;
     DProfile[NDecayBin] = flux;
+    if (flux > 0.) {
+      decayWindows[NDecayBin] = dWindows;
+      dWindows++;
+      G4RadioactivityTable *rTable = new G4RadioactivityTable() ;
+      theRadioactivityTables.push_back(rTable);
+    }
+  }
-  G4int i ;
   for ( i = 1; i<= NDecayBin; i++) DProfile[i] += DProfile[i-1];
   for ( i = 0; i<= NDecayBin; i++) DProfile[i] /= DProfile[NDecayBin];
+  // converted to accumulated probabilities
+  //
   SetAnalogueMonteCarlo(0);
+  infile.close();
 #ifdef G4VERBOSE
   if (GetVerboseLevel()>1)
 …
 ////////////////////////////////////////////////////////////////////////////////
 //
-//
 // DecayIt
 //
 G4VParticleChange* G4RadioactiveDecay::DecayIt(const G4Track& theTrack, const G4Step& )
+{
+  //
+G4VParticleChange*
+G4RadioactiveDecay::DecayIt(const G4Track& theTrack, const G4Step&)
+{
   // Initialize the G4ParticleChange object. Get the particle details and the
   // decay table.
+  //
   fParticleChangeForRadDecay.Initialize(theTrack);
   const G4DynamicParticle* theParticle = theTrack.GetDynamicParticle();
 …
   // First check whether RDM applies to the current logical volume
+  //
+  if(!std::binary_search(ValidVolumes.begin(),
+                    ValidVolumes.end(),
+                    theTrack.GetVolume()->GetLogicalVolume()->GetName()))
+    {
+#ifdef G4VERBOSE
+      if (GetVerboseLevel()>0)
+        {
+          G4cout <<"G4RadioactiveDecay::DecayIt : "
+                 << theTrack.GetVolume()->GetLogicalVolume()->GetName()
+                 << " is not selected for the RDM"<< G4endl;
+          G4cout << " There are " << ValidVolumes.size() << " volumes" << G4endl;
+          G4cout << " The Valid volumes are " << G4endl;
+          for (size_t i = 0; i< ValidVolumes.size(); i++)
+            G4cout << ValidVolumes[i] << G4endl;
+        }
+#endif
+      fParticleChangeForRadDecay.SetNumberOfSecondaries(0);
+      //
+      //
+      // Kill the parent particle.
+      //
+      fParticleChangeForRadDecay.ProposeTrackStatus( fStopAndKill ) ;
+      fParticleChangeForRadDecay.ProposeLocalEnergyDeposit(0.0);
+      ClearNumberOfInteractionLengthLeft();
+      return &fParticleChangeForRadDecay;
+  if (!std::binary_search(ValidVolumes.begin(), ValidVolumes.end(),
+                          theTrack.GetVolume()->GetLogicalVolume()->GetName())) {
+#ifdef G4VERBOSE
+    if (GetVerboseLevel()>0) {
+      G4cout <<"G4RadioactiveDecay::DecayIt : "
+             << theTrack.GetVolume()->GetLogicalVolume()->GetName()
+             << " is not selected for the RDM"<< G4endl;
+      G4cout << " There are " << ValidVolumes.size() << " volumes" << G4endl;
+      G4cout << " The Valid volumes are " << G4endl;
+      for (size_t i = 0; i< ValidVolumes.size(); i++) G4cout << ValidVolumes[i] << G4endl;
+    }
+#endif
+    fParticleChangeForRadDecay.SetNumberOfSecondaries(0);
+    // Kill the parent particle.
+    fParticleChangeForRadDecay.ProposeTrackStatus( fStopAndKill ) ;
+    fParticleChangeForRadDecay.ProposeLocalEnergyDeposit(0.0);
+    ClearNumberOfInteractionLengthLeft();
+    return &fParticleChangeForRadDecay;
+  }
   // now check is the particle is valid for RDM
+  //
+  if (!(IsApplicable(*theParticleDef)))
+    {
+      //
+      // The particle is not a Ion or outside the nucleuslimits for decay
+      //
+#ifdef G4VERBOSE
+      if (GetVerboseLevel()>0)
+        {
+          G4cerr <<"G4RadioactiveDecay::DecayIt : "
+                 <<theParticleDef->GetParticleName()
+                 << " is not a valid nucleus for the RDM"<< G4endl;
+        }
+#endif
+      fParticleChangeForRadDecay.SetNumberOfSecondaries(0);
+      //
+      //
+      // Kill the parent particle.
+      //
+      fParticleChangeForRadDecay.ProposeTrackStatus( fStopAndKill ) ;
+      fParticleChangeForRadDecay.ProposeLocalEnergyDeposit(0.0);
+      ClearNumberOfInteractionLengthLeft();
+      return &fParticleChangeForRadDecay;
+  if (!(IsApplicable(*theParticleDef))) {
+    //
+    // The particle is not a Ion or outside the nucleuslimits for decay
+    //
+#ifdef G4VERBOSE
+    if (GetVerboseLevel()>0) {
+      G4cerr <<"G4RadioactiveDecay::DecayIt : "
+             <<theParticleDef->GetParticleName()
+             << " is not a valid nucleus for the RDM"<< G4endl;
+    }
+#endif
+    fParticleChangeForRadDecay.SetNumberOfSecondaries(0);
+    //
+    // Kill the parent particle.
+    //
+    fParticleChangeForRadDecay.ProposeTrackStatus( fStopAndKill ) ;
+    fParticleChangeForRadDecay.ProposeLocalEnergyDeposit(0.0);
+    ClearNumberOfInteractionLengthLeft();
+    return &fParticleChangeForRadDecay;
+  }
   if (!IsLoaded(*theParticleDef))
+    {
 …
+    }
   G4DecayTable *theDecayTable = theParticleDef->GetDecayTable();
   if  (theDecayTable == 0 || theDecayTable->entries() == 0 )
+    {
 …
       G4ThreeVector currentPosition;
       currentPosition = theTrack.GetPosition();
       // check whether use Analogue or VR implementation
       //
 …
         G4double ParentEnergy = theParticle->GetTotalEnergy();
         G4ThreeVector ParentDirection(theParticle->GetMomentumDirection());
         if (theTrack.GetTrackStatus() == fStopButAlive )
+          {
 …
               (products->PopProducts(), finalGlobalTime, currentPosition);
             secondary->SetGoodForTrackingFlag();
                         secondary->SetTouchableHandle(theTrack.GetTouchableHandle());
+            secondary->SetTouchableHandle(theTrack.GetTouchableHandle());
             fParticleChangeForRadDecay.AddSecondary(secondary);
+          }
 …
         if (!IsRateTableReady(*theParticleDef)) {
           // if the decayrates are not ready, calculate them and
           // add to the rate table vector
+          // add to the rate table vector
           AddDecayRateTable(*theParticleDef);
+        }
 …
         G4double taotime;
         G4double decayRate;
         size_t i;
         size_t j;
 …
         for (G4int n = 0; n < NSplit; n++)
+          {
-            /*
-            //
             // Get the decay time following the decay probability function
             // suppllied by user
             //
             G4double theDecayTime = GetDecayTime();
             G4int nbin = GetDecayTimeBin(theDecayTime);
             // claculate the first part of the weight function
+            // calculate the first part of the weight function
+            G4double weight1 =1./DProfile[nbin-1]
+              *(DBin[nbin]-DBin[nbin-1])
+              /NSplit;
+            if (nbin > 1) {
+               weight1 = 1./(DProfile[nbin]-DProfile[nbin-2])
+                 *(DBin[nbin]-DBin[nbin-1])
+                 /NSplit;}
+            G4double weight1 = 1.;
+            if (nbin == 1) {
+              weight1 = 1./DProfile[nbin-1]
+                *(DBin[nbin]-DBin[nbin-1])/NSplit;
+            } else if (nbin > 1) {
+              weight1 = 1./(DProfile[nbin]-DProfile[nbin-2])
+                *(DBin[nbin]-DBin[nbin-1])/NSplit;
+            }
             // it should be calculated in seconds
             weight1 /= s ;
+            */
+            //
             // loop over all the possible secondaries of the nucleus
             // the first one is itself.
+            //
             for ( i = 0; i<theDecayRateVector.size(); i++){
+            for (i = 0; i<theDecayRateVector.size(); i++){
               PZ = theDecayRateVector[i].GetZ();
               PA = theDecayRateVector[i].GetA();
 …
               PR = theDecayRateVector[i].GetDecayRateC();
-              //
-              // Get the decay time following the decay probability function
-              // suppllied by user
-              //
-              G4double theDecayTime = GetDecayTime();
-              G4int nbin = GetDecayTimeBin(theDecayTime);
-              // claculate the first part of the weight function
-              G4double weight1 =1./DProfile[nbin-1]
-                *(DBin[nbin]-DBin[nbin-1])
-                /NSplit;
-              if (nbin > 1) {
-                weight1 = 1./(DProfile[nbin]-DProfile[nbin-2])
-                  *(DBin[nbin]-DBin[nbin-1])
-                  /NSplit;}
-              // it should be calculated in seconds
-              weight1 /= s ;
               // a temprary products buffer and its contents is transfered to
               // the products at the end of the loop
+              //
               G4DecayProducts *tempprods = 0;
               // calculate the decay rate of the isotope
+              // one need to fold the the source bias function with the decaytime
+              //
+              // decayRate is the radioactivity of isotope (PZ,PA,PE) at the
+              // time 'theDecayTime'
+              // it will be used to calculate the statistical weight of the
+              // decay products of this isotope
+              //              G4cout <<"PA= "<< PA << " PZ= " << PZ << " PE= "<< PE  <<G4endl;
               decayRate = 0.;
               for ( j = 0; j < PT.size(); j++){
                 taotime = GetTaoTime(theDecayTime,PT[j]);
                 decayRate -= PR[j] * taotime;
+                // Eq.4.23 of of the TN
+                // note the negative here is required as the rate in the eqation is defined to be negative,
+                // i.e. decay away, but we need pasitive value here.
+                //              G4cout << j << "\t"<< PT[j]/s <<"\t"<<PR[j]<< "\t" << decayRate << G4endl ;
+              }
+              // decayRatehe radioactivity of isotope (PZ,PA,PE) at the
+              // time 'theDecayTime'
+              // it will be used to calculate the statistical weight of the
+              // decay products of this isotope
+              //
               // now calculate the statistical weight
+              //
+              G4double weight = weight1*decayRate;
+              // one need to fold the the source bias function with the decaytime
+              // also need to include the track weight! (F.Lei, 28/10/10)
+              G4double weight = weight1*decayRate*theTrack.GetWeight();
+              // add the isotope to the radioactivity tables
+              //                            G4cout <<theDecayTime/s <<"\t"<<nbin<<G4endl;
+              //G4cout << theTrack.GetWeight() <<"\t"<<weight1<<"\t"<<decayRate<< G4endl;
+              theRadioactivityTables[decayWindows[nbin-1]]->AddIsotope(PZ,PA,PE,weight);
               // decay the isotope
               theIonTable = (G4IonTable *)(G4ParticleTable::GetParticleTable()->GetIonTable());
               parentNucleus = theIonTable->GetIon(PZ,PA,PE);
               // decide whther to apply branching ratio bias or not
               //
 …
                 ndecaych = G4int(theDecayTable->entries()*G4UniformRand());
                 G4VDecayChannel *theDecayChannel = theDecayTable->GetDecayChannel(ndecaych);
+                if (theDecayChannel == 0)
+                  {
+                    // Decay channel not found.
+#ifdef G4VERBOSE
+                    if (GetVerboseLevel()>0)
+                      {
+                        G4cerr <<"G4RadioactiveDecay::DoIt : can not determine decay channel";
+                        G4cerr <<G4endl;
+                        theDecayTable ->DumpInfo();
+                      }
+#endif
+                if (theDecayChannel == 0) {
+                  // Decay channel not found.
+#ifdef G4VERBOSE
+                  if (GetVerboseLevel()>0) {
+                    G4cerr <<"G4RadioactiveDecay::DoIt : can not determine decay channel";
+                    G4cerr <<G4endl;
+                    theDecayTable ->DumpInfo();
+                  }
+                else
+                  {
+                    // A decay channel has been identified, so execute the DecayIt.
+                    G4double tempmass = parentNucleus->GetPDGMass();
+                    tempprods = theDecayChannel->DecayIt(tempmass);
+                    weight *= (theDecayChannel->GetBR())*(theDecayTable->entries());
+                  }
+              }
+              else {
+#endif
+                } else {
+                  // A decay channel has been identified, so execute the DecayIt.
+                  G4double tempmass = parentNucleus->GetPDGMass();
+                  tempprods = theDecayChannel->DecayIt(tempmass);
+                  weight *= (theDecayChannel->GetBR())*(theDecayTable->entries());
+                }
+              } else {
                 tempprods = DoDecay(*parentNucleus);
+              }
+              //
               // save the secondaries for buffers
+              //
               numberOfSecondaries = tempprods->entries();
               currentTime = finalGlobalTime + theDecayTime;
+              for (index=0; index < numberOfSecondaries; index++)
+                {
+                  asecondaryparticle = tempprods->PopProducts();
+                  if (asecondaryparticle->GetDefinition()->GetBaryonNumber() < 5){
+                    pw.push_back(weight);
+                    ptime.push_back(currentTime);
+                    secondaryparticles.push_back(asecondaryparticle);
+                  }
+              for (index=0; index < numberOfSecondaries; index++) {
+                asecondaryparticle = tempprods->PopProducts();
+                if (asecondaryparticle->GetDefinition()->GetBaryonNumber() < 5){
+                  pw.push_back(weight);
+                  ptime.push_back(currentTime);
+                  secondaryparticles.push_back(asecondaryparticle);
+                }
+              //
+              }
               delete tempprods;
               //end of i loop
+            }
             // end of n loop
+          }
+          }
         // now deal with the secondaries in the two stl containers
         // and submmit them back to the tracking manager
 …
                                              secondaryparticles[index], ptime[index], currentPosition);
             secondary->SetGoodForTrackingFlag();
                         secondary->SetTouchableHandle(theTrack.GetTouchableHandle());
+            secondary->SetTouchableHandle(theTrack.GetTouchableHandle());
             secondary->SetWeight(pw[index]);
             fParticleChangeForRadDecay.AddSecondary(secondary);
+            fParticleChangeForRadDecay.AddSecondary(secondary);
+          }
         //
 …
         //theTrack.SetTrackStatus(fStopButAlive);
         //energyDeposit += theParticle->GetKineticEnergy();
+      }
       //
       // Kill the parent particle.
 …
       //
       ClearNumberOfInteractionLengthLeft();
       return &fParticleChangeForRadDecay ;
+    }
+}
+////////////////////////////////////////////////////////////////////////////////
+//
+///////////////////////////////////////////////////////////////////
 //
 // DoDecay
 //
 G4DecayProducts* G4RadioactiveDecay::DoDecay(  G4ParticleDefinition& theParticleDef )
+{
+  G4DecayProducts *products = 0;
   //
+  //
+G4DecayProducts*
+G4RadioactiveDecay::DoDecay(  G4ParticleDefinition& theParticleDef )
+{
+  G4DecayProducts* products = 0;
   // follow the decaytable and generate the secondaries...
+  //
+  //
+#ifdef G4VERBOSE
+  if (GetVerboseLevel()>0)
+    {
+      G4cout<<"Begin of DoDecay..."<<G4endl;
+#ifdef G4VERBOSE
+  if (GetVerboseLevel()>0) G4cout<<"Begin of DoDecay..."<<G4endl;
+#endif
+  G4DecayTable* theDecayTable = theParticleDef.GetDecayTable();
+  // Choose a decay channel.
+#ifdef G4VERBOSE
+  if (GetVerboseLevel()>0) G4cout <<"Selecte a channel..."<<G4endl;
+#endif
+  G4VDecayChannel* theDecayChannel = theDecayTable->SelectADecayChannel();
+  if (theDecayChannel == 0) {
+    // Decay channel not found.
+    G4cerr <<"G4RadioactiveDecay::DoIt : can not determine decay channel";
+    G4cerr <<G4endl;
+    theDecayTable ->DumpInfo();
+  } else {
+    // A decay channel has been identified, so execute the DecayIt.
+#ifdef G4VERBOSE
+    if (GetVerboseLevel()>1) {
+      G4cerr <<"G4RadioactiveDecay::DoIt : selected decay channel  addr:";
+      G4cerr <<theDecayChannel <<G4endl;
+    }
 #endif
+  G4DecayTable *theDecayTable = theParticleDef.GetDecayTable();
+  //
+  // Choose a decay channel.
+  //
+#ifdef G4VERBOSE
+  if (GetVerboseLevel()>0)
+    {
+      G4cout <<"Selecte a channel..."<<G4endl;
+    }
+#endif
+  G4VDecayChannel *theDecayChannel = theDecayTable->SelectADecayChannel();
+  if (theDecayChannel == 0)
+    {
+      // Decay channel not found.
+      //
+      G4cerr <<"G4RadioactiveDecay::DoIt : can not determine decay channel";
+      G4cerr <<G4endl;
+      theDecayTable ->DumpInfo();
+    }
+      else
+    {
+      //
+      // A decay channel has been identified, so execute the DecayIt.
+      //
+#ifdef G4VERBOSE
+      if (GetVerboseLevel()>1)
+        {
+          G4cerr <<"G4RadioactiveDecay::DoIt : selected decay channel  addr:";
+          G4cerr <<theDecayChannel <<G4endl;
+        }
+#endif
+      G4double tempmass = theParticleDef.GetPDGMass();
+      //
+      products = theDecayChannel->DecayIt(tempmass);
+    }
+    G4double tempmass = theParticleDef.GetPDGMass();
+    products = theDecayChannel->DecayIt(tempmass);
+  }
   return products;
+}
+}

trunk/source/processes/hadronic/models/radioactive_decay/src/G4RadioactiveDecaymessenger.cc

-              r1340
+              r1347
   icmCmd->SetParameterName("applyICM",true);
   icmCmd->SetDefaultValue(true);
   icmCmd->AvailableForStates(G4State_PreInit);
+  //icmCmd->AvailableForStates(G4State_PreInit);
   //
   // Command contols whether ARM will be applied or not
 …
   armCmd->SetParameterName("applyARM",true);
   armCmd->SetDefaultValue(true);
   armCmd->AvailableForStates(G4State_PreInit);
+  //armCmd->AvailableForStates(G4State_PreInit);
   //
   // Command to set the h-l thresold for isomer production
 …
   // hlthCmd->SetRange("hlThreshold>0.");
   hlthCmd->SetUnitCategory("Time");
   hlthCmd->AvailableForStates(G4State_PreInit);
+  //  hlthCmd->AvailableForStates(G4State_PreInit);
   //
   // Command to define the incident particle source time profile.
 …
                                     SetNucleusLimits(nucleuslimitsCmd->GetNewNucleusLimitsValue(newValues));}
   else if  (command==analoguemcCmd) {
+    G4int vl;
+    const char* t = newValues;
+    std::istringstream is(t);
+    is >> vl;
+    theRadioactiveDecayContainer->SetAnalogueMonteCarlo(vl!=0);}
+    theRadioactiveDecayContainer->SetAnalogueMonteCarlo(analoguemcCmd->GetNewBoolValue(newValues));}
   else if  (command==fbetaCmd) {
+    G4int vl;
+    const char* t = newValues;
+    std::istringstream is(t);
+    is >> vl;
+    theRadioactiveDecayContainer->SetFBeta(vl!=0);}
+    theRadioactiveDecayContainer->SetFBeta(fbetaCmd->GetNewBoolValue(newValues));}
   else if  (command==avolumeCmd) {theRadioactiveDecayContainer->
                                    SelectAVolume(newValues);}
 …
                                    DeselectAllVolumes();}
   else if  (command==brbiasCmd) {
+    G4int vl;
+    const char* t = newValues;
+    std::istringstream is(t);
+    is >> vl;
+    theRadioactiveDecayContainer->SetBRBias(vl!=0);}
+    theRadioactiveDecayContainer->SetBRBias(brbiasCmd->GetNewBoolValue(newValues));}
   else if (command==sourcetimeprofileCmd) {theRadioactiveDecayContainer->
                                              SetSourceTimeProfile(newValues);}

trunk/source/processes/hadronic/models/rpg/History

-              r1228
+              r1347
    * Please list in reverse chronological order (last date on top)
    ---------------------------------------------------------------
+Nov 2010 - Dennis Wright (hadr-rpg-V09-03-00)
+------------------------------------------------
+G4RPGFragmentation.cc: initialize dndl in ctor as per CoVerity
 Nov 2009 - Dennis Wright (hadr-rpg-V09-02-01)

trunk/source/processes/hadronic/models/util/History

-              r1340
+              r1347
 $Id: History,v 1.40 2010/09/28 17:03:26 vnivanch Exp $
+$Id: History,v 1.45 2010/11/03 17:37:57 gunter Exp $
 -------------------------------------------------------------------
 …
      * Please list in reverse chronological order (last date on top)
      ---------------------------------------------------------------
+Nov 2010 Gunter Folger                        hadr-mod-util-V09-03-07
+- G4Nuclear...Density: migrate to integer A&Z
+Nov 2010 Gunter Folger                        hadr-mod-util-V09-03-06
+- G4KineticTrack: fix coverity warnings of memory leak
+Nov 2010 Vladimir Ivanchenko hadr-mod-util-V09-03-05
+- G4Fragment - improved printout of negative excitation energy
+- G4DecayStrongResonances - constructor and destructor moved to source,
+                            fixed Coverity warning
 Sep 2010 Vladimir Ivanchenko hadr-mod-util-V09-03-04

trunk/source/processes/hadronic/models/util/include/G4DecayStrongResonances.hh

-              r1340
+              r1347
 // ********************************************************************
 //
+// $Id: G4DecayStrongResonances.hh,v 1.9 2010/11/02 17:57:38 vnivanch Exp $
+// GEANT4 tag $Name: geant4-09-04-ref-00 $
+//
+// -------------------------------------------------------------------
+//
+// GEANT4 Class file
+//
+// File name:     G4DecayStrongResonances
+//
+// Modified:
+// 02.11.2010 V.Ivanchenko moved constructor and destructor to source;
+//                         removed unused variable
 #ifndef G4DecayStrongResonances_h
 …
+{
 public:
    G4DecayStrongResonances(){}
    ~G4DecayStrongResonances(){}
+  G4DecayStrongResonances();
+  ~G4DecayStrongResonances();
 private:
    G4int operator==(G4DecayStrongResonances& right) {return (this == &right);}
    G4int operator!=(G4DecayStrongResonances& right) {return (this != &right);}
-   G4double theEnergy;
 public:

trunk/source/processes/hadronic/models/util/include/G4NuclearFermiDensity.hh

r1228	r1347
40	40
41	41	public:
42		G4NuclearFermiDensity(G4~~double anA, G4double~~ aZ);
	42	G4NuclearFermiDensity(G4int anA, G4int aZ);
43	43	~G4NuclearFermiDensity();
44	44

trunk/source/processes/hadronic/models/util/include/G4NuclearShellModelDensity.hh

r819	r1347
40	40
41	41	public:
42		G4NuclearShellModelDensity(G4~~double anA, G4double~~ aZ);
	42	G4NuclearShellModelDensity(G4int anA, G4int aZ);
43	43	~G4NuclearShellModelDensity();
44	44

trunk/source/processes/hadronic/models/util/src/G4KineticTrack.cc

-              r1196
+              r1347
       G4cout << "DECAY Actual Mass " << theActualMass << G4endl;
 */
+  G4ParticleDefinition* thisDefinition = this->GetDefinition();
+  if(!thisDefinition)
+  {
+    G4cerr << "Error condition encountered in G4KineticTrack::Decay()"<<G4endl;
+    G4cerr << "  track has no particle definition associated."<<G4endl;
+    return 0;
+  }
+  G4DecayTable* theDecayTable = thisDefinition->GetDecayTable();
+  if(!theDecayTable)
+  {
+    G4cerr << "Error condition encountered in G4KineticTrack::Decay()"<<G4endl;
+    G4cerr << "  particle definiton has no decay table associated."<<G4endl;
+    G4cerr << "  particle was "<<thisDefinition->GetParticleName()<<G4endl;
+    return 0;
+  }
  G4int chargeBalance = G4lrint(theDefinition->GetPDGCharge() );
 …
      //  cout << "DECAY Total Width " << theTotalActualWidth << G4endl;
      G4double r = theTotalActualWidth * G4UniformRand();
+     G4ParticleDefinition* thisDefinition = this->GetDefinition();
+     if(!thisDefinition)
+     {
+       G4cerr << "Error condition encountered in G4KineticTrack::Decay()"<<G4endl;
+       G4cerr << "  track has no particle definition associated."<<G4endl;
+       return 0;
+     }
+     G4DecayTable* theDecayTable = thisDefinition->GetDecayTable();
+     if(!theDecayTable)
+     {
+       G4cerr << "Error condition encountered in G4KineticTrack::Decay()"<<G4endl;
+       G4cerr << "  particle definiton has no decay table associated."<<G4endl;
+       G4cerr << "  particle was "<<thisDefinition->GetParticleName()<<G4endl;
+       return 0;
+     }
+     G4VDecayChannel* theDecayChannel=NULL;
+     G4VDecayChannel* theDecayChannel(0);
      for (index = nChannels - 1; index >= 0; index--)
+        {
 …
+            }
+        }
+     delete [] theCumActualWidth;
      if(!theDecayChannel)
+     {
 …
+        }
      delete theDecayProducts;
-     delete [] theCumActualWidth;
      if(getenv("DecayEnergyBalanceCheck"))
        std::cout << "DEBUGGING energy balance in cms and lab, charge baryon balance : "

trunk/source/processes/hadronic/models/util/src/G4NuclearFermiDensity.cc

-              r819
+              r1347
 #include "G4NuclearFermiDensity.hh"
 G4NuclearFermiDensity::G4NuclearFermiDensity(G4double anA, G4double aZ)
   :  a(0.545 * fermi)
+G4NuclearFermiDensity::G4NuclearFermiDensity(G4int anA, G4int aZ)
+  :  theA(anA), theZ(aZ), a(0.545 * fermi)
+{
 //        const G4double r0=1.14*fermi;
+        const G4double r0=1.16 * ( 1. - 1.16 * std::pow(anA, -2./3.)) * fermi;
+        theA = G4int(anA);
+        theZ = G4int(aZ);
+        const G4double r0=1.16 * ( 1. - 1.16 * std::pow(G4double(anA), -2./3.)) * fermi;
         theR= r0 * std::pow(anA, 1./3. );
         Setrho0(3./ (4. * pi * std::pow(r0,3.) * theA * ( 1. + sqr(a/theR)*pi2 )));

trunk/source/processes/hadronic/models/util/src/G4NuclearShellModelDensity.cc

-              r819
+              r1347
 #include "G4NuclearShellModelDensity.hh"
+G4NuclearShellModelDensity::G4NuclearShellModelDensity(G4double anA, G4double aZ)
+G4NuclearShellModelDensity::G4NuclearShellModelDensity(G4int anA, G4int aZ)
+: theA(anA), theZ(aZ)
+{
         const G4double r0sq=0.8133*fermi*fermi;
-        theA = G4int(anA);
-        theZ = G4int(aZ);
         theRsquare= r0sq * std::pow(G4double(theA), 2./3. );
         Setrho0(std::pow(1./(pi*theRsquare),3./2.));

trunk/source/processes/hadronic/stopping/History

-              r1340
+              r1347
      ---------------------------------------------------------------
+-Nov-2010 Dennis Wright        (hadr-stopping-V09-03-01)
+----------------------------------------------------------
+- G4MuonMinusCaptureAtRest::DoMuCapture : fix unused branch
+    pd = G4Deuteron::Deuteron() in mass calculation
+- G4PiMinusStopMaterial: theR was used but uninitialized.  Now init'ed
+    to 0.5 in ctor
+- G4PiMinusAbsorptionAtRest: remove null test for vector pointer
+    in dtor
+- G4StopDummyDeexcitation: initialize pointer _products in ctor
+- G4KaonMinusAbsorptionAtRest::SigmaLambdaConversion : add dummy
+    particles to default of switch/case to avoid possible NULL
+    pointers
 -Sep-2010 Gunter Folger        (hadr-stopping-V09-03-00)
 ----------------------------------------------------------

trunk/source/processes/hadronic/stopping/src/G4KaonMinusAbsorptionAtRest.cc

-              r1196
+              r1347
   default:
     sigmaLambdaConversionRate = 0.;
+    // Add dummy particles to avoid possibility of passing NULL pointers
+    inNucleonDef   = G4Proton::Proton();
+    outNucleonDef  = G4Proton::Proton();
+  }

trunk/source/processes/hadronic/stopping/src/G4PiMinusAbsorptionAtRest.cc

-              r1196
+              r1347
+    }
   G4int index = 3;
   if (Z <= 3) { index = 3;}
   if (Z > 3 && Z<= 6) {index = 6;}
+  G4int index = 0;
+  if (Z > 0 && Z < 4) {index = 3;}
+  if (Z > 3 && Z < 7) {index = 6;}
   if (Z == 7) {index = 7;}
   if (Z >= 8 && Z<= 11) {index = 8;}

trunk/source/processes/hadronic/stopping/src/G4PiMinusStopMaterial.cc

-              r1196
+              r1347
 G4PiMinusStopMaterial::G4PiMinusStopMaterial()
+{
   _definitions = 0;
 …
   _distributionE = 0;
   _distributionAngle = 0;
+  theR = 0.5;
+}
 …
 G4PiMinusStopMaterial::~G4PiMinusStopMaterial()
+{
-  //  _definitions->clear();
   if (_definitions != 0) delete _definitions;
   _definitions = 0;
   for(unsigned int i=0; i<_momenta->size(); i++) delete(*_momenta)[i];
+  for (unsigned int i=0; i<_momenta->size(); i++) delete(*_momenta)[i];
   if (_momenta != 0) delete _momenta;
 …
+}
+std::vector<G4LorentzVector*>* G4PiMinusStopMaterial::P4Vector(const G4double binding,
+                                                                      const G4double massNucleus)
+std::vector<G4LorentzVector*>*
+G4PiMinusStopMaterial::P4Vector(const G4double binding,
+                                const G4double massNucleus)
+{
+  // Generate energy of direct absorption products according to experimental data
+  // The energy distribution of the two nucleons is assumed to be the same
+  // for protons and neutrons
+  // Generate energy of direct absorption products according to experimental
+  // data.  The energy distribution of the two nucleons is assumed to be the
+  // same for protons and neutrons.
   G4double eKin1;
 …
+}

trunk/source/processes/hadronic/stopping/src/G4StopDummyDeexcitation.cc

-              r819
+              r1347
 // Constructor
+G4StopDummyDeexcitation::G4StopDummyDeexcitation()
+{}
+G4StopDummyDeexcitation::G4StopDummyDeexcitation()
+{
+  _products = 0;
+}

trunk/source/processes/hadronic/util/History

-              r1315
+              r1347
      * Please list in reverse chronological order (last date on top)
      ---------------------------------------------------------------
+Nov 2010  Dennis Wright              (hadr-util-V09-03-01)
+-------------------------------------------------------------
+- G4HadronicWhiteBoard: fix uninitialized ptrs (theProjectile, theDef,
+    theName)
+- G4Nucleus: add dtaBlackTrackEnergyfromAnnihilation and
+    pnBlackTrackEnergyfromAnnihilation to copy ctor
+    initialize theA, theZ. aEff, zEff to 0 in ctor
 Mar 2010 G.Folger                    (hadr-util-V09-03-00)

trunk/source/processes/hadronic/util/include/G4HadronicWhiteBoard.hh

-              r1315
+              r1347
+{
   public:
   G4HadronicWhiteBoard(){}
+  G4HadronicWhiteBoard();
   static G4HadronicWhiteBoard & Instance();
+  static G4HadronicWhiteBoard& Instance();
   void SetProjectile(const G4HadProjectile & aProjectile);
+  void SetProjectile(const G4HadProjectile& aProjectile);
   void SetTargetNucleus(const G4Nucleus & aTarget);
+  void SetTargetNucleus(const G4Nucleus& aTarget);
   void SetProcessName(const G4String& aProcessName);
 …
   void SetModelName(const G4String& aModelName);
   const G4HadProjectile * GetProjectile();
   const G4Nucleus & GetTargetNucleus();
   G4ParticleDefinition * GetPDef();
+  const G4HadProjectile* GetProjectile();
+  const G4Nucleus& GetTargetNucleus();
+  G4ParticleDefinition* GetPDef();
   G4String GetParticleName();
   G4double GetEnergy();
 …
   private:
   G4HadProjectile * theProjectile;
   G4ParticleDefinition * theDef;
   char * theName;
+  G4HadProjectile* theProjectile;
+  G4ParticleDefinition* theDef;
+  char* theName;
   G4double theE;
   G4double thePx;

trunk/source/processes/hadronic/util/include/G4Nucleus.hh

-              r1315
+              r1347
          zEff=right.zEff;
          pnBlackTrackEnergy=right.pnBlackTrackEnergy;
+         dtaBlackTrackEnergy=right.dtaBlackTrackEnergy;
+         dtaBlackTrackEnergy=right.dtaBlackTrackEnergy;
+         pnBlackTrackEnergyfromAnnihilation =
+                      right.pnBlackTrackEnergyfromAnnihilation;
+         dtaBlackTrackEnergyfromAnnihilation =
+                      right.dtaBlackTrackEnergyfromAnnihilation;
          theTemp = right.theTemp;
          excitationEnergy = right.excitationEnergy;

trunk/source/processes/hadronic/util/src/G4HadronicWhiteBoard.cc

-              r1315
+              r1347
 //
 #include "G4HadronicWhiteBoard.hh"
+G4HadronicWhiteBoard::G4HadronicWhiteBoard()
+  : theProjectile(0), theDef(0), theName(0)
+{}

trunk/source/processes/hadronic/util/src/G4Nucleus.cc

r1315	r1347
46	46
47	47	G4Nucleus::G4Nucleus()
	48	: theA(0), theZ(0), aEff(0.0), zEff(0)
48	49	{
49	50	pnBlackTrackEnergy = 0.0;

Context Navigation

Legend: