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

Import Geant4 10.0.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-10 11:51:14 +02:00
parent e2d2f9810a
commit 286caacf06
12421 changed files with 730077 additions and 502383 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/hadronic/stopping/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:08:15 bmorgan Exp $
# $Id: CMakeLists.txt 66367 2012-12-18 09:18:08Z gcosmo $
#
#------------------------------------------------------------------------------
source/processes/hadronic/stopping/GNUmakefile
+1 -2
View File
@@ -1,4 +1,4 @@
# $Id: GNUmakefile,v 1.5 2008-09-01 17:12:40 vnivanch Exp $
# $Id: GNUmakefile 76309 2013-11-08 13:48:42Z gcosmo $
# -----------------------------------------------------------
# GNUmakefile for hadronic stopping library. G.Folger 10-Dec-97
# --------------------------------------------------------------
@@ -27,7 +27,6 @@ CPPFLAGS += -I$(G4BASE)/global/management/include \
-I$(G4BASE)/processes/management/include \
-I$(G4BASE)/processes/hadronic/management/include \
-I$(G4BASE)/processes/hadronic/cross_sections/include \
-I$(G4BASE)/processes/hadronic/models/high_energy/include \
-I$(G4BASE)/processes/hadronic/models/util/include \
-I$(G4BASE)/processes/hadronic/models/pre_equilibrium/exciton_model/include \
-I$(G4BASE)/processes/hadronic/models/management/include \
source/processes/hadronic/stopping/History
+80
View File
@@ -14,6 +14,86 @@ code and to keep track of all tags.
* Please list in reverse chronological order (last date on top)
---------------------------------------------------------------
08 Nov 2013 A. Ribon (hadr-stopping-V09-06-11)
--------------------------------------------------------------------
- Updated GNUmakefile and sources.cmake to reflect removal of HE
hadronic models.
03 Oct 2013 K. Genser (hadr-stopping-V09-06-10)
--------------------------------------------------------------------
- G4MuonMinusCapture.cc
Replaced native PreCompound model with Bertini
(G4MuMinusCapturePrecompound with G4CascadeInterface)
16 July 2013 G. Cosmo (hadr-stopping-V09-06-09)
--------------------------------------------------------------------
- Correction to CMake scripts for granular build.
04 June 2013 A. Ribon (hadr-stopping-V09-06-08)
--------------------------------------------------------------------
- G4MuonMinusCaptureAtRest
fix inside .cc file to access ions via IonTable class and
GetIon method
01 May 2013 K. Genser (hadr-stopping-V09-06-07)
--------------------------------------------------------------------
- G4MuonMinusBoundDecay
improved muon capture rate data/lookup and improved
calculation of bound muon decay rate
24 April 2013 K. Genser (hadr-stopping-V09-06-06)
--------------------------------------------------------------------
- G4MuonMinusBoundDecay.hh, G4MuonMinusBoundDecay.cc
G4StopElementSelector.cc
corrected calculations and lookup of MuonCaptureRate
24 April 2013 V. Ivantchenko (hadr-stopping-V09-06-05)
--------------------------------------------------------------------
- G4EmCaptureCascade - fix inside .cc file instead of .hh
24 April 2013 V. Ivantchenko (hadr-stopping-V09-06-04)
--------------------------------------------------------------------
- G4EmCaptureCascade - fixed array length (reported by Coverity)
15 March 2013 V. Ivantchenko (hadr-stopping-V09-06-03)
--------------------------------------------------------------------
- G4MuMinusCapturePrecompound, G4EmCaptureCascade,
G4MuonMinusBoundDecay, G4StopElementSelector - fixed Coverity warnings,
removed "static" const, make physics methods public to be used
in unit tests
28 January 2013 Julia Yarba (hadr-stopping-V09-06-02)
---------------------------------------------------------
- Remove G4ThreadLocal from G4StopElementSelector, G4MuMinusCaptureCascade,
G4MuonMinusBoundDecay, and replace with static const as those arrays are
NOT mutable; this is part of adapting for MT processing
13 December 2012 Michael Kelsey (hadr-stopping-V09-06-01)
---------------------------------------------------------
- G4AntiNeutronAnnihilationAtRest.hh,cc: Restore this process from the
cleanup below. This class does not have a Fritiof-based counterpart.
NOTE: Restoration was done using |svn copy -r 66187|, so all prior
history of the file is also recovered.
- sources.cmake: Restore G4AntiNeutronAnnihilationAtRest.hh,cc.
3 December 2012 Michael Kelsey (hadr-stopping-V09-06-00)
--------------------------------------------------------
- sources.cmake: Remove all deprecated classes for start of 10.0 development:
G4AntiNeutronAnnihilationAtRest.hh,cc G4PiMinusStopLi.hh,cc
G4AntiProtonAnnihilationAtRest.hh,cc G4PiMinusStopMaterial.hh,cc
G4DistributionGenerator.hh,cc G4PiMinusStopN.hh,cc
G4KaonMinusAbsorption.hh,cc G4PiMinusStopO.hh,cc
G4KaonMinusAbsorptionAtRest.hh,cc G4PiMinusStopPb.hh,cc
G4NeutronCaptureAtRest.hh,cc G4PiMinusStopTa.hh,cc
G4PiMinusAbsorptionAtRest.hh,cc G4PionMinusAbsorptionAtRest.hh,cc
G4PiMinusStopAbsorption.hh,cc G4StopDeexcitation.hh,cc
G4PiMinusStopAl.hh,cc G4StopDeexcitationAlgorithm.hh
G4PiMinusStopC.hh,cc G4StopDummyDeexcitation.hh,cc
G4PiMinusStopCo.hh,cc G4StopTheoDeexcitation.hh,cc
G4PiMinusStopCu.hh,cc
14 November 2012 V. Ivantchenko (hadr-stopping-V09-05-31)
--------------------------------------------------------------------
- G4MuMinusCapturePrecompound - fixed extra run time memory leak
source/processes/hadronic/stopping/include/G4AntiNeutronAnnihilationAtRest.hh
+1
View File
@@ -23,6 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4AntiNeutronAnnihilationAtRest.hh 66367 2012-12-18 09:18:08Z gcosmo $
// G4AntiNeutronAnnihilationAtRest physics process
// Larry Felawka (TRIUMF), April 1998
//---------------------------------------------------------------------
source/processes/hadronic/stopping/include/G4AntiProtonAnnihilationAtRest.hh
-135
View File
@@ -1,135 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// G4AntiProtonAnnihilationAtRest physics process
// Larry Felawka (TRIUMF), April 1998
//---------------------------------------------------------------------
#ifndef G4AntiProtonAnnihilationAtRest_h
#define G4AntiProtonAnnihilationAtRest_h 1
// Class Description:
//
// Process for annihilation of p-bar at rest.
// To be used in your physics list in case you need this physics.
#include "globals.hh"
#include "Randomize.hh"
#include "G4VRestProcess.hh"
#include "G4VParticleChange.hh"
#include "G4ParticleDefinition.hh"
#include "G4GHEKinematicsVector.hh"
#include "G4HadronicProcessType.hh"
class G4AntiProtonAnnihilationAtRest : public G4VRestProcess
{
private:
// hide assignment operator as private
G4AntiProtonAnnihilationAtRest& operator=(const G4AntiProtonAnnihilationAtRest &right);
G4AntiProtonAnnihilationAtRest(const G4AntiProtonAnnihilationAtRest& );
public:
G4AntiProtonAnnihilationAtRest(const G4String& processName ="AntiProtonAnnihilationAtRest",
G4ProcessType aType = fHadronic );
~G4AntiProtonAnnihilationAtRest();
G4bool IsApplicable(const G4ParticleDefinition&);
void PreparePhysicsTable(const G4ParticleDefinition&);
void BuildPhysicsTable(const G4ParticleDefinition&);
G4double AtRestGetPhysicalInteractionLength(const G4Track&,
G4ForceCondition*);
// zero mean lifetime
G4double GetMeanLifeTime(const G4Track& ,
G4ForceCondition* ) {return 0.0;}
G4VParticleChange* AtRestDoIt(const G4Track&, const G4Step&);
// return number of secondaries produced
G4int GetNumberOfSecondaries();
// pointer to array containg kinematics of secondaries
G4GHEKinematicsVector* GetSecondaryKinematics();
private:
void GenerateSecondaries();
void Poisso( G4float, G4int* );
void Normal( G4float* );
void AntiProtonAnnihilation( G4int* );
G4double ExNu( G4float );
G4int NFac( G4int );
private:
// global time-of-flight of stopped AntiProton
G4float globalTime;
// atomic mass of target nucleus
G4float targetAtomicMass;
// charge of target nucleus
G4float targetCharge;
G4GHEKinematicsVector* pv;
G4GHEKinematicsVector* eve;
G4GHEKinematicsVector* gkin;
G4float evapEnergy1;
G4float evapEnergy3;
G4int ngkine;
G4int ntot;
G4GHEKinematicsVector result;
G4float massPionMinus;
G4float massProton;
G4float massPionZero;
G4float massAntiProton;
G4float massPionPlus;
G4float massGamma;
G4ParticleDefinition* pdefGamma;
G4ParticleDefinition* pdefPionPlus;
G4ParticleDefinition* pdefPionZero;
G4ParticleDefinition* pdefPionMinus;
G4ParticleDefinition* pdefProton;
G4ParticleDefinition* pdefAntiProton;
G4ParticleDefinition* pdefNeutron;
G4ParticleDefinition* pdefDeuteron;
G4ParticleDefinition* pdefTriton;
G4ParticleDefinition* pdefAlpha;
};
#endif
source/processes/hadronic/stopping/include/G4DistributionGenerator.hh
-69
View File
@@ -1,69 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4DistributionGenerator.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 12 May 1998
//
#ifndef G4DISTRIBUTIONGENERATOR_HH
#define G4DISTRIBUTIONGENERATOR_HH
#include <vector>
#include "globals.hh"
#include "Randomize.hh"
class G4DistributionGenerator
{
public:
// Constructor
G4DistributionGenerator(std::vector<G4double>& x,
std::vector<G4double>& values);
G4DistributionGenerator();
// Destructor
~G4DistributionGenerator();
G4double Generate(G4double ranflat);
private:
// Hide assignment operator as private
// G4DistributionGenerator& operator=(const G4DistributionGenerator &right);
// Copy constructor
// G4DistributionGenerator(const G4DistributionGenerator& );
std::vector<G4double> _x;
std::vector<G4double> _cumProb;
};
#endif
source/processes/hadronic/stopping/include/G4ElementSelector.hh
+1 -1
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4ElementSelector.hh 66367 2012-12-18 09:18:08Z gcosmo $
//
//-----------------------------------------------------------------------------
//
source/processes/hadronic/stopping/include/G4EmCaptureCascade.hh
+1 -1
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4EmCaptureCascade.hh 66367 2012-12-18 09:18:08Z gcosmo $
//
//-----------------------------------------------------------------------------
//
source/processes/hadronic/stopping/include/G4HadronStoppingProcess.hh
+1 -1
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4HadronStoppingProcess.hh 66367 2012-12-18 09:18:08Z gcosmo $
//
//---------------------------------------------------------------------
//
source/processes/hadronic/stopping/include/G4KaonMinusAbsorption.hh
-133
View File
@@ -1,133 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// G4KaonMinusAbsorption physics process
// Larry Felawka (TRIUMF), April 1998
//---------------------------------------------------------------------
#ifndef G4KaonMinusAbsorption_h
#define G4KaonMinusAbsorption_h 1
#include "globals.hh"
#include "Randomize.hh"
#include "G4VRestProcess.hh"
#include "G4VParticleChange.hh"
#include "G4ParticleDefinition.hh"
#include "G4GHEKinematicsVector.hh"
#include "G4HadronicProcessType.hh"
// Class Description:
//
// Alternative process for absorption of K- at rest.
// To be used in your physics list in case you need this physics.
class G4KaonMinusAbsorption : public G4VRestProcess
{
private:
// hide assignment operator as private
G4KaonMinusAbsorption& operator=(const G4KaonMinusAbsorption &right);
G4KaonMinusAbsorption(const G4KaonMinusAbsorption& );
public:
G4KaonMinusAbsorption(const G4String& processName ="KaonMinusAbsorption",
G4ProcessType aType = fHadronic );
~G4KaonMinusAbsorption();
G4bool IsApplicable(const G4ParticleDefinition&);
void PreparePhysicsTable(const G4ParticleDefinition&);
void BuildPhysicsTable(const G4ParticleDefinition&);
G4double AtRestGetPhysicalInteractionLength(const G4Track&,
G4ForceCondition*);
// zero mean lifetime
G4double GetMeanLifeTime(const G4Track& ,
G4ForceCondition* ) {return 0.0;}
G4VParticleChange* AtRestDoIt(const G4Track&, const G4Step&);
// return number of secondaries produced
G4int GetNumberOfSecondaries();
// pointer to array containg kinematics of secondaries
G4GHEKinematicsVector* GetSecondaryKinematics();
private:
void GenerateSecondaries();
void Poisso( G4float, G4int* );
void Normal( G4float* );
void KaonMinusAbsorption( G4int* );
G4int NFac( G4int );
private:
// global time-of-flight of stopped AntiProton
G4float globalTime;
// atomic mass of target nucleus
G4float targetAtomicMass;
// charge of target nucleus
G4float targetCharge;
G4GHEKinematicsVector* pv;
G4GHEKinematicsVector* eve;
G4GHEKinematicsVector* gkin;
G4float evapEnergy1;
G4float evapEnergy3;
G4int ngkine;
G4int ntot;
G4GHEKinematicsVector result;
G4float massKaonMinus;
G4float massGamma;
G4float massPionZero;
G4float massProton;
G4float massLambda;
G4ParticleDefinition* pdefKaonMinus;
G4ParticleDefinition* pdefGamma;
G4ParticleDefinition* pdefPionZero;
G4ParticleDefinition* pdefProton;
G4ParticleDefinition* pdefNeutron;
G4ParticleDefinition* pdefLambda;
G4ParticleDefinition* pdefDeuteron;
G4ParticleDefinition* pdefTriton;
G4ParticleDefinition* pdefAlpha;
};
#endif
source/processes/hadronic/stopping/include/G4KaonMinusAbsorptionAtRest.hh
-148
View File
@@ -1,148 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4KaonMinusAbsorptionAtRest.hh
//
// Author: Christian V"olcker (Christian.Volcker@cern.ch),
//
// Creation date: 10. November 1997
//
// -------------------------------------------------------------------
#ifndef G4KaonMinusAbsorptionAtRest_h
#define G4KaonMinusAbsorptionAtRest_h 1
// Class Description:
//
// Process for nuclear absorption of K- at rest.
// To be used in your physics list in case you need this physics.
#include "globals.hh"
#include "Randomize.hh"
#include "G4VRestProcess.hh"
#include "G4ParticleTypes.hh"
#include "G4Nucleus.hh"
#include "G4DynamicParticle.hh"
#include "G4DynamicParticleVector.hh"
#include "G4NucleiProperties.hh"
#include "G4HadronicProcessType.hh"
// *********************************************************
class G4KaonMinusAbsorptionAtRest : public G4VRestProcess
// *********************************************************
{
private:
// hide assignment operator as private
G4KaonMinusAbsorptionAtRest& operator=(const G4KaonMinusAbsorptionAtRest &right);
G4KaonMinusAbsorptionAtRest(const G4KaonMinusAbsorptionAtRest& );
public:
G4KaonMinusAbsorptionAtRest(const G4String& processName ="KaonMinusAbsorptionAtRest",
G4ProcessType aType = fHadronic );
~G4KaonMinusAbsorptionAtRest();
//override methods...
public:
G4bool IsApplicable(const G4ParticleDefinition& particle) {
return( particle == *(G4KaonMinus::KaonMinus()) );
}
void PreparePhysicsTable(const G4ParticleDefinition&);
void BuildPhysicsTable(const G4ParticleDefinition&);
// the main method ...
G4VParticleChange* AtRestDoIt(const G4Track& aTrack, const G4Step& aStep);
protected: // why?? might be private....
// zero mean lifetime
G4double GetMeanLifeTime(const G4Track& aTrack,
G4ForceCondition* )
{
G4double result = 0;
if(aTrack.GetMaterial()->GetNumberOfElements() == 1)
if(aTrack.GetMaterial()->GetZ()<1.5) result = DBL_MAX;
return result;
}
private:
// returns proton or neutron with fermi-momentum
G4DynamicParticle GetAbsorbingNucleon();
// returns proton or neutron particle definition;
G4ParticleDefinition* SelectAbsorbingNucleon();
// provides the neutron halo factor for absorption on nucleus surface.
// in the G4Nucleus
G4double NeutronHaloFactor(G4double Z, G4double N);
// creates the reaction products
G4DynamicParticleVector* KaonNucleonReaction();
// secondary pion absorption in parent nucleus
// if TRUE, then add excitation energy to the Nucleus
G4bool AbsorbPionByNucleus(G4DynamicParticle* aPion);
// secondary Sigma-Lambda conversion
// if conversion Done, then add excitation energy to the Nucleus
G4DynamicParticle *SigmaLambdaConversion(G4DynamicParticle* aSigma);
// instance variables ...
private:
// pointer to current stopped hadron
const G4DynamicParticle *stoppedHadron;
// pointer to current target nucleus
G4Nucleus* nucleus;
// some constant parameters
G4double pionAbsorptionRate;
// primary production rates ( for absorption on Carbon)
G4double rateLambdaZeroPiZero;
G4double rateSigmaMinusPiPlus;
G4double rateSigmaPlusPiMinus;
G4double rateSigmaZeroPiZero;
G4double rateLambdaZeroPiMinus;
G4double rateSigmaZeroPiMinus;
G4double rateSigmaMinusPiZero;
// Sigma Lambda Conversion rates
// for sigma- p -> lambda n
// sigma+ n -> lambda p
// sigma- n -> lambda
G4double sigmaPlusLambdaConversionRate;
G4double sigmaMinusLambdaConversionRate;
G4double sigmaZeroLambdaConversionRate;
};
#endif
source/processes/hadronic/stopping/include/G4MuMinusCaptureCascade.hh
+1 -1
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4MuMinusCaptureCascade.hh 66367 2012-12-18 09:18:08Z gcosmo $
//
// G4MuMinusCaptureCascade physics process --------
// Vladimir Ivanchenko, April 2000
source/processes/hadronic/stopping/include/G4MuMinusCapturePrecompound.hh
+1 -1
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4MuMinusCapturePrecompound.hh 66367 2012-12-18 09:18:08Z gcosmo $
//
//-----------------------------------------------------------------------------
//
source/processes/hadronic/stopping/include/G4MuonMinusBoundDecay.hh
+11 -5
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4MuonMinusBoundDecay.hh 69573 2013-05-08 13:35:53Z gcosmo $
//
//-----------------------------------------------------------------------------
//
@@ -49,6 +49,10 @@
//-----------------------------------------------------------------------------
//
// Modifications:
// 23/04/2013 K.Genser Made GetMuonCaptureRate and
// GetMuonDecayRate public static
// 04/30/2013 K.Genser Added GetMuonZeff
//
//
//-----------------------------------------------------------------------------
@@ -77,12 +81,14 @@ public:
void ModelDescription(std::ostream& outFile) const;
static G4double GetMuonCaptureRate(G4int Z, G4int A);
static G4double GetMuonDecayRate(G4int Z);
static G4double GetMuonZeff(G4int Z);
private:
G4double GetMuonCaptureRate(G4int Z, G4int A);
G4double GetMuonDecayRate(G4int Z);
inline void AddNewParticle(G4DynamicParticle* dp, G4double time);
// hide assignment operator as private
source/processes/hadronic/stopping/include/G4MuonMinusCapture.hh
+1 -1
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4MuonMinusCapture.hh 66367 2012-12-18 09:18:08Z gcosmo $
//
//---------------------------------------------------------------------
//
source/processes/hadronic/stopping/include/G4MuonMinusCaptureAtRest.hh
+1 -1
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4MuonMinusCaptureAtRest.hh 66367 2012-12-18 09:18:08Z gcosmo $
//
// G4MuonMinusCaptureAtRest physics process
// Larry Felawka (TRIUMF) and Art Olin (TRIUMF) April 1998
source/processes/hadronic/stopping/include/G4NeutronCaptureAtRest.hh
-123
View File
@@ -1,123 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// G4NeutronCaptureAtRest physics process
// Larry Felawka (TRIUMF), April 1998
//---------------------------------------------------------------------
#ifndef G4NeutronCaptureAtRest_h
#define G4NeutronCaptureAtRest_h 1
// Class Description:
//
// Process for capture of neutrons at rest.
// To be used in your physics list in case you need this physics.
#include "globals.hh"
#include "Randomize.hh"
#include "G4VRestProcess.hh"
#include "G4VParticleChange.hh"
#include "G4ParticleDefinition.hh"
#include "G4GHEKinematicsVector.hh"
#include "G4HadronicProcessType.hh"
class G4NeutronCaptureAtRest : public G4VRestProcess
{
private:
// hide assignment operator as private
G4NeutronCaptureAtRest& operator=(const G4NeutronCaptureAtRest &right);
G4NeutronCaptureAtRest(const G4NeutronCaptureAtRest& );
public:
G4NeutronCaptureAtRest(const G4String& processName ="NeutronCaptureAtRest",
G4ProcessType aType = fHadronic );
~G4NeutronCaptureAtRest();
G4bool IsApplicable(const G4ParticleDefinition&);
void PreparePhysicsTable(const G4ParticleDefinition&);
// null physics table
void BuildPhysicsTable(const G4ParticleDefinition&);
G4double AtRestGetPhysicalInteractionLength(const G4Track&,
G4ForceCondition*);
// zero mean lifetime
G4double GetMeanLifeTime(const G4Track& ,
G4ForceCondition* ) {return 0.0;}
G4VParticleChange* AtRestDoIt(const G4Track&, const G4Step&);
// return number of secondaries produced
G4int GetNumberOfSecondaries();
// pointer to array containg kinematics of secondaries
G4GHEKinematicsVector* GetSecondaryKinematics();
private:
void GenerateSecondaries();
void Normal( G4float* );
void NeutronCapture( G4int* );
G4double AtomAs( G4float, G4float );
private:
// global time-of-flight of stopped hadron
G4float globalTime;
// atomic mass of target nucleus
G4float targetAtomicMass;
// charge of target nucleus
G4float targetCharge;
G4GHEKinematicsVector* pv;
G4GHEKinematicsVector* eve;
G4GHEKinematicsVector* gkin;
G4int ngkine;
G4int ntot;
G4GHEKinematicsVector result;
G4float massProton;
G4float massNeutron;
G4float massElectron;
G4float massDeuteron;
G4float massAlpha;
G4ParticleDefinition* pdefGamma;
G4ParticleDefinition* pdefNeutron;
};
#endif
source/processes/hadronic/stopping/include/G4PiMinusAbsorptionAtRest.hh
-108
View File
@@ -1,108 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusAbsorptionAtRest.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 9 May 1998
//
// -------------------------------------------------------------------
#ifndef G4PIMINUSABSORPTIONATREST_HH
#define G4PIMINUSABSORPTIONATREST_HH
// Class Description:
//
// Alternative Process for absorption of pi- at rest.
// To be used in your physics list in case you need this physics.
#include "globals.hh"
#include "G4VRestProcess.hh"
#include "G4ParticleTypes.hh"
#include "G4PiMinusStopMaterial.hh"
#include "G4PiMinusStopAbsorption.hh"
#include "G4StopDeexcitation.hh"
#include "G4StopDeexcitationAlgorithm.hh"
#include "G4HadronicProcessType.hh"
class G4DynamicParticle;
class G4PiMinusAbsorptionAtRest : public G4VRestProcess
{
private:
// Hide assignment operator as private
G4PiMinusAbsorptionAtRest& operator=(const G4PiMinusAbsorptionAtRest &right);
// Copy constructor
G4PiMinusAbsorptionAtRest(const G4PiMinusAbsorptionAtRest& );
public:
// Constructor
G4PiMinusAbsorptionAtRest(const G4String& processName ="PiMinusAbsorptionAtRest",
G4ProcessType aType = fHadronic );
// Destructor
~G4PiMinusAbsorptionAtRest();
G4bool IsApplicable(const G4ParticleDefinition& particle)
{ return ( particle == *(G4PionMinus::PionMinus()) ); }
void PreparePhysicsTable(const G4ParticleDefinition&);
void BuildPhysicsTable(const G4ParticleDefinition&);
G4VParticleChange* AtRestDoIt(const G4Track& aTrack, const G4Step& aStep);
void SetDeexcitationAlgorithm(G4int index);
protected:
// zero mean lifetime
G4double GetMeanLifeTime(const G4Track& aTrack,
G4ForceCondition* )
{
G4double result = 0;
if(aTrack.GetMaterial()->GetNumberOfElements() == 1)
if(aTrack.GetMaterial()->GetZ()<1.5) result = DBL_MAX;
return result;
}
private:
// G4PiMinusStopAbsorption* _stopAbsorption;
// G4StopDeexcitation* _stopDeexcitation;
G4int _indexDeexcitation;
G4PiMinusStopMaterial* LoadAlgorithm(int Z);
G4StopDeexcitationAlgorithm* LoadNucleusAlgorithm();
};
#endif
source/processes/hadronic/stopping/include/G4PiMinusStopAbsorption.hh
-111
View File
@@ -1,111 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusStopAbsorption.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 12 May 1998
//
// Modifications:
// 13 Sep 1998 - Changed DoAbsorption
//
// -------------------------------------------------------------------
#ifndef G4PIMINUSSTOPABSORPTION_HH
#define G4PIMINUSSTOPABSORPTION_HH
#include "globals.hh"
#include "G4DynamicParticle.hh"
#include "G4DynamicParticleVector.hh"
#include "G4PiMinusStopMaterial.hh"
#include "G4ThreeVector.hh"
class G4PiMinusStopAbsorption
{
public:
// Constructor
G4PiMinusStopAbsorption(G4PiMinusStopMaterial* materialAlgo, const G4double Z, const G4double A);
// Destructor
~G4PiMinusStopAbsorption();
// Return final absorption products
G4DynamicParticleVector* DoAbsorption();
// Energy involved in the absorption process
G4double Energy();
// Return nucleus recoil momentum
G4ThreeVector RecoilMomentum();
// Number of protons in the absorption products
G4int NProtons();
// Number of neutrons in the absorption products
G4int NNeutrons();
void SetVerboseLevel(G4int level);
private:
// Hide assignment operator as private
G4PiMinusStopAbsorption& operator=(const G4PiMinusStopAbsorption &right);
// Copy constructor
G4PiMinusStopAbsorption(const G4PiMinusStopAbsorption& );
G4PiMinusStopMaterial* _materialAlgo; // owned pointer
G4DynamicParticleVector* _absorptionProducts;
G4double _nucleusA;
G4double _nucleusZ;
G4int _level;
};
#endif
source/processes/hadronic/stopping/include/G4PiMinusStopAl.hh
-87
View File
@@ -1,87 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusStopAl.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// -------------------------------------------------------------------
#ifndef G4PIMINUSSTOPAL_HH
#define G4PIMINUSSTOPAL_HH
#include "G4PiMinusStopMaterial.hh"
#include "globals.hh"
#include "G4LorentzVector.hh"
class G4PiMinusStopAl : public G4PiMinusStopMaterial
{
private:
// Hide assignment operator as private
G4PiMinusStopAl& operator=(const G4PiMinusStopAl &right);
// Copy constructor
G4PiMinusStopAl(const G4PiMinusStopAl& );
public:
// Constructor
G4PiMinusStopAl();
// Destructor
virtual ~G4PiMinusStopAl();
// Number of final nucleons, out of generated absorption products
virtual G4double FinalNucleons();
private:
static G4int eKinEntries;
static G4int angleEntries;
static G4double npRatio;
static G4double nFinalNucleons;
static G4double eMaxTot;
static G4double eKinData[10];
static G4double eKin[11];
static G4double angleData[7];
static G4double angle[8];
G4double _clusterSize;
};
#endif
source/processes/hadronic/stopping/include/G4PiMinusStopC.hh
-85
View File
@@ -1,85 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusStopC.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// -------------------------------------------------------------------
#ifndef G4PIMINUSSTOPC_HH
#define G4PIMINUSSTOPC_HH
#include "G4PiMinusStopMaterial.hh"
#include "globals.hh"
#include "G4LorentzVector.hh"
class G4PiMinusStopC : public G4PiMinusStopMaterial
{
private:
// Hide assignment operator as private
G4PiMinusStopC& operator=(const G4PiMinusStopC &right);
// Copy constructor
G4PiMinusStopC(const G4PiMinusStopC& );
public:
// Constructor
G4PiMinusStopC();
// Destructor
virtual ~G4PiMinusStopC();
// Number of final nucleons, out of generated absorption products
virtual G4double FinalNucleons();
private:
static G4int eKinEntries;
static G4int angleEntries;
static G4double npRatio;
static G4double nFinalNucleons;
static G4double eKinData[21];
static G4double eKin[22];
static G4double angleData[7];
static G4double angle[8];
G4double _clusterSize;
};
#endif
source/processes/hadronic/stopping/include/G4PiMinusStopCo.hh
-87
View File
@@ -1,87 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusStopCo.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// -------------------------------------------------------------------
#ifndef G4PIMINUSSTOPCO_HH
#define G4PIMINUSSTOPCO_HH
#include "G4PiMinusStopMaterial.hh"
#include "globals.hh"
#include "G4LorentzVector.hh"
class G4PiMinusStopCo : public G4PiMinusStopMaterial
{
private:
// Hide assignment operator as private
G4PiMinusStopCo& operator=(const G4PiMinusStopCo &right);
// Copy constructor
G4PiMinusStopCo(const G4PiMinusStopCo& );
public:
// Constructor
G4PiMinusStopCo();
// Destructor
virtual ~G4PiMinusStopCo();
// Number of final nucleons, out of generated absorption products
virtual G4double FinalNucleons();
private:
static G4int eKinEntries;
static G4int angleEntries;
static G4double npRatio;
static G4double nFinalNucleons;
static G4double eMaxTot;
static G4double eKinData[11];
static G4double eKin[12];
static G4double angleData[7];
static G4double angle[8];
G4double _clusterSize;
};
#endif
source/processes/hadronic/stopping/include/G4PiMinusStopCu.hh
-87
View File
@@ -1,87 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusStopCu.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// -------------------------------------------------------------------
#ifndef G4PIMINUSSTOPCU_HH
#define G4PIMINUSSTOPCU_HH
#include "G4PiMinusStopMaterial.hh"
#include "globals.hh"
#include "G4LorentzVector.hh"
class G4PiMinusStopCu : public G4PiMinusStopMaterial
{
private:
// Hide assignment operator as private
G4PiMinusStopCu& operator=(const G4PiMinusStopCu &right);
// Copy constructor
G4PiMinusStopCu(const G4PiMinusStopCu& );
public:
// Constructor
G4PiMinusStopCu();
// Destructor
virtual ~G4PiMinusStopCu();
// Number of final nucleons, out of generated absorption products
virtual G4double FinalNucleons();
private:
static G4int eKinEntries;
static G4int angleEntries;
static G4double npRatio;
static G4double nFinalNucleons;
static G4double eMaxTot;
static G4double eKinData[10];
static G4double eKin[11];
static G4double angleData[7];
static G4double angle[8];
G4double _clusterSize;
};
#endif
source/processes/hadronic/stopping/include/G4PiMinusStopLi.hh
-87
View File
@@ -1,87 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusStopLi.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// -------------------------------------------------------------------
#ifndef G4PIMINUSSTOPLI_HH
#define G4PIMINUSSTOPLI_HH
#include "G4PiMinusStopMaterial.hh"
#include "globals.hh"
#include "G4LorentzVector.hh"
class G4PiMinusStopLi : public G4PiMinusStopMaterial
{
private:
// Hide assignment operator as private
G4PiMinusStopLi& operator=(const G4PiMinusStopLi &right);
// Copy constructor
G4PiMinusStopLi(const G4PiMinusStopLi& );
public:
// Constructor
G4PiMinusStopLi();
// Destructor
virtual ~G4PiMinusStopLi();
// Number of final nucleons, out of generated absorption products
virtual G4double FinalNucleons();
private:
static G4int eKinEntries;
static G4int angleEntries;
static G4double npRatio;
static G4double nFinalNucleons;
static G4double eMaxTot;
static G4double eKinData[21];
static G4double eKin[22];
static G4double angleData[7];
static G4double angle[8];
G4double _clusterSize;
};
#endif
source/processes/hadronic/stopping/include/G4PiMinusStopMaterial.hh
-96
View File
@@ -1,96 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
//
// File name: G4PiMinusStopMaterial.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// Modifications:
// 13 Sep 1998 - MGP Modified P4Vector
//
// -------------------------------------------------------------------
#ifndef G4PIMINUSSTOPMATERIAL_HH
#define G4PIMINUSSTOPMATERIAL_HH
#include "globals.hh"
#include "G4LorentzVector.hh"
//#include "G4String.hh"
#include "G4DistributionGenerator.hh"
#include "G4ParticleDefinition.hh"
class G4PiMinusStopMaterial
{
private:
// Hide assignment operator as private
G4PiMinusStopMaterial& operator=(const G4PiMinusStopMaterial &right);
// Copy constructor
G4PiMinusStopMaterial(const G4PiMinusStopMaterial& );
public:
// Constructor
G4PiMinusStopMaterial();
// Destructor
virtual ~G4PiMinusStopMaterial();
// Definitions of absorption products
virtual std::vector<G4ParticleDefinition*>* DefinitionVector();
// 4-vectors of absorption products
virtual std::vector<G4LorentzVector*>* P4Vector(const G4double binding,
const G4double mass);
// Number of final nucleons, out of generated absorption products
virtual G4double FinalNucleons()=0;
protected:
std::vector<G4ParticleDefinition* >* _definitions;
std::vector<G4LorentzVector* >* _momenta;
G4DistributionGenerator* _distributionE;
G4DistributionGenerator* _distributionAngle;
G4double theR;
G4double GenerateAngle(G4double range);
G4LorentzVector MakeP4(G4double p, G4double theta,
G4double phi, G4double e);
G4double RecoilEnergy(const G4double mass);
private:
};
#endif
source/processes/hadronic/stopping/include/G4PiMinusStopN.hh
-87
View File
@@ -1,87 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusStopN.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// -------------------------------------------------------------------
#ifndef G4PIMINUSSTOPN_HH
#define G4PIMINUSSTOPN_HH
#include "G4PiMinusStopMaterial.hh"
#include "globals.hh"
#include "G4LorentzVector.hh"
class G4PiMinusStopN : public G4PiMinusStopMaterial
{
private:
// Hide assignment operator as private
G4PiMinusStopN& operator=(const G4PiMinusStopN &right);
// Copy constructor
G4PiMinusStopN(const G4PiMinusStopN& );
public:
// Constructor
G4PiMinusStopN();
// Destructor
virtual ~G4PiMinusStopN();
// Number of final nucleons, out of generated absorption products
virtual G4double FinalNucleons();
private:
static G4int eKinEntries;
static G4int angleEntries;
static G4double npRatio;
static G4double nFinalNucleons;
static G4double eMaxTot;
static G4double eKinData[10];
static G4double eKin[11];
static G4double angleData[7];
static G4double angle[8];
G4double _clusterSize;
};
#endif
source/processes/hadronic/stopping/include/G4PiMinusStopO.hh
-87
View File
@@ -1,87 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusStopO.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// -------------------------------------------------------------------
#ifndef G4PIMINUSSTOPO_HH
#define G4PIMINUSSTOPO_HH
#include "G4PiMinusStopMaterial.hh"
#include "globals.hh"
#include "G4LorentzVector.hh"
class G4PiMinusStopO : public G4PiMinusStopMaterial
{
private:
// Hide assignment operator as private
G4PiMinusStopO& operator=(const G4PiMinusStopO &right);
// Copy constructor
G4PiMinusStopO(const G4PiMinusStopO& );
public:
// Constructor
G4PiMinusStopO();
// Destructor
virtual ~G4PiMinusStopO();
// Number of final nucleons, out of generated absorption products
virtual G4double FinalNucleons();
private:
static G4int eKinEntries;
static G4int angleEntries;
static G4double npRatio;
static G4double nFinalNucleons;
static G4double eMaxTot;
static G4double eKinData[10];
static G4double eKin[11];
static G4double angleData[7];
static G4double angle[8];
G4double _clusterSize;
};
#endif
source/processes/hadronic/stopping/include/G4PiMinusStopPb.hh
-87
View File
@@ -1,87 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusStopPb.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// -------------------------------------------------------------------
#ifndef G4PIMINUSSTOPPB_HH
#define G4PIMINUSSTOPPB_HH
#include "G4PiMinusStopMaterial.hh"
#include "globals.hh"
#include "G4LorentzVector.hh"
class G4PiMinusStopPb : public G4PiMinusStopMaterial
{
private:
// Hide assignment operator as private
G4PiMinusStopPb& operator=(const G4PiMinusStopPb &right);
// Copy constructor
G4PiMinusStopPb(const G4PiMinusStopPb& );
public:
// Constructor
G4PiMinusStopPb();
// Destructor
virtual ~G4PiMinusStopPb();
// Number of final nucleons, out of generated absorption products
virtual G4double FinalNucleons();
private:
static G4int eKinEntries;
static G4int angleEntries;
static G4double npRatio;
static G4double nFinalNucleons;
static G4double eMaxTot;
static G4double eKinData[10];
static G4double eKin[11];
static G4double angleData[7];
static G4double angle[8];
G4double _clusterSize;
};
#endif
source/processes/hadronic/stopping/include/G4PiMinusStopTa.hh
-87
View File
@@ -1,87 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusStopTa.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// -------------------------------------------------------------------
#ifndef G4PIMINUSSTOPTA_HH
#define G4PIMINUSSTOPTA_HH
#include "G4PiMinusStopMaterial.hh"
#include "globals.hh"
#include "G4LorentzVector.hh"
class G4PiMinusStopTa : public G4PiMinusStopMaterial
{
private:
// Hide assignment operator as private
G4PiMinusStopTa& operator=(const G4PiMinusStopTa &right);
// Copy constructor
G4PiMinusStopTa(const G4PiMinusStopTa& );
public:
// Constructor
G4PiMinusStopTa();
// Destructor
virtual ~G4PiMinusStopTa();
// Number of final nucleons, out of generated absorption products
virtual G4double FinalNucleons();
private:
static G4int eKinEntries;
static G4int angleEntries;
static G4double npRatio;
static G4double nFinalNucleons;
static G4double eMaxTot;
static G4double eKinData[10];
static G4double eKin[11];
static G4double angleData[7];
static G4double angle[8];
G4double _clusterSize;
};
#endif
source/processes/hadronic/stopping/include/G4PionMinusAbsorptionAtRest.hh
-129
View File
@@ -1,129 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// G4PionMinusAbsorptionAtRest physics process
// Larry Felawka (TRIUMF), April 1998
//---------------------------------------------------------------------
#ifndef G4PionMinusAbsorptionAtRest_h
#define G4PionMinusAbsorptionAtRest_h 1
// Class Description:
//
// Process for pi- absorption at rest.
// To be used in your physics list in case you need this physics.
#include "globals.hh"
#include "Randomize.hh"
#include "G4VRestProcess.hh"
#include "G4VParticleChange.hh"
#include "G4ParticleDefinition.hh"
#include "G4GHEKinematicsVector.hh"
#include "G4HadronicProcessType.hh"
class G4PionMinusAbsorptionAtRest : public G4VRestProcess
{
private:
// hide assignment operator as private
G4PionMinusAbsorptionAtRest& operator=(const G4PionMinusAbsorptionAtRest &right);
G4PionMinusAbsorptionAtRest(const G4PionMinusAbsorptionAtRest& );
public:
G4PionMinusAbsorptionAtRest(const G4String& processName ="PionMinusAbsorptionAtRest",
G4ProcessType aType = fHadronic);
~G4PionMinusAbsorptionAtRest();
G4bool IsApplicable(const G4ParticleDefinition&);
void PreparePhysicsTable(const G4ParticleDefinition&);
// null physics table
void BuildPhysicsTable(const G4ParticleDefinition&);
G4double AtRestGetPhysicalInteractionLength(const G4Track&,
G4ForceCondition*);
// zero mean lifetime
G4double GetMeanLifeTime(const G4Track& ,
G4ForceCondition* ) {return 0.0;}
G4VParticleChange* AtRestDoIt(const G4Track&, const G4Step&);
// return number of secondaries produced
G4int GetNumberOfSecondaries();
// pointer to array containg kinematics of secondaries
G4GHEKinematicsVector* GetSecondaryKinematics();
private:
void GenerateSecondaries();
void PionMinusAbsorption( G4int* );
void Poisso( G4float, G4int* );
void Normal( G4float* );
G4double ExNu( G4float );
G4int NFac( G4int );
private:
// global time-of-flight of stopped PionMinus
G4float globalTime;
// atomic mass of target nucleus
G4float targetAtomicMass;
// charge of target nucleus
G4float targetCharge;
G4GHEKinematicsVector* pv;
G4GHEKinematicsVector* eve;
G4GHEKinematicsVector* gkin;
G4float evapEnergy1;
G4float evapEnergy3;
G4int ngkine;
G4int ntot;
G4GHEKinematicsVector result;
G4float massPionMinus;
G4ParticleDefinition* pdefGamma;
G4ParticleDefinition* pdefPionZero;
G4ParticleDefinition* pdefPionMinus;
G4ParticleDefinition* pdefProton;
G4ParticleDefinition* pdefNeutron;
G4ParticleDefinition* pdefDeuteron;
G4ParticleDefinition* pdefTriton;
G4ParticleDefinition* pdefAlpha;
};
#endif
source/processes/hadronic/stopping/include/G4StopDeexcitation.hh
-91
View File
@@ -1,91 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4StopDeexcitation.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 12 May 1998
//
// -------------------------------------------------------------------
#ifndef G4STOPDEEXCITATION_HH
#define G4STOPDEEXCITATION_HH
#include "globals.hh"
#include "G4ReactionProduct.hh"
#include "G4ReactionProductVector.hh"
#include "G4ThreeVector.hh"
#include "G4StopDeexcitationAlgorithm.hh"
class G4StopDeexcitation
{
public:
// Constructor
G4StopDeexcitation(G4StopDeexcitationAlgorithm* algorithm);
// Destructor
~G4StopDeexcitation();
// Return final absorption products
G4ReactionProductVector* DoBreakUp(G4double A, G4double Z,
G4double excitation, const G4ThreeVector& p) const;
private:
// Hide assignment operator as private
G4StopDeexcitation& operator=(const G4StopDeexcitation &right);
// Copy constructor
G4StopDeexcitation(const G4StopDeexcitation& );
G4StopDeexcitationAlgorithm* _algorithm; // owned pointer
};
#endif
source/processes/hadronic/stopping/include/G4StopDeexcitationAlgorithm.hh
-77
View File
@@ -1,77 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4StopDeexcitationAlgorithm.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// -------------------------------------------------------------------
#ifndef G4STOPDEEXCITATIONALGORITHM_HH
#define G4STOPDEEXCITATIONALGORITHM_HH
#include "globals.hh"
#include "G4ReactionProduct.hh"
#include "G4ReactionProductVector.hh"
#include "G4ThreeVector.hh"
#include "G4HadronicDeprecate.hh"
#include "G4ios.hh"
class G4StopDeexcitationAlgorithm
{
private:
// Hide assignment operator as private
G4StopDeexcitationAlgorithm& operator=(const G4StopDeexcitationAlgorithm &right);
// Copy constructor
G4StopDeexcitationAlgorithm(const G4StopDeexcitationAlgorithm& );
public:
// Constructor
G4StopDeexcitationAlgorithm() {
G4HadronicDeprecate("G4StopDeexcitationAlgorithm");
}
// Destructor
virtual ~G4StopDeexcitationAlgorithm() {};
// Products
virtual G4ReactionProductVector* BreakUp(G4double A, G4double Z,
G4double excitation, const G4ThreeVector& p) =0;
protected:
private:
};
#endif
source/processes/hadronic/stopping/include/G4StopDummyDeexcitation.hh
-76
View File
@@ -1,76 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4StopDummyDeexcitation.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// -------------------------------------------------------------------
#ifndef G4STOPDUMMYDEEXCITATION_HH
#define G4STOPDUMMYDEEXCITATION_HH
#include "G4StopDeexcitationAlgorithm.hh"
#include "globals.hh"
#include "G4ReactionProduct.hh"
#include "G4ReactionProductVector.hh"
#include "G4ThreeVector.hh"
class G4StopDummyDeexcitation: public G4StopDeexcitationAlgorithm
{
private:
// Hide assignment operator as private
G4StopDummyDeexcitation& operator=(const G4StopDummyDeexcitation &right);
// Copy constructor
G4StopDummyDeexcitation(const G4StopDummyDeexcitation& );
public:
// Constructor
G4StopDummyDeexcitation();
// Destructor
virtual ~G4StopDummyDeexcitation();
// Products
virtual G4ReactionProductVector* BreakUp(G4double A, G4double Z,
G4double excitation, const G4ThreeVector& p);
protected:
private:
G4ReactionProductVector* _products;
};
#endif
source/processes/hadronic/stopping/include/G4StopElementSelector.hh
+1 -1
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4StopElementSelector.hh 66367 2012-12-18 09:18:08Z gcosmo $
//
// Author: V.Ivanchenko (Vladimir.Ivantchenko@cern.ch)
//
source/processes/hadronic/stopping/include/G4StopTheoDeexcitation.hh
-73
View File
@@ -1,73 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4StopTheoDeexcitation.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// -------------------------------------------------------------------
#ifndef G4STOPTHEODEEXCITATION_HH
#define G4STOPTHEODEEXCITATION_HH
#include "G4StopDeexcitationAlgorithm.hh"
#include "globals.hh"
#include "G4DynamicParticle.hh"
#include "G4DynamicParticleVector.hh"
#include "G4ThreeVector.hh"
class G4StopTheoDeexcitation: public G4StopDeexcitationAlgorithm
{
private:
// Hide assignment operator as private
G4StopTheoDeexcitation& operator=(const G4StopTheoDeexcitation &right);
// Copy constructor
G4StopTheoDeexcitation(const G4StopTheoDeexcitation& );
public:
// Constructor
G4StopTheoDeexcitation();
// Destructor
virtual ~G4StopTheoDeexcitation();
// Products
virtual G4ReactionProductVector* BreakUp(G4double A, G4double Z,
G4double excitation, const G4ThreeVector& p);
protected:
private:
};
#endif
source/processes/hadronic/stopping/sources.cmake
+2 -49
View File
@@ -11,7 +11,7 @@
#
# Generated on : 24/9/2010
#
# $Id: sources.cmake,v 1.1 2010-09-29 19:08:23 bmorgan Exp $
# $Id: sources.cmake 76309 2013-11-08 13:48:42Z gcosmo $
#
#------------------------------------------------------------------------------
@@ -48,7 +48,6 @@ include_directories(${CMAKE_SOURCE_DIR}/source/processes/hadronic/models/parton_
include_directories(${CMAKE_SOURCE_DIR}/source/processes/hadronic/models/parton_string/hadronization/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/hadronic/models/parton_string/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/hadronic/models/theo_high_energy/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/hadronic/models/high_energy/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/hadronic/models/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/hadronic/models/pre_equilibrium/exciton_model/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/hadronic/models/util/include)
@@ -65,77 +64,34 @@ GEANT4_DEFINE_MODULE(NAME G4hadronic_stop
HEADERS
G4AntiNeutronAnnihilationAtRest.hh
G4AntiProtonAbsorptionFritiof.hh
G4AntiProtonAnnihilationAtRest.hh
G4AntiSigmaPlusAbsorptionFritiof.hh
G4DistributionGenerator.hh
G4ElementSelector.hh
G4EmCaptureCascade.hh
G4HadronicAbsorptionFritiof.hh
G4HadronStoppingProcess.hh
G4KaonMinusAbsorption.hh
G4KaonMinusAbsorptionAtRest.hh
G4MuMinusCaptureCascade.hh
G4MuMinusCapturePrecompound.hh
G4MuonMinusBoundDecay.hh
G4MuonMinusCapture.hh
G4MuonMinusCaptureAtRest.hh
G4NeutronCaptureAtRest.hh
G4PiMinusAbsorptionAtRest.hh
G4HadronicAbsorptionBertini.hh
G4PiMinusAbsorptionBertini.hh
G4KaonMinusAbsorptionBertini.hh
G4SigmaMinusAbsorptionBertini.hh
G4PiMinusStopAbsorption.hh
G4PiMinusStopAl.hh
G4PiMinusStopC.hh
G4PiMinusStopCo.hh
G4PiMinusStopCu.hh
G4PiMinusStopLi.hh
G4PiMinusStopMaterial.hh
G4PiMinusStopN.hh
G4PiMinusStopO.hh
G4PiMinusStopPb.hh
G4PiMinusStopTa.hh
G4PionMinusAbsorptionAtRest.hh
G4StopDeexcitation.hh
G4StopDeexcitationAlgorithm.hh
G4StopDummyDeexcitation.hh
G4StopElementSelector.hh
G4StopTheoDeexcitation.hh
SOURCES
G4AntiNeutronAnnihilationAtRest.cc
G4AntiProtonAnnihilationAtRest.cc
G4DistributionGenerator.cc
G4ElementSelector.cc
G4EmCaptureCascade.cc
G4HadronicAbsorptionFritiof.cc
G4HadronStoppingProcess.cc
G4KaonMinusAbsorption.cc
G4KaonMinusAbsorptionAtRest.cc
G4MuMinusCaptureCascade.cc
G4MuMinusCapturePrecompound.cc
G4MuonMinusBoundDecay.cc
G4MuonMinusCapture.cc
G4MuonMinusCaptureAtRest.cc
G4NeutronCaptureAtRest.cc
G4PiMinusAbsorptionAtRest.cc
G4HadronicAbsorptionBertini.cc
G4PiMinusStopAbsorption.cc
G4PiMinusStopAl.cc
G4PiMinusStopC.cc
G4PiMinusStopCo.cc
G4PiMinusStopCu.cc
G4PiMinusStopLi.cc
G4PiMinusStopMaterial.cc
G4PiMinusStopN.cc
G4PiMinusStopO.cc
G4PiMinusStopPb.cc
G4PiMinusStopTa.cc
G4PionMinusAbsorptionAtRest.cc
G4StopDeexcitation.cc
G4StopDummyDeexcitation.cc
G4StopElementSelector.cc
G4StopTheoDeexcitation.cc
GRANULAR_DEPENDENCIES
G4baryons
G4bosons
@@ -148,11 +104,8 @@ GEANT4_DEFINE_MODULE(NAME G4hadronic_stop
G4had_string_frag
G4had_string_man
G4had_theo_max
G4hadronic_HE
G4hadronic_binary
G4hadronic_bert_cascade
G4hadronic_body_ci
G4hadronic_crosec_ci
G4hadronic_bert_cascade
G4hadronic_deex_evaporation
G4hadronic_deex_fermi_breakup
G4hadronic_deex_fission
source/processes/hadronic/stopping/src/G4AntiNeutronAnnihilationAtRest.cc
+29 -28
View File
@@ -23,6 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4AntiNeutronAnnihilationAtRest.cc 66872 2013-01-15 01:25:57Z japost $
// G4AntiNeutronAnnihilationAtRest physics process
// Larry Felawka (TRIUMF), April 1998
//---------------------------------------------------------------------
@@ -235,10 +236,10 @@ G4VParticleChange* G4AntiNeutronAnnihilationAtRest::AtRestDoIt(
void G4AntiNeutronAnnihilationAtRest::GenerateSecondaries()
{
static G4int index;
static G4int l;
static G4int nopt;
static G4int i;
static G4ThreadLocal G4int index;
static G4ThreadLocal G4int l;
static G4ThreadLocal G4int nopt;
static G4ThreadLocal G4int i;
// DHW 15 May 2011: unused: static G4ParticleDefinition* jnd;
for (i = 1; i <= MAX_SECONDARIES; ++i) {
@@ -303,10 +304,10 @@ void G4AntiNeutronAnnihilationAtRest::GenerateSecondaries()
void G4AntiNeutronAnnihilationAtRest::Poisso(G4float xav, G4int *iran)
{
static G4int i;
static G4float r, p1, p2, p3;
static G4int fivex;
static G4float rr, ran, rrr, ran1;
static G4ThreadLocal G4int i;
static G4ThreadLocal G4float r, p1, p2, p3;
static G4ThreadLocal G4int fivex;
static G4ThreadLocal G4float rr, ran, rrr, ran1;
// *** GENERATION OF POISSON DISTRIBUTION ***
// *** NVE 16-MAR-1988 CERN GENEVA ***
@@ -380,7 +381,7 @@ G4int G4AntiNeutronAnnihilationAtRest::NFac(G4int n)
{
G4int ret_val;
static G4int i, j;
static G4ThreadLocal G4int i, j;
// *** NVE 16-MAR-1988 CERN GENEVA ***
// ORIGIN : H.FESEFELDT (27-OCT-1983)
@@ -402,7 +403,7 @@ G4int G4AntiNeutronAnnihilationAtRest::NFac(G4int n)
void G4AntiNeutronAnnihilationAtRest::Normal(G4float *ran)
{
static G4int i;
static G4ThreadLocal G4int i;
// *** NVE 14-APR-1988 CERN GENEVA ***
// ORIGIN : H.FESEFELDT (27-OCT-1983)
@@ -417,24 +418,24 @@ void G4AntiNeutronAnnihilationAtRest::Normal(G4float *ran)
void G4AntiNeutronAnnihilationAtRest::AntiNeutronAnnihilation(G4int *nopt)
{
static G4float brr[3] = { G4float(.125),G4float(.25),G4float(.5) };
static G4ThreadLocal G4float brr[3] = { G4float(.125),G4float(.25),G4float(.5) };
G4float r__1;
static G4int i, ii, kk;
static G4int nt;
static G4float cfa, eka;
static G4int ika, nbl;
static G4float ran, pcm;
static G4int isw;
static G4float tex;
static G4ParticleDefinition* ipa1;
static G4float ran1, ran2, ekin, tkin;
static G4float targ;
static G4ParticleDefinition* inve;
static G4float ekin1, ekin2, black;
static G4float pnrat, rmnve1, rmnve2;
static G4float ek, en;
static G4ThreadLocal G4int i, ii, kk;
static G4ThreadLocal G4int nt;
static G4ThreadLocal G4float cfa, eka;
static G4ThreadLocal G4int ika, nbl;
static G4ThreadLocal G4float ran, pcm;
static G4ThreadLocal G4int isw;
static G4ThreadLocal G4float tex;
static G4ThreadLocal G4ParticleDefinition* ipa1;
static G4ThreadLocal G4float ran1, ran2, ekin, tkin;
static G4ThreadLocal G4float targ;
static G4ThreadLocal G4ParticleDefinition* inve;
static G4ThreadLocal G4float ekin1, ekin2, black;
static G4ThreadLocal G4float pnrat, rmnve1, rmnve2;
static G4ThreadLocal G4float ek, en;
// *** ANTI NEUTRON ANNIHILATION AT REST ***
// *** NVE 04-MAR-1988 CERN GENEVA ***
@@ -679,9 +680,9 @@ G4double G4AntiNeutronAnnihilationAtRest::ExNu(G4float ek1)
{
G4float ret_val, r__1;
static G4float cfa, gfa, ran1, ran2, ekin1, atno3;
static G4int magic;
static G4float fpdiv;
static G4ThreadLocal G4float cfa, gfa, ran1, ran2, ekin1, atno3;
static G4ThreadLocal G4int magic;
static G4ThreadLocal G4float fpdiv;
// *** NUCLEAR EVAPORATION AS FUNCTION OF ATOMIC NUMBER ATNO ***
// *** AND KINETIC ENERGY EKIN OF PRIMARY PARTICLE ***
source/processes/hadronic/stopping/src/G4AntiProtonAnnihilationAtRest.cc
-747
View File
@@ -1,747 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// G4AntiProtonAnnihilationAtRest physics process
// Larry Felawka (TRIUMF), April 1998
//---------------------------------------------------------------------
#include <string.h>
#include <cmath>
#include <stdio.h>
#include "G4AntiProtonAnnihilationAtRest.hh"
#include "G4SystemOfUnits.hh"
#include "G4DynamicParticle.hh"
#include "G4ParticleTypes.hh"
#include "Randomize.hh"
#include "G4HadronicProcessStore.hh"
#include "G4HadronicDeprecate.hh"
#define MAX_SECONDARIES 100
// constructor
G4AntiProtonAnnihilationAtRest::G4AntiProtonAnnihilationAtRest(const G4String& processName,
G4ProcessType aType ) :
G4VRestProcess (processName, aType), // initialization
massPionMinus(G4PionMinus::PionMinus()->GetPDGMass()/GeV),
massProton(G4Proton::Proton()->GetPDGMass()/GeV),
massPionZero(G4PionZero::PionZero()->GetPDGMass()/GeV),
massAntiProton(G4AntiProton::AntiProton()->GetPDGMass()/GeV),
massPionPlus(G4PionPlus::PionPlus()->GetPDGMass()/GeV),
massGamma(G4Gamma::Gamma()->GetPDGMass()/GeV),
pdefGamma(G4Gamma::Gamma()),
pdefPionPlus(G4PionPlus::PionPlus()),
pdefPionZero(G4PionZero::PionZero()),
pdefPionMinus(G4PionMinus::PionMinus()),
pdefProton(G4Proton::Proton()),
pdefAntiProton(G4AntiProton::AntiProton()),
pdefNeutron(G4Neutron::Neutron()),
pdefDeuteron(G4Deuteron::Deuteron()),
pdefTriton(G4Triton::Triton()),
pdefAlpha(G4Alpha::Alpha())
{
G4HadronicDeprecate("G4AntiProtonAnnihilationAtRest");
if (verboseLevel>0) {
G4cout << GetProcessName() << " is created "<< G4endl;
}
SetProcessSubType(fHadronAtRest);
pv = new G4GHEKinematicsVector [MAX_SECONDARIES+1];
eve = new G4GHEKinematicsVector [MAX_SECONDARIES];
gkin = new G4GHEKinematicsVector [MAX_SECONDARIES];
G4HadronicProcessStore::Instance()->RegisterExtraProcess(this);
}
// destructor
G4AntiProtonAnnihilationAtRest::~G4AntiProtonAnnihilationAtRest()
{
G4HadronicProcessStore::Instance()->DeRegisterExtraProcess(this);
delete [] pv;
delete [] eve;
delete [] gkin;
}
void G4AntiProtonAnnihilationAtRest::PreparePhysicsTable(const G4ParticleDefinition& p)
{
G4HadronicProcessStore::Instance()->RegisterParticleForExtraProcess(this, &p);
}
void G4AntiProtonAnnihilationAtRest::BuildPhysicsTable(const G4ParticleDefinition& p)
{
G4HadronicProcessStore::Instance()->PrintInfo(&p);
}
// methods.............................................................................
G4bool G4AntiProtonAnnihilationAtRest::IsApplicable(
const G4ParticleDefinition& particle
)
{
return ( &particle == pdefAntiProton );
}
// Warning - this method may be optimized away if made "inline"
G4int G4AntiProtonAnnihilationAtRest::GetNumberOfSecondaries()
{
return ( ngkine );
}
// Warning - this method may be optimized away if made "inline"
G4GHEKinematicsVector* G4AntiProtonAnnihilationAtRest::GetSecondaryKinematics()
{
return ( &gkin[0] );
}
G4double G4AntiProtonAnnihilationAtRest::AtRestGetPhysicalInteractionLength(
const G4Track& track,
G4ForceCondition* condition
)
{
// beggining of tracking
ResetNumberOfInteractionLengthLeft();
// condition is set to "Not Forced"
*condition = NotForced;
// get mean life time
currentInteractionLength = GetMeanLifeTime(track, condition);
if ((currentInteractionLength <0.0) || (verboseLevel>2)){
G4cout << "G4AntiProtonAnnihilationAtRestProcess::AtRestGetPhysicalInteractionLength ";
G4cout << "[ " << GetProcessName() << "]" <<G4endl;
track.GetDynamicParticle()->DumpInfo();
G4cout << " in Material " << track.GetMaterial()->GetName() <<G4endl;
G4cout << "MeanLifeTime = " << currentInteractionLength/ns << "[ns]" <<G4endl;
}
return theNumberOfInteractionLengthLeft * currentInteractionLength;
}
G4VParticleChange* G4AntiProtonAnnihilationAtRest::AtRestDoIt(
const G4Track& track,
const G4Step&
)
//
// Handles AntiProtons at rest; a AntiProton can either create secondaries or
// do nothing (in which case it should be sent back to decay-handling
// section
//
{
// Initialize ParticleChange
// all members of G4VParticleChange are set to equal to
// corresponding member in G4Track
aParticleChange.Initialize(track);
// Store some global quantities that depend on current material and particle
globalTime = track.GetGlobalTime()/s;
G4Material * aMaterial = track.GetMaterial();
const G4int numberOfElements = aMaterial->GetNumberOfElements();
const G4ElementVector* theElementVector = aMaterial->GetElementVector();
const G4double* theAtomicNumberDensity = aMaterial->GetAtomicNumDensityVector();
G4double normalization = 0;
for ( G4int i1=0; i1 < numberOfElements; i1++ )
{
normalization += theAtomicNumberDensity[i1] ; // change when nucleon specific
// probabilities are included.
}
G4double runningSum= 0.;
G4double random = G4UniformRand()*normalization;
for ( G4int i2=0; i2 < numberOfElements; i2++ )
{
runningSum += theAtomicNumberDensity[i2]; // change when nucleon specific
// probabilities are included.
if (random<=runningSum)
{
targetCharge = G4double((*theElementVector)[i2]->GetZ());
targetAtomicMass = (*theElementVector)[i2]->GetN();
}
}
if (random>runningSum)
{
targetCharge = G4double((*theElementVector)[numberOfElements-1]->GetZ());
targetAtomicMass = (*theElementVector)[numberOfElements-1]->GetN();
}
if (verboseLevel>1) {
G4cout << "G4AntiProtonAnnihilationAtRest::AtRestDoIt is invoked " <<G4endl;
}
G4ParticleMomentum momentum;
G4float localtime;
G4ThreeVector position = track.GetPosition();
GenerateSecondaries(); // Generate secondaries
aParticleChange.SetNumberOfSecondaries( ngkine );
for ( G4int isec = 0; isec < ngkine; isec++ ) {
G4DynamicParticle* aNewParticle = new G4DynamicParticle;
aNewParticle->SetDefinition( gkin[isec].GetParticleDef() );
aNewParticle->SetMomentum( gkin[isec].GetMomentum() * GeV );
localtime = globalTime + gkin[isec].GetTOF();
G4Track* aNewTrack = new G4Track( aNewParticle, localtime*s, position );
aNewTrack->SetTouchableHandle(track.GetTouchableHandle());
aParticleChange.AddSecondary( aNewTrack );
}
aParticleChange.ProposeLocalEnergyDeposit( 0.0*GeV );
aParticleChange.ProposeTrackStatus(fStopAndKill); // Kill the incident AntiProton
// clear InteractionLengthLeft
ResetNumberOfInteractionLengthLeft();
return &aParticleChange;
}
void G4AntiProtonAnnihilationAtRest::GenerateSecondaries()
{
static G4int index;
static G4int l;
static G4int nopt;
static G4int i;
// DHW 15 May 2011: unused: static G4ParticleDefinition* jnd;
for (i = 1; i <= MAX_SECONDARIES; ++i) {
pv[i].SetZero();
}
ngkine = 0; // number of generated secondary particles
ntot = 0;
result.SetZero();
result.SetMass( massAntiProton );
result.SetKineticEnergyAndUpdate( 0. );
result.SetTOF( 0. );
result.SetParticleDef( pdefAntiProton );
AntiProtonAnnihilation(&nopt);
// *** CHECK WHETHER THERE ARE NEW PARTICLES GENERATED ***
if (ntot != 0 || result.GetParticleDef() != pdefAntiProton) {
// *** CURRENT PARTICLE IS NOT THE SAME AS IN THE BEGINNING OR/AND ***
// *** ONE OR MORE SECONDARIES HAVE BEEN GENERATED ***
// --- INITIAL PARTICLE TYPE HAS BEEN CHANGED ==> PUT NEW TYPE ON ---
// --- THE GEANT TEMPORARY STACK ---
// --- PUT PARTICLE ON THE STACK ---
gkin[0] = result;
gkin[0].SetTOF( result.GetTOF() * 5e-11 );
ngkine = 1;
// --- ALL QUANTITIES ARE TAKEN FROM THE GHEISHA STACK WHERE THE ---
// --- CONVENTION IS THE FOLLOWING ---
// --- ONE OR MORE SECONDARIES HAVE BEEN GENERATED ---
for (l = 1; l <= ntot; ++l) {
index = l - 1;
// DHW 15 May 2011: unused: jnd = eve[index].GetParticleDef();
// --- ADD PARTICLE TO THE STACK IF STACK NOT YET FULL ---
if (ngkine < MAX_SECONDARIES) {
gkin[ngkine] = eve[index];
gkin[ngkine].SetTOF( eve[index].GetTOF() * 5e-11 );
++ngkine;
}
}
}
else {
// --- NO SECONDARIES GENERATED AND PARTICLE IS STILL THE SAME ---
// --- ==> COPY EVERYTHING BACK IN THE CURRENT GEANT STACK ---
ngkine = 0;
ntot = 0;
globalTime += result.GetTOF() * G4float(5e-11);
}
// --- LIMIT THE VALUE OF NGKINE IN CASE OF OVERFLOW ---
ngkine = G4int(std::min(ngkine,G4int(MAX_SECONDARIES)));
} // GenerateSecondaries
void G4AntiProtonAnnihilationAtRest::Poisso(G4float xav, G4int *iran)
{
static G4int i;
static G4float r, p1, p2, p3;
static G4int fivex;
static G4float rr, ran, rrr, ran1;
// *** GENERATION OF POISSON DISTRIBUTION ***
// *** NVE 16-MAR-1988 CERN GENEVA ***
// ORIGIN : H.FESEFELDT (27-OCT-1983)
// --- USE NORMAL DISTRIBUTION FOR <X> > 9.9 ---
if (xav > G4float(9.9)) {
// ** NORMAL DISTRIBUTION WITH SIGMA**2 = <X>
Normal(&ran1);
ran1 = xav + ran1 * std::sqrt(xav);
*iran = G4int(ran1);
if (*iran < 0) {
*iran = 0;
}
}
else {
fivex = G4int(xav * G4float(5.));
*iran = 0;
if (fivex > 0) {
r = std::exp(-G4double(xav));
ran1 = G4UniformRand();
if (ran1 > r) {
rr = r;
for (i = 1; i <= fivex; ++i) {
++(*iran);
if (i <= 5) {
rrr = std::pow(xav, G4float(i)) / NFac(i);
}
// ** STIRLING' S FORMULA FOR LARGE NUMBERS
if (i > 5) {
rrr = std::exp(i * std::log(xav) -
(i + G4float(.5)) * std::log(i * G4float(1.)) +
i - G4float(.9189385));
}
rr += r * rrr;
if (ran1 <= rr) {
break;
}
}
}
}
else {
// ** FOR VERY SMALL XAV TRY IRAN=1,2,3
p1 = xav * std::exp(-G4double(xav));
p2 = xav * p1 / G4float(2.);
p3 = xav * p2 / G4float(3.);
ran = G4UniformRand();
if (ran >= p3) {
if (ran >= p2) {
if (ran >= p1) {
*iran = 0;
}
else {
*iran = 1;
}
}
else {
*iran = 2;
}
}
else {
*iran = 3;
}
}
}
} // Poisso
G4int G4AntiProtonAnnihilationAtRest::NFac(G4int n)
{
G4int ret_val;
static G4int i, j;
// *** NVE 16-MAR-1988 CERN GENEVA ***
// ORIGIN : H.FESEFELDT (27-OCT-1983)
ret_val = 1;
j = n;
if (j > 1) {
if (j > 10) {
j = 10;
}
for (i = 2; i <= j; ++i) {
ret_val *= i;
}
}
return ret_val;
} // NFac
void G4AntiProtonAnnihilationAtRest::Normal(G4float *ran)
{
static G4int i;
// *** NVE 14-APR-1988 CERN GENEVA ***
// ORIGIN : H.FESEFELDT (27-OCT-1983)
*ran = G4float(-6.);
for (i = 1; i <= 12; ++i) {
*ran += G4UniformRand();
}
} // Normal
void G4AntiProtonAnnihilationAtRest::AntiProtonAnnihilation(G4int *nopt)
{
static G4float brr[3] = { G4float(.125),G4float(.25),G4float(.5) };
G4float r__1;
static G4int i, ii, kk;
static G4int nt;
static G4float cfa, eka;
static G4int ika, nbl;
static G4float ran, pcm;
static G4int isw;
static G4float tex;
static G4ParticleDefinition* ipa1;
static G4float ran1, ran2, ekin, tkin;
static G4float targ;
static G4ParticleDefinition* inve;
static G4float ekin1, ekin2, black;
static G4float pnrat, rmnve1, rmnve2;
static G4float ek, en;
// *** ANTI PROTON ANNIHILATION AT REST ***
// *** NVE 04-MAR-1988 CERN GENEVA ***
// ORIGIN : H.FESEFELDT (09-JULY-1987)
// NOPT=0 NO ANNIHILATION
// NOPT=1 ANNIH.IN PI+ PI-
// NOPT=2 ANNIH.IN PI0 PI0
// NOPT=3 ANNIH.IN PI- PI0
// NOPT=4 ANNIH.IN GAMMA GAMMA
pv[1].SetZero();
pv[1].SetMass( massAntiProton );
pv[1].SetKineticEnergyAndUpdate( 0. );
pv[1].SetTOF( result.GetTOF() );
pv[1].SetParticleDef( result.GetParticleDef() );
isw = 1;
ran = G4UniformRand();
if (ran > brr[0]) {
isw = 2;
}
if (ran > brr[1]) {
isw = 3;
}
if (ran > brr[2]) {
isw = 4;
}
*nopt = isw;
// **
// ** EVAPORATION
// **
if (isw == 1) {
rmnve1 = massPionPlus;
rmnve2 = massPionMinus;
}
else if (isw == 2) {
rmnve1 = massPionZero;
rmnve2 = massPionZero;
}
else if (isw == 3) {
rmnve1 = massPionMinus;
rmnve2 = massPionZero;
}
else if (isw == 4) {
rmnve1 = massGamma;
rmnve2 = massGamma;
}
ek = massProton + massAntiProton - rmnve1 - rmnve2;
tkin = ExNu(ek);
ek -= tkin;
if (ek < G4float(1e-4)) {
ek = G4float(1e-4);
}
ek *= G4float(.5);
en = ek + (rmnve1 + rmnve2) * G4float(.5);
r__1 = en * en - rmnve1 * rmnve2;
pcm = r__1 > 0 ? std::sqrt(r__1) : 0;
pv[2].SetZero();
pv[2].SetMass( rmnve1 );
pv[3].SetZero();
pv[3].SetMass( rmnve2 );
if (isw > 3) {
pv[2].SetMass( 0. );
pv[3].SetMass( 0. );
}
pv[2].SetEnergyAndUpdate( std::sqrt(pv[2].GetMass()*pv[2].GetMass()+pcm*pcm) );
pv[2].SetTOF( result.GetTOF() );
pv[3].SetEnergy( std::sqrt(pv[3].GetMass()*pv[3].GetMass()+pcm*pcm) );
pv[3].SetMomentumAndUpdate( -pv[2].GetMomentum().x(), -pv[2].GetMomentum().y(), -pv[2].GetMomentum().z() );
pv[3].SetTOF( result.GetTOF() );
switch ((int)isw) {
case 1:
pv[2].SetParticleDef( pdefPionPlus );
pv[3].SetParticleDef( pdefPionMinus );
break;
case 2:
pv[2].SetParticleDef( pdefPionZero );
pv[3].SetParticleDef( pdefPionZero );
break;
case 3:
pv[2].SetParticleDef( pdefPionMinus );
pv[3].SetParticleDef( pdefPionZero );
break;
case 4:
pv[2].SetParticleDef( pdefGamma );
pv[3].SetParticleDef( pdefGamma );
break;
default:
break;
}
nt = 3;
if (targetAtomicMass >= G4float(1.5)) {
cfa = (targetAtomicMass - G4float(1.)) /
G4float(120.) * G4float(.025) *
std::exp(-G4double(targetAtomicMass - G4float(1.)) / G4float(120.));
targ = G4float(1.);
tex = evapEnergy1;
if (tex >= G4float(.001)) {
black = (targ * G4float(1.25) +
G4float(1.5)) * evapEnergy1 / (evapEnergy1 + evapEnergy3);
Poisso(black, &nbl);
if (G4float(G4int(targ) + nbl) > targetAtomicMass) {
nbl = G4int(targetAtomicMass - targ);
}
if (nt + nbl > (MAX_SECONDARIES - 2)) {
nbl = (MAX_SECONDARIES - 2) - nt;
}
if (nbl > 0) {
ekin = tex / nbl;
ekin2 = G4float(0.);
for (i = 1; i <= nbl; ++i) {
if (nt == (MAX_SECONDARIES - 2)) {
continue;
}
if (ekin2 > tex) {
break;
}
ran1 = G4UniformRand();
Normal(&ran2);
ekin1 = -G4double(ekin) * std::log(ran1) -
cfa * (ran2 * G4float(.5) + G4float(1.));
if (ekin1 < G4float(0.)) {
ekin1 = std::log(ran1) * G4float(-.01);
}
ekin1 *= G4float(1.);
ekin2 += ekin1;
if (ekin2 > tex) {
ekin1 = tex - (ekin2 - ekin1);
}
if (ekin1 < G4float(0.)) {
ekin1 = G4float(.001);
}
ipa1 = pdefNeutron;
pnrat = G4float(1.) - targetCharge / targetAtomicMass;
if (G4UniformRand() > pnrat) {
ipa1 = pdefProton;
}
++nt;
pv[nt].SetZero();
pv[nt].SetMass( ipa1->GetPDGMass()/GeV );
pv[nt].SetKineticEnergyAndUpdate( ekin1 );
pv[nt].SetTOF( result.GetTOF() );
pv[nt].SetParticleDef( ipa1 );
}
if (targetAtomicMass >= G4float(230.) && ek <= G4float(2.)) {
ii = nt + 1;
kk = 0;
eka = ek;
if (eka > G4float(1.)) {
eka *= eka;
}
if (eka < G4float(.1)) {
eka = G4float(.1);
}
ika = G4int(G4float(3.6) / eka);
for (i = 1; i <= nt; ++i) {
--ii;
if (pv[ii].GetParticleDef() != pdefProton) {
continue;
}
ipa1 = pdefNeutron;
pv[ii].SetMass( ipa1->GetPDGMass()/GeV );
pv[ii].SetParticleDef( ipa1 );
++kk;
if (kk > ika) {
break;
}
}
}
}
}
// **
// ** THEN ALSO DEUTERONS, TRITONS AND ALPHAS
// **
tex = evapEnergy3;
if (tex >= G4float(.001)) {
black = (targ * G4float(1.25) + G4float(1.5)) * evapEnergy3 /
(evapEnergy1 + evapEnergy3);
Poisso(black, &nbl);
if (nt + nbl > (MAX_SECONDARIES - 2)) {
nbl = (MAX_SECONDARIES - 2) - nt;
}
if (nbl > 0) {
ekin = tex / nbl;
ekin2 = G4float(0.);
for (i = 1; i <= nbl; ++i) {
if (nt == (MAX_SECONDARIES - 2)) {
continue;
}
if (ekin2 > tex) {
break;
}
ran1 = G4UniformRand();
Normal(&ran2);
ekin1 = -G4double(ekin) * std::log(ran1) -
cfa * (ran2 * G4float(.5) + G4float(1.));
if (ekin1 < G4float(0.)) {
ekin1 = std::log(ran1) * G4float(-.01);
}
ekin1 *= G4float(1.);
ekin2 += ekin1;
if (ekin2 > tex) {
ekin1 = tex - (ekin2 - ekin1);
}
if (ekin1 < G4float(0.)) {
ekin1 = G4float(.001);
}
ran = G4UniformRand();
inve = pdefDeuteron;
if (ran > G4float(.6)) {
inve = pdefTriton;
}
if (ran > G4float(.9)) {
inve = pdefAlpha;
}
++nt;
pv[nt].SetZero();
pv[nt].SetMass( inve->GetPDGMass()/GeV );
pv[nt].SetKineticEnergyAndUpdate( ekin1 );
pv[nt].SetTOF( result.GetTOF() );
pv[nt].SetParticleDef( inve );
}
}
}
}
result = pv[2];
if (nt == 2) {
return;
}
for (i = 3; i <= nt; ++i) {
if (ntot >= MAX_SECONDARIES) {
return;
}
eve[ntot++] = pv[i];
}
} // AntiProtonAnnihilation
G4double G4AntiProtonAnnihilationAtRest::ExNu(G4float ek1)
{
G4float ret_val, r__1;
static G4float cfa, gfa, ran1, ran2, ekin1, atno3;
static G4int magic;
static G4float fpdiv;
// *** NUCLEAR EVAPORATION AS FUNCTION OF ATOMIC NUMBER ATNO ***
// *** AND KINETIC ENERGY EKIN OF PRIMARY PARTICLE ***
// *** NVE 04-MAR-1988 CERN GENEVA ***
// ORIGIN : H.FESEFELDT (10-DEC-1986)
ret_val = G4float(0.);
if (targetAtomicMass >= G4float(1.5)) {
magic = 0;
if (G4int(targetCharge + G4float(.1)) == 82) {
magic = 1;
}
ekin1 = ek1;
if (ekin1 < G4float(.1)) {
ekin1 = G4float(.1);
}
if (ekin1 > G4float(4.)) {
ekin1 = G4float(4.);
}
// ** 0.35 VALUE AT 1 GEV
// ** 0.05 VALUE AT 0.1 GEV
cfa = G4float(.13043478260869565);
cfa = cfa * std::log(ekin1) + G4float(.35);
if (cfa < G4float(.15)) {
cfa = G4float(.15);
}
ret_val = cfa * G4float(7.716) * std::exp(-G4double(cfa));
atno3 = targetAtomicMass;
if (atno3 > G4float(120.)) {
atno3 = G4float(120.);
}
cfa = (atno3 - G4float(1.)) /
G4float(120.) * std::exp(-G4double(atno3 - G4float(1.)) / G4float(120.));
ret_val *= cfa;
r__1 = ekin1;
fpdiv = G4float(1.) - r__1 * r__1 * G4float(.25);
if (fpdiv < G4float(.5)) {
fpdiv = G4float(.5);
}
gfa = (targetAtomicMass - G4float(1.)) /
G4float(70.) * G4float(2.) *
std::exp(-G4double(targetAtomicMass - G4float(1.)) / G4float(70.));
evapEnergy1 = ret_val * fpdiv;
evapEnergy3 = ret_val - evapEnergy1;
Normal(&ran1);
Normal(&ran2);
if (magic == 1) {
ran1 = G4float(0.);
ran2 = G4float(0.);
}
evapEnergy1 *= ran1 * gfa + G4float(1.);
if (evapEnergy1 < G4float(0.)) {
evapEnergy1 = G4float(0.);
}
evapEnergy3 *= ran2 * gfa + G4float(1.);
if (evapEnergy3 < G4float(0.)) {
evapEnergy3 = G4float(0.);
}
while ((ret_val = evapEnergy1 + evapEnergy3) >= ek1) {
evapEnergy1 *= G4float(1.) - G4UniformRand() * G4float(.5);
evapEnergy3 *= G4float(1.) - G4UniformRand() * G4float(.5);
}
}
return ret_val;
} // ExNu
source/processes/hadronic/stopping/src/G4DistributionGenerator.cc
-134
View File
@@ -1,134 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4DistributionGenerator
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 8 May 1998
//
// -------------------------------------------------------------------
#include "globals.hh"
#include "G4DistributionGenerator.hh"
#include "G4HadronicDeprecate.hh"
#include "G4ios.hh"
#include <assert.h>
// Constructor
G4DistributionGenerator::G4DistributionGenerator(std::vector<G4double>& x,
std::vector<G4double>& values)
{
G4HadronicDeprecate("G4DistributionGenerator");
_x = x;
// Check boundaries: must be size(x) = size(values) + 1
if (x.size() != (values.size() + 1))
{ G4cout << " Inconsistent parameters in G4DistributionGenerator "
<< G4endl;
}
assert (x.size() == (values.size() + 1));
G4double tot = 0.;
unsigned int i;
for (i=0; i<values.size(); i++) { tot += values[i]; }
assert (tot > 0.);
_cumProb.push_back(0.);
// _cumProb.push_back(values[0] / tot);
G4double sum = 0.;
for (i=0; i<values.size(); i++)
{
sum += values[i];
_cumProb.push_back(sum / tot); }
// Debugging
/*
for (i=0; i<values.size(); i++)
{ G4cout << values[i] << " " ; }
G4cout << " Integral = " << tot << G4endl;
for (i=0; i<_cumProb.size(); i++)
{
G4cout << "Variable " << _x[i]
<< " --- cumProb = " << _cumProb[i] << G4endl;
}
*/
// End of debugging
}
// Destructor
G4DistributionGenerator::~G4DistributionGenerator()
{
}
G4double G4DistributionGenerator::Generate(G4double ranflat)
{
G4double xRandom = _x[0];
G4int bin = _cumProb.size() - 1;
unsigned int i;
for (i=1; i<_cumProb.size(); i++)
{
if (ranflat >= _cumProb[i-1] && ranflat < _cumProb[i])
{
bin = i - 1;
}
}
if (bin >= 0 && bin < static_cast<G4int>(_cumProb.size()-1) && bin < static_cast<G4int>(_x.size()-1))
{
G4double coeff = (ranflat - _cumProb[bin]) * (_x[bin+1] - _x[bin]) /
(_cumProb[bin+1] - _cumProb[bin]);
xRandom = _x[bin] + coeff;
// Deugging
/*
G4cout << "Random = " << ranflat << " Generated " << xRandom << G4endl;
*/
// Endo of Debugging
}
else
{
// Debugging
/*
G4cout << "Bin " << bin << " "
<< _cumProb.size() << " "
<< _x.size()
<< G4endl;
*/
// End of debugging
}
return xRandom;
}
source/processes/hadronic/stopping/src/G4ElementSelector.cc
+1 -1
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4ElementSelector.cc 66367 2012-12-18 09:18:08Z gcosmo $
//
// File: G4ElementSelector
//
source/processes/hadronic/stopping/src/G4EmCaptureCascade.cc
+2 -1
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4EmCaptureCascade.cc 69573 2013-05-08 13:35:53Z gcosmo $
//
//-----------------------------------------------------------------------------
//
@@ -94,6 +94,7 @@ G4EmCaptureCascade::G4EmCaptureCascade()
fKLevelEnergy[z2] = listKEnergy[i];
idx = i;
}
for( G4int i = 0; i<14; ++i) { fLevelEnergy[i] = 0.0; }
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
source/processes/hadronic/stopping/src/G4HadronStoppingProcess.cc
+1 -1
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4HadronStoppingProcess.cc 66367 2012-12-18 09:18:08Z gcosmo $
//
//---------------------------------------------------------------------
//
source/processes/hadronic/stopping/src/G4KaonMinusAbsorption.cc
-572
View File
@@ -1,572 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// G4KaonMinusAbsorption physics process
// Larry Felawka (TRIUMF), April 1998
//---------------------------------------------------------------------
#include <string.h>
#include <cmath>
#include <stdio.h>
#include "G4KaonMinusAbsorption.hh"
#include "G4DynamicParticle.hh"
#include "G4ParticleTypes.hh"
#include "Randomize.hh"
#include "G4SystemOfUnits.hh"
#include "G4HadronicProcessStore.hh"
#include "G4HadronicDeprecate.hh"
#define MAX_SECONDARIES 100
// constructor
G4KaonMinusAbsorption::G4KaonMinusAbsorption(const G4String& processName,
G4ProcessType aType ) :
G4VRestProcess (processName, aType), // initialization
massKaonMinus(G4KaonMinus::KaonMinus()->GetPDGMass()/GeV),
massGamma(G4Gamma::Gamma()->GetPDGMass()/GeV),
massPionZero(G4PionZero::PionZero()->GetPDGMass()/GeV),
massProton(G4Proton::Proton()->GetPDGMass()/GeV),
massLambda(G4Lambda::Lambda()->GetPDGMass()/GeV),
pdefKaonMinus(G4KaonMinus::KaonMinus()),
pdefGamma(G4Gamma::Gamma()),
pdefPionZero(G4PionZero::PionZero()),
pdefProton(G4Proton::Proton()),
pdefNeutron(G4Neutron::Neutron()),
pdefLambda(G4Lambda::Lambda()),
pdefDeuteron(G4Deuteron::Deuteron()),
pdefTriton(G4Triton::Triton()),
pdefAlpha(G4Alpha::Alpha())
{
G4HadronicDeprecate("G4KaonMinusAbsorption");
if (verboseLevel>0) {
G4cout << GetProcessName() << " is created "<< G4endl;
}
SetProcessSubType(fHadronAtRest);
pv = new G4GHEKinematicsVector [MAX_SECONDARIES+1];
eve = new G4GHEKinematicsVector [MAX_SECONDARIES];
gkin = new G4GHEKinematicsVector [MAX_SECONDARIES];
G4HadronicProcessStore::Instance()->RegisterExtraProcess(this);
}
// destructor
G4KaonMinusAbsorption::~G4KaonMinusAbsorption()
{
G4HadronicProcessStore::Instance()->DeRegisterExtraProcess(this);
delete [] pv;
delete [] eve;
delete [] gkin;
}
void G4KaonMinusAbsorption::PreparePhysicsTable(const G4ParticleDefinition& p)
{
G4HadronicProcessStore::Instance()->RegisterParticleForExtraProcess(this, &p);
}
void G4KaonMinusAbsorption::BuildPhysicsTable(const G4ParticleDefinition& p)
{
G4HadronicProcessStore::Instance()->PrintInfo(&p);
}
// methods.............................................................................
G4bool G4KaonMinusAbsorption::IsApplicable(
const G4ParticleDefinition& particle
)
{
return ( &particle == pdefKaonMinus );
}
// Warning - this method may be optimized away if made "inline"
G4int G4KaonMinusAbsorption::GetNumberOfSecondaries()
{
return ( ngkine );
}
// Warning - this method may be optimized away if made "inline"
G4GHEKinematicsVector* G4KaonMinusAbsorption::GetSecondaryKinematics()
{
return ( &gkin[0] );
}
G4double G4KaonMinusAbsorption::AtRestGetPhysicalInteractionLength(
const G4Track& track,
G4ForceCondition* condition
)
{
// beggining of tracking
ResetNumberOfInteractionLengthLeft();
// condition is set to "Not Forced"
*condition = NotForced;
// get mean life time
currentInteractionLength = GetMeanLifeTime(track, condition);
if ((currentInteractionLength <0.0) || (verboseLevel>2)){
G4cout << "G4KaonMinusAbsorptionProcess::AtRestGetPhysicalInteractionLength ";
G4cout << "[ " << GetProcessName() << "]" <<G4endl;
track.GetDynamicParticle()->DumpInfo();
G4cout << " in Material " << track.GetMaterial()->GetName() <<G4endl;
G4cout << "MeanLifeTime = " << currentInteractionLength/ns << "[ns]" <<G4endl;
}
return theNumberOfInteractionLengthLeft * currentInteractionLength;
}
G4VParticleChange* G4KaonMinusAbsorption::AtRestDoIt(
const G4Track& track,
const G4Step&
)
//
// Handles KaonMinus at rest; a KaonMinus can either create secondaries or
// do nothing (in which case it should be sent back to decay-handling
// section
//
{
// Initialize ParticleChange
// all members of G4VParticleChange are set to equal to
// corresponding member in G4Track
aParticleChange.Initialize(track);
// Store some global quantities that depend on current material and particle
globalTime = track.GetGlobalTime()/s;
G4Material * aMaterial = track.GetMaterial();
const G4int numberOfElements = aMaterial->GetNumberOfElements();
const G4ElementVector* theElementVector = aMaterial->GetElementVector();
const G4double* theAtomicNumberDensity = aMaterial->GetAtomicNumDensityVector();
G4double normalization = 0;
for ( G4int i1=0; i1 < numberOfElements; i1++ )
{
normalization += theAtomicNumberDensity[i1] ; // change when nucleon specific
// probabilities are included.
}
G4double runningSum= 0.;
G4double random = G4UniformRand()*normalization;
for ( G4int i2=0; i2 < numberOfElements; i2++ )
{
runningSum += theAtomicNumberDensity[i2]; // change when nucleon specific
// probabilities are included.
if (random<=runningSum)
{
targetCharge = G4double( ((*theElementVector)[i2])->GetZ());
targetAtomicMass = (*theElementVector)[i2]->GetN();
}
}
if (random>runningSum)
{
targetCharge = G4double((*theElementVector)[numberOfElements-1]->GetZ());
targetAtomicMass = (*theElementVector)[numberOfElements-1]->GetN();
}
if (verboseLevel>1) {
G4cout << "G4KaonMinusAbsorption::AtRestDoIt is invoked " <<G4endl;
}
G4ParticleMomentum momentum;
G4float localtime;
G4ThreeVector position = track.GetPosition();
GenerateSecondaries(); // Generate secondaries
aParticleChange.SetNumberOfSecondaries( ngkine );
for ( G4int isec = 0; isec < ngkine; isec++ ) {
G4DynamicParticle* aNewParticle = new G4DynamicParticle;
aNewParticle->SetDefinition( gkin[isec].GetParticleDef() );
aNewParticle->SetMomentum( gkin[isec].GetMomentum() * GeV );
localtime = globalTime + gkin[isec].GetTOF();
G4Track* aNewTrack = new G4Track( aNewParticle, localtime*s, position );
aNewTrack->SetTouchableHandle(track.GetTouchableHandle());
aParticleChange.AddSecondary( aNewTrack );
}
aParticleChange.ProposeLocalEnergyDeposit( 0.0*GeV );
aParticleChange.ProposeTrackStatus(fStopAndKill); // Kill the incident KaonMinus
// clear InteractionLengthLeft
ResetNumberOfInteractionLengthLeft();
return &aParticleChange;
}
void G4KaonMinusAbsorption::GenerateSecondaries()
{
static G4int index;
static G4int l;
static G4int nopt;
static G4int i;
// DHW 15 May 2011: unused: static G4ParticleDefinition* jnd;
for (i = 1; i <= MAX_SECONDARIES; ++i) {
pv[i].SetZero();
}
ngkine = 0; // number of generated secondary particles
ntot = 0;
result.SetZero();
result.SetMass( massKaonMinus );
result.SetKineticEnergyAndUpdate( 0. );
result.SetTOF( 0. );
result.SetParticleDef( pdefKaonMinus );
KaonMinusAbsorption(&nopt);
// *** CHECK WHETHER THERE ARE NEW PARTICLES GENERATED ***
if (ntot != 0 || result.GetParticleDef() != pdefKaonMinus) {
// *** CURRENT PARTICLE IS NOT THE SAME AS IN THE BEGINNING OR/AND ***
// *** ONE OR MORE SECONDARIES HAVE BEEN GENERATED ***
// --- INITIAL PARTICLE TYPE HAS BEEN CHANGED ==> PUT NEW TYPE ON ---
// --- THE GEANT TEMPORARY STACK ---
// --- PUT PARTICLE ON THE STACK ---
gkin[0] = result;
gkin[0].SetTOF( result.GetTOF() * 5e-11 );
ngkine = 1;
// --- ALL QUANTITIES ARE TAKEN FROM THE GHEISHA STACK WHERE THE ---
// --- CONVENTION IS THE FOLLOWING ---
// --- ONE OR MORE SECONDARIES HAVE BEEN GENERATED ---
for (l = 1; l <= ntot; ++l) {
index = l - 1;
// DHW 15 May 2011: unused: jnd = eve[index].GetParticleDef();
// --- ADD PARTICLE TO THE STACK IF STACK NOT YET FULL ---
if (ngkine < MAX_SECONDARIES) {
gkin[ngkine] = eve[index];
gkin[ngkine].SetTOF( eve[index].GetTOF() * 5e-11 );
++ngkine;
}
}
}
else {
// --- NO SECONDARIES GENERATED AND PARTICLE IS STILL THE SAME ---
// --- ==> COPY EVERYTHING BACK IN THE CURRENT GEANT STACK ---
ngkine = 0;
ntot = 0;
globalTime += result.GetTOF() * G4float(5e-11);
}
// --- LIMIT THE VALUE OF NGKINE IN CASE OF OVERFLOW ---
ngkine = G4int(std::min(ngkine,G4int(MAX_SECONDARIES)));
} // GenerateSecondaries
void G4KaonMinusAbsorption::Poisso(G4float xav, G4int *iran)
{
static G4int i;
static G4float r, p1, p2, p3;
static G4int fivex;
static G4float rr, ran, rrr, ran1;
// *** GENERATION OF POISSON DISTRIBUTION ***
// *** NVE 16-MAR-1988 CERN GENEVA ***
// ORIGIN : H.FESEFELDT (27-OCT-1983)
// --- USE NORMAL DISTRIBUTION FOR <X> > 9.9 ---
if (xav > G4float(9.9)) {
// ** NORMAL DISTRIBUTION WITH SIGMA**2 = <X>
Normal(&ran1);
ran1 = xav + ran1 * std::sqrt(xav);
*iran = G4int(ran1);
if (*iran < 0) {
*iran = 0;
}
}
else {
fivex = G4int(xav * G4float(5.));
*iran = 0;
if (fivex > 0) {
r = std::exp(-G4double(xav));
ran1 = G4UniformRand();
if (ran1 > r) {
rr = r;
for (i = 1; i <= fivex; ++i) {
++(*iran);
if (i <= 5) {
rrr = std::pow(xav, G4float(i)) / NFac(i);
}
// ** STIRLING' S FORMULA FOR LARGE NUMBERS
if (i > 5) {
rrr = std::exp(i * std::log(xav) -
(i + G4float(.5)) * std::log(i * G4float(1.)) +
i - G4float(.9189385));
}
rr += r * rrr;
if (ran1 <= rr) {
break;
}
}
}
}
else {
// ** FOR VERY SMALL XAV TRY IRAN=1,2,3
p1 = xav * std::exp(-G4double(xav));
p2 = xav * p1 / G4float(2.);
p3 = xav * p2 / G4float(3.);
ran = G4UniformRand();
if (ran >= p3) {
if (ran >= p2) {
if (ran >= p1) {
*iran = 0;
}
else {
*iran = 1;
}
}
else {
*iran = 2;
}
}
else {
*iran = 3;
}
}
}
} // Poisso
G4int G4KaonMinusAbsorption::NFac(G4int n)
{
G4int ret_val;
static G4int i, j;
// *** NVE 16-MAR-1988 CERN GENEVA ***
// ORIGIN : H.FESEFELDT (27-OCT-1983)
ret_val = 1;
j = n;
if (j > 1) {
if (j > 10) {
j = 10;
}
for (i = 2; i <= j; ++i) {
ret_val *= i;
}
}
return ret_val;
} // NFac
void G4KaonMinusAbsorption::Normal(G4float *ran)
{
static G4int i;
// *** NVE 14-APR-1988 CERN GENEVA ***
// ORIGIN : H.FESEFELDT (27-OCT-1983)
*ran = G4float(-6.);
for (i = 1; i <= 12; ++i) {
*ran += G4UniformRand();
}
} // Normal
void G4KaonMinusAbsorption::KaonMinusAbsorption(G4int *nopt)
{
static G4int i;
static G4int nt, nbl;
static G4float ran, pcm;
static G4int isw;
static G4float tex;
static G4float ran2, tof1, ekin, ekin1, ekin2, black;
static G4float pnrat;
static G4ParticleDefinition* ipa1;
static G4ParticleDefinition* inve;
// *** CHARGED KAON ABSORPTION BY A NUCLEUS ***
// *** NVE 04-MAR-1988 CERN GENEVA ***
// ORIGIN : H.FESEFELDT (09-JULY-1987)
// PRODUCTION OF A HYPERFRAGMENT WITH SUBSEQUENT DECAY
// PANOFSKY RATIO (K- P --> LAMBDA PI0/K- P --> LAMBDA GAMMA) = 3/2
pv[1].SetZero();
pv[1].SetMass( massKaonMinus );
pv[1].SetKineticEnergyAndUpdate( 0. );
pv[1].SetTOF( result.GetTOF() );
pv[1].SetParticleDef( result.GetParticleDef() );
if (targetAtomicMass <= G4float(1.5)) {
ran = G4UniformRand();
tof1 = std::log(ran) * G4float(-12.5);
tof1 *= G4float(20.);
ran = G4UniformRand();
isw = 1;
if (ran < G4float(.33)) {
isw = 2;
}
*nopt = isw;
pv[3].SetZero();
pv[3].SetMass( massLambda );
pv[3].SetKineticEnergyAndUpdate( 0. );
pv[3].SetTOF( result.GetTOF() + tof1 );
pv[3].SetParticleDef( pdefLambda );
pcm = massKaonMinus + massProton - massLambda;
if (isw != 1) {
pv[2].SetZero();
pv[2].SetMass( massGamma );
pv[2].SetKineticEnergyAndUpdate( pcm );
pv[2].SetTOF( result.GetTOF() + tof1 );
pv[2].SetParticleDef( pdefGamma );
}
else {
pcm = pcm * pcm - massPionZero * massPionZero;
if (pcm <= G4float(0.)) {
pcm = G4float(0.);
}
pv[2].SetZero();
pv[2].SetEnergy( std::sqrt(pcm + massPionZero * massPionZero) );
pv[2].SetMassAndUpdate( massPionZero );
pv[2].SetTOF( result.GetTOF() + tof1 );
pv[2].SetParticleDef( pdefPionZero );
}
result = pv[2];
if (ntot < MAX_SECONDARIES-1) {
eve[ntot++] = pv[3];
}
}
else {
// **
// ** STAR PRODUCTION FOR PION ABSORPTION IN HEAVY ELEMENTS
// **
evapEnergy1 = G4float(.3);
evapEnergy3 = G4float(.15);
nt = 1;
tex = evapEnergy1;
black = std::log(targetAtomicMass) * G4float(.5);
Poisso(black, &nbl);
if (nt + nbl > (MAX_SECONDARIES - 2)) {
nbl = (MAX_SECONDARIES - 2) - nt;
}
if (nbl <= 0) {
nbl = 1;
}
ekin = tex / nbl;
ekin2 = G4float(0.);
for (i = 1; i <= nbl; ++i) {
if (nt == (MAX_SECONDARIES - 2)) {
continue;
}
ran2 = G4UniformRand();
ekin1 = -G4double(ekin) * std::log(ran2);
ekin2 += ekin1;
ipa1 = pdefNeutron;
pnrat = G4float(1.) - targetCharge / targetAtomicMass;
if (G4UniformRand() > pnrat) {
ipa1 = pdefProton;
}
++nt;
pv[nt].SetZero();
pv[nt].SetMass( ipa1->GetPDGMass()/GeV );
pv[nt].SetKineticEnergyAndUpdate( ekin1 );
pv[nt].SetTOF( 2. );
pv[nt].SetParticleDef( ipa1 );
if (ekin2 > tex) {
break;
}
}
tex = evapEnergy3;
black = std::log(targetAtomicMass) * G4float(.5);
Poisso(black, &nbl);
if (nt + nbl > (MAX_SECONDARIES - 2)) {
nbl = (MAX_SECONDARIES - 2) - nt;
}
if (nbl <= 0) {
nbl = 1;
}
ekin = tex / nbl;
ekin2 = G4float(0.);
for (i = 1; i <= nbl; ++i) {
if (nt == (MAX_SECONDARIES - 2)) {
continue;
}
ran2 = G4UniformRand();
ekin1 = -G4double(ekin) * std::log(ran2);
ekin2 += ekin1;
++nt;
ran = G4UniformRand();
inve = pdefDeuteron;
if (ran > G4float(.6)) {
inve = pdefTriton;
}
if (ran > G4float(.9)) {
inve = pdefAlpha;
}
// PV(5,NT)=(ABS(IPA(NT))-28)*RMASS(14) <-- Wrong! (LF)
pv[nt].SetZero();
pv[nt].SetMass( inve->GetPDGMass()/GeV );
pv[nt].SetKineticEnergyAndUpdate( ekin1 );
pv[nt].SetTOF( 2. );
pv[nt].SetParticleDef( inve );
if (ekin2 > tex) {
break;
}
}
// **
// ** STORE ON EVENT COMMON
// **
ran = G4UniformRand();
tof1 = std::log(ran) * G4float(-12.5);
tof1 *= G4float(20.);
for (i = 2; i <= nt; ++i) {
pv[i].SetTOF( result.GetTOF() + tof1 );
}
result = pv[2];
for (i = 3; i <= nt; ++i) {
if (ntot >= MAX_SECONDARIES) {
break;
}
eve[ntot++] = pv[i];
}
}
} // KaonMinusAbsorption
source/processes/hadronic/stopping/src/G4KaonMinusAbsorptionAtRest.cc
-555
View File
@@ -1,555 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// Author: Christian V"olcker (Christian.Volcker@cern.ch),
//
// Creation date: November 1997
//
// Testfile: ../G4KaonMinusAbsorptionAtRestTest.cc
//
// Modifications:
// Maria Grazia Pia September 1998
// Various bug fixes, eliminated several memory leaks
//
// -------------------------------------------------------------------
#include "G4KaonMinusAbsorptionAtRest.hh"
#include "G4StopDeexcitation.hh"
#include "G4StopTheoDeexcitation.hh"
#include "G4StopDeexcitationAlgorithm.hh"
#include "G4ReactionKinematics.hh"
#include "G4HadronicProcessStore.hh"
#include "G4HadronicDeprecate.hh"
G4KaonMinusAbsorptionAtRest::G4KaonMinusAbsorptionAtRest(const G4String& processName,
G4ProcessType aType ) :
G4VRestProcess (processName, aType)
{
G4HadronicDeprecate("G4KaonMinusAbsorptionAtRest");
if (verboseLevel>0) {
G4cout << GetProcessName() << " is created "<< G4endl;
}
SetProcessSubType(fHadronAtRest);
// see Cohn et al, PLB27(1968) 527;
// Davis et al, PLB1(1967) 434;
pionAbsorptionRate = 0.07;
// see VanderVelde-Wilquet et al, Nuov.Cim.39A(1978)538;
// see VanderVelde-Wilquet et al, Nuov.Cim.38A(1977)178;
// see VanderVelde-Wilquet et al, Nucl.Phys.A241(1975)511;
// primary production rates ( for absorption on Carbon)
// .. other elements are extrapolated by the halo factor.
rateLambdaZeroPiZero = 0.052;
rateSigmaMinusPiPlus = 0.199;
rateSigmaPlusPiMinus = 0.446;
rateSigmaZeroPiZero = 0.303;
rateLambdaZeroPiMinus = 0.568;
rateSigmaZeroPiMinus = 0.216;
rateSigmaMinusPiZero = 0.216;
// for sigma- p -> lambda n
// sigma+ n -> lambda p
// sigma- n -> lambda
// all values compatible with 0.55 same literature as above.
sigmaPlusLambdaConversionRate = 0.55;
sigmaMinusLambdaConversionRate = 0.55;
sigmaZeroLambdaConversionRate = 0.55;
G4HadronicProcessStore::Instance()->RegisterExtraProcess(this);
}
G4KaonMinusAbsorptionAtRest::~G4KaonMinusAbsorptionAtRest()
{
G4HadronicProcessStore::Instance()->DeRegisterExtraProcess(this);
}
void G4KaonMinusAbsorptionAtRest::PreparePhysicsTable(const G4ParticleDefinition& p)
{
G4HadronicProcessStore::Instance()->RegisterParticleForExtraProcess(this, &p);
}
void G4KaonMinusAbsorptionAtRest::BuildPhysicsTable(const G4ParticleDefinition& p)
{
G4HadronicProcessStore::Instance()->PrintInfo(&p);
}
G4VParticleChange* G4KaonMinusAbsorptionAtRest::AtRestDoIt
(const G4Track& track, const G4Step& )
{
stoppedHadron = track.GetDynamicParticle();
// Check applicability
if (!IsApplicable(*(stoppedHadron->GetDefinition())))
{
G4cerr <<"G4KaonMinusAbsorptionAtRest:ERROR, particle must be a Kaon!" <<G4endl;
return 0;
}
G4Material* material;
material = track.GetMaterial();
nucleus = 0;
do
{
// Select the nucleus, get nucleon
nucleus = new G4Nucleus(material);
if (nucleus->GetA_asInt() < 1.5)
{
delete nucleus;
nucleus = 0;
}
} while(nucleus == 0);
G4double Z = nucleus->GetZ_asInt();
G4double A = nucleus->GetA_asInt();
// Do the interaction with the nucleon
G4DynamicParticleVector* absorptionProducts = KaonNucleonReaction();
//A.R. 26-Jul-2012 Coverity fix
if ( ! absorptionProducts ) {
G4Exception("G4KaonMinusAbsorptionAtRest::AtRestDoIt()", "HAD_STOP_0001",
FatalException, "NULL absorptionProducts");
return 0;
}
// Secondary interactions
G4DynamicParticle* thePion;
unsigned int i;
for(i = 0; i < absorptionProducts->size(); i++)
{
thePion = (*absorptionProducts)[i];
if (thePion->GetDefinition() == G4PionMinus::PionMinus()
|| thePion->GetDefinition() == G4PionPlus::PionPlus()
|| thePion->GetDefinition() == G4PionZero::PionZero())
{
if (AbsorbPionByNucleus(thePion))
{
absorptionProducts->erase(absorptionProducts->begin()+i);
i--;
delete thePion;
if (verboseLevel > 1)
G4cout << "G4KaonMinusAbsorption::AtRestDoIt: Pion absorbed in Nucleus"
<< G4endl;
}
}
}
G4DynamicParticle* theSigma;
G4DynamicParticle* theLambda;
for (i = 0; i < absorptionProducts->size(); i++)
{
theSigma = (*absorptionProducts)[i];
if (theSigma->GetDefinition() == G4SigmaMinus::SigmaMinus()
|| theSigma->GetDefinition() == G4SigmaPlus::SigmaPlus()
|| theSigma->GetDefinition() == G4SigmaZero::SigmaZero())
{
theLambda = SigmaLambdaConversion(theSigma);
if (theLambda != 0){
absorptionProducts->erase(absorptionProducts->begin()+i);
i--;
delete theSigma;
absorptionProducts->push_back(theLambda);
if (verboseLevel > 1)
G4cout << "G4KaonMinusAbsorption::AtRestDoIt: SigmaLambdaConversion Done"
<< G4endl;
}
}
}
// Nucleus deexcitation
G4double productEnergy = 0.;
G4ThreeVector pProducts(0.,0.,0.);
unsigned int nAbsorptionProducts = 0;
if (absorptionProducts != 0) nAbsorptionProducts = absorptionProducts->size();
for ( i = 0; i<nAbsorptionProducts; i++)
{
pProducts += (*absorptionProducts)[i]->GetMomentum();
productEnergy += (*absorptionProducts)[i]->GetKineticEnergy();
}
G4double newZ = nucleus->GetZ_asInt();
G4double newA = nucleus->GetA_asInt();
G4double bDiff = G4NucleiProperties::GetBindingEnergy(static_cast<G4int>(A),static_cast<G4int>(Z)) -
G4NucleiProperties::GetBindingEnergy(static_cast<G4int>(newA), static_cast<G4int>(newZ));
G4StopDeexcitationAlgorithm* nucleusAlgorithm = new G4StopTheoDeexcitation();
G4StopDeexcitation stopDeexcitation(nucleusAlgorithm);
nucleus->AddExcitationEnergy(bDiff);
// returns excitation energy for the moment ..
G4double energyDeposit = nucleus->GetEnergyDeposit();
if (verboseLevel>0)
{
G4cout << " -- KaonAtRest -- excitation = "
<< energyDeposit
<< ", pNucleus = "
<< pProducts
<< ", A: "
<< A
<< ", "
<< newA
<< ", Z: "
<< Z
<< ", "
<< newZ
<< G4endl;
}
if (energyDeposit < 0.)
G4Exception("G4KaonMinusAbsorptionAtRest::AtRestDoIt()", "HAD_STOP_0002",
FatalException, "Excitation energy < 0");
delete nucleus;
G4ReactionProductVector* fragmentationProducts = stopDeexcitation.DoBreakUp(newA,newZ,energyDeposit,pProducts);
unsigned int nFragmentationProducts = 0;
if (fragmentationProducts != 0) nFragmentationProducts = fragmentationProducts->size();
//Initialize ParticleChange
aParticleChange.Initialize(track);
aParticleChange.SetNumberOfSecondaries(G4int(nAbsorptionProducts+nFragmentationProducts) );
// update List of alive particles. put energy deposit at the right place ...
for (i = 0; i < nAbsorptionProducts; i++)
{aParticleChange.AddSecondary((*absorptionProducts)[i]); }
if (absorptionProducts != 0) delete absorptionProducts;
// for (i = 0; i < nFragmentationProducts; i++)
// { aParticleChange.AddSecondary(fragmentationProducts->at(i)); }
for(i=0; i<nFragmentationProducts; i++)
{
G4DynamicParticle * aNew =
new G4DynamicParticle((*fragmentationProducts)[i]->GetDefinition(),
(*fragmentationProducts)[i]->GetTotalEnergy(),
(*fragmentationProducts)[i]->GetMomentum());
G4double newTime = aParticleChange.GetGlobalTime((*fragmentationProducts)[i]->GetFormationTime());
aParticleChange.AddSecondary(aNew, newTime);
delete (*fragmentationProducts)[i];
}
if (fragmentationProducts != 0) delete fragmentationProducts;
// finally ...
aParticleChange.ProposeTrackStatus(fStopAndKill); // Kill the incident Kaon
return &aParticleChange;
}
G4DynamicParticle G4KaonMinusAbsorptionAtRest::GetAbsorbingNucleon()
{
G4DynamicParticle aNucleon;
// Get nucleon definition, based on Z,N of current Nucleus
aNucleon.SetDefinition(SelectAbsorbingNucleon());
// Fermi momentum distribution in three dimensions
G4ThreeVector pFermi = nucleus->GetFermiMomentum();
aNucleon.SetMomentum(pFermi);
return aNucleon;
}
G4ParticleDefinition* G4KaonMinusAbsorptionAtRest::SelectAbsorbingNucleon()
{
// (Ch. Voelcker) extended from ReturnTargetParticle():
// Choose a proton or a neutron as the absorbing particle,
// taking weight into account!
// Update nucleon's atomic numbers.
G4ParticleDefinition* absorbingParticleDef;
G4double ranflat = G4UniformRand();
G4double myZ = nucleus->GetZ_asInt(); // number of protons
G4double myN = nucleus->GetA_asInt(); // number of nucleons (not neutrons!!)
// See VanderVelde-Wilquet et al, Nuov.Cim.39A(1978)538;
G4double carbonRatioNP = 0.18; // (Rn/Rp)c, see page 544
G4double neutronProtonRatio = NeutronHaloFactor(myZ,myN)*carbonRatioNP*(myN-myZ)/myZ;
G4double protonProbability = 1./(1.+neutronProtonRatio);
if ( ranflat < protonProbability )
{
absorbingParticleDef = G4Proton::Proton();
myZ-= 1.;
}
else
{ absorbingParticleDef = G4Neutron::Neutron(); }
myN -= 1.;
nucleus->SetParameters(myN,myZ);
return absorbingParticleDef;
}
G4double G4KaonMinusAbsorptionAtRest::NeutronHaloFactor(G4double Z, G4double N)
{
// this function should take care of the probability for absorption
// on neutrons, depending on number of protons Z and number of neutrons N-Z
// parametrisation from fit to
// VanderVelde-Wilquet et al, Nuov.Cim.39A(1978)538;
//
if (Z == 1.) return 1.389; // deuterium
else if (Z == 2.) return 1.78; // helium
else if (Z == 10.) return 0.66; // neon
else
return 0.6742+(N-Z)*0.06524;
}
G4DynamicParticleVector* G4KaonMinusAbsorptionAtRest::KaonNucleonReaction()
{
G4DynamicParticleVector* products = new G4DynamicParticleVector();
G4double ranflat = G4UniformRand();
G4double prob = 0;
G4ParticleDefinition* producedBaryonDef;
G4ParticleDefinition* producedMesonDef;
G4double iniZ = nucleus->GetZ_asInt();
G4double iniA = nucleus->GetA_asInt();
G4DynamicParticle aNucleon = GetAbsorbingNucleon();
// DHW 15 may 2011: unused: G4double nucleonMass;
if (aNucleon.GetDefinition() == G4Proton::Proton())
{
// DHW 15 May 2011: unused: nucleonMass = proton_mass_c2+electron_mass_c2;
if ( (prob += rateLambdaZeroPiZero) > ranflat)
{ // lambda pi0
producedBaryonDef = G4Lambda::Lambda();
producedMesonDef = G4PionZero::PionZero();
}
else if ((prob += rateSigmaPlusPiMinus) > ranflat)
{ // sigma+ pi-
producedBaryonDef = G4SigmaPlus::SigmaPlus();
producedMesonDef = G4PionMinus::PionMinus();
}
else if ((prob += rateSigmaMinusPiPlus) > ranflat)
{ // sigma- pi+
producedBaryonDef = G4SigmaMinus::SigmaMinus();
producedMesonDef = G4PionPlus::PionPlus();
}
else
{ // sigma0 pi0
producedBaryonDef = G4SigmaZero::SigmaZero();
producedMesonDef = G4PionZero::PionZero();
}
}
else if (aNucleon.GetDefinition() == G4Neutron::Neutron())
{
// DHW 15 May 2011: unused: nucleonMass = neutron_mass_c2;
if ((prob += rateLambdaZeroPiMinus) > ranflat)
{ // lambda pi-
producedBaryonDef = G4Lambda::Lambda();
producedMesonDef = G4PionMinus::PionMinus();
}
else if ((prob += rateSigmaZeroPiMinus) > ranflat)
{ // sigma0 pi-
producedBaryonDef = G4SigmaZero::SigmaZero();
producedMesonDef = G4PionMinus::PionMinus();
}
else
{ // sigma- pi0
producedBaryonDef = G4SigmaMinus::SigmaMinus();
producedMesonDef = G4PionZero::PionZero();
}
}
else
{
if (verboseLevel>0)
{
G4cout
<< "G4KaonMinusAbsorption::KaonNucleonReaction: "
<< aNucleon.GetDefinition()->GetParticleName()
<< " is not a good nucleon - check G4Nucleus::ReturnTargetParticle()!"
<< G4endl;
}
//A.R. 26-Jul-2012 Coverity fix
if ( products ) delete products;
return 0;
}
G4double newZ = nucleus->GetZ_asInt();
G4double newA = nucleus->GetA_asInt();
// Modify the Kaon mass to take nuclear binding energy into account
// .. using mas formula ..
// .. using mass table ..
// equivalent to -'initialBindingEnergy+nucleus.GetBindingEnergy' !
G4double nucleonBindingEnergy =
-G4NucleiProperties::GetBindingEnergy(static_cast<G4int>(iniA), static_cast<G4int>(iniZ) )
+G4NucleiProperties::GetBindingEnergy(static_cast<G4int>(newA), static_cast<G4int>(newZ) );
G4DynamicParticle modifiedHadron = (*stoppedHadron);
modifiedHadron.SetMass(stoppedHadron->GetMass() + nucleonBindingEnergy);
// Setup outgoing dynamic particles
G4ThreeVector dummy(0.,0.,0.);
G4DynamicParticle* producedBaryon = new G4DynamicParticle(producedBaryonDef,dummy);
G4DynamicParticle* producedMeson = new G4DynamicParticle(producedMesonDef,dummy);
// Produce the secondary particles in a twobody process:
G4ReactionKinematics theReactionKinematics;
theReactionKinematics.TwoBodyScattering( &modifiedHadron, &aNucleon,
producedBaryon, producedMeson);
products->push_back(producedBaryon);
products->push_back(producedMeson);
if (verboseLevel > 1)
{
G4cout
<< "G4KaonMinusAbsorption::KaonNucleonReaction: Number of primaries = "
<< products->size()
<< ": " <<producedMesonDef->GetParticleName()
<< ", " <<producedBaryonDef->GetParticleName() << G4endl;
}
return products;
}
G4bool G4KaonMinusAbsorptionAtRest::AbsorbPionByNucleus(G4DynamicParticle* aPion)
{
// Needs some more investigation!
G4double ranflat = G4UniformRand();
if (ranflat < pionAbsorptionRate){
// Add pion energy to ExcitationEnergy and NucleusMomentum
nucleus->AddExcitationEnergy(aPion->GetTotalEnergy());
nucleus->AddMomentum(aPion->GetMomentum());
}
return (ranflat < pionAbsorptionRate);
}
G4DynamicParticle* G4KaonMinusAbsorptionAtRest::SigmaLambdaConversion(G4DynamicParticle* aSigma)
{
G4double ranflat = G4UniformRand();
G4double sigmaLambdaConversionRate;
G4double A = nucleus->GetA_asInt();
G4double Z = nucleus->GetZ_asInt();
G4double newZ = Z;
// DHW 15 May 2011: unused: G4double nucleonMassDifference = 0;
G4ParticleDefinition* inNucleonDef=NULL;
G4ParticleDefinition* outNucleonDef=NULL;
// Decide which sigma
switch((int) aSigma->GetDefinition()->GetPDGCharge()) {
case 1:
sigmaLambdaConversionRate = sigmaPlusLambdaConversionRate;
inNucleonDef = G4Neutron::Neutron();
outNucleonDef = G4Proton::Proton();
newZ = Z+1;
// DHW 15 May 2011: unused: nucleonMassDifference = neutron_mass_c2 - proton_mass_c2-electron_mass_c2;
break;
case -1:
sigmaLambdaConversionRate = sigmaMinusLambdaConversionRate;
inNucleonDef = G4Proton::Proton();
outNucleonDef = G4Neutron::Neutron();
newZ = Z-1;
// DHW 15 May 2011: unused: nucleonMassDifference = proton_mass_c2+electron_mass_c2 - neutron_mass_c2;
break;
case 0:
sigmaLambdaConversionRate = sigmaZeroLambdaConversionRate;
// The 'outgoing' nucleon is just virtual, to keep the energy-momentum
// balance and will not appear in the ParticleChange. Therefore no need
// choose between neutron and proton here!
inNucleonDef = G4Neutron::Neutron();
outNucleonDef = G4Neutron::Neutron();
break;
default:
sigmaLambdaConversionRate = 0.;
// Add dummy particles to avoid possibility of passing NULL pointers
inNucleonDef = G4Proton::Proton();
outNucleonDef = G4Proton::Proton();
}
if (ranflat >= sigmaLambdaConversionRate) return 0;
G4ThreeVector dummy(0.,0.,0.);
// Fermi momentum distribution in three dimensions
G4ThreeVector momentum = nucleus->GetFermiMomentum();
G4ParticleDefinition* lambdaDef = G4Lambda::Lambda();
G4DynamicParticle inNucleon(inNucleonDef,momentum);
G4DynamicParticle outNucleon(outNucleonDef,dummy);
G4DynamicParticle* outLambda = new G4DynamicParticle(lambdaDef,dummy);
G4ReactionKinematics theReactionKinematics;
// Now do the twobody scattering
theReactionKinematics.TwoBodyScattering(aSigma, &inNucleon,
&outNucleon, outLambda);
// Binding energy of nucleus has changed. This will change the
// ExcitationEnergy.
// .. using mass formula ..
// .. using mass table ..
// equivalent to -'initialBindingEnergy+nucleus.GetBindingEnergy' !
// Add energy and momentum to nucleus, change Z,A
nucleus->AddExcitationEnergy(outNucleon.GetKineticEnergy());
nucleus->AddMomentum(outNucleon.GetMomentum());
nucleus->SetParameters(A,newZ);
// The calling routine is responsible to delete the sigma!!
return outLambda;
}
source/processes/hadronic/stopping/src/G4MuMinusCaptureCascade.cc
+3 -3
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4MuMinusCaptureCascade.cc 68700 2013-04-05 08:44:19Z gcosmo $
//
// G4MuonMinusCaptureAtRest physics process
//
@@ -73,11 +73,11 @@ G4double G4MuMinusCaptureCascade::GetKShellEnergy(G4double Z)
// the Energy of Hydrogen Atom taken into account finite size of the
// nucleus (V.Ivanchenko)
const G4int ListK = 28;
static G4double ListZK[ListK] = {
const G4double ListZK[ListK] = {
1., 2., 4., 6., 8., 11., 14., 17., 18., 21., 24.,
26., 29., 32., 38., 40., 41., 44., 49., 53., 55.,
60., 65., 70., 75., 81., 85., 92.};
static G4double ListKEnergy[ListK] = {
const G4double ListKEnergy[ListK] = {
0.00275, 0.011, 0.043, 0.098, 0.173, 0.326,
0.524, 0.765, 0.853, 1.146, 1.472,
1.708, 2.081, 2.475, 3.323, 3.627,
source/processes/hadronic/stopping/src/G4MuMinusCapturePrecompound.cc
+2 -1
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4MuMinusCapturePrecompound.cc 68700 2013-04-05 08:44:19Z gcosmo $
//
//-----------------------------------------------------------------------------
//
@@ -69,6 +69,7 @@ G4MuMinusCapturePrecompound::G4MuMinusCapturePrecompound(
fProton = G4Proton::Proton();
fNeutron = G4Neutron::Neutron();
fThreshold = 10*MeV;
fTime = 0.0;
fPreCompound = ptr;
if(!ptr) {
G4HadronicInteraction* p =
source/processes/hadronic/stopping/src/G4MuonMinusBoundDecay.cc
+237 -92
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4MuonMinusBoundDecay.cc 69573 2013-05-08 13:35:53Z gcosmo $
//
//-----------------------------------------------------------------------------
//
@@ -36,7 +36,14 @@
// Creation date: 24 April 2012 on base of G4MuMinusCaptureAtRest
//
// Modified:
//
// 04/23/2013 K.Genser Fixed a constant in computation of lambda
// as suggested by J P Miller/Y Oksuzian;
// Optimized and corrected lambda calculation/lookup
// 04/30/2013 K.Genser Improved GetMuonCaptureRate
// extended data and lookup to take both Z & A into account
// Improved GetMuonDecayRate by using Zeff instead of Z
// Extracted Zeff into GetMuonZeff
//
//----------------------------------------------------------------------
#include "G4MuonMinusBoundDecay.hh"
@@ -67,7 +74,7 @@ G4MuonMinusBoundDecay::~G4MuonMinusBoundDecay()
G4HadFinalState*
G4MuonMinusBoundDecay::ApplyYourself(const G4HadProjectile& projectile,
G4Nucleus& targetNucleus)
G4Nucleus& targetNucleus)
{
result.Clear();
G4int Z = targetNucleus.GetZ_asInt();
@@ -114,15 +121,15 @@ G4MuonMinusBoundDecay::ApplyYourself(const G4HadProjectile& projectile,
// Calculate electron energy
do {
do {
x = xmin + (xmax-xmin)*G4UniformRand();
x = xmin + (xmax-xmin)*G4UniformRand();
} while (G4UniformRand() > (3.0 - 2.0*x)*x*x );
Eelect = x*fMuMass*0.5;
Pelect = 0.0;
if(Eelect > electron_mass_c2) {
Pelect = std::sqrt(Eelect*Eelect - electron_mass_c2*electron_mass_c2);
Pelect = std::sqrt(Eelect*Eelect - electron_mass_c2*electron_mass_c2);
} else {
Pelect = 0.0;
Eelect = electron_mass_c2;
Pelect = 0.0;
Eelect = electron_mass_c2;
}
dir = G4RandomDirection();
EL = G4LorentzVector(Pelect*dir,Eelect);
@@ -139,8 +146,8 @@ G4MuonMinusBoundDecay::ApplyYourself(const G4HadProjectile& projectile,
// Create electron
//
G4DynamicParticle* dp = new G4DynamicParticle(G4Electron::Electron(),
EL.vect().unit(),
Eelect);
EL.vect().unit(),
Eelect);
AddNewParticle(dp, time);
//
@@ -164,105 +171,243 @@ G4MuonMinusBoundDecay::ApplyYourself(const G4HadProjectile& projectile,
G4double G4MuonMinusBoundDecay::GetMuonCaptureRate(G4int Z, G4int A)
{
// Initialized data
static G4double zeff[101] = { 0.,
1.,1.98,2.95,3.89,4.8,5.72,6.61,7.49,8.32,9.12,9.95,10.69,11.48,12.22,
12.91,13.64,14.24,14.89,15.53,16.15,16.75,17.38,18.04,18.49,
19.06,19.59,20.1,20.66,21.12,21.61,22.02,22.43,22.84,23.24,
23.65,24.06,24.47,24.85,25.23,25.61,25.99,26.37,26.69,27.,
27.32,27.63,27.95,28.2,28.42,28.64,28.79,29.03,29.27,29.51,
29.75,29.99,30.2,30.36,30.53,30.69,30.85,31.01,31.18,31.34,
31.48,31.62,31.76,31.9,32.05,32.19,32.33,32.47,32.61,32.76,
32.94,33.11,33.29,33.46,33.64,33.81,34.21,34.18,34.,34.1,
34.21,34.31,34.42,34.52,34.63,34.73,34.84,34.94,35.04,35.15,
35.25,35.36,35.46,35.57,35.67,35.78 };
// Mu- capture data from B.B.Balashov, G.Ya.Korenman, P.A.Eramgan
// Atomizdat, 1978. (Experimental capture velocities)
// Initialize data
// Mu- capture data from
// T. Suzuki, D. F. Measday, J.P. Roalsvig Phys.Rev. C35 (1987) 2212
// weighted average of the two most precise measurements
// Data for Hydrogen from Phys. Rev. Lett. 99(2007)032002
// Data for Helium from Phys. Rep. 354(2001)243
// Data for Helium from D.F. Measday Phys. Rep. 354(2001)243
const size_t ListZE = 67;
static G4int ListZExp[ListZE] = { 1, 2,
3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
13, 14, 15, 16, 17, 18, 19, 20, 22, 23,
24, 25, 26, 27, 28, 31, 32, 33, 34, 37,
38, 39, 40, 41, 42, 45, 46, 47, 48, 49,
50, 51, 52, 53, 55, 56, 57, 58, 59, 60,
62, 64, 65, 67, 72, 73, 74, 80, 81, 82,
83, 90, 92, 93};
struct capRate {
G4int Z;
G4int A;
G4double cRate;
G4double cRErr;
};
static G4double ListCaptureVel[ListZE] = { 0.000725, 0.000356,
0.0057, 0.010, 0.0258, 0.0371, 0.0644,
0.0974, 0.144, 0.250, 0.386, 0.479,
0.700, 0.849, 1.119, 1.338, 1.40,
1.30, 1.98, 2.45, 2.60, 3.19,
3.29, 3.91, 4.41, 4.96, 5.74,
5.68, 5.53, 6.06, 5.69, 6.89,
7.25, 7.89, 8.59, 10.40, 9.22,
10.01, 10.00, 10.88, 10.62, 11.37,
10.68, 10.49, 9.06, 11.20, 10.98,
10.18, 10.71, 11.44, 13.45, 12.32,
12.22, 12.09, 12.73, 12.95, 13.03,
12.86, 13.13, 13.39, 12.74, 13.78,
13.02, 13.26, 13.10, 14.00, 14.70};
// this struct has to be sorted by Z when initialized as we exit the
// loop once Z is above the stored value; cRErr are not used now but
// are included for completeness and future use
const capRate capRates [] = {
{ 1, 1, 0.000725, 0.000017 },
{ 2, 3, 0.002149, 0.00017 },
{ 2, 4, 0.000356, 0.000026 },
{ 3, 6, 0.004647, 0.00012 },
{ 3, 7, 0.002229, 0.00012 },
{ 4, 9, 0.006107, 0.00019 },
{ 5, 10, 0.02757 , 0.00063 },
{ 5, 11, 0.02188 , 0.00064 },
{ 6, 12, 0.03807 , 0.00031 },
{ 6, 13, 0.03474 , 0.00034 },
{ 7, 14, 0.06885 , 0.00057 },
{ 8, 16, 0.10242 , 0.00059 },
{ 8, 18, 0.0880 , 0.0015 },
{ 9, 19, 0.22905 , 0.00099 },
{ 10, 20, 0.2288 , 0.0045 },
{ 11, 23, 0.3773 , 0.0014 },
{ 12, 24, 0.4823 , 0.0013 },
{ 13, 27, 0.6985 , 0.0012 },
{ 14, 28, 0.8656 , 0.0015 },
{ 15, 31, 1.1681 , 0.0026 },
{ 16, 32, 1.3510 , 0.0029 },
{ 17, 35, 1.800 , 0.050 },
{ 17, 37, 1.250 , 0.050 },
{ 18, 40, 1.2727 , 0.0650 },
{ 19, 39, 1.8492 , 0.0050 },
{ 20, 40, 2.5359 , 0.0070 },
{ 21, 45, 2.711 , 0.025 },
{ 22, 48, 2.5908 , 0.0115 },
{ 23, 51, 3.073 , 0.022 },
{ 24, 50, 3.825 , 0.050 },
{ 24, 52, 3.465 , 0.026 },
{ 24, 53, 3.297 , 0.045 },
{ 24, 54, 3.057 , 0.042 },
{ 25, 55, 3.900 , 0.030 },
{ 26, 56, 4.408 , 0.022 },
{ 27, 59, 4.945 , 0.025 },
{ 28, 58, 6.11 , 0.10 },
{ 28, 60, 5.56 , 0.10 },
{ 28, 62, 4.72 , 0.10 },
{ 29, 63, 5.691 , 0.030 },
{ 30, 66, 5.806 , 0.031 },
{ 31, 69, 5.700 , 0.060 },
{ 32, 72, 5.561 , 0.031 },
{ 33, 75, 6.094 , 0.037 },
{ 34, 80, 5.687 , 0.030 },
{ 35, 79, 7.223 , 0.28 },
{ 35, 81, 7.547 , 0.48 },
{ 37, 85, 6.89 , 0.14 },
{ 38, 88, 6.93 , 0.12 },
{ 39, 89, 7.89 , 0.11 },
{ 40, 91, 8.620 , 0.053 },
{ 41, 93, 10.38 , 0.11 },
{ 42, 96, 9.298 , 0.063 },
{ 45, 103, 10.010 , 0.045 },
{ 46, 106, 10.000 , 0.070 },
{ 47, 107, 10.869 , 0.095 },
{ 48, 112, 10.624 , 0.094 },
{ 49, 115, 11.38 , 0.11 },
{ 50, 119, 10.60 , 0.11 },
{ 51, 121, 10.40 , 0.12 },
{ 52, 128, 9.174 , 0.074 },
{ 53, 127, 11.276 , 0.098 },
{ 55, 133, 10.98 , 0.25 },
{ 56, 138, 10.112 , 0.085 },
{ 57, 139, 10.71 , 0.10 },
{ 58, 140, 11.501 , 0.087 },
{ 59, 141, 13.45 , 0.13 },
{ 60, 144, 12.35 , 0.13 },
{ 62, 150, 12.22 , 0.17 },
{ 64, 157, 12.00 , 0.13 },
{ 65, 159, 12.73 , 0.13 },
{ 66, 163, 12.29 , 0.18 },
{ 67, 165, 12.95 , 0.13 },
{ 68, 167, 13.04 , 0.27 },
{ 72, 178, 13.03 , 0.21 },
{ 73, 181, 12.86 , 0.13 },
{ 74, 184, 12.76 , 0.16 },
{ 79, 197, 13.35 , 0.10 },
{ 80, 201, 12.74 , 0.18 },
{ 81, 205, 13.85 , 0.17 },
{ 82, 207, 13.295 , 0.071 },
{ 83, 209, 13.238 , 0.065 },
{ 90, 232, 12.555 , 0.049 },
{ 92, 238, 12.592 , 0.035 },
{ 92, 233, 14.27 , 0.15 },
{ 92, 235, 13.470 , 0.085 },
{ 92, 236, 13.90 , 0.40 },
{ 93, 237, 13.58 , 0.18 },
{ 94, 239, 13.90 , 0.20 },
{ 94, 242, 12.86 , 0.19 }
};
// Local variables
G4double zeff2, xmu, a2ze, r1, r2;
G4double lambda;
G4double lambda = -1.;
// == Effective charges from Ford and Wills Nucl Phys 35(1962)295.
// == Untabulated charges are interpolated.
// == Mu capture lifetime (Goulard and Primakoff PRC10(1974)2034.
G4int i = Z;
if(i > 100) { i = 100; }
const G4double b0a = -.03;
const G4double b0b = -.25;
const G4double b0c = 3.24;
const G4double t1 = 875.e-10;
r1 = zeff[i];
zeff2 = r1 * r1;
// ^-4 -> ^-5 suggested by user
xmu = zeff2 * 2.663e-5;
a2ze = 0.5 * A / Z;
r2 = 1.0 - xmu;
lambda = t1 * zeff2 * zeff2 * (r2 * r2) * (1.0 - (1.0 - xmu) * .75704) *
(a2ze * b0a + 1.0 - (a2ze - 1.0) * b0b -
(2 * (A - Z) + std::fabs(a2ze - 1.) ) * b0c / G4double(A * 4) );
// == Mu capture data are taken if exist
for (size_t j = 0; j < ListZE; ++j) {
if( ListZExp[j] == i + 1) {
lambda = ListCaptureVel[j] / microsecond;
size_t nCapRates = sizeof(capRates)/sizeof(capRates[0]);
for (size_t j = 0; j < nCapRates; ++j) {
if( capRates[j].Z == Z && capRates[j].A == A ) {
lambda = capRates[j].cRate / microsecond;
break;
}
// make sure the data is sorted for the next statement to work correctly
if (capRates[j].Z > Z) {break;}
}
if (lambda < 0.) {
// == Mu capture lifetime (Goulard and Primakoff PRC10(1974)2034.
const G4double b0a = -0.03;
const G4double b0b = -0.25;
const G4double b0c = 3.24;
const G4double t1 = 875.e-9; // -10-> -9 suggested by user
G4double r1 = GetMuonZeff(Z);
G4double zeff2 = r1 * r1;
// ^-4 -> ^-5 suggested by user
G4double xmu = zeff2 * 2.663e-5;
G4double a2ze = 0.5 *G4double(A) / G4double(Z);
G4double r2 = 1.0 - xmu;
lambda = t1 * zeff2 * zeff2 * (r2 * r2) * (1.0 - (1.0 - xmu) * .75704) *
(a2ze * b0a + 1.0 - (a2ze - 1.0) * b0b -
G4double(2 * (A - Z) + std::fabs(a2ze - 1.) ) * b0c / G4double(A * 4) );
}
return lambda;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4MuonMinusBoundDecay::GetMuonZeff(G4int Z)
{
// == Effective charges from
// "Total Nuclear Capture Rates for Negative Muons"
// T. Suzuki, D. F. Measday, J.P. Roalsvig Phys.Rev. C35 (1987) 2212
// and if not present from
// Ford and Wills Nucl Phys 35(1962)295 or interpolated
const size_t maxZ = 100;
const G4double zeff[maxZ+1] =
{ 0.,
1.00, 1.98, 2.94, 3.89, 4.81, 5.72, 6.61, 7.49, 8.32, 9.14,
9.95,10.69,11.48,12.22,12.90,13.64,14.24,14.89,15.53,16.15,
16.77,17.38,18.04,18.49,19.06,19.59,20.13,20.66,21.12,21.61,
22.02,22.43,22.84,23.24,23.65,24.06,24.47,24.85,25.23,25.61,
25.99,26.37,26.69,27.00,27.32,27.63,27.95,28.20,28.42,28.64,
28.79,29.03,29.27,29.51,29.75,29.99,30.22,30.36,30.53,30.69,
30.85,31.01,31.18,31.34,31.48,31.62,31.76,31.90,32.05,32.19,
32.33,32.47,32.61,32.76,32.94,33.11,33.29,33.46,33.64,33.81,
34.21,34.18,34.00,34.10,34.21,34.31,34.42,34.52,34.63,34.73,
34.84,34.94,35.05,35.16,35.25,35.36,35.46,35.57,35.67,35.78 };
if (Z<0) {Z=0;}
if (Z>G4int(maxZ)) {Z=maxZ;}
return zeff[Z];
}
G4double G4MuonMinusBoundDecay::GetMuonDecayRate(G4int Z)
{
// Decay time on K-shell
// N.C.Mukhopadhyay Phys. Rep. 30 (1977) 1.
G4double lambda = 1.0;
if(Z > 1) {
G4double x = Z*fine_structure_const;
lambda -= 2.5 * x * x;
if( 0.5 > lambda ) { lambda = 0.5; }
} else {
// this is the "small Z" approximation formula (2.9)
// Lambda(bound)/Lambda(free) = 1-beta(Z*alpha)**2 with beta~=2.5
// we assume that Z is Zeff
// Published value 0.455851 - Phys. Rev. Lett. 99(2007)032002
lambda = 1.00151;
// PDG 2012 muon lifetime value is 2.1969811(22) 10e-6s
// which when inverted gives 0.45517005 10e+6/s
struct decRate {
G4int Z;
G4double dRate;
G4double dRErr;
};
// this struct has to be sorted by Z when initialized as we exit the
// loop once Z is above the stored value
const decRate decRates [] = {
{ 1, 0.4558514, 0.0000151 }
};
G4double lambda = -1.;
// size_t nDecRates = sizeof(decRates)/sizeof(decRates[0]);
// for (size_t j = 0; j < nDecRates; ++j) {
// if( decRates[j].Z == Z ) {
// lambda = decRates[j].dRate / microsecond;
// break;
// }
// // make sure the data is sorted for the next statement to work
// if (decRates[j].Z > Z) {break;}
// }
// we'll use the above code once we have more data
// since we only have one value we just assign it
if (Z == 1) {lambda = decRates[0].dRate/microsecond;}
if (lambda < 0.) {
const G4double freeMuonDecayRate = 0.45517005 / microsecond;
lambda = 1.0;
G4double x = GetMuonZeff(Z)*fine_structure_const;
lambda -= 2.5 * x * x;
lambda *= freeMuonDecayRate;
}
return lambda * 0.445164 / microsecond;
return lambda;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
@@ -270,14 +415,14 @@ G4double G4MuonMinusBoundDecay::GetMuonDecayRate(G4int Z)
void G4MuonMinusBoundDecay::ModelDescription(std::ostream& outFile) const
{
outFile << "Sample probabilities of mu- nuclear capture of decay"
<< " from K-shell orbit.\n"
<< " Time of projectile is changed taking into account life time"
<< " of muonic atom.\n"
<< " If decay is sampled primary state become stopAndKill,"
<< " else - isAlive.\n"
<< "Based of reviews:\n"
<< " from K-shell orbit.\n"
<< " Time of projectile is changed taking into account life time"
<< " of muonic atom.\n"
<< " If decay is sampled primary state become stopAndKill,"
<< " else - isAlive.\n"
<< " Based of reviews:\n"
<< " N.C.Mukhopadhyay Phy. Rep. 30 (1977) 1.\n"
<< " B.B.Balashov, G.Ya.Korenman, P.A.Eramgan, Atomizdat, 1978.\n";
<< " T. Suzuki, D. F. Measday, J.P. Roalsvig Phys.Rev. C35 (1987) 2212\n";
}
source/processes/hadronic/stopping/src/G4MuonMinusCapture.cc
+6 -5
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4MuonMinusCapture.cc 74377 2013-10-04 08:29:54Z gcosmo $
//
//---------------------------------------------------------------------
//
@@ -43,7 +43,8 @@
// 20121003 K. Genser -- Changed the constructor argument type
// Used two argument base constructor
// 20121016 K. Genser -- Reverting to use one argument base c'tor
//
// 20121002 K. Genser -- Replaced G4MuMinusCapturePrecompound with
// G4CascadeInterface (Bertini)
//------------------------------------------------------------------------
#include "G4MuonMinusCapture.hh"
@@ -51,7 +52,7 @@
#include "G4MuonMinusBoundDecay.hh"
#include "G4HadronicInteraction.hh"
#include "G4MuonMinus.hh"
#include "G4MuMinusCapturePrecompound.hh"
#include "G4CascadeInterface.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
@@ -60,7 +61,7 @@ G4MuonMinusCapture::G4MuonMinusCapture(G4HadronicInteraction* hiptr)
{
SetBoundDecay(new G4MuonMinusBoundDecay()); // Owned by InteractionRegistry
if (!hiptr) {
hiptr = new G4MuMinusCapturePrecompound(); // Owned by InteractionRegistry
hiptr = new G4CascadeInterface(); // Owned by InteractionRegistry
}
RegisterMe(hiptr);
}
@@ -83,7 +84,7 @@ void G4MuonMinusCapture::ProcessDescription(std::ostream& outFile) const
{
outFile << "Stopping of mu- using default element selector, EM cascade"
<< " sampling and bound decay sampling.\n"
<< "Native PreCompound model is used for nuclear capture\n";
<< "Bertini model is used for nuclear capture\n";
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
source/processes/hadronic/stopping/src/G4MuonMinusCaptureAtRest.cc
+2 -2
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4MuonMinusCaptureAtRest.cc 70681 2013-06-04 07:54:04Z gcosmo $
//
// G4MuonMinusCaptureAtRest physics process
// Larry Felawka (TRIUMF) and Art Olin (TRIUMF)
@@ -264,7 +264,7 @@ G4ReactionProductVector* G4MuonMinusCaptureAtRest::DoMuCapture()
} else if(ia == 4) {
pd = G4Triton::Triton();
} else {
pd = G4ParticleTable::GetParticleTable()->FindIon(1,ia-1,0,1);
pd = G4ParticleTable::GetParticleTable()->GetIonTable()->GetIon(1,ia-1,0);
}
// G4cout << "Extra " << pd->GetParticleName() << G4endl;
source/processes/hadronic/stopping/src/G4NeutronCaptureAtRest.cc
-431
View File
@@ -1,431 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// G4NeutronCaptureAtRest physics process
// Larry Felawka (TRIUMF), April 1998
//---------------------------------------------------------------------
#include <string.h>
#include <cmath>
#include <stdio.h>
#include "G4NeutronCaptureAtRest.hh"
#include "G4SystemOfUnits.hh"
#include "G4DynamicParticle.hh"
#include "G4ParticleTypes.hh"
#include "Randomize.hh"
#include "G4HadronicProcessStore.hh"
#include "G4HadronicDeprecate.hh"
#define MAX_SECONDARIES 100
// constructor
G4NeutronCaptureAtRest::G4NeutronCaptureAtRest(const G4String& processName,
G4ProcessType aType ) :
G4VRestProcess (processName, aType), // initialization
massProton(G4Proton::Proton()->GetPDGMass()/GeV),
massNeutron(G4Neutron::Neutron()->GetPDGMass()/GeV),
massElectron(G4Electron::Electron()->GetPDGMass()/GeV),
massDeuteron(G4Deuteron::Deuteron()->GetPDGMass()/GeV),
massAlpha(G4Alpha::Alpha()->GetPDGMass()/GeV),
pdefGamma(G4Gamma::Gamma()),
pdefNeutron(G4Neutron::Neutron())
{
G4HadronicDeprecate("G4NeutronCaptureAtRest");
if (verboseLevel>0) {
G4cout << GetProcessName() << " is created "<< G4endl;
}
SetProcessSubType(fHadronAtRest);
pv = new G4GHEKinematicsVector [MAX_SECONDARIES+1];
eve = new G4GHEKinematicsVector [MAX_SECONDARIES];
gkin = new G4GHEKinematicsVector [MAX_SECONDARIES];
G4HadronicProcessStore::Instance()->RegisterExtraProcess(this);
}
// destructor
G4NeutronCaptureAtRest::~G4NeutronCaptureAtRest()
{
G4HadronicProcessStore::Instance()->DeRegisterExtraProcess(this);
delete [] pv;
delete [] eve;
delete [] gkin;
}
void G4NeutronCaptureAtRest::PreparePhysicsTable(const G4ParticleDefinition& p)
{
G4HadronicProcessStore::Instance()->RegisterParticleForExtraProcess(this, &p);
}
void G4NeutronCaptureAtRest::BuildPhysicsTable(const G4ParticleDefinition& p)
{
G4HadronicProcessStore::Instance()->PrintInfo(&p);
}
// methods.............................................................................
G4bool G4NeutronCaptureAtRest::IsApplicable(
const G4ParticleDefinition& particle
)
{
return ( &particle == pdefNeutron );
}
// Warning - this method may be optimized away if made "inline"
G4int G4NeutronCaptureAtRest::GetNumberOfSecondaries()
{
return ( ngkine );
}
// Warning - this method may be optimized away if made "inline"
G4GHEKinematicsVector* G4NeutronCaptureAtRest::GetSecondaryKinematics()
{
return ( &gkin[0] );
}
G4double G4NeutronCaptureAtRest::AtRestGetPhysicalInteractionLength(
const G4Track& track,
G4ForceCondition* condition
)
{
// beggining of tracking
ResetNumberOfInteractionLengthLeft();
// condition is set to "Not Forced"
*condition = NotForced;
// get mean life time
currentInteractionLength = GetMeanLifeTime(track, condition);
if ((currentInteractionLength <0.0) || (verboseLevel>2)){
G4cout << "G4NeutronCaptureAtRestProcess::AtRestGetPhysicalInteractionLength ";
G4cout << "[ " << GetProcessName() << "]" <<G4endl;
track.GetDynamicParticle()->DumpInfo();
G4cout << " in Material " << track.GetMaterial()->GetName() <<G4endl;
G4cout << "MeanLifeTime = " << currentInteractionLength/ns << "[ns]" <<G4endl;
}
return theNumberOfInteractionLengthLeft * currentInteractionLength;
}
G4VParticleChange* G4NeutronCaptureAtRest::AtRestDoIt(
const G4Track& track,
const G4Step&
)
//
// Handles Neutrons at rest; a Neutron can either create secondaries or
// do nothing (in which case it should be sent back to decay-handling
// section
//
{
// Initialize ParticleChange
// all members of G4VParticleChange are set to equal to
// corresponding member in G4Track
aParticleChange.Initialize(track);
// Store some global quantities that depend on current material and particle
globalTime = track.GetGlobalTime()/s;
G4Material * aMaterial = track.GetMaterial();
const G4int numberOfElements = aMaterial->GetNumberOfElements();
const G4ElementVector* theElementVector = aMaterial->GetElementVector();
const G4double* theAtomicNumberDensity = aMaterial->GetAtomicNumDensityVector();
G4double normalization = 0;
for ( G4int i1=0; i1 < numberOfElements; i1++ )
{
normalization += theAtomicNumberDensity[i1] ; // change when nucleon specific
// probabilities are included.
}
G4double runningSum= 0.;
G4double random = G4UniformRand()*normalization;
for ( G4int i2=0; i2 < numberOfElements; i2++ )
{
runningSum += theAtomicNumberDensity[i2]; // change when nucleon specific
// probabilities are included.
if (random<=runningSum)
{
targetCharge = G4double((*theElementVector)[i2]->GetZ());
targetAtomicMass = (*theElementVector)[i2]->GetN();
}
}
if (random>runningSum)
{
targetCharge = G4double((*theElementVector)[numberOfElements-1]->GetZ());
targetAtomicMass = (*theElementVector)[numberOfElements-1]->GetN();
}
if (verboseLevel>1) {
G4cout << "G4NeutronCaptureAtRest::AtRestDoIt is invoked " <<G4endl;
}
G4ParticleMomentum momentum;
G4float localtime;
G4ThreeVector position = track.GetPosition();
GenerateSecondaries(); // Generate secondaries
aParticleChange.SetNumberOfSecondaries( ngkine );
for ( G4int isec = 0; isec < ngkine; isec++ ) {
G4DynamicParticle* aNewParticle = new G4DynamicParticle;
aNewParticle->SetDefinition( gkin[isec].GetParticleDef() );
aNewParticle->SetMomentum( gkin[isec].GetMomentum() * GeV );
localtime = globalTime + gkin[isec].GetTOF();
G4Track* aNewTrack = new G4Track( aNewParticle, localtime*s, position );
aNewTrack->SetTouchableHandle(track.GetTouchableHandle());
aParticleChange.AddSecondary( aNewTrack );
}
aParticleChange.ProposeLocalEnergyDeposit( 0.0*GeV );
aParticleChange.ProposeTrackStatus(fStopAndKill); // Kill the incident Neutron
// clear InteractionLengthLeft
ResetNumberOfInteractionLengthLeft();
return &aParticleChange;
}
void G4NeutronCaptureAtRest::GenerateSecondaries()
{
static G4int index;
static G4int l;
static G4int nopt;
static G4int i;
// DHW 15 May 2011: unused: static G4ParticleDefinition* jnd;
for (i = 1; i <= MAX_SECONDARIES; ++i) {
pv[i].SetZero();
}
ngkine = 0; // number of generated secondary particles
ntot = 0;
result.SetZero();
result.SetMass( massNeutron );
result.SetKineticEnergyAndUpdate( 0. );
result.SetTOF( 0. );
result.SetParticleDef( pdefNeutron );
NeutronCapture(&nopt);
// *** CHECK WHETHER THERE ARE NEW PARTICLES GENERATED ***
if (ntot != 0 || result.GetParticleDef() != pdefNeutron) {
// *** CURRENT PARTICLE IS NOT THE SAME AS IN THE BEGINNING OR/AND ***
// *** ONE OR MORE SECONDARIES HAVE BEEN GENERATED ***
// --- INITIAL PARTICLE TYPE HAS BEEN CHANGED ==> PUT NEW TYPE ON ---
// --- THE GEANT TEMPORARY STACK ---
// --- PUT PARTICLE ON THE STACK ---
gkin[0] = result;
gkin[0].SetTOF( result.GetTOF() * 5e-11 );
ngkine = 1;
// --- ALL QUANTITIES ARE TAKEN FROM THE GHEISHA STACK WHERE THE ---
// --- CONVENTION IS THE FOLLOWING ---
// --- ONE OR MORE SECONDARIES HAVE BEEN GENERATED ---
for (l = 1; l <= ntot; ++l) {
index = l - 1;
// DHW 15 May 2011: unused: jnd = eve[index].GetParticleDef();
// --- ADD PARTICLE TO THE STACK IF STACK NOT YET FULL ---
if (ngkine < MAX_SECONDARIES) {
gkin[ngkine] = eve[index];
gkin[ngkine].SetTOF( eve[index].GetTOF() * 5e-11 );
++ngkine;
}
}
}
else {
// --- NO SECONDARIES GENERATED AND PARTICLE IS STILL THE SAME ---
// --- ==> COPY EVERYTHING BACK IN THE CURRENT GEANT STACK ---
ngkine = 0;
ntot = 0;
globalTime += result.GetTOF() * G4float(5e-11);
}
// --- LIMIT THE VALUE OF NGKINE IN CASE OF OVERFLOW ---
ngkine = G4int(std::min(ngkine,G4int(MAX_SECONDARIES)));
} // GenerateSecondaries
void G4NeutronCaptureAtRest::Normal(G4float *ran)
{
static G4int i;
// *** NVE 14-APR-1988 CERN GENEVA ***
// ORIGIN : H.FESEFELDT (27-OCT-1983)
*ran = G4float(-6.);
for (i = 1; i <= 12; ++i) {
*ran += G4UniformRand();
}
} // Normal
void G4NeutronCaptureAtRest::NeutronCapture(G4int *nopt)
{
static G4int nt;
static G4float xp, pcm;
static G4float ran;
// *** ROUTINE FOR CAPTURE OF NEUTRAL BARYONS ***
// *** NVE 04-MAR-1988 CERN GENEVA ***
// ORIGIN : H.FESEFELDT (02-DEC-1986)
*nopt = 1;
pv[1] = result;
pv[2].SetZero();
pv[2].SetMass( AtomAs(targetAtomicMass, targetCharge) );
pv[2].SetMomentumAndUpdate( 0., 0., 0. );
pv[2].SetTOF( result.GetTOF() );
pv[2].SetParticleDef( NULL );
pv[MAX_SECONDARIES].Add( pv[1], pv[2] );
pv[MAX_SECONDARIES].SetMomentum( -pv[MAX_SECONDARIES].GetMomentum().x(), -pv[MAX_SECONDARIES].GetMomentum().y(), -pv[MAX_SECONDARIES].GetMomentum().z() );
pv[MAX_SECONDARIES].SetParticleDef( NULL );
Normal(&ran);
pcm = ran * G4float(.001) + G4float(.0065);
ran = G4UniformRand();
result.SetTOF( result.GetTOF() - std::log(ran) * G4float(480.) );
pv[3].SetZero();
pv[3].SetMass( 0. );
pv[3].SetKineticEnergyAndUpdate( pcm );
pv[3].SetTOF( result.GetTOF() );
pv[3].SetParticleDef( pdefGamma );
pv[3].Lor( pv[3], pv[MAX_SECONDARIES] );
nt = 3;
xp = G4float(.008) - pcm;
if (xp >= G4float(0.)) {
nt = 4;
pv[4].SetZero();
pv[4].SetMass( 0. );
pv[4].SetKineticEnergyAndUpdate( xp );
pv[4].SetTOF( result.GetTOF() );
pv[4].SetParticleDef( pdefGamma );
pv[4].Lor( pv[4], pv[MAX_SECONDARIES] );
}
result = pv[3];
if (nt == 4) {
if (ntot < MAX_SECONDARIES-1) {
eve[ntot++] = pv[4];
}
}
} // NeutronCapture
G4double G4NeutronCaptureAtRest::AtomAs(G4float a, G4float z)
{
G4float ret_val;
G4double d__1, d__2;
static G4double aa;
static G4int ia, iz;
static G4double zz;
static G4float rma, rmd;
static G4int ipp;
static G4float rmn, rmp;
static G4int izz;
static G4float rmel;
static G4double mass;
// *** DETERMINATION OF THE ATOMIC MASS ***
// *** NVE 19-MAY-1988 CERN GENEVA ***
// ORIGIN : H.FESEFELDT (02-DEC-1986)
// --- GET ATOMIC (= ELECTRONS INCL.) MASSES (IN MEV) FROM RMASS ARRAY ---
// --- ELECTRON ---
rmel = massElectron * G4float(1e3);
// --- PROTON ---
rmp = massProton * G4float(1e3);
// --- NEUTRON ---
rmn = massNeutron * G4float(1e3);
// --- DEUTERON ---
rmd = massDeuteron * G4float(1e3) + rmel;
// --- ALPHA ---
rma = massAlpha * G4float(1e3) + rmel * G4float(2.);
ret_val = G4float(0.);
aa = a * 1.;
zz = z * 1.;
ia = G4int(a + G4float(.5));
if (ia < 1) {
return ret_val;
}
iz = G4int(z + G4float(.5));
if (iz < 0 || iz > ia) {
return ret_val;
}
mass = 0.;
if (ia == 1) {
if (iz == 0) {
mass = rmn;
}
else if (iz == 1) {
mass = rmp + rmel;
}
}
else if (ia == 2 && iz == 1) {
mass = rmd;
}
else if (ia == 4 && iz == 2) {
mass = rma;
}
else if ( (ia == 2 && iz != 1) || ia == 3 || (ia == 4 && iz != 2) || ia > 4) {
d__1 = aa / G4float(2.) - zz;
d__2 = zz;
mass = (aa - zz) * rmn + zz * rmp + zz * rmel - aa * G4float(15.67) +
std::pow(aa, .6666667) * G4float(17.23) + d__1 * d__1 * G4float(93.15) / aa +
d__2 * d__2 * G4float(.6984523) / std::pow(aa, .3333333);
ipp = (ia - iz) % 2;
izz = iz % 2;
if (ipp == izz) {
mass += (ipp + izz - 1) * G4float(12.) * std::pow(aa, -.5);
}
}
ret_val = mass * G4float(.001);
return ret_val;
} // AtomAs
source/processes/hadronic/stopping/src/G4PiMinusAbsorptionAtRest.cc
-290
View File
@@ -1,290 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusAbsorptionAtRest.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 8 May 1998
//
// Modifications:
// MGP 4 Jul 1998 Changed excitation energy calculation
// MGP 14 Sep 1998 Fixed excitation energy calculation
//
// -------------------------------------------------------------------
#include "G4ios.hh"
#include "G4PiMinusAbsorptionAtRest.hh"
#include "G4SystemOfUnits.hh"
#include "G4PiMinusStopLi.hh"
#include "G4PiMinusStopC.hh"
#include "G4PiMinusStopN.hh"
#include "G4PiMinusStopO.hh"
#include "G4PiMinusStopAl.hh"
#include "G4PiMinusStopCu.hh"
#include "G4PiMinusStopCo.hh"
#include "G4PiMinusStopTa.hh"
#include "G4PiMinusStopPb.hh"
#include "G4StopTheoDeexcitation.hh"
#include "G4StopDummyDeexcitation.hh"
#include "G4DynamicParticle.hh"
#include "G4DynamicParticleVector.hh"
#include "Randomize.hh"
#include "G4ThreeVector.hh"
#include "G4LorentzVector.hh"
#include "G4HadronicProcessStore.hh"
#include "G4HadronicDeprecate.hh"
// Constructor
G4PiMinusAbsorptionAtRest::G4PiMinusAbsorptionAtRest(const G4String& processName,
G4ProcessType aType) :
G4VRestProcess (processName, aType)
{
G4HadronicDeprecate("G4PiMinusAbsorptionAtRest");
SetProcessSubType(fHadronAtRest);
_indexDeexcitation = 0;
if (verboseLevel>0)
{ G4cout << GetProcessName() << " is created "<< G4endl; }
G4HadronicProcessStore::Instance()->RegisterExtraProcess(this);
}
// Destructor
G4PiMinusAbsorptionAtRest::~G4PiMinusAbsorptionAtRest()
{
G4HadronicProcessStore::Instance()->DeRegisterExtraProcess(this);
}
void G4PiMinusAbsorptionAtRest::PreparePhysicsTable(const G4ParticleDefinition& p)
{
G4HadronicProcessStore::Instance()->RegisterParticleForExtraProcess(this, &p);
}
void G4PiMinusAbsorptionAtRest::BuildPhysicsTable(const G4ParticleDefinition& p)
{
G4HadronicProcessStore::Instance()->PrintInfo(&p);
}
G4VParticleChange* G4PiMinusAbsorptionAtRest::AtRestDoIt(const G4Track& track, const G4Step& )
{
const G4DynamicParticle* stoppedHadron = track.GetDynamicParticle();
// Check applicability
if (! IsApplicable(*(stoppedHadron->GetDefinition())))
{
G4cerr
<< "G4PiMinusAbsorptionAtRest: ERROR, particle must be a pion minus!"
<< G4endl;
return NULL;
}
// Get the current material
const G4Material* material = track.GetMaterial();
G4double A=-1;
G4double Z=-1;
G4double random = G4UniformRand();
const G4ElementVector* theElementVector = material->GetElementVector();
unsigned int i;
G4double sum = 0;
G4double totalsum=0;
for(i=0; i<material->GetNumberOfElements(); ++i)
{
if((*theElementVector)[i]->GetZ()!=1) totalsum+=material->GetFractionVector()[i];
}
for (i = 0; i<material->GetNumberOfElements(); ++i)
{
if((*theElementVector)[i]->GetZ()!=1) sum += material->GetFractionVector()[i];
if ( sum/totalsum > random )
{
A = (*theElementVector)[i]->GetA()*mole/g;
Z = (*theElementVector)[i]->GetZ();
break;
}
}
// Do the interaction with the nucleon cluster
G4PiMinusStopMaterial* algorithm = LoadAlgorithm(static_cast<G4int>(Z));
G4PiMinusStopAbsorption stopAbsorption(algorithm,Z,A);
stopAbsorption.SetVerboseLevel(verboseLevel);
G4DynamicParticleVector* absorptionProducts = stopAbsorption.DoAbsorption();
// Deal with the leftover nucleus
G4double pionEnergy = stoppedHadron->GetTotalEnergy();
G4double excitation = pionEnergy - stopAbsorption.Energy();
if (excitation < 0.)
{
G4Exception("G4PiMinusAbsorptionAtRest::AtRestDoIt()", "HAD_STOP_0000",
FatalException, "Excitation energy < 0");
}
if (verboseLevel>0) { G4cout << " excitation " << excitation << G4endl; }
G4StopDeexcitationAlgorithm* nucleusAlgorithm = LoadNucleusAlgorithm();
G4StopDeexcitation stopDeexcitation(nucleusAlgorithm);
G4double newZ = Z - stopAbsorption.NProtons();
G4double newN = A - Z - stopAbsorption.NNeutrons();
G4double newA = newZ + newN;
G4ReactionProductVector* fragmentationProducts = stopDeexcitation.DoBreakUp(newA,newZ,excitation,stopAbsorption.RecoilMomentum());
unsigned int nAbsorptionProducts = 0;
if (absorptionProducts != 0)
{ nAbsorptionProducts = absorptionProducts->size(); }
unsigned int nFragmentationProducts = 0;
if (fragmentationProducts != 0)
{ nFragmentationProducts = fragmentationProducts->size(); }
if (verboseLevel>0)
{
G4cout << "nAbsorptionProducts = " << nAbsorptionProducts
<< " nFragmentationProducts = " << nFragmentationProducts
<< G4endl;
}
// Deal with ParticleChange final state
aParticleChange.Initialize(track);
aParticleChange.SetNumberOfSecondaries(G4int(nAbsorptionProducts + nFragmentationProducts));
for (i = 0; i<nAbsorptionProducts; i++)
{ aParticleChange.AddSecondary((*absorptionProducts)[i]); }
// for (i = 0; i<nFragmentationProducts; i++)
// { aParticleChange.AddSecondary(fragmentationProducts->at(i)); }
for(i=0; i<nFragmentationProducts; i++)
{
G4DynamicParticle * aNew =
new G4DynamicParticle((*fragmentationProducts)[i]->GetDefinition(),
(*fragmentationProducts)[i]->GetMomentum());
G4double newTime = aParticleChange.GetGlobalTime((*fragmentationProducts)[i]->GetFormationTime());
aParticleChange.AddSecondary(aNew, newTime);
delete (*fragmentationProducts)[i];
}
if (fragmentationProducts != 0) delete fragmentationProducts;
if (_indexDeexcitation == 1) aParticleChange.ProposeLocalEnergyDeposit(excitation);
// Kill the absorbed pion
aParticleChange.ProposeTrackStatus(fStopAndKill);
return &aParticleChange;
}
G4PiMinusStopMaterial* G4PiMinusAbsorptionAtRest::LoadAlgorithm(int Z)
{
if (verboseLevel>0)
{
G4cout << "Load material algorithm " << Z << G4endl;
}
G4int index = 0;
if (Z > 0 && Z < 4) {index = 3;}
if (Z > 3 && Z < 7) {index = 6;}
if (Z == 7) {index = 7;}
if (Z >= 8 && Z<= 11) {index = 8;}
if (Z >= 12 && Z<= 18) {index = 13;}
if (Z >=19 && Z<= 27) {index = 27;}
if (Z >= 28 && Z<= 51) {index = 29;}
if (Z >=52 ) {index = 73;}
switch (index)
{
case 3:
if (verboseLevel>0)
{ G4cout << " =================== Load Li algorithm " << G4endl; }
return new G4PiMinusStopLi();
case 6:
if (verboseLevel>0)
{ G4cout << " =================== Load C algorithm " << G4endl; }
return new G4PiMinusStopC();
case 7:
if (verboseLevel>0)
{ G4cout << " =================== Load N algorithm " << G4endl; }
return new G4PiMinusStopN();
case 8:
if (verboseLevel>0)
{ G4cout << " =================== Load O algorithm " << G4endl; }
return new G4PiMinusStopO();
case 13:
if (verboseLevel>0)
{ G4cout << " =================== Load Al algorithm " << G4endl; }
return new G4PiMinusStopAl();
case 27:
if (verboseLevel>0)
{ G4cout << " =================== Load Cu algorithm " << G4endl; }
return new G4PiMinusStopCu();
case 29:
if (verboseLevel>0)
{ G4cout << " =================== Load Co algorithm " << G4endl; }
return new G4PiMinusStopCo();
case 73:
if (verboseLevel>0)
{ G4cout << " =================== Load Ta algorithm " << G4endl; }
return new G4PiMinusStopTa();
default:
if (verboseLevel>0)
{ G4cout << " =================== Load default material algorithm " << G4endl; }
return new G4PiMinusStopC();
}
}
G4StopDeexcitationAlgorithm* G4PiMinusAbsorptionAtRest::LoadNucleusAlgorithm()
{
switch (_indexDeexcitation)
{
case 0:
if (verboseLevel>0)
{ G4cout << " =================== Load Theo deexcitation " << G4endl; }
return new G4StopTheoDeexcitation();
case 1:
if (verboseLevel>0)
{ G4cout << " =================== Load Dummy deexcitation " << G4endl; }
return new G4StopDummyDeexcitation();
default:
if (verboseLevel>0)
{ G4cout << " =================== Load default deexcitation " << G4endl; }
return new G4StopTheoDeexcitation();
}
}
void G4PiMinusAbsorptionAtRest::SetDeexcitationAlgorithm(G4int index)
{
_indexDeexcitation = index;
}
source/processes/hadronic/stopping/src/G4PiMinusStopAbsorption.cc
-213
View File
@@ -1,213 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusStopAbsorption
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 8 May 1998
//
// -------------------------------------------------------------------
#include "G4PiMinusStopAbsorption.hh"
#include <vector>
#include "globals.hh"
#include "Randomize.hh"
#include "G4NucleiProperties.hh"
#include "G4ParticleTypes.hh"
#include "G4Nucleus.hh"
#include "G4ReactionKinematics.hh"
#include "G4DynamicParticleVector.hh"
#include "G4ParticleDefinition.hh"
#include "G4Proton.hh"
#include "G4Neutron.hh"
#include "G4ThreeVector.hh"
#include "G4HadronicDeprecate.hh"
// Constructor
G4PiMinusStopAbsorption::G4PiMinusStopAbsorption(G4PiMinusStopMaterial* materialAlgo,
const G4double Z, const G4double A)
{
G4HadronicDeprecate("G4PiMinusStopAbsorption");
_materialAlgo = materialAlgo;
_nucleusZ = Z;
_nucleusA = A;
_level = 0;
_absorptionProducts = new G4DynamicParticleVector();
}
// Destructor
G4PiMinusStopAbsorption::~G4PiMinusStopAbsorption()
{
// Memory management of materialAlgo needs better thought (MGP)
delete _materialAlgo;
// Who owns it? Memory management is not clear... (MGP)
// _absorptionProducts->clearAndDestroy();
delete _absorptionProducts;
}
G4DynamicParticleVector* G4PiMinusStopAbsorption::DoAbsorption()
{
std::vector<G4ParticleDefinition*>* defNucleons = _materialAlgo->DefinitionVector();
G4double newA = _nucleusA;
G4double newZ = _nucleusZ;
if (defNucleons != 0)
{
for (unsigned int i=0; i<defNucleons->size(); i++)
{
if ( (*defNucleons)[i] == G4Proton::Proton())
{
newA = newA - 1;
newZ = newZ - 1;
}
if ((*defNucleons)[i] == G4Neutron::Neutron())
{ newA = newA - 1; }
}
}
G4double binding = G4NucleiProperties::GetBindingEnergy(static_cast<G4int>(_nucleusA) ,static_cast<G4int>(_nucleusZ)) / _nucleusA;
G4double mass = G4NucleiProperties::GetNuclearMass(static_cast<G4int>(newA),static_cast<G4int>(newZ));
std::vector<G4LorentzVector*>* p4Nucleons = _materialAlgo->P4Vector(binding,mass);
if (defNucleons != 0 && p4Nucleons != 0)
{
unsigned int nNucleons = p4Nucleons->size();
G4double seen = _materialAlgo->FinalNucleons() / 2.;
G4int maxN = nNucleons;
if (defNucleons->size() < nNucleons) { maxN = defNucleons->size(); }
for (G4int i=0; i<maxN; i++)
{
G4DynamicParticle* product;
if ((*defNucleons)[i] == G4Proton::Proton())
{ product = new G4DynamicParticle(G4Proton::Proton(),*((*p4Nucleons)[i])); }
else
{ product = new G4DynamicParticle(G4Neutron::Neutron(),*((*p4Nucleons)[i])); }
G4double ranflat = G4UniformRand();
if (ranflat < seen)
{ _absorptionProducts->push_back(product); }
else
{ delete product; }
}
}
return _absorptionProducts;
}
G4ThreeVector G4PiMinusStopAbsorption::RecoilMomentum()
{
G4ThreeVector pProducts(0.,0.,0.);
for (unsigned int i = 0; i< _absorptionProducts->size(); i++)
{
pProducts = pProducts + (*_absorptionProducts)[i]->GetMomentum();
}
return pProducts;
}
G4int G4PiMinusStopAbsorption::NProtons()
{
G4int n = 0;
G4int entries = _absorptionProducts->size();
for (int i = 0; i<entries; i++)
{
if ((*_absorptionProducts)[i]->GetDefinition() == G4Proton::Proton())
{ n = n + 1; }
}
return n;
}
G4int G4PiMinusStopAbsorption::NNeutrons()
{
G4int n = 0;
G4int entries = _absorptionProducts->size();
for (int i = 0; i<entries; i++)
{
if ((*_absorptionProducts)[i]->GetDefinition() == G4Neutron::Neutron())
{ n = n + 1; }
}
return n;
}
G4double G4PiMinusStopAbsorption::Energy()
{
G4double energy = 0.;
G4double productEnergy = 0.;
G4ThreeVector pProducts(0.,0.,0.);
G4int nN = 0;
G4int nP = 0;
G4int nAbsorptionProducts = _absorptionProducts->size();
for (int i = 0; i<nAbsorptionProducts; i++)
{
productEnergy += (*_absorptionProducts)[i]->GetKineticEnergy();
pProducts = pProducts + (*_absorptionProducts)[i]->GetMomentum();
if ((*_absorptionProducts)[i]->GetDefinition() == G4Neutron::Neutron()) nN++;
if ((*_absorptionProducts)[i]->GetDefinition() == G4Proton::Proton()) nP++;
}
G4double productBinding = (G4NucleiProperties::GetBindingEnergy(static_cast<G4int>(_nucleusA),static_cast<G4int>(_nucleusZ)) / _nucleusA) * nAbsorptionProducts;
G4double mass = G4NucleiProperties::GetNuclearMass(_nucleusA - (nP + nN),_nucleusZ - nP);
G4double pNucleus = pProducts.mag();
G4double eNucleus = std::sqrt(pNucleus*pNucleus + mass*mass);
G4double tNucleus = eNucleus - mass;
G4double temp =
G4NucleiProperties::GetBindingEnergy(static_cast<G4int>(_nucleusA - (nP + nN)),static_cast<G4int>(_nucleusZ - nP)) -
G4NucleiProperties::GetBindingEnergy(static_cast<G4int>(_nucleusA),static_cast<G4int>(_nucleusZ));
energy = productEnergy + productBinding + tNucleus;
if (_level > 0)
{
std::cout << "E products " << productEnergy
<< " Binding " << productBinding << " " << temp << " "
<< " Tnucleus " << tNucleus
<< " energy = " << energy << G4endl;
}
return energy;
}
void G4PiMinusStopAbsorption::SetVerboseLevel(G4int level)
{
_level = level;
return;
}
source/processes/hadronic/stopping/src/G4PiMinusStopAl.cc
-133
View File
@@ -1,133 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusStopAl
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 8 May 1998
//
// -------------------------------------------------------------------
#include "G4ios.hh"
#include "G4PiMinusStopAl.hh"
#include "globals.hh"
#include "Randomize.hh"
#include "G4Proton.hh"
#include "G4Neutron.hh"
#include "G4ParticleTypes.hh"
#include "G4ReactionKinematics.hh"
#include "G4DynamicParticleVector.hh"
#include "G4LorentzVector.hh"
#include "G4PiMinusStopMaterial.hh"
#include "G4DistributionGenerator.hh"
// np/pp production ratio
// Experimental values:
// R(np/pp) = average (E. Gadioli et al., Phys Rev C36 (1987) 741)
G4double G4PiMinusStopAl::npRatio = 4;
// Average numbers of final nucleons detected, for N-pair absorption
// (R. Madey et al., Phys Rev C25 (1982) 3050
G4double G4PiMinusStopAl::nFinalNucleons = 1.67;
// Kinetic energy (MeV) distributions measured for coincident nucleon
// emission
// (R. Madey et al., Phys Rev C25 (1982) 3050
G4int G4PiMinusStopAl::eKinEntries = 10;
G4double G4PiMinusStopAl::eKinData[10] = { 0.23, 0.58, 1.24, 1.52,
1.67,
1.52, 1.24, 0.95, 0.58, 0.23};
G4double G4PiMinusStopAl::eKin[11] = { 5.2, 15., 27., 41.5,
49.6,
57.7, 79.3, 94.4, 114., 125., 140.};
// Opening angle distributions measured for coincident nucleon emission
// (P.Heusi et al., Nucl. Phys. A407 (1983) 429
G4int G4PiMinusStopAl::angleEntries = 7;
G4double G4PiMinusStopAl::angleData[7] =
{ 1.43, 1.67, 2.62, 4.29, 7.62, 11.90, 14.76 };
G4double G4PiMinusStopAl::angle[8] = { 1.308997, 1.570796, 1.832596, 2.094395,
2.356194, 2.617994, 2.967060, 3.1415927 };
// Constructor
G4PiMinusStopAl::G4PiMinusStopAl()
{
// Cluster size: nucleon pair, alpha, triton etc.
// First implementation: interaction with nucleon pair only
_clusterSize = 2;
// R ratio
theR = 1. / (1. + npRatio);
_definitions = new std::vector<G4ParticleDefinition*>();
_momenta = new std::vector<G4LorentzVector*>();
std::vector<double> eKinVector;
std::vector<double> eKinDataVector;
int i;
for (i=0; i<eKinEntries; i++)
{
eKinVector.push_back(eKin[i]);
eKinDataVector.push_back(eKinData[i]);
}
eKinVector.push_back(eKin[eKinEntries]);
_distributionE = new G4DistributionGenerator(eKinVector,eKinDataVector);
std::vector<double> angleVector;
std::vector<double> angleDataVector;
for (i=0; i<angleEntries; i++)
{
angleVector.push_back(angle[i]);
angleDataVector.push_back(angleData[i]);
}
angleVector.push_back(angle[angleEntries]);
_distributionAngle = new G4DistributionGenerator(angleVector,angleDataVector);
}
// Destructor
G4PiMinusStopAl::~G4PiMinusStopAl()
{}
G4double G4PiMinusStopAl::FinalNucleons()
{
return nFinalNucleons;
}
source/processes/hadronic/stopping/src/G4PiMinusStopC.cc
-151
View File
@@ -1,151 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusStopC
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 8 May 1998
//
// -------------------------------------------------------------------
#include "G4ios.hh"
#include "G4PiMinusStopC.hh"
#include <vector>
#include "globals.hh"
#include "Randomize.hh"
#include "G4Proton.hh"
#include "G4Neutron.hh"
#include "G4ParticleTypes.hh"
#include "G4ReactionKinematics.hh"
#include "G4DynamicParticleVector.hh"
#include "G4LorentzVector.hh"
#include "G4PiMinusStopMaterial.hh"
#include "G4DistributionGenerator.hh"
// np/pp production ratio
// Experimental values:
// R(np/pp) = 6.3 +- 1.4 (P. Heusi et al. (Nucl. Phys. A407, 429 [1983])
// R = 5.0 +- 1.5 (Ozaki et al.)
// R = 8.8 +- 1.3 (Lee et al.)
// R = 2.4 +- 1.0 (Nordberg et al.)
// Use average value of the first three ones
G4double G4PiMinusStopC::npRatio = 6.7;
// Average numbers of final nucleons detected, for N-pair absorption
// R. Madey et al., Phys. Rev. C25(1982) 3050
G4double G4PiMinusStopC::nFinalNucleons = 1.77;
// Kinetic energy (MeV) distributions measured for coincident nucleon
// emission
// P. Heusi et al., Nucl. Phys. A407(1983) 429
G4int G4PiMinusStopC::eKinEntries = 21;
G4double G4PiMinusStopC::eKinData[21] = { 0.031, 0.045, 0.06, 0.09,
0.11, 0.116, 0.14,
0.18, 0.21, 0.25,
0.3, 0.32, 0.31, 0.3,
0.25, 0.18, 0.16,
0.15, 0.08, 0.05, 0.01};
G4double G4PiMinusStopC::eKin[22] = { 8., 17.5, 21., 24.5,
27.5, 31., 33.5,
37.5, 42.5, 46.4,
49., 52.5, 57.5, 62.5,
67.5, 72.5, 75.,
77.5, 82.5, 87.5, 92.5, 110. };
//G4double G4PiMinusStopC::eKin[22] = { 15., 20., 22., 25.,
// 30., 32., 36.,
// 40., 45., 48.,
// 50., 54., 60., 65.,
// 70., 75., 78.,
// 80., 86., 90., 95., 100. };
// Opening angle distributions measured for coincident nucleon emission
// R. Hartmann et al., Nucl. Phys. A308 (1978) 345
G4int G4PiMinusStopC::angleEntries = 7;
G4double G4PiMinusStopC::angleData[7] =
{ 1.43, 1.67, 2.62, 4.29, 7.62, 11.90, 14.76 };
G4double G4PiMinusStopC::angle[8] = { 1.308997, 1.570796, 1.832596, 2.094395,
2.356194, 2.617994, 2.967060, 3.1415927 };
// Constructor
G4PiMinusStopC::G4PiMinusStopC()
{
// Cluster size: nucleon pair, alpha, triton etc.
// First implementation: interaction with nucleon pair only
_clusterSize = 2;
// R ratio
theR = 1. / (1. + npRatio);
_definitions = new std::vector<G4ParticleDefinition*>();
_momenta = new std::vector<G4LorentzVector*>();
std::vector<double> eKinVector;
std::vector<double> eKinDataVector;
int i;
for (i=0; i<eKinEntries; i++)
{
eKinVector.push_back(eKin[i]);
eKinDataVector.push_back(eKinData[i]);
}
eKinVector.push_back(eKin[eKinEntries]);
_distributionE = new G4DistributionGenerator(eKinVector,eKinDataVector);
std::vector<double> angleVector;
std::vector<double> angleDataVector;
for (i=0; i<angleEntries; i++)
{
angleVector.push_back(angle[i]);
angleDataVector.push_back(angleData[i]);
}
angleVector.push_back(angle[angleEntries]);
_distributionAngle = new G4DistributionGenerator(angleVector,angleDataVector);
}
// Destructor
G4PiMinusStopC::~G4PiMinusStopC()
{}
G4double G4PiMinusStopC::FinalNucleons()
{
return nFinalNucleons;
}
source/processes/hadronic/stopping/src/G4PiMinusStopCo.cc
-137
View File
@@ -1,137 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusStopCo
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 8 May 1998
//
// -------------------------------------------------------------------
#include "G4ios.hh"
#include "G4PiMinusStopCo.hh"
#include <vector>
#include "globals.hh"
#include "Randomize.hh"
#include "G4Proton.hh"
#include "G4Neutron.hh"
#include "G4ParticleTypes.hh"
#include "G4ReactionKinematics.hh"
#include "G4DynamicParticleVector.hh"
#include "G4LorentzVector.hh"
#include "G4PiMinusStopMaterial.hh"
#include "G4DistributionGenerator.hh"
// np/pp production ratio
// Experimental values:
// R(np/pp) (E. Gadioli et al., Phys Rev C36 (1987) 741
G4double G4PiMinusStopCo::npRatio = 2.5;
// Average numbers of final nucleons detected, for N-pair absorption
// (Hartmann et al., Nucl. Phys. A300 (1978) 345
G4double G4PiMinusStopCo::nFinalNucleons = 1.38;
// Kinetic energy (MeV) distributions measured for coincident nucleon
// emission
// P. Heusi et al., Nucl. Phys. A407(1983) 429
G4int G4PiMinusStopCo::eKinEntries = 11;
G4double G4PiMinusStopCo::eKinData[11] = {0.085, 0.09, 0.09, 0.15,
0.1, 0.09, 0.08,
0.04, 0.03, 0.02, 0.01};
G4double G4PiMinusStopCo::eKin[12] = { 15., 17.5, 25., 33.,
42., 52., 62.,
75., 85., 95., 105. };
// Opening angle distributions measured for coincident nucleon emission
// (P.Heusi et al., Nucl. Phys. A407 (1983) 429
G4int G4PiMinusStopCo::angleEntries = 7;
G4double G4PiMinusStopCo::angleData[7] =
{6., 8., 9., 10., 25., 40., 45. };
G4double G4PiMinusStopCo::angle[8] = { 0.5, 0.7, 0.87, 1.4, 2.1,
2.44, 2.8, 3.1415927 };
// Constructor
G4PiMinusStopCo::G4PiMinusStopCo()
{
// Cluster size: nucleon pair, alpha, triton etc.
// First implementation: interaction with nucleon pair only
_clusterSize = 2;
// R ratio
theR = 1. / (1. + npRatio);
_definitions = new std::vector<G4ParticleDefinition*>();
_momenta = new std::vector<G4LorentzVector*>();
std::vector<double> eKinVector;
std::vector<double> eKinDataVector;
int i;
for (i=0; i<eKinEntries; i++)
{
eKinVector.push_back(eKin[i]);
eKinDataVector.push_back(eKinData[i]);
}
eKinVector.push_back(eKin[eKinEntries]);
_distributionE = new G4DistributionGenerator(eKinVector,eKinDataVector);
std::vector<double> angleVector;
std::vector<double> angleDataVector;
for (i=0; i<angleEntries; i++)
{
angleVector.push_back(angle[i]);
angleDataVector.push_back(angleData[i]);
}
angleVector.push_back(angle[angleEntries]);
_distributionAngle = new G4DistributionGenerator(angleVector,angleDataVector);
}
// Destructor
G4PiMinusStopCo::~G4PiMinusStopCo()
{}
G4double G4PiMinusStopCo::FinalNucleons()
{
return nFinalNucleons;
}
source/processes/hadronic/stopping/src/G4PiMinusStopCu.cc
-136
View File
@@ -1,136 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusStopCu
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 8 May 1998
//
// -------------------------------------------------------------------
#include "G4ios.hh"
#include "G4PiMinusStopCu.hh"
#include <vector>
#include "globals.hh"
#include "Randomize.hh"
#include "G4Proton.hh"
#include "G4Neutron.hh"
#include "G4ParticleTypes.hh"
#include "G4ReactionKinematics.hh"
#include "G4DynamicParticleVector.hh"
#include "G4LorentzVector.hh"
#include "G4PiMinusStopMaterial.hh"
#include "G4DistributionGenerator.hh"
// np/pp production ratio
// Experimental values:
// R(np/pp) = 6.3 +- 1.4 (E. Gadioli et al., Phys Rev C36 (1987) 741)
// [looks odd!]
G4double G4PiMinusStopCu::npRatio = 2.;
// Average numbers of final nucleons detected, for N-pair absorption
// (R. Madey et al., Phys Rev C25 (1982) 3050
G4double G4PiMinusStopCu::nFinalNucleons = 1.72;
// Kinetic energy (MeV) distributions measured for coincident nucleon
// emission
// (R. Madey et al., Phys Rev C25 (1982) 3050
G4int G4PiMinusStopCu::eKinEntries = 10;
G4double G4PiMinusStopCu::eKinData[10] = { 0.24, 0.57, 1.13, 1.38,
1.54,
1.38, 1.13, 0.84, 0.57, 0.24};
G4double G4PiMinusStopCu::eKin[11] = { 5.2, 10.2, 19.9, 41.5,
49.6,
57.7, 79.3, 94.4, 114., 120., 135.};
// Opening angle distributions measured for coincident nucleon emission
// (P.Heusi et al., Nucl. Phys. A407 (1983) 429
G4int G4PiMinusStopCu::angleEntries = 7;
G4double G4PiMinusStopCu::angleData[7] =
{ 1.43, 1.67, 2.62, 4.29, 7.62, 11.90, 14.76 };
G4double G4PiMinusStopCu::angle[8] = { 1.308997, 1.570796, 1.832596, 2.094395,
2.356194, 2.617994, 2.967060, 3.1415927 };
// Constructor
G4PiMinusStopCu::G4PiMinusStopCu()
{
// Cluster size: nucleon pair, alpha, triton etc.
// First implementation: interaction with nucleon pair only
_clusterSize = 2;
// R ratio
theR = 1. / (1. + npRatio);
_definitions = new std::vector<G4ParticleDefinition* >();
_momenta = new std::vector<G4LorentzVector* >();
std::vector<double> eKinVector;
std::vector<double> eKinDataVector;
int i;
for (i=0; i<eKinEntries; i++)
{
eKinVector.push_back(eKin[i]);
eKinDataVector.push_back(eKinData[i]);
}
eKinVector.push_back(eKin[eKinEntries]);
_distributionE = new G4DistributionGenerator(eKinVector,eKinDataVector);
std::vector<double> angleVector;
std::vector<double> angleDataVector;
for (i=0; i<angleEntries; i++)
{
angleVector.push_back(angle[i]);
angleDataVector.push_back(angleData[i]);
}
angleVector.push_back(angle[angleEntries]);
_distributionAngle = new G4DistributionGenerator(angleVector,angleDataVector);
}
// Destructor
G4PiMinusStopCu::~G4PiMinusStopCu()
{}
G4double G4PiMinusStopCu::FinalNucleons()
{
return nFinalNucleons;
}
source/processes/hadronic/stopping/src/G4PiMinusStopLi.cc
-141
View File
@@ -1,141 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusStopLi
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 8 May 1998
//
// -------------------------------------------------------------------
#include "G4ios.hh"
#include "G4PiMinusStopLi.hh"
#include <vector>
#include "globals.hh"
#include "Randomize.hh"
#include "G4Proton.hh"
#include "G4Neutron.hh"
#include "G4ParticleTypes.hh"
#include "G4ReactionKinematics.hh"
#include "G4DynamicParticleVector.hh"
#include "G4LorentzVector.hh"
#include "G4PiMinusStopMaterial.hh"
#include "G4DistributionGenerator.hh"
// np/pp production ratio
// Experimental values:
// R(np/pp) = 6.3 +- 1.4 (P.Heusi et al., Nucl. Phys. A407 (1983) 429
G4double G4PiMinusStopLi::npRatio = 6.3;
// Average numbers of final nucleons detected, for N-pair absorption
// (P.Heusi et al., Nucl. Phys. A407 (1983) 429
G4double G4PiMinusStopLi::nFinalNucleons = 1.9;
// Kinetic energy (MeV) distributions measured for coincident nucleon
// emission
// P. Heusi et al., Nucl. Phys. A407(1983) 429
G4int G4PiMinusStopLi::eKinEntries = 21;
G4double G4PiMinusStopLi::eKinData[21] = { 0.0018, 0.0025, 0.003, 0.045,
0.007, 0.014, 0.023,
0.4, 0.09, 0.18,
0.25, 0.3, 0.25, 0.2,
0.18, 0.08, 0.05,
0.023, 0.012, 0.007, 0.02};
G4double G4PiMinusStopLi::eKin[22] = { 15., 17.5, 22.5, 27.5,
32.5, 37.5, 42.5,
47.5, 52.5, 57.5,
62.5, 67.5, 72.5, 77.5,
82.5, 87.5, 92.5,
97.5, 102.5, 105. };
// Opening angle distributions measured for coincident nucleon emission
// (P.Heusi et al., Nucl. Phys. A407 (1983) 429
G4int G4PiMinusStopLi::angleEntries = 7;
G4double G4PiMinusStopLi::angleData[7] =
{ 0.17, 0.4, 0.7, 1.1, 1.3, 20., 70. };
G4double G4PiMinusStopLi::angle[8] = { 1.308997, 1.570796, 1.832596, 2.094395,
2.356194, 2.617994, 2.967060, 3.1415927 };
// Constructor
G4PiMinusStopLi::G4PiMinusStopLi()
{
// Cluster size: nucleon pair, alpha, triton etc.
// First implementation: interaction with nucleon pair only
_clusterSize = 2;
// R ratio
theR = 1. / (1. + npRatio);
_definitions = new std::vector<G4ParticleDefinition*>();
_momenta = new std::vector<G4LorentzVector*>();
std::vector<double> eKinVector;
std::vector<double> eKinDataVector;
int i;
for (i=0; i<eKinEntries; i++)
{
eKinVector.push_back(eKin[i]);
eKinDataVector.push_back(eKinData[i]);
}
eKinVector.push_back(eKin[eKinEntries]);
_distributionE = new G4DistributionGenerator(eKinVector,eKinDataVector);
std::vector<double> angleVector;
std::vector<double> angleDataVector;
for (i=0; i<angleEntries; i++)
{
angleVector.push_back(angle[i]);
angleDataVector.push_back(angleData[i]);
}
angleVector.push_back(angle[angleEntries]);
_distributionAngle = new G4DistributionGenerator(angleVector,angleDataVector);
}
// Destructor
G4PiMinusStopLi::~G4PiMinusStopLi()
{}
G4double G4PiMinusStopLi::FinalNucleons()
{
return nFinalNucleons;
}
source/processes/hadronic/stopping/src/G4PiMinusStopMaterial.cc
-199
View File
@@ -1,199 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusStopMaterial
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 8 May 1998
//
// -------------------------------------------------------------------
#include <vector>
#include "G4PiMinusStopMaterial.hh"
#include "globals.hh"
#include "G4ios.hh"
#include "Randomize.hh"
#include "G4PhysicalConstants.hh"
#include "G4Proton.hh"
#include "G4Neutron.hh"
#include "G4PionMinus.hh"
#include "G4ParticleTypes.hh"
#include "G4ReactionKinematics.hh"
#include "G4DynamicParticleVector.hh"
#include "G4LorentzVector.hh"
#include "G4PiMinusStopMaterial.hh"
#include "G4DistributionGenerator.hh"
// Constructor
G4PiMinusStopMaterial::G4PiMinusStopMaterial()
{
_definitions = 0;
_momenta = 0;
_distributionE = 0;
_distributionAngle = 0;
theR = 0.5;
}
// Destructor
G4PiMinusStopMaterial::~G4PiMinusStopMaterial()
{
if (_definitions != 0) delete _definitions;
_definitions = 0;
//A.R. 26-Jul-2012 Coverity fix
if (_momenta != 0) {
for (unsigned int i=0; i<_momenta->size(); i++) delete(*_momenta)[i];
delete _momenta;
}
delete _distributionE;
delete _distributionAngle;
}
std::vector<G4ParticleDefinition*>* G4PiMinusStopMaterial::DefinitionVector()
{
_definitions->push_back(G4Neutron::Neutron());
G4double ranflat = G4UniformRand();
if (ranflat < theR)
{ _definitions->push_back(G4Proton::Proton()); }
else
{ _definitions->push_back(G4Neutron::Neutron()); }
return _definitions;
}
std::vector<G4LorentzVector*>*
G4PiMinusStopMaterial::P4Vector(const G4double binding,
const G4double massNucleus)
{
// Generate energy of direct absorption products according to experimental
// data. The energy distribution of the two nucleons is assumed to be the
// same for protons and neutrons.
G4double eKin1;
G4double eKin2;
G4double eRecoil;
// Assume absorption on two nucleons
G4int nNucleons = 2;
G4double availableE = G4PionMinus::PionMinus()->GetPDGMass() - nNucleons * binding;
G4LorentzVector p1;
G4LorentzVector p2;
do
{
G4double ranflat;
G4double p;
G4double energy;
G4double mass;
ranflat = G4UniformRand();
eKin1 = _distributionE->Generate(ranflat);
mass = (*_definitions)[0]->GetPDGMass();
energy = eKin1 + mass;
p = std::sqrt(energy*energy - mass*mass);
G4double theta1 = pi*G4UniformRand();
G4double phi1 = GenerateAngle(2.*pi);
p1 = MakeP4(p,theta1,phi1,energy);
ranflat = G4UniformRand();
eKin2 = _distributionE->Generate(ranflat);
mass = (*_definitions)[1]->GetPDGMass();
energy = eKin2 + mass;
p = std::sqrt(energy*energy - mass*mass);
ranflat = G4UniformRand();
G4double opAngle = _distributionAngle->Generate(ranflat);
G4double theta2 = theta1 + opAngle;
G4double phi2 = phi1 + opAngle;
p2 = MakeP4(p,theta2,phi2,energy);
G4double pNucleus = (p1.vect() + p2.vect()).mag();
eRecoil = std::sqrt(pNucleus*pNucleus + massNucleus*massNucleus) - massNucleus;
// ---- Debug
// G4cout << " ---- binding = " << binding << ", nucleus mass = " << massNucleus
// << ", p nucleus = " << pNucleus << G4endl;
// G4cout << "eKin1,2 " << eKin1 << " " << eKin2 << " eRecoil " << eRecoil
// << " availableE " << availableE << G4endl;
// ----
} while ((eKin1 + eKin2 + eRecoil) > availableE);
//A.R. 26-Jul-2012 Coverity fix
if (_momenta != 0) {
_momenta->push_back(new G4LorentzVector(p1));
_momenta->push_back(new G4LorentzVector(p2));
}
return _momenta;
}
G4double G4PiMinusStopMaterial::GenerateAngle(G4double x)
{
G4double ranflat = G4UniformRand();
G4double value = ranflat * x;
return value;
}
G4LorentzVector G4PiMinusStopMaterial::MakeP4(G4double p, G4double theta, G4double phi, G4double e)
{
// G4LorentzVector p4;
G4double px = p * std::sin(theta) * std::cos(phi);
G4double py = p * std::sin(theta) * std::sin(phi);
G4double pz = p * std::cos(theta);
G4LorentzVector p4(px,py,pz,e);
return p4;
}
G4double G4PiMinusStopMaterial::RecoilEnergy(const G4double mass)
{
G4ThreeVector p(0.,0.,0.);
//A.R. 26-Jul-2012 Coverity fix
if (_momenta != 0) {
for (unsigned int i = 0; i< _momenta->size(); i++)
{
p = p + (*_momenta)[i]->vect();
}
}
G4double pNucleus = p.mag();
G4double eNucleus = std::sqrt(pNucleus*pNucleus + mass*mass);
return eNucleus;
}
source/processes/hadronic/stopping/src/G4PiMinusStopN.cc
-135
View File
@@ -1,135 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusStopN
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 8 May 1998
//
// -------------------------------------------------------------------
#include "G4ios.hh"
#include "G4PiMinusStopN.hh"
#include <vector>
#include "globals.hh"
#include "Randomize.hh"
#include "G4Proton.hh"
#include "G4Neutron.hh"
#include "G4ParticleTypes.hh"
#include "G4ReactionKinematics.hh"
#include "G4DynamicParticleVector.hh"
#include "G4LorentzVector.hh"
#include "G4PiMinusStopMaterial.hh"
#include "G4DistributionGenerator.hh"
// np/pp production ratio
// Experimental values:
// R(np/pp) = 6.3 +- 1.4 (R. Madey et al., Phys Rev C25 (1982) 3050
G4double G4PiMinusStopN::npRatio = 6.3;
// Average numbers of final nucleons detected, for N-pair absorption
// (R. Madey et al., Phys Rev C25 (1982) 3050
G4double G4PiMinusStopN::nFinalNucleons = 1.76;
// Kinetic energy (MeV) distributions measured for coincident nucleon
// emission
// P. Heusi et al., Nucl. Phys. A407(1983) 429
G4int G4PiMinusStopN::eKinEntries = 10;
G4double G4PiMinusStopN::eKinData[10] = { 0.24, 1.08, 1.46, 1.69,
1.79,
1.69, 1.46, 1.08, 0.62, 0.24};
G4double G4PiMinusStopN::eKin[11] = { 5.2, 15., 27., 41.5,
49.6,
57.7, 79.3, 94.4, 114., 125., 140.};
// Opening angle distributions measured for coincident nucleon emission
// (P.Heusi et al., Nucl. Phys. A407 (1983) 429
G4int G4PiMinusStopN::angleEntries = 7;
G4double G4PiMinusStopN::angleData[7] =
{ 1.43, 1.67, 2.62, 4.29, 7.62, 11.90, 14.76 };
G4double G4PiMinusStopN::angle[8] = { 1.308997, 1.570796, 1.832596, 2.094395,
2.356194, 2.617994, 2.967060, 3.1415927 };
// Constructor
G4PiMinusStopN::G4PiMinusStopN()
{
// Cluster size: nucleon pair, alpha, triton etc.
// First implementation: interaction with nucleon pair only
_clusterSize = 2;
// R ratio
theR = 1. / (1. + npRatio);
_definitions = new std::vector<G4ParticleDefinition*>();
_momenta = new std::vector<G4LorentzVector*>();
std::vector<double> eKinVector;
std::vector<double> eKinDataVector;
int i;
for (i=0; i<eKinEntries; i++)
{
eKinVector.push_back(eKin[i]);
eKinDataVector.push_back(eKinData[i]);
}
eKinVector.push_back(eKin[eKinEntries]);
_distributionE = new G4DistributionGenerator(eKinVector,eKinDataVector);
std::vector<double> angleVector;
std::vector<double> angleDataVector;
for (i=0; i<angleEntries; i++)
{
angleVector.push_back(angle[i]);
angleDataVector.push_back(angleData[i]);
}
angleVector.push_back(angle[angleEntries]);
_distributionAngle = new G4DistributionGenerator(angleVector,angleDataVector);
}
// Destructor
G4PiMinusStopN::~G4PiMinusStopN()
{}
G4double G4PiMinusStopN::FinalNucleons()
{
return nFinalNucleons;
}
source/processes/hadronic/stopping/src/G4PiMinusStopO.cc
-135
View File
@@ -1,135 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusStopO
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 8 May 1998
//
// -------------------------------------------------------------------
#include "G4ios.hh"
#include "G4PiMinusStopO.hh"
#include <vector>
#include "globals.hh"
#include "Randomize.hh"
#include "G4Proton.hh"
#include "G4Neutron.hh"
#include "G4ParticleTypes.hh"
#include "G4ReactionKinematics.hh"
#include "G4DynamicParticleVector.hh"
#include "G4LorentzVector.hh"
#include "G4PiMinusStopMaterial.hh"
#include "G4DistributionGenerator.hh"
// np/pp production ratio
// Experimental values:
// R(np/pp) = 6.3 +- 1.4 (R. Madey et al., Phys Rev C25 (1982) 3050
G4double G4PiMinusStopO::npRatio = 6.3;
// Average numbers of final nucleons detected, for N-pair absorption
// (R. Madey et al., Phys Rev C25 (1982) 3050
G4double G4PiMinusStopO::nFinalNucleons = 1.78;
// Kinetic energy (MeV) distributions measured for coincident nucleon
// emission
// (R. Madey et al., Phys Rev C25 (1982) 3050
G4int G4PiMinusStopO::eKinEntries = 10;
G4double G4PiMinusStopO::eKinData[10] = { 0.25, 0.62, 1.58, 1.78,
1.87,
1.78, 1.58, 1.13, 0.62, 0.25};
G4double G4PiMinusStopO::eKin[11] = { 5.2, 15., 27., 41.5,
49.6,
57.7, 79.3, 94.4, 114., 140., 140.};
// Opening angle distributions measured for coincident nucleon emission
// (P.Heusi et al., Nucl. Phys. A407 (1983) 429
G4int G4PiMinusStopO::angleEntries = 7;
G4double G4PiMinusStopO::angleData[7] =
{ 1.43, 1.67, 2.62, 4.29, 7.62, 11.90, 14.76 };
G4double G4PiMinusStopO::angle[8] = { 1.308997, 1.570796, 1.832596, 2.094395,
2.356194, 2.617994, 2.967060, 3.1415927 };
// Constructor
G4PiMinusStopO::G4PiMinusStopO()
{
// Cluster size: nucleon pair, alpha, triton etc.
// First implementation: interaction with nucleon pair only
_clusterSize = 2;
// R ratio
theR = 1. / (1. + npRatio);
_definitions = new std::vector<G4ParticleDefinition*>();
_momenta = new std::vector<G4LorentzVector*>();
std::vector<double> eKinVector;
std::vector<double> eKinDataVector;
int i;
for (i=0; i<eKinEntries; i++)
{
eKinVector.push_back(eKin[i]);
eKinDataVector.push_back(eKinData[i]);
}
eKinVector.push_back(eKin[eKinEntries]);
_distributionE = new G4DistributionGenerator(eKinVector,eKinDataVector);
std::vector<double> angleVector;
std::vector<double> angleDataVector;
for (i=0; i<angleEntries; i++)
{
angleVector.push_back(angle[i]);
angleDataVector.push_back(angleData[i]);
}
angleVector.push_back(angle[angleEntries]);
_distributionAngle = new G4DistributionGenerator(angleVector,angleDataVector);
}
// Destructor
G4PiMinusStopO::~G4PiMinusStopO()
{}
G4double G4PiMinusStopO::FinalNucleons()
{
return nFinalNucleons;
}
source/processes/hadronic/stopping/src/G4PiMinusStopPb.cc
-135
View File
@@ -1,135 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusStopPb
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 8 May 1998
//
// -------------------------------------------------------------------
#include "G4ios.hh"
#include "G4PiMinusStopPb.hh"
#include <vector>
#include "globals.hh"
#include "Randomize.hh"
#include "G4Proton.hh"
#include "G4Neutron.hh"
#include "G4ParticleTypes.hh"
#include "G4ReactionKinematics.hh"
#include "G4DynamicParticleVector.hh"
#include "G4LorentzVector.hh"
#include "G4PiMinusStopMaterial.hh"
#include "G4DistributionGenerator.hh"
// np/pp production ratio
// Experimental values:
// R(np/pp) (E. Gadioli et al., Phys Rev C36 (1987) 741)
G4double G4PiMinusStopPb::npRatio = 6;
// Average numbers of final nucleons detected, for N-pair absorption
// (R. Madey et al., Phys Rev C25 (1982) 3050
G4double G4PiMinusStopPb::nFinalNucleons = 1.67;
// Kinetic energy (MeV) distributions measured for coincident nucleon
// emission
// (R. Madey et al., Phys Rev C25 (1982) 3050
G4int G4PiMinusStopPb::eKinEntries = 10;
G4double G4PiMinusStopPb::eKinData[10] = { 0.24, 0.5, 1.03, 1.28,
1.44,
1.28, 1.03, 0.82, 0.50, 0.22};
G4double G4PiMinusStopPb::eKin[11] = { 5.2, 15., 27., 41.5,
49.6,
57.7, 79.3, 94.4, 114., 125., 140.};
// Opening angle distributions measured for coincident nucleon emission
// (P.Heusi et al., Nucl. Phys. A407 (1983) 429
G4int G4PiMinusStopPb::angleEntries = 7;
G4double G4PiMinusStopPb::angleData[7] =
{ 1.43, 1.67, 2.62, 4.29, 7.62, 11.90, 14.76 };
G4double G4PiMinusStopPb::angle[8] = { 1.308997, 1.570796, 1.832596, 2.094395,
2.356194, 2.617994, 2.967060, 3.1415927 };
// Constructor
G4PiMinusStopPb::G4PiMinusStopPb()
{
// Cluster size: nucleon pair, alpha, triton etc.
// First implementation: interaction with nucleon pair only
_clusterSize = 2;
// R ratio
theR = 1. / (1. + npRatio);
_definitions = new std::vector<G4ParticleDefinition*>();
_momenta = new std::vector<G4LorentzVector*>();
std::vector<double> eKinVector;
std::vector<double> eKinDataVector;
int i;
for (i=0; i<eKinEntries; i++)
{
eKinVector.push_back(eKin[i]);
eKinDataVector.push_back(eKinData[i]);
}
eKinVector.push_back(eKin[eKinEntries]);
_distributionE = new G4DistributionGenerator(eKinVector,eKinDataVector);
std::vector<double> angleVector;
std::vector<double> angleDataVector;
for (i=0; i<angleEntries; i++)
{
angleVector.push_back(angle[i]);
angleDataVector.push_back(angleData[i]);
}
angleVector.push_back(angle[angleEntries]);
_distributionAngle = new G4DistributionGenerator(angleVector,angleDataVector);
}
// Destructor
G4PiMinusStopPb::~G4PiMinusStopPb()
{}
G4double G4PiMinusStopPb::FinalNucleons()
{
return nFinalNucleons;
}
source/processes/hadronic/stopping/src/G4PiMinusStopTa.cc
-134
View File
@@ -1,134 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4PiMinusStopTa
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 8 May 1998
//
// -------------------------------------------------------------------
#include "G4ios.hh"
#include "G4PiMinusStopTa.hh"
#include <vector>
#include "globals.hh"
#include "Randomize.hh"
#include "G4Proton.hh"
#include "G4Neutron.hh"
#include "G4ParticleTypes.hh"
#include "G4ReactionKinematics.hh"
#include "G4DynamicParticleVector.hh"
#include "G4LorentzVector.hh"
#include "G4PiMinusStopMaterial.hh"
#include "G4DistributionGenerator.hh"
// np/pp production ratio
// Experimental values:
// R(np/pp) = 6.3 +- 1.4 (R. Madey et al., Phys Rev C25 (1982) 3050
G4double G4PiMinusStopTa::npRatio = 17.;
// Average numbers of final nucleons detected, for N-pair absorption
// (R. Madey et al., Phys Rev C25 (1982) 3050
G4double G4PiMinusStopTa::nFinalNucleons = 1.8;
// Kinetic energy (MeV) distributions measured for coincident nucleon
// emission
// (R. Madey et al., Phys Rev C25 (1982) 3050
G4int G4PiMinusStopTa::eKinEntries = 10;
G4double G4PiMinusStopTa::eKinData[10] = { 0.24, 0.59, 1.13, 1.38,
1.50,
1.38, 1.13, 0.83, 0.49, 0.22};
G4double G4PiMinusStopTa::eKin[11] = { 5.2, 12., 25., 41.5,
49.6,
57.7, 79.3, 94.4, 104., 120., 140.};
// Opening angle distributions measured for coincident nucleon emission
// (P.Heusi et al., Nucl. Phys. A407 (1983) 429
G4int G4PiMinusStopTa::angleEntries = 7;
G4double G4PiMinusStopTa::angleData[7] =
{ 1.43, 1.67, 2.62, 4.29, 7.62, 11.90, 14.76 };
G4double G4PiMinusStopTa::angle[8] = { 1.308997, 1.570796, 1.832596, 2.094395,
2.356194, 2.617994, 2.967060, 3.1415927 };
// Constructor
G4PiMinusStopTa::G4PiMinusStopTa()
{
// Cluster size: nucleon pair, alpha, triton etc.
// First implementation: interaction with nucleon pair only
_clusterSize = 2;
// R ratio
theR = 1. / (1. + npRatio);
_definitions = new std::vector<G4ParticleDefinition*>();
_momenta = new std::vector<G4LorentzVector*>();
std::vector<double> eKinVector;
std::vector<double> eKinDataVector;
int i;
for (i=0; i<eKinEntries; i++)
{
eKinVector.push_back(eKin[i]);
eKinDataVector.push_back(eKinData[i]);
}
eKinVector.push_back(eKin[eKinEntries]);
_distributionE = new G4DistributionGenerator(eKinVector,eKinDataVector);
std::vector<double> angleVector;
std::vector<double> angleDataVector;
for (i=0; i<angleEntries; i++)
{
angleVector.push_back(angle[i]);
angleDataVector.push_back(angleData[i]);
}
angleVector.push_back(angle[angleEntries]);
_distributionAngle = new G4DistributionGenerator(angleVector,angleDataVector);
}
// Destructor
G4PiMinusStopTa::~G4PiMinusStopTa()
{}
G4double G4PiMinusStopTa::FinalNucleons()
{
return nFinalNucleons;
}
source/processes/hadronic/stopping/src/G4PionMinusAbsorptionAtRest.cc
-553
View File
@@ -1,553 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// G4PionMinusAbsorptionAtRest physics process
// Larry Felawka (TRIUMF), April 1998
//---------------------------------------------------------------------
#include <string.h>
#include <cmath>
#include <stdio.h>
#include "G4PionMinusAbsorptionAtRest.hh"
#include "G4DynamicParticle.hh"
#include "G4ParticleTypes.hh"
#include "G4SystemOfUnits.hh"
#include "Randomize.hh"
#include "G4HadronicProcessStore.hh"
#include "G4HadronicDeprecate.hh"
#define MAX_SECONDARIES 100
// constructor
G4PionMinusAbsorptionAtRest::G4PionMinusAbsorptionAtRest(const G4String& processName,
G4ProcessType aType ) :
G4VRestProcess (processName, aType), // initialization
massPionMinus(G4PionMinus::PionMinus()->GetPDGMass()/GeV),
pdefGamma(G4Gamma::Gamma()),
pdefPionZero(G4PionZero::PionZero()),
pdefPionMinus(G4PionMinus::PionMinus()),
pdefProton(G4Proton::Proton()),
pdefNeutron(G4Neutron::Neutron()),
pdefDeuteron(G4Deuteron::Deuteron()),
pdefTriton(G4Triton::Triton()),
pdefAlpha(G4Alpha::Alpha())
{
G4HadronicDeprecate("G4PiMinusAbsorptionAtRest");
if (verboseLevel>0) {
G4cout << GetProcessName() << " is created "<< G4endl;
}
SetProcessSubType(fHadronAtRest);
pv = new G4GHEKinematicsVector [MAX_SECONDARIES+1];
eve = new G4GHEKinematicsVector [MAX_SECONDARIES];
gkin = new G4GHEKinematicsVector [MAX_SECONDARIES];
G4HadronicProcessStore::Instance()->RegisterExtraProcess(this);
}
// destructor
G4PionMinusAbsorptionAtRest::~G4PionMinusAbsorptionAtRest()
{
G4HadronicProcessStore::Instance()->DeRegisterExtraProcess(this);
delete [] pv;
delete [] eve;
delete [] gkin;
}
void G4PionMinusAbsorptionAtRest::PreparePhysicsTable(const G4ParticleDefinition& p)
{
G4HadronicProcessStore::Instance()->RegisterParticleForExtraProcess(this, &p);
}
void G4PionMinusAbsorptionAtRest::BuildPhysicsTable(const G4ParticleDefinition& p)
{
G4HadronicProcessStore::Instance()->PrintInfo(&p);
}
// methods.............................................................................
G4bool G4PionMinusAbsorptionAtRest::IsApplicable(
const G4ParticleDefinition& particle
)
{
return ( &particle == pdefPionMinus );
}
// Warning - this method may be optimized away if made "inline"
G4int G4PionMinusAbsorptionAtRest::GetNumberOfSecondaries()
{
return ( ngkine );
}
// Warning - this method may be optimized away if made "inline"
G4GHEKinematicsVector* G4PionMinusAbsorptionAtRest::GetSecondaryKinematics()
{
return ( &gkin[0] );
}
G4double G4PionMinusAbsorptionAtRest::AtRestGetPhysicalInteractionLength(
const G4Track& track,
G4ForceCondition* condition
)
{
// beggining of tracking
ResetNumberOfInteractionLengthLeft();
// condition is set to "Not Forced"
*condition = NotForced;
// get mean life time
currentInteractionLength = GetMeanLifeTime(track, condition);
if ((currentInteractionLength <0.0) || (verboseLevel>2)){
G4cout << "G4PionMinusAbsorptionAtRestProcess::AtRestGetPhysicalInteractionLength ";
G4cout << "[ " << GetProcessName() << "]" <<G4endl;
track.GetDynamicParticle()->DumpInfo();
G4cout << " in Material " << track.GetMaterial()->GetName() <<G4endl;
G4cout << "MeanLifeTime = " << currentInteractionLength/ns << "[ns]" <<G4endl;
}
return theNumberOfInteractionLengthLeft * currentInteractionLength;
}
G4VParticleChange* G4PionMinusAbsorptionAtRest::AtRestDoIt(
const G4Track& track,
const G4Step&
)
//
// Handles PionMinuss at rest; a PionMinus can either create secondaries or
// do nothing (in which case it should be sent back to decay-handling
// section
//
{
// Initialize ParticleChange
// all members of G4VParticleChange are set to equal to
// corresponding member in G4Track
aParticleChange.Initialize(track);
// Store some global quantities that depend on current material and particle
globalTime = track.GetGlobalTime()/s;
G4Material * aMaterial = track.GetMaterial();
const G4int numberOfElements = aMaterial->GetNumberOfElements();
const G4ElementVector* theElementVector = aMaterial->GetElementVector();
const G4double* theAtomicNumberDensity = aMaterial->GetAtomicNumDensityVector();
G4double normalization = 0;
for ( G4int i1=0; i1 < numberOfElements; i1++ )
{
normalization += theAtomicNumberDensity[i1] ; // change when nucleon specific
// probabilities are included.
}
G4double runningSum= 0.;
G4double random = G4UniformRand()*normalization;
for ( G4int i2=0; i2 < numberOfElements; i2++ )
{
runningSum += theAtomicNumberDensity[i2]; // change when nucleon specific
// probabilities are included.
if (random<=runningSum)
{
targetCharge = G4double((*theElementVector)[i2]->GetZ());
targetAtomicMass = (*theElementVector)[i2]->GetN();
}
}
if (random>runningSum)
{
targetCharge = G4double((*theElementVector)[numberOfElements-1]->GetZ());
targetAtomicMass = (*theElementVector)[numberOfElements-1]->GetN();
}
if (verboseLevel>1) {
G4cout << "G4PionMinusAbsorptionAtRest::AtRestDoIt is invoked " <<G4endl;
}
G4ParticleMomentum momentum;
G4float localtime;
G4ThreeVector position = track.GetPosition();
GenerateSecondaries(); // Generate secondaries
aParticleChange.SetNumberOfSecondaries( ngkine );
for ( G4int isec = 0; isec < ngkine; isec++ ) {
G4DynamicParticle* aNewParticle = new G4DynamicParticle;
aNewParticle->SetDefinition( gkin[isec].GetParticleDef() );
aNewParticle->SetMomentum( gkin[isec].GetMomentum() * GeV );
localtime = globalTime + gkin[isec].GetTOF();
G4Track* aNewTrack = new G4Track( aNewParticle, localtime*s, position );
aNewTrack->SetTouchableHandle(track.GetTouchableHandle());
aParticleChange.AddSecondary( aNewTrack );
}
aParticleChange.ProposeLocalEnergyDeposit( 0.0*GeV );
aParticleChange.ProposeTrackStatus(fStopAndKill); // Kill the incident PionMinus
// clear InteractionLengthLeft
ResetNumberOfInteractionLengthLeft();
return &aParticleChange;
}
void G4PionMinusAbsorptionAtRest::GenerateSecondaries()
{
static G4int index;
static G4int l;
static G4int nopt;
static G4int i;
// DHW 15 May 2011: unused: static G4ParticleDefinition* jnd;
for (i = 1; i <= MAX_SECONDARIES; ++i) {
pv[i].SetZero();
}
ngkine = 0; // number of generated secondary particles
ntot = 0;
result.SetZero();
result.SetMass( massPionMinus );
result.SetKineticEnergyAndUpdate( 0. );
result.SetTOF( 0. );
result.SetParticleDef( pdefPionMinus );
PionMinusAbsorption(&nopt);
// *** CHECK WHETHER THERE ARE NEW PARTICLES GENERATED ***
if (ntot != 0 || result.GetParticleDef() != pdefPionMinus) {
// *** CURRENT PARTICLE IS NOT THE SAME AS IN THE BEGINNING OR/AND ***
// *** ONE OR MORE SECONDARIES HAVE BEEN GENERATED ***
// --- INITIAL PARTICLE TYPE HAS BEEN CHANGED ==> PUT NEW TYPE ON ---
// --- THE GEANT TEMPORARY STACK ---
// --- PUT PARTICLE ON THE STACK ---
gkin[0] = result;
gkin[0].SetTOF( result.GetTOF() * 5e-11 );
ngkine = 1;
// --- ALL QUANTITIES ARE TAKEN FROM THE GHEISHA STACK WHERE THE ---
// --- CONVENTION IS THE FOLLOWING ---
// --- ONE OR MORE SECONDARIES HAVE BEEN GENERATED ---
for (l = 1; l <= ntot; ++l) {
index = l - 1;
// DHW 15 May 2011: unused: jnd = eve[index].GetParticleDef();
// --- ADD PARTICLE TO THE STACK IF STACK NOT YET FULL ---
if (ngkine < MAX_SECONDARIES) {
gkin[ngkine] = eve[index];
gkin[ngkine].SetTOF( eve[index].GetTOF() * 5e-11 );
++ngkine;
}
}
}
else {
// --- NO SECONDARIES GENERATED AND PARTICLE IS STILL THE SAME ---
// --- ==> COPY EVERYTHING BACK IN THE CURRENT GEANT STACK ---
ngkine = 0;
ntot = 0;
globalTime += result.GetTOF() * G4float(5e-11);
}
// --- LIMIT THE VALUE OF NGKINE IN CASE OF OVERFLOW ---
ngkine = G4int(std::min(ngkine,G4int(MAX_SECONDARIES)));
} // GenerateSecondaries
void G4PionMinusAbsorptionAtRest::PionMinusAbsorption(G4int *nopt)
{
static G4int i;
static G4int nt, nbl;
static G4float ran, tex;
static G4int isw;
static G4float ran2, tof1, ekin;
static G4float ekin1, ekin2, black;
static G4float pnrat;
static G4ParticleDefinition* ipa1;
static G4ParticleDefinition* inve;
// *** CHARGED PION ABSORPTION BY A NUCLEUS ***
// *** NVE 04-MAR-1988 CERN GENEVA ***
// ORIGIN : H.FESEFELDT (09-JULY-1987)
// PANOFSKY RATIO (PI- P --> N PI0/PI- P --> N GAMMA) = 3/2
// FOR CAPTURE ON PROTON (HYDROGEN),
// STAR PRODUCTION FOR HEAVIER ELEMENTS
pv[1].SetZero();
pv[1].SetMass( massPionMinus );
pv[1].SetKineticEnergyAndUpdate( 0. );
pv[1].SetTOF( result.GetTOF() );
pv[1].SetParticleDef( result.GetParticleDef() );
if (targetAtomicMass <= G4float(1.5)) {
ran = G4UniformRand();
isw = 1;
if (ran < G4float(.33)) {
isw = 2;
}
*nopt = isw;
ran = G4UniformRand();
tof1 = std::log(ran) * G4float(-25.);
tof1 *= G4float(20.);
if (isw != 1) {
pv[2].SetZero();
pv[2].SetMass( 0. );
pv[2].SetKineticEnergyAndUpdate( .02 );
pv[2].SetTOF( result.GetTOF() + tof1 );
pv[2].SetParticleDef( pdefGamma );
}
else {
pv[2] = pv[1];
pv[2].SetTOF( result.GetTOF() + tof1 );
pv[2].SetParticleDef( pdefPionZero );
}
result = pv[2];
}
else {
// **
// ** STAR PRODUCTION FOR PION ABSORPTION IN HEAVY ELEMENTS
// **
evapEnergy1 = G4float(.0135);
evapEnergy3 = G4float(.0058);
nt = 1;
tex = evapEnergy1;
black = std::log(targetAtomicMass) * G4float(.5);
Poisso(black, &nbl);
if (nbl <= 0) {
nbl = 1;
}
if (nt + nbl > (MAX_SECONDARIES - 2)) {
nbl = (MAX_SECONDARIES - 2) - nt;
}
ekin = tex / nbl;
ekin2 = G4float(0.);
for (i = 1; i <= nbl; ++i) {
if (nt == (MAX_SECONDARIES - 2)) {
continue;
}
ran2 = G4UniformRand();
ekin1 = -G4double(ekin) * std::log(ran2);
ekin2 += ekin1;
ipa1 = pdefNeutron;
pnrat = G4float(1.) - targetCharge / targetAtomicMass;
if (G4UniformRand() > pnrat) {
ipa1 = pdefProton;
}
++nt;
pv[nt].SetZero();
pv[nt].SetMass( ipa1->GetPDGMass()/GeV );
pv[nt].SetKineticEnergyAndUpdate( ekin1 );
pv[nt].SetTOF( 2. );
pv[nt].SetParticleDef( ipa1 );
if (ekin2 > tex) {
break;
}
}
tex = evapEnergy3;
black = std::log(targetAtomicMass) * G4float(.5);
Poisso(black, &nbl);
if (nt + nbl > (MAX_SECONDARIES - 2)) {
nbl = (MAX_SECONDARIES - 2) - nt;
}
if (nbl <= 0) {
nbl = 1;
}
ekin = tex / nbl;
ekin2 = G4float(0.);
for (i = 1; i <= nbl; ++i) {
if (nt == (MAX_SECONDARIES - 2)) {
continue;
}
ran2 = G4UniformRand();
ekin1 = -G4double(ekin) * std::log(ran2);
ekin2 += ekin1;
++nt;
ran = G4UniformRand();
inve= pdefDeuteron;
if (ran > G4float(.6)) {
inve = pdefTriton;
}
if (ran > G4float(.9)) {
inve = pdefAlpha;
}
pv[nt].SetZero();
pv[nt].SetMass( inve->GetPDGMass()/GeV );
pv[nt].SetKineticEnergyAndUpdate( ekin1 );
pv[nt].SetTOF( 2. );
pv[nt].SetParticleDef( inve );
if (ekin2 > tex) {
break;
}
}
// **
// ** STORE ON EVENT COMMON
// **
ran = G4UniformRand();
tof1 = std::log(ran) * G4float(-25.);
tof1 *= G4float(20.);
for (i = 2; i <= nt; ++i) {
pv[i].SetTOF( result.GetTOF() + tof1 );
}
result = pv[2];
for (i = 3; i <= nt; ++i) {
if (ntot >= MAX_SECONDARIES) {
break;
}
eve[ntot++] = pv[i];
}
}
} // PionMinusAbsorption
void G4PionMinusAbsorptionAtRest::Poisso(G4float xav, G4int *iran)
{
static G4int i;
static G4float r, p1, p2, p3;
static G4int fivex;
static G4float rr, ran, rrr, ran1;
// *** GENERATION OF POISSON DISTRIBUTION ***
// *** NVE 16-MAR-1988 CERN GENEVA ***
// ORIGIN : H.FESEFELDT (27-OCT-1983)
// --- USE NORMAL DISTRIBUTION FOR <X> > 9.9 ---
if (xav > G4float(9.9)) {
// ** NORMAL DISTRIBUTION WITH SIGMA**2 = <X>
Normal(&ran1);
ran1 = xav + ran1 * std::sqrt(xav);
*iran = G4int(ran1);
if (*iran < 0) {
*iran = 0;
}
}
else {
fivex = G4int(xav * G4float(5.));
*iran = 0;
if (fivex > 0) {
r = std::exp(-G4double(xav));
ran1 = G4UniformRand();
if (ran1 > r) {
rr = r;
for (i = 1; i <= fivex; ++i) {
++(*iran);
if (i <= 5) {
rrr = std::pow(xav, G4float(i)) / NFac(i);
}
// ** STIRLING' S FORMULA FOR LARGE NUMBERS
if (i > 5) {
rrr = std::exp(i * std::log(xav) -
(i + G4float(.5)) * std::log(i * G4float(1.)) +
i - G4float(.9189385));
}
rr += r * rrr;
if (ran1 <= rr) {
break;
}
}
}
}
else {
// ** FOR VERY SMALL XAV TRY IRAN=1,2,3
p1 = xav * std::exp(-G4double(xav));
p2 = xav * p1 / G4float(2.);
p3 = xav * p2 / G4float(3.);
ran = G4UniformRand();
if (ran >= p3) {
if (ran >= p2) {
if (ran >= p1) {
*iran = 0;
}
else {
*iran = 1;
}
}
else {
*iran = 2;
}
}
else {
*iran = 3;
}
}
}
} // Poisso
G4int G4PionMinusAbsorptionAtRest::NFac(G4int n)
{
G4int ret_val;
static G4int i, j;
// *** NVE 16-MAR-1988 CERN GENEVA ***
// ORIGIN : H.FESEFELDT (27-OCT-1983)
ret_val = 1;
j = n;
if (j > 1) {
if (j > 10) {
j = 10;
}
for (i = 2; i <= j; ++i) {
ret_val *= i;
}
}
return ret_val;
} // NFac
void G4PionMinusAbsorptionAtRest::Normal(G4float *ran)
{
static G4int i;
// *** NVE 14-APR-1988 CERN GENEVA ***
// ORIGIN : H.FESEFELDT (27-OCT-1983)
*ran = G4float(-6.);
for (i = 1; i <= 12; ++i) {
*ran += G4UniformRand();
}
} // Normal
source/processes/hadronic/stopping/src/G4StopDeexcitation.cc
-72
View File
@@ -1,72 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4StopDeexcitation
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 8 May 1998
//
// -------------------------------------------------------------------
#include "G4StopDeexcitation.hh"
#include <vector>
#include "globals.hh"
#include "Randomize.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleDefinition.hh"
#include "G4ThreeVector.hh"
#include "G4HadronicDeprecate.hh"
// Constructor
G4StopDeexcitation::G4StopDeexcitation(G4StopDeexcitationAlgorithm* algorithm)
{
G4HadronicDeprecate("G4StopDeexcitation");
_algorithm = algorithm;
}
// Destructor
G4StopDeexcitation::~G4StopDeexcitation()
{
delete _algorithm;
}
G4ReactionProductVector* G4StopDeexcitation::DoBreakUp(G4double A, G4double Z,
G4double excitation,
const G4ThreeVector& p) const
{
G4ReactionProductVector* v = 0;
if (_algorithm != 0)
{
v = _algorithm->BreakUp(A,Z,excitation,p);
}
return v;
}
source/processes/hadronic/stopping/src/G4StopDummyDeexcitation.cc
-66
View File
@@ -1,66 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4StopDummyDeexcitation
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 8 May 1998
//
// -------------------------------------------------------------------
#include "G4ios.hh"
#include "G4StopDummyDeexcitation.hh"
#include "globals.hh"
#include "G4DynamicParticleVector.hh"
#include "G4ThreeVector.hh"
#include "G4HadronicDeprecate.hh"
// Constructor
G4StopDummyDeexcitation::G4StopDummyDeexcitation()
{
G4HadronicDeprecate("G4StopDummyDeexcitation");
_products = 0;
}
// Destructor
G4StopDummyDeexcitation::~G4StopDummyDeexcitation()
{
}
G4ReactionProductVector* G4StopDummyDeexcitation::BreakUp(G4double /*A*/, G4double /*Z*/,
G4double /*excitation*/,
const G4ThreeVector& /*p*/)
{
return 0;
}
source/processes/hadronic/stopping/src/G4StopElementSelector.cc
+6 -159
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
// $Id: G4StopElementSelector.cc 69573 2013-05-08 13:35:53Z gcosmo $
//
// File: G4StopElementSelector
//
@@ -36,7 +36,8 @@
// 17/05/2006 V.Ivanchenko Cleanup
// 02/10/2007 V.Ivanchenko Fixed typo in computation of Lambda-factor
// proposed by Victor Pec
//
// 04/23/2013 K.Genser used new G4MuonMinusBoundDecay
// in GetMuonCaptureRate and GetMuonDecayRate
//---------------------------------------------------------------------
#include "G4StopElementSelector.hh"
@@ -44,6 +45,7 @@
#include "G4SystemOfUnits.hh"
#include "Randomize.hh"
#include "G4Material.hh"
#include "G4MuonMinusBoundDecay.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
@@ -123,167 +125,12 @@ G4Element* G4StopElementSelector::GetElement(const G4Material* aMaterial)
G4double G4StopElementSelector::GetMuonCaptureRate(G4double Z, G4double A)
{
// Initialized data
// static std::vector<G4double> zeff(100);
static G4double zeff[100] = {
1.,1.98,2.95,3.89,4.8,5.72,6.61,7.49,8.32,9.12,9.95,10.69,11.48,12.22,
12.91,13.64,14.24,14.89,15.53,16.15,16.75,17.38,18.04,18.49,
19.06,19.59,20.1,20.66,21.12,21.61,22.02,22.43,22.84,23.24,
23.65,24.06,24.47,24.85,25.23,25.61,25.99,26.37,26.69,27.,
27.32,27.63,27.95,28.2,28.42,28.64,28.79,29.03,29.27,29.51,
29.75,29.99,30.2,30.36,30.53,30.69,30.85,31.01,31.18,31.34,
31.48,31.62,31.76,31.9,32.05,32.19,32.33,32.47,32.61,32.76,
32.94,33.11,33.29,33.46,33.64,33.81,34.21,34.18,34.,34.1,
34.21,34.31,34.42,34.52,34.63,34.73,34.84,34.94,35.04,35.15,
35.25,35.36,35.46,35.57,35.67,35.78 };
// Mu- capture data from B.B.Balashov, G.Ya.Korenman, P.A.Eramgan
// Atomizdat, 1978. (Experimental capture velocities)
// Data for Hydrogen from Phys. Rev. Lett. 99(2007)032002
const size_t ListZE = 66;
static G4int ListZExp[ListZE] = {1,
3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
13, 14, 15, 16, 17, 18, 19, 20, 22, 23,
24, 25, 26, 27, 28, 31, 32, 33, 34, 37,
38, 39, 40, 41, 42, 45, 46, 47, 48, 49,
50, 51, 52, 53, 55, 56, 57, 58, 59, 60,
62, 64, 65, 67, 72, 73, 74, 80, 81, 82,
83, 90, 92, 93};
static G4double ListCaptureVel[ListZE] = {0.000725,
0.0057, 0.010, 0.0258, 0.0371, 0.0644,
0.0974, 0.144, 0.250, 0.386, 0.479,
0.700, 0.849, 1.119, 1.338, 1.40,
1.30, 1.98, 2.45, 2.60, 3.19,
3.29, 3.91, 4.41, 4.96, 5.74,
5.68, 5.53, 6.06, 5.69, 6.89,
7.25, 7.89, 8.59, 10.40, 9.22,
10.01, 10.00, 10.88, 10.62, 11.37,
10.68, 10.49, 9.06, 11.20, 10.98,
10.18, 10.71, 11.44, 13.45, 12.32,
12.22, 12.09, 12.73, 12.95, 13.03,
12.86, 13.13, 13.39, 12.74, 13.78,
13.02, 13.26, 13.10, 14.00, 14.70};
// Local variables
G4double zeff2, xmu, a2ze, r1, r2;
G4double lambda;
// == Effective charges from Ford and Wills Nucl Phys 35(1962)295.
// == Untabulated charges are interpolated.
// == Mu capture lifetime (Goulard and Primakoff PRC10(1974)2034.
G4int i = G4int(Z) - 1 ;
if(i > 99) i = 99;
const G4double b0a = -.03;
const G4double b0b = -.25;
const G4double b0c = 3.24;
const G4double t1 = 875.e-10;
r1 = zeff[i];
zeff2 = r1 * r1;
// ^-4 -> ^-5 suggested by user
xmu = zeff2 * 2.663e-5;
a2ze = 0.5 * A / Z;
r2 = 1.0 - xmu;
lambda = t1 * zeff2 * zeff2 * (r2 * r2) * (1.0 - (1.0 - xmu) * .75704) *
(a2ze * b0a + 1.0 - (a2ze - 1.0) * b0b -
(2.0 * (A - Z) + std::abs(a2ze - 1.) ) * b0c / (A * 4.) );
// == Mu capture data are taken if exist
for (unsigned int j = 0; j < ListZE; j++) {
if( ListZExp[j] == i + 1) {
lambda = ListCaptureVel[j] / microsecond;
break;
}
}
return lambda;
return G4MuonMinusBoundDecay::GetMuonCaptureRate(G4int(Z),G4int(A));
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4StopElementSelector::GetMuonDecayRate(G4double Z, G4double /* A */)
{
// Decay time on K-shell
// N.C.Mukhopadhyay Phys. Rep. 30 (1977) 1.
G4double lambda = 1.0;
if(Z > 1) {
G4double x = Z*fine_structure_const;
lambda -= 2.5 * x * x;
if( 0.5 > lambda ) { lambda = 0.5; }
}
return lambda * 0.445164 / microsecond;
return G4MuonMinusBoundDecay::GetMuonDecayRate(G4int(Z));
}
source/processes/hadronic/stopping/src/G4StopTheoDeexcitation.cc
-87
View File
@@ -1,87 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// File name: G4StopTheoDeexcitation
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 8 May 1998
//
// Modifications:
// MGP 4 July 1998 Modified parameters to force evaporation
//
// -------------------------------------------------------------------
#include "G4ios.hh"
#include "G4StopTheoDeexcitation.hh"
#include "globals.hh"
#include "G4SystemOfUnits.hh"
#include "G4ThreeVector.hh"
#include "G4LorentzVector.hh"
#include "G4NucleiProperties.hh"
#include "G4Fragment.hh"
#include "G4ExcitationHandler.hh"
#include "G4DynamicParticleVector.hh"
#include "G4HadronicDeprecate.hh"
// Constructor
G4StopTheoDeexcitation::G4StopTheoDeexcitation() {
G4HadronicDeprecate("G4StopTheoDeexcitation");
}
// Destructor
G4StopTheoDeexcitation::~G4StopTheoDeexcitation()
{}
G4ReactionProductVector*
G4StopTheoDeexcitation::BreakUp(G4double A, G4double Z, G4double excitation,
const G4ThreeVector& p)
{
G4ExcitationHandler theHandler;
// MF and FB parameters modified by MGP to force evaporation
// Max A and Z values for use Fermi Breakup
// theHandler.SetMaxAandZForFermiBreakUp(16, 10);
// theHandler.SetMaxAandZForFermiBreakUp(2, 1);
// Min excitation energy (per nucleon) for use MultiFrag
theHandler.SetMinEForMultiFrag(300*GeV);
// Deexcite the nucleus
G4double atomicMass = G4NucleiProperties::GetNuclearMass(static_cast<G4int>(A),static_cast<G4int>(Z));
G4double mass = atomicMass + excitation;
G4double pMag = p.mag();
G4LorentzVector initialMomentum(p.x(),p.y(),p.z(),std::sqrt(pMag*pMag + mass*mass));
G4Fragment theExcitedNucleus(static_cast<G4int>(A),static_cast<G4int>(Z),initialMomentum);
return theHandler.BreakItUp(theExcitedNucleus);
}