Gabriele Cosmo
289 lines
12 KiB
C++
289 lines
12 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. *
|
|
// ********************************************************************
|
|
//
|
|
|
|
#ifndef G4ParticleHPManager_h
|
|
#define G4ParticleHPManager_h 1
|
|
|
|
// 121031 First implementation done by T. Koi (SLAC/PPA)
|
|
// P. Arce, June-2014 Conversion neutron_hp to particle_hp
|
|
// V. Ivanchenko, July-2023 Basic revision of particle HP classes
|
|
//
|
|
#include "G4ParticleHPReactionWhiteBoard.hh"
|
|
#include "globals.hh"
|
|
|
|
#include <map>
|
|
#include <vector>
|
|
|
|
class G4ParticleDefinition;
|
|
class G4ParticleHPChannel;
|
|
class G4ParticleHPChannelList;
|
|
class G4ParticleHPMessenger;
|
|
class G4ParticleHPVector;
|
|
class G4ParticleHPIsoProbabilityTable;
|
|
class G4PhysicsTable;
|
|
|
|
struct E_isoAng;
|
|
struct E_P_E_isoAng;
|
|
|
|
class G4ParticleHPManager
|
|
{
|
|
public:
|
|
|
|
static G4ParticleHPManager* GetInstance();
|
|
~G4ParticleHPManager();
|
|
|
|
G4ParticleHPReactionWhiteBoard* GetReactionWhiteBoard();
|
|
void OpenReactionWhiteBoard();
|
|
void CloseReactionWhiteBoard();
|
|
|
|
void GetDataStream(const G4String&, std::istringstream& iss);
|
|
void GetDataStream2(const G4String&, std::istringstream& iss);
|
|
void SetVerboseLevel(G4int i);
|
|
G4int GetVerboseLevel() const { return verboseLevel; }
|
|
|
|
void DumpDataSource() const;
|
|
|
|
G4bool GetUseOnlyPhotoEvaporation() const { return USE_ONLY_PHOTONEVAPORATION; }
|
|
G4bool GetSkipMissingIsotopes() const { return SKIP_MISSING_ISOTOPES; }
|
|
G4bool GetNeglectDoppler() const { return NEGLECT_DOPPLER; }
|
|
G4bool GetDoNotAdjustFinalState() const { return DO_NOT_ADJUST_FINAL_STATE; }
|
|
G4bool GetProduceFissionFragments() const { return PRODUCE_FISSION_FRAGMENTS; }
|
|
G4bool GetUseWendtFissionModel() const { return USE_WENDT_FISSION_MODEL; }
|
|
G4bool GetUseNRESP71Model() const { return USE_NRESP71_MODEL; }
|
|
G4bool GetUseDBRC() const { return USE_DBRC; }
|
|
G4bool GetCheckHPNames() const { return CHECK_HP_NAMES; }
|
|
G4bool GetPHPCheck() const { return PHP_CHECK; }
|
|
G4bool GetPHCUsePoisson() const { return PHP_USE_POISSON; }
|
|
G4bool GetDEBUG() const { return DEBUG; }
|
|
|
|
const G4String& GetNeutronHPPath() const { return fDataPath[0]; };
|
|
const G4String& GetParticleHPPath(const G4ParticleDefinition*) const;
|
|
G4int GetPHPIndex(const G4ParticleDefinition*) const;
|
|
|
|
void SetUseOnlyPhotoEvaporation(G4bool val) { USE_ONLY_PHOTONEVAPORATION = val; }
|
|
void SetSkipMissingIsotopes(G4bool val) { SKIP_MISSING_ISOTOPES = val; }
|
|
void SetNeglectDoppler(G4bool val) { NEGLECT_DOPPLER = val; }
|
|
void SetDoNotAdjustFinalState(G4bool val) { DO_NOT_ADJUST_FINAL_STATE = val; }
|
|
void SetProduceFissionFragments(G4bool val)
|
|
{
|
|
// Make sure both fission fragment models are not active at same time
|
|
PRODUCE_FISSION_FRAGMENTS = USE_WENDT_FISSION_MODEL ? false : val;
|
|
}
|
|
void SetUseWendtFissionModel(G4bool val)
|
|
{
|
|
USE_WENDT_FISSION_MODEL = val;
|
|
// Make sure both fission fragment models are not active at same time
|
|
if (USE_WENDT_FISSION_MODEL) PRODUCE_FISSION_FRAGMENTS = false;
|
|
}
|
|
void SetUseNRESP71Model(G4bool val) { USE_NRESP71_MODEL = val; }
|
|
void SetUseDBRC(G4bool val) { USE_DBRC = val; }
|
|
|
|
void DumpSetting();
|
|
|
|
void RegisterElasticCrossSections(G4PhysicsTable* val) { theElasticCrossSections = val; }
|
|
G4PhysicsTable* GetElasticCrossSections() const { return theElasticCrossSections; }
|
|
void RegisterCaptureCrossSections(G4PhysicsTable* val) { theCaptureCrossSections = val; }
|
|
G4PhysicsTable* GetCaptureCrossSections() const { return theCaptureCrossSections; }
|
|
void RegisterInelasticCrossSections(const G4ParticleDefinition* part, G4PhysicsTable* ptr)
|
|
{
|
|
theInelasticCrossSections[GetPHPIndex(part)] = ptr;
|
|
}
|
|
G4PhysicsTable* GetInelasticCrossSections(const G4ParticleDefinition* part) const
|
|
{
|
|
return theInelasticCrossSections[GetPHPIndex(part)];
|
|
}
|
|
void RegisterFissionCrossSections(G4PhysicsTable* val) { theFissionCrossSections = val; }
|
|
G4PhysicsTable* GetFissionCrossSections() const { return theFissionCrossSections; }
|
|
|
|
std::vector<G4ParticleHPChannel*>* GetElasticFinalStates() const { return theElasticFSs; }
|
|
void RegisterElasticFinalStates(std::vector<G4ParticleHPChannel*>* val)
|
|
{
|
|
theElasticFSs = val;
|
|
}
|
|
|
|
std::vector<G4ParticleHPChannelList*>*
|
|
GetInelasticFinalStates(const G4ParticleDefinition* part) const
|
|
{
|
|
return theInelasticFSs[GetPHPIndex(part)];
|
|
}
|
|
void RegisterInelasticFinalStates(const G4ParticleDefinition* part,
|
|
std::vector<G4ParticleHPChannelList*>* ptr)
|
|
{
|
|
theInelasticFSs[GetPHPIndex(part)] = ptr;
|
|
}
|
|
|
|
std::vector<G4ParticleHPChannel*>* GetCaptureFinalStates() const { return theCaptureFSs; }
|
|
void RegisterCaptureFinalStates(std::vector<G4ParticleHPChannel*>* val)
|
|
{
|
|
theCaptureFSs = val;
|
|
}
|
|
std::vector<G4ParticleHPChannel*>* GetFissionFinalStates() const { return theFissionFSs; }
|
|
void RegisterFissionFinalStates(std::vector<G4ParticleHPChannel*>* val)
|
|
{
|
|
theFissionFSs = val;
|
|
}
|
|
|
|
std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>*
|
|
GetThermalScatteringCoherentCrossSections() const
|
|
{
|
|
return theTSCoherentCrossSections;
|
|
}
|
|
void RegisterThermalScatteringCoherentCrossSections(
|
|
std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>* val)
|
|
{
|
|
theTSCoherentCrossSections = val;
|
|
}
|
|
std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>*
|
|
GetThermalScatteringIncoherentCrossSections() const
|
|
{
|
|
return theTSIncoherentCrossSections;
|
|
}
|
|
void RegisterThermalScatteringIncoherentCrossSections(
|
|
std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>* val)
|
|
{
|
|
theTSIncoherentCrossSections = val;
|
|
}
|
|
std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>*
|
|
GetThermalScatteringInelasticCrossSections() const
|
|
{
|
|
return theTSInelasticCrossSections;
|
|
}
|
|
void RegisterThermalScatteringInelasticCrossSections(
|
|
std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>* val)
|
|
{
|
|
theTSInelasticCrossSections = val;
|
|
}
|
|
|
|
std::map<G4int, std::map<G4double, std::vector<std::pair<G4double, G4double>*>*>*>*
|
|
GetThermalScatteringCoherentFinalStates() const
|
|
{
|
|
return theTSCoherentFinalStates;
|
|
}
|
|
void RegisterThermalScatteringCoherentFinalStates(
|
|
std::map<G4int, std::map<G4double, std::vector<std::pair<G4double, G4double>*>*>*>* val)
|
|
{
|
|
theTSCoherentFinalStates = val;
|
|
}
|
|
std::map<G4int, std::map<G4double, std::vector<E_isoAng*>*>*>*
|
|
GetThermalScatteringIncoherentFinalStates() const
|
|
{
|
|
return theTSIncoherentFinalStates;
|
|
}
|
|
void RegisterThermalScatteringIncoherentFinalStates(
|
|
std::map<G4int, std::map<G4double, std::vector<E_isoAng*>*>*>* val)
|
|
{
|
|
theTSIncoherentFinalStates = val;
|
|
}
|
|
std::map<G4int, std::map<G4double, std::vector<E_P_E_isoAng*>*>*>*
|
|
GetThermalScatteringInelasticFinalStates() const
|
|
{
|
|
return theTSInelasticFinalStates;
|
|
}
|
|
void RegisterThermalScatteringInelasticFinalStates(
|
|
std::map<G4int, std::map<G4double, std::vector<E_P_E_isoAng*>*>*>* val)
|
|
{
|
|
theTSInelasticFinalStates = val;
|
|
}
|
|
|
|
std::vector< std::map< G4int, G4ParticleHPIsoProbabilityTable* > >* GetProbabilityTables() const
|
|
{ return theProbabilityTables; }
|
|
void RegisterProbabilityTables( std::vector< std::map< G4int, G4ParticleHPIsoProbabilityTable* > >* val )
|
|
{ theProbabilityTables = val; }
|
|
|
|
std::vector< std::pair< G4double, G4double > >* GetURRlimits() const { return theURRlimits; }
|
|
void RegisterURRlimits( std::vector< std::pair< G4double, G4double > >* val ) { theURRlimits = val; }
|
|
|
|
G4double GetMinADBRC() const { return theMinADBRC; }
|
|
G4double GetMinEnergyDBRC() const { return theMinEnergyDBRC; }
|
|
G4double GetMaxEnergyDBRC() const { return theMaxEnergyDBRC; }
|
|
G4double GetMaxEnergyDoppler() const { return theMaxEnergyDoppler; }
|
|
|
|
void SetMinADBRC(G4double val) { theMinADBRC = val; }
|
|
void SetMinEnergyDBRC(G4double val) { theMinEnergyDBRC = val; }
|
|
void SetMaxEnergyDBRC(G4double val) { theMaxEnergyDBRC = val; }
|
|
void SetMaxEnergyDoppler(G4double val) { theMaxEnergyDoppler = val; }
|
|
|
|
G4ParticleHPManager(G4ParticleHPManager &) = delete;
|
|
G4ParticleHPManager & operator=(const G4ParticleHPManager &right) = delete;
|
|
|
|
private:
|
|
|
|
G4ParticleHPManager();
|
|
void register_data_file(const G4String&, const G4String&);
|
|
|
|
static G4ParticleHPManager* instance;
|
|
|
|
std::map<G4String, G4String> mDataEvaluation;
|
|
|
|
G4int verboseLevel{1};
|
|
|
|
G4ParticleHPMessenger* messenger;
|
|
G4bool USE_ONLY_PHOTONEVAPORATION{false};
|
|
G4bool SKIP_MISSING_ISOTOPES{false};
|
|
G4bool NEGLECT_DOPPLER{false};
|
|
G4bool DO_NOT_ADJUST_FINAL_STATE{false};
|
|
G4bool PRODUCE_FISSION_FRAGMENTS{false};
|
|
G4bool USE_WENDT_FISSION_MODEL{false};
|
|
G4bool USE_NRESP71_MODEL{false};
|
|
G4bool USE_DBRC{false};
|
|
G4bool CHECK_HP_NAMES{false};
|
|
G4bool PHP_CHECK{true};
|
|
G4bool PHP_USE_POISSON{false};
|
|
G4bool DEBUG{false};
|
|
G4bool isPrinted{false};
|
|
|
|
G4PhysicsTable* theElasticCrossSections{nullptr};
|
|
G4PhysicsTable* theCaptureCrossSections{nullptr};
|
|
G4PhysicsTable* theInelasticCrossSections[6]{nullptr};
|
|
G4PhysicsTable* theFissionCrossSections{nullptr};
|
|
|
|
std::vector<G4ParticleHPChannel*>* theElasticFSs{nullptr};
|
|
std::vector<G4ParticleHPChannelList*>* theInelasticFSs[6]{nullptr};
|
|
std::vector<G4ParticleHPChannel*>* theCaptureFSs{nullptr};
|
|
std::vector<G4ParticleHPChannel*>* theFissionFSs{nullptr};
|
|
|
|
std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>* theTSCoherentCrossSections{nullptr};
|
|
std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>* theTSIncoherentCrossSections{nullptr};
|
|
std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>* theTSInelasticCrossSections{nullptr};
|
|
|
|
std::map<G4int, std::map<G4double, std::vector<std::pair<G4double, G4double>*>*>*>*
|
|
theTSCoherentFinalStates{nullptr};
|
|
std::map<G4int, std::map<G4double, std::vector<E_isoAng*>*>*>* theTSIncoherentFinalStates{nullptr};
|
|
std::map<G4int, std::map<G4double, std::vector<E_P_E_isoAng*>*>*>* theTSInelasticFinalStates{nullptr};
|
|
|
|
G4double theMinADBRC{200.};
|
|
G4double theMinEnergyDBRC;
|
|
G4double theMaxEnergyDBRC;
|
|
G4double theMaxEnergyDoppler;
|
|
|
|
G4String fDataPath[6]{""};
|
|
|
|
std::vector< std::map< G4int, G4ParticleHPIsoProbabilityTable* > >* theProbabilityTables{nullptr};
|
|
std::vector< std::pair< G4double, G4double > >* theURRlimits{nullptr};
|
|
|
|
};
|
|
#endif
|