Gabriele Cosmo
229 lines
6.6 KiB
C++
229 lines
6.6 KiB
C++
//
|
|
// ********************************************************************
|
|
// * 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. *
|
|
// ********************************************************************
|
|
//
|
|
//
|
|
// -------------------------------------------------------------------
|
|
//
|
|
// GEANT4 header file
|
|
//
|
|
// File name: G4LevelManager
|
|
//
|
|
// Author: V.Ivanchenko
|
|
//
|
|
// Creation date: 4 January 2012
|
|
//
|
|
// Modifications:
|
|
// 13.02.2015 Design change for gamma de-excitation
|
|
//
|
|
// -------------------------------------------------------------------
|
|
//
|
|
// Nuclear level manager for photon de-excitation process
|
|
//
|
|
|
|
#ifndef G4LEVELMANAGER_HH
|
|
#define G4LEVELMANAGER_HH 1
|
|
|
|
#include "globals.hh"
|
|
#include "G4NucLevel.hh"
|
|
#include <vector>
|
|
#include <iostream>
|
|
|
|
class G4LevelManager
|
|
{
|
|
|
|
public:
|
|
// levels - vector of nuclear level objects, ground state
|
|
// level has NULL pointer
|
|
// energies - list of excitation energies of nuclear levels starting
|
|
// from the ground state with energy zero
|
|
// spin - 2J, where J is the full angular momentum of the state
|
|
explicit G4LevelManager(G4int Z, G4int A, size_t nlev,
|
|
const std::vector<G4double>& energies,
|
|
const std::vector<G4int>& spin,
|
|
const std::vector<const G4NucLevel*>& levels);
|
|
|
|
~G4LevelManager();
|
|
|
|
//===================================================================
|
|
// run time inlined const functions
|
|
//===================================================================
|
|
|
|
inline size_t NumberOfTransitions() const;
|
|
|
|
inline const G4NucLevel* GetLevel(size_t i) const;
|
|
|
|
inline G4double LevelEnergy(size_t i) const;
|
|
|
|
inline G4double MaxLevelEnergy() const;
|
|
|
|
size_t NearestLevelIndex(G4double energy, size_t index=0) const;
|
|
|
|
inline size_t NearestLowEdgeLevelIndex(G4double energy) const;
|
|
|
|
inline const G4NucLevel* NearestLevel(G4double energy, size_t index=0) const;
|
|
|
|
inline G4double NearestLevelEnergy(G4double energy, size_t index=0) const;
|
|
|
|
inline G4double NearestLowEdgeLevelEnergy(G4double energy) const;
|
|
|
|
// for stable isotopes life time is -1
|
|
inline G4double LifeTime(size_t i) const;
|
|
|
|
inline G4int SpinTwo(size_t i) const;
|
|
|
|
inline G4int Parity(size_t i) const;
|
|
|
|
inline G4int FloatingLevel(size_t i) const;
|
|
|
|
inline G4double ShellCorrection() const;
|
|
|
|
inline G4double LevelDensity(G4double U) const;
|
|
|
|
const G4String& FloatingType(size_t i) const;
|
|
|
|
void StreamInfo(std::ostream& os) const;
|
|
|
|
private:
|
|
|
|
#ifdef G4VERBOSE
|
|
void PrintError(size_t idx, const G4String&) const;
|
|
#endif
|
|
|
|
G4LevelManager(const G4LevelManager & right) = delete;
|
|
const G4LevelManager& operator=(const G4LevelManager &right) = delete;
|
|
G4bool operator==(const G4LevelManager &right) const = delete;
|
|
G4bool operator!=(const G4LevelManager &right) const = delete;
|
|
|
|
std::vector<G4double> fLevelEnergy;
|
|
std::vector<G4int> fSpin;
|
|
std::vector<const G4NucLevel*> fLevels;
|
|
|
|
G4double fShellCorrection;
|
|
G4double fLevelDensity;
|
|
|
|
size_t nTransitions;
|
|
|
|
static const G4int nfloting = 13;
|
|
static G4String fFloatingLevels[nfloting];
|
|
|
|
};
|
|
|
|
inline size_t G4LevelManager::NumberOfTransitions() const
|
|
{
|
|
return nTransitions;
|
|
}
|
|
|
|
inline const G4NucLevel* G4LevelManager::GetLevel(size_t i) const
|
|
{
|
|
#ifdef G4VERBOSE
|
|
if(i > nTransitions) { PrintError(i, "GetLevel(idx)"); }
|
|
#endif
|
|
return fLevels[i];
|
|
}
|
|
|
|
inline G4double G4LevelManager::LevelEnergy(size_t i) const
|
|
{
|
|
#ifdef G4VERBOSE
|
|
if(i > nTransitions) { PrintError(i, "LevelEnergy(idx)"); }
|
|
#endif
|
|
return fLevelEnergy[i];
|
|
}
|
|
|
|
inline G4double G4LevelManager::MaxLevelEnergy() const
|
|
{
|
|
return fLevelEnergy[nTransitions];
|
|
}
|
|
|
|
inline size_t G4LevelManager::NearestLowEdgeLevelIndex(G4double energy) const
|
|
{
|
|
size_t idx = nTransitions;
|
|
if(energy < fLevelEnergy[nTransitions]) {
|
|
idx = std::lower_bound(fLevelEnergy.begin(), fLevelEnergy.end(), energy)
|
|
- fLevelEnergy.begin() - 1;
|
|
}
|
|
return idx;
|
|
}
|
|
|
|
inline const G4NucLevel*
|
|
G4LevelManager::NearestLevel(G4double energy, size_t index) const
|
|
{
|
|
return GetLevel(NearestLevelIndex(energy, index));
|
|
}
|
|
|
|
inline G4double
|
|
G4LevelManager::NearestLevelEnergy(G4double energy, size_t index) const
|
|
{
|
|
return LevelEnergy(NearestLevelIndex(energy, index));
|
|
}
|
|
|
|
inline G4double G4LevelManager::NearestLowEdgeLevelEnergy(G4double energy) const
|
|
{
|
|
return LevelEnergy(NearestLowEdgeLevelIndex(energy));
|
|
}
|
|
|
|
inline G4double G4LevelManager::LifeTime(size_t i) const
|
|
{
|
|
#ifdef G4VERBOSE
|
|
if(i > nTransitions) { PrintError(i, "LifeTime"); }
|
|
#endif
|
|
return (fLevels[i]) ? fLevels[i]->GetTimeGamma() : 0.0;
|
|
}
|
|
|
|
inline G4int G4LevelManager::SpinTwo(size_t i) const
|
|
{
|
|
#ifdef G4VERBOSE
|
|
if(i > nTransitions) { PrintError(i, "SpinTwo"); }
|
|
#endif
|
|
return std::abs(fSpin[i]%100000 - 100);
|
|
}
|
|
|
|
inline G4int G4LevelManager::Parity(size_t i) const
|
|
{
|
|
#ifdef G4VERBOSE
|
|
if(i > nTransitions) { PrintError(i, "SpinTwo"); }
|
|
#endif
|
|
return (fSpin[i]%100000 - 100 > 0) ? 1 : -1;
|
|
}
|
|
|
|
inline G4int G4LevelManager::FloatingLevel(size_t i) const
|
|
{
|
|
#ifdef G4VERBOSE
|
|
if(i > nTransitions) { PrintError(i, "Floating"); }
|
|
#endif
|
|
return fSpin[i]/100000;
|
|
}
|
|
|
|
inline G4double G4LevelManager::ShellCorrection() const
|
|
{
|
|
return fShellCorrection;
|
|
}
|
|
|
|
inline G4double G4LevelManager::LevelDensity(G4double) const
|
|
{
|
|
return fLevelDensity;
|
|
}
|
|
|
|
#endif
|