Import Geant4 0.0.0 source tree

This commit is contained in:
Gabriele Cosmo
2016-06-01 15:25:35 +02:00
parent 54d6b71f95
commit b97f8d0df7
3237 changed files with 807095 additions and 0 deletions
@@ -0,0 +1,122 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4AntiNeutronAnnihilationAtRest.hh,v 2.0 1998/07/02 16:36:54 gunter Exp $
// GEANT4 tag $Name: geant4-00 $
//
// ------------------------------------------------------------
// GEANT 4 class header file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, CN Division, ASD group
// History: first implementation, based on object model of
// 2nd December 1995, G.Cosmo
// ------------ G4AntiNeutronAnnihilationAtRest physics process ------
// by Larry Felawka (TRIUMF), April 1998
// E-mail: felawka@alph04.triumf.ca
// ************************************************************
//-----------------------------------------------------------------------------
#ifndef G4AntiNeutronAnnihilationAtRest_h
#define G4AntiNeutronAnnihilationAtRest_h 1
#include "globals.hh"
#include "Randomize.hh"
#include "G4VRestProcess.hh"
#include "G4VParticleChange.hh"
#include "G4ParticleDefinition.hh"
#include "G4GHEKinematicsVector.hh"
class G4AntiNeutronAnnihilationAtRest : public G4VRestProcess
{
private:
// hide assignment operator as private
G4AntiNeutronAnnihilationAtRest& operator=(const G4AntiNeutronAnnihilationAtRest &right);
G4AntiNeutronAnnihilationAtRest(const G4AntiNeutronAnnihilationAtRest& );
public:
G4AntiNeutronAnnihilationAtRest(const G4String& processName ="AntiNeutronAnnihilationAtRest");
~G4AntiNeutronAnnihilationAtRest();
G4bool IsApplicable(const G4ParticleDefinition&);
// null physics table
void BuildPhysicsTable(const G4ParticleDefinition&){}
G4double AtRestGetPhysicalInteractionLength(const G4Track&,
G4ForceCondition*);
// zero mean lifetime
G4double GetMeanLifeTime(const G4Track& aTrack,
G4ForceCondition* condition) {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 AntiNeutronAnnihilation( G4int* );
G4double ExNu( G4float );
G4int NFac( G4int );
private:
// global time-of-flight of stopped AntiNeutron
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 massPionZero;
G4float massPionPlus;
G4float massGamma;
G4float massAntiNeutron;
G4float massNeutron;
G4ParticleDefinition* pdefGamma;
G4ParticleDefinition* pdefPionPlus;
G4ParticleDefinition* pdefPionZero;
G4ParticleDefinition* pdefPionMinus;
G4ParticleDefinition* pdefProton;
G4ParticleDefinition* pdefNeutron;
G4ParticleDefinition* pdefAntiNeutron;
G4ParticleDefinition* pdefDeuteron;
G4ParticleDefinition* pdefTriton;
G4ParticleDefinition* pdefAlpha;
};
#endif
@@ -0,0 +1,122 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4AntiProtonAnnihilationAtRest.hh,v 2.0 1998/07/02 16:36:56 gunter Exp $
// GEANT4 tag $Name: geant4-00 $
//
// ------------------------------------------------------------
// GEANT 4 class header file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, CN Division, ASD group
// History: first implementation, based on object model of
// 2nd December 1995, G.Cosmo
// ------------ G4AntiProtonAnnihilationAtRest physics process ------
// by Larry Felawka (TRIUMF), April 1998
// E-mail: felawka@alph04.triumf.ca
// ************************************************************
//-----------------------------------------------------------------------------
#ifndef G4AntiProtonAnnihilationAtRest_h
#define G4AntiProtonAnnihilationAtRest_h 1
#include "globals.hh"
#include "Randomize.hh"
#include "G4VRestProcess.hh"
#include "G4VParticleChange.hh"
#include "G4ParticleDefinition.hh"
#include "G4GHEKinematicsVector.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");
~G4AntiProtonAnnihilationAtRest();
G4bool IsApplicable(const G4ParticleDefinition&);
// null physics table
void BuildPhysicsTable(const G4ParticleDefinition&){}
G4double AtRestGetPhysicalInteractionLength(const G4Track&,
G4ForceCondition*);
// zero mean lifetime
G4double GetMeanLifeTime(const G4Track& aTrack,
G4ForceCondition* condition) {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
@@ -0,0 +1,63 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4DistributionGenerator.hh,v 2.1 1998/07/12 03:07:08 urbi Exp $
// GEANT4 tag $Name: geant4-00 $
//
// -------------------------------------------------------------------
// GEANT 4 class file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, IT Division, ASD group
//
// File name: G4DistributionGenerator.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 12 May 1998
//
// Modifications:
// -------------------------------------------------------------------
#ifndef G4DISTRIBUTIONGENERATOR_HH
#define G4DISTRIBUTIONGENERATOR_HH
#include <rw/tvordvec.h>
#include "globals.hh"
#include "Randomize.hh"
class G4DistributionGenerator
{
public:
// Constructor
G4DistributionGenerator(RWTValOrderedVector<G4double>& x,
RWTValOrderedVector<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& );
RWTValOrderedVector<G4double> _x;
RWTValOrderedVector<G4double> _cumProb;
};
#endif
@@ -0,0 +1,119 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4KaonMinusAbsorption.hh,v 2.0 1998/07/02 16:36:59 gunter Exp $
// GEANT4 tag $Name: geant4-00 $
//
// ------------------------------------------------------------
// GEANT 4 class header file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, CN Division, ASD group
// History: first implementation, based on object model of
// 2nd December 1995, G.Cosmo
// ------------ G4KaonMinusAbsorption physics process ------
// by Larry Felawka (TRIUMF), April 1998
// E-mail: felawka@alph04.triumf.ca
// ************************************************************
//-----------------------------------------------------------------------------
#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"
class G4KaonMinusAbsorption : public G4VRestProcess
{
private:
// hide assignment operator as private
G4KaonMinusAbsorption& operator=(const G4KaonMinusAbsorption &right);
G4KaonMinusAbsorption(const G4KaonMinusAbsorption& );
public:
G4KaonMinusAbsorption(const G4String& processName ="KaonMinusAbsorption");
~G4KaonMinusAbsorption();
G4bool IsApplicable(const G4ParticleDefinition&);
// null physics table
void BuildPhysicsTable(const G4ParticleDefinition&){}
G4double AtRestGetPhysicalInteractionLength(const G4Track&,
G4ForceCondition*);
// zero mean lifetime
G4double GetMeanLifeTime(const G4Track& aTrack,
G4ForceCondition* condition) {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
@@ -0,0 +1,133 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4KaonMinusAbsorptionAtRest.hh,v 2.5 1998/10/02 17:25:44 pia Exp $
// GEANT4 tag $Name: geant4-00 $
//
// -------------------------------------------------------------------
// GEANT 4 class file --- Copyright CERN 1997
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, IT Division, ASD group
//
// File name: G4KaonMinusAbsorptionAtRest.hh
//
// Author: Christian V"olcker (Christian.Volcker@cern.ch),
//
// Creation date: 10. November 1997
//
// Modifications:
// -------------------------------------------------------------------
#ifndef G4KaonMinusAbsorptionAtRest_h
#define G4KaonMinusAbsorptionAtRest_h 1
#include <rw/tpordvec.h>
#include "globals.hh"
#include "Randomize.hh"
#include "G4VRestProcess.hh"
#include "G4ParticleTypes.hh"
#include "G4Nucleus.hh"
#include "G4DynamicParticle.hh"
#include "G4DynamicParticleVector.hh"
#include "G4NucleiPropertiesTable.hh"
//#include "G4String.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");
~G4KaonMinusAbsorptionAtRest();
//override methods...
public:
G4bool IsApplicable(const G4ParticleDefinition& particle) {
return( particle == *(G4KaonMinus::KaonMinus()) );
}
// 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* condition)
{
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
@@ -0,0 +1,182 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4MuonMinusCaptureAtRest.hh,v 2.0 1998/07/02 16:37:02 gunter Exp $
// GEANT4 tag $Name: geant4-00 $
//
// ------------------------------------------------------------
// GEANT 4 class header file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, CN Division, ASD group
// History: first implementation, based on object model of
// 2nd December 1995, G.Cosmo
// ------------ G4MuonMinusCaptureAtRest physics process ------
// by Larry Felawka (TRIUMF)
// E-mail: felawka@alph04.triumf.ca
// and Art Olin (TRIUMF)
// E-mail: olin@triumf.ca
// April 1998
// ************************************************************
//-----------------------------------------------------------------------------
#ifndef G4MuonMinusCaptureAtRest_h
#define G4MuonMinusCaptureAtRest_h 1
#include "globals.hh"
#include "Randomize.hh"
#include "G4VRestProcess.hh"
#include "G4VParticleChange.hh"
#include "G4ParticleDefinition.hh"
#include "G4GHEKinematicsVector.hh"
class G4MuonMinusCaptureAtRest : public G4VRestProcess
{
private:
// hide assignment operator as private
G4MuonMinusCaptureAtRest& operator=(const G4MuonMinusCaptureAtRest &right);
G4MuonMinusCaptureAtRest(const G4MuonMinusCaptureAtRest& );
public:
G4MuonMinusCaptureAtRest(const G4String& processName ="MuonMinusCaptureAtRest");
~G4MuonMinusCaptureAtRest();
G4bool IsApplicable(const G4ParticleDefinition&);
// null physics table
void BuildPhysicsTable(const G4ParticleDefinition&){}
G4double AtRestGetPhysicalInteractionLength(const G4Track&,
G4ForceCondition*);
G4double GetMeanLifeTime(const G4Track&, G4ForceCondition*);
G4VParticleChange* AtRestDoIt(const G4Track&, const G4Step&);
// return number of secondaries produced
G4int GetNumberOfSecondaries();
// pointer to array containg kinematics of secondaries
G4GHEKinematicsVector* GetSecondaryKinematics();
private:
void CascadeCorrection(G4double, G4double);
G4double CoulombBarrier(G4int, G4double);
void ExcitationEnergyLevel(G4int, G4int, G4double*, G4double*, G4double*);
G4double CalculateIsotopicMass(G4double, G4double);
void EvaporationDeexcitation();
void FermiMotion(G4int);
void ResidualNucleusCascade(G4int, G4int, G4double, G4double*,
G4double*, G4bool*);
G4double GetIsotopicMass(G4double, G4double);
void Erup();
void InitializeMuCapture();
G4double LevelDensity(G4int, G4int, G4double*, G4double*);
void GetCaptureIsotope(const G4Track&);
void NuclearExcitation(G4double, G4double, G4double, G4double*,
G4double*, G4double, G4double);
void DoMuCapture();
void MuEvaporation();
void RanPolarAng(G4double*, G4double*);
G4double NuclearBindingEnergy(G4double, G4double, G4double, G4double);
void RanDirCos(G4double*, G4double*, G4double*);
void RanAzimuthalAng(G4double*, G4double*);
private:
// relative time-of-flight of stopped hadron
G4double tDelay;
// atomic mass of target nucleus
G4double targetAtomicMass;
// charge of target nucleus
G4double targetCharge;
// effective charge squared of target nucleus
G4double zeff2;
// nuclear isotopica data
G4double isotopicData[11][250];
// residual nuclear masses
G4double residualNuclearMasses[297];
G4GHEKinematicsVector* Fragments;
G4GHEKinematicsVector* Secondaries;
G4GHEKinematicsVector* Evaporates;
G4GHEKinematicsVector* Gkin;
G4int nGkine;
G4int nSecPart;
G4int nallFragm;
G4int nVariousFragm[6];
G4double nucleonMass[2];
G4double nucleonMassSquared[2];
G4double nucleonBindingEn[2];
G4double nucleonPotWell[2];
G4double nucleonMaxFermiEn[2];
G4double atMassCurrent;
G4double chargeCurrent;
G4double massTarget;
G4int atMassTarget;
G4int chargeTarget;
G4double pairCorrFlag;
G4double nucleonFermiEn;
G4double nucleonFermiMomX;
G4double nucleonFermiMomY;
G4double nucleonFermiMomZ;
G4double atMassEvapNucl;
G4double chargeEvapNucl;
G4double iniExcitEnEvapNucl;
G4double finExcitEnEvapNucl;
G4double recoilEnEvapNucl;
// residual nucleus kinematical quantities
G4double totMomResidNucl;
G4double momXResidNucl;
G4double momYResidNucl;
G4double momZResidNucl;
G4double dirCosXResidNucl;
G4double dirCosYResidNucl;
G4double dirCosZResidNucl;
G4double massResidNucl;
G4double totEnResidNucl;
G4double kinEnResidNucl;
G4double excitEnResidNucl;
G4double recoilEnResidNucl;
G4int atMassResidNucl;
G4int chargeResidNucl;
G4double massGamma;
G4double massNeutrinoE;
G4double massProton;
G4double massNeutron;
G4double massFragm[6];
G4ParticleDefinition* pdefGamma;
G4ParticleDefinition* pdefNeutrinoE;
G4ParticleDefinition* pdefMuonMinus;
G4ParticleDefinition* pdefNeutron;
G4ParticleDefinition* pdefFragm[6];
};
#endif
@@ -0,0 +1,108 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4NeutronCaptureAtRest.hh,v 2.0 1998/07/02 16:37:04 gunter Exp $
// GEANT4 tag $Name: geant4-00 $
//
// ------------------------------------------------------------
// GEANT 4 class header file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, CN Division, ASD group
// History: first implementation, based on object model of
// 2nd December 1995, G.Cosmo
// ------------ G4NeutronCaptureAtRest physics process ------
// by Larry Felawka (TRIUMF), April 1998
// E-mail: felawka@alph04.triumf.ca
// ************************************************************
//-----------------------------------------------------------------------------
#ifndef G4NeutronCaptureAtRest_h
#define G4NeutronCaptureAtRest_h 1
#include "globals.hh"
#include "Randomize.hh"
#include "G4VRestProcess.hh"
#include "G4VParticleChange.hh"
#include "G4ParticleDefinition.hh"
#include "G4GHEKinematicsVector.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");
~G4NeutronCaptureAtRest();
G4bool IsApplicable(const G4ParticleDefinition&);
// null physics table
void BuildPhysicsTable(const G4ParticleDefinition&){}
G4double AtRestGetPhysicalInteractionLength(const G4Track&,
G4ForceCondition*);
// zero mean lifetime
G4double GetMeanLifeTime(const G4Track& aTrack,
G4ForceCondition* condition) {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
@@ -0,0 +1,89 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4PiMinusAbsorptionAtRest.hh,v 2.7 1998/10/01 19:29:33 pia Exp $
// GEANT4 tag $Name: geant4-00 $
//
// -------------------------------------------------------------------
// GEANT 4 class file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, IT Division, ASD group
//
// File name: G4PiMinusAbsorptionAtRest.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 9 May 1998
//
// Modifications:
// -------------------------------------------------------------------
#ifndef G4PIMINUSABSORPTIONATREST_HH
#define G4PIMINUSABSORPTIONATREST_HH
#include "globals.hh"
#include "G4VRestProcess.hh"
#include "G4ParticleTypes.hh"
#include "G4PiMinusStopMaterial.hh"
#include "G4PiMinusStopAbsorption.hh"
#include "G4StopDeexcitation.hh"
#include "G4StopDeexcitationAlgorithm.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");
// Destructor
~G4PiMinusAbsorptionAtRest();
G4bool IsApplicable(const G4ParticleDefinition& particle)
{ return ( particle == *(G4PionMinus::PionMinus()) ); }
G4VParticleChange* AtRestDoIt(const G4Track& aTrack, const G4Step& aStep);
void SetDeexcitationAlgorithm(G4int index);
protected:
// zero mean lifetime
G4double GetMeanLifeTime(const G4Track& aTrack,
G4ForceCondition* condition)
{
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
@@ -0,0 +1,105 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4PiMinusStopAbsorption.hh,v 2.4 1998/09/18 16:53:50 pia Exp $
// GEANT4 tag $Name: geant4-00 $
//
// -------------------------------------------------------------------
// GEANT 4 class file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, IT Division, ASD group
//
// 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 <rw/tpordvec.h>
#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 _A;
G4double _Z;
G4int _level;
};
#endif
@@ -0,0 +1,90 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4PiMinusStopAl.hh,v 2.1 1998/07/12 03:07:11 urbi Exp $
// GEANT4 tag $Name: geant4-00 $
//
// -------------------------------------------------------------------
// GEANT 4 class file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, IT Division, ASD group
//
// File name: G4PiMinusStopAl.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// Modifications:
// -------------------------------------------------------------------
#ifndef G4PIMINUSSTOPAL_HH
#define G4PIMINUSSTOPAL_HH
#include <rw/tpordvec.h>
#include <rw/tvordvec.h>
#include <rw/cstring.h>
#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();
// Definitions of absorption products
// virtual RWTValOrderedVector<G4String>* DefinitionVector();
// 4-vectors of absorption products
// virtual RWTPtrOrderedVector<G4LorentzVector>* P4Vector();
// 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
@@ -0,0 +1,84 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4PiMinusStopC.hh,v 2.2 1998/10/01 19:30:12 pia Exp $
// GEANT4 tag $Name: geant4-00 $
//
// -------------------------------------------------------------------
// GEANT 4 class file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, IT Division, ASD group
//
// File name: G4PiMinusStopC.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// Modifications:
// -------------------------------------------------------------------
#ifndef G4PIMINUSSTOPC_HH
#define G4PIMINUSSTOPC_HH
#include <rw/tpordvec.h>
#include <rw/tvordvec.h>
#include <rw/cstring.h>
#include "G4PiMinusStopMaterial.hh"
#include "globals.hh"
#include "G4LorentzVector.hh"
//#include "G4String.hh"
//#include "G4NucleiPropertiesTable.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
@@ -0,0 +1,90 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4PiMinusStopCo.hh,v 2.1 1998/07/12 03:07:12 urbi Exp $
// GEANT4 tag $Name: geant4-00 $
//
// -------------------------------------------------------------------
// GEANT 4 class file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, IT Division, ASD group
//
// File name: G4PiMinusStopCo.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// Modifications:
// -------------------------------------------------------------------
#ifndef G4PIMINUSSTOPCO_HH
#define G4PIMINUSSTOPCO_HH
#include <rw/tpordvec.h>
#include <rw/tvordvec.h>
#include <rw/cstring.h>
#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();
// Definitions of absorption products
// virtual RWTValOrderedVector<G4String>* DefinitionVector();
// 4-vectors of absorption products
// virtual RWTPtrOrderedVector<G4LorentzVector>* P4Vector();
// 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
@@ -0,0 +1,90 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4PiMinusStopCu.hh,v 2.1 1998/07/12 03:07:13 urbi Exp $
// GEANT4 tag $Name: geant4-00 $
//
// -------------------------------------------------------------------
// GEANT 4 class file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, IT Division, ASD group
//
// File name: G4PiMinusStopCu.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// Modifications:
// -------------------------------------------------------------------
#ifndef G4PIMINUSSTOPCU_HH
#define G4PIMINUSSTOPCU_HH
#include <rw/tpordvec.h>
#include <rw/tvordvec.h>
#include <rw/cstring.h>
#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();
// Definitions of absorption products
// virtual RWTValOrderedVector<G4String>* DefinitionVector();
// 4-vectors of absorption products
// virtual RWTPtrOrderedVector<G4LorentzVector>* P4Vector();
// 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
@@ -0,0 +1,90 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4PiMinusStopLi.hh,v 2.1 1998/07/12 03:07:14 urbi Exp $
// GEANT4 tag $Name: geant4-00 $
//
// -------------------------------------------------------------------
// GEANT 4 class file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, IT Division, ASD group
//
// File name: G4PiMinusStopLi.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// Modifications:
// -------------------------------------------------------------------
#ifndef G4PIMINUSSTOPLI_HH
#define G4PIMINUSSTOPLI_HH
#include <rw/tpordvec.h>
#include <rw/tvordvec.h>
#include <rw/cstring.h>
#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();
// Definitions of absorption products
// virtual RWTValOrderedVector<G4String>* DefinitionVector();
// 4-vectors of absorption products
// virtual RWTPtrOrderedVector<G4LorentzVector>* P4Vector();
// 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
@@ -0,0 +1,89 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4PiMinusStopMaterial.hh,v 2.2 1998/09/18 16:53:51 pia Exp $
// GEANT4 tag $Name: geant4-00 $
//
// -------------------------------------------------------------------
// GEANT 4 class file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, IT Division, ASD group
//
// 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 <rw/tvordvec.h>
#include <rw/tpordvec.h>
#include <rw/cstring.h>
#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 RWTPtrOrderedVector<G4ParticleDefinition>* DefinitionVector();
// 4-vectors of absorption products
virtual RWTPtrOrderedVector<G4LorentzVector>* P4Vector(const G4double binding,
const G4double mass);
// Number of final nucleons, out of generated absorption products
virtual G4double FinalNucleons()=0;
protected:
RWTPtrOrderedVector<G4ParticleDefinition>* _definitions;
RWTPtrOrderedVector<G4LorentzVector>* _momenta;
G4DistributionGenerator* _distributionE;
G4DistributionGenerator* _distributionAngle;
G4double _R;
G4double GenerateAngle(G4double range);
G4LorentzVector MakeP4(G4double p, G4double theta,
G4double phi, G4double e);
G4double RecoilEnergy(const G4double mass);
private:
};
#endif
@@ -0,0 +1,90 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4PiMinusStopN.hh,v 2.1 1998/07/12 03:07:15 urbi Exp $
// GEANT4 tag $Name: geant4-00 $
//
// -------------------------------------------------------------------
// GEANT 4 class file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, IT Division, ASD group
//
// File name: G4PiMinusStopN.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// Modifications:
// -------------------------------------------------------------------
#ifndef G4PIMINUSSTOPN_HH
#define G4PIMINUSSTOPN_HH
#include <rw/tpordvec.h>
#include <rw/tvordvec.h>
#include <rw/cstring.h>
#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();
// Definitions of absorption products
// virtual RWTValOrderedVector<G4String>* DefinitionVector();
// 4-vectors of absorption products
// virtual RWTPtrOrderedVector<G4LorentzVector>* P4Vector();
// 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
@@ -0,0 +1,90 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4PiMinusStopO.hh,v 2.1 1998/07/12 03:07:15 urbi Exp $
// GEANT4 tag $Name: geant4-00 $
//
// -------------------------------------------------------------------
// GEANT 4 class file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, IT Division, ASD group
//
// File name: G4PiMinusStopO.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// Modifications:
// -------------------------------------------------------------------
#ifndef G4PIMINUSSTOPO_HH
#define G4PIMINUSSTOPO_HH
#include <rw/tpordvec.h>
#include <rw/tvordvec.h>
#include <rw/cstring.h>
#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();
// Definitions of absorption products
// virtual RWTValOrderedVector<G4String>* DefinitionVector();
// 4-vectors of absorption products
// virtual RWTPtrOrderedVector<G4LorentzVector>* P4Vector();
// 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
@@ -0,0 +1,90 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4PiMinusStopPb.hh,v 2.1 1998/07/12 03:07:16 urbi Exp $
// GEANT4 tag $Name: geant4-00 $
//
// -------------------------------------------------------------------
// GEANT 4 class file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, IT Division, ASD group
//
// File name: G4PiMinusStopPb.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// Modifications:
// -------------------------------------------------------------------
#ifndef G4PIMINUSSTOPPB_HH
#define G4PIMINUSSTOPPB_HH
#include <rw/tpordvec.h>
#include <rw/tvordvec.h>
#include <rw/cstring.h>
#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();
// Definitions of absorption products
// virtual RWTValOrderedVector<G4String>* DefinitionVector();
// 4-vectors of absorption products
// virtual RWTPtrOrderedVector<G4LorentzVector>* P4Vector();
// 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
@@ -0,0 +1,90 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4PiMinusStopTa.hh,v 2.1 1998/07/12 03:07:16 urbi Exp $
// GEANT4 tag $Name: geant4-00 $
//
// -------------------------------------------------------------------
// GEANT 4 class file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, IT Division, ASD group
//
// File name: G4PiMinusStopTa.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// Modifications:
// -------------------------------------------------------------------
#ifndef G4PIMINUSSTOPTA_HH
#define G4PIMINUSSTOPTA_HH
#include <rw/tpordvec.h>
#include <rw/tvordvec.h>
#include <rw/cstring.h>
#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();
// Definitions of absorption products
// virtual RWTValOrderedVector<G4String>* DefinitionVector();
// 4-vectors of absorption products
// virtual RWTPtrOrderedVector<G4LorentzVector>* P4Vector();
// 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
@@ -0,0 +1,115 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4PionMinusAbsorptionAtRest.hh,v 2.0 1998/07/02 16:37:26 gunter Exp $
// GEANT4 tag $Name: geant4-00 $
//
// ------------------------------------------------------------
// GEANT 4 class header file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, CN Division, ASD group
// History: first implementation, based on object model of
// 2nd December 1995, G.Cosmo
// ------------ G4PionMinusAbsorptionAtRest physics process ------
// by Larry Felawka (TRIUMF), April 1998
// E-mail: felawka@alph04.triumf.ca
// ************************************************************
//-----------------------------------------------------------------------------
#ifndef G4PionMinusAbsorptionAtRest_h
#define G4PionMinusAbsorptionAtRest_h 1
#include "globals.hh"
#include "Randomize.hh"
#include "G4VRestProcess.hh"
#include "G4VParticleChange.hh"
#include "G4ParticleDefinition.hh"
#include "G4GHEKinematicsVector.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");
~G4PionMinusAbsorptionAtRest();
G4bool IsApplicable(const G4ParticleDefinition&);
// null physics table
void BuildPhysicsTable(const G4ParticleDefinition&){}
G4double AtRestGetPhysicalInteractionLength(const G4Track&,
G4ForceCondition*);
// zero mean lifetime
G4double GetMeanLifeTime(const G4Track& aTrack,
G4ForceCondition* condition) {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
@@ -0,0 +1,84 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4StopDeexcitation.hh,v 2.3 1998/07/14 12:52:46 jwellisc Exp $
// GEANT4 tag $Name: geant4-00 $
//
// -------------------------------------------------------------------
// GEANT 4 class file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, IT Division, ASD group
//
// File name: G4StopDeexcitation.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 12 May 1998
//
// Modifications:
// -------------------------------------------------------------------
#ifndef G4STOPDEEXCITATION_HH
#define G4STOPDEEXCITATION_HH
#include "globals.hh"
#include "G4DynamicParticle.hh"
#include "G4DynamicParticleVector.hh"
#include "G4ThreeVector.hh"
#include "G4StopDeexcitationAlgorithm.hh"
class G4StopDeexcitation
{
public:
// Constructor
G4StopDeexcitation(G4StopDeexcitationAlgorithm* algorithm);
// Destructor
~G4StopDeexcitation();
// Return final absorption products
G4DynamicParticleVector* 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
@@ -0,0 +1,66 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4StopDeexcitationAlgorithm.hh,v 2.3 1998/10/01 19:30:13 pia Exp $
// GEANT4 tag $Name: geant4-00 $
//
// -------------------------------------------------------------------
// GEANT 4 class file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, IT Division, ASD group
//
// File name: G4StopDeexcitationAlgorithm.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// Modifications:
// -------------------------------------------------------------------
#ifndef G4STOPDEEXCITATIONALGORITHM_HH
#define G4STOPDEEXCITATIONALGORITHM_HH
#include "globals.hh"
#include "G4DynamicParticle.hh"
#include "G4DynamicParticleVector.hh"
#include "G4ThreeVector.hh"
class G4StopDeexcitationAlgorithm
{
private:
// Hide assignment operator as private
G4StopDeexcitationAlgorithm& operator=(const G4StopDeexcitationAlgorithm &right);
// Copy constructor
G4StopDeexcitationAlgorithm(const G4StopDeexcitationAlgorithm& );
public:
// Constructor
G4StopDeexcitationAlgorithm() {};
// Destructor
virtual ~G4StopDeexcitationAlgorithm() {};
// Products
virtual G4DynamicParticleVector* BreakUp(G4double A, G4double Z,
G4double excitation, const G4ThreeVector& p) =0;
protected:
private:
};
#endif
@@ -0,0 +1,69 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4StopDummyDeexcitation.hh,v 2.2 1998/07/14 12:35:23 jwellisc Exp $
// GEANT4 tag $Name: geant4-00 $
//
// -------------------------------------------------------------------
// GEANT 4 class file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, IT Division, ASD group
//
// File name: G4StopDummyDeexcitation.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// Modifications:
// -------------------------------------------------------------------
#ifndef G4STOPDUMMYDEEXCITATION_HH
#define G4STOPDUMMYDEEXCITATION_HH
#include "G4StopDeexcitationAlgorithm.hh"
#include "globals.hh"
#include "G4DynamicParticle.hh"
#include "G4DynamicParticleVector.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 G4DynamicParticleVector* BreakUp(G4double A, G4double Z,
G4double excitation, const G4ThreeVector& p);
protected:
private:
G4DynamicParticleVector* _products;
};
#endif
@@ -0,0 +1,66 @@
// This code implementation is the intellectual property of
// the RD44 GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4StopTheoDeexcitation.hh,v 2.5 1998/10/01 19:30:13 pia Exp $
// GEANT4 tag $Name: geant4-00 $
//
// -------------------------------------------------------------------
// GEANT 4 class file --- Copyright CERN 1998
// CERN Geneva Switzerland
//
// For information related to this code contact:
// CERN, IT Division, ASD group
//
// File name: G4StopTheoDeexcitation.hh
//
// Author: Maria Grazia Pia (pia@genova.infn.it)
//
// Creation date: 18 May 1998
//
// Modifications:
// -------------------------------------------------------------------
#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 G4DynamicParticleVector* BreakUp(G4double A, G4double Z,
G4double excitation, const G4ThreeVector& p);
protected:
private:
};
#endif