lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 9.5.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-09 16:46:55 +02:00
parent 89a9605df1
commit b1eb5424d2
10957 changed files with 888481 additions and 160139 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/hadronic/models/low_energy/CMakeLists.txt
+1 -1
View File
@@ -7,7 +7,7 @@
#
# Generated on : 24/9/2010
#
# $Id: CMakeLists.txt,v 1.1 2010/09/29 19:03:31 bmorgan Exp $
# $Id: CMakeLists.txt,v 1.1 2010-09-29 19:03:31 bmorgan Exp $
#
#------------------------------------------------------------------------------
source/processes/hadronic/models/low_energy/GNUmakefile
+2 -1
View File
@@ -1,4 +1,4 @@
# $Id: GNUmakefile,v 1.2 2003/10/08 16:42:20 hpw Exp $
# $Id: GNUmakefile,v 1.2 2003-10-08 16:42:20 hpw Exp $
# -----------------------------------------------------------
# GNUmakefile for hadronic library. Gabriele Cosmo, 18/9/96.
# -----------------------------------------------------------
@@ -11,6 +11,7 @@ endif
include $(G4INSTALL)/config/architecture.gmk
CPPFLAGS += -DG4HADRONIC_ALLOC_EXPORT
CPPFLAGS += -I$(G4BASE)/global/management/include \
-I$(G4BASE)/global/HEPRandom/include \
-I$(G4BASE)/global/HEPGeometry/include \
source/processes/hadronic/models/low_energy/History
+36
View File
@@ -14,6 +14,42 @@ code and to keep track of all tags.
* Please list in reverse chronological order (last date on top)
---------------------------------------------------------------
19 November 2011 - V.Ivanchenko (hadr-lep-V09-04-05)
----------------------------------------------------
Added protection against return back only primary particle with
increased energy (warning in simplified calorimeter test):
G4LEDeuteronInelastic.cc
G4LETritonInelastic.cc
G4LEAlphaInelastic.cc
25 October 2011 - Dennis Wright (hadr-lep-V09-04-04)
----------------------------------------------------
Replace Description() with ModelDescription(std::ostream&) in all models
27 September 2011 - Dennis Wright (hadr-lep-V09-04-03)
------------------------------------------------------
Migrate to integer Z and A. Files affected:
G4LCapture.cc
G4LEAlphaInelastic.cc
G4LEDeuteronInelastic.cc
G4LENeutronInelastic.cc
G4LEProtonInelastic.cc
G4LETritonInelastic.cc
G4LElastic.cc
G4LFission.cc
02 August 2011 - Dennis Wright (hadr-lep-V09-04-02)
---------------------------------------------------
Remove test directory from trunk. It remains in tag hadr-lep-V09-04-01
02 August 2011 - Dennis Wright (hadr-lep-V09-04-01)
---------------------------------------------------
Add Description() method to all model classes for html documentation
19 May 2011 - Dennis Wright (hadr-lep-V09-04-00)
------------------------------------------------
G4LCapture.cc: fix gcc-4.6 compiler warning (variable e0 set but not used)
26 February 2007 - Dennis Wright (hadr-lep-V08-02-01)
-----------------------------------------------------
G4LEAntiProtonInelastic.cc : for low energy (< 0.1 MeV) anti-protons,
source/processes/hadronic/models/low_energy/include/G4LCapture.hh
+16 -13
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4LCapture.hh,v 1.11 2006/06/29 20:43:26 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4LCapture.hh,v 1.11 2006-06-29 20:43:26 gunter Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
//
// G4 Low energy model: neutron capture -- header file
@@ -65,22 +65,25 @@
class G4LCapture : public G4HadronicInteraction
{
public:
public:
G4LCapture();
G4LCapture(const G4String& name = "G4LCapture");
~G4LCapture();
~G4LCapture();
G4HadFinalState * ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
private:
// void Description() const;
virtual void ModelDescription(std::ostream& outFile) const;
// Computes atomic mass in GeV using method from G4LFission
inline
G4double Atomas(const G4double A, const G4double Z)
{
private:
// Computes atomic mass in GeV using method from G4LFission
inline
G4double Atomas(const G4double A, const G4double Z)
{
return G4LFission::Atomas(A, Z)/GeV;
}
}
};
#endif
source/processes/hadronic/models/low_energy/include/G4LEAlphaInelastic.hh
+14 -21
View File
@@ -23,13 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEAlphaInelastic.hh,v 1.10 2007-02-24 06:06:38 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEAlphaInelastic.hh,v 1.10 2007/02/24 06:06:38 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy Alpha Inelastic Process
// J.L. Chuma, TRIUMF, 21-Feb-1997
// Last modified: 27-Mar-1997
// Hadronic Process: Low Energy Alpha Inelastic Process
// J.L. Chuma, TRIUMF, 21-Feb-1997
#ifndef G4LEAlphaInelastic_h
#define G4LEAlphaInelastic_h 1
@@ -43,23 +41,18 @@
#include "G4InelasticInteraction.hh"
class G4LEAlphaInelastic : public G4InelasticInteraction
{
public:
class G4LEAlphaInelastic : public G4InelasticInteraction
{
public:
G4LEAlphaInelastic() : G4InelasticInteraction("G4LEAlphaInelastic")
{
SetMinEnergy( 0.0 );
// SetMaxEnergy( 100.*MeV ); // NUCREC only worked for energies < 100MeV
// Work around to avoid exception in G4EnergyRangeManager
SetMaxEnergy( 10.*TeV ); // NUCREC only worked for energies < 100MeV
}
G4LEAlphaInelastic(const G4String& name = "G4LEAlphaInelastic");
~G4LEAlphaInelastic() { }
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
};
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
};
#endif
source/processes/hadronic/models/low_energy/include/G4LEAntiKaonZeroInelastic.hh
+14 -16
View File
@@ -23,13 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEAntiKaonZeroInelastic.hh,v 1.7 2007-02-24 06:10:26 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEAntiKaonZeroInelastic.hh,v 1.7 2007/02/24 06:10:26 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy KaonZeroL Inelastic Process
// J.L. Chuma, TRIUMF, 12-Feb-1997
// Last modified: 27-Mar-1997
// Hadronic Process: Low Energy KaonZeroL Inelastic Process
// J.L. Chuma, TRIUMF, 12-Feb-1997
#ifndef G4LEAntiKaonZeroInelastic_h
#define G4LEAntiKaonZeroInelastic_h 1
@@ -43,9 +41,9 @@
#include "G4InelasticInteraction.hh"
class G4LEAntiKaonZeroInelastic : public G4InelasticInteraction
{
public:
class G4LEAntiKaonZeroInelastic : public G4InelasticInteraction
{
public:
G4LEAntiKaonZeroInelastic() : G4InelasticInteraction("G4LEAntiKaonZeroInelastic")
{
@@ -53,13 +51,14 @@
SetMaxEnergy( 25.*GeV );
}
~G4LEAntiKaonZeroInelastic()
{ }
~G4LEAntiKaonZeroInelastic() {}
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
private:
private:
void Cascade( // derived from CASK0B
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
@@ -70,8 +69,7 @@
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic );
};
};
#endif
source/processes/hadronic/models/low_energy/include/G4LEAntiLambdaInelastic.hh
+4 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4LEAntiLambdaInelastic.hh,v 1.11 2007/02/24 06:11:24 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4LEAntiLambdaInelastic.hh,v 1.11 2007-02-24 06:11:24 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// Hadronic Process: Low Energy AntiLambda Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
@@ -57,6 +57,8 @@
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
virtual void ModelDescription(std::ostream& outFile) const;
private:
source/processes/hadronic/models/low_energy/include/G4LEAntiNeutronInelastic.hh
+29 -34
View File
@@ -24,13 +24,13 @@
// ********************************************************************
//
//
// $Id: G4LEAntiNeutronInelastic.hh,v 1.11 2007/02/24 06:13:02 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4LEAntiNeutronInelastic.hh,v 1.11 2007-02-24 06:13:02 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// Hadronic Process: Low Energy AntiNeutron Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
// Last modified: 27-Mar-1997
// Hadronic Process: Low Energy AntiNeutron Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
//
#ifndef G4LEAntiNeutronInelastic_h
#define G4LEAntiNeutronInelastic_h 1
@@ -42,37 +42,32 @@
// Class Description - End
#include "G4InelasticInteraction.hh"
class G4LEAntiNeutronInelastic : public G4InelasticInteraction
{
public:
class G4LEAntiNeutronInelastic : public G4InelasticInteraction
{
public:
G4LEAntiNeutronInelastic() : G4InelasticInteraction("G4LEAntiNeutronInelastic")
{
SetMinEnergy( 0.0 );
SetMaxEnergy( 25.*GeV );
}
G4LEAntiNeutronInelastic(const G4String& name = "G4LEAntiNeutronInelastic");
~G4LEAntiNeutronInelastic()
{ }
~G4LEAntiNeutronInelastic() {}
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
private:
private:
void
Cascade( // derived from CASNB
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int &vecLen,
const G4HadProjectile *originalIncident,
G4ReactionProduct &currentParticle,
G4ReactionProduct &targetParticle,
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic );
};
void Cascade( // derived from CASNB
G4FastVector<G4ReactionProduct,GHADLISTSIZE>& vec,
G4int& vecLen,
const G4HadProjectile* originalIncident,
G4ReactionProduct& currentParticle,
G4ReactionProduct& targetParticle,
G4bool& incidentHasChanged,
G4bool& targetHasChanged,
G4bool& quasiElastic);
};
#endif
source/processes/hadronic/models/low_energy/include/G4LEAntiOmegaMinusInelastic.hh
+15 -15
View File
@@ -23,13 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEAntiOmegaMinusInelastic.hh,v 1.11 2007-02-24 06:13:54 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEAntiOmegaMinusInelastic.hh,v 1.11 2007/02/24 06:13:54 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy AntiOmegaMinus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
// Last modified: 27-Mar-1997
// Hadronic Process: Low Energy AntiOmegaMinus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
#ifndef G4LEAntiOmegaMinusInelastic_h
#define G4LEAntiOmegaMinusInelastic_h 1
@@ -43,22 +41,24 @@
#include "G4InelasticInteraction.hh"
class G4LEAntiOmegaMinusInelastic : public G4InelasticInteraction
{
public:
class G4LEAntiOmegaMinusInelastic : public G4InelasticInteraction
{
public:
G4LEAntiOmegaMinusInelastic() : G4InelasticInteraction("G4LEAntiOmegaMinusInelastic")
{
SetMinEnergy( 0.0 );
SetMaxEnergy( 25.*GeV );
SetMinEnergy(0.0);
SetMaxEnergy(25.*GeV);
}
~G4LEAntiOmegaMinusInelastic() { }
~G4LEAntiOmegaMinusInelastic() {}
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
private:
private:
void
Cascade( // derived from CASOM
source/processes/hadronic/models/low_energy/include/G4LEAntiProtonInelastic.hh
+31 -35
View File
@@ -23,54 +23,50 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEAntiProtonInelastic.hh,v 1.11 2007/02/24 05:07:32 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4LEAntiProtonInelastic.hh,v 1.11 2007-02-24 05:07:32 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// Hadronic Process: Low Energy AntiProton Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
//
// Hadronic Process: Low Energy AntiProton Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
// Last modified: 27-Mar-1997
#ifndef G4LEAntiProtonInelastic_h
#define G4LEAntiProtonInelastic_h 1
// Class Description
// Final state production model for AntiProton inelastic scattering below 20 GeV;
// To be used in your physics list in case you need this physics.
// Final state production model for AntiProton inelastic scattering below
// 20 GeV; To be used in your physics list in case you need this physics.
// In this case you want to register an object of this class with
// the corresponding process.
// Class Description - End
#include "G4InelasticInteraction.hh"
class G4LEAntiProtonInelastic : public G4InelasticInteraction
{
public:
class G4LEAntiProtonInelastic : public G4InelasticInteraction
{
public:
G4LEAntiProtonInelastic():G4InelasticInteraction("G4LEAntiProtonInelastic")
{
SetMinEnergy( 0.0 );
SetMaxEnergy( 25.*GeV );
}
G4LEAntiProtonInelastic(const G4String& name = "G4LEAntiProtonInelastic");
~G4LEAntiProtonInelastic() { }
~G4LEAntiProtonInelastic() {}
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
private:
private:
void
Cascade( // derived from CASPB
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int &vecLen,
const G4HadProjectile *originalIncident,
G4ReactionProduct &currentParticle,
G4ReactionProduct &targetParticle,
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic );
};
void Cascade( // derived from CASPB
G4FastVector<G4ReactionProduct,GHADLISTSIZE>& vec,
G4int& vecLen,
const G4HadProjectile* originalIncident,
G4ReactionProduct& currentParticle,
G4ReactionProduct& targetParticle,
G4bool& incidentHasChanged,
G4bool& targetHasChanged,
G4bool& quasiElastic);
};
#endif
source/processes/hadronic/models/low_energy/include/G4LEAntiSigmaMinusInelastic.hh
+15 -15
View File
@@ -23,13 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEAntiSigmaMinusInelastic.hh,v 1.11 2007-02-24 06:38:14 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEAntiSigmaMinusInelastic.hh,v 1.11 2007/02/24 06:38:14 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy AntiSigmaMinus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
// Last modified: 27-Mar-1997
// Hadronic Process: Low Energy AntiSigmaMinus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
#ifndef G4LEAntiSigmaMinusInelastic_h
#define G4LEAntiSigmaMinusInelastic_h 1
@@ -43,22 +41,24 @@
#include "G4InelasticInteraction.hh"
class G4LEAntiSigmaMinusInelastic : public G4InelasticInteraction
{
public:
class G4LEAntiSigmaMinusInelastic : public G4InelasticInteraction
{
public:
G4LEAntiSigmaMinusInelastic() : G4InelasticInteraction("G4LEAntiSigmaMinusInelastic")
{
SetMinEnergy( 0.0 );
SetMaxEnergy( 25.*GeV );
SetMinEnergy(0.0);
SetMaxEnergy(25.*GeV);
}
~G4LEAntiSigmaMinusInelastic() { }
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
private:
private:
void
Cascade( // derived from CASASM
@@ -71,7 +71,7 @@
G4bool &targetHasChanged,
G4bool &quasiElastic );
};
};
#endif
source/processes/hadronic/models/low_energy/include/G4LEAntiSigmaPlusInelastic.hh
+12 -12
View File
@@ -23,13 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEAntiSigmaPlusInelastic.hh,v 1.11 2007-02-24 06:39:17 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEAntiSigmaPlusInelastic.hh,v 1.11 2007/02/24 06:39:17 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy AntiSigmaPlus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
// Last modified: 27-Mar-1997
// Hadronic Process: Low Energy AntiSigmaPlus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
#ifndef G4LEAntiSigmaPlusInelastic_h
#define G4LEAntiSigmaPlusInelastic_h 1
@@ -43,9 +41,9 @@
#include "G4InelasticInteraction.hh"
class G4LEAntiSigmaPlusInelastic : public G4InelasticInteraction
{
public:
class G4LEAntiSigmaPlusInelastic : public G4InelasticInteraction
{
public:
G4LEAntiSigmaPlusInelastic() : G4InelasticInteraction("G4LEAntiSigmaPlusInelastic")
{
@@ -55,8 +53,10 @@
~G4LEAntiSigmaPlusInelastic() { }
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
private:
@@ -71,7 +71,7 @@
G4bool &targetHasChanged,
G4bool &quasiElastic );
};
};
#endif
source/processes/hadronic/models/low_energy/include/G4LEAntiXiMinusInelastic.hh
+14 -15
View File
@@ -23,13 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEAntiXiMinusInelastic.hh,v 1.11 2007-02-24 06:42:10 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEAntiXiMinusInelastic.hh,v 1.11 2007/02/24 06:42:10 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy AntiXiMinus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
// Last modified: 27-Mar-1997
// Hadronic Process: Low Energy AntiXiMinus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
#ifndef G4LEAntiXiMinusInelastic_h
#define G4LEAntiXiMinusInelastic_h 1
@@ -43,9 +41,9 @@
#include "G4InelasticInteraction.hh"
class G4LEAntiXiMinusInelastic : public G4InelasticInteraction
{
public:
class G4LEAntiXiMinusInelastic : public G4InelasticInteraction
{
public:
G4LEAntiXiMinusInelastic() : G4InelasticInteraction("G4LEAntiXiMinusInelastic")
{
@@ -53,13 +51,14 @@
SetMaxEnergy( 25.*GeV );
}
~G4LEAntiXiMinusInelastic()
{ }
~G4LEAntiXiMinusInelastic() {}
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
private:
private:
void
Cascade( // derived from CASAL0
@@ -72,7 +71,7 @@
G4bool &targetHasChanged,
G4bool &quasiElastic );
};
};
#endif
source/processes/hadronic/models/low_energy/include/G4LEAntiXiZeroInelastic.hh
+14 -14
View File
@@ -23,13 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEAntiXiZeroInelastic.hh,v 1.11 2007-02-24 06:43:02 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEAntiXiZeroInelastic.hh,v 1.11 2007/02/24 06:43:02 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy AntiXiZero Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
// Last modified: 27-Mar-1997
// Hadronic Process: Low Energy AntiXiZero Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
#ifndef G4LEAntiXiZeroInelastic_h
#define G4LEAntiXiZeroInelastic_h 1
@@ -43,9 +41,9 @@
#include "G4InelasticInteraction.hh"
class G4LEAntiXiZeroInelastic : public G4InelasticInteraction
{
public:
class G4LEAntiXiZeroInelastic : public G4InelasticInteraction
{
public:
G4LEAntiXiZeroInelastic() : G4InelasticInteraction("G4LEAntiXiZeroInelastic")
{
@@ -55,11 +53,13 @@
~G4LEAntiXiZeroInelastic() { }
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
private:
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
private:
void
Cascade( // derived from CASAL0
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
@@ -71,7 +71,7 @@
G4bool &targetHasChanged,
G4bool &quasiElastic );
};
};
#endif
source/processes/hadronic/models/low_energy/include/G4LEDeuteronInelastic.hh
+13 -13
View File
@@ -23,13 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEDeuteronInelastic.hh,v 1.10 2007-02-24 06:45:04 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEDeuteronInelastic.hh,v 1.10 2007/02/24 06:45:04 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy Deuteron Inelastic Process
// J.L. Chuma, TRIUMF, 25-Feb-1997
// Last modified: 27-Mar-1997
// Hadronic Process: Low Energy Deuteron Inelastic Process
// J.L. Chuma, TRIUMF, 25-Feb-1997
#ifndef G4LEDeuteronInelastic_h
#define G4LEDeuteronInelastic_h 1
@@ -43,9 +41,9 @@
#include "G4InelasticInteraction.hh"
class G4LEDeuteronInelastic : public G4InelasticInteraction
{
public:
class G4LEDeuteronInelastic : public G4InelasticInteraction
{
public:
G4LEDeuteronInelastic() : G4InelasticInteraction("G4LEDeuteronInelastic")
{
@@ -55,11 +53,13 @@
SetMaxEnergy( 10.*TeV ); // NUCREC only worked for energies < 100MeV
}
~G4LEDeuteronInelastic() { }
~G4LEDeuteronInelastic() {}
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
};
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
};
#endif
source/processes/hadronic/models/low_energy/include/G4LEKaonMinusInelastic.hh
+25 -32
View File
@@ -23,13 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEKaonMinusInelastic.hh,v 1.11 2007-02-26 18:21:07 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEKaonMinusInelastic.hh,v 1.11 2007/02/26 18:21:07 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy KaonMinus Inelastic Process
// J.L. Chuma, TRIUMF, 12-Feb-1997
// Last modified: 27-Mar-1997
// Hadronic Process: Low Energy KaonMinus Inelastic Process
// J.L. Chuma, TRIUMF, 12-Feb-1997
#ifndef G4LEKaonMinusInelastic_h
#define G4LEKaonMinusInelastic_h 1
@@ -43,35 +41,30 @@
#include "G4InelasticInteraction.hh"
class G4LEKaonMinusInelastic : public G4InelasticInteraction
{
public:
class G4LEKaonMinusInelastic : public G4InelasticInteraction
{
public:
G4LEKaonMinusInelastic() : G4InelasticInteraction("G4LEKaonMinusInelastic")
{
SetMinEnergy( 0.0 );
SetMaxEnergy( 25.*GeV );
}
G4LEKaonMinusInelastic(const G4String& name = "G4LEKaonMinusInelastic");
~G4LEKaonMinusInelastic()
{ }
~G4LEKaonMinusInelastic() {}
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
private:
private:
void Cascade( // derived from CASKM
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int &vecLen,
const G4HadProjectile *originalIncident,
G4ReactionProduct &currentParticle,
G4ReactionProduct &targetParticle,
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic );
};
void Cascade( // derived from CASKM
G4FastVector<G4ReactionProduct,GHADLISTSIZE>& vec,
G4int& vecLen,
const G4HadProjectile* originalIncident,
G4ReactionProduct& currentParticle,
G4ReactionProduct& targetParticle,
G4bool& incidentHasChanged,
G4bool& targetHasChanged,
G4bool& quasiElastic);
};
#endif
source/processes/hadronic/models/low_energy/include/G4LEKaonPlusInelastic.hh
+21 -26
View File
@@ -23,13 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEKaonPlusInelastic.hh,v 1.11 2007-02-26 18:21:57 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEKaonPlusInelastic.hh,v 1.11 2007/02/26 18:21:57 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy KaonPlus Inelastic Process
// J.L. Chuma, TRIUMF, 12-Feb-1997
// Last modified: 27-Mar-1997
// Hadronic Process: Low Energy KaonPlus Inelastic Process
// J.L. Chuma, TRIUMF, 12-Feb-1997
#ifndef G4LEKaonPlusInelastic_h
#define G4LEKaonPlusInelastic_h 1
@@ -42,24 +40,22 @@
// Class Description - End
#include "G4InelasticInteraction.hh"
class G4LEKaonPlusInelastic : public G4InelasticInteraction
{
public:
G4LEKaonPlusInelastic(const G4String& name = "G4LEKaonPlusInelastic");
~G4LEKaonPlusInelastic() {}
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
class G4LEKaonPlusInelastic : public G4InelasticInteraction
{
public:
G4LEKaonPlusInelastic() : G4InelasticInteraction("G4LEKaonPlusInelastic")
{
SetMinEnergy( 0.0 );
SetMaxEnergy( 25.*GeV );
}
~G4LEKaonPlusInelastic()
{ }
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
private:
private:
void Cascade( // derived from CASKP
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
@@ -71,7 +67,6 @@
G4bool &targetHasChanged,
G4bool &quasiElastic );
};
};
#endif
source/processes/hadronic/models/low_energy/include/G4LEKaonZeroInelastic.hh
+12 -12
View File
@@ -23,13 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEKaonZeroInelastic.hh,v 1.7 2007-02-26 18:23:45 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEKaonZeroInelastic.hh,v 1.7 2007/02/26 18:23:45 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy KaonZeroS Inelastic Process
// J.L. Chuma, TRIUMF, 12-Feb-1997
// Last modified: 27-Mar-1997
// Hadronic Process: Low Energy KaonZeroS Inelastic Process
// J.L. Chuma, TRIUMF, 12-Feb-1997
#ifndef G4LEKaonZeroInelastic_h
#define G4LEKaonZeroInelastic_h 1
@@ -43,9 +41,9 @@
#include "G4InelasticInteraction.hh"
class G4LEKaonZeroInelastic : public G4InelasticInteraction
{
public:
class G4LEKaonZeroInelastic : public G4InelasticInteraction
{
public:
G4LEKaonZeroInelastic() : G4InelasticInteraction("G4LEKaonZeroInelastic")
{
@@ -57,9 +55,11 @@
{ }
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
G4Nucleus &targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
private:
private:
void Cascade( // derived from CASK0
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
@@ -71,7 +71,7 @@
G4bool &targetHasChanged,
G4bool &quasiElastic );
};
};
#endif
source/processes/hadronic/models/low_energy/include/G4LEKaonZeroLInelastic.hh
+20 -9
View File
@@ -23,15 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: G4LEKaonZeroLInelastic.hh,v 1.12 2007/02/26 18:24:54 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// $Id: G4LEKaonZeroLInelastic.hh,v 1.12 2007-02-26 18:24:54 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// G4 Gheisha High Energy model class -- header file
// H. Fesefeldt, RWTH Aachen 23-October-1996
// Last modified: 10-December-1996
// A prototype of the Gheisha High Energy collision model.
#ifndef G4LEKaonZeroLInelastic_h
@@ -46,13 +42,13 @@ class G4LEKaonZeroLInelastic : public G4InelasticInteraction
public:
G4LEKaonZeroLInelastic() : G4InelasticInteraction("G4LEKaonZeroLInelastic")
{
SetMinEnergy( 0.0 );
SetMaxEnergy( 25.*GeV );
SetMinEnergy(0.0);
SetMaxEnergy(25.*GeV);
}
virtual ~G4LEKaonZeroLInelastic(){ }
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack, G4Nucleus& targetNucleus)
{
if(G4UniformRand() < 0.50)
{
@@ -67,6 +63,21 @@ class G4LEKaonZeroLInelastic : public G4InelasticInteraction
G4LEKaonZeroInelastic theKaonZeroInelastic;
G4LEAntiKaonZeroInelastic theAntiKaonZeroInelastic;
virtual void ModelDescription(std::ostream& outFile) const
{
outFile << "G4LEKaonZeroLInelastic is one of the Low Energy\n"
<< "Parameterized (LEP) models used to implement K0L\n"
<< "scattering from nuclei. Upon interaction with a nucleus\n"
<< "the K0L is treated as a K0 50% of the time and an antiK0\n"
<< "50% of the time. Then the K0 or antiK0 interacts with the\n"
<< "nucleus using the re-engineered GHEISHA code of\n"
<< "H. Fesefeldt, which divides the initial collision products\n"
<< "into backward- and forward-going clusters which are then\n"
<< "decayed into final state hadrons. The model does not\n"
<< "conserve energy or charge on an event-by-event basis. It\n"
<< "may be applied to K0Ls with initial energies between 0 and\n"
<< "25 GeV.\n";
}
};
#endif
source/processes/hadronic/models/low_energy/include/G4LEKaonZeroSInelastic.hh
+24 -13
View File
@@ -23,15 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: G4LEKaonZeroSInelastic.hh,v 1.12 2007/02/26 18:25:37 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// $Id: G4LEKaonZeroSInelastic.hh,v 1.12 2007-02-26 18:25:37 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// G4 Gheisha High Energy model class -- header file
// H. Fesefeldt, RWTH Aachen 23-October-1996
// Last modified: 10-December-1996
// A prototype of the Gheisha High Energy collision model.
#ifndef G4LEKaonZeroSInelastic_h
@@ -46,13 +42,13 @@ class G4LEKaonZeroSInelastic : public G4InelasticInteraction
public:
G4LEKaonZeroSInelastic() : G4InelasticInteraction("G4LEKaonZeroSInelastic")
{
SetMinEnergy( 0.0 );
SetMaxEnergy( 25.*GeV );
SetMinEnergy(0.0);
SetMaxEnergy(25.*GeV);
}
virtual ~G4LEKaonZeroSInelastic(){ }
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus )
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack, G4Nucleus& targetNucleus)
{
if(G4UniformRand() < 0.50)
{
@@ -62,12 +58,27 @@ class G4LEKaonZeroSInelastic : public G4InelasticInteraction
{
return theAntiKaonZeroInelastic.ApplyYourself(aTrack, targetNucleus);
}
}
}
virtual void ModelDescription(std::ostream& outFile) const
{
outFile << "G4LEKaonZeroSInelastic is one of the Low Energy\n"
<< "Parameterized (LEP) models used to implement K0S\n"
<< "scattering from nuclei. Upon interaction with a nucleus\n"
<< "the K0S is treated as a K0 50% of the time and an antiK0\n"
<< "50% of the time. Then the K0 or antiK0 interacts with the\n"
<< "nucleus using the re-engineered GHEISHA code of\n"
<< "H. Fesefeldt, which divides the initial collision products\n"
<< "into backward- and forward-going clusters which are then\n"
<< "decayed into final state hadrons. The model does not\n"
<< "conserve energy or charge on an event-by-event basis. It\n"
<< "may be applied to K0S with initial energies between 0 and\n"
<< "25 GeV.\n";
}
private:
G4LEKaonZeroInelastic theKaonZeroInelastic;
G4LEAntiKaonZeroInelastic theAntiKaonZeroInelastic;
G4LEAntiKaonZeroInelastic theAntiKaonZeroInelastic;
};
#endif
source/processes/hadronic/models/low_energy/include/G4LELambdaInelastic.hh
+26 -32
View File
@@ -23,13 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LELambdaInelastic.hh,v 1.11 2007-02-26 18:27:08 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LELambdaInelastic.hh,v 1.11 2007/02/26 18:27:08 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy Lambda Inelastic Process
// J.L. Chuma, TRIUMF, 18-Feb-1997
// Last modified: 27-Mar-1997
// Hadronic Process: Low Energy Lambda Inelastic Process
// J.L. Chuma, TRIUMF, 18-Feb-1997
#ifndef G4LELambdaInelastic_h
#define G4LELambdaInelastic_h 1
@@ -42,36 +40,32 @@
// Class Description - End
#include "G4InelasticInteraction.hh"
class G4LELambdaInelastic : public G4InelasticInteraction
{
public:
class G4LELambdaInelastic : public G4InelasticInteraction
{
public:
G4LELambdaInelastic() : G4InelasticInteraction("G4LELambdaInelastic")
{
SetMinEnergy( 0.0 );
SetMaxEnergy( 25.*GeV );
}
G4LELambdaInelastic(const G4String& name = "G4LELambdaInelastic");
~G4LELambdaInelastic() { }
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
private:
private:
void
Cascade( // derived from CASL0
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int &vecLen,
const G4HadProjectile *originalIncident,
G4ReactionProduct &currentParticle,
G4ReactionProduct &targetParticle,
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic );
};
void Cascade( // derived from CASL0
G4FastVector<G4ReactionProduct,GHADLISTSIZE>& vec,
G4int& vecLen,
const G4HadProjectile* originalIncident,
G4ReactionProduct& currentParticle,
G4ReactionProduct& targetParticle,
G4bool& incidentHasChanged,
G4bool& targetHasChanged,
G4bool& quasiElastic);
};
#endif
source/processes/hadronic/models/low_energy/include/G4LENeutronInelastic.hh
+28 -27
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// Hadronic Process: Low Energy Neutron Inelastic Process
// original by J.L. Chuma, TRIUMF, 04-Feb-1997
// Hadronic Process: Low Energy Neutron Inelastic Process
// original by J.L. Chuma, TRIUMF, 04-Feb-1997
#ifndef G4LENeutronInelastic_h
#define G4LENeutronInelastic_h 1
@@ -37,41 +37,42 @@
// Class Description - End
#include "G4InelasticInteraction.hh"
class G4LENeutronInelastic : public G4InelasticInteraction
{
public:
class G4LENeutronInelastic : public G4InelasticInteraction
{
public:
G4LENeutronInelastic() : G4InelasticInteraction("G4LENeutronInelastic")
{
SetMinEnergy( 0.0 );
SetMaxEnergy( 55.*GeV );
SetMinEnergy(0.0);
SetMaxEnergy(55.*GeV);
}
~G4LENeutronInelastic()
{ }
~G4LENeutronInelastic() {}
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
private:
private:
void Cascade( // derived from CASN
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int &vecLen,
const G4HadProjectile *originalIncident,
G4ReactionProduct &currentParticle,
G4ReactionProduct &targetParticle,
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic );
G4FastVector<G4ReactionProduct,GHADLISTSIZE>& vec,
G4int& vecLen,
const G4HadProjectile* originalIncident,
G4ReactionProduct& currentParticle,
G4ReactionProduct& targetParticle,
G4bool& incidentHasChanged,
G4bool& targetHasChanged,
G4bool& quasiElastic);
void SlowNeutron(
const G4HadProjectile *originalIncident,
G4ReactionProduct &modifiedOriginal,
G4ReactionProduct &targetParticle,
G4Nucleus & targetNucleus );
};
void SlowNeutron(const G4HadProjectile* originalIncident,
G4ReactionProduct& modifiedOriginal,
G4ReactionProduct& targetParticle,
G4Nucleus& targetNucleus);
};
#endif
source/processes/hadronic/models/low_energy/include/G4LEOmegaMinusInelastic.hh
+16 -16
View File
@@ -23,13 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEOmegaMinusInelastic.hh,v 1.11 2007-02-26 18:29:56 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEOmegaMinusInelastic.hh,v 1.11 2007/02/26 18:29:56 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy OmegaMinus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Nov-1996
// Last modified: 27-Mar-1997
// Hadronic Process: Low Energy OmegaMinus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Nov-1996
#ifndef G4LEOmegaMinusInelastic_h
#define G4LEOmegaMinusInelastic_h 1
@@ -43,22 +41,24 @@
#include "G4InelasticInteraction.hh"
class G4LEOmegaMinusInelastic : public G4InelasticInteraction
{
public:
class G4LEOmegaMinusInelastic : public G4InelasticInteraction
{
public:
G4LEOmegaMinusInelastic() : G4InelasticInteraction("G4LEOmegaMinusInelastic")
{
SetMinEnergy( 0.0 );
SetMaxEnergy( 25.*GeV );
SetMinEnergy(0.0);
SetMaxEnergy(25.*GeV);
}
~G4LEOmegaMinusInelastic() { }
~G4LEOmegaMinusInelastic() {}
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
private:
private:
void Cascade( // derived from CASOM
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
@@ -70,7 +70,7 @@
G4bool &targetHasChanged,
G4bool &quasiElastic );
};
};
#endif
source/processes/hadronic/models/low_energy/include/G4LEPionMinusInelastic.hh
+19 -24
View File
@@ -23,13 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEPionMinusInelastic.hh,v 1.12 2007-02-24 05:23:37 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEPionMinusInelastic.hh,v 1.12 2007/02/24 05:23:37 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
// original by J.L. Chuma, TRIUMF, 03-Feb-1997
//
// Hadronic Process: Low Energy PionMinus Inelastic Process
// original by J.L. Chuma, TRIUMF, 03-Feb-1997
// Last modified: 27-Mar-1997
#ifndef G4LEPionMinusInelastic_h
#define G4LEPionMinusInelastic_h 1
@@ -42,23 +40,22 @@
// Class Description - End
#include "G4InelasticInteraction.hh"
class G4LEPionMinusInelastic : public G4InelasticInteraction
{
public:
class G4LEPionMinusInelastic : public G4InelasticInteraction
{
public:
G4LEPionMinusInelastic() : G4InelasticInteraction("G4LEPionMinusInelastic")
{
SetMinEnergy( 0.0 );
SetMaxEnergy( 55.*GeV );
}
G4LEPionMinusInelastic(const G4String& name = "G4LEPionMinusInelastic");
~G4LEPionMinusInelastic() { }
~G4LEPionMinusInelastic() {}
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
private:
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
private:
void Cascade( // derived from CASPIM
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
@@ -68,9 +65,7 @@
G4ReactionProduct &targetParticle,
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic );
};
G4bool &quasiElastic );
};
#endif
source/processes/hadronic/models/low_energy/include/G4LEPionPlusInelastic.hh
+22 -26
View File
@@ -23,13 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEPionPlusInelastic.hh,v 1.12 2007-02-24 05:23:52 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEPionPlusInelastic.hh,v 1.12 2007/02/24 05:23:52 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy PionPlus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Nov-1996
// Last modified: 27-Mar-1997
// Hadronic Process: Low Energy PionPlus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Nov-1996
#ifndef G4LEPionPlusInelastic_h
#define G4LEPionPlusInelastic_h 1
@@ -43,33 +41,31 @@
#include "G4InelasticInteraction.hh"
class G4LEPionPlusInelastic : public G4InelasticInteraction
{
public:
class G4LEPionPlusInelastic : public G4InelasticInteraction
{
public:
G4LEPionPlusInelastic() : G4InelasticInteraction("G4LEPionPlusInelastic")
{
SetMinEnergy( 0.0 );
SetMaxEnergy( 55.*GeV );
}
G4LEPionPlusInelastic(const G4String& name = "G4LEPionPlusInelastic");
~G4LEPionPlusInelastic() { }
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
private:
private:
void Cascade( // derived from CASPIP
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int &vecLen,
const G4HadProjectile *originalIncident,
G4ReactionProduct &currentParticle,
G4ReactionProduct &targetParticle,
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic );
G4FastVector<G4ReactionProduct,GHADLISTSIZE>& vec,
G4int& vecLen,
const G4HadProjectile* originalIncident,
G4ReactionProduct& currentParticle,
G4ReactionProduct& targetParticle,
G4bool& incidentHasChanged,
G4bool& targetHasChanged,
G4bool& quasiElastic);
};
};
#endif
source/processes/hadronic/models/low_energy/include/G4LEProtonInelastic.hh
+31 -35
View File
@@ -23,15 +23,13 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEProtonInelastic.hh,v 1.12 2007-02-26 18:31:19 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEProtonInelastic.hh,v 1.12 2007/02/26 18:31:19 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy Proton Inelastic Process
// original by H.P. Wellisch
// modified by J.L. Chuma, TRIUMF, 19-Nov-1996
// Last modified: 27-Mar-1997
// Modified by J.L.Chuma 8-Jul-97 to implement Nucleus changes
// Hadronic Process: Low Energy Proton Inelastic Process
// original by H.P. Wellisch
// modified by J.L. Chuma, TRIUMF, 19-Nov-1996
// Modified by J.L.Chuma 8-Jul-97 to implement Nucleus changes
#ifndef G4LEProtonInelastic_h
#define G4LEProtonInelastic_h 1
@@ -44,38 +42,36 @@
// Class Description - End
#include "G4InelasticInteraction.hh"
class G4LEProtonInelastic : public G4InelasticInteraction
{
public:
class G4LEProtonInelastic : public G4InelasticInteraction
{
public:
G4LEProtonInelastic(const G4String& name = "G4LEProtonInelastic");
~G4LEProtonInelastic() {}
G4LEProtonInelastic() : G4InelasticInteraction("G4LEProtonInelastic")
{
SetMinEnergy( 0.0 );
SetMaxEnergy( 55.*GeV );
}
~G4LEProtonInelastic()
{ }
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
private:
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
private:
void Cascade( // derived from CASP
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int &vecLen,
const G4HadProjectile *originalIncident,
G4ReactionProduct &currentParticle,
G4ReactionProduct &targetParticle,
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic );
G4FastVector<G4ReactionProduct,GHADLISTSIZE>& vec,
G4int& vecLen,
const G4HadProjectile* originalIncident,
G4ReactionProduct& currentParticle,
G4ReactionProduct& targetParticle,
G4bool& incidentHasChanged,
G4bool& targetHasChanged,
G4bool& quasiElastic);
void SlowProton(
const G4HadProjectile *originalIncident,
G4Nucleus &targetNucleus );
};
void SlowProton(const G4HadProjectile* originalIncident,
G4Nucleus& targetNucleus);
};
#endif
source/processes/hadronic/models/low_energy/include/G4LESigmaMinusInelastic.hh
+16 -17
View File
@@ -23,13 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LESigmaMinusInelastic.hh,v 1.11 2007-02-26 18:33:03 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LESigmaMinusInelastic.hh,v 1.11 2007/02/26 18:33:03 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy SigmaMinus Inelastic Process
// original by J.L. Chuma, TRIUMF, 03-Feb-1997
// Last modified: 27-Mar-1997
// Hadronic Process: Low Energy SigmaMinus Inelastic Process
// original by J.L. Chuma, TRIUMF, 03-Feb-1997
#ifndef G4LESigmaMinusInelastic_h
#define G4LESigmaMinusInelastic_h 1
@@ -43,23 +41,24 @@
#include "G4InelasticInteraction.hh"
class G4LESigmaMinusInelastic : public G4InelasticInteraction
{
public:
class G4LESigmaMinusInelastic : public G4InelasticInteraction
{
public:
G4LESigmaMinusInelastic() : G4InelasticInteraction("G4LESigmaMinusInelastic")
{
SetMinEnergy( 0.0 );
SetMaxEnergy( 25.*GeV );
SetMinEnergy(0.0);
SetMaxEnergy(25.*GeV);
}
~G4LESigmaMinusInelastic()
{ }
~G4LESigmaMinusInelastic() {}
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
private:
private:
void Cascade( // derived from CASSM
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
@@ -71,7 +70,7 @@
G4bool &targetHasChanged,
G4bool &quasiElastic );
};
};
#endif
source/processes/hadronic/models/low_energy/include/G4LESigmaPlusInelastic.hh
+14 -14
View File
@@ -23,13 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LESigmaPlusInelastic.hh,v 1.11 2007-02-26 18:33:48 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LESigmaPlusInelastic.hh,v 1.11 2007/02/26 18:33:48 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy SigmaPlus Inelastic Process
// original by J.L. Chuma, TRIUMF, 03-Feb-1997
// Last modified: 27-Mar-1997
// Hadronic Process: Low Energy SigmaPlus Inelastic Process
// original by J.L. Chuma, TRIUMF, 03-Feb-1997
#ifndef G4LESigmaPlusInelastic_h
#define G4LESigmaPlusInelastic_h 1
@@ -43,9 +41,9 @@
#include "G4InelasticInteraction.hh"
class G4LESigmaPlusInelastic : public G4InelasticInteraction
{
public:
class G4LESigmaPlusInelastic : public G4InelasticInteraction
{
public:
G4LESigmaPlusInelastic() : G4InelasticInteraction("G4LESigmaPlusInelastic")
{
@@ -55,10 +53,12 @@
~G4LESigmaPlusInelastic() { }
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
private:
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
private:
void Cascade( // derived from CASSM
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
@@ -70,7 +70,7 @@
G4bool &targetHasChanged,
G4bool &quasiElastic );
};
};
#endif
source/processes/hadronic/models/low_energy/include/G4LETritonInelastic.hh
+12 -12
View File
@@ -23,13 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LETritonInelastic.hh,v 1.10 2007-02-26 18:34:35 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LETritonInelastic.hh,v 1.10 2007/02/26 18:34:35 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy Triton Inelastic Process
// J.L. Chuma, TRIUMF, 25-Feb-1997
// Last modified: 27-Mar-1997
// Hadronic Process: Low Energy Triton Inelastic Process
// J.L. Chuma, TRIUMF, 25-Feb-1997
#ifndef G4LETritonInelastic_h
#define G4LETritonInelastic_h 1
@@ -43,22 +41,24 @@
#include "G4InelasticInteraction.hh"
class G4LETritonInelastic : public G4InelasticInteraction
{
public:
class G4LETritonInelastic : public G4InelasticInteraction
{
public:
G4LETritonInelastic() : G4InelasticInteraction("G4LETritonInelastic")
{
SetMinEnergy( 0.0 );
// SetMaxEnergy( 100.*MeV ); // NUCREC only worked for energies < 100MeV
// Work around to avoid exception in G4EnergyRangeManager
SetMaxEnergy( 10.*TeV ); // NUCREC only worked for energies < 100MeV
SetMaxEnergy(10.*TeV); // NUCREC only worked for energies < 100MeV
}
~G4LETritonInelastic() { }
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
};
#endif
source/processes/hadronic/models/low_energy/include/G4LEXiMinusInelastic.hh
+13 -13
View File
@@ -23,13 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEXiMinusInelastic.hh,v 1.11 2007-02-26 18:35:18 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEXiMinusInelastic.hh,v 1.11 2007/02/26 18:35:18 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy XiMinus Inelastic Process
// original by J.L. Chuma, TRIUMF, 03-Feb-1997
// Last modified: 27-Mar-1997
// Hadronic Process: Low Energy XiMinus Inelastic Process
// original by J.L. Chuma, TRIUMF, 03-Feb-1997
#ifndef G4LEXiMinusInelastic_h
#define G4LEXiMinusInelastic_h 1
@@ -43,9 +41,9 @@
#include "G4InelasticInteraction.hh"
class G4LEXiMinusInelastic : public G4InelasticInteraction
{
public:
class G4LEXiMinusInelastic : public G4InelasticInteraction
{
public:
G4LEXiMinusInelastic() : G4InelasticInteraction("G4LEXiMinusInelastic")
{
@@ -55,10 +53,12 @@
~G4LEXiMinusInelastic() { }
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
private:
private:
void Cascade( // derived from CASXM
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
@@ -70,7 +70,7 @@
G4bool &targetHasChanged,
G4bool &quasiElastic );
};
};
#endif
source/processes/hadronic/models/low_energy/include/G4LEXiZeroInelastic.hh
+14 -15
View File
@@ -23,13 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEXiZeroInelastic.hh,v 1.11 2007-02-26 18:36:05 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEXiZeroInelastic.hh,v 1.11 2007/02/26 18:36:05 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy XiZero Inelastic Process
// original by J.L. Chuma, TRIUMF, 03-Feb-1997
// Last modified: 27-Mar-1997
// Hadronic Process: Low Energy XiZero Inelastic Process
// original by J.L. Chuma, TRIUMF, 03-Feb-1997
#ifndef G4LEXiZeroInelastic_h
#define G4LEXiZeroInelastic_h 1
@@ -43,9 +41,9 @@
#include "G4InelasticInteraction.hh"
class G4LEXiZeroInelastic : public G4InelasticInteraction
{
public:
class G4LEXiZeroInelastic : public G4InelasticInteraction
{
public:
G4LEXiZeroInelastic() : G4InelasticInteraction("G4LEXiZeroInelastic")
{
@@ -53,13 +51,14 @@
SetMaxEnergy( 25.*GeV );
}
~G4LEXiZeroInelastic()
{ }
~G4LEXiZeroInelastic() {}
G4HadFinalState * ApplyYourself(const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus );
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
virtual void ModelDescription(std::ostream& outFile) const;
private:
private:
void Cascade( // derived from CASX0
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
@@ -71,7 +70,7 @@
G4bool &targetHasChanged,
G4bool &quasiElastic );
};
};
#endif
source/processes/hadronic/models/low_energy/include/G4LElastic.hh
+20 -26
View File
@@ -23,9 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: G4LElastic.hh,v 1.12 2007/02/26 19:05:01 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4LElastic.hh,v 1.12 2007-02-26 19:05:01 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
//
// G4 Model: Low energy elastic scattering -- header file
@@ -35,8 +34,6 @@
//
// use -scheme for elastic scattering: HPW, 20th June 1997
// most of the code comes from the old Low-energy Elastic class
//
#ifndef G4LElastic_h
#define G4LElastic_h 1
@@ -64,35 +61,32 @@
class G4LElastic : public G4HadronicInteraction
{
public:
public:
G4LElastic() : G4HadronicInteraction("G4LElastic")
{
SetMinEnergy( 0.0*GeV );
SetMaxEnergy( DBL_MAX );
}
G4LElastic(const G4String& name = "G4LElastic");
~G4LElastic() {};
~G4LElastic() {};
G4HadFinalState * ApplyYourself(const G4HadProjectile & aTrack,
G4Nucleus & targetNucleus);
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
private:
virtual void ModelDescription(std::ostream& outFile) const;
private:
G4LightMedia LightMedia;
G4LightMedia LightMedia;
G4int Rtmi(G4double* x, G4double xli, G4double xri, G4double eps,
G4int iend,
G4double aa, G4double bb, G4double cc, G4double dd,
G4double rr);
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 Fctcos(G4double t,
G4double aa, G4double bb, G4double cc, G4double dd,
G4double rr);
void Defs1(G4double p, G4double px, G4double py, G4double pz,
G4double pxinc, G4double pyinc, G4double pzinc,
G4double* pxnew, G4double* pynew, G4double* pznew);
void Defs1(G4double p, G4double px, G4double py, G4double pz,
G4double pxinc, G4double pyinc, G4double pzinc,
G4double* pxnew, G4double* pynew, G4double* pznew);
};
#endif
source/processes/hadronic/models/low_energy/include/G4LFission.hh
+12 -13
View File
@@ -23,9 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: G4LFission.hh,v 1.11 2006/06/29 20:44:27 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4LFission.hh,v 1.11 2006-06-29 20:44:27 gunter Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
//
// G4 Low-energy Model: Fission -- header file
@@ -35,7 +34,6 @@
//
// use -scheme for elastic scattering: HPW, 20th June 1997
// most of the code comes from the old Low-energy Fission class
//
// Class Description
// Final state production model for induced fission;
@@ -67,20 +65,21 @@
class G4LFission : public G4HadronicInteraction
{
public:
public:
G4LFission();
~G4LFission();
G4LFission(const G4String& name = "G4LFission");
~G4LFission();
G4HadFinalState * ApplyYourself(const G4HadProjectile & aTrack,
G4Nucleus& targetNucleus);
G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus);
static G4double Atomas(const G4double A, const G4double Z);
static G4double Atomas(const G4double A, const G4double Z);
private:
virtual void ModelDescription(std::ostream& outFile) const;
void init();
private:
G4double spneut[10];
void init();
G4double spneut[10];
};
#endif
source/processes/hadronic/models/low_energy/sources.cmake
+1 -1
View File
@@ -11,7 +11,7 @@
#
# Generated on : 24/9/2010
#
# $Id: sources.cmake,v 1.1 2010/09/29 19:03:39 bmorgan Exp $
# $Id: sources.cmake,v 1.1 2010-09-29 19:03:39 bmorgan Exp $
#
#------------------------------------------------------------------------------
source/processes/hadronic/models/low_energy/src/G4LCapture.cc
+120 -105
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4LCapture.cc,v 1.14 2007/02/24 05:17:29 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4LCapture.cc,v 1.14 2007-02-24 05:17:29 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
//
// G4 Model: Low-energy Neutron Capture
@@ -44,134 +44,149 @@
#include "globals.hh"
#include "G4LCapture.hh"
#include "Randomize.hh"
#include <iostream>
G4LCapture::G4LCapture() :
G4HadronicInteraction("G4LCapture")
G4LCapture::G4LCapture(const G4String& name)
: G4HadronicInteraction(name)
{
SetMinEnergy( 0.0*GeV );
SetMaxEnergy( DBL_MAX );
SetMinEnergy(0.0*GeV);
SetMaxEnergy(DBL_MAX);
// Description();
}
G4LCapture::~G4LCapture()
{
theParticleChange.Clear();
theParticleChange.Clear();
}
void G4LCapture::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LCapture is one of the Low Energy Parameterized\n"
<< "(LEP) models used to implement neutron capture on nuclei.\n"
<< "It is a re-engineered version of the GHEISHA code of\n"
<< "H. Fesefeldt which simply adds the neutron mass and energy\n"
<< "to the target nucleus, and emits gammas isotropically as\n"
<< "long as there is sufficient excitation energy in the\n"
<< "daughter nucleus. The model is applicable to all incident\n"
<< "neutron energies.\n";
}
G4HadFinalState*
G4LCapture::ApplyYourself(const G4HadProjectile & aTrack, G4Nucleus& targetNucleus)
G4LCapture::ApplyYourself(const G4HadProjectile& aTrack, G4Nucleus& targetNucleus)
{
theParticleChange.Clear();
theParticleChange.SetStatusChange(stopAndKill);
theParticleChange.Clear();
theParticleChange.SetStatusChange(stopAndKill);
G4double N = targetNucleus.GetA_asInt();
G4double Z = targetNucleus.GetZ_asInt();
G4double N = targetNucleus.GetN();
G4double Z = targetNucleus.GetZ();
const G4LorentzVector theMom = aTrack.Get4Momentum();
G4double P = theMom.vect().mag()/GeV;
G4double Px = theMom.vect().x()/GeV;
G4double Py = theMom.vect().y()/GeV;
G4double Pz = theMom.vect().z()/GeV;
G4double E = theMom.e()/GeV;
G4double E0 = aTrack.GetDefinition()->GetPDGMass()/GeV;
G4double Q = aTrack.GetDefinition()->GetPDGCharge();
if (verboseLevel > 1) {
G4cout << "G4LCapture:ApplyYourself: incident particle:" << G4endl;
G4cout << "P " << P << " GeV/c" << G4endl;
G4cout << "Px " << Px << " GeV/c" << G4endl;
G4cout << "Py " << Py << " GeV/c" << G4endl;
G4cout << "Pz " << Pz << " GeV/c" << G4endl;
G4cout << "E " << E << " GeV" << G4endl;
G4cout << "mass " << E0 << " GeV" << G4endl;
G4cout << "charge " << Q << G4endl;
}
const G4LorentzVector theMom = aTrack.Get4Momentum();
G4double P = theMom.vect().mag()/GeV;
G4double Px = theMom.vect().x()/GeV;
G4double Py = theMom.vect().y()/GeV;
G4double Pz = theMom.vect().z()/GeV;
G4double E = theMom.e()/GeV;
G4double E0 = aTrack.GetDefinition()->GetPDGMass()/GeV;
G4double Q = aTrack.GetDefinition()->GetPDGCharge();
if (verboseLevel > 1) {
G4cout << "G4LCapture:ApplyYourself: incident particle:" << G4endl;
G4cout << "P " << P << " GeV/c" << G4endl;
G4cout << "Px " << Px << " GeV/c" << G4endl;
G4cout << "Py " << Py << " GeV/c" << G4endl;
G4cout << "Pz " << Pz << " GeV/c" << G4endl;
G4cout << "E " << E << " GeV" << G4endl;
G4cout << "mass " << E0 << " GeV" << G4endl;
G4cout << "charge " << Q << G4endl;
}
// GHEISHA ADD operation to get total energy, mass, charge:
// GHEISHA ADD operation to get total energy, mass, charge:
if (verboseLevel > 1) {
G4cout << "G4LCapture:ApplyYourself: material:" << G4endl;
G4cout << "A " << N << G4endl;
G4cout << "Z " << Z << G4endl;
G4cout << "atomic mass " <<
Atomas(N, Z) << "GeV" << G4endl;
}
E = E + Atomas(N, Z);
G4double E02 = E*E - P*P;
E0 = std::sqrt(std::abs(E02));
if (E02 < 0) E0 = -E0;
Q = Q + Z;
if (verboseLevel > 1) {
G4cout << "G4LCapture:ApplyYourself: total:" << G4endl;
G4cout << "E " << E << " GeV" << G4endl;
G4cout << "mass " << E0 << " GeV" << G4endl;
G4cout << "charge " << Q << G4endl;
}
Px = -Px;
Py = -Py;
Pz = -Pz;
if (verboseLevel > 1) {
G4cout << "G4LCapture:ApplyYourself: material:" << G4endl;
G4cout << "A " << N << G4endl;
G4cout << "Z " << Z << G4endl;
G4cout << "atomic mass " <<
Atomas(N, Z) << "GeV" << G4endl;
}
E = E + Atomas(N, Z);
G4double E02 = E*E - P*P;
E0 = std::sqrt(std::abs(E02));
if (E02 < 0) E0 = -E0;
Q = Q + Z;
if (verboseLevel > 1) {
G4cout << "G4LCapture:ApplyYourself: total:" << G4endl;
G4cout << "E " << E << " GeV" << G4endl;
G4cout << "mass " << E0 << " GeV" << G4endl;
G4cout << "charge " << Q << G4endl;
}
Px = -Px;
Py = -Py;
Pz = -Pz;
// Make a gamma...
// Make a gamma...
G4double p;
if (Z == 1 && N == 1) { // special case for hydrogen
p = 0.0022;
} else {
G4double ran = G4RandGauss::shoot();
p = 0.0065 + ran*0.0010;
}
G4double p;
if (Z == 1 && N == 1) { // special case for hydrogen
p = 0.0022;
} else {
G4double ran = G4RandGauss::shoot();
p = 0.0065 + ran*0.0010;
}
G4double ran1 = G4UniformRand();
G4double ran2 = G4UniformRand();
G4double cost = -1. + 2.*ran1;
G4double sint = std::sqrt(std::abs(1. - cost*cost));
G4double phi = ran2*twopi;
G4double ran1 = G4UniformRand();
G4double ran2 = G4UniformRand();
G4double cost = -1. + 2.*ran1;
G4double sint = std::sqrt(std::abs(1. - cost*cost));
G4double phi = ran2*twopi;
G4double px = p*sint*std::sin(phi);
G4double py = p*sint*std::cos(phi);
G4double pz = p*cost;
G4double e = p;
G4double px = p*sint*std::sin(phi);
G4double py = p*sint*std::cos(phi);
G4double pz = p*cost;
G4double e = p;
G4double e0 = 0.;
G4double a = px*Px + py*Py + pz*Pz;
a = (a/(E + E0) - e)/E0;
G4double a = px*Px + py*Py + pz*Pz;
a = (a/(E + E0) - e)/E0;
px = px + a*Px;
py = py + a*Py;
pz = pz + a*Pz;
px = px + a*Px;
py = py + a*Py;
pz = pz + a*Pz;
G4DynamicParticle* aGamma;
aGamma = new G4DynamicParticle(G4Gamma::GammaDefinition(),
G4ThreeVector(px*GeV, py*GeV, pz*GeV));
theParticleChange.AddSecondary(aGamma);
G4DynamicParticle* aGamma;
aGamma = new G4DynamicParticle(G4Gamma::GammaDefinition(),
G4ThreeVector(px*GeV, py*GeV, pz*GeV));
theParticleChange.AddSecondary(aGamma);
// Make another gamma if there is sufficient energy left over...
// Make another gamma if there is sufficient energy left over...
G4double xp = 0.008 - p;
if (xp > 0.) {
if (Z > 1 || N > 1) {
ran1 = G4UniformRand();
ran2 = G4UniformRand();
cost = -1. + 2.*ran1;
sint = std::sqrt(std::abs(1. - cost*cost));
phi = ran2*twopi;
G4double xp = 0.008 - p;
if (xp > 0.) {
if (Z > 1 || N > 1) {
ran1 = G4UniformRand();
ran2 = G4UniformRand();
cost = -1. + 2.*ran1;
sint = std::sqrt(std::abs(1. - cost*cost));
phi = ran2*twopi;
px = xp*sint*std::sin(phi);
py = xp*sint*std::cos(phi);
pz = xp*cost;
e = xp;
px = xp*sint*std::sin(phi);
py = xp*sint*std::cos(phi);
pz = xp*cost;
e = xp;
e0 = 0.;
a = px*Px + py*Py + pz*Pz;
a = (a/(E + E0) - e)/E0;
a = px*Px + py*Py + pz*Pz;
a = (a/(E + E0) - e)/E0;
px = px + a*Px;
py = py + a*Py;
pz = pz + a*Pz;
px = px + a*Px;
py = py + a*Py;
pz = pz + a*Pz;
aGamma = new G4DynamicParticle(G4Gamma::GammaDefinition(),
G4ThreeVector(px*GeV, py*GeV, pz*GeV));
theParticleChange.AddSecondary(aGamma);
}
}
return &theParticleChange;
aGamma = new G4DynamicParticle(G4Gamma::GammaDefinition(),
G4ThreeVector(px*GeV, py*GeV, pz*GeV));
theParticleChange.AddSecondary(aGamma);
}
}
return &theParticleChange;
}
source/processes/hadronic/models/low_energy/src/G4LEAlphaInelastic.cc
+87 -64
View File
@@ -23,79 +23,102 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//
// Hadronic Process: Alpha Inelastic Process
// J.L. Chuma, TRIUMF, 25-Feb-1997
// Last modified: 27-Mar-1997
// J.L. Chuma, 08-May-2001: Update original incident passed back in vec[0]
// from NuclearReaction
//
// Hadronic Process: Alpha Inelastic Process
// J.L. Chuma, TRIUMF, 25-Feb-1997
// J.L. Chuma, 08-May-2001: Update original incident passed back in vec[0]
// from NuclearReaction
#include "G4LEAlphaInelastic.hh"
#include "Randomize.hh"
#include "G4Electron.hh"
G4HadFinalState *
G4LEAlphaInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
theParticleChange.Clear();
G4double A = targetNucleus.GetN();
G4double Z = targetNucleus.GetZ();
#include <iostream>
G4LEAlphaInelastic::G4LEAlphaInelastic(const G4String& name)
: G4InelasticInteraction(name)
{
SetMinEnergy(0.0*GeV);
SetMaxEnergy(10.*TeV);
}
void G4LEAlphaInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LEAlphaInelastic is one of the Low Energy Parameterized\n"
<< "(LEP) models used to implement inelastic alpha scattering\n"
<< "from nuclei. It is a re-engineered version of the GHEISHA\n"
<< "code of H. Fesefeldt. It divides the initial collision\n"
<< "products into backward- and forward-going clusters which are\n"
<< "then decayed into final state hadrons. The model does not\n"
<< "conserve energy on an event-by-event basis. It may be\n"
<< "applied to alphas with initial energies between 0 and 10\n"
<< "TeV.\n";
}
G4HadFinalState*
G4LEAlphaInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
theParticleChange.Clear();
G4double A = targetNucleus.GetA_asInt();
G4double Z = targetNucleus.GetZ_asInt();
G4double kineticEnergy = aTrack.Get4Momentum().e()-aTrack.GetDefinition()->GetPDGMass();
if( verboseLevel > 1 )
{
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEAlphaInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetc energy = " <<kineticEnergy/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << G4endl;
}
G4double kineticEnergy = aTrack.Get4Momentum().e()-aTrack.GetDefinition()->GetPDGMass();
if (verboseLevel > 1) {
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEAlphaInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetc energy = " <<kineticEnergy/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << G4endl;
}
// Work-around for lack of model above 100 MeV
if (kineticEnergy/MeV > 100. || kineticEnergy <= 0.1*MeV)
// Work-around for lack of model above 100 MeV
if (kineticEnergy/MeV > 100. || kineticEnergy <= 0.1*MeV) {
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
G4double theAtomicMass = targetNucleus.AtomicMass( A, Z );
G4double massVec[9];
massVec[0] = targetNucleus.AtomicMass( A+4.0, Z+2.0 );
massVec[1] = targetNucleus.AtomicMass( A+3.0, Z+2.0 );
massVec[2] = targetNucleus.AtomicMass( A+3.0, Z+1.0 );
massVec[3] = targetNucleus.AtomicMass( A+2.0, Z+1.0 );
massVec[4] = targetNucleus.AtomicMass( A+1.0, Z+1.0 );
massVec[5] = theAtomicMass;
massVec[6] = targetNucleus.AtomicMass( A+2.0, Z+2.0 );
massVec[7] = massVec[3];
massVec[8] = targetNucleus.AtomicMass( A+2.0, Z );
G4FastVector<G4ReactionProduct,4> vec; // vec will contain the secondary particles
G4int vecLen = 0;
vec.Initialize( 0 );
theReactionDynamics.NuclearReaction(vec, vecLen, &aTrack,
targetNucleus, theAtomicMass, massVec);
G4double p = vec[0]->GetMomentum().mag();
theParticleChange.SetMomentumChange( vec[0]->GetMomentum() *(1./p));
theParticleChange.SetEnergyChange( vec[0]->GetKineticEnergy() );
delete vec[0];
if (vecLen <= 1)
{
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
G4double theAtomicMass = targetNucleus.AtomicMass( A, Z );
G4double massVec[9];
massVec[0] = targetNucleus.AtomicMass( A+4.0, Z+2.0 );
massVec[1] = targetNucleus.AtomicMass( A+3.0, Z+2.0 );
massVec[2] = targetNucleus.AtomicMass( A+3.0, Z+1.0 );
massVec[3] = targetNucleus.AtomicMass( A+2.0, Z+1.0 );
massVec[4] = targetNucleus.AtomicMass( A+1.0, Z+1.0 );
massVec[5] = theAtomicMass;
massVec[6] = targetNucleus.AtomicMass( A+2.0, Z+2.0 );
massVec[7] = massVec[3];
massVec[8] = targetNucleus.AtomicMass( A+2.0, Z );
//
G4FastVector<G4ReactionProduct,4> vec; // vec will contain the secondary particles
G4int vecLen = 0;
vec.Initialize( 0 );
//
theReactionDynamics.NuclearReaction( vec, vecLen, &aTrack,
targetNucleus, theAtomicMass, massVec );
//
G4double p = vec[0]->GetMomentum().mag();
theParticleChange.SetMomentumChange( vec[0]->GetMomentum() *(1./p));
theParticleChange.SetEnergyChange( vec[0]->GetKineticEnergy() );
delete vec[0];
//
G4DynamicParticle *pd;
for( G4int i=1; i<vecLen; ++i )
{
pd = new G4DynamicParticle();
pd->SetDefinition( vec[i]->GetDefinition() );
pd->SetMomentum( vec[i]->GetMomentum() );
theParticleChange.AddSecondary( pd );
delete vec[i];
}
//
return &theParticleChange;
G4DynamicParticle *pd;
for (G4int i = 1; i < vecLen; ++i) {
pd = new G4DynamicParticle();
pd->SetDefinition( vec[i]->GetDefinition() );
pd->SetMomentum( vec[i]->GetMomentum() );
theParticleChange.AddSecondary( pd );
delete vec[i];
}
/* end of file */
return &theParticleChange;
}
source/processes/hadronic/models/low_energy/src/G4LEAntiKaonZeroInelastic.cc
+101 -98
View File
@@ -23,112 +23,115 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEAntiKaonZeroInelastic.cc,v 1.10 2006-06-29 20:44:39 gunter Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEAntiKaonZeroInelastic.cc,v 1.10 2006/06/29 20:44:39 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy KaonZeroLong Inelastic Process
// J.L. Chuma, TRIUMF, 11-Feb-1997
// Last modified: 27-Mar-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
// Hadronic Process: Low Energy KaonZeroLong Inelastic Process
// J.L. Chuma, TRIUMF, 11-Feb-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
#include "G4LEAntiKaonZeroInelastic.hh"
#include "Randomize.hh"
#include "G4HadReentrentException.hh"
G4HadFinalState *
G4LEAntiKaonZeroInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
const G4HadProjectile *originalIncident = &aTrack;
//
// create the target particle
//
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
void G4LEAntiKaonZeroInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LEAntiKaonZeroInelastic is one of the Low Energy\n"
<< "Parameterized (LEP) models used to implement anti-K0 scattering\n"
<< "from nuclei. It is a re-engineered version of the GHEISHA code\n"
<< "of H. Fesefeldt. It divides the initial collision products\n"
<< "into backward- and forward-going clusters which are then\n"
<< "decayed into final state hadrons. The model does not conserve\n"
<< "energy on an event-by-event basis. It may be applied to\n"
<< "anti-K0s with initial energies between 0 and 25 GeV.\n";
}
G4HadFinalState*
G4LEAntiKaonZeroInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
const G4HadProjectile *originalIncident = &aTrack;
// create the target particle
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
if( verboseLevel > 1 )
{
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEAntiKaonZeroInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
if (verboseLevel > 1) {
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEAntiKaonZeroInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
<< G4endl;
}
//
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
//
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
modifiedOriginal.SetKineticEnergy( ek*MeV );
G4double et = ek + amas;
G4double p = std::sqrt( std::abs((et-amas)*(et+amas)) );
G4double pp = modifiedOriginal.GetMomentum().mag()/MeV;
if( pp > 0.0 )
{
G4ThreeVector momentum = modifiedOriginal.GetMomentum();
modifiedOriginal.SetMomentum( momentum * (p/pp) );
}
//
// calculate black track energies
//
tkin = targetNucleus.EvaporationEffects( ek );
ek -= tkin;
modifiedOriginal.SetKineticEnergy( ek*MeV );
et = ek + amas;
p = std::sqrt( std::abs((et-amas)*(et+amas)) );
pp = modifiedOriginal.GetMomentum().mag()/MeV;
if( pp > 0.0 )
{
G4ThreeVector momentum = modifiedOriginal.GetMomentum();
modifiedOriginal.SetMomentum( momentum * (p/pp) );
}
G4ReactionProduct currentParticle = modifiedOriginal;
G4ReactionProduct targetParticle;
targetParticle = *originalTarget;
currentParticle.SetSide( 1 ); // incident always goes in forward hemisphere
targetParticle.SetSide( -1 ); // target always goes in backward hemisphere
G4bool incidentHasChanged = false;
G4bool targetHasChanged = false;
G4bool quasiElastic = false;
G4FastVector<G4ReactionProduct,GHADLISTSIZE> vec; // vec will contain the secondary particles
G4int vecLen = 0;
vec.Initialize( 0 );
const G4double cutOff = 0.1;
if( currentParticle.GetKineticEnergy()/MeV > cutOff )
Cascade( vec, vecLen,
originalIncident, currentParticle, targetParticle,
incidentHasChanged, targetHasChanged, quasiElastic );
try
{
CalculateMomenta( vec, vecLen,
originalIncident, originalTarget, modifiedOriginal,
targetNucleus, currentParticle, targetParticle,
incidentHasChanged, targetHasChanged, quasiElastic );
}
catch(G4HadReentrentException aR)
{
aR.Report(G4cout);
throw G4HadReentrentException(__FILE__, __LINE__, "Bailing out");
}
SetUpChange( vec, vecLen,
currentParticle, targetParticle,
incidentHasChanged );
delete originalTarget;
return &theParticleChange;
}
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
modifiedOriginal.SetKineticEnergy( ek*MeV );
G4double et = ek + amas;
G4double p = std::sqrt( std::abs((et-amas)*(et+amas)) );
G4double pp = modifiedOriginal.GetMomentum().mag()/MeV;
if (pp > 0.0) {
G4ThreeVector momentum = modifiedOriginal.GetMomentum();
modifiedOriginal.SetMomentum( momentum * (p/pp) );
}
// calculate black track energies
tkin = targetNucleus.EvaporationEffects( ek );
ek -= tkin;
modifiedOriginal.SetKineticEnergy( ek*MeV );
et = ek + amas;
p = std::sqrt( std::abs((et-amas)*(et+amas)) );
pp = modifiedOriginal.GetMomentum().mag()/MeV;
if (pp > 0.0) {
G4ThreeVector momentum = modifiedOriginal.GetMomentum();
modifiedOriginal.SetMomentum( momentum * (p/pp) );
}
G4ReactionProduct currentParticle = modifiedOriginal;
G4ReactionProduct targetParticle;
targetParticle = *originalTarget;
currentParticle.SetSide( 1 ); // incident always goes in forward hemisphere
targetParticle.SetSide( -1 ); // target always goes in backward hemisphere
G4bool incidentHasChanged = false;
G4bool targetHasChanged = false;
G4bool quasiElastic = false;
G4FastVector<G4ReactionProduct,GHADLISTSIZE> vec; // vec will contain the secondary particles
G4int vecLen = 0;
vec.Initialize( 0 );
const G4double cutOff = 0.1;
if (currentParticle.GetKineticEnergy()/MeV > cutOff)
Cascade(vec, vecLen,
originalIncident, currentParticle, targetParticle,
incidentHasChanged, targetHasChanged, quasiElastic);
try {
CalculateMomenta(vec, vecLen, originalIncident, originalTarget,
modifiedOriginal, targetNucleus, currentParticle,
targetParticle, incidentHasChanged, targetHasChanged,
quasiElastic);
}
catch(G4HadReentrentException aR)
{
aR.Report(G4cout);
throw G4HadReentrentException(__FILE__, __LINE__, "Bailing out");
}
SetUpChange(vec, vecLen, currentParticle, targetParticle, incidentHasChanged);
delete originalTarget;
return &theParticleChange;
}
void
G4LEAntiKaonZeroInelastic::Cascade(
void G4LEAntiKaonZeroInelastic::Cascade(
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int& vecLen,
const G4HadProjectile *originalIncident,
@@ -137,7 +140,7 @@
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic )
{
{
// derived from original FORTRAN code CASK0B by H. Fesefeldt (13-Sep-1987)
//
// K0Long undergoes interaction with nucleon within a nucleus. Check if it is
@@ -504,7 +507,7 @@
}
SetUpPions( np, nm, nz, vec, vecLen );
return;
}
}
/* end of file */
source/processes/hadronic/models/low_energy/src/G4LEAntiLambdaInelastic.cc
+46 -37
View File
@@ -23,45 +23,55 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEAntiLambdaInelastic.cc,v 1.11 2006-06-29 20:44:41 gunter Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEAntiLambdaInelastic.cc,v 1.11 2006/06/29 20:44:41 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: AntiLambda Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
// Last modified: 27-Mar-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
// Hadronic Process: AntiLambda Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
#include "G4LEAntiLambdaInelastic.hh"
#include "Randomize.hh"
G4HadFinalState *
G4LEAntiLambdaInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
const G4HadProjectile *originalIncident = &aTrack;
//
// create the target particle
//
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
void G4LEAntiLambdaInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LEAntiLambdaInelastic is one of the Low Energy Parameterized\n"
<< "(LEP) models used to implement inelastic anti-lambda\n"
<< "scattering from nuclei. It is a re-engineered version of the\n"
<< "GHEISHA code of H. Fesefeldt. It divides the initial\n"
<< "collision products into backward- and forward-going clusters\n"
<< "which are then decayed into final state hadrons. The model\n"
<< "does not conserve energy on an event-by-event basis. It may\n"
<< "be applied to anti-lambdas with initial energies between 0 and\n"
<< "25 GeV.\n";
}
G4HadFinalState*
G4LEAntiLambdaInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
const G4HadProjectile *originalIncident = &aTrack;
// create the target particle
G4DynamicParticle* originalTarget = targetNucleus.ReturnTargetParticle();
if( verboseLevel > 1 )
{
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEAntiLambdaInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
if (verboseLevel > 1) {
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEAntiLambdaInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
<< G4endl;
}
//
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
//
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
}
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
@@ -119,10 +129,9 @@
delete originalTarget;
return &theParticleChange;
}
}
void
G4LEAntiLambdaInelastic::Cascade(
void G4LEAntiLambdaInelastic::Cascade(
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int &vecLen,
const G4HadProjectile *originalIncident,
@@ -131,7 +140,7 @@
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic )
{
{
// derived from original FORTRAN code CASAL0 by H. Fesefeldt (13-Sep-1987)
//
// AntiLambda undergoes interaction with nucleon within a nucleus. Check if it is
@@ -642,7 +651,7 @@
}
}
return;
}
}
/* end of file */
source/processes/hadronic/models/low_energy/src/G4LEAntiNeutronInelastic.cc
+83 -63
View File
@@ -23,47 +23,69 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEAntiNeutronInelastic.cc,v 1.14 2006-06-29 20:44:43 gunter Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEAntiNeutronInelastic.cc,v 1.14 2006/06/29 20:44:43 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
// Hadronic Process: AntiNeutron Inelastic Process
// J.L. Chuma, TRIUMF, 18-Feb-1997
// J.P.Wellisch: 23-Apr-97: Added theNucleus.SetParameters call
// J.P. Wellisch: 23-Apr-97: nm = np+1; in line 392
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
//
// Hadronic Process: AntiNeutron Inelastic Process
// J.L. Chuma, TRIUMF, 18-Feb-1997
// Last modified: 27-Mar-1997
// J.P.Wellisch: 23-Apr-97: Added theNucleus.SetParameters call
// J.P. Wellisch: 23-Apr-97: nm = np+1; in line 392
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
#include "G4LEAntiNeutronInelastic.hh"
#include "Randomize.hh"
#include <iostream>
G4HadFinalState *
G4LEAntiNeutronInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
const G4HadProjectile *originalIncident = &aTrack;
//
// create the target particle
//
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
G4LEAntiNeutronInelastic::G4LEAntiNeutronInelastic(const G4String& name)
:G4InelasticInteraction(name)
{
SetMinEnergy(0.0);
SetMaxEnergy(25.*GeV);
}
void G4LEAntiNeutronInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LEAntiNeutronInelastic is one of the Low Energy\n"
<< "Parameterized (LEP) models used to implement inelastic\n"
<< "anti-neutron scattering from nuclei. It is a re-engineered\n"
<< "version of the GHEISHA code of H. Fesefeldt. It divides the\n"
<< "initial collision products into backward- and forward-going\n"
<< "clusters which are then decayed into final state hadrons.\n"
<< "The model does not conserve energy on an event-by-event\n"
<< "basis. It may be applied to anti-neutrons with initial\n"
<< "energies between 0 and 25 GeV.\n";
}
G4HadFinalState*
G4LEAntiNeutronInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
const G4HadProjectile* originalIncident = &aTrack;
// create the target particle
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
if( verboseLevel > 1 )
{
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEAntiNeutronInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
if (verboseLevel > 1) {
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEAntiNeutronInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
<< G4endl;
}
//
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
//
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
}
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
@@ -123,12 +145,12 @@
currentParticle, targetParticle,
incidentHasChanged );
delete originalTarget;
return &theParticleChange;
}
void
G4LEAntiNeutronInelastic::Cascade(
delete originalTarget;
return &theParticleChange;
}
void G4LEAntiNeutronInelastic::Cascade(
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int& vecLen,
const G4HadProjectile *originalIncident,
@@ -136,26 +158,27 @@
G4ReactionProduct &targetParticle,
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic )
{
// derived from original FORTRAN code CASNB by H. Fesefeldt (13-Sep-1987)
//
// 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.
// 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.
//
const G4double mOriginal = originalIncident->GetDefinition()->GetPDGMass()/MeV;
const G4double etOriginal = originalIncident->GetTotalEnergy()/MeV;
const G4double pOriginal = originalIncident->GetTotalMomentum()/MeV;
const G4double targetMass = targetParticle.GetMass()/MeV;
G4double centerofmassEnergy = std::sqrt( mOriginal*mOriginal +
G4bool &quasiElastic)
{
// Derived from original FORTRAN code CASNB by H. Fesefeldt (13-Sep-1987)
//
// 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. 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.
const G4double mOriginal = originalIncident->GetDefinition()->GetPDGMass()/MeV;
const G4double etOriginal = originalIncident->GetTotalEnergy()/MeV;
const G4double pOriginal = originalIncident->GetTotalMomentum()/MeV;
const G4double targetMass = targetParticle.GetMass()/MeV;
G4double centerofmassEnergy = std::sqrt( mOriginal*mOriginal +
targetMass*targetMass +
2.0*targetMass*etOriginal );
G4double availableEnergy = centerofmassEnergy-(targetMass+mOriginal);
G4double availableEnergy = centerofmassEnergy-(targetMass+mOriginal);
static G4bool first = true;
const G4int numMul = 1200;
@@ -531,9 +554,6 @@
targetParticle.SetMass( 0.0 );
}
while(np+nm+nz<3) nz++;
SetUpPions( np, nm, nz, vec, vecLen );
return;
}
/* end of file */
SetUpPions( np, nm, nz, vec, vecLen );
return;
}
source/processes/hadronic/models/low_energy/src/G4LEAntiOmegaMinusInelastic.cc
+54 -47
View File
@@ -23,55 +23,63 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEAntiOmegaMinusInelastic.cc,v 1.12 2006-06-29 20:44:45 gunter Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEAntiOmegaMinusInelastic.cc,v 1.12 2006/06/29 20:44:45 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
// Hadronic Process: AntiOmegaMinus Inelastic Process
// J.L. Chuma, TRIUMF, 20-Feb-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
//
// Hadronic Process: AntiOmegaMinus Inelastic Process
// J.L. Chuma, TRIUMF, 20-Feb-1997
// Last modified: 27-Mar-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
//
// NOTE: The FORTRAN version of the cascade, CASAOM, simply called the
// routine for the OmegaMinus particle. Hence, the Cascade function
// below is just a copy of the Cascade from the OmegaMinus particle.
// NOTE: The FORTRAN version of the cascade, CASAOM, simply called the
// routine for the OmegaMinus particle. Hence, the Cascade function
// below is just a copy of the Cascade from the OmegaMinus particle.
#include "G4LEAntiOmegaMinusInelastic.hh"
#include "Randomize.hh"
G4HadFinalState *
G4LEAntiOmegaMinusInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV)
{
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
//
// create the target particle
//
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
if( verboseLevel > 1 )
{
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
void G4LEAntiOmegaMinusInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LEAntiOmegaMinusInelastic is one of the Low Energy\n"
<< "Parameterized (LEP) models used to implement inelastic\n"
<< "antiOmega- scattering from nuclei. It is a re-engineered\n"
<< "version of the GHEISHA code of H. Fesefeldt. It divides the\n"
<< "initial collision products into backward- and forward-going\n"
<< "clusters which are then decayed into final state hadrons. The\n"
<< "model does not conserve energy on an event-by-event basis. It\n"
<< "may be applied to antiOmega- with initial energies between 0\n"
<< "and 25 GeV.\n";
}
G4HadFinalState*
G4LEAntiOmegaMinusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV) {
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
// create the target particle
G4DynamicParticle* originalTarget = targetNucleus.ReturnTargetParticle();
if (verboseLevel > 1) {
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
<< G4endl;
}
//
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
//
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
}
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
@@ -129,10 +137,9 @@
delete originalTarget;
return &theParticleChange;
}
}
void
G4LEAntiOmegaMinusInelastic::Cascade(
void G4LEAntiOmegaMinusInelastic::Cascade(
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int& vecLen,
const G4HadProjectile *originalIncident,
@@ -141,7 +148,7 @@
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic )
{
{
// derived from original FORTRAN code CASOM by H. Fesefeldt (31-Jan-1989)
//
// AntiOmegaMinus undergoes interaction with nucleon within a nucleus. Check if it is
@@ -369,7 +376,7 @@
}
}
return;
}
}
/* end of file */
source/processes/hadronic/models/low_energy/src/G4LEAntiProtonInelastic.cc
+86 -66
View File
@@ -23,54 +23,75 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEAntiProtonInelastic.cc,v 1.15 2007-02-24 05:11:27 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEAntiProtonInelastic.cc,v 1.15 2007/02/24 05:11:27 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
// Hadronic Process: AntiProton Inelastic Process
// J.L. Chuma, TRIUMF, 13-Feb-1997
// J.P. Wellisch: 23-Apr-97: Bug hunting
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
//
// Hadronic Process: AntiProton Inelastic Process
// J.L. Chuma, TRIUMF, 13-Feb-1997
// Last modified: 27-Mar-1997
// J.P. Wellisch: 23-Apr-97: Bug hunting
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
#include "G4LEAntiProtonInelastic.hh"
#include "Randomize.hh"
#include <iostream>
G4HadFinalState *
G4LEAntiProtonInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
const G4HadProjectile* originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy() <= 0.1*MeV) {
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
G4LEAntiProtonInelastic::G4LEAntiProtonInelastic(const G4String& name)
:G4InelasticInteraction(name)
{
SetMinEnergy(0.0);
SetMaxEnergy(25.*GeV);
}
//
// create the target particle
//
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
void G4LEAntiProtonInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LEAntiProtonInelastic is one of the Low Energy Parameterized\n"
<< "(LEP) models used to implement inelastic anti-proton scattering\n"
<< "from nuclei. It is a re-engineered version of the GHEISHA\n"
<< "code of H. Fesefeldt. It divides the initial collision\n"
<< "products into backward- and forward-going clusters which are\n"
<< "then decayed into final state hadrons. The model does not\n"
<< "conserve energy on an event-by-event basis. It may be\n"
<< "applied to anti-protons with initial energies between 0 and 25\n"
<< "GeV.\n";
}
G4HadFinalState*
G4LEAntiProtonInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
const G4HadProjectile* originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy() <= 0.1*MeV) {
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
// create the target particle
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
if( verboseLevel > 1 )
{
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEAntiProtonInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
if (verboseLevel > 1) {
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEAntiProtonInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
<< G4endl;
}
//
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
//
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
}
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
@@ -129,12 +150,12 @@
currentParticle, targetParticle,
incidentHasChanged );
delete originalTarget;
return &theParticleChange;
}
void
G4LEAntiProtonInelastic::Cascade(
delete originalTarget;
return &theParticleChange;
}
void G4LEAntiProtonInelastic::Cascade(
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int& vecLen,
const G4HadProjectile *originalIncident,
@@ -143,25 +164,26 @@
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic )
{
// derived from original FORTRAN code CASPB by H. Fesefeldt (13-Sep-1987)
//
// AntiProton 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.
//
const G4double mOriginal = originalIncident->GetDefinition()->GetPDGMass()/MeV;
const G4double etOriginal = originalIncident->GetTotalEnergy()/MeV;
const G4double pOriginal = originalIncident->GetTotalMomentum()/MeV;
const G4double targetMass = targetParticle.GetMass()/MeV;
G4double centerofmassEnergy = std::sqrt( mOriginal*mOriginal +
{
// derived from original FORTRAN code CASPB by H. Fesefeldt (13-Sep-1987)
//
// AntiProton 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.
const G4double mOriginal = originalIncident->GetDefinition()->GetPDGMass()/MeV;
const G4double etOriginal = originalIncident->GetTotalEnergy()/MeV;
const G4double pOriginal = originalIncident->GetTotalMomentum()/MeV;
const G4double targetMass = targetParticle.GetMass()/MeV;
G4double centerofmassEnergy = std::sqrt( mOriginal*mOriginal +
targetMass*targetMass +
2.0*targetMass*etOriginal );
G4double availableEnergy = centerofmassEnergy-(targetMass+mOriginal);
G4double availableEnergy = centerofmassEnergy-(targetMass+mOriginal);
static G4bool first = true;
const G4int numMul = 1200;
@@ -540,9 +562,7 @@
targetParticle.SetMass( 0.0 );
}
while(np+nm+nz<3) nz++;
SetUpPions( np, nm, nz, vec, vecLen );
return;
}
/* end of file */
SetUpPions( np, nm, nz, vec, vecLen );
return;
}
source/processes/hadronic/models/low_energy/src/G4LEAntiSigmaMinusInelastic.cc
+52 -45
View File
@@ -23,53 +23,61 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEAntiSigmaMinusInelastic.cc,v 1.11 2006-06-29 20:44:49 gunter Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEAntiSigmaMinusInelastic.cc,v 1.11 2006/06/29 20:44:49 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: AntiSigmaMinus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
// Last modified: 27-Mar-1997
// J.P. Wellisch: 25.Apr-97: counter errors removed lines 426, 447
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
// Hadronic Process: AntiSigmaMinus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
// J.P. Wellisch: 25.Apr-97: counter errors removed lines 426, 447
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
#include "G4LEAntiSigmaMinusInelastic.hh"
#include "Randomize.hh"
G4HadFinalState *
G4LEAntiSigmaMinusInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV)
{
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
//
// create the target particle
//
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
void G4LEAntiSigmaMinusInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LEAntiSigmaMinusInelastic is one of the Low Energy\n"
<< "Parameterized (LEP) models used to implement inelastic\n"
<< "antiSigma- scattering from nuclei. It is a re-engineered\n"
<< "version of the GHEISHA code of H. Fesefeldt. It divides the\n"
<< "initial collision products into backward- and forward-going\n"
<< "clusters which are then decayed into final state hadrons. The\n"
<< "model does not conserve energy on an event-by-event basis. It\n"
<< "may be applied to antiSigma- with initial energies between 0\n"
<< "and 25 GeV.\n";
}
G4HadFinalState*
G4LEAntiSigmaMinusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV) {
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
// create the target particle
G4DynamicParticle* originalTarget = targetNucleus.ReturnTargetParticle();
if( verboseLevel > 1 )
{
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEAntiSigmaMinusInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
if (verboseLevel > 1) {
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEAntiSigmaMinusInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
<< G4endl;
}
//
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
//
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
}
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
@@ -126,10 +134,9 @@
delete originalTarget;
return &theParticleChange;
}
}
void
G4LEAntiSigmaMinusInelastic::Cascade(
void G4LEAntiSigmaMinusInelastic::Cascade(
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int& vecLen,
const G4HadProjectile *originalIncident,
@@ -138,7 +145,7 @@
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic )
{
{
// derived from original FORTRAN code CASASM by H. Fesefeldt (13-Sep-1987)
//
// AntiSigmaMinus undergoes interaction with nucleon within a nucleus. Check if it is
@@ -561,7 +568,7 @@
}
SetUpPions( np, nm, nz, vec, vecLen );
return;
}
}
/* end of file */
source/processes/hadronic/models/low_energy/src/G4LEAntiSigmaPlusInelastic.cc
+52 -44
View File
@@ -23,52 +23,61 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEAntiSigmaPlusInelastic.cc,v 1.11 2006-06-29 20:44:51 gunter Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEAntiSigmaPlusInelastic.cc,v 1.11 2006/06/29 20:44:51 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: AntiSigmaPlus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
// Last modified: 27-Mar-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
// Hadronic Process: AntiSigmaPlus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
#include "G4LEAntiSigmaPlusInelastic.hh"
#include "Randomize.hh"
G4HadFinalState *
G4LEAntiSigmaPlusInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV)
{
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
//
// create the target particle
//
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
void G4LEAntiSigmaPlusInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LEAntiSigmaPlusInelastic is one of the Low Energy\n"
<< "Parameterized (LEP) models used to implement inelastic\n"
<< "antiSigma+ scattering from nuclei. It is a re-engineered\n"
<< "version of the GHEISHA code of H. Fesefeldt. It divides the\n"
<< "initial collision products into backward- and forward-going\n"
<< "clusters which are then decayed into final state hadrons. The\n"
<< "model does not conserve energy on an event-by-event basis. It\n"
<< "may be applied to antiSigma+ with initial energies between 0\n"
<< "and 25 GeV.\n";
}
G4HadFinalState*
G4LEAntiSigmaPlusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV) {
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
// create the target particle
G4DynamicParticle* originalTarget = targetNucleus.ReturnTargetParticle();
if( verboseLevel > 1 )
{
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEAntiSigmaPlusInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
if (verboseLevel > 1) {
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEAntiSigmaPlusInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
<< G4endl;
}
//
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
//
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
}
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
@@ -125,10 +134,9 @@
delete originalTarget;
return &theParticleChange;
}
}
void
G4LEAntiSigmaPlusInelastic::Cascade(
void G4LEAntiSigmaPlusInelastic::Cascade(
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int& vecLen,
const G4HadProjectile *originalIncident,
@@ -137,7 +145,7 @@
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic )
{
{
// derived from original FORTRAN code CASASP by H. Fesefeldt (13-Sep-1987)
//
// AntiSigmaPlus undergoes interaction with nucleon within a nucleus. Check if it is
@@ -562,7 +570,7 @@
}
SetUpPions( np, nm, nz, vec, vecLen );
return;
}
}
/* end of file */
source/processes/hadronic/models/low_energy/src/G4LEAntiXiMinusInelastic.cc
+55 -49
View File
@@ -23,56 +23,63 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEAntiXiMinusInelastic.cc,v 1.11 2006-06-29 20:44:53 gunter Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEAntiXiMinusInelastic.cc,v 1.11 2006/06/29 20:44:53 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
// Hadronic Process: AntiXiMinus Inelastic Process
// J.L. Chuma, TRIUMF, 20-Feb-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
//
// Hadronic Process: AntiXiMinus Inelastic Process
// J.L. Chuma, TRIUMF, 20-Feb-1997
// Last modified: 27-Mar-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
//
// NOTE: The FORTRAN version of the cascade, CASAXM, simply called the
// routine for the XiMinus particle. Hence, the ApplyYourself function
// below is just a copy of the ApplyYourself from the XiMinus particle.
// NOTE: The FORTRAN version of the cascade, CASAXM, simply called the
// routine for the XiMinus particle. Hence, the ApplyYourself function
// below is just a copy of the ApplyYourself from the XiMinus particle.
#include "G4LEAntiXiMinusInelastic.hh"
#include "Randomize.hh"
G4HadFinalState *
G4LEAntiXiMinusInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV)
{
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
//
// create the target particle
//
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
if( verboseLevel > 1 )
{
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEAntiXiMinusInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
void G4LEAntiXiMinusInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LEAntiXiMinusInelastic is one of the Low Energy Parameterized\n"
<< "(LEP) models used to implement inelastic antiXi- scattering\n"
<< "from nuclei. It is a re-engineered version of the GHEISHA\n"
<< "code of H. Fesefeldt. It divides the initial collision\n"
<< "products into backward- and forward-going clusters which are\n"
<< "then decayed into final state hadrons. The model does not\n"
<< "conserve energy on an event-by-event basis. It may be applied\n"
<< "to antiXi- with initial energies between 0 and 25 GeV.\n";
}
G4HadFinalState*
G4LEAntiXiMinusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV) {
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
// create the target particle
G4DynamicParticle* originalTarget = targetNucleus.ReturnTargetParticle();
if (verboseLevel > 1) {
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEAntiXiMinusInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
<< G4endl;
}
//
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
//
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
}
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
@@ -129,10 +136,9 @@
delete originalTarget;
return &theParticleChange;
}
}
void
G4LEAntiXiMinusInelastic::Cascade(
void G4LEAntiXiMinusInelastic::Cascade(
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int& vecLen,
const G4HadProjectile *originalIncident,
@@ -141,7 +147,7 @@
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic )
{
{
// derived from original FORTRAN code CASAXM by H. Fesefeldt (17-Jan-1989)
// which is just a copy of casxm (cascade for Xi-).
//
@@ -394,7 +400,7 @@
}
SetUpPions( np, nm, nz, vec, vecLen );
return;
}
}
/* end of file */
source/processes/hadronic/models/low_energy/src/G4LEAntiXiZeroInelastic.cc
+49 -42
View File
@@ -23,49 +23,57 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEAntiXiZeroInelastic.cc,v 1.11 2006-06-29 20:44:55 gunter Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEAntiXiZeroInelastic.cc,v 1.11 2006/06/29 20:44:55 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
// Hadronic Process: AntiXiZero Inelastic Process
// J.L. Chuma, TRIUMF, 20-Feb-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
//
// Hadronic Process: AntiXiZero Inelastic Process
// J.L. Chuma, TRIUMF, 20-Feb-1997
// Last modified: 27-Mar-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
//
// NOTE: The FORTRAN version of the cascade, CASAXO, simply called the
// routine for the XiZero particle. Hence, the ApplyYourself function
// below is just a copy of the ApplyYourself from the XiZero particle.
// NOTE: The FORTRAN version of the cascade, CASAXO, simply called the
// routine for the XiZero particle. Hence, the ApplyYourself function
// below is just a copy of the ApplyYourself from the XiZero particle.
#include "G4LEAntiXiZeroInelastic.hh"
#include "Randomize.hh"
G4HadFinalState *
G4LEAntiXiZeroInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
const G4HadProjectile *originalIncident = &aTrack;
//
// create the target particle
//
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
void G4LEAntiXiZeroInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LEAntiXiZeroInelastic is one of the Low Energy Parameterized\n"
<< "(LEP) models used to implement inelastic antiXi0 scattering\n"
<< "from nuclei. It is a re-engineered version of the GHEISHA\n"
<< "code of H. Fesefeldt. It divides the initial collision\n"
<< "products into backward- and forward-going clusters which are\n"
<< "then decayed into final state hadrons. The model does not\n"
<< "conserve energy on an event-by-event basis. It may be\n"
<< "applied to antiXi0 with initial energies between 0 and 25\n"
<< "GeV.\n";
}
G4HadFinalState*
G4LEAntiXiZeroInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
const G4HadProjectile *originalIncident = &aTrack;
// create the target particle
G4DynamicParticle* originalTarget = targetNucleus.ReturnTargetParticle();
if( verboseLevel > 1 )
{
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEAntiXiZeroInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
if (verboseLevel > 1) {
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEAntiXiZeroInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
<< G4endl;
}
//
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
//
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
}
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
@@ -122,10 +130,9 @@
delete originalTarget;
return &theParticleChange;
}
}
void
G4LEAntiXiZeroInelastic::Cascade(
void G4LEAntiXiZeroInelastic::Cascade(
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int& vecLen,
const G4HadProjectile *originalIncident,
@@ -133,8 +140,8 @@
G4ReactionProduct &targetParticle,
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic )
{
G4bool &quasiElastic)
{
// derived from original FORTRAN code CASAX0 by H. Fesefeldt (20-Jan-1989)
// which is just a copy of CASX0 (cascade for Xi0)
//
@@ -387,7 +394,7 @@
}
SetUpPions( np, nm, nz, vec, vecLen );
return;
}
}
/* end of file */
source/processes/hadronic/models/low_energy/src/G4LEDeuteronInelastic.cc
+84 -67
View File
@@ -23,36 +23,86 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//
// Hadronic Process: Deuteron Inelastic Process
// J.L. Chuma, TRIUMF, 25-Feb-1997
// Last modified: 27-Mar-1997
// J.L. Chuma, 08-May-2001: Update original incident passed back in vec[0]
// from NuclearReaction
//
// Hadronic Process: Deuteron Inelastic Process
// J.L. Chuma, TRIUMF, 25-Feb-1997
// J.L. Chuma, 08-May-2001: Update original incident passed back in vec[0]
// from NuclearReaction
#include "G4LEDeuteronInelastic.hh"
#include "Randomize.hh"
#include "G4Electron.hh"
G4HadFinalState *
G4LEDeuteronInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
theParticleChange.Clear();
const G4HadProjectile *originalIncident = &aTrack;
void G4LEDeuteronInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LEDeuteronInelastic is one of the Low Energy Parameterized\n"
<< "(LEP) models used to implement inelastic deuteron scattering\n"
<< "from nuclei. It is a re-engineered version of the GHEISHA\n"
<< "code of H. Fesefeldt. It divides the initial collision\n"
<< "products into backward- and forward-going clusters which are\n"
<< "then decayed into final state hadrons. The model does not\n"
<< "conserve energy on an event-by-event basis. It may be\n"
<< "applied to deuterons with initial energies between 0 and 10\n"
<< "TeV.\n";
}
G4HadFinalState*
G4LEDeuteronInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
theParticleChange.Clear();
const G4HadProjectile *originalIncident = &aTrack;
if( verboseLevel > 1 )
{
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEDeuteronInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
}
if (verboseLevel > 1) {
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEDeuteronInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
}
// Work-around for lack of model above 100 MeV
if( originalIncident->GetKineticEnergy()/MeV > 100. ||
originalIncident->GetKineticEnergy() <= 0.1*MeV )
// Work-around for lack of model above 100 MeV
if (originalIncident->GetKineticEnergy()/MeV > 100. ||
originalIncident->GetKineticEnergy() <= 0.1*MeV) {
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
G4double A = targetNucleus.GetA_asInt();
G4double Z = targetNucleus.GetZ_asInt();
G4double theAtomicMass = targetNucleus.AtomicMass(A, Z);
G4double massVec[9];
massVec[0] = targetNucleus.AtomicMass( A+2.0, Z+1.0 );
massVec[1] = targetNucleus.AtomicMass( A+1.0, Z+1.0 );
massVec[2] = targetNucleus.AtomicMass( A+1.0, Z );
massVec[3] = theAtomicMass;
massVec[4] = 0.;
if (A > 1.0 && A-1.0 > Z)
massVec[4] = targetNucleus.AtomicMass(A-1.0, Z);
massVec[5] = 0.;
if (A > 2.0 && Z > 1.0 && A-2.0 > Z-1.0)
massVec[5] = targetNucleus.AtomicMass(A-2.0, Z-1.0);
massVec[6] = 0.;
if (A > Z+1.0)
massVec[6] = targetNucleus.AtomicMass(A, Z+1.0);
massVec[7] = massVec[3];
massVec[8] = 0.;
if (Z > 1.0) massVec[8] = targetNucleus.AtomicMass(A,Z-1.0);
G4FastVector<G4ReactionProduct,4> vec; // vec will contain the secondary particles
G4int vecLen = 0;
vec.Initialize( 0 );
theReactionDynamics.NuclearReaction(vec, vecLen, originalIncident,
targetNucleus, theAtomicMass, massVec);
G4double p = vec[0]->GetMomentum().mag();
theParticleChange.SetMomentumChange( vec[0]->GetMomentum() * (1.0/p) );
theParticleChange.SetEnergyChange( vec[0]->GetKineticEnergy() );
delete vec[0];
if (vecLen <= 1)
{
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
@@ -60,50 +110,17 @@
return &theParticleChange;
}
G4double A = targetNucleus.GetN();
G4double Z = targetNucleus.GetZ();
G4double theAtomicMass = targetNucleus.AtomicMass( A, Z );
G4double massVec[9];
massVec[0] = targetNucleus.AtomicMass( A+2.0, Z+1.0 );
massVec[1] = targetNucleus.AtomicMass( A+1.0, Z+1.0 );
massVec[2] = targetNucleus.AtomicMass( A+1.0, Z );
massVec[3] = theAtomicMass;
massVec[4] = 0.;
if (A > 1.0 && A-1.0 > Z)
massVec[4] = targetNucleus.AtomicMass( A-1.0, Z );
massVec[5] = 0.;
if (A > 2.0 && Z > 1.0 && A-2.0 > Z-1.0)
massVec[5] = targetNucleus.AtomicMass( A-2.0, Z-1.0 );
massVec[6] = 0.;
if (A > Z+1.0)
massVec[6] = targetNucleus.AtomicMass( A, Z+1.0 );
massVec[7] = massVec[3];
massVec[8] = 0.;
if (Z > 1.0) massVec[8] = targetNucleus.AtomicMass( A,Z-1.0 );
G4FastVector<G4ReactionProduct,4> vec; // vec will contain the secondary particles
G4int vecLen = 0;
vec.Initialize( 0 );
theReactionDynamics.NuclearReaction( vec, vecLen, originalIncident,
targetNucleus, theAtomicMass, massVec );
//
G4double p = vec[0]->GetMomentum().mag();
theParticleChange.SetMomentumChange( vec[0]->GetMomentum() * (1.0/p) );
theParticleChange.SetEnergyChange( vec[0]->GetKineticEnergy() );
delete vec[0];
//
G4DynamicParticle *pd;
for( G4int i=1; i<vecLen; ++i )
{
pd = new G4DynamicParticle();
pd->SetDefinition( vec[i]->GetDefinition() );
pd->SetMomentum( vec[i]->GetMomentum() );
theParticleChange.AddSecondary( pd );
delete vec[i];
}
return &theParticleChange;
G4DynamicParticle* pd;
for (G4int i=1; i<vecLen; ++i) {
pd = new G4DynamicParticle();
pd->SetDefinition( vec[i]->GetDefinition() );
pd->SetMomentum( vec[i]->GetMomentum() );
theParticleChange.AddSecondary( pd );
delete vec[i];
}
return &theParticleChange;
}
/* end of file */
source/processes/hadronic/models/low_energy/src/G4LEKaonMinusInelastic.cc
+80 -64
View File
@@ -23,69 +23,90 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEKaonMinusInelastic.cc,v 1.15 2006-06-29 20:44:59 gunter Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEKaonMinusInelastic.cc,v 1.15 2006/06/29 20:44:59 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy KaonMinus Inelastic Process
// J.L. Chuma, TRIUMF, 12-Feb-1997
// Last modified: 27-Mar-1997
// J.P.Wellisch 23-Apr-97: bug-hunting (missing initialization of np,nm,nz fixed)
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
// Hadronic Process: Low Energy KaonMinus Inelastic Process
// J.L. Chuma, TRIUMF, 12-Feb-1997
// J.P.Wellisch 23-Apr-97: bug-hunting (missing initialization of np,nm,nz
// fixed)
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
#include "G4LEKaonMinusInelastic.hh"
#include "Randomize.hh"
#include "Randomize.hh"
#include <iostream>
G4HadFinalState *
G4LEKaonMinusInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV)
{
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
// create the target particle
G4LEKaonMinusInelastic::G4LEKaonMinusInelastic(const G4String& name)
:G4InelasticInteraction(name)
{
SetMinEnergy(0.0);
SetMaxEnergy(25.*GeV);
}
void G4LEKaonMinusInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LEKaonMinusInelastic is one of the Low Energy Parameterized\n"
<< "(LEP) models used to implement inelastic K- scattering\n"
<< "from nuclei. It is a re-engineered version of the GHEISHA\n"
<< "code of H. Fesefeldt. It divides the initial collision\n"
<< "products into backward- and forward-going clusters which are\n"
<< "then decayed into final state hadrons. The model does not\n"
<< "conserve energy on an event-by-event basis. It may be\n"
<< "applied to kaons with initial energies between 0 and 25\n"
<< "GeV.\n";
}
G4HadFinalState*
G4LEKaonMinusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV) {
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
// create the target particle
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
G4ReactionProduct targetParticle( originalTarget->GetDefinition() );
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
G4ReactionProduct targetParticle( originalTarget->GetDefinition() );
if( verboseLevel > 1 )
{
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEKaonMinusInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy() << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
if (verboseLevel > 1) {
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEKaonMinusInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy() << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
<< G4endl;
}
G4ReactionProduct currentParticle( const_cast<G4ParticleDefinition *>(originalIncident->GetDefinition()) );
currentParticle.SetMomentum( originalIncident->Get4Momentum().vect() );
currentParticle.SetKineticEnergy( originalIncident->GetKineticEnergy() );
}
G4ReactionProduct currentParticle(const_cast<G4ParticleDefinition*>(originalIncident->GetDefinition()) );
currentParticle.SetMomentum( originalIncident->Get4Momentum().vect() );
currentParticle.SetKineticEnergy( originalIncident->GetKineticEnergy() );
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been done
G4double ek = originalIncident->GetKineticEnergy();
G4double amas = originalIncident->GetDefinition()->GetPDGMass();
G4double ek = originalIncident->GetKineticEnergy();
G4double amas = originalIncident->GetDefinition()->GetPDGMass();
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
currentParticle.SetKineticEnergy( ek );
G4double et = ek + amas;
G4double p = std::sqrt( std::abs((et-amas)*(et+amas)) );
G4double pp = currentParticle.GetMomentum().mag();
if( pp > 0.0 )
{
G4ThreeVector momentum = currentParticle.GetMomentum();
currentParticle.SetMomentum( momentum * (p/pp) );
}
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
currentParticle.SetKineticEnergy( ek );
G4double et = ek + amas;
G4double p = std::sqrt( std::abs((et-amas)*(et+amas)) );
G4double pp = currentParticle.GetMomentum().mag();
if (pp > 0.0) {
G4ThreeVector momentum = currentParticle.GetMomentum();
currentParticle.SetMomentum( momentum * (p/pp) );
}
// calculate black track energies
// calculate black track energies
tkin = targetNucleus.EvaporationEffects( ek );
ek -= tkin;
@@ -125,12 +146,11 @@
currentParticle, targetParticle,
incidentHasChanged );
delete originalTarget;
return &theParticleChange;
}
delete originalTarget;
return &theParticleChange;
}
void
G4LEKaonMinusInelastic::Cascade(
void G4LEKaonMinusInelastic::Cascade(
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int& vecLen,
const G4HadProjectile *originalIncident,
@@ -139,7 +159,7 @@
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic )
{
{
// derived from original FORTRAN code CASKM by H. Fesefeldt (13-Sep-1987)
//
// K- undergoes interaction with nucleon within a nucleus. Check if it is
@@ -527,11 +547,7 @@
targetHasChanged = true;
}
}
SetUpPions( np, nm, nz, vec, vecLen );
return;
}
/* end of file */
SetUpPions( np, nm, nz, vec, vecLen );
return;
}
source/processes/hadronic/models/low_energy/src/G4LEKaonPlusInelastic.cc
+46 -26
View File
@@ -23,32 +23,53 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEKaonPlusInelastic.cc,v 1.13 2006-06-29 20:45:01 gunter Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEKaonPlusInelastic.cc,v 1.13 2006/06/29 20:45:01 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Low Energy KaonPlus Inelastic Process
// J.L. Chuma, TRIUMF, 05-Feb-1997
// Last modified: 27-Mar-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
// Hadronic Process: Low Energy KaonPlus Inelastic Process
// J.L. Chuma, TRIUMF, 05-Feb-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
#include "G4LEKaonPlusInelastic.hh"
#include "Randomize.hh"
G4HadFinalState *
G4LEKaonPlusInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV)
{
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
#include <iostream>
G4LEKaonPlusInelastic::G4LEKaonPlusInelastic(const G4String& name)
:G4InelasticInteraction(name)
{
SetMinEnergy(0.0);
SetMaxEnergy(25.*GeV);
}
void G4LEKaonPlusInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LEKaonPlusInelastic is one of the Low Energy Parameterized\n"
<< "(LEP) models used to implement inelastic K+ scattering\n"
<< "from nuclei. It is a re-engineered version of the GHEISHA\n"
<< "code of H. Fesefeldt. It divides the initial collision\n"
<< "products into backward- and forward-going clusters which are\n"
<< "then decayed into final state hadrons. The model does not\n"
<< "conserve energy on an event-by-event basis. It may be\n"
<< "applied to kaons with initial energies between 0 and 25\n"
<< "GeV.\n";
}
G4HadFinalState*
G4LEKaonPlusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV) {
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
// create the target particle
// create the target particle
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
G4ReactionProduct targetParticle( originalTarget->GetDefinition() );
@@ -124,12 +145,11 @@
currentParticle, targetParticle,
incidentHasChanged );
delete originalTarget;
return &theParticleChange;
}
delete originalTarget;
return &theParticleChange;
}
void
void
G4LEKaonPlusInelastic::Cascade(
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int &vecLen,
source/processes/hadronic/models/low_energy/src/G4LEKaonZeroInelastic.cc
+42 -33
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4LEKaonZeroInelastic.cc,v 1.9 2006/06/29 20:45:03 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4LEKaonZeroInelastic.cc,v 1.9 2006-06-29 20:45:03 gunter Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// Hadronic Process: Low Energy KaonZeroShort Inelastic Process
// J.L. Chuma, TRIUMF, 11-Feb-1997
@@ -34,34 +34,44 @@
#include "G4LEKaonZeroInelastic.hh"
#include "Randomize.hh"
void G4LEKaonZeroInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LEKaonZeroInelastic is one of the Low Energy Parameterized\n"
<< "(LEP) models used to implement K0 scattering from nuclei. It\n"
<< "is a re-engineered version of the GHEISHA code of\n"
<< "H. Fesefeldt. It divides the initial collision products\n"
<< "into backward- and forward-going clusters which are then\n"
<< "decayed into final state hadrons. The model does not conserve\n"
<< "energy on an event-by-event basis. It may be applied to\n"
<< "K0s with initial energies between 0 and 25 GeV.\n";
}
G4HadFinalState *
G4LEKaonZeroInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
const G4HadProjectile *originalIncident = &aTrack;
//
// create the target particle
//
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
if( verboseLevel > 1 )
{
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEKaonZeroInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
G4HadFinalState*
G4LEKaonZeroInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
const G4HadProjectile *originalIncident = &aTrack;
// create the target particle
G4DynamicParticle* originalTarget = targetNucleus.ReturnTargetParticle();
if (verboseLevel > 1) {
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEKaonZeroInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
<< G4endl;
}
//
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
//
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
}
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
@@ -117,10 +127,9 @@
delete originalTarget;
return &theParticleChange;
}
}
void
G4LEKaonZeroInelastic::Cascade(
void G4LEKaonZeroInelastic::Cascade(
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int& vecLen,
const G4HadProjectile *originalIncident,
@@ -129,7 +138,7 @@
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic )
{
{
// derived from original FORTRAN code CASK0 by H. Fesefeldt (13-Sep-1987)
//
// K0Short undergoes interaction with nucleon within a nucleus. Check if it is
@@ -402,7 +411,7 @@
}
SetUpPions( np, nm, nz, vec, vecLen );
return;
}
}
/* end of file */
source/processes/hadronic/models/low_energy/src/G4LELambdaInelastic.cc
+101 -84
View File
@@ -23,60 +23,80 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LELambdaInelastic.cc,v 1.11 2006-06-29 20:45:05 gunter Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LELambdaInelastic.cc,v 1.11 2006/06/29 20:45:05 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: Lambda Inelastic Process
// J.L. Chuma, TRIUMF, 18-Feb-1997
// Last modified: 27-Mar-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
// Hadronic Process: Lambda Inelastic Process
// J.L. Chuma, TRIUMF, 18-Feb-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
#include "G4LELambdaInelastic.hh"
#include "Randomize.hh"
#include <iostream>
G4HadFinalState *
G4LELambdaInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
const G4HadProjectile *originalIncident = &aTrack;
//
// create the target particle
//
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
G4LELambdaInelastic::G4LELambdaInelastic(const G4String& name)
:G4InelasticInteraction(name)
{
SetMinEnergy(0.0);
SetMaxEnergy(25.*GeV);
}
void G4LELambdaInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LELambdaInelastic is one of the Low Energy Parameterized\n"
<< "(LEP) models used to implement inelastic Lambda scattering\n"
<< "from nuclei. It is a re-engineered version of the GHEISHA\n"
<< "code of H. Fesefeldt. It divides the initial collision\n"
<< "products into backward- and forward-going clusters which are\n"
<< "then decayed into final state hadrons. The model does not\n"
<< "conserve energy on an event-by-event basis. It may be\n"
<< "applied to lambdas with initial energies between 0 and 25\n"
<< "GeV.\n";
}
G4HadFinalState*
G4LELambdaInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
const G4HadProjectile *originalIncident = &aTrack;
// create the target particle
G4DynamicParticle* originalTarget = targetNucleus.ReturnTargetParticle();
if( verboseLevel > 1 )
{
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LELambdaInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
if (verboseLevel > 1) {
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LELambdaInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
<< G4endl;
}
//
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
//
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
}
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
modifiedOriginal.SetKineticEnergy( ek*MeV );
G4double et = ek + amas;
G4double p = std::sqrt( std::abs((et-amas)*(et+amas)) );
G4double pp = modifiedOriginal.GetMomentum().mag()/MeV;
if( pp > 0.0 )
{
G4ThreeVector momentum = modifiedOriginal.GetMomentum();
modifiedOriginal.SetMomentum( momentum * (p/pp) );
}
//
// calculate black track energies
//
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
modifiedOriginal.SetKineticEnergy( ek*MeV );
G4double et = ek + amas;
G4double p = std::sqrt( std::abs((et-amas)*(et+amas)) );
G4double pp = modifiedOriginal.GetMomentum().mag()/MeV;
if (pp > 0.0) {
G4ThreeVector momentum = modifiedOriginal.GetMomentum();
modifiedOriginal.SetMomentum( momentum * (p/pp) );
}
// calculate black track energies
tkin = targetNucleus.EvaporationEffects( ek );
ek -= tkin;
modifiedOriginal.SetKineticEnergy( ek*MeV );
@@ -116,43 +136,42 @@
currentParticle, targetParticle,
incidentHasChanged );
delete originalTarget;
return &theParticleChange;
}
delete originalTarget;
return &theParticleChange;
}
void
G4LELambdaInelastic::Cascade(
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
void G4LELambdaInelastic::Cascade(
G4FastVector<G4ReactionProduct,GHADLISTSIZE>& vec,
G4int& vecLen,
const G4HadProjectile *originalIncident,
G4ReactionProduct &currentParticle,
G4ReactionProduct &targetParticle,
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic )
{
// derived from original FORTRAN code CASL0 by H. Fesefeldt (13-Sep-1987)
//
// Lambda 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.
//
const G4double mOriginal = originalIncident->GetDefinition()->GetPDGMass()/MeV;
const G4double etOriginal = originalIncident->GetTotalEnergy()/MeV;
const G4double targetMass = targetParticle.GetMass()/MeV;
G4double centerofmassEnergy = std::sqrt( mOriginal*mOriginal +
const G4HadProjectile* originalIncident,
G4ReactionProduct& currentParticle,
G4ReactionProduct& targetParticle,
G4bool& incidentHasChanged,
G4bool& targetHasChanged,
G4bool& quasiElastic )
{
// derived from original FORTRAN code CASL0 by H. Fesefeldt (13-Sep-1987)
//
// Lambda 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.
const G4double mOriginal = originalIncident->GetDefinition()->GetPDGMass()/MeV;
const G4double etOriginal = originalIncident->GetTotalEnergy()/MeV;
const G4double targetMass = targetParticle.GetMass()/MeV;
G4double centerofmassEnergy = std::sqrt(mOriginal*mOriginal +
targetMass*targetMass +
2.0*targetMass*etOriginal );
G4double availableEnergy = centerofmassEnergy-(targetMass+mOriginal);
if( availableEnergy <= G4PionPlus::PionPlus()->GetPDGMass()/MeV )
{
quasiElastic = true;
return;
}
G4double availableEnergy = centerofmassEnergy-(targetMass+mOriginal);
if (availableEnergy <= G4PionPlus::PionPlus()->GetPDGMass()/MeV) {
quasiElastic = true;
return;
}
static G4bool first = true;
const G4int numMul = 1200;
const G4int numSec = 60;
@@ -352,9 +371,7 @@
break;
}
}
SetUpPions( np, nm, nz, vec, vecLen );
return;
}
/* end of file */
SetUpPions( np, nm, nz, vec, vecLen );
return;
}
source/processes/hadronic/models/low_energy/src/G4LENeutronInelastic.cc
+66 -56
View File
@@ -23,36 +23,48 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//
// Hadronic Process: Low Energy Neutron Inelastic Process
// J.L. Chuma, TRIUMF, 04-Feb-1997
#include "G4LENeutronInelastic.hh"
#include "Randomize.hh"
#include "G4Electron.hh"
// #include "DumpFrame.hh"
#include <iostream>
G4HadFinalState *
G4LENeutronInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
theParticleChange.Clear();
const G4HadProjectile *originalIncident = &aTrack;
//
// create the target particle
//
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
void G4LENeutronInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LENeutronInelastic is one of the Low Energy Parameterized\n"
<< "(LEP) models used to implement inelastic neutron scattering\n"
<< "from nuclei. It is a re-engineered version of the GHEISHA\n"
<< "code of H. Fesefeldt. It divides the initial collision\n"
<< "products into backward- and forward-going clusters which are\n"
<< "then decayed into final state hadrons. The model does not\n"
<< "conserve energy on an event-by-event basis. It may be\n"
<< "applied to neutrons with initial energies between 0 and 25\n"
<< "GeV.\n";
}
G4HadFinalState*
G4LENeutronInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
theParticleChange.Clear();
const G4HadProjectile *originalIncident = &aTrack;
// Create the target particle
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
if( verboseLevel > 1 )
{
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LENeutronInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
if (verboseLevel > 1) {
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LENeutronInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
<< G4endl;
}
}
/* not true, for example for Fe56, etc..
if( originalIncident->GetKineticEnergy()/MeV < 0.000001 )
throw G4HadronicException(__FILE__, __LINE__, "G4LENeutronInelastic: should be capture process!");
@@ -60,22 +72,21 @@
throw G4HadronicException(__FILE__, __LINE__, "G4LENeutronInelastic: should be capture process!");
*/
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
G4ReactionProduct targetParticle;
targetParticle = *originalTarget;
if( originalIncident->GetKineticEnergy()/GeV < 0.01 + 2.*G4UniformRand()/9. )
{
SlowNeutron( originalIncident, modifiedOriginal, targetParticle, targetNucleus );
delete originalTarget;
return &theParticleChange;
}
//
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
//
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
G4ReactionProduct targetParticle;
targetParticle = *originalTarget;
if (originalIncident->GetKineticEnergy()/GeV < 0.01 + 2.*G4UniformRand()/9.) {
SlowNeutron( originalIncident, modifiedOriginal, targetParticle, targetNucleus );
delete originalTarget;
return &theParticleChange;
}
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been done
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
@@ -132,23 +143,22 @@
currentParticle, targetParticle,
incidentHasChanged );
delete originalTarget;
return &theParticleChange;
}
delete originalTarget;
return &theParticleChange;
}
void
G4LENeutronInelastic::SlowNeutron(
const G4HadProjectile *originalIncident,
G4ReactionProduct &modifiedOriginal,
G4ReactionProduct &targetParticle,
G4Nucleus &targetNucleus )
{
const G4double A = targetNucleus.GetN(); // atomic weight
const G4double Z = targetNucleus.GetZ(); // atomic number
void G4LENeutronInelastic::SlowNeutron(const G4HadProjectile* originalIncident,
G4ReactionProduct& modifiedOriginal,
G4ReactionProduct& targetParticle,
G4Nucleus& targetNucleus)
{
const G4double A = targetNucleus.GetA_asInt(); // atomic weight
const G4double Z = targetNucleus.GetZ_asInt(); // atomic number
G4double currentKinetic = modifiedOriginal.GetKineticEnergy()/MeV;
G4double currentMass = modifiedOriginal.GetMass()/MeV;
if( A < 1.5 ) // Hydrogen
G4double currentKinetic = modifiedOriginal.GetKineticEnergy()/MeV;
G4double currentMass = modifiedOriginal.GetMass()/MeV;
if( A < 1.5 ) // Hydrogen
{
//
// very simple simulation of scattering angle and energy
@@ -256,10 +266,10 @@
theParticleChange.AddSecondary( pd );
delete vec[i];
}
}
void
G4LENeutronInelastic::Cascade(
}
void G4LENeutronInelastic::Cascade(
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int& vecLen,
const G4HadProjectile *originalIncident,
source/processes/hadronic/models/low_energy/src/G4LEOmegaMinusInelastic.cc
+51 -47
View File
@@ -23,55 +23,61 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEOmegaMinusInelastic.cc,v 1.12 2006-06-29 20:45:09 gunter Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEOmegaMinusInelastic.cc,v 1.12 2006/06/29 20:45:09 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: OmegaMinus Inelastic Process
// J.L. Chuma, TRIUMF, 20-Feb-1997
// Last modified: 27-Mar-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
// Hadronic Process: OmegaMinus Inelastic Process
// J.L. Chuma, TRIUMF, 20-Feb-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
#include "G4LEOmegaMinusInelastic.hh"
#include "Randomize.hh"
G4HadFinalState *
G4LEOmegaMinusInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV)
{
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
void G4LEOmegaMinusInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LEOmegaMinusInelastic is one of the Low Energy Parameterized\n"
<< "(LEP) models used to implement inelastic Omega- scattering from\n"
<< "nuclei. It is a re-engineered version of the GHEISHA code of\n"
<< "H. Fesefeldt. It divides the initial collision products into\n"
<< "backward- and forward-going clusters which are then decayed\n"
<< "into final state hadrons. The model does not conserve energy\n"
<< "on an event-by-event basis. It may be applied to Omega- with\n"
<< "initial energies between 0 and 25 GeV.\n";
}
G4HadFinalState*
G4LEOmegaMinusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV) {
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
// create the target particle
// create the target particle
G4DynamicParticle* originalTarget = targetNucleus.ReturnTargetParticle();
G4ReactionProduct targetParticle( originalTarget->GetDefinition() );
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
// G4double targetMass = originalTarget->GetDefinition()->GetPDGMass();
G4ReactionProduct targetParticle( originalTarget->GetDefinition() );
if( verboseLevel > 1 )
{
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEOmegaMinusInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy() << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
if (verboseLevel > 1) {
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEOmegaMinusInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy() << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
<< G4endl;
}
G4ReactionProduct currentParticle( const_cast<G4ParticleDefinition *>(originalIncident->GetDefinition() ));
currentParticle.SetMomentum( originalIncident->Get4Momentum().vect() );
currentParticle.SetKineticEnergy( originalIncident->GetKineticEnergy() );
}
G4ReactionProduct currentParticle( const_cast<G4ParticleDefinition *>(originalIncident->GetDefinition() ));
currentParticle.SetMomentum( originalIncident->Get4Momentum().vect() );
currentParticle.SetKineticEnergy( originalIncident->GetKineticEnergy() );
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
G4double ek = originalIncident->GetKineticEnergy();
G4double amas = originalIncident->GetDefinition()->GetPDGMass();
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
G4double ek = originalIncident->GetKineticEnergy();
G4double amas = originalIncident->GetDefinition()->GetPDGMass();
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
@@ -127,10 +133,9 @@
delete originalTarget;
return &theParticleChange;
}
}
void
G4LEOmegaMinusInelastic::Cascade(
void G4LEOmegaMinusInelastic::Cascade(
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int& vecLen,
const G4HadProjectile *originalIncident,
@@ -138,8 +143,8 @@
G4ReactionProduct &targetParticle,
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic )
{
G4bool &quasiElastic)
{
// derived from original FORTRAN code CASOM by H. Fesefeldt (31-Jan-1989)
//
// OmegaMinus undergoes interaction with nucleon within a nucleus. Check if it is
@@ -152,7 +157,6 @@
//
const G4double mOriginal = originalIncident->GetDefinition()->GetPDGMass();
const G4double etOriginal = originalIncident->GetTotalEnergy();
// const G4double pOriginal = originalIncident->GetTotalMomentum();
const G4double targetMass = targetParticle.GetMass();
G4double centerofmassEnergy = std::sqrt( mOriginal*mOriginal +
targetMass*targetMass +
@@ -372,7 +376,7 @@
}
}
return;
}
}
/* end of file */
source/processes/hadronic/models/low_energy/src/G4LEPionMinusInelastic.cc
+64 -46
View File
@@ -24,55 +24,72 @@
// ********************************************************************
//
//
//
// Hadronic Process: PionMinus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Nov-1996
// Last modified: 27-Mar-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
// Hadronic Process: PionMinus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Nov-1996
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
#include "G4LEPionMinusInelastic.hh"
#include "Randomize.hh"
G4HadFinalState *
G4LEPionMinusInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV)
{
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
#include <iostream>
// create the target particle
G4LEPionMinusInelastic::G4LEPionMinusInelastic(const G4String& name)
: G4InelasticInteraction(name)
{
SetMinEnergy(0.0);
SetMaxEnergy(55.*GeV);
}
void G4LEPionMinusInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LEPionMinusInelastic is one of the Low Energy Parameterized\n"
<< "(LEP) models used to implement inelastic pi- scattering\n"
<< "from nuclei. It is a re-engineered version of the GHEISHA\n"
<< "code of H. Fesefeldt. It divides the initial collision\n"
<< "products into backward- and forward-going clusters which are\n"
<< "then decayed into final state hadrons. The model does not\n"
<< "conserve energy on an event-by-event basis. It may be\n"
<< "applied to pions with initial energies between 0 and 25\n"
<< "GeV.\n";
}
G4HadFinalState*
G4LEPionMinusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV) {
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
// create the target particle
G4DynamicParticle* originalTarget = targetNucleus.ReturnTargetParticle();
G4ReactionProduct targetParticle( originalTarget->GetDefinition() );
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
// G4double targetMass = originalTarget->GetDefinition()->GetPDGMass();
G4ReactionProduct targetParticle( originalTarget->GetDefinition() );
if( verboseLevel > 1 )
{
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4PionMinusInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy() << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
if (verboseLevel > 1) {
const G4Material* targetMaterial = aTrack.GetMaterial();
G4cout << "G4PionMinusInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy() << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
<< G4endl;
}
G4ReactionProduct currentParticle(
const_cast<G4ParticleDefinition *>(originalIncident->GetDefinition() ) );
currentParticle.SetMomentum( originalIncident->Get4Momentum().vect() );
currentParticle.SetKineticEnergy( originalIncident->GetKineticEnergy() );
}
G4ReactionProduct currentParticle(
const_cast<G4ParticleDefinition *>(originalIncident->GetDefinition() ) );
currentParticle.SetMomentum( originalIncident->Get4Momentum().vect() );
currentParticle.SetKineticEnergy( originalIncident->GetKineticEnergy() );
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
G4double ek = originalIncident->GetKineticEnergy();
G4double amas = originalIncident->GetDefinition()->GetPDGMass();
G4double ek = originalIncident->GetKineticEnergy();
G4double amas = originalIncident->GetDefinition()->GetPDGMass();
G4double tkin = targetNucleus.Cinema( ek );
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
currentParticle.SetKineticEnergy( ek );
G4double et = ek + amas;
@@ -124,12 +141,13 @@
currentParticle, targetParticle,
incidentHasChanged );
delete originalTarget;
return &theParticleChange;
}
delete originalTarget;
return &theParticleChange;
}
void
G4LEPionMinusInelastic::Cascade(
void
G4LEPionMinusInelastic::Cascade(
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int& vecLen,
const G4HadProjectile *originalIncident,
source/processes/hadronic/models/low_energy/src/G4LEPionPlusInelastic.cc
+81 -66
View File
@@ -23,57 +23,76 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEPionPlusInelastic.cc,v 1.15 2007-02-24 06:28:52 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEPionPlusInelastic.cc,v 1.15 2007/02/24 06:28:52 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: PionPlus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Nov-1996
// Last modified: 27-Mar-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
// fixing charge exchange - HPW Sep 2002.
// Hadronic Process: PionPlus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Nov-1996
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
// fixing charge exchange - HPW Sep 2002.
#include "G4LEPionPlusInelastic.hh"
#include "Randomize.hh"
#include <iostream>
G4HadFinalState *
G4LEPionPlusInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV)
{
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
// create the target particle
G4LEPionPlusInelastic::G4LEPionPlusInelastic(const G4String& name)
:G4InelasticInteraction(name)
{
SetMinEnergy(0.0);
SetMaxEnergy(55.*GeV);
}
void G4LEPionPlusInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LEPionPlusInelastic is one of the Low Energy Parameterized\n"
<< "(LEP) models used to implement inelastic pi+ scattering\n"
<< "from nuclei. It is a re-engineered version of the GHEISHA\n"
<< "code of H. Fesefeldt. It divides the initial collision\n"
<< "products into backward- and forward-going clusters which are\n"
<< "then decayed into final state hadrons. The model does not\n"
<< "conserve energy on an event-by-event basis. It may be\n"
<< "applied to pions with initial energies between 0 and 25\n"
<< "GeV.\n";
}
G4HadFinalState*
G4LEPionPlusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV) {
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
// create the target particle
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
// G4double targetMass = originalTarget->GetDefinition()->GetPDGMass();
G4ReactionProduct targetParticle( originalTarget->GetDefinition() );
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
G4ReactionProduct targetParticle( originalTarget->GetDefinition() );
if( verboseLevel > 1 )
{
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEPionPlusInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy() << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
if (verboseLevel > 1) {
const G4Material* targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEPionPlusInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy() << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
<< G4endl;
}
G4ReactionProduct currentParticle(
const_cast<G4ParticleDefinition *>(originalIncident->GetDefinition() ) );
currentParticle.SetMomentum( originalIncident->Get4Momentum().vect() );
currentParticle.SetKineticEnergy( originalIncident->GetKineticEnergy() );
}
G4ReactionProduct currentParticle(
const_cast<G4ParticleDefinition *>(originalIncident->GetDefinition() ) );
currentParticle.SetMomentum( originalIncident->Get4Momentum().vect() );
currentParticle.SetKineticEnergy( originalIncident->GetKineticEnergy() );
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
G4double ek = originalIncident->GetKineticEnergy();
G4double amas = originalIncident->GetDefinition()->GetPDGMass();
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
G4double ek = originalIncident->GetKineticEnergy();
G4double amas = originalIncident->GetDefinition()->GetPDGMass();
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
@@ -112,27 +131,26 @@
G4int vecLen = 0;
vec.Initialize( 0 );
const G4double cutOff = 0.1*MeV;
if( currentParticle.GetKineticEnergy() > cutOff )
Cascade( vec, vecLen,
originalIncident, currentParticle, targetParticle,
incidentHasChanged, targetHasChanged, quasiElastic );
const G4double cutOff = 0.1*MeV;
if (currentParticle.GetKineticEnergy() > cutOff)
Cascade(vec, vecLen,
originalIncident, currentParticle, targetParticle,
incidentHasChanged, targetHasChanged, quasiElastic);
CalculateMomenta( vec, vecLen,
originalIncident, originalTarget, modifiedOriginal,
targetNucleus, currentParticle, targetParticle,
incidentHasChanged, targetHasChanged, quasiElastic );
CalculateMomenta(vec, vecLen,
originalIncident, originalTarget, modifiedOriginal,
targetNucleus, currentParticle, targetParticle,
incidentHasChanged, targetHasChanged, quasiElastic);
SetUpChange( vec, vecLen,
currentParticle, targetParticle,
incidentHasChanged );
SetUpChange(vec, vecLen,
currentParticle, targetParticle,
incidentHasChanged);
delete originalTarget;
return &theParticleChange;
}
delete originalTarget;
return &theParticleChange;
}
void
G4LEPionPlusInelastic::Cascade(
void G4LEPionPlusInelastic::Cascade(
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int& vecLen,
const G4HadProjectile *originalIncident,
@@ -140,8 +158,8 @@
G4ReactionProduct &targetParticle,
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic )
{
G4bool &quasiElastic)
{
// derived from original FORTRAN code CASPIP by H. Fesefeldt (18-Sep-1987)
//
// pi+ undergoes interaction with nucleon within nucleus.
@@ -373,9 +391,6 @@
break;
}
}
SetUpPions( np, nm, nz, vec, vecLen );
return;
}
/* end of file */
SetUpPions( np, nm, nz, vec, vecLen );
return;
}
source/processes/hadronic/models/low_energy/src/G4LEProtonInelastic.cc
+124 -108
View File
@@ -23,124 +23,140 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//
// Hadronic Process: Low Energy Proton Inelastic Process
// J.L. Chuma, TRIUMF, 19-Nov-1996
#include "G4LEProtonInelastic.hh"
#include "Randomize.hh"
G4HadFinalState *
G4LEProtonInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
theParticleChange.Clear();
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV)
{
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
//
// create the target particle
//
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
if( verboseLevel > 1 )
{
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEProtonInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
#include <iostream>
G4LEProtonInelastic::G4LEProtonInelastic(const G4String& name)
:G4InelasticInteraction(name)
{
SetMinEnergy(0.0);
SetMaxEnergy(55.*GeV);
}
void G4LEProtonInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LEProtonInelastic is one of the Low Energy Parameterized\n"
<< "(LEP) models used to implement inelastic proton scattering\n"
<< "from nuclei. It is a re-engineered version of the GHEISHA\n"
<< "code of H. Fesefeldt. It divides the initial collision\n"
<< "products into backward- and forward-going clusters which are\n"
<< "then decayed into final state hadrons. The model does not\n"
<< "conserve energy on an event-by-event basis. It may be\n"
<< "applied to protons with initial energies between 0 and 25\n"
<< "GeV.\n";
}
G4HadFinalState*
G4LEProtonInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
theParticleChange.Clear();
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV) {
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
// Create the target particle
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
if (verboseLevel > 1) {
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEProtonInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
<< G4endl;
}
if( originalIncident->GetKineticEnergy()/GeV < 0.01+2.*G4UniformRand()/9. )
{
SlowProton( originalIncident, targetNucleus );
delete originalTarget;
return &theParticleChange;
}
//
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
//
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
modifiedOriginal.SetKineticEnergy( ek*MeV );
G4double et = ek + amas;
G4double p = std::sqrt( std::abs((et-amas)*(et+amas)) );
G4double pp = modifiedOriginal.GetMomentum().mag()/MeV;
if( pp > 0.0 )
{
G4ThreeVector momentum = modifiedOriginal.GetMomentum();
modifiedOriginal.SetMomentum( momentum * (p/pp) );
}
//
// calculate black track energies
//
tkin = targetNucleus.EvaporationEffects( ek );
ek -= tkin;
modifiedOriginal.SetKineticEnergy( ek*MeV );
et = ek + amas;
p = std::sqrt( std::abs((et-amas)*(et+amas)) );
pp = modifiedOriginal.GetMomentum().mag()/MeV;
if( pp > 0.0 )
{
G4ThreeVector momentum = modifiedOriginal.GetMomentum();
modifiedOriginal.SetMomentum( momentum * (p/pp) );
}
const G4double cutOff = 0.1;
if( modifiedOriginal.GetKineticEnergy()/MeV <= cutOff )
{
SlowProton( originalIncident, targetNucleus );
delete originalTarget;
return &theParticleChange;
}
G4ReactionProduct currentParticle = modifiedOriginal;
G4ReactionProduct targetParticle;
targetParticle = *originalTarget;
currentParticle.SetSide( 1 ); // incident always goes in forward hemisphere
targetParticle.SetSide( -1 ); // target always goes in backward hemisphere
G4bool incidentHasChanged = false;
G4bool targetHasChanged = false;
G4bool quasiElastic = false;
G4FastVector<G4ReactionProduct,GHADLISTSIZE> vec; // vec will contain the sec. particles
G4int vecLen = 0;
vec.Initialize( 0 );
Cascade( vec, vecLen,
originalIncident, currentParticle, targetParticle,
incidentHasChanged, targetHasChanged, quasiElastic );
CalculateMomenta( vec, vecLen,
originalIncident, originalTarget, modifiedOriginal,
targetNucleus, currentParticle, targetParticle,
incidentHasChanged, targetHasChanged, quasiElastic );
SetUpChange( vec, vecLen,
currentParticle, targetParticle,
incidentHasChanged );
}
if (originalIncident->GetKineticEnergy()/GeV < 0.01+2.*G4UniformRand()/9.) {
SlowProton( originalIncident, targetNucleus );
delete originalTarget;
return &theParticleChange;
}
void
G4LEProtonInelastic::SlowProton(
const G4HadProjectile *originalIncident,
G4Nucleus &targetNucleus )
{
const G4double A = targetNucleus.GetN(); // atomic weight
const G4double Z = targetNucleus.GetZ(); // atomic number
// G4double currentKinetic = originalIncident->GetKineticEnergy()/MeV;
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
modifiedOriginal.SetKineticEnergy( ek*MeV );
G4double et = ek + amas;
G4double p = std::sqrt( std::abs((et-amas)*(et+amas)) );
G4double pp = modifiedOriginal.GetMomentum().mag()/MeV;
if (pp > 0.0) {
G4ThreeVector momentum = modifiedOriginal.GetMomentum();
modifiedOriginal.SetMomentum( momentum * (p/pp) );
}
// calculate black track energies
tkin = targetNucleus.EvaporationEffects( ek );
ek -= tkin;
modifiedOriginal.SetKineticEnergy( ek*MeV );
et = ek + amas;
p = std::sqrt( std::abs((et-amas)*(et+amas)) );
pp = modifiedOriginal.GetMomentum().mag()/MeV;
if (pp > 0.0) {
G4ThreeVector momentum = modifiedOriginal.GetMomentum();
modifiedOriginal.SetMomentum( momentum * (p/pp) );
}
const G4double cutOff = 0.1;
if (modifiedOriginal.GetKineticEnergy()/MeV <= cutOff) {
SlowProton( originalIncident, targetNucleus );
delete originalTarget;
return &theParticleChange;
}
G4ReactionProduct currentParticle = modifiedOriginal;
G4ReactionProduct targetParticle;
targetParticle = *originalTarget;
currentParticle.SetSide( 1 ); // incident always goes in forward hemisphere
targetParticle.SetSide( -1 ); // target always goes in backward hemisphere
G4bool incidentHasChanged = false;
G4bool targetHasChanged = false;
G4bool quasiElastic = false;
G4FastVector<G4ReactionProduct,GHADLISTSIZE> vec; // vec will contain the sec. particles
G4int vecLen = 0;
vec.Initialize( 0 );
Cascade(vec, vecLen,
originalIncident, currentParticle, targetParticle,
incidentHasChanged, targetHasChanged, quasiElastic);
CalculateMomenta(vec, vecLen,
originalIncident, originalTarget, modifiedOriginal,
targetNucleus, currentParticle, targetParticle,
incidentHasChanged, targetHasChanged, quasiElastic);
SetUpChange(vec, vecLen,
currentParticle, targetParticle,
incidentHasChanged);
delete originalTarget;
return &theParticleChange;
}
void
G4LEProtonInelastic::SlowProton(const G4HadProjectile* originalIncident,
G4Nucleus& targetNucleus)
{
const G4double A = targetNucleus.GetA_asInt(); // atomic weight
const G4double Z = targetNucleus.GetZ_asInt(); // atomic number
//
// calculate Q-value of reactions
//
source/processes/hadronic/models/low_energy/src/G4LESigmaMinusInelastic.cc
+49 -43
View File
@@ -23,50 +23,57 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LESigmaMinusInelastic.cc,v 1.11 2006-06-29 20:45:17 gunter Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LESigmaMinusInelastic.cc,v 1.11 2006/06/29 20:45:17 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: SigmaMinus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
// Last modified: 27-Mar-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
// Hadronic Process: SigmaMinus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
#include "G4LESigmaMinusInelastic.hh"
#include "Randomize.hh"
G4HadFinalState *
G4LESigmaMinusInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV)
{
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
//
// create the target particle
//
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
void G4LESigmaMinusInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LESigmaMinusInelastic is one of the Low Energy Parameterized\n"
<< "(LEP) models used to implement inelastic Sigma- scattering\n"
<< "from nuclei. It is a re-engineered version of the GHEISHA\n"
<< "code of H. Fesefeldt. It divides the initial collision\n"
<< "products into backward- and forward-going clusters which are\n"
<< "then decayed into final state hadrons. The model does not\n"
<< "conserve energy on an event-by-event basis. It may be\n"
<< "applied to Sigma- with initial energies between 0 and 25\n"
<< "GeV.\n";
}
G4HadFinalState*
G4LESigmaMinusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV) {
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
// create the target particle
G4DynamicParticle* originalTarget = targetNucleus.ReturnTargetParticle();
if( verboseLevel > 1 )
{
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LESigmaMinusInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
if (verboseLevel > 1) {
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LESigmaMinusInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
<< G4endl;
}
//
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
//
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
}
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
@@ -124,10 +131,9 @@
delete originalTarget;
return &theParticleChange;
}
}
void
G4LESigmaMinusInelastic::Cascade(
void G4LESigmaMinusInelastic::Cascade(
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int& vecLen,
const G4HadProjectile *originalIncident,
@@ -136,7 +142,7 @@
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic )
{
{
// derived from original FORTRAN code CASSM by H. Fesefeldt (13-Sep-1987)
//
// SigmaMinus undergoes interaction with nucleon within a nucleus. Check if it is
@@ -362,7 +368,7 @@
}
SetUpPions( np, nm, nz, vec, vecLen );
return;
}
}
/* end of file */
source/processes/hadronic/models/low_energy/src/G4LESigmaPlusInelastic.cc
+50 -44
View File
@@ -23,52 +23,59 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LESigmaPlusInelastic.cc,v 1.11 2006-06-29 20:45:19 gunter Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LESigmaPlusInelastic.cc,v 1.11 2006/06/29 20:45:19 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: SigmaPlus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
// Last modified: 27-Mar-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
// Hadronic Process: SigmaPlus Inelastic Process
// J.L. Chuma, TRIUMF, 19-Feb-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
#include "G4LESigmaPlusInelastic.hh"
#include "Randomize.hh"
G4HadFinalState *
G4LESigmaPlusInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV)
{
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
//
// create the target particle
//
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
void G4LESigmaPlusInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LESigmaPlusInelastic is one of the Low Energy Parameterized\n"
<< "(LEP) models used to implement inelastic Sigma+ scattering\n"
<< "from nuclei. It is a re-engineered version of the GHEISHA\n"
<< "code of H. Fesefeldt. It divides the initial collision\n"
<< "products into backward- and forward-going clusters which are\n"
<< "then decayed into final state hadrons. The model does not\n"
<< "conserve energy on an event-by-event basis. It may be\n"
<< "applied to Sigma+ with initial energies between 0 and 25\n"
<< "GeV.\n";
}
G4HadFinalState*
G4LESigmaPlusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV) {
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
// create the target particle
G4DynamicParticle* originalTarget = targetNucleus.ReturnTargetParticle();
if( verboseLevel > 1 )
{
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LESigmaPlusInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
if (verboseLevel > 1) {
const G4Material* targetMaterial = aTrack.GetMaterial();
G4cout << "G4LESigmaPlusInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
<< G4endl;
}
//
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
//
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
}
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
@@ -124,10 +131,9 @@
delete originalTarget;
return &theParticleChange;
}
}
void
G4LESigmaPlusInelastic::Cascade(
void G4LESigmaPlusInelastic::Cascade(
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int& vecLen,
const G4HadProjectile *originalIncident,
@@ -136,7 +142,7 @@
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic )
{
{
// derived from original FORTRAN code CASSP by H. Fesefeldt (30-Nov-1987)
//
// SigmaPlus undergoes interaction with nucleon within a nucleus. Check if it is
@@ -375,7 +381,7 @@
}
SetUpPions( np, nm, nz, vec, vecLen );
return;
}
}
/* end of file */
source/processes/hadronic/models/low_energy/src/G4LETritonInelastic.cc
+50 -26
View File
@@ -23,25 +23,37 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// Hadronic Process: Triton Inelastic Process
// J.L. Chuma, TRIUMF, 25-Feb-1997
// Last modified: 27-Mar-1997
// J.L. Chuma, 08-May-2001: Update original incident passed back in vec[0]
// from NuclearReaction
//
// Hadronic Process: Triton Inelastic Process
// J.L. Chuma, TRIUMF, 25-Feb-1997
// J.L. Chuma, 08-May-2001: Update original incident passed back in vec[0]
// from NuclearReaction
#include "G4LETritonInelastic.hh"
#include "Randomize.hh"
#include "G4Electron.hh"
G4HadFinalState *
G4LETritonInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
bool triton_debug = false;
if(getenv("TritonLEDebug")) triton_debug = true;
theParticleChange.Clear();
const G4HadProjectile *originalIncident = &aTrack;
void G4LETritonInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LETritonInelastic is one of the Low Energy Parameterized\n"
<< "(LEP) models used to implement inelastic triton scattering\n"
<< "from nuclei. It is a re-engineered version of the GHEISHA\n"
<< "code of H. Fesefeldt. It divides the initial collision\n"
<< "products into backward- and forward-going clusters which are\n"
<< "then decayed into final state hadrons. The model does not\n"
<< "conserve energy on an event-by-event basis. It may be\n"
<< "applied to tritons with initial energies between 0 and 25\n"
<< "GeV.\n";
}
G4HadFinalState*
G4LETritonInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
G4bool triton_debug = false;
if (getenv("TritonLEDebug")) triton_debug = true;
theParticleChange.Clear();
const G4HadProjectile *originalIncident = &aTrack;
if(triton_debug) std::cout << "entering LETritonInelastic "<<originalIncident->GetKineticEnergy()<<std::endl;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV)
{
@@ -71,23 +83,23 @@
}
if(triton_debug)std::cout << "running LETritonInelastic 2"<<std::endl;
G4double A = targetNucleus.GetN();
G4double Z = targetNucleus.GetZ();
G4double theAtomicMass = targetNucleus.AtomicMass( A, Z );
G4double A = targetNucleus.GetA_asInt();
G4double Z = targetNucleus.GetZ_asInt();
G4double theAtomicMass = targetNucleus.AtomicMass(A, Z);
G4double massVec[9];
massVec[0] = targetNucleus.AtomicMass( A+3.0, Z+1.0 );
massVec[1] = targetNucleus.AtomicMass( A+2.0, Z+1.0 );
massVec[2] = targetNucleus.AtomicMass( A+2.0, Z );
massVec[3] = targetNucleus.AtomicMass( A+1.0, Z );
massVec[4] = theAtomicMass;
massVec[5] = 0.;
massVec[5] = massVec[3]; //0.;
if (A > 1.0 && Z > 1.0)
massVec[5] = targetNucleus.AtomicMass( A-1.0, Z-1.0 );
massVec[5] = targetNucleus.AtomicMass( A-1.0, Z-1.0 );
massVec[6] = targetNucleus.AtomicMass( A+1.0, Z+1.0 );
massVec[7] = massVec[3];
massVec[8] = 0.;
massVec[8] = massVec[2]; //0.;
if (Z > 1.0)
massVec[8] = targetNucleus.AtomicMass( A+1.0, Z-1.0 );
massVec[8] = targetNucleus.AtomicMass( A+1.0, Z-1.0 );
G4FastVector<G4ReactionProduct,4> vec; // vec will contain the secondary particles
G4int vecLen = 0;
@@ -98,10 +110,20 @@
targetNucleus, theAtomicMass, massVec );
if(triton_debug)std::cout << "running LETritonInelastic 4"<<std::endl;
//
// G4cout << "0 E(MeV)= " << vec[0]->GetKineticEnergy() << G4endl;
G4double p = vec[0]->GetMomentum().mag();
theParticleChange.SetMomentumChange( vec[0]->GetMomentum()*(1./p) );
theParticleChange.SetEnergyChange( vec[0]->GetKineticEnergy() );
delete vec[0];
if (vecLen <= 1)
{
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
//
G4DynamicParticle *pd;
for( G4int i=1; i<vecLen; ++i )
@@ -110,12 +132,14 @@
pd->SetDefinition( vec[i]->GetDefinition() );
pd->SetMomentum( vec[i]->GetMomentum() );
theParticleChange.AddSecondary( pd );
//G4cout << "i E(MeV)= " << pd->GetKineticEnergy()
// << " " << pd->GetDefinition()->GetParticleName() << G4endl;
delete vec[i];
}
if(triton_debug)std::cout << "leaving LETritonInelastic"<<std::endl;
return &theParticleChange;
}
if(triton_debug)std::cout << "leaving LETritonInelastic"<<std::endl;
return &theParticleChange;
}
/* end of file */
source/processes/hadronic/models/low_energy/src/G4LEXiMinusInelastic.cc
+53 -46
View File
@@ -23,52 +23,60 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEXiMinusInelastic.cc,v 1.11 2006-06-29 20:45:23 gunter Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEXiMinusInelastic.cc,v 1.11 2006/06/29 20:45:23 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: XiMinus Inelastic Process
// J.L. Chuma, TRIUMF, 20-Feb-1997
// Last modified: 27-Mar-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
// Hadronic Process: XiMinus Inelastic Process
// J.L. Chuma, TRIUMF, 20-Feb-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
#include "G4LEXiMinusInelastic.hh"
#include "Randomize.hh"
void G4LEXiMinusInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LEXiMinusInelastic is one of the Low Energy Parameterized\n"
<< "(LEP) models used to implement inelastic Xi- scattering\n"
<< "from nuclei. It is a re-engineered version of the GHEISHA\n"
<< "code of H. Fesefeldt. It divides the initial collision\n"
<< "products into backward- and forward-going clusters which are\n"
<< "then decayed into final state hadrons. The model does not\n"
<< "conserve energy on an event-by-event basis. It may be\n"
<< "applied to Xi- with initial energies between 0 and 25\n"
<< "GeV.\n";
}
G4HadFinalState *
G4LEXiMinusInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV)
{
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
//
// create the target particle
//
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
if( verboseLevel > 1 )
{
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEXiMinusInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
G4HadFinalState*
G4LEXiMinusInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV) {
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
// create the target particle
G4DynamicParticle* originalTarget = targetNucleus.ReturnTargetParticle();
if (verboseLevel > 1) {
const G4Material *targetMaterial = aTrack.GetMaterial();
G4cout << "G4LEXiMinusInelastic::ApplyYourself called" << G4endl;
G4cout << "kinetic energy = " << originalIncident->GetKineticEnergy()/MeV << "MeV, ";
G4cout << "target material = " << targetMaterial->GetName() << ", ";
G4cout << "target particle = " << originalTarget->GetDefinition()->GetParticleName()
<< G4endl;
}
//
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
//
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
}
// Fermi motion and evaporation
// As of Geant3, the Fermi energy calculation had not been Done
G4double ek = originalIncident->GetKineticEnergy()/MeV;
G4double amas = originalIncident->GetDefinition()->GetPDGMass()/MeV;
G4ReactionProduct modifiedOriginal;
modifiedOriginal = *originalIncident;
G4double tkin = targetNucleus.Cinema( ek );
ek += tkin;
@@ -124,10 +132,9 @@
delete originalTarget;
return &theParticleChange;
}
}
void
G4LEXiMinusInelastic::Cascade(
void G4LEXiMinusInelastic::Cascade(
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int& vecLen,
const G4HadProjectile *originalIncident,
@@ -135,8 +142,8 @@
G4ReactionProduct &targetParticle,
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic )
{
G4bool &quasiElastic)
{
// derived from original FORTRAN code CASXM by H. Fesefeldt (17-Jan-1989)
//
// XiMinus undergoes interaction with nucleon within a nucleus. Check if it is
@@ -388,7 +395,7 @@
}
SetUpPions( np, nm, nz, vec, vecLen );
return;
}
}
/* end of file */
source/processes/hadronic/models/low_energy/src/G4LEXiZeroInelastic.cc
+38 -29
View File
@@ -23,34 +23,44 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LEXiZeroInelastic.cc,v 1.11 2006-06-29 20:45:25 gunter Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
// $Id: G4LEXiZeroInelastic.cc,v 1.11 2006/06/29 20:45:25 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Hadronic Process: XiZero Inelastic Process
// J.L. Chuma, TRIUMF, 20-Feb-1997
// Last modified: 27-Mar-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
// Hadronic Process: XiZero Inelastic Process
// J.L. Chuma, TRIUMF, 20-Feb-1997
// Modified by J.L.Chuma 30-Apr-97: added originalTarget for CalculateMomenta
#include "G4LEXiZeroInelastic.hh"
#include "Randomize.hh"
void G4LEXiZeroInelastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LEXiZeroInelastic is one of the Low Energy Parameterized\n"
<< "(LEP) models used to implement inelastic X0 scattering\n"
<< "from nuclei. It is a re-engineered version of the GHEISHA\n"
<< "code of H. Fesefeldt. It divides the initial collision\n"
<< "products into backward- and forward-going clusters which are\n"
<< "then decayed into final state hadrons. The model does not\n"
<< "conserve energy on an event-by-event basis. It may be\n"
<< "applied to X0 with initial energies between 0 and 25\n"
<< "GeV.\n";
}
G4HadFinalState *
G4LEXiZeroInelastic::ApplyYourself( const G4HadProjectile &aTrack,
G4Nucleus &targetNucleus )
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV)
{
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
//
// create the target particle
//
G4DynamicParticle *originalTarget = targetNucleus.ReturnTargetParticle();
G4HadFinalState*
G4LEXiZeroInelastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
const G4HadProjectile *originalIncident = &aTrack;
if (originalIncident->GetKineticEnergy()<= 0.1*MeV) {
theParticleChange.SetStatusChange(isAlive);
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
// create the target particle
G4DynamicParticle* originalTarget = targetNucleus.ReturnTargetParticle();
if( verboseLevel > 1 )
{
@@ -124,10 +134,9 @@
delete originalTarget;
return &theParticleChange;
}
}
void
G4LEXiZeroInelastic::Cascade(
void G4LEXiZeroInelastic::Cascade(
G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
G4int& vecLen,
const G4HadProjectile *originalIncident,
@@ -135,8 +144,8 @@
G4ReactionProduct &targetParticle,
G4bool &incidentHasChanged,
G4bool &targetHasChanged,
G4bool &quasiElastic )
{
G4bool &quasiElastic)
{
// derived from original FORTRAN code CASX0 by H. Fesefeldt (20-Jan-1989)
//
// XiZero undergoes interaction with nucleon within a nucleus. Check if it is
@@ -388,7 +397,7 @@
}
SetUpPions( np, nm, nz, vec, vecLen );
return;
}
}
/* end of file */
source/processes/hadronic/models/low_energy/src/G4LElastic.cc
+80 -64
View File
@@ -23,11 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
//
// Physics model class G4LElastic
//
//
// G4 Model: Low-energy Elastic scattering
// F.W. Jones, TRIUMF, 04-JUN-96
//
@@ -37,80 +33,100 @@
// 25-JUN-98 FWJ: replaced missing Initialize for ParticleChange.
// 14-DEC-05 V.Ivanchenko: restore 1.19 version (7.0)
// 23-JAN-07 V.Ivanchenko: add protection inside sqrt
//
#include "globals.hh"
#include "G4LElastic.hh"
#include "Randomize.hh"
#include "G4ParticleTable.hh"
#include "G4IonTable.hh"
#include <iostream>
G4LElastic::G4LElastic(const G4String& name)
:G4HadronicInteraction(name)
{
SetMinEnergy(0.0);
SetMaxEnergy(DBL_MAX);
}
void G4LElastic::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LElastic is one of the Low Energy Parameterized (LEP)\n"
<< "models used to implement elastic hadron scattering from nuclei.\n"
<< "It is a re-engineered version of the GHEISHA code of\n"
<< "H. Fesefeldt. It performs simplified two-body elastic\n"
<< "scattering for all long-lived hadronic projectiles by using\n"
<< "a two-exponential parameterization in momentum transfer.\n"
<< "It is valid for incident hadrons of all energies.\n";
}
G4HadFinalState*
G4LElastic::ApplyYourself(const G4HadProjectile& aTrack, G4Nucleus& targetNucleus)
{
if(getenv("debug_LElastic")) verboseLevel = 5;
theParticleChange.Clear();
const G4HadProjectile* aParticle = &aTrack;
G4double atno2 = targetNucleus.GetN();
G4double zTarget = targetNucleus.GetZ();
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
if(getenv("debug_LElastic")) verboseLevel = 5;
theParticleChange.Clear();
const G4HadProjectile* aParticle = &aTrack;
G4double atno2 = targetNucleus.GetA_asInt();
G4double zTarget = targetNucleus.GetZ_asInt();
theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
// Elastic scattering off Hydrogen
// Elastic scattering off Hydrogen
G4DynamicParticle* aSecondary = 0;
if (atno2 < 1.5) {
const G4ParticleDefinition* aParticleType = aParticle->GetDefinition();
if (aParticleType == G4PionPlus::PionPlus())
aSecondary = LightMedia.PionPlusExchange(aParticle, targetNucleus);
else if (aParticleType == G4PionMinus::PionMinus())
aSecondary = LightMedia.PionMinusExchange(aParticle, targetNucleus);
else if (aParticleType == G4KaonPlus::KaonPlus())
aSecondary = LightMedia.KaonPlusExchange(aParticle, targetNucleus);
else if (aParticleType == G4KaonZeroShort::KaonZeroShort())
aSecondary = LightMedia.KaonZeroShortExchange(aParticle,targetNucleus);
else if (aParticleType == G4KaonZeroLong::KaonZeroLong())
aSecondary = LightMedia.KaonZeroLongExchange(aParticle, targetNucleus);
else if (aParticleType == G4KaonMinus::KaonMinus())
aSecondary = LightMedia.KaonMinusExchange(aParticle, targetNucleus);
else if (aParticleType == G4Proton::Proton())
aSecondary = LightMedia.ProtonExchange(aParticle, targetNucleus);
else if (aParticleType == G4AntiProton::AntiProton())
aSecondary = LightMedia.AntiProtonExchange(aParticle, targetNucleus);
else if (aParticleType == G4Neutron::Neutron())
aSecondary = LightMedia.NeutronExchange(aParticle, targetNucleus);
else if (aParticleType == G4AntiNeutron::AntiNeutron())
aSecondary = LightMedia.AntiNeutronExchange(aParticle, targetNucleus);
else if (aParticleType == G4Lambda::Lambda())
aSecondary = LightMedia.LambdaExchange(aParticle, targetNucleus);
else if (aParticleType == G4AntiLambda::AntiLambda())
aSecondary = LightMedia.AntiLambdaExchange(aParticle, targetNucleus);
else if (aParticleType == G4SigmaPlus::SigmaPlus())
aSecondary = LightMedia.SigmaPlusExchange(aParticle, targetNucleus);
else if (aParticleType == G4SigmaMinus::SigmaMinus())
aSecondary = LightMedia.SigmaMinusExchange(aParticle, targetNucleus);
else if (aParticleType == G4AntiSigmaPlus::AntiSigmaPlus())
aSecondary = LightMedia.AntiSigmaPlusExchange(aParticle,targetNucleus);
else if (aParticleType == G4AntiSigmaMinus::AntiSigmaMinus())
aSecondary= LightMedia.AntiSigmaMinusExchange(aParticle,targetNucleus);
else if (aParticleType == G4XiZero::XiZero())
aSecondary = LightMedia.XiZeroExchange(aParticle, targetNucleus);
else if (aParticleType == G4XiMinus::XiMinus())
aSecondary = LightMedia.XiMinusExchange(aParticle, targetNucleus);
else if (aParticleType == G4AntiXiZero::AntiXiZero())
aSecondary = LightMedia.AntiXiZeroExchange(aParticle, targetNucleus);
else if (aParticleType == G4AntiXiMinus::AntiXiMinus())
aSecondary = LightMedia.AntiXiMinusExchange(aParticle, targetNucleus);
else if (aParticleType == G4OmegaMinus::OmegaMinus())
aSecondary = LightMedia.OmegaMinusExchange(aParticle, targetNucleus);
else if (aParticleType == G4AntiOmegaMinus::AntiOmegaMinus())
aSecondary= LightMedia.AntiOmegaMinusExchange(aParticle,targetNucleus);
else if (aParticleType == G4KaonPlus::KaonPlus())
aSecondary = LightMedia.KaonPlusExchange(aParticle, targetNucleus);
}
G4DynamicParticle* aSecondary = 0;
if (atno2 < 1.5) {
const G4ParticleDefinition* aParticleType = aParticle->GetDefinition();
if (aParticleType == G4PionPlus::PionPlus())
aSecondary = LightMedia.PionPlusExchange(aParticle, targetNucleus);
else if (aParticleType == G4PionMinus::PionMinus())
aSecondary = LightMedia.PionMinusExchange(aParticle, targetNucleus);
else if (aParticleType == G4KaonPlus::KaonPlus())
aSecondary = LightMedia.KaonPlusExchange(aParticle, targetNucleus);
else if (aParticleType == G4KaonZeroShort::KaonZeroShort())
aSecondary = LightMedia.KaonZeroShortExchange(aParticle,targetNucleus);
else if (aParticleType == G4KaonZeroLong::KaonZeroLong())
aSecondary = LightMedia.KaonZeroLongExchange(aParticle, targetNucleus);
else if (aParticleType == G4KaonMinus::KaonMinus())
aSecondary = LightMedia.KaonMinusExchange(aParticle, targetNucleus);
else if (aParticleType == G4Proton::Proton())
aSecondary = LightMedia.ProtonExchange(aParticle, targetNucleus);
else if (aParticleType == G4AntiProton::AntiProton())
aSecondary = LightMedia.AntiProtonExchange(aParticle, targetNucleus);
else if (aParticleType == G4Neutron::Neutron())
aSecondary = LightMedia.NeutronExchange(aParticle, targetNucleus);
else if (aParticleType == G4AntiNeutron::AntiNeutron())
aSecondary = LightMedia.AntiNeutronExchange(aParticle, targetNucleus);
else if (aParticleType == G4Lambda::Lambda())
aSecondary = LightMedia.LambdaExchange(aParticle, targetNucleus);
else if (aParticleType == G4AntiLambda::AntiLambda())
aSecondary = LightMedia.AntiLambdaExchange(aParticle, targetNucleus);
else if (aParticleType == G4SigmaPlus::SigmaPlus())
aSecondary = LightMedia.SigmaPlusExchange(aParticle, targetNucleus);
else if (aParticleType == G4SigmaMinus::SigmaMinus())
aSecondary = LightMedia.SigmaMinusExchange(aParticle, targetNucleus);
else if (aParticleType == G4AntiSigmaPlus::AntiSigmaPlus())
aSecondary = LightMedia.AntiSigmaPlusExchange(aParticle,targetNucleus);
else if (aParticleType == G4AntiSigmaMinus::AntiSigmaMinus())
aSecondary= LightMedia.AntiSigmaMinusExchange(aParticle,targetNucleus);
else if (aParticleType == G4XiZero::XiZero())
aSecondary = LightMedia.XiZeroExchange(aParticle, targetNucleus);
else if (aParticleType == G4XiMinus::XiMinus())
aSecondary = LightMedia.XiMinusExchange(aParticle, targetNucleus);
else if (aParticleType == G4AntiXiZero::AntiXiZero())
aSecondary = LightMedia.AntiXiZeroExchange(aParticle, targetNucleus);
else if (aParticleType == G4AntiXiMinus::AntiXiMinus())
aSecondary = LightMedia.AntiXiMinusExchange(aParticle, targetNucleus);
else if (aParticleType == G4OmegaMinus::OmegaMinus())
aSecondary = LightMedia.OmegaMinusExchange(aParticle, targetNucleus);
else if (aParticleType == G4AntiOmegaMinus::AntiOmegaMinus())
aSecondary= LightMedia.AntiOmegaMinusExchange(aParticle,targetNucleus);
else if (aParticleType == G4KaonPlus::KaonPlus())
aSecondary = LightMedia.KaonPlusExchange(aParticle, targetNucleus);
}
// Has a charge or strangeness exchange occurred?
// Has a charge or strangeness exchange occurred?
if (aSecondary) {
aSecondary->SetMomentum(aParticle->Get4Momentum().vect());
theParticleChange.SetStatusChange(stopAndKill);
source/processes/hadronic/models/low_energy/src/G4LFission.cc
+25 -15
View File
@@ -23,9 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: G4LFission.cc,v 1.15 2007/02/26 19:29:30 dennis Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4LFission.cc,v 1.15 2007-02-26 19:29:30 dennis Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
//
// G4 Model: Low Energy Fission
@@ -40,28 +39,39 @@
// the code comes mostly from the old Low-energy Fission class
//
// 25-JUN-98 FWJ: replaced missing Initialize for ParticleChange.
//
#include "globals.hh"
#include "G4LFission.hh"
#include "Randomize.hh"
#include <iostream>
G4LFission::G4LFission() : G4HadronicInteraction("G4LFission")
G4LFission::G4LFission(const G4String& name)
: G4HadronicInteraction(name)
{
init();
SetMinEnergy( 0.0*GeV );
SetMaxEnergy( DBL_MAX );
init();
SetMinEnergy(0.0*GeV);
SetMaxEnergy(DBL_MAX);
}
G4LFission::~G4LFission()
{
theParticleChange.Clear();
theParticleChange.Clear();
}
void
G4LFission::init()
void G4LFission::ModelDescription(std::ostream& outFile) const
{
outFile << "G4LFission is one of the Low Energy Parameterized\n"
<< "(LEP) models used to implement neutron-induced fission of\n"
<< "nuclei. It is a re-engineered version of the GHEISHA code\n"
<< "of H. Fesefeldt which emits neutrons and gammas but no\n"
<< "nuclear fragments. The model is applicable to all incident\n"
<< "neutron energies.\n";
}
void G4LFission::init()
{
G4int i;
G4double xx = 1. - 0.5;
@@ -86,8 +96,8 @@ G4LFission::ApplyYourself(const G4HadProjectile & aTrack,G4Nucleus & targetNucle
theParticleChange.Clear();
const G4HadProjectile* aParticle = &aTrack;
G4double N = targetNucleus.GetN();
G4double Z = targetNucleus.GetZ();
G4double N = targetNucleus.GetA_asInt();
G4double Z = targetNucleus.GetZ_asInt();
theParticleChange.SetStatusChange(stopAndKill);
G4double P = aParticle->GetTotalMomentum()/MeV;