//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: G4Material.hh 67044 2013-01-30 08:50:06Z gcosmo $
//
//---------------------------------------------------------------------------
//
// ClassName: G4Material
//
// Description: Contains material properties
//
// Class description:
//
// Is used to define the material composition of Geant4 volumes.
// A G4Material is always made of G4Elements. It should has the name,
// the list of G4Elements, material density, material state, temperature,
// pressure. Other parameters are optional and may be set by the user code
// or computed at initialisation.
//
// There is several ways to construct G4Material:
// - from single element;
// - from a list of components (elements or other materials);
// - from internal Geant4 database of materials
//
// A collection of constituent Elements/Materials should be defined
// with specified weights by fractional mass or atom counts (only for Elements).
//
// Quantities, with physical meaning or not, which are constant in a given
// material are computed and stored here as Derived data members.
//
// The class contains as a private static member the Table of defined
// materials (an ordered vector of materials).
//
// It is strongly not recommended to delete materials in user code.
// All materials will be deleted automatically at the end of Geant4 session.
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
// 10-07-96, new data members added by L.Urban
// 12-12-96, new data members added by L.Urban
// 20-01-97, aesthetic rearrangement. RadLength calculation modified
// Data members Zeff and Aeff REMOVED (i.e. passed to the Elements).
// (local definition of Zeff in DensityEffect and FluctModel...)
// Vacuum defined as a G4State. Mixture flag removed, M.Maire
// 29-01-97, State=Vacuum automatically set density=0 in the contructors.
// Subsequent protections have been put in the calculation of
// MeanExcEnergy, ShellCorrectionVector, DensityEffect, M.Maire
// 20-03-97, corrected initialization of pointers, M.Maire
// 10-06-97, new data member added by V.Grichine (fSandiaPhotoAbsCof)
// 27-06-97, new function GetElement(int), M.Maire
// 24-02-98, fFractionVector become fMassFractionVector
// 28-05-98, kState=kVacuum removed:
// The vacuum is an ordinary gas vith very low density, M.Maire
// 12-06-98, new method AddMaterial() allowing mixture of materials, M.Maire
// 09-07-98, Ionisation parameters removed from the class, M.Maire
// 04-08-98, new method GetMaterial(materialName), M.Maire
// 05-10-98, change name: NumDensity -> NbOfAtomsPerVolume
// 18-11-98, SandiaTable interface modified.
// 19-07-99, new data member (chemicalFormula) added by V.Ivanchenko
// 12-03-01, G4bool fImplicitElement (mma)
// 30-03-01, suppression of the warning message in GetMaterial
// 17-07-01, migration to STL. M. Verderi.
// 14-09-01, Suppression of the data member fIndexInTable
// 31-10-01, new function SetChemicalFormula() (mma)
// 26-02-02, fIndexInTable renewed
// 06-08-02, remove constructors with ChemicalFormula (mma)
// 15-11-05, GetMaterial(materialName, G4bool warning=true)
// 13-04-12, std::map<G4Material*,G4double> fMatComponents (mma)
// 21-04-12, fMassOfMolecule (mma)
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#ifndef G4MATERIAL_HH
#define G4MATERIAL_HH 1
#include <vector>
#include <map>
#include <CLHEP/Units/PhysicalConstants.h>
#include "globals.hh"
#include "G4ios.hh"
#include "G4Element.hh"
#include "G4MaterialPropertiesTable.hh"
#include "G4IonisParamMat.hh"
#include "G4SandiaTable.hh"
#include "G4ElementVector.hh"
#include "G4MaterialTable.hh"
enum G4State { kStateUndefined = 0, kStateSolid, kStateLiquid, kStateGas };
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class G4Material
{
public: // with description
//
// Constructor to create a material from single element
//
G4Material(const G4String& name, //its name
G4double z, //atomic number
G4double a, //mass of mole
G4double density, //density
G4State state = kStateUndefined, //solid,gas
G4double temp = CLHEP::STP_Temperature, //temperature
G4double pressure = CLHEP::STP_Pressure); //pressure
//
// Constructor to create a material from a combination of elements
// and/or materials subsequently added via AddElement and/or AddMaterial
//
G4Material(const G4String& name, //its name
G4double density, //density
G4int nComponents, //nbOfComponents
G4State state = kStateUndefined, //solid,gas
G4double temp = CLHEP::STP_Temperature, //temperature
G4double pressure = CLHEP::STP_Pressure); //pressure
//
// Constructor to create a material from the base material
//
G4Material(const G4String& name, //its name
G4double density, //density
const G4Material* baseMaterial, //base material
G4State state = kStateUndefined, //solid,gas
G4double temp = CLHEP::STP_Temperature, //temperature
G4double pressure = CLHEP::STP_Pressure); //pressure
//
// Add an element, giving number of atoms
//
void AddElement(G4Element* element, //the element
G4int nAtoms); //nb of atoms in
// a molecule
//
// Add an element or material, giving fraction of mass
//
void AddElement (G4Element* element , //the element
G4double fraction); //fractionOfMass
void AddMaterial(G4Material* material, //the material
G4double fraction); //fractionOfMass
virtual ~G4Material();
inline void SetChemicalFormula (const G4String& chF) {fChemicalFormula=chF;}
//
// retrieval methods
//
inline const G4String& GetName() const {return fName;}
inline const G4String& GetChemicalFormula() const {return fChemicalFormula;}
inline G4double GetDensity() const {return fDensity;}
inline G4State GetState() const {return fState;}
inline G4double GetTemperature() const {return fTemp;}
inline G4double GetPressure() const {return fPressure;}
//number of elements constituing this material:
inline size_t GetNumberOfElements() const {return fNumberOfElements;}
//vector of pointers to elements constituing this material:
inline const
G4ElementVector* GetElementVector() const {return theElementVector;}
//vector of fractional mass of each element:
inline const
G4double* GetFractionVector() const {return fMassFractionVector;}
//vector of atom count of each element:
inline const
G4int* GetAtomsVector() const {return fAtomsVector;}
//return a pointer to an element, given its index in the material:
inline const
G4Element* GetElement(G4int iel) const {return (*theElementVector)[iel];}
//vector of nb of atoms per volume of each element in this material:
inline const
G4double* GetVecNbOfAtomsPerVolume() const {return VecNbOfAtomsPerVolume;}
//total number of atoms per volume:
inline
G4double GetTotNbOfAtomsPerVolume() const {return TotNbOfAtomsPerVolume;}
//total number of electrons per volume:
inline
G4double GetTotNbOfElectPerVolume() const {return TotNbOfElectPerVolume;}
//obsolete names (5-10-98) see the 2 functions above
inline const
G4double* GetAtomicNumDensityVector() const {return VecNbOfAtomsPerVolume;}
inline G4double GetElectronDensity() const {return TotNbOfElectPerVolume;}
// Radiation length:
inline G4double GetRadlen() const {return fRadlen;}
// Nuclear interaction length:
inline G4double GetNuclearInterLength() const {return fNuclInterLen;}
// ionisation parameters:
inline G4IonisParamMat* GetIonisation() const {return fIonisation;}
// Sandia table:
inline G4SandiaTable* GetSandiaTable() const {return fSandiaTable;}
// Base material:
inline
const G4Material* GetBaseMaterial() const {return fBaseMaterial;}
// material components:
inline
std::map<G4Material*,G4double> GetMatComponents() const
{return fMatComponents;}
//for chemical compound
inline
G4double GetMassOfMolecule() const {return fMassOfMolecule;}
//meaningful only for single material:
G4double GetZ() const;
G4double GetA() const;
//the MaterialPropertiesTable (if any) attached to this material:
inline void SetMaterialPropertiesTable(G4MaterialPropertiesTable* anMPT)
{fMaterialPropertiesTable = anMPT;}
inline G4MaterialPropertiesTable* GetMaterialPropertiesTable() const
{return fMaterialPropertiesTable;}
//the (static) Table of Materials:
//
static const G4MaterialTable* GetMaterialTable();
static size_t GetNumberOfMaterials();
//the index of this material in the Table:
inline size_t GetIndex() const {return fIndexInTable;}
//return pointer to a material, given its name:
static G4Material* GetMaterial(const G4String& name, G4bool warning=true);
//
//printing methods
//
friend std::ostream& operator<<(std::ostream&, G4Material*);
friend std::ostream& operator<<(std::ostream&, G4Material&);
friend std::ostream& operator<<(std::ostream&, G4MaterialTable);
public: // without description
G4int operator==(const G4Material&) const;
G4int operator!=(const G4Material&) const;
G4Material(__void__&);
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects.
inline void SetName (const G4String& name) {fName=name;}
private:
G4Material(const G4Material&);
const G4Material& operator=(const G4Material&);
void InitializePointers();
// Header routine for all derived quantities
void ComputeDerivedQuantities();
// Compute Radiation length
void ComputeRadiationLength();
// Compute Nuclear interaction length
void ComputeNuclearInterLength();
// Copy pointers of base material
void CopyPointersOfBaseMaterial();
private:
//
// Basic data members ( To define a material)
//
G4String fName; // Material name
G4String fChemicalFormula; // Material chemical formula
G4double fDensity; // Material density
G4State fState; // Material state (determined
// internally based on density)
G4double fTemp; // Temperature (defaults: STP)
G4double fPressure; // Pressure (defaults: STP)
G4int maxNbComponents; // totalNbOfComponentsInTheMaterial
G4int fArrayLength; // the length of fAtomsVector
size_t fNumberOfComponents; // Nb of components declared so far
size_t fNumberOfElements; // Nb of Elements in the material
G4ElementVector* theElementVector; // vector of constituent Elements
G4bool fImplicitElement; // implicit Element created by this?
G4double* fMassFractionVector; // composition by fractional mass
G4int* fAtomsVector; // composition by atom count
G4MaterialPropertiesTable* fMaterialPropertiesTable;
static
G4MaterialTable theMaterialTable; // the material table
size_t fIndexInTable; // the position in the table
//
// Derived data members (computed from the basic data members)
//
// some general atomic properties
G4double* VecNbOfAtomsPerVolume; // vector of nb of atoms per volume
G4double TotNbOfAtomsPerVolume; // total nb of atoms per volume
G4double TotNbOfElectPerVolume; // total nb of electrons per volume
G4double fRadlen; // Radiation length
G4double fNuclInterLen; // Nuclear interaction length
G4IonisParamMat* fIonisation; // ionisation parameters
G4SandiaTable* fSandiaTable; // Sandia table
// utilities
//
const G4Material* fBaseMaterial; // Pointer to the base material
G4double fMassOfMolecule; // for materials built by atoms count
std::map<G4Material*,G4double> fMatComponents; // for composites built via
// AddMaterial()
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif