Import Geant4 4.0.0 source tree

This commit is contained in:
Gabriele Cosmo
2016-06-08 16:18:25 +02:00
parent 36c080dca6
commit 921d3b1cda
3990 changed files with 185376 additions and 82884 deletions
@@ -0,0 +1,84 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4AtomicTransitionManager.hh,v 1.2 ????
// GEANT4 tag $Name: geant4-04-00 $
//
// Authors: Elena Guardincerri (Elena.Guardincerri@ge.infn.it)
// Alfonso Mantero (Alfonso.Mantero@ge.infn.it)
//
// History:
// -----------
//
// 16 Sept 2001 First committed to cvs
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic Physics, management of atomic deexcitation
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
#ifndef G4AtomicDeexcitation_h
#define G4AtomicDeexcitation_h 1
#include "globals.hh"
#include "g4std/vector"
#include "G4AtomicTransitionManager.hh"
#include "G4DynamicParticle.hh"
class G4AtomicDeexcitation {
public:
G4AtomicDeexcitation();
~G4AtomicDeexcitation();
// Returns a vector contains the photons generated by radiative transitions
// (non zero particles) or by non radiative transitions (zero particles)
G4std::vector<G4DynamicParticle*>* GenerateParticles(G4int Z, G4int shellId);
private:
// Decides wether a radiative transition is possible and, if it is,
// returns the identity of the starting shell for the transition
const G4int SelectTypeOfTransition(G4int Z, G4int shellId);
// Generates a particle from a radiative transition and returns it
G4DynamicParticle* GenerateFluorescence(G4int Z, G4int shellId,G4int provShellId);
// Dummy function: when invowed returns a null pointer
G4DynamicParticle* GenerateAuger(G4int Z, G4int shellId);
// Data member which stores the shells to be filled by
// the radiative transition
G4int newShellId;
};
#endif
@@ -0,0 +1,75 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4AtomicShell.hh,v 1.2 ????
// GEANT4 tag $Name: geant4-04-00 $
//
// Authors: Elena Guardincerri (Elena.Guardincerri@ge.infn.it)
// Alfonso Mantero (Alfonso.Mantero@ge.infn.it)
//
// History:
// -----------
//
// 16 Sept 2001 Modofied according to a design iteration in the
// LowEnergy category
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic Physics, a data container
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
#ifndef G4AtomicShell_h
#define G4AtomicShell_h 1
#include "globals.hh"
class G4AtomicShell {
public:
// The data and the methods of this class are relative to
// a given shell
G4AtomicShell(G4int,G4double);
~G4AtomicShell();
// Returns the binding energy of the shell
G4double BindingEnergy() const;
// Returns the id of the shell
G4int ShellId() const;
private:
G4int identifier;
G4double bindingEnergy;
};
#endif
@@ -0,0 +1,95 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4AtomicTransition.hh,v 1.2 ????
// GEANT4 tag $Name: geant4-04-00 $
//
// Author: Elena Guardincerri (Elena.Guardincerri@ge.infn.it)
//
// History:
// -----------
// 16 Sept 2001 Modofied according to a design iteration in the
// LowEnergy category
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic Physics, a data container
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
#ifndef G4AtomicTransition_h
#define G4AtomicTransition_h 1
#include "G4DataVector.hh"
#include "globals.hh"
#include "g4std/vector"
class G4AtomicTransition {
public:
G4AtomicTransition(G4int,const G4std::vector<G4int>&,const G4DataVector&,
const G4DataVector&);
~G4AtomicTransition();
// All the data stored and provided by this class are relative to a
// given vacancy, whose identity is provided by the FinalShellId() method,
// in an atom of a given material
// Returns the identities of the originating shells for the transitions
const G4std::vector<G4int>& OriginatingShellIds() const;
// Return the energies of the transitions
const G4DataVector& TransitionEnergies() const;
// Return the probabilities of the transitions
const G4DataVector& TransitionProbabilities() const;
// Return the identity if the vacancy
const G4int FinalShellId() const;
// Given the index of the originating shells returns its identity
G4int OriginatingShellId(G4int index) const;
// Given the index of the originating shells returns the energy
// of the transition starting from it
G4double TransitionEnergy(G4int index) const;
// Given the index of the originating shells returns the probability
// of the transition starting from it
G4double TransitionProbability(G4int index) const;
private:
G4int finalShellId;
G4std::vector<G4int> originatingShellIds;
G4DataVector transitionEnergies;
G4DataVector transitionProbabilities;
};
#endif
@@ -0,0 +1,121 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4AtomicTransitionManager.hh,v 1.2 ????
// GEANT4 tag $Name: geant4-04-00 $
//
// Authors: Elena Guardincerri (Elena.Guardincerri@ge.infn.it)
// Alfonso Mantero (Alfonso.Mantero@ge.infn.it)
//
// History:
// -----------
//
// 16 Sept 2001 EG Modified according to a design iteration in the
// LowEnergy category
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic Physics, fills and manages G4AtomicShell
// and G4AtomicTransition objects
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
#ifndef G4AtomicTransitionManager_h
#define G4AtomicTransitionManager_h 1
#include "G4ShellData.hh"
#include "G4FluoData.hh"
#include "G4AtomicTransition.hh"
#include "G4AtomicShell.hh"
#include "g4std/map"
#include "g4std/vector"
#include "globals.hh"
// This class is a singleton
class G4AtomicTransitionManager {
public:
// The only way to get an instance of this class is to call the
// function Instance()
static G4AtomicTransitionManager* Instance();
// Z is the atomic number of the element, shellIndex is the
// index (in EADL) of the shell
const G4AtomicShell* Shell(G4int Z, size_t shellIndex);
// Z is the atomic number of the element, shellIndex is the
// index (in EADL) of the final shell for the transition
const G4AtomicTransition* ReachableShell(G4int Z, size_t shellIndex);
// This function returns the number of shells of the element
// whose atomic number is Z
G4int NumberOfShells(G4int Z);
// This function returns the number of those shells of the element
// whose atomic number is Z which are reachable through a radiative
// transition
G4int NumberOfReachableShells(G4int Z);
// Gives the sum of the probabilities of radiative transition towards the
// shell whose index is shellIndex
G4double TotalRadiativeTransitionProbability(G4int Z, size_t shellIndex);
// Gives the sum of the probabilities of non radiative transition from the
// shell whose index is shellIndex
G4double TotalNonRadiativeTransitionProbability(G4int Z, size_t shellIndex);
protected:
G4AtomicTransitionManager(G4int minZ = 1, G4int maxZ = 99,
G4int limitInfTable = 6, G4int limitSupTable=100 );
~G4AtomicTransitionManager();
private:
static G4AtomicTransitionManager* instance;
// the first element of the map is the atomic number Z.
// the second element is a vector of G4AtomicShell*.
G4std::map<G4int,G4std::vector<G4AtomicShell*>,G4std::less<G4int> > shellTable;
// the first element of the map is the atomic number Z.
// the second element is a vector of G4AtomicTransition*.
G4std::map<G4int,G4std::vector<G4AtomicTransition*>,G4std::less<G4int> > transitionTable;
// Minimum and maximum Z in EADL table containing identities and binding
// energies of shells
G4int zMin;
G4int zMax;
// Minimum and maximum Z in EADL table containing identities, transition
// energies and transition probabilities of shells
G4int infTableLimit;
G4int supTableLimit;
};
#endif
@@ -0,0 +1,83 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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. *
// ********************************************************************
//
//
// -------------------------------------------------------------------
//
// GEANT4 Class file
//
//
// File name: G4BremsstrahlungCrossSectionHandler
//
// Author: V.Ivanchenko (Vladimir.Ivanchenko@cern.ch)
//
// Creation date: 17 September 2001
//
// Modified:
//
// -------------------------------------------------------------------
// Class Description:
//
// Provides build cross sections with cut for LowEnergyBremsstrahlung
//
// Class Description: End
// -------------------------------------------------------------------
//
#ifndef G4BremsstrahlungCrossSectionHandler_h
#define G4BremsstrahlungCrossSectionHandler_h 1
#include "G4VCrossSectionHandler.hh"
#include "G4VEnergySpectrum.hh"
#include "globals.hh"
class G4DataVector;
class G4VEMDataSet;
class G4VDataSetAlgorithm;
class G4BremsstrahlungCrossSectionHandler : public G4VCrossSectionHandler
{
public:
G4BremsstrahlungCrossSectionHandler(const G4VEnergySpectrum* spectrum,
G4VDataSetAlgorithm* interpolation);
~G4BremsstrahlungCrossSectionHandler();
protected:
G4std::vector<G4VEMDataSet*>* BuildCrossSectionsForMaterials(const G4DataVector& energyVector,
const G4DataVector* energyCuts);
private:
const G4VEnergySpectrum* theBR;
G4VDataSetAlgorithm* interp;
};
#endif
@@ -0,0 +1,103 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4BremsstrahlungParameters.hh,v 1.6 2001/11/29 19:01:44 vnivanch Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// Author: Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
// V. Ivanchenko (Vladimir.Ivantchenko@cern.ch)
//
// History:
// -----------
// 31 Jul 2001 MGP Created
// Values of the parameters from A. Forti's fit
// 12.09.01 V.Ivanchenko Add activeZ and paramA
// 25.09.01 V.Ivanchenko Add parameter C and change interface to B
// 29.11.01 V.Ivanchenko Parametrisation is updated
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic Physics
// Load and access to parameters for LowEnergyBremsstrahlung from EEDL
// database. Parametrisation is described in Physics Reference Manual
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
#ifndef G4BREMSSTRAHLUNGPARAMETERS_HH
#define G4BREMSSTRAHLUNGPARAMETERS_HH 1
#include "globals.hh"
#include "G4DataVector.hh"
#include "g4std/map"
class G4VEMDataSet;
class G4VDataSetAlgorithm;
class G4BremsstrahlungParameters {
public:
G4BremsstrahlungParameters(G4int minZ = 1, G4int maxZ = 99);
~G4BremsstrahlungParameters();
G4double Parameter(G4int parameterIndex, G4int Z, G4double energy) const;
G4double ParameterC(G4int index) const;
void PrintData() const;
private:
// hide assignment operator
G4BremsstrahlungParameters(const G4BremsstrahlungParameters&);
G4BremsstrahlungParameters & operator=(const G4BremsstrahlungParameters &right);
void LoadData();
G4std::map<G4int,G4VEMDataSet*,G4std::less<G4int> > param;
G4DataVector paramC;
G4DataVector activeZ;
G4int zMin;
G4int zMax;
size_t length;
};
#endif
@@ -0,0 +1,107 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4CompositeEMDataSet.hh,v 1.3 2001/10/08 15:27:01 pia Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// Author: Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
//
// History:
// -----------
// 31 Jul 2001 MGP Created
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic Physics
// Composite data set for an electromagnetic physics process
// A strategy pattern is used to encapsulate algorithms for data interpolation
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
#ifndef G4COMPOSITEEMDATASET_HH
#define G4COMPOSITEEMDATASET_HH 1
#include "globals.hh"
#include "G4DataVector.hh"
#include "G4VEMDataSet.hh"
#include "g4std/vector"
class G4EMDataSet;
class G4VDataSetAlgorithm;
class G4CompositeEMDataSet : public G4VEMDataSet
{
public:
G4CompositeEMDataSet(G4VDataSetAlgorithm* interpolation,
G4double unitE = MeV, G4double unitData = barn,
G4int minZ = 1, G4int maxZ = 99);
G4CompositeEMDataSet(const G4String& dataFile,
G4VDataSetAlgorithm* interpolation,
G4double unitE = MeV, G4double unitData = barn,
G4int minZ = 1, G4int maxZ = 99);
~G4CompositeEMDataSet();
G4double FindValue(G4double e, G4int Z = 0) const;
const G4VEMDataSet* GetComponent(G4int i) const { return components[i]; }
void AddComponent(G4VEMDataSet* component);
size_t NumberOfComponents() const { return nComponents; }
void PrintData() const;
const G4DataVector& GetEnergies(G4int i) const;
const G4DataVector& GetData(G4int i) const;
private:
void LoadData(const G4String& fileName);
G4VDataSetAlgorithm* algorithm;
G4std::vector<G4VEMDataSet*> components;
size_t nComponents;
G4double unit1;
G4double unit2;
G4int zMin;
G4int zMax;
};
#endif
@@ -0,0 +1,89 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4CrossSectionHandler.hh,v 1.6 2001/10/05 18:25:19 pia Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// Author: Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
//
// History:
// -----------
// 1 Aug 2001 MGP Created
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic Physics
// Data set manager for an electromagnetic physics process
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
#ifndef G4CROSSSECTIONHANDLER_HH
#define G4CROSSSECTIONHANDLER_HH 1
#include "globals.hh"
#include "G4DataVector.hh"
#include "g4std/map"
#include "g4std/vector"
#include "G4VCrossSectionHandler.hh"
class G4VDataSetAlgorithm;
class G4VEMDataSet;
class G4Material;
class G4Element;
class G4CrossSectionHandler : public G4VCrossSectionHandler {
public:
G4CrossSectionHandler();
~G4CrossSectionHandler();
protected:
virtual G4std::vector<G4VEMDataSet*>* BuildCrossSectionsForMaterials(const G4DataVector& energyVector,
const G4DataVector* energyCuts = 0);
private:
// Hide copy constructor and assignment operator
G4CrossSectionHandler(const G4CrossSectionHandler&);
G4CrossSectionHandler & operator=(const G4CrossSectionHandler &right);
};
#endif
@@ -0,0 +1,76 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4CutsPerMaterialWarning.hh,v 1.1 2001/11/07 22:38:47 pia Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// Author: Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
//
// History:
// -----------
// 7 Nov 2001 MGP Created
//
// -------------------------------------------------------------------
// Class description:
// Functor class to print a warning if the deprecated, unsupported feature
// of having different range cuts for different materials is used
// Will be removed when properly designed "range cuts by region"
// will be available in Geant4
// Further documentation available from http://www.ge.infn.it/geant4/lowE/
// -------------------------------------------------------------------
#ifndef G4CUTSPERMATERIALWARNING_HH
#define G4CUTSPERMATERIALWARNING_HH 1
#include "globals.hh"
class G4ParticleDefinition;
class G4Material;
class G4CutsPerMaterialWarning
{
public:
G4CutsPerMaterialWarning() { }
~G4CutsPerMaterialWarning() { }
void PrintWarning(const G4ParticleDefinition* particle) const;
private:
};
#endif
@@ -0,0 +1,107 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4EMDataSet.hh,v 1.2 2001/10/08 07:45:32 pia Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// Author: Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
//
// History:
// -----------
// 31 Jul 2001 MGP Created
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic Physics
// Data set for an electromagnetic physics process
// A strategy pattern is used to encapsulate algorithms for data interpolation
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
#ifndef G4EMDATASET_HH
#define G4EMDATASET_HH 1
#include "globals.hh"
#include "G4DataVector.hh"
#include "G4VEMDataSet.hh"
class G4VDataSetAlgorithm;
class G4EMDataSet : public G4VEMDataSet {
public:
G4EMDataSet(G4int Z,
G4DataVector* points,
G4DataVector* values,
G4VDataSetAlgorithm* interpolation,
G4double unitE = MeV, G4double unitData = barn);
G4EMDataSet(G4int Z,
const G4String& dataFile,
G4VDataSetAlgorithm* interpolation,
G4double unitE = MeV, G4double unitData = barn);
~G4EMDataSet();
G4double FindValue(G4double e, G4int id = 0) const;
void PrintData() const;
const G4DataVector& GetEnergies(G4int i) const { return *energies; }
const G4DataVector& GetData(G4int i) const { return *data; }
private:
void LoadData(const G4String& dataFile);
G4int FindBinLocation(G4double energy) const;
G4int z;
G4DataVector* energies; // Owned pointer
G4DataVector* data; // Owned pointer
G4VDataSetAlgorithm* algorithm; // Owned pointer
G4double unit1;
G4double unit2;
size_t numberOfBins;
};
#endif
@@ -0,0 +1,101 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4FluoData.hh,v 1.1 ?????
// GEANT4 tag $Name: geant4-04-00 $
//
// Author: Elena Guardincerri (Elena.Guardincerri@ge.infn.it)
//
// History:
// -----------
// 16 Sept 2001 First committed to cvs
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic Physics
// Fluorescence data set: shell identifiers, transition probabilities,
// transition energies
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
#ifndef G4FLUODATA_HH
#define G4FLUODATA_HH 1
#include "globals.hh"
#include "g4std/vector"
#include "g4std/map"
class G4DataVector;
class G4FluoData
{
public:
G4FluoData();
~G4FluoData();
// The method returns the number of shells in wich a
// vacancy can be filled by a radiative transition
size_t NumberOfVacancies() const;
// Given the index of the vacancy returns its identity
G4int VacancyId(G4int vacancyIndex) const;
// Given the index of a vacancy returns the number of
//shells starting from wich an electrons can fill the vacancy
size_t NumberOfTransitions(G4int vacancyIndex) const;
// Given the indexes of the starting and final shells for the
// transition, returns the identity of the starting one
G4int StartShellId(G4int initIndex,G4int vacancyIndex);
// Given the indexes of the starting and final shells for the
// transition, returns the transition energy
G4double StartShellEnergy(G4int initIndex,G4int vacancyIndex);
// Given the indexes of the starting and final shells for the
// transition, returns the probability of this transition
G4double StartShellProb(G4int initIndex,G4int vacancyIndex);
void LoadData( G4int Z);
void PrintData();
private:
G4std::map<G4int,G4DataVector*,G4std::less<G4int> > idMap;
G4std::map<G4int,G4DataVector*,G4std::less<G4int> > energyMap;
G4std::map<G4int,G4DataVector*,G4std::less<G4int> > probabilityMap;
G4std::vector<G4int> nInitShells;
G4int numberOfVacancies;
};
#endif
@@ -0,0 +1,80 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4LinInterpolation.hh,v 1.1 2001/11/29 19:01:44 vnivanch Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// Author: Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
//
// History:
// -----------
// 31 Jul 2001 MGP Created
//
// -------------------------------------------------------------------
// Class description:
// Log-Log interpolation of a data set
// Part of a strategy pattern to encapsulate algorithms for interpolation of data sets
// Further documentation available from http://www.ge.infn.it/geant4/lowE/index.html
// -------------------------------------------------------------------
#ifndef G4LININTERPOLATION_HH
#define G4LININTERPOLATION_HH 1
#include "globals.hh"
#include "G4VDataSetAlgorithm.hh"
#include "G4DataVector.hh"
class G4LinInterpolation : public G4VDataSetAlgorithm {
public:
G4LinInterpolation();
~G4LinInterpolation();
G4double Calculate(G4double point, G4int bin,
const G4DataVector& energies,
const G4DataVector& data) const;
virtual G4VDataSetAlgorithm* Clone() const { return new G4LinInterpolation; }
private:
// Hide copy constructor and assignment operator
};
#endif
@@ -0,0 +1,80 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4LogLogInterpolation.hh,v 1.2 2001/10/08 07:45:33 pia Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// Author: Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
//
// History:
// -----------
// 31 Jul 2001 MGP Created
//
// -------------------------------------------------------------------
// Class description:
// Log-Log interpolation of a data set
// Part of a strategy pattern to encapsulate algorithms for interpolation of data sets
// Further documentation available from http://www.ge.infn.it/geant4/lowE/index.html
// -------------------------------------------------------------------
#ifndef G4LOGLOGINTERPOLATION_HH
#define G4LOGLOGINTERPOLATION_HH 1
#include "globals.hh"
#include "G4VDataSetAlgorithm.hh"
#include "G4DataVector.hh"
class G4LogLogInterpolation : public G4VDataSetAlgorithm {
public:
G4LogLogInterpolation();
~G4LogLogInterpolation();
G4double Calculate(G4double point, G4int bin,
const G4DataVector& energies,
const G4DataVector& data) const;
virtual G4VDataSetAlgorithm* Clone() const { return new G4LogLogInterpolation; }
private:
// Hide copy constructor and assignment operator
};
#endif
@@ -20,36 +20,48 @@
// * statement, and all its terms. *
// ********************************************************************
//
//
// $Id: G4LowEnergyBremsstrahlung.hh,v 1.16.2.2 2001/06/28 20:19:23 gunter Exp $
// GEANT4 tag $Name: $
//
//
// ------------------------------------------------------------
// GEANT 4 class header file
// CERN Geneva Switzerland
// -------------------------------------------------------------------
// $Id: G4LowEnergyBremsstrahlung.hh,v 1.28 2001/11/29 22:47:27 vnivanch Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// ------------ G4LowEnergyBremsstrahlung physics process ------
// by A.Forti 1999/03/27 19:18:13
//
// 18.04.2000 V.Lefebure
// - First implementation of continuous energy loss.
// Author: A. Forti
//
// History:
// -----------
// 02 Mar 1999 A. Forti 1st implementation
// 27 Sep 2001 V. Ivanchenko Major revision according to a design iteration
// 10 Oct 2001 M.G. Pia Revision to improve code quality
// and consistency with design
// 29 Nov 2001 V.Ivanchenko New parametrisation of EEDL data
//
// -------------------------------------------------------------------
// Class description:
// Low Energy electromagnetic process, Bremsstrahlung
// Low Energy electromagnetic process, electron Bremsstrahlung
// based on the data of the EEDL database. Details are described
// in the Physics Reference Manual.
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// ************************************************************
// --------------------------------------------------------------
#ifndef G4LowEnergyBremsstrahlung_h
#define G4LowEnergyBremsstrahlung_h 1
#ifndef G4LOWENERGYBREMSSTRAHLUNG_HH
#define G4LOWENERGYBREMSSTRAHLUNG_HH 1
#include "G4eLowEnergyLoss.hh"
#include "G4LowEnergyUtilities.hh"
#include "G4DataVector.hh"
class G4LowEnergyBremsstrahlung : public G4eLowEnergyLoss{
class G4Track;
class G4Step;
class G4ParticleDefinition;
class G4VParticleChange;
class G4VEMDataSet;
class G4VEnergySpectrum;
class G4VCrossSectionHandler;
class G4LowEnergyBremsstrahlung : public G4eLowEnergyLoss
{
public:
G4LowEnergyBremsstrahlung(const G4String& processName = "LowEnBrem");
@@ -57,80 +69,40 @@ public:
~G4LowEnergyBremsstrahlung();
G4bool IsApplicable(const G4ParticleDefinition&);
void SetCutForLowEnSecPhotons(G4double);
void BuildPhysicsTable(const G4ParticleDefinition& particleType);
G4VParticleChange* PostStepDoIt(const G4Track& track,
const G4Step& step);
void SetCutForLowEnSecPhotons(G4double cut);
void PrintInfoDefinition();
void BuildPhysicsTable(const G4ParticleDefinition& ParticleType);
void BuildLossTable(const G4ParticleDefinition& ParticleType);
protected:
G4double GetMeanFreePath(const G4Track& track,
G4double previousStepSize,
G4ForceCondition* condition );
G4VParticleChange* PostStepDoIt(const G4Track& track,
const G4Step& step);
G4double GetEnergyLossWithCut(const G4double AtomicNumber,
const G4double KineticEnergy,
const G4double Tcut) ;
private:
void BuildCrossSectionTable();
void BuildMeanFreePathTable();
void BuildATable();
void BuildBTable();
void BuildZVec();
void BuildLambdaTable(const G4ParticleDefinition& aParticleType);
void ComputepartialSumSigma(const G4double KineticEnergy,
const G4Material* aMaterial,
const G4double threshold);
// Hide copy constructor and assignment operator as private
G4LowEnergyBremsstrahlung(const G4LowEnergyBremsstrahlung& );
G4LowEnergyBremsstrahlung& operator = (const G4LowEnergyBremsstrahlung& right);
private:
void BuildLossTable(const G4ParticleDefinition& ParticleType);
G4double ComputeA(const G4int Z,const G4double ElectKinEnergy); // interpolation
G4double ComputeB(const G4int Z,const G4double ElectKinEnergy); // parametrized formula
G4double GetCrossSection(const G4double AtomicNumber,
const G4double KineticEnergy) ;
G4double GetCrossSectionWithCut(const G4double AtomIndex,
const G4double IncEnergy,
const G4double CutEnergy);
G4Element* SelectRandomAtom(G4Material* aMaterial) const;
G4LowEnergyBremsstrahlung & operator=(const G4LowEnergyBremsstrahlung &right);
G4LowEnergyBremsstrahlung(const G4LowEnergyBremsstrahlung&);
private:
G4SecondLevel* theCrossSectionTable ;
G4PhysicsTable* theMeanFreePathTable ;
G4SecondLevel* ATable;
G4FirstLevel* BTable;
G4DataVector* ZNumVec;
G4LowEnergyUtilities util;
// partial sum of total crosssection
G4OrderedTable partialSumSigma;
G4double lowestKineticEnergy;
G4double highestKineticEnergy;
G4double lowEnergyCut; // lower limit of the energy sampling formula
G4int totBin; // number of bins in the tables
G4double cutForLowEnergySecondaryPhotons;
G4VCrossSectionHandler* crossSectionHandler;
G4VEMDataSet* theMeanFreePath;
G4VEnergySpectrum* energySpectrum;
// Lower limit for generation of gamma in this model
G4DataVector cutForSecondaryPhotons;
G4double cutForPhotons;
};
#include "G4LowEnergyBremsstrahlung.icc"
#endif
@@ -1,143 +0,0 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4LowEnergyBremsstrahlung.icc,v 1.18.2.2 2001/06/28 20:19:23 gunter Exp $
// GEANT4 tag $Name: $
//
//
// ---------------------------------------------------------------
// GEANT 4 class inlined methods file
//
// ------------ G4LowEnergyBremsstrahlung physics process ---------
// by A.Forti 1999/03/27
//
// 18.04.2000 V.Lefebure
// - First implementation of continuous energy loss.
// - Return an infinite MeanfreePath when cross-section = 0.
// ***************************************************************
#include "G4Gamma.hh"
//
inline G4bool G4LowEnergyBremsstrahlung::IsApplicable(
const G4ParticleDefinition& particle)
{
return( (&particle == G4Electron::Electron())
/////////////||(&particle == G4Positron::Positron())
);
}
inline G4double G4LowEnergyBremsstrahlung::GetMeanFreePath(const G4Track& track,
G4double,
G4ForceCondition*)
// gives the MeanFreePath in GEANT4 internal units
{
const G4DynamicParticle* aDynamicParticle = track.GetDynamicParticle();
G4double KineticEnergy = aDynamicParticle->GetKineticEnergy();
G4Material* aMaterial = track.GetMaterial();
const G4ElementVector* theElementVector = aMaterial->GetElementVector();
const G4double* theAtomicNumDensityVector = aMaterial->GetAtomicNumDensityVector();
const G4int NumberOfElements = aMaterial->GetNumberOfElements() ;
G4double* CutInKineticEnergy = G4Gamma::Gamma()->GetCutsInEnergy() ;
G4double Threshold = CutInKineticEnergy[aMaterial->GetIndex()] ;
G4double MeanFreePath;
// G4bool isOutRange ;
if (KineticEnergy < lowestKineticEnergy)
////MeanFreePath = DBL_MIN;
MeanFreePath = DBL_MAX;
else {
if (KineticEnergy > highestKineticEnergy) KineticEnergy = 0.99*highestKineticEnergy ;
///MeanFreePath = util.DataLogInterpolation(KineticEnergy, aMaterial->GetIndex(), theMeanFreePathTable);
/// MeanFreePath = (*theMeanFreePathTable)(aMaterial->GetIndex())->
//// GetValue( KineticEnergy, isOutRange );
G4double SIGMA = 0.;
G4int iel;
for (iel=0; iel<NumberOfElements; iel++ ){
SIGMA += theAtomicNumDensityVector[iel]*
GetCrossSectionWithCut( (*theElementVector)(iel)->GetZ(),
KineticEnergy,
Threshold);
}
MeanFreePath = SIGMA > DBL_MIN ? 1./SIGMA : DBL_MAX;
}
return MeanFreePath;
}
inline G4double G4LowEnergyBremsstrahlung::ComputeA(const G4int AtomicNumber,const G4double ElectronKinEnergy){
G4double aVal;
G4FirstLevel* oneAtomCoeff = (*ATable)[AtomicNumber-1];
G4DataVector* ElectEnVec = (*oneAtomCoeff)[0];
G4DataVector* AValueVec = (*oneAtomCoeff)[1];
aVal = util.DataLogInterpolation(ElectronKinEnergy, (*ElectEnVec), (*AValueVec));
if(AtomicNumber > 99){
aVal = 0;
}
return aVal;
}
inline G4double G4LowEnergyBremsstrahlung::ComputeB(const G4int AtomicNumber,const G4double ElectronKinEnergy){
G4double bVal;
G4double constTerm = (*(*BTable)[0])[AtomicNumber-1];
G4double linearTerm = (*(*BTable)[1])[AtomicNumber-1];
G4double logElectEn = log10(ElectronKinEnergy);
if(logElectEn > -5 && logElectEn < (-constTerm/linearTerm)){
bVal = linearTerm*logElectEn+constTerm;
}
else{
bVal = 0;
}
if(AtomicNumber > 99){
bVal = 0;
}
return bVal;
}
@@ -19,85 +19,86 @@
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
// $Id: G4LowEnergyCompton.hh,v 1.19 2001/12/13 12:04:13 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// Author: A. Forti
// Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
//
// $Id: G4LowEnergyCompton.hh,v 1.11.2.2 2001/06/28 20:19:23 gunter Exp $
// GEANT4 tag $Name: $
//
//
// ------------------------------------------------------------
// GEANT 4 class header file --- Copyright CERN 1995
// CERN Geneva Switzerland
//
// ------------ G4LowEnergyCompton physics process ------
// by A.Forti 1999/03/02
// History:
// -----------
// 02 Mar 1999 A. Forti 1st implementation
// 1 Aug 2001 MGP Major revision according to a design iteration
//
// -------------------------------------------------------------------
// Class description:
// Low Energy electromagnetic process, Compton
// Low Energy Electromagnetic Physics, Compton Scattering
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// ************************************************************
// -------------------------------------------------------------------
#ifndef G4LowEnergyCompton_h
#define G4LowEnergyCompton_h
#ifndef G4LOWENERGYCOMPTON_HH
#define G4LOWENERGYCOMPTON_HH 1
// Base Class Headers
#include "globals.hh"
#include "G4VDiscreteProcess.hh"
// Contained Variables Headers
#include "G4LowEnergyUtilities.hh"
#include "G4Gamma.hh"
class G4Track;
class G4Step;
class G4ParticleDefinition;
class G4VParticleChange;
class G4VEMDataSet;
class G4VCrossSectionHandler;
class G4VRangeTest;
class G4LowEnergyCompton : public G4VDiscreteProcess{
class G4LowEnergyCompton : public G4VDiscreteProcess {
private:
// hide assignment operator as private
G4LowEnergyCompton& operator=(const G4LowEnergyCompton &right);
G4LowEnergyCompton(const G4LowEnergyCompton& );
public:
G4LowEnergyCompton(const G4String& processName ="LowEnCompton");
~G4LowEnergyCompton();
G4bool IsApplicable(const G4ParticleDefinition&);
G4bool IsApplicable(const G4ParticleDefinition& definition);
void BuildPhysicsTable(const G4ParticleDefinition& GammaType);
void BuildPhysicsTable(const G4ParticleDefinition& photon);
G4VParticleChange* PostStepDoIt(const G4Track& aTrack, const G4Step& aStep);
// For testing purpose only
G4double DumpMeanFreePath(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition)
{ return GetMeanFreePath(aTrack, previousStepSize, condition); }
protected:
G4double GetMeanFreePath(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition);
G4VParticleChange* PostStepDoIt(const G4Track& aTrack, const G4Step& aStep);
protected:
private:
void BuildScatteringFunctionTable();
void BuildCrossSectionTable();
void BuildMeanFreePathTable();
void BuildZVec();
// Hide copy constructor and assignment operator as private
G4LowEnergyCompton& operator=(const G4LowEnergyCompton& right);
G4LowEnergyCompton(const G4LowEnergyCompton& );
private:
G4double lowEnergyLimit; // low energy limit applied to the process
G4double highEnergyLimit; // high energy limit applied to the process
G4Element* SelectRandomAtom(const G4DynamicParticle*, G4Material*);
G4SecondLevel* theCrossSectionTable;
G4SecondLevel* theScatteringFunctionTable;
G4PhysicsTable* theMeanFreePathTable;
G4DataVector* ZNumVec;
G4VEMDataSet* meanFreePathTable;
G4VEMDataSet* scatterFunctionData;
G4double lowestEnergyLimit; // low energy limit of the crosssection data
G4double highestEnergyLimit; // high energy limit of the crosssection data
G4int numbBinTable; // number of bins in the data tables
G4VCrossSectionHandler* crossSectionHandler;
G4LowEnergyUtilities util;
G4VRangeTest* rangeTest;
const G4double intrinsicLowEnergyLimit; // intrinsic validity range
const G4double intrinsicHighEnergyLimit;
G4double meanFreePath; // actual Mean Free Path (current medium)
};
#include "G4LowEnergyCompton.icc"
#endif
@@ -21,86 +21,92 @@
// ********************************************************************
//
//
// $Id: G4LowEnergyGammaConversion.hh,v 1.9.2.2 2001/06/28 20:19:23 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4LowEnergyGammaConversion.hh,v 1.14 2001/10/08 07:45:33 pia Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
//
// ------------------------------------------------------------
// GEANT 4 class header file
// CERN Geneva Switzerland
// Author: A. Forti
// Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
//
// ------------ G4LowEnergyGammaConversion physics process ------
// by A.Forti 1999/03/02
// History:
// -----------
// 02 Mar 1999 A. Forti 1st implementation
// 14 Aug 2001 MGP Major revision according to a design iteration
//
// -------------------------------------------------------------------
// Class description:
// Low Energy process, Photon conversion
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// ************************************************************
// -------------------------------------------------------------------
#ifndef G4LOWENERGYGAMMACONVERSION_HH
#define G4LOWENERGYGAMMACONVERSION_HH 1
#ifndef G4LowEnergyGammaConversion_h
#define G4LowEnergyGammaConversion_h 1
// Base Class Headers
#include "G4VDiscreteProcess.hh"
// Contained Variables Headers
#include "G4LowEnergyUtilities.hh"
#include "G4Gamma.hh"
#include "globals.hh"
#include "G4VDiscreteProcess.hh"
class G4Track;
class G4Step;
class G4ParticleDefinition;
class G4VParticleChange;
class G4VEMDataSet;
class G4VCrossSectionHandler;
class G4VRangeTest;
class G4LowEnergyGammaConversion : public G4VDiscreteProcess {
class G4LowEnergyGammaConversion : public G4VDiscreteProcess
{
private:
// hide assignment operator as private
G4LowEnergyGammaConversion& operator=(const G4LowEnergyGammaConversion &right);
G4LowEnergyGammaConversion(const G4LowEnergyGammaConversion& );
public:
G4LowEnergyGammaConversion(const G4String& processName ="LowEnConversion");
~G4LowEnergyGammaConversion();
G4bool IsApplicable(const G4ParticleDefinition&);
G4bool IsApplicable(const G4ParticleDefinition& photon);
void BuildPhysicsTable(const G4ParticleDefinition& GammaType);
void BuildPhysicsTable(const G4ParticleDefinition& photon);
G4VParticleChange* PostStepDoIt(const G4Track& aTrack, const G4Step& aStep);
// For testing purpose only
G4double DumpMeanFreePath(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition)
{ return GetMeanFreePath(aTrack, previousStepSize, condition); }
protected:
G4double GetMeanFreePath(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition);
G4VParticleChange* PostStepDoIt(const G4Track& aTrack, const G4Step& aStep);
protected:
void BuildCrossSectionTable();
void BuildMeanFreePathTable();
void BuildZVec();
private:
G4Element* SelectRandomAtom(const G4DynamicParticle*, G4Material*);
static G4double ScreenFunction1(G4double ScreenVariable);
static G4double ScreenFunction2(G4double ScreenVariable);
private:
G4SecondLevel* theCrossSectionTable;
G4PhysicsTable* theMeanFreePathTable;
// Hide copy constructor and assignment operator as private
G4LowEnergyGammaConversion& operator=(const G4LowEnergyGammaConversion &right);
G4LowEnergyGammaConversion(const G4LowEnergyGammaConversion& );
G4DataVector* ZNumVec;
G4double ScreenFunction1(G4double screenVariable);
G4double ScreenFunction2(G4double screenVariable);
G4double lowEnergyLimit; // low energy limit applied to the process
G4double highEnergyLimit; // high energy limit applied to the process
G4double lowestEnergyLimit;
G4double highestEnergyLimit;
G4int NumbBinTable;
G4VEMDataSet* meanFreePathTable;
G4VCrossSectionHandler* crossSectionHandler;
G4VRangeTest* rangeTest;
const G4double intrinsicLowEnergyLimit; // intrinsic validity range
const G4double intrinsicHighEnergyLimit;
const G4double smallEnergy;
G4double MeanFreePath; // actual Mean Free Path (current medium)
G4LowEnergyUtilities util;
};
#include "G4LowEnergyGammaConversion.icc"
#endif
@@ -1,95 +0,0 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4LowEnergyGammaConversion.icc,v 1.11.2.2 2001/06/28 20:19:23 gunter Exp $
// GEANT4 tag $Name: $
//
//
// ---------------------------------------------------------------
// GEANT 4 class inlined methods file
//
// ------------ G4LowEnergyGammaConversion physics process ---------
// by A.Forti 1999/03/02
// ***************************************************************
inline G4bool G4LowEnergyGammaConversion::IsApplicable(const G4ParticleDefinition& particle)
{
return ( &particle == G4Gamma::Gamma() );
}
inline G4double
G4LowEnergyGammaConversion::GetMeanFreePath(const G4Track& aTrack, G4double, G4ForceCondition*){
// returns the gamma mean free path in GEANT4 internal units
const G4DynamicParticle* aDynamicGamma = aTrack.GetDynamicParticle();
G4double GammaEnergy = aDynamicGamma->GetKineticEnergy();
G4Material* aMaterial = aTrack.GetMaterial();
// G4bool isOutRange ;
if (GammaEnergy < lowestEnergyLimit){
MeanFreePath = DBL_MAX;
}
else {
if(GammaEnergy > highestEnergyLimit) GammaEnergy = 0.99*highestEnergyLimit;
MeanFreePath = util.DataLogInterpolation(GammaEnergy, aMaterial->GetIndex(), theMeanFreePathTable);
}
return MeanFreePath;
}
inline G4double
G4LowEnergyGammaConversion::ScreenFunction1(G4double ScreenVariable)
// compute the value of the screening function 3*PHI1 - PHI2
{
G4double screenVal;
if (ScreenVariable > 1.)
screenVal = 42.24 - 8.368*log(ScreenVariable+0.952);
else
screenVal = 42.392 - ScreenVariable* (7.796 - 1.961*ScreenVariable);
return screenVal;
}
inline G4double
G4LowEnergyGammaConversion::ScreenFunction2(G4double ScreenVariable)
// compute the value of the screening function 1.5*PHI1 - 0.5*PHI2
{
G4double screenVal;
if (ScreenVariable > 1.)
screenVal = 42.24 - 8.368*log(ScreenVariable+0.952);
else
screenVal = 41.405 - ScreenVariable* (5.828 - 0.8945*ScreenVariable);
return screenVal;
}
@@ -20,154 +20,101 @@
// * statement, and all its terms. *
// ********************************************************************
//
// -------------------------------------------------------------------
// $Id: G4LowEnergyIonisation.hh,v 1.34 2001/11/29 22:47:27 vnivanch Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// $Id: G4LowEnergyIonisation.hh,v 1.20.2.2 2001/06/28 20:19:23 gunter Exp $
// GEANT4 tag $Name: $
// Author: A. Forti
//
//
// ------------------------------------------------------------
// GEANT 4 class header file
//
// --- G4LowEnergyIonisation physics process for electrons
// by Alessandra Forti July 1999
// ************************************************************
//
// 07.04.2000 Veronique Lefebure + Laszlo Urban
// - First implemention of continuous energy loss
// 14/07/99: corrections , L.Urban
// 20/09/00 update fluctuations V.Ivanchenko
// History:
// -----------
// 02 Mar 1999 A. Forti 1st implementation
// 27 Sep 2001 V. Ivanchenko Major revision according to a design iteration
// 10 Oct 2001 M.G. Pia Revision to improve code quality and
// consistency with design
// 18 Oct 2001 M.G. Pia Revision to improve code quality and
// consistency with design
// 29 Nov 2001 V.Ivanchenko New parametrisation of EEDL data
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic process, electron Ionisation
// Low Energy electromagnetic process, electron Ionisation
// based on the data of the EEDL database. Details are described
// in the Physics Reference Manual.
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// ------------------------------------------------------------
#ifndef G4LowEnergyIonisation_h
#define G4LowEnergyIonisation_h 1
// --------------------------------------------------------------
#ifndef G4lOWENERGYIONISATION_HH
#define G4LOWENERGYIONISATION_HH 1
// Base Class Headers
#include "G4eLowEnergyLoss.hh"
#include "G4AtomicDeexcitation.hh"
// Contained Variables Headers
#include "G4LowEnergyUtilities.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
typedef G4FirstLevel oneShellTable;
typedef G4SecondLevel oneAtomTable;
typedef G4ThirdLevel allAtomTable;
class G4LowEnergyIonisation : public G4eLowEnergyLoss{
class G4Track;
class G4Step;
class G4ParticleDefinition;
class G4VParticleChange;
class G4VDataSetAlgorithm;
class G4ParticleChange;
class G4VEnergySpectrum;
class G4VCrossSectionHandler;
class G4ShellVacancy;
class G4VEMDataSet;
class G4LowEnergyIonisation : public G4eLowEnergyLoss
{
public:
G4LowEnergyIonisation(const G4String& processName = "LowEnergyIoni");
G4LowEnergyIonisation(const G4String& processName = "LowEnergyIoni");
~G4LowEnergyIonisation();
G4bool IsApplicable(const G4ParticleDefinition&);
void SetCutForLowEnSecPhotons(G4double);
void SetCutForLowEnSecElectrons(G4double);
void BuildPhysicsTable(const G4ParticleDefinition& aParticleType);
G4double GetMeanFreePath(const G4Track& track,
G4double previousStepSize,
G4ForceCondition* condition ) ;
inline G4double GetTransitionShell(G4int k){return(thePrimShVec[k]);};
G4VParticleChange *PostStepDoIt(const G4Track& track,
const G4Step& Step ) ;
G4bool IsApplicable(const G4ParticleDefinition&);
void PrintInfoDefinition();
void BuildPhysicsTable(const G4ParticleDefinition& ParticleType);
G4VParticleChange* PostStepDoIt(const G4Track& track,
const G4Step& step);
void SetCutForLowEnSecPhotons(G4double cut);
G4double GetShellCrossSection(const G4double AtomicNumber,
const G4int subshellindex,
const G4double KineticEnergy) ;
G4double GetShellCrossSectionwithCut(const G4double AtomicNumber,
const G4int subshellindex,
const G4double KineticEnergy,
const G4double Tcut) ;
G4double GetShellEnergyLosswithCut(const G4double AtomicNumber,
const G4int subshellindex,
const G4double KineticEnergy,
const G4double Tcut) ;
void SetLowEnergyLimit(G4double val) {if(val > 0.0) lEnergyLimit = val;};
private:
virtual G4double ComputeCrossSection(const G4double AtomicNumber,
const G4double IncEnergy);
G4double ComputeCrossSectionWithCut(const G4double AtomIndex,
const G4double IncEnergy,
const G4double CutEnergy);
G4double ComputeMicroscopicCrossSection(const G4double AtomIndex,
const G4double IncEnergy,
const G4double CutEnergy);
void BuildLossTable(const G4ParticleDefinition& aParticleType);
void BuildShellCrossSectionTable();
void BuildBindingEnergyTable();
void BuildFluorTransitionTable();
void BuildSamplingCoeffTable();
void BuildZVec();
void BuildLambdaTable(const G4ParticleDefinition& aParticleType);
void SetCutForLowEnSecElectrons(G4double cut);
protected:
G4double GetMeanFreePath(const G4Track& track,
G4double previousStepSize,
G4ForceCondition* condition );
virtual G4std::vector<G4DynamicParticle*>* DeexciteAtom(const G4Material* material,
G4double incidentEnergy,
G4double eLoss);
private:
// Hide copy constructor and assignment operator as private
G4LowEnergyIonisation(const G4LowEnergyIonisation& );
G4LowEnergyIonisation& operator = (const G4LowEnergyIonisation& right);
// hide assignment operator
G4LowEnergyIonisation & operator=(const G4LowEnergyIonisation &right);
G4LowEnergyIonisation(const G4LowEnergyIonisation&);
void BuildLossTable(const G4ParticleDefinition& ParticleType);
private:
G4VCrossSectionHandler* crossSectionHandler;
G4VEMDataSet* theMeanFreePath;
G4VEnergySpectrum* energySpectrum;
// Lower limit for generation of gamma in this model
G4DataVector cutForDelta;
G4double cutForPhotons;
G4double cutForElectrons;
G4AtomicDeexcitation deexcitationManager;
G4ShellVacancy* shellVacancy;
G4int SelectRandomShell(const G4int AtomIndex
, const G4double IncEnergy
, const G4double CutEnergy);
G4Element* SelectRandomAtom(const G4DynamicParticle* aDynamicPhoton,
G4Material* aMaterial);
G4bool SelectRandomTransition(G4int, G4double*,
const oneAtomTable*);
G4double EnergySampling(const G4int AtomicNumber
, const G4int ShellIndex
, const G4double KinEn
, const G4double deltaRayMinE = 0.1*eV);
allAtomTable* allAtomShellCrossSec;
allAtomTable* theFluorTransitionTable;
allAtomTable* theSamplingCoeffTable;
G4SecondLevel* theBindingEnergyTable;
G4DataVector* ZNumVec;
G4DataVector* ZNumVecFluor;
G4PhysicsTable* theMeanFreePathTable;
G4double CutForLowEnergySecondaryPhotons;
G4double CutForLowEnergySecondaryElectrons;
G4double MeanFreePath;
G4double lowestKineticEnergy;
G4double highestKineticEnergy;
G4int TotBin;
G4LowEnergyUtilities util;
G4DataVector thePrimShVec;
G4double lEnergyLimit;
};
#include "G4LowEnergyIonisation.icc"
#endif
@@ -180,7 +127,3 @@ private:
@@ -1,87 +0,0 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4LowEnergyIonisation.icc,v 1.16.2.2 2001/06/28 20:19:24 gunter Exp $
//
//
// ---------------------------------------------------------------
// GEANT 4 class inlined methods file
//
// ------------ G4LowEnergyIonisation physics process ------------
//
// by Alessandra Forti , July 1999
// ***************************************************************
//
// 07.04.2000 Veronique Lefebure + Laszlo Urban
// - First implemention of continuous energy loss
// 14/07/99 corrections by L. Urban
// 16/05/01 V.Ivanchenko: cross section is taken from the table.
// 17/05/01 V.Ivanchenko: warning print out.
// 22/05/01 V.Ivanchenko: switch on using tables of cross sections.
// ---------------------------------------------------------------
//
inline G4bool G4LowEnergyIonisation::IsApplicable(
const G4ParticleDefinition& particle)
{
if(&particle == G4Positron::Positron()) {
G4cout << "WARNING: G4LowEnergyIonisation is not applicable"
<< " for positron yet!" << G4endl;
}
return( (&particle == G4Electron::Electron())
/////////////////||(&particle == G4Positron::Positron())
);
}
//
inline G4double G4LowEnergyIonisation::GetMeanFreePath(
const G4Track& track,
G4double,
G4ForceCondition*){
const G4DynamicParticle* aParticle = track.GetDynamicParticle();
G4double KineticEnergy = aParticle->GetKineticEnergy();
const G4Material* aMaterial = track.GetMaterial();
G4bool isOutRange = false;
if( KineticEnergy < lowestKineticEnergy ) MeanFreePath = DBL_MAX;
else {
if(KineticEnergy > highestKineticEnergy)
KineticEnergy = highestKineticEnergy;
MeanFreePath = ((*theMeanFreePathTable)(aMaterial->GetIndex()))->
GetValue( KineticEnergy, isOutRange);
}
return MeanFreePath ;
}
@@ -21,124 +21,93 @@
// ********************************************************************
//
//
// $Id: G4LowEnergyPhotoElectric.hh,v 1.18.2.2 2001/06/28 20:19:24 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4LowEnergyPhotoElectric.hh,v 1.23 2001/10/08 07:45:34 pia Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
//
// ------------------------------------------------------------
// GEANT 4 class header file
// CERN Geneva Switzerland
// Author: A. Forti
// Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
//
// ------------ G4LowEnergyPhotoElectric physics process ------
// by A.Forti 1999/03/02
// History:
// -----------
// 02 Mar 1999 A. Forti 1st implementation
// 12 Aug 2001 MGP Major revision according to a design iteration
// 16 Sept 2001 E. Guardincerri Added fluorescence generation
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic process, Photoelectric effect
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// ************************************************************
// -------------------------------------------------------------------
#ifndef G4LowEnergyPhotoElectric_h
#define G4LowEnergyPhotoElectric_h 1
#ifndef G4LOWENERGYPHOTOELECTRIC_HH
#define G4LOWENERGYPHOTOELECTRIC_HH 1
// Base Class Headers
#include "globals.hh"
#include "G4VDiscreteProcess.hh"
#include "G4AtomicDeexcitation.hh"
// Contained Variables Headers
#include "G4LowEnergyUtilities.hh"
#include "G4Gamma.hh"
class G4Track;
class G4Step;
class G4ParticleDefinition;
class G4VParticleChange;
class G4VEMDataSet;
class G4VCrossSectionHandler;
class G4VRangeTest;
// ..
typedef G4FirstLevel oneShellTable;
typedef G4SecondLevel oneAtomTable;
typedef G4ThirdLevel allAtomTable;
// ..
class G4LowEnergyPhotoElectric : public G4VDiscreteProcess
{
class G4LowEnergyPhotoElectric : public G4VDiscreteProcess {
public:
G4LowEnergyPhotoElectric(const G4String& processName ="LowEnPhotoElec");
~G4LowEnergyPhotoElectric();
~G4LowEnergyPhotoElectric();
G4bool IsApplicable(const G4ParticleDefinition&);
void BuildPhysicsTable(const G4ParticleDefinition& photon);
G4VParticleChange* PostStepDoIt(const G4Track& aTrack, const G4Step& aStep);
void SetCutForLowEnSecPhotons(G4double);
// void SetCutForLowEnSecElectrons(G4double);
// For testing purpose only
G4double DumpMeanFreePath(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition)
{ return GetMeanFreePath(aTrack, previousStepSize, condition); }
protected:
void BuildPhysicsTable(const G4ParticleDefinition& PhotonType);
G4double GetMeanFreePath(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition);
G4double GetCrossSection(G4DynamicParticle* aDynamicGamma,
G4Element* anElement);
inline G4double GetTransitionShell(G4int k){return(thePrimShVec[k]);};
G4VParticleChange* PostStepDoIt(const G4Track& aTrack, const G4Step& aStep);
protected:
virtual G4double ComputeCrossSection(const G4double AtomicNumber,
const G4double IncEnergy);
void BuildCrossSectionTable();
void BuildShellCrossSectionTable();
void BuildBindingEnergyTable();
void BuildFluorTransitionTable();
void BuildMeanFreePathTable();
void BuildZVec();
private:
G4int SelectRandomShell(const G4int AtomIndex, const G4double IncEnergy);
G4Element* SelectRandomAtom(const G4DynamicParticle* aDynamicPhoton,
G4Material* aMaterial);
G4bool SelectRandomTransition(G4int, G4double*, const oneAtomTable*);
private:
// hide assignment operator as private
G4LowEnergyPhotoElectric& operator=(const G4LowEnergyPhotoElectric &right);
// Hide copy constructor and assignment operator as private
G4LowEnergyPhotoElectric& operator=(const G4LowEnergyPhotoElectric& right);
G4LowEnergyPhotoElectric(const G4LowEnergyPhotoElectric& );
private:
G4double lowestEnergyLimit;
G4double highestEnergyLimit;
G4double lowEnergyLimit; // low energy limit applied to the process
G4double highEnergyLimit; // high energy limit applied to the process
G4int NumbBinTable;
G4VEMDataSet* meanFreePathTable;
G4double CutForLowEnergySecondaryPhotons;
G4VCrossSectionHandler* crossSectionHandler;
G4VCrossSectionHandler* shellCrossSectionHandler;
G4SecondLevel* theCrossSectionTable;
G4PhysicsTable* theMeanFreePathTable;
G4VRangeTest* rangeTest;
allAtomTable* allAtomShellCrossSec;
allAtomTable* theFluorTransitionTable;
G4SecondLevel* theBindingEnergyTable;
G4DataVector* ZNumVec;
G4DataVector* ZNumVecFluor;
const G4double intrinsicLowEnergyLimit; // intrinsic validity range
const G4double intrinsicHighEnergyLimit;
G4DataVector thePrimShVec;
G4LowEnergyUtilities util;
G4double cutForLowEnergySecondaryPhotons;
G4double MeanFreePath;
G4AtomicDeexcitation deexcitationManager;
};
// ..
#include "G4LowEnergyPhotoElectric.icc"
#endif
@@ -1,104 +0,0 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4LowEnergyPhotoElectric.icc,v 1.18.2.2 2001/06/28 20:19:24 gunter Exp $
// GEANT4 tag $Name: $
//
//
// ---------------------------------------------------------------
// GEANT 4 class inlined methods file
//
// ------------ G4LowEnergyPhotoElectric physics process ---------
// by A.Forti 1999/03/02
//
// 10/05/2001 V.Ivanchenko Clean up againist Linux compilation with -Wall
//
// ***************************************************************
// ..
inline G4bool G4LowEnergyPhotoElectric::IsApplicable(const G4ParticleDefinition& particle)
{
return ( &particle == G4Gamma::Gamma() );
}
// ..
inline G4double
G4LowEnergyPhotoElectric::GetMeanFreePath(const G4Track& aTrack, G4double,
G4ForceCondition*)
{
// returns the gamma mean free path in GEANT4 internal units
const G4DynamicParticle* aDynamicGamma = aTrack.GetDynamicParticle();
G4double GammaEnergy = aDynamicGamma->GetKineticEnergy();
G4Material* aMaterial = aTrack.GetMaterial();
// G4bool isOutRange ;
if (GammaEnergy > highestEnergyLimit){
MeanFreePath = DBL_MAX;
}
else if(GammaEnergy < lowestEnergyLimit){
MeanFreePath = DBL_MIN;
}
else {
MeanFreePath = util.DataLogInterpolation(GammaEnergy,
aMaterial->GetIndex(),
theMeanFreePathTable);
}
return MeanFreePath;
}
// ..
inline G4double G4LowEnergyPhotoElectric::GetCrossSection(G4DynamicParticle* aDynamicGamma,
G4Element* anElement)
// gives the microscopic total cross section in GEANT4 internal units
{
G4double crossSection;
G4double GammaEnergy = aDynamicGamma->GetKineticEnergy();
if (GammaEnergy < lowestEnergyLimit || GammaEnergy > highestEnergyLimit)
crossSection = 0.;
else{
G4int elemZ = (G4int) anElement->GetZ();
const G4FirstLevel* oneAtomCS
= (*theCrossSectionTable)[ZNumVec->index(elemZ)];
crossSection = util.DataLogInterpolation(GammaEnergy,
(*(*oneAtomCS)[0]), (*(*oneAtomCS)[1]))*barn;
}
return crossSection;
}
// ..
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4LowEnergyPolarizedCompton.hh,v 1.4.2.2 2001/06/28 20:19:24 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4LowEnergyPolarizedCompton.hh,v 1.7 2001/10/24 09:07:20 flongo Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// ------------------------------------------------------------
// GEANT 4 class header file
@@ -35,26 +35,27 @@
// 24 May 2001 - MGP Modified to inherit from G4VDiscreteProcess
// 25 May 2001 - MGP Added protections to avoid crashes
//
// 17 October 2001 - F.Longo Major revision according to design iteration
//
// Class description:
// Low Energy electromagnetic process, Polarised Compton scattering
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// ------------------------------------------------------------
#ifndef G4LowEnergyPolarizedCompton_h
#define G4LowEnergyPolarizedCompton_h 1
#ifndef G4LOWENERGYPOLARIZEDCOMPTON_H
#define G4LOWENERGYPOLARIZEDCOMPTON_H 1
#include "globals.hh"
#include "G4VDiscreteProcess.hh"
#include "G4LowEnergyUtilities.hh"
//#include "G4VParticleChange.hh"
class G4SecondLevel;
class G4PhysicsTable;
class G4DataVector;
class G4Track;
class G4Step;
class G4ParticleDefinition;
class G4VParticleChange;
class G4VEMDataSet;
class G4VCrossSectionHandler;
class G4VRangeTest;
class G4LowEnergyPolarizedCompton : public G4VDiscreteProcess
{
@@ -64,53 +65,60 @@ public:
~G4LowEnergyPolarizedCompton();
G4bool IsApplicable(const G4ParticleDefinition&);
G4bool IsApplicable(const G4ParticleDefinition& definition);
void BuildPhysicsTable(const G4ParticleDefinition& photon);
G4VParticleChange* PostStepDoIt(const G4Track& aTrack, const G4Step& aStep);
// For testing purpose only
G4double DumpMeanFreePath(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition)
{ return GetMeanFreePath(aTrack, previousStepSize, condition); }
protected:
void BuildPhysicsTable(const G4ParticleDefinition& GammaType);
G4double GetMeanFreePath(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition);
G4VParticleChange* PostStepDoIt(const G4Track& aTrack, const G4Step& aStep);
protected:
void BuildScatteringFunctionTable();
void BuildCrossSectionTable();
void BuildMeanFreePathTable();
void BuildZVec();
private:
// Hide copy constructor and assignment operator as private
G4LowEnergyPolarizedCompton& operator=(const G4LowEnergyPolarizedCompton&
right);
G4LowEnergyPolarizedCompton(const G4LowEnergyPolarizedCompton& );
G4Element* SelectRandomAtom(const G4DynamicParticle*, G4Material*);
G4double lowEnergyLimit; // low energy limit applied to the process
G4double highEnergyLimit; // high energy limit applied to the process
G4SecondLevel* theCrossSectionTable;
G4SecondLevel* theScatteringFunctionTable;
G4PhysicsTable* theMeanFreePathTable;
G4DataVector* ZNumVec;
G4VEMDataSet* meanFreePathTable;
G4VEMDataSet* scatterFunctionData;
G4double lowestEnergyLimit; // low energy limit of the crosssection data
G4double highestEnergyLimit; // high energy limit of the crosssection data
G4int numbBinTable; // number of bins in the data tables
G4VCrossSectionHandler* crossSectionHandler;
G4VRangeTest* rangeTest;
G4LowEnergyUtilities util;
G4double meanFreePath; // actual Mean Free Path (current medium)
const G4double intrinsicLowEnergyLimit; // intrinsic validity range
const G4double intrinsicHighEnergyLimit;
// specific methods for polarization
G4ThreeVector SetRandomPolarization(G4ThreeVector& direction0); // Random Polarization
G4ThreeVector SetPerpendicularVector(G4ThreeVector& a); // temporary
G4ThreeVector SetNewPolarization(G4double epsilon, G4double sinSqrTheta,
G4double phi, G4double cosTheta);
G4double SetPhi(G4double, G4double);
void SystemOfRefChange(G4ThreeVector& direction0, G4ThreeVector& direction1,
G4ThreeVector& polarization0, G4ThreeVector& polarization1);
// hide assignment operator as private
G4LowEnergyPolarizedCompton& operator=(const G4LowEnergyPolarizedCompton &right);
G4LowEnergyPolarizedCompton(const G4LowEnergyPolarizedCompton& );
};
#endif
@@ -21,41 +21,41 @@
// ********************************************************************
//
//
// $Id: G4LowEnergyRayleigh.hh,v 1.10.2.2 2001/06/28 20:19:24 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4LowEnergyRayleigh.hh,v 1.15 2001/10/08 07:45:35 pia Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
//
// ------------------------------------------------------------
// GEANT 4 class header file --- Copyright CERN 1995
// CERN Geneva Switzerland
//
// ------------ G4LowEnergyRayleigh physics process ------
// by A.Forti 1999/03/02
// Author: A. Forti
// Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
//
// History:
// -----------
// 02 Mar 1999 A. Forti 1st implementation
// 11 Aug 2001 MGP Major revision according to a design iteration
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic process, Rayleigh effect
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// ************************************************************
// -------------------------------------------------------------------
#ifndef G4LowEnergyRayleigh_h
#define G4LowEnergyRayleigh_h
#ifndef G4LOWENERGYRAYLEIGH_HH
#define G4LOWENERGYRAYLEIGH_HH 1
// Base Class Headers
#include "globals.hh"
#include "G4VDiscreteProcess.hh"
// Contained Variables Headers
#include "G4LowEnergyUtilities.hh"
#include "G4Gamma.hh"
class G4Track;
class G4Step;
class G4ParticleDefinition;
class G4VParticleChange;
class G4VEMDataSet;
class G4VCrossSectionHandler;
class G4LowEnergyRayleigh : public G4VDiscreteProcess {
private:
// hide assignment operator as private
G4LowEnergyRayleigh& operator=(const G4LowEnergyRayleigh &right);
G4LowEnergyRayleigh(const G4LowEnergyRayleigh& );
public:
G4LowEnergyRayleigh(const G4String& processName ="LowEnRayleigh");
@@ -64,42 +64,43 @@ public:
G4bool IsApplicable(const G4ParticleDefinition&);
void BuildPhysicsTable(const G4ParticleDefinition& GammaType);
void BuildPhysicsTable(const G4ParticleDefinition& photon);
G4VParticleChange* PostStepDoIt(const G4Track& aTrack, const G4Step& aStep);
// For testing purpose only
G4double DumpMeanFreePath(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition)
{ return GetMeanFreePath(aTrack, previousStepSize, condition); }
protected:
G4double GetMeanFreePath(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition);
G4VParticleChange* PostStepDoIt(const G4Track&, const G4Step& aStep);
protected:
void BuildFormFactorTable();
void BuildCrossSectionTable();
void BuildMeanFreePathTable();
void BuildZVec();
private:
// Hide copy constructor and assignment operator as private
G4LowEnergyRayleigh& operator=(const G4LowEnergyRayleigh &right);
G4LowEnergyRayleigh(const G4LowEnergyRayleigh& );
G4Element* SelectRandomAtom(const G4DynamicParticle*, G4Material*);
G4double lowEnergyLimit; // low energy limit applied to the process
G4double highEnergyLimit; // high energy limit applied to the process
G4SecondLevel* theCrossSectionTable;
G4SecondLevel* theFormFactorTable;
G4PhysicsTable* theMeanFreePathTable;
G4DataVector* ZNumVec;
G4VEMDataSet* meanFreePathTable;
G4VEMDataSet* formFactorData;
G4double lowestEnergyLimit; // low energy limit of the crosssection formula
G4double highestEnergyLimit; // high energy limit of the crosssection formula
G4int NumbBinTable; // number of bins in the crossection table
G4VCrossSectionHandler* crossSectionHandler;
const G4double intrinsicLowEnergyLimit; // intrinsic validity range
const G4double intrinsicHighEnergyLimit;
G4LowEnergyUtilities util;
G4double MeanFreePath; // actual Mean Free Path (current medium)
};
#include "G4LowEnergyRayleigh.icc"
#endif
@@ -113,6 +114,3 @@ private:
@@ -1,209 +0,0 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4LowEnergyUtilities.hh,v 1.8.2.2 2001/06/28 20:19:24 gunter Exp $
// GEANT4 tag $Name: $
//
//
// ------------------------------------------------------------
// GEANT 4 class header file
// CERN Geneva Switzerland
//
// ------------ G4LowEnergyPhotoElectric physics process ------
// by A.Forti 1999/06/28
//
// Class description:
// Class for the handling of the data libraries
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// ************************************************************
#ifndef G4LowEnergyUtilities_h
#define G4LowEnergyUtilities_h 1
//#include "G4FirstLevel.hh"
//#include "G4SecondLevel.hh"
#include "G4ThirdLevel.hh"
#include "G4PhysicsVector.hh"
#include "G4PhysicsTable.hh"
typedef G4FirstLevel oneShellTable;
typedef G4SecondLevel oneAtomTable;
typedef G4ThirdLevel allAtomTable;
class G4LowEnergyUtilities
{
public:
G4LowEnergyUtilities();
~G4LowEnergyUtilities();
G4FirstLevel* BuildFirstLevelTables(const G4int, const G4int, const char*);
G4SecondLevel* BuildSecondLevelTables(const G4int, const G4int, const char*);
//inline functions
G4int FindBinLocation(const G4double BinValue, const G4DataVector& arg);
G4int FindBinLocation(const G4double, const G4PhysicsVector*);
G4double DataLogInterpolation(const G4double,
const G4DataVector&,
const G4DataVector&);
G4double DataLogInterpolation(const G4double Argument,
const G4double AtomicNumber,
const G4PhysicsTable* Table);
G4double DataSemiLogInterpolation(const G4double,
const G4DataVector&,
const G4DataVector&);
};
inline G4int G4LowEnergyUtilities::FindBinLocation(const G4double arg, const G4DataVector& vec){
G4int numberOfBin = vec.size();
G4int lowerBound = 0;
G4int upperBound = numberOfBin-1;
do {
G4int midBin = (lowerBound + upperBound)/2;
if( arg < vec[midBin] )
upperBound = midBin-1;
else
lowerBound = midBin+1;
} while (lowerBound <= upperBound);
return upperBound;
}
inline G4double G4LowEnergyUtilities::DataLogInterpolation(const G4double Argument,
const G4DataVector& argVec,
const G4DataVector& valVec){
G4int theLoc = FindBinLocation(Argument, argVec);
G4int size = argVec.size()-1;
if(theLoc == size){
return valVec[theLoc];
}
G4double val1 = valVec[theLoc], val2 = valVec[theLoc+1];
G4double arg1 = argVec[theLoc], arg2 = argVec[theLoc+1];
if(arg1 == 0.0) arg1 = 1e-17; if(val1 == 0.0) val1 = 1e-17;
G4double theVal = (log10(val1)*log10(arg2/Argument)
+log10(val2)*log10(Argument/arg1))/log10(arg2/arg1);
theVal = pow(10,theVal);
return theVal;
}
inline G4int G4LowEnergyUtilities::FindBinLocation(const G4double arg,
const G4PhysicsVector* vec){
if(!vec){
G4Exception("G4LowEnergy: FindBinLocation: Vector Empty "
"probably the program hasn't found data files or data files are empty");
}
G4int numberOfBin = vec->GetVectorLength();
G4int lowerBound = 0;
G4int upperBound = numberOfBin-1;
do {
G4int midBin = (lowerBound + upperBound)/2;
if( arg < vec->GetLowEdgeEnergy(midBin) )
upperBound = midBin-1;
else
lowerBound = midBin+1;
} while (lowerBound <= upperBound);
return upperBound;
}
inline G4double G4LowEnergyUtilities::DataLogInterpolation(const G4double Argument,
const G4double TableIndex,
const G4PhysicsTable* Table){
G4PhysicsVector* theVec = 0;
theVec = (*Table)(TableIndex);
G4int theLoc = FindBinLocation(Argument, theVec);
G4double val1 = (*theVec)(theLoc), val2 = (*theVec)(theLoc+1);
G4double arg1 = theVec->GetLowEdgeEnergy(theLoc), arg2 = theVec->GetLowEdgeEnergy(theLoc+1);
G4double theVal = (log10(val1)*log10(arg2/Argument)
+log10(val2)*log10(Argument/arg1))/log10(arg2/arg1);
theVal = pow(10,theVal);
return theVal;
}
inline G4double G4LowEnergyUtilities::DataSemiLogInterpolation(const G4double Argument,
const G4DataVector& argVec,
const G4DataVector& valVec){
G4int theLoc = FindBinLocation(Argument, argVec);
G4int size = argVec.size()-1;
if (theLoc == size){
return valVec[theLoc];
}
G4double val1 = valVec[theLoc], val2 = valVec[theLoc+1];
G4double arg1 = argVec[theLoc], arg2 = argVec[theLoc+1];
G4double theVal = (val1*log10(arg2/Argument)
+val2*log10(Argument/arg1))/log10(arg2/arg1);
return theVal;
}
#endif
@@ -21,49 +21,55 @@
// ********************************************************************
//
//
// $Id: G4RangeNoTest.hh,v 1.1 2001/10/08 07:51:41 pia Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// Author: Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
//
// History:
// -----------
// 5 Oct 2001 MGP Created
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// CERN, Geneva, Switzerland
//
// File name: G4SecondLevel.hh
//
// Author: Alessandra Forti (Alessandra.Forti@cern.ch)
//
// Creation date: 1 Giugno 1999
//
// Modifications: 24.04.01 V.Ivanchenko remove RogueWave
//
// -------------------------------------------------------------------
// Class description:
// Utility for Low Energy electromagnetic e/photon processes
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// Class for a strategy pattern encapsulating algorithms to test the range
// of a particle: no test is performed
// Further documentation available from http://www.ge.infn.it/geant4/lowE/index.html
// -------------------------------------------------------------------
#ifndef G4SECONDLEVEL_HH
#define G4SECONDLEVEL_HH
#ifndef G4RANGENOTEST_HH
#define G4RANGENOTEST_HH 1
#include "G4FirstLevel.hh"
//#include "g4rw/tpordvec.h"
#include "globals.hh"
#include "G4VRangeTest.hh"
//class G4SecondLevel : public G4RWTPtrOrderedVector< G4FirstLevel >{
class G4SecondLevel : public G4std::vector< G4FirstLevel* >
{
class G4ParticleDefinition;
class G4Material;
class G4RangeNoTest : public G4VRangeTest {
public:
~G4SecondLevel();
G4RangeNoTest() { }
G4bool operator == (const G4SecondLevel& ) const;
virtual ~G4RangeNoTest() { }
virtual G4bool Escape(const G4ParticleDefinition* particle,
const G4Material* material,
G4double energy,
G4double safety) const { return true; }
G4bool operator < (const G4SecondLevel&) const;
private:
};
#endif
@@ -21,48 +21,55 @@
// ********************************************************************
//
//
// $Id: G4RangeTest.hh,v 1.1 2001/10/08 07:51:42 pia Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// Author: Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
//
// History:
// -----------
// 5 Oct 2001 MGP Created
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// CERN, Geneva, Switzerland
//
// File name: G4ThirdLevel.hh
//
// Author: Alessandra Forti (Alessandra.Forti@cern.ch)
//
// Creation date: 1 Giugno 1999
//
// Modifications: 24.04.01 V.Ivanchenko remove RogueWave
//
// -------------------------------------------------------------------
// Class description:
// Utility for Low Energy electromagnetic e/photon processes
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// Class for a strategy pattern encapsulating algorithms to test the range
// of a perticle: test range against cut and safety
// Further documentation available from http://www.ge.infn.it/geant4/lowE/index.html
// -------------------------------------------------------------------
#ifndef G4THIRDLEVEL_HH
#define G4THIRDLEVEL_HH
#ifndef G4RANGETEST_HH
#define G4RANGETEST_HH 1
#include "G4SecondLevel.hh"
//#include "g4rw/tpordvec.h"
#include "globals.hh"
#include "G4VRangeTest.hh"
//class G4ThirdLevel : public G4RWTPtrOrderedVector< G4SecondLevel >{
class G4ThirdLevel : public G4std::vector< G4SecondLevel* >
{
class G4ParticleDefinition;
class G4Material;
class G4RangeTest : public G4VRangeTest {
public:
virtual ~G4ThirdLevel();
G4RangeTest() { }
G4bool operator == (const G4ThirdLevel& ) const;
virtual ~G4RangeTest() { }
virtual G4bool Escape(const G4ParticleDefinition* particle,
const G4Material* material,
G4double energy,
G4double safety) const;
G4bool operator < (const G4ThirdLevel&) const;
private:
};
#endif
@@ -0,0 +1,80 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4SemiLogInterpolation.hh,v 1.2 2001/10/08 07:45:35 pia Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// Author: Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
//
// History:
// -----------
// 31 Jul 2001 MGP Created
//
// -------------------------------------------------------------------
// Class description:
// Log-Log interpolation of a data set
// Part of a strategy pattern to encapsulate algorithms for interpolation of data sets
// Further documentation available from http://www.ge.infn.it/geant4/lowE/index.html
// -------------------------------------------------------------------
#ifndef G4SEMILOGINTERPOLATION_HH
#define G4SEMILOGINTERPOLATION_HH 1
#include "globals.hh"
#include "G4VDataSetAlgorithm.hh"
#include "G4DataVector.hh"
class G4SemiLogInterpolation : public G4VDataSetAlgorithm {
public:
G4SemiLogInterpolation();
~G4SemiLogInterpolation();
G4double Calculate(G4double point, G4int bin,
const G4DataVector& energies,
const G4DataVector& data) const;
virtual G4VDataSetAlgorithm* Clone() const { return new G4SemiLogInterpolation; }
private:
// Hide copy constructor and assignment operator
};
#endif
@@ -0,0 +1,90 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4ShellData.hh,v 1.1 2001/08/20 16:36:01 pia Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// Author: Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
//
// History:
// -----------
// 6 Aug 2001 MGP Created
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic Physics
// Shell data set: shell identifiers and binding energies
// -------------------------------------------------------------------
#ifndef G4SHELLDATA_HH
#define G4SHELLDATA_HH 1
#include "globals.hh"
#include "g4std/vector"
#include "g4std/map"
class G4DataVector;
class G4ShellData
{
public:
G4ShellData(G4int minZ = 1, G4int maxZ = 99);
~G4ShellData();
size_t NumberOfShells(G4int Z) const;
G4int ShellId(G4int Z, G4int shellIndex) const;
const G4DataVector& ShellIdVector(G4int Z) const;
G4double BindingEnergy(G4int Z, G4int shellIndex) const;
void LoadData(const G4String& fileName);
void PrintData() const;
private:
G4int zMin;
G4int zMax;
G4std::map<G4int,G4DataVector*,G4std::less<G4int> > idMap;
G4std::map<G4int,G4DataVector*,G4std::less<G4int> > bindingMap;
G4std::vector<G4int> nShells;
};
#endif
@@ -0,0 +1,107 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4ShellEMDataSet.hh,v 1.3 2001/09/10 18:05:16 pia Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// Author: Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
//
// History:
// -----------
// 31 Jul 2001 MGP Created
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic Physics
// Data set for an electromagnetic physics process
// A strategy pattern is used to encapsulate algorithms for data interpolation
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
#ifndef G4SHELLEMDATASET_HH
#define G4SHELLEMDATASET_HH 1
#include "globals.hh"
#include "G4DataVector.hh"
#include "G4VEMDataSet.hh"
#include "g4std/vector"
class G4EMDataSet;
class G4VDataSetAlgorithm;
class G4ShellEMDataSet : public G4VEMDataSet
{
public:
G4ShellEMDataSet(G4int Z,
const G4VDataSetAlgorithm* interpolation,
G4double unitE = MeV, G4double unitData = barn);
G4ShellEMDataSet(G4int Z,
const G4String& dataFile,
const G4VDataSetAlgorithm* interpolation,
G4double unitE = MeV, G4double unitData = barn);
~G4ShellEMDataSet();
G4double FindValue(G4double e, G4int id = 0) const;
const G4VEMDataSet* GetComponent(G4int i) const { return components[i]; }
void AddComponent(G4VEMDataSet* component);
size_t NumberOfComponents() const { return nComponents; }
void PrintData() const;
const G4DataVector& GetEnergies(G4int i) const;
const G4DataVector& GetData(G4int i) const;
private:
void LoadData(const G4String& fileName);
G4int z;
const G4VDataSetAlgorithm* algorithm; // Not owned pointer
// G4std::map<G4int,G4VEMDataSet*,G4std::less<G4int> > componentsMap;
G4std::vector<G4VEMDataSet*> components;
size_t nComponents;
G4double unit1;
G4double unit2;
};
#endif
@@ -0,0 +1,80 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4ShellVacancy.hh
// GEANT4 tag $Name:
//
// Author: Elena Guardincerri (Elena.Guardincerri@ge.infn.it)
//
// History:
// -----------
// 21 Sept 2001 Elena Guardincerri Created
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic Physics
// Fluorescence in along step do it: determinates the number of ionizations
// -------------------------------------------------------------------
#ifndef G4SHELLVACANCY_HH
#define G4SHELLVACANCY_HH 1
#include "globals.hh"
#include "g4std/vector"
//#include "g4std/map"
class G4VEMDataSet;
class G4Material;
class G4Element;
class G4ShellVacancy
{
public:
G4ShellVacancy();
~G4ShellVacancy();
G4std::vector<G4int> GenerateNumberOfIonisations(const G4Material* material,
G4double incidentEnergy,
G4double eLoss) const;
void AddXsiTable(G4VEMDataSet* set);
private:
G4int AverageNOfIonisations(const G4Material* material,
const G4Element* element,
G4double energy,
G4double eLoss) const;
G4std::vector<G4VEMDataSet*> xsis;
};
#endif
@@ -0,0 +1,152 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4VCrossSectionHandler.hh,v 1.9 2001/10/10 09:49:29 pia Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// Author: Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
//
// History:
// -----------
// 16 Sep 2001 MGP Created
// 26 Sep 2001 V.Ivanchenko Hide copy constructor and assignement operator
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic Physics
// Base class for cross section manager for an electromagnetic physics process
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
#ifndef G4VCROSSSECTIONHANDLER_HH
#define G4VCROSSSECTIONHANDLER_HH 1
#include "globals.hh"
#include "G4DataVector.hh"
#include "g4std/map"
#include "g4std/vector"
class G4VDataSetAlgorithm;
class G4VEMDataSet;
class G4Material;
class G4Element;
class G4VCrossSectionHandler {
public:
G4VCrossSectionHandler();
G4VCrossSectionHandler(G4VDataSetAlgorithm* interpolation,
G4double minE = 250*eV, G4double maxE = 100*GeV,
G4int nBins = 200,
G4double unitE = MeV, G4double unitData = barn,
G4int minZ = 1, G4int maxZ = 99);
virtual ~G4VCrossSectionHandler();
void Initialise(G4VDataSetAlgorithm* interpolation = 0,
G4double minE = 250*eV, G4double maxE = 100*GeV,
G4int numberOfBins = 200,
G4double unitE = MeV, G4double unitData = barn,
G4int minZ = 1, G4int maxZ = 99);
G4int SelectRandomAtom(const G4Material* material, G4double e) const;
const G4Element* SelectRandomElement(const G4Material* material,
G4double e) const;
G4int SelectRandomShell(G4int Z, G4double e) const;
G4VEMDataSet* BuildMeanFreePathForMaterials(const G4DataVector* energyCuts = 0);
G4double FindValue(G4int Z, G4double e) const;
G4double FindValue(G4int Z, G4double e, G4int shellIndex) const;
void LoadData(const G4String& dataFile);
void LoadShellData(const G4String& dataFile);
void PrintData() const;
void Clear();
protected:
G4int NumberOfComponents(G4int Z) const;
G4double ValueForMaterial(const G4Material* material, G4double e) const;
void ActiveElements();
// Factory method
virtual G4std::vector<G4VEMDataSet*>* BuildCrossSectionsForMaterials(
const G4DataVector& energyVector,
const G4DataVector* energyCuts = 0) = 0;
// Factory method
virtual G4VDataSetAlgorithm* CreateInterpolation();
G4VDataSetAlgorithm* GetInterpolation() const { return interpolation; }
private:
// Hide copy constructor and assignment operator
G4VCrossSectionHandler(const G4VCrossSectionHandler&);
G4VCrossSectionHandler & operator=(const G4VCrossSectionHandler &right);
G4VDataSetAlgorithm* interpolation;
G4double eMin;
G4double eMax;
G4int nBins;
G4double unit1;
G4double unit2;
G4int zMin;
G4int zMax;
G4DataVector activeZ;
G4std::map<G4int,G4VEMDataSet*,G4std::less<G4int> > dataMap;
G4std::vector<G4VEMDataSet*>* crossSections;
};
#endif
@@ -0,0 +1,80 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4VDataSetAlgorithm.hh,v 1.5 2001/10/09 12:13:48 pia Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// Author: Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
//
// History:
// -----------
// 31 Jul 2001 MGP Created
//
// -------------------------------------------------------------------
// Class description:
// Base class for a strategy pattern to encapsulate algorithms for interpolation of a data set
// Further documentation available from http://www.ge.infn.it/geant4/lowE/index.html
// -------------------------------------------------------------------
#ifndef G4VDATASETALGORITHM_HH
#define G4VDATASETALGORITHM_HH 1
#include "globals.hh"
#include "G4DataVector.hh"
class G4VDataSetAlgorithm {
public:
G4VDataSetAlgorithm() { }
virtual ~G4VDataSetAlgorithm() { }
virtual G4double Calculate(G4double point, G4int bin,
const G4DataVector& energies,
const G4DataVector& data) const = 0;
virtual G4VDataSetAlgorithm* Clone() const = 0;
private:
// Hide copy constructor and assignment operator
G4VDataSetAlgorithm(const G4VDataSetAlgorithm&);
G4VDataSetAlgorithm & operator=(const G4VDataSetAlgorithm &right);
};
#endif
@@ -0,0 +1,93 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4VEMDataSet.hh,v 1.5 2001/10/04 14:03:57 pia Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// Author: Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
//
// History:
// -----------
// 31 Jul 2001 MGP Created
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic Physics
// Data set for an electromagnetic physics process
// A strategy pattern is used to encapsulate algorithms for data interpolation
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
#ifndef G4VEMDATASET_HH
#define G4VEMDATASET_HH 1
#include "globals.hh"
#include "G4DataVector.hh"
class G4VDataSetAlgorithm;
class G4VEMDataSet
{
public:
G4VEMDataSet() { }
virtual ~G4VEMDataSet() { }
virtual G4double FindValue(G4double e, G4int id = 0) const = 0;
virtual void PrintData() const = 0;
virtual const G4VEMDataSet* GetComponent(G4int i) const { return 0; }
virtual void AddComponent(G4VEMDataSet* dataSet) { }
virtual size_t NumberOfComponents() const { return 0; }
virtual const G4DataVector& GetEnergies(G4int i) const = 0;
virtual const G4DataVector& GetData(G4int i) const = 0;
protected:
private:
// Hide copy constructor and assignment operator
G4VEMDataSet(const G4VEMDataSet&);
G4VEMDataSet & operator=(const G4VEMDataSet &right);
};
#endif
@@ -0,0 +1,106 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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. *
// ********************************************************************
//
//
// -------------------------------------------------------------------
//
// GEANT4 Class file
//
//
// File name: G4VEnergySpectrum
//
// Author: V.Ivanchenko (Vladimir.Ivantchenko@cern.ch)
//
// Creation date: 29 September 2001
//
// Modifications:
//
// -------------------------------------------------------------------
// Class Description:
//
// Abstract interface for the energy spectrum of secondary particles in
// electromagnetic processes.
//
// Class Description: End
// -------------------------------------------------------------------
//
#ifndef G4VENERGYSPECTRUM_HH
#define G4VENERGYSPECTRUM_HH 1
#include "globals.hh"
class G4ParticleDefinition;
class G4VEnergySpectrum
{
public:
G4VEnergySpectrum() {};
virtual ~G4VEnergySpectrum() {};
virtual G4double Probability(G4int Z,
G4double minKineticEnergy,
G4double maxKineticEnergy,
G4double kineticEnergy,
G4int shell = 0,
const G4ParticleDefinition* pd = 0) const = 0;
virtual G4double AverageEnergy(G4int Z,
G4double minKineticEnergy,
G4double maxKineticEnergy,
G4double kineticEnergy,
G4int shell = 0,
const G4ParticleDefinition* pd = 0) const = 0;
virtual G4double SampleEnergy(G4int Z,
G4double minKineticEnergy,
G4double maxKineticEnergy,
G4double kineticEnergy,
G4int shell = 0,
const G4ParticleDefinition* pd = 0) const = 0;
virtual G4double MaxEnergyOfSecondaries(G4double kineticEnergy,
G4int Z = 0,
const G4ParticleDefinition* pd = 0) const = 0;
virtual G4double Excitation(G4int Z, G4double kineticEnergy) const
{return 0.0;};
virtual void PrintData() const = 0;
protected:
private:
// Hide copy constructor and assignment operator
G4VEnergySpectrum(const G4VEnergySpectrum&);
G4VEnergySpectrum & operator=(const G4VEnergySpectrum &right);
};
#endif
@@ -21,50 +21,53 @@
// ********************************************************************
//
//
// $Id: G4VRangeTest.hh,v 1.1 2001/10/08 07:51:42 pia Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// Author: Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
//
// History:
// -----------
// 5 Oct 2001 MGP Created
//
// -------------------------------------------------------------------
// GEANT 4 class file
//
// CERN, Geneva, Switzerland
//
// File name: G4FirstLevel.hh
//
// Author: Alessandra Forti (Alessandra.Forti@cern.ch)
//
// Creation date: 1 Giugno 1999
//
// Modifications: 24.04.01 V.Ivanchenko remove RogueWave
//
// -------------------------------------------------------------------
// Class description:
// Utility for Low Energy e.m. e/photon processes
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// Base class for a strategy pattern encapsulating algorithms to test the range
// of a particle
// Further documentation available from http://www.ge.infn.it/geant4/lowE/index.html
// -------------------------------------------------------------------
#ifndef G4FIRSTLEVEL_HH
#define G4FIRSTLEVEL_HH
#ifndef G4VRANGETEST_HH
#define G4VRANGETEST_HH 1
#include "G4DataVector.hh"
class G4FirstLevel : public G4std::vector< G4DataVector* >
{
#include "globals.hh"
class G4ParticleDefinition;
class G4Material;
class G4VRangeTest {
public:
// G4FirstLevel( G4FirstLevel& )
G4VRangeTest() { }
~G4FirstLevel();
virtual ~G4VRangeTest() { }
virtual G4bool Escape(const G4ParticleDefinition* particle,
const G4Material* material,
G4double energy,
G4double safety) const = 0;
G4bool operator == (const G4FirstLevel& ) const;
G4bool operator < (const G4FirstLevel&) const;
private:
};
#endif
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4VeLowEnergyLoss.hh,v 1.4.2.2 2001/06/28 20:19:25 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4VeLowEnergyLoss.hh,v 1.7 2001/11/23 11:45:20 vnivanch Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// 3.4.2000 Veronique Lefebure:
// Move utils/include/G4VEnergyLoss.hh to
@@ -49,7 +49,8 @@
// -----------------------------------------------------------
//
// Modifications:
// 20/09/00 update fluctuations V.Ivanchenko
// 20/09/00 V.Ivanchenko update fluctuations
// 23/11/01 V.Ivanchenko Move static member-functions from header to source
//
// Class description:
// Abstract class for Low Energy Electromagnetic electron energy loss
@@ -127,20 +128,15 @@ class G4VeLowEnergyLoss : public G4VContinuousDiscreteProcess
public: // With description
static void SetRndmStep (G4bool value) {rndmStepFlag = value;}
static void SetRndmStep (G4bool value);
// use / do not use randomisation in energy loss steplimit
// ( default = no randomisation)
static void SetEnlossFluc (G4bool value) {EnlossFlucFlag = value;}
static void SetEnlossFluc (G4bool value);
// compute energy loss with/without fluctuation
// ( default : with fluctuation)
static void SetStepFunction (G4double c1, G4double c2)
{dRoverRange = c1; finalRange = c2;
c1lim=dRoverRange ;
c2lim=2.*(1-dRoverRange)*finalRange;
c3lim=-(1.-dRoverRange)*finalRange*finalRange;
}
static void SetStepFunction (G4double c1, G4double c2);
// sets values for data members used to compute the step limit:
// dRoverRange : max. relative range change in one step,
// finalRange : if range <= finalRange --> last step for the particle.
@@ -20,49 +20,63 @@
// * statement, and all its terms. *
// ********************************************************************
//
// -------------------------------------------------------------------
//
// $Id: G4LowEnergyRayleigh.icc,v 1.12.2.2 2001/06/28 20:19:24 gunter Exp $
// GEANT4 tag $Name: $
// GEANT4 Class file
//
//
// File name: G4VhShellCrossSection
//
// Author: S. Dussoni and A. Mantero (Alfonso.Mantero@ge.infn.it)
//
// ---------------------------------------------------------------
// GEANT 4 class inlined methods file
// History:
// -----------
// 23 Oct 2001 A. Mantero 1st implementation
// 24 Oct 2001 MGP Cleaned up
// 29 Oct 2001 VI Add delta energy
//
// ------------ G4LowEnergyRayleigh physics process ---------
// by A.Forti 1999/03/02
// ***************************************************************
// -------------------------------------------------------------------
inline G4bool G4LowEnergyRayleigh::IsApplicable(const G4ParticleDefinition& particle){
return ( &particle == G4Gamma::Gamma() );
}
// Class Description:
//
// Abstract class for models of shell cross sections in proton ionisation
inline G4double G4LowEnergyRayleigh::GetMeanFreePath(const G4Track& aTrack, G4double, G4ForceCondition*){
// -------------------------------------------------------------------
//
// returns the gamma mean free path in GEANT4 internal units
const G4DynamicParticle* aDynamicGamma = aTrack.GetDynamicParticle();
G4double GammaEnergy = aDynamicGamma->GetKineticEnergy();
G4Material* aMaterial = aTrack.GetMaterial();
#ifndef G4VHSHELLCROSSSECTION_HH
#define G4VHSHELLCROSSSECTION_HH 1
// G4bool isOutRange ;
#include "globals.hh"
#include "g4std/vector"
if (GammaEnergy > highestEnergyLimit){
MeanFreePath = DBL_MAX;
}
else if(GammaEnergy < lowestEnergyLimit){
class G4VhShellCrossSection
{
MeanFreePath = DBL_MIN;
}
else {
public:
MeanFreePath = util.DataLogInterpolation(GammaEnergy,
aMaterial->GetIndex(),
theMeanFreePathTable);
}
G4VhShellCrossSection();
return MeanFreePath;
}
virtual ~G4VhShellCrossSection();
G4int SelectRandomShell(G4int Z,
G4double incidentEnergy,
G4double mass,
G4double deltaEnergy) const;
protected:
virtual G4std::vector<G4double> Probabilities(G4int Z,
G4double incidentEnergy,
G4double mass,
G4double deltaEnergy) const = 0;
private:
// Hide copy constructor and assignment operator
G4VhShellCrossSection(const G4VhShellCrossSection&);
G4VhShellCrossSection & operator=(const G4VhShellCrossSection &right);
};
#endif
@@ -0,0 +1,118 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4eBremsstrahlungSpectrum.hh,v 1.2 2001/11/29 19:01:45 vnivanch Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// -------------------------------------------------------------------
//
// GEANT4 Class file
//
//
// File name: G4EBremsstrahlungSpectrum
//
// Author: V.Ivanchenko (Vladimir.Ivantchenko@cern.ch)
//
// Creation date: 27 September 2001
//
// Modifications:
// 10.10.01 MGP Revision to improve code quality and consistency with design
// 29.11.01 V.Ivanchenko Parametrisation is updated
//
// -------------------------------------------------------------------
// Class Description:
// Provides various integration over gamma spectrum of e- Bremsstrahlung.
// Parametrisation is described in Physics Reference Manual based on
// data from EEDL database.
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
#ifndef G4EBREMSSTRAHLUNGSPECTRUM_HH
#define G4EBREMSSTRAHLUNGSPECTRUM_HH 1
#include "globals.hh"
#include "G4DataVector.hh"
#include "G4VEnergySpectrum.hh"
class G4BremsstrahlungParameters;
class G4eBremsstrahlungSpectrum : public G4VEnergySpectrum
{
public:
G4eBremsstrahlungSpectrum();
~G4eBremsstrahlungSpectrum();
G4double Probability(G4int Z,
G4double tMin,
G4double tMax,
G4double kineticEnergy,
G4int shell=0,
const G4ParticleDefinition* pd=0) const;
G4double AverageEnergy(G4int Z,
G4double tMin,
G4double tMax,
G4double kineticEnergy,
G4int shell=0,
const G4ParticleDefinition* pd=0) const;
G4double SampleEnergy(G4int Z,
G4double tMin,
G4double tMax,
G4double kineticEnergy,
G4int shell=0,
const G4ParticleDefinition* pd=0) const;
G4double MaxEnergyOfSecondaries(G4double kineticEnergy,
G4int Z = 0,
const G4ParticleDefinition* pd=0) const
{ return kineticEnergy; }
void PrintData() const;
private:
G4double IntSpectrum(G4double xMin, G4double xMax,
const G4DataVector& p) const;
G4double AverageValue(G4double xMin, G4double xMax,
const G4DataVector& p) const;
G4double Function(G4double x, const G4DataVector& p) const;
// Hide copy constructor and assignment operator
G4eBremsstrahlungSpectrum(const G4eBremsstrahlungSpectrum&);
G4eBremsstrahlungSpectrum & operator = (const G4eBremsstrahlungSpectrum &right);
G4BremsstrahlungParameters* theBRparam;
G4double lowestE;
size_t length;
G4int verbose;
G4DataVector xp;
};
#endif
@@ -0,0 +1,87 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4eIonisationCrossSectionHandler.hh,v 1.2 2001/10/10 17:37:27 pia Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// -------------------------------------------------------------------
//
// GEANT4 Class file
//
//
// File name: G4eIonisationCrossSectionHandler
//
// Author: V.Ivanchenko (Vladimir.Ivanchenko@cern.ch)
//
// Creation date: 17 September 2001
//
// Modified:
// 10 Oct 2001 M.G. Pia Revision to improve code quality and consistency with design
//
// -------------------------------------------------------------------
// Class description:
// Provides cross sections with cut for LowEnergyIonisation
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
//
#ifndef G4EIONISATIONCROSSSECTIONHANDLER_HH
#define GG4EIONISATIONCROSSSECTIONHANDLER_HH 1
#include "G4VCrossSectionHandler.hh"
#include "globals.hh"
class G4VEnergySpectrum;
class G4DataVector;
class G4VEMDataSet;
class G4VDataSetAlgorithm;
class G4eIonisationCrossSectionHandler : public G4VCrossSectionHandler
{
public:
G4eIonisationCrossSectionHandler(const G4VEnergySpectrum* spec,
G4VDataSetAlgorithm* alg,
G4double emin,
G4double emax,
G4int nbin);
~G4eIonisationCrossSectionHandler();
protected:
G4std::vector<G4VEMDataSet*>* BuildCrossSectionsForMaterials(
const G4DataVector& energyVector,
const G4DataVector* energyCuts);
private:
const G4VEnergySpectrum* theParam;
G4VDataSetAlgorithm* interp;
};
#endif
@@ -0,0 +1,94 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4eIonisationParameters.hh,v 1.6 2001/11/29 19:01:45 vnivanch Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// Author: Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
// V. Ivanchenko
// Values of the parameters from A. Forti's fit
//
// History:
// -----------
// 31 Jul 2001 MGP Created
// 12.09.01 V.Ivanchenko Add param and interpolation of parametersVI
// 10.10.2001 MGP Revision to improve code quality and
// consistency with design
// 29.11.01 V.Ivanchenko Parametrisation is updated
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic Physics
// Set of parameters for LowEnergyIonisation described spectrum
// of delta-electrons retrieved from EEDL database.
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
#ifndef G4IONISATIONPARAMETERS_HH
#define G4IONISATIONPARAMETERS_HH 1
#include "globals.hh"
#include "G4DataVector.hh"
#include "g4std/map"
class G4VDataSetAlgorithm;
class G4VEMDataSet;
class G4eIonisationParameters {
public:
G4eIonisationParameters(G4int minZ = 1, G4int maxZ = 99);
~G4eIonisationParameters();
G4double Parameter(G4int Z, G4int shellIndex,
G4int parameterIndex, G4double e) const;
G4double Excitation(G4int Z, G4double e) const;
void PrintData() const;
private:
// Hide copy constructor and assignment operator
G4eIonisationParameters(const G4eIonisationParameters&);
G4eIonisationParameters & operator=(const G4eIonisationParameters &right);
void LoadData();
G4int zMin;
G4int zMax;
G4DataVector activeZ;
// Parameters of the energy spectra
G4std::map<G4int,G4VEMDataSet*,G4std::less<G4int> > param;
G4std::map<G4int,G4VEMDataSet*,G4std::less<G4int> > excit;
size_t length;
};
#endif
@@ -0,0 +1,115 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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: G4eIonisationSpectrum.hh,v 1.3 2001/11/29 19:01:45 vnivanch Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// -------------------------------------------------------------------
//
// GEANT4 Class file
//
//
// File name: G4eIonisationSpectrum
//
// Author: V.Ivanchenko (Vladimir.Ivantchenko@cern.ch)
//
// Creation date: 27 September 2001
//
// Modifications:
// 10.10.01 MGP Revision to improve code quality and
// consistency with design
// 29.11.01 V.Ivanchenko Parametrisation is updated
//
// -------------------------------------------------------------------
// Class Description:
// Provides various integration over delta-electron spectrum for e-
// ionisation process. Spectrum is parametrised accourding to
// EEDL database, details are described in the Physics Reference Manual
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
#ifndef G4EIONISATIONSPECTRUM_HH
#define GG4EIONISATIONSPECTRUM_HH 1
#include "G4VEnergySpectrum.hh"
class G4eIonisationParameters;
class G4DataVector;
class G4eIonisationSpectrum : public G4VEnergySpectrum
{
public:
G4eIonisationSpectrum();
~G4eIonisationSpectrum();
G4double Probability(G4int Z, G4double tMin, G4double tMax,
G4double kineticEnergy, G4int shell,
const G4ParticleDefinition* pd=0) const;
G4double AverageEnergy(G4int Z, G4double tMin, G4double tMax,
G4double kineticEnergy, G4int shell,
const G4ParticleDefinition* pd=0) const;
G4double SampleEnergy(G4int Z, G4double tMin, G4double tMax,
G4double kineticEnergy, G4int shell,
const G4ParticleDefinition* pd=0) const;
G4double MaxEnergyOfSecondaries(G4double kineticEnergy,
G4int Z = 0,
const G4ParticleDefinition* pd=0) const
{ return 0.5*kineticEnergy; };
G4double Excitation(G4int Z, G4double e) const;
void PrintData() const;
protected:
private:
G4double IntSpectrum(G4double xMin, G4double xMax,
const G4DataVector& p) const;
G4double AverageValue(G4double xMin, G4double xMax,
const G4DataVector& p) const;
G4double Function(G4double x, const G4DataVector& p) const;
// Hide copy constructor and assignment operator
G4eIonisationSpectrum(const G4eIonisationSpectrum&);
G4eIonisationSpectrum & operator = (const G4eIonisationSpectrum &right);
private:
G4eIonisationParameters* theParam;
G4double lowestE;
G4double factor;
G4int verbose;
};
#endif
@@ -21,11 +21,28 @@
// ********************************************************************
//
//
// $Id: G4eLowEnergyLoss.hh,v 1.1.4.2 2001/06/28 20:19:25 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4eLowEnergyLoss.hh,v 1.7 2001/11/23 11:45:20 vnivanch Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// ------------------------------------------------------------
// GEANT 4 class header file
// -------------------------------------------------------------------
// Class description:
// Low Energy electromagnetic process, electron energy loss
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
//
// This class is the implementation of the unified Energy Loss process.
// It calculates the continuous energy loss for e+/e-.
// The following processes give contributions to the continuous
// energy loss (by default) :
// --- ionisation (= cont.ion.loss + delta ray production)
// --- bremsstrahlung (= cont.loss due to soft brems+discrete bremsstrahlung)
// more can be added ..........
// This class creates static dE/dx and range tables for e+ and e-,
// which tables can be used by other processes , too.
// G4eLowEnergyLoss is the base class for the processes giving contribution
// to the (continuous) energy loss of e+/e- .
//
// History: first implementation, based on object model of
// 2nd December 1995, G.Cosmo
@@ -37,6 +54,8 @@
// 16.10.98 public method SetStepFunction() + messenger class
// 20.01.99 new data members , L.Urban
// 10.02.00 modifications, new e.m. structure , L.Urban
// 18.10.01 Revision to improve code quality and consistency with design
// 23.11.01 V.Ivanchenko Move static member-functions from header to source
// ------------------------------------------------------------
#ifndef G4eLowEnergyLoss_h
@@ -58,20 +77,6 @@
#include "G4PhysicsLinearVector.hh"
#include "G4EnergyLossTables.hh"
// Class description:
// This class is the implementation of the unified Energy Loss process.
// It calculates the continuous energy loss for e+/e-.
// The following processes give contributions to the continuous
// energy loss (by default) :
// --- ionisation (= cont.ion.loss + delta ray production)
// --- bremsstrahlung (= cont.loss due to soft brems+discrete bremsstrahlung)
// more can be added ..........
// This class creates static dE/dx and range tables for e+ and e-,
// which tables can be used by other processes , too.
// G4eLowEnergyLoss is the base class for the processes giving contribution
// to the (continuous) energy loss of e+/e- .
// Class description - end
class G4EnergyLossMessenger;
class G4eLowEnergyLoss : public G4VeLowEnergyLoss
@@ -83,8 +88,6 @@ class G4eLowEnergyLoss : public G4VeLowEnergyLoss
~G4eLowEnergyLoss();
public: // With description
G4bool IsApplicable(const G4ParticleDefinition&);
// true for e+/e- , false otherwise
@@ -110,22 +113,38 @@ class G4eLowEnergyLoss : public G4VeLowEnergyLoss
// ( ionisation and bremsstrahlung) .
virtual G4VParticleChange* PostStepDoIt(const G4Track& track,
const G4Step& Step) = 0;
const G4Step& step) = 0;
// Virtual function to be overridden in the derived classes
// ( ionisation and bremsstrahlung) .
static void SetNbOfProcesses(G4int nb);
// Sets number of processes giving contribution to the energy loss
static void PlusNbOfProcesses();
// Increases number of processes giving contribution to the energy loss
static void MinusNbOfProcesses();
// Decreases number of processes giving contribution to the energy loss
static G4int GetNbOfProcesses();
// Gets number of processes giving contribution to the energy loss
// ( default value = 2)
static void SetLowerBoundEloss(G4double val);
static void SetUpperBoundEloss(G4double val);
static void SetNbinEloss(G4int nb);
static G4double GetLowerBoundEloss();
static G4double GetUpperBoundEloss();
static G4int GetNbinEloss();
private:
G4double GetConstraints(const G4DynamicParticle* aParticle,
G4Material* aMaterial);
// hide assignment operator
G4eLowEnergyLoss (G4eLowEnergyLoss &);
G4eLowEnergyLoss & operator=(const G4eLowEnergyLoss &right);
protected:
virtual G4std::vector<G4DynamicParticle*>* DeexciteAtom(const G4Material* material,
G4double incidentEnergy,
G4double eLoss) { return 0; }
G4PhysicsTable* theLossTable;
G4double MinKineticEnergy ; // particle with kinetic energy
@@ -134,51 +153,6 @@ class G4eLowEnergyLoss : public G4VeLowEnergyLoss
G4double Charge,lastCharge ;
private:
G4PhysicsTable* theDEDXTable;
G4int CounterOfProcess;
G4PhysicsTable** RecorderOfProcess;
G4double fdEdx; // computed in GetConstraints
G4double fRangeNow; // computed in GetConstraints
G4double linLossLimit ; // used in AlongStepDoIt
//New ParticleChange
G4ParticleChangeForLoss fParticleChange ;
//
// static part of the class
//
public: // With description
static void SetNbOfProcesses(G4int nb) {NbOfProcesses=nb;};
// Sets number of processes giving contribution to the energy loss
static void PlusNbOfProcesses() {NbOfProcesses++ ;};
// Increases number of processes giving contribution to the energy loss
static void MinusNbOfProcesses() {NbOfProcesses-- ;};
// Decreases number of processes giving contribution to the energy loss
static G4int GetNbOfProcesses() {return NbOfProcesses;};
// Gets number of processes giving contribution to the energy loss
// ( default value = 2)
static void SetLowerBoundEloss(G4double val) {LowerBoundEloss=val;};
static void SetUpperBoundEloss(G4double val) {UpperBoundEloss=val;};
static void SetNbinEloss(G4int nb) {NbinEloss=nb;};
static G4double GetLowerBoundEloss() {return LowerBoundEloss;};
static G4double GetUpperBoundEloss() {return UpperBoundEloss;};
static G4int GetNbinEloss() {return NbinEloss;};
protected:
//basic DEDX and Range tables
static G4PhysicsTable* theDEDXElectronTable ;
static G4PhysicsTable* theDEDXPositronTable ;
@@ -205,7 +179,34 @@ class G4eLowEnergyLoss : public G4VeLowEnergyLoss
static G4PhysicsTable** RecorderOfElectronProcess;
static G4PhysicsTable** RecorderOfPositronProcess;
private:
G4double GetConstraints(const G4DynamicParticle* aParticle,
G4Material* aMaterial);
// hide assignment operator
G4eLowEnergyLoss (G4eLowEnergyLoss &);
G4eLowEnergyLoss & operator=(const G4eLowEnergyLoss &right);
G4PhysicsTable* theDEDXTable;
G4int CounterOfProcess;
G4PhysicsTable** RecorderOfProcess;
G4double fdEdx; // computed in GetConstraints
G4double fRangeNow; // computed in GetConstraints
G4double linLossLimit ; // used in AlongStepDoIt
//New ParticleChange
G4ParticleChangeForLoss fParticleChange ;
//
// static part of the class
//
static G4int NbinEloss; // number of bins in table,
// calculated in BuildPhysicTable
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4eLowEnergyLoss.icc,v 1.2.2.2 2001/06/28 20:19:25 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4eLowEnergyLoss.icc,v 1.3 2001/07/11 10:02:39 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// ---------------------------------------------------------------
// GEANT 4 class inlined methods file
@@ -46,8 +46,13 @@
#ifndef G4hBetheBlochModel_h
#define G4hBetheBlochModel_h 1
#include "globals.hh"
#include "G4VLowEnergyModel.hh"
class G4Material;
class G4ParticleDefinition;
class G4DynamicParticle;
class G4hBetheBlochModel : public G4VLowEnergyModel
{
@@ -47,8 +47,11 @@
#ifndef G4hICRU49He_h
#define G4hICRU49He_h 1
#include "globals.hh"
#include "G4VhElectronicStoppingPower.hh"
class G4Material;
class G4hICRU49He : public G4VhElectronicStoppingPower
{
@@ -48,6 +48,7 @@
#ifndef G4hICRU49Nuclear_h
#define G4hICRU49Nuclear_h 1
#include "globals.hh"
#include "G4VhNuclearStoppingPower.hh"
class G4hICRU49Nuclear : public G4VhNuclearStoppingPower
@@ -48,8 +48,11 @@
#ifndef G4hICRU49p_h
#define G4hICRU49p_h 1
#include "globals.hh"
#include "G4VhElectronicStoppingPower.hh"
class G4Material;
class G4hICRU49p : public G4VhElectronicStoppingPower
{
@@ -48,8 +48,13 @@
#ifndef G4hIonEffChargeSquare_h
#define G4hIonEffChargeSquare_h 1
#include "globals.hh"
#include "G4VLowEnergyModel.hh"
class G4Material;
class G4ParticleDefinition;
class G4DynamicParticle;
class G4hIonEffChargeSquare : public G4VLowEnergyModel
{
@@ -42,6 +42,8 @@
// 09 August 2000 V.Ivanchenko Add GetContinuousStepLimit
// 17 August 2000 V.Ivanchenko Add IonFluctuationModel
// 23 Oct 2000 V.Ivanchenko Renew comments
// 30 Oct 2001 V.Ivanchenko Add minGammaEnergy and minElectronEnergy
// 07 Dec 2001 V.Ivanchenko Add SetFluorescence method
// ------------------------------------------------------------
// Class Description:
@@ -64,6 +66,7 @@
#ifndef G4hLowEnergyIonisation_h
#define G4hLowEnergyIonisation_h 1
#include "globals.hh"
#include "G4hLowEnergyLoss.hh"
#include "G4VLowEnergyModel.hh"
#include "G4Track.hh"
@@ -78,6 +81,11 @@
#include "G4hIonEffChargeSquare.hh"
#include "G4IonChuFluctuationModel.hh"
#include "G4IonYangFluctuationModel.hh"
#include "G4AtomicDeexcitation.hh"
class G4VEMDataSet;
class G4ShellVacancy;
class G4VhShellCrossSection;
class G4hLowEnergyIonisation : public G4hLowEnergyLoss
{
@@ -155,7 +163,10 @@ public: // With description
void SetBarkasOff() {theBarkas = false;};
// This method switch off calculation of the Barkas and Bloch effects.
void SetFluorescence(const G4bool val) {theFluo = val;};
// This method switch on/off simulation of the fluorescence of the media.
G4VParticleChange* AlongStepDoIt(const G4Track& trackData ,
const G4Step& stepData ) ;
// Function to determine total energy deposition on the step
@@ -169,6 +180,13 @@ public: // With description
G4double kineticEnergy);
// This method returns electronic dE/dx for protons or antiproton.
void SetCutForSecondaryPhotons(G4double cut);
// Set threshold energy for fluorescence
void SetCutForAugerElectrons(G4double cut);
// Set threshold energy for Auger electron production
protected:
private:
@@ -177,9 +195,11 @@ private:
void InitializeParametrisation();
void BuildLossTable(const G4ParticleDefinition& aParticleType) ;
void BuildLossTable(const G4ParticleDefinition& aParticleType);
void BuildLambdaTable(const G4ParticleDefinition& aParticleType) ;
void BuildDataForFluorescence(const G4ParticleDefinition& aParticleType);
void BuildLambdaTable(const G4ParticleDefinition& aParticleType);
void SetProtonElectronicStoppingPowerModel(const G4String& dedxTable)
{theProtonTable = dedxTable ;};
@@ -224,6 +244,14 @@ private:
G4double meanLoss,
G4double step) const;
// Function to sample electronic losses
G4std::vector<G4DynamicParticle*>* DeexciteAtom(const G4Material* material,
G4double incidentEnergy,
G4double hMass,
G4double eLoss);
G4int SelectRandomAtom(const G4Material* material,
G4double kineticEnergy) const;
// hide assignment operator
G4hLowEnergyIonisation & operator=(const G4hLowEnergyIonisation &right);
@@ -254,7 +282,10 @@ private:
G4bool nStopping;
G4bool theBarkas;
G4double* deltaCutInKineticEnergy;
G4DataVector cutForDelta;
G4DataVector cutForGamma;
G4double minGammaEnergy;
G4double minElectronEnergy;
G4PhysicsTable* theMeanFreePathTable;
const G4double paramStepLimit; // parameter limits the step at low energy
@@ -264,13 +295,41 @@ private:
G4double charge; //
G4double chargeSquare; //
protected:
private:
G4AtomicDeexcitation deexcitationManager;
G4ShellVacancy* shellVacancy;
G4VhShellCrossSection* shellCS;
G4std::vector<G4VEMDataSet*> zFluoDataVector;
G4bool theFluo;
};
#include "G4hLowEnergyIonisation.icc"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
inline G4double G4hLowEnergyIonisation::GetContinuousStepLimit(
const G4Track& track,
G4double,
G4double currentMinimumStep,
G4double&)
{
G4double Step =
GetConstraints(track.GetDynamicParticle(),track.GetMaterial()) ;
if((Step>0.0)&&(Step<currentMinimumStep))
currentMinimumStep = Step ;
return Step ;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
inline G4bool G4hLowEnergyIonisation::IsApplicable(
const G4ParticleDefinition& particle)
{
return(particle.GetPDGCharge() != 0.0
&& particle.GetPDGMass() > proton_mass_c2*0.1);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
#endif
@@ -1,98 +0,0 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * 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. *
// ********************************************************************
//
//
// ---------------------------------------------------------------
// GEANT 4 class inlined methods file
//
// ------------ G4hLowEnergyIonisation physics process ------
// by Vladimir Ivanchenko, 27 July 1999
// was made on the base of G4hIonisation class
// developed by Laszlo Urban
// ************************************************************
// It is the extention of the ionisation process for the slow
// charged hadrons.
// ************************************************************
// 28 July 1999 V.Ivanchenko cleen up
// 09 Aug 2000 V.Ivanchenko add GetContinuousStepLimit
// 23 Oct 2000 V.Ivanchenko add control on particle mass
// ---------------------------------------------------------------
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
inline G4double G4hLowEnergyIonisation::GetMeanFreePath(
const G4Track& trackData,
G4double previousStepSize,
enum G4ForceCondition* condition)
{
const G4DynamicParticle* aParticle = trackData.GetDynamicParticle() ;
G4Material* aMaterial = trackData.GetMaterial() ;
G4double meanFreePath;
G4bool isOutRange ;
*condition = NotForced ;
G4double kineticEnergy = aParticle->GetKineticEnergy() ;
if(kineticEnergy < LowestKineticEnergy) meanFreePath = DBL_MAX;
else {
if(kineticEnergy > HighestKineticEnergy)
kineticEnergy = HighestKineticEnergy ;
meanFreePath = ((*theMeanFreePathTable)(aMaterial->GetIndex()))->
GetValue(kineticEnergy,isOutRange) ;
}
return meanFreePath ;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
inline G4double G4hLowEnergyIonisation::GetContinuousStepLimit(
const G4Track& track,
G4double,
G4double currentMinimumStep,
G4double&)
{
G4double Step =
GetConstraints(track.GetDynamicParticle(),track.GetMaterial()) ;
if((Step>0.0)&&(Step<currentMinimumStep))
currentMinimumStep = Step ;
return Step ;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
inline G4bool G4hLowEnergyIonisation::IsApplicable(
const G4ParticleDefinition& particle)
{
return(particle.GetPDGCharge() != 0.0
&& particle.GetPDGMass() > proton_mass_c2*0.1);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4hLowEnergyLoss.hh,v 1.10.2.2 2001/06/28 20:19:27 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4hLowEnergyLoss.hh,v 1.13 2001/11/23 11:45:20 vnivanch Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// $Id:
// ------------------------------------------------------------
@@ -49,6 +49,7 @@
// 02/02/99 L.Urban several bugs fixed
// 31/03/00 V.Ivanchenko rename to lowenergy as G4hLowEnergyLoss.hh
// 09/08/00 V.Ivanchenko remove GetContinuousStepLimit and IsApplicable
// 23/11/01 V.Ivanchenko Move static member-functions from header to source
//
// Class description:
// Class for Low Energy electromagnetic energy loss of hadrons
@@ -126,29 +127,21 @@ class G4hLowEnergyLoss : public G4VContinuousDiscreteProcess
public:
// get the number of processes contributing to the cont.energy loss
static G4int GetNumberOfProcesses() { return NumberOfProcesses; };
static G4int GetNumberOfProcesses();
// set the number of processes contributing to the cont.energy loss
static void SetNumberOfProcesses(G4int number)
{NumberOfProcesses=number ; };
static void SetNumberOfProcesses(G4int number);
// Increment the number of processes contributing to the cont.energy loss
static void PlusNumberOfProcesses()
{ NumberOfProcesses++ ; };
static void PlusNumberOfProcesses();
// decrement the number of processes contributing to the cont.energy loss
static void MinusNumberOfProcesses()
{ NumberOfProcesses-- ; };
static void MinusNumberOfProcesses();
static void SetdRoverRange(G4double value) {dRoverRange = value;}
static void SetRndmStep (G4bool value) {rndmStepFlag = value;}
static void SetEnlossFluc (G4bool value) {EnlossFlucFlag = value;}
static void SetStepFunction (G4double c1, G4double c2)
{dRoverRange = c1; finalRange = c2;
c1lim=dRoverRange ;
c2lim=2.*(1-dRoverRange)*finalRange;
c3lim=-(1.-dRoverRange)*finalRange*finalRange;
}
static void SetdRoverRange(G4double value);
static void SetRndmStep (G4bool value);
static void SetEnlossFluc (G4bool value);
static void SetStepFunction (G4double c1, G4double c2);
protected:
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4hLowEnergyLoss.icc,v 1.1.4.2 2001/06/28 20:19:27 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4hLowEnergyLoss.icc,v 1.2 2001/07/11 10:02:40 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// $Id:
// ---------------------------------------------------------------
@@ -46,9 +46,14 @@
#ifndef G4hNuclearStoppingModel_h
#define G4hNuclearStoppingModel_h 1
#include "globals.hh"
#include "G4VLowEnergyModel.hh"
#include "G4VhNuclearStoppingPower.hh"
class G4ParticleDefinition;
class G4Material;
class G4DynamicParticle;
class G4hNuclearStoppingModel : public G4VLowEnergyModel
{
@@ -46,9 +46,14 @@
#ifndef G4hParametrisedLossModel_h
#define G4hParametrisedLossModel_h 1
#include "globals.hh"
#include "G4VLowEnergyModel.hh"
#include "G4VhElectronicStoppingPower.hh"
class G4DynamicParticle;
class G4ParticleDefinition;
class G4Material;
class G4hParametrisedLossModel : public G4VLowEnergyModel
{
@@ -20,53 +20,55 @@
// * statement, and all its terms. *
// ********************************************************************
//
// -------------------------------------------------------------------
//
// $Id: G4LowEnergyCompton.icc,v 1.13.2.2 2001/06/28 20:19:23 gunter Exp $
// GEANT4 tag $Name: $
// GEANT4 Class file
//
//
// File name: G4hShellCrossSection
//
// Author: S. Dussoni and A. Mantero (Alfonso.Mantero@ge.infn.it)
//
// ---------------------------------------------------------------
// GEANT 4 class inlined methods file
// History:
// -----------
// 23 Oct 2001 A. Mantero 1st implementation
// 24 Oct 2001 MGP Cleaned up
// 29 Oct 2001 VI Add delta energy
//
// ------------ G4LowEnergyCompton physics process ---------
// by A.Forti 1999/03/02
// ***************************************************************
// -------------------------------------------------------------------
inline G4bool
G4LowEnergyCompton::IsApplicable(const G4ParticleDefinition& particle){
// Class Description:
// Model for shell cross sections in proton ionisation
return ( &particle == G4Gamma::Gamma() );
}
// -------------------------------------------------------------------
inline G4double
G4LowEnergyCompton::GetMeanFreePath(const G4Track& aTrack, G4double, G4ForceCondition*){
#ifndef G4HSHELLCROSSSECTION_HH
#define G4HSHELLCROSSSECTION_HH 1
// returns the gamma mean free path in GEANT4 internal units
const G4DynamicParticle* aDynamicGamma = aTrack.GetDynamicParticle();
G4double GammaEnergy = aDynamicGamma->GetKineticEnergy();
G4Material* aMaterial = aTrack.GetMaterial();
#include "globals.hh"
#include "G4VhShellCrossSection.hh"
// G4bool isOutRange ;
class G4hShellCrossSection : public G4VhShellCrossSection
{
public:
if (GammaEnergy > highestEnergyLimit){
meanFreePath = DBL_MAX;
}
else if(GammaEnergy < lowestEnergyLimit){
G4hShellCrossSection();
meanFreePath = DBL_MIN;
}
virtual ~G4hShellCrossSection();
else {
protected:
meanFreePath = util.DataLogInterpolation(GammaEnergy,
aMaterial->GetIndex(),
theMeanFreePathTable);
virtual G4std::vector<G4double> Probabilities(G4int Z,
G4double incidentEnergy,
G4double mass,
G4double deltaEnergy) const;
}
return meanFreePath;
}
private:
// Hide copy constructor and assignment operator
G4hShellCrossSection(const G4hShellCrossSection&);
G4hShellCrossSection & operator = (const G4hShellCrossSection &right);
};
#endif
@@ -48,8 +48,11 @@
#ifndef G4hZiegler1977He_h
#define G4hZiegler1977He_h 1
#include "globals.hh"
#include "G4VhElectronicStoppingPower.hh"
class G4Material;
class G4hZiegler1977He : public G4VhElectronicStoppingPower
{
@@ -48,6 +48,7 @@
#ifndef G4hZiegler1977Nuclear_h
#define G4hZiegler1977Nuclear_h 1
#include "globals.hh"
#include "G4VhNuclearStoppingPower.hh"
class G4hZiegler1977Nuclear : public G4VhNuclearStoppingPower
@@ -48,8 +48,11 @@
#ifndef G4hZiegler1977p_h
#define G4hZiegler1977p_h 1
#include "globals.hh"
#include "G4VhElectronicStoppingPower.hh"
class G4Material;
class G4hZiegler1977p : public G4VhElectronicStoppingPower
{
@@ -49,6 +49,7 @@
#ifndef G4hZiegler1985Nuclear_h
#define G4hZiegler1985Nuclear_h 1
#include "globals.hh"
#include "G4VhNuclearStoppingPower.hh"
class G4hZiegler1985Nuclear : public G4VhNuclearStoppingPower
@@ -48,8 +48,11 @@
#ifndef G4hZiegler1985p_h
#define G4hZiegler1985p_h 1
#include "globals.hh"
#include "G4VhElectronicStoppingPower.hh"
class G4Material;
class G4hZiegler1985p : public G4VhElectronicStoppingPower
{