#include <G4ParticleHPManager.hh>

Public Member Functions
G4ParticleHPReactionWhiteBoard *	GetReactionWhiteBoard ()

void	OpenReactionWhiteBoard ()

void	CloseReactionWhiteBoard ()

void	GetDataStream (G4String, std::istringstream &iss)

void	GetDataStream2 (G4String, std::istringstream &iss)

void	SetVerboseLevel (G4int i)

G4int	GetVerboseLevel ()

void	DumpDataSource ()

G4bool	GetUseOnlyPhotoEvaporation ()

void	SetUseOnlyPhotoEvaporation (G4bool val)

G4bool	GetSkipMissingIsotopes ()

G4bool	GetNeglectDoppler ()

G4bool	GetDoNotAdjustFinalState ()

G4bool	GetProduceFissionFragments ()

void	SetSkipMissingIsotopes (G4bool val)

void	SetNeglectDoppler (G4bool val)

void	SetDoNotAdjustFinalState (G4bool val)

void	SetProduceFissionFragments (G4bool val)

void	RegisterElasticCrossSections (G4PhysicsTable *val)

G4PhysicsTable *	GetElasticCrossSections ()

void	RegisterCaptureCrossSections (G4PhysicsTable *val)

G4PhysicsTable *	GetCaptureCrossSections ()

void	RegisterInelasticCrossSections (const G4ParticleDefinition , G4PhysicsTable )

G4PhysicsTable *	GetInelasticCrossSections (const G4ParticleDefinition *)

void	RegisterFissionCrossSections (G4PhysicsTable *val)

G4PhysicsTable *	GetFissionCrossSections ()

std::vector < G4ParticleHPChannel * > *	GetElasticFinalStates ()

void	RegisterElasticFinalStates (std::vector< G4ParticleHPChannel * > *val)

std::vector < G4ParticleHPChannelList * > *	GetInelasticFinalStates (const G4ParticleDefinition *)

void	RegisterInelasticFinalStates (const G4ParticleDefinition , std::vector< G4ParticleHPChannelList > *)

std::vector < G4ParticleHPChannel * > *	GetCaptureFinalStates ()

void	RegisterCaptureFinalStates (std::vector< G4ParticleHPChannel * > *val)

std::vector < G4ParticleHPChannel * > *	GetFissionFinalStates ()

void	RegisterFissionFinalStates (std::vector< G4ParticleHPChannel * > *val)

std::map< G4int, std::map < G4double, G4ParticleHPVector * > * > *	GetThermalScatteringCoherentCrossSections ()

void	RegisterThermalScatteringCoherentCrossSections (std::map< G4int, std::map< G4double, G4ParticleHPVector * > * > *val)

std::map< G4int, std::map < G4double, G4ParticleHPVector * > * > *	GetThermalScatteringIncoherentCrossSections ()

void	RegisterThermalScatteringIncoherentCrossSections (std::map< G4int, std::map< G4double, G4ParticleHPVector * > * > *val)

std::map< G4int, std::map < G4double, G4ParticleHPVector * > * > *	GetThermalScatteringInelasticCrossSections ()

void	RegisterThermalScatteringInelasticCrossSections (std::map< G4int, std::map< G4double, G4ParticleHPVector * > * > *val)

std::map< G4int, std::map < G4double, std::vector < std::pair< G4double, G4double > * > * > * > *	GetThermalScatteringCoherentFinalStates ()

void	RegisterThermalScatteringCoherentFinalStates (std::map< G4int, std::map< G4double, std::vector< std::pair< G4double, G4double > * > * > * > *val)

std::map< G4int, std::map < G4double, std::vector < E_isoAng * > * > * > *	GetThermalScatteringIncoherentFinalStates ()

void	RegisterThermalScatteringIncoherentFinalStates (std::map< G4int, std::map< G4double, std::vector< E_isoAng * > * > * > *val)

std::map< G4int, std::map < G4double, std::vector < E_P_E_isoAng * > * > * > *	GetThermalScatteringInelasticFinalStates ()

void	RegisterThermalScatteringInelasticFinalStates (std::map< G4int, std::map< G4double, std::vector< E_P_E_isoAng * > * > * > *val)

Static Public Member Functions
static G4ParticleHPManager *	GetInstance ()

Detailed Description

Definition at line 53 of file G4ParticleHPManager.hh.

Member Function Documentation

void G4ParticleHPManager::CloseReactionWhiteBoard ( )

Definition at line 93 of file G4ParticleHPManager.cc.

 {
    G4ParticleHPThreadLocalManager::GetInstance()->CloseReactionWhiteBoard();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4ParticleHPManager::DumpDataSource ( )

Definition at line 202 of file G4ParticleHPManager.cc.

 {
 
    G4cout << "Data source of this Partile HP calculation are " << G4endl;
    for (  std::map< G4String , G4String >::iterator 
           it = mDataEvaluation.begin() ; it != mDataEvaluation.end() ; it++ ) {
       G4cout << it->first << " " << it->second << G4endl;
    }
    G4cout << G4endl;
 }

G4PhysicsTable* G4ParticleHPManager::GetCaptureCrossSections ( )

inline

Definition at line 96 of file G4ParticleHPManager.hh.

96 { return theCaptureCrossSections; };

Here is the caller graph for this function:

std::vector<G4ParticleHPChannel*>* G4ParticleHPManager::GetCaptureFinalStates ( )

inline

Definition at line 106 of file G4ParticleHPManager.hh.

106 { return theCaptureFSs; };

Here is the caller graph for this function:

void G4ParticleHPManager::GetDataStream	(	G4String	filename,
		std::istringstream &	iss
	)

Definition at line 100 of file G4ParticleHPManager.cc.

 {
    G4String* data=NULL;
    G4String compfilename(filename);
    compfilename += ".z";
    std::ifstream* in = new std::ifstream ( compfilename , std::ios::binary | std::ios::ate );
    if ( in->good() )
    {
 // Use the compressed file 
       G4int file_size = in->tellg();
       in->seekg( 0 , std::ios::beg );
       Bytef* compdata = new Bytef[ file_size ];
 
       while ( *in ) { // Loop checking, 11.05.2015, T. Koi
          in->read( (char*)compdata , file_size );
       }
 
       uLongf complen = (uLongf) ( file_size*4 );
       Bytef* uncompdata = new Bytef[complen];
 
       while ( Z_OK != uncompress ( uncompdata , &complen , compdata , file_size ) ) { // Loop checking, 11.05.2015, T. Koi
          //G4cout << "Too small, retry 2 times bigger size." << G4endl;
          delete[] uncompdata;
          complen *= 2;
          uncompdata = new Bytef[complen];
       }
       delete [] compdata;
       //                                 Now "complen" has uncomplessed size
       data = new G4String ( (char*)uncompdata , (G4long)complen );
       delete [] uncompdata;
    } else {
 // Use regular text file 
       std::ifstream thefData( filename , std::ios::in | std::ios::ate );
       if ( thefData.good() ) {
          G4int file_size = thefData.tellg();
          thefData.seekg( 0 , std::ios::beg );
          char* filedata = new char[ file_size ];
          while ( thefData ) { // Loop checking, 11.05.2015, T. Koi
             thefData.read( filedata , file_size );
          }
          thefData.close();
          data = new G4String ( filedata , file_size );
          delete [] filedata;
       } else {
 // found no data file
 //                 set error bit to the stream   
          iss.setstate( std::ios::badbit ); 
       }
    }
    if ( data != NULL ) {
       iss.str(*data);
       G4String id;
       iss >> id;
       if ( id == "G4NDL" ) {
          //Register information of file
          G4String source;
          iss >> source;
          register_data_file(filename,source);
       } else {
          iss.seekg( 0 , std::ios::beg );
       }
    }
    //G4cout << iss.rdbuf()->in_avail() << G4endl;
    in->close(); delete in;
    delete data;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4ParticleHPManager::GetDataStream2	(	G4String	filename,
		std::istringstream &	iss
	)

Definition at line 167 of file G4ParticleHPManager.cc.

 {
    G4String compfilename(filename);
    compfilename += ".z";
    std::ifstream* in = new std::ifstream ( compfilename , std::ios::binary | std::ios::ate );
    if ( in->good() )
    {
 // Compressed file is exist 
       in->close(); 
    } else {
       std::ifstream thefData( filename , std::ios::in | std::ios::ate );
       if ( thefData.good() ) {
 // Regular text file is exist
          thefData.close();
       } else {
 // found no data file
 //                 set error bit to the stream   
          iss.setstate( std::ios::badbit ); 
       }
    }
    delete in;
 }

Here is the caller graph for this function:

G4bool G4ParticleHPManager::GetDoNotAdjustFinalState ( )

inline

Definition at line 85 of file G4ParticleHPManager.hh.

85 { return DO_NOT_ADJUST_FINAL_STATE; };

G4PhysicsTable* G4ParticleHPManager::GetElasticCrossSections ( )

inline

Definition at line 94 of file G4ParticleHPManager.hh.

94 { return theElasticCrossSections; };

Here is the caller graph for this function:

std::vector<G4ParticleHPChannel*>* G4ParticleHPManager::GetElasticFinalStates ( )

inline

Definition at line 102 of file G4ParticleHPManager.hh.

102 { return theElasticFSs; };

Here is the caller graph for this function:

G4PhysicsTable* G4ParticleHPManager::GetFissionCrossSections ( )

inline

Definition at line 100 of file G4ParticleHPManager.hh.

100 { return theFissionCrossSections; };

Here is the caller graph for this function:

std::vector<G4ParticleHPChannel*>* G4ParticleHPManager::GetFissionFinalStates ( )

inline

Definition at line 108 of file G4ParticleHPManager.hh.

108 { return theFissionFSs; };

Here is the caller graph for this function:

G4PhysicsTable * G4ParticleHPManager::GetInelasticCrossSections ( const G4ParticleDefinition * particle )

Definition at line 213 of file G4ParticleHPManager.cc.

                                                                                                    { 
    if ( theInelasticCrossSections.end() !=  theInelasticCrossSections.find( particle ) )
       return theInelasticCrossSections.find( particle )->second; 
    else 
       return NULL; 
 }

Here is the caller graph for this function:

std::vector< G4ParticleHPChannelList * > * G4ParticleHPManager::GetInelasticFinalStates ( const G4ParticleDefinition * particle )

Definition at line 224 of file G4ParticleHPManager.cc.

                                                                                                                       { 
    if ( theInelasticFSs.end() != theInelasticFSs.find( particle ) )
       return theInelasticFSs.find( particle )->second;
    else 
       return NULL;
 }

Here is the caller graph for this function:

static G4ParticleHPManager* G4ParticleHPManager::GetInstance ( )

inlinestatic

Definition at line 56 of file G4ParticleHPManager.hh.

                                                 {
          if ( instance == NULL) instance = new G4ParticleHPManager();
          return instance;
       };

Here is the caller graph for this function:

G4bool G4ParticleHPManager::GetNeglectDoppler ( )

inline

Definition at line 84 of file G4ParticleHPManager.hh.

84 { return NEGLECT_DOPPLER; };

G4bool G4ParticleHPManager::GetProduceFissionFragments ( )

inline

Definition at line 86 of file G4ParticleHPManager.hh.

86 { return PRODUCE_FISSION_FRAGMENTS; };

Here is the caller graph for this function:

G4ParticleHPReactionWhiteBoard * G4ParticleHPManager::GetReactionWhiteBoard ( )

Definition at line 84 of file G4ParticleHPManager.cc.

 {
 //   if ( RWB == NULL ) {
 //      G4cout << "Warning: try to access G4ParticleHPReactionWhiteBoard before opening" << G4endl;
 //      RWB = new G4ParticleHPReactionWhiteBoard();
 //   }
 //   return RWB; 
    return G4ParticleHPThreadLocalManager::GetInstance()->GetReactionWhiteBoard();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4ParticleHPManager::GetSkipMissingIsotopes ( )

inline

Definition at line 83 of file G4ParticleHPManager.hh.

83 { return SKIP_MISSING_ISOTOPES; };

Here is the caller graph for this function:

std::map<G4int,std::map<G4double,G4ParticleHPVector*>*>* G4ParticleHPManager::GetThermalScatteringCoherentCrossSections ( )

inline

Definition at line 111 of file G4ParticleHPManager.hh.

111 { return theTSCoherentCrossSections; };

Here is the caller graph for this function:

std::map< G4int , std::map < G4double , std::vector < std::pair< G4double , G4double >* >* >* >* G4ParticleHPManager::GetThermalScatteringCoherentFinalStates ( )

inline

Definition at line 118 of file G4ParticleHPManager.hh.

118 { return theTSCoherentFinalStates; };

std::map<G4int,std::map<G4double,G4ParticleHPVector*>*>* G4ParticleHPManager::GetThermalScatteringIncoherentCrossSections ( )

inline

Definition at line 113 of file G4ParticleHPManager.hh.

113 { return theTSIncoherentCrossSections; };

Here is the caller graph for this function:

std::map< G4int , std::map < G4double , std::vector < E_isoAng* >* >* >* G4ParticleHPManager::GetThermalScatteringIncoherentFinalStates ( )

inline

Definition at line 120 of file G4ParticleHPManager.hh.

120 { return theTSIncoherentFinalStates; };

std::map<G4int,std::map<G4double,G4ParticleHPVector*>*>* G4ParticleHPManager::GetThermalScatteringInelasticCrossSections ( )

inline

Definition at line 115 of file G4ParticleHPManager.hh.

115 { return theTSInelasticCrossSections; };

Here is the caller graph for this function:

std::map< G4int , std::map < G4double , std::vector < E_P_E_isoAng* >* >* >* G4ParticleHPManager::GetThermalScatteringInelasticFinalStates ( )

inline

Definition at line 122 of file G4ParticleHPManager.hh.

122 { return theTSInelasticFinalStates; };

G4bool G4ParticleHPManager::GetUseOnlyPhotoEvaporation ( )

inline

Definition at line 81 of file G4ParticleHPManager.hh.

81 { return USE_ONLY_PHOTONEVAPORATION; };

G4int G4ParticleHPManager::GetVerboseLevel ( )

inline

Definition at line 77 of file G4ParticleHPManager.hh.

77 {return verboseLevel; };

Here is the caller graph for this function:

void G4ParticleHPManager::OpenReactionWhiteBoard ( )

Definition at line 74 of file G4ParticleHPManager.cc.

 {
 //   if ( RWB != NULL ) {
 //      G4cout << "Warning: G4ParticleHPReactionWhiteBoard is tried doubly opening" << G4endl;
 //      RWB = new G4ParticleHPReactionWhiteBoard();
 //   }
 //   
 //   RWB = new G4ParticleHPReactionWhiteBoard();
    G4ParticleHPThreadLocalManager::GetInstance()->OpenReactionWhiteBoard();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4ParticleHPManager::RegisterCaptureCrossSections ( G4PhysicsTable * val )

inline

Definition at line 95 of file G4ParticleHPManager.hh.

95 { theCaptureCrossSections = val; };

Here is the caller graph for this function:

void G4ParticleHPManager::RegisterCaptureFinalStates ( std::vector< G4ParticleHPChannel * > * val )

inline

Definition at line 107 of file G4ParticleHPManager.hh.

107 { theCaptureFSs = val; };

Here is the caller graph for this function:

void G4ParticleHPManager::RegisterElasticCrossSections ( G4PhysicsTable * val )

inline

Definition at line 93 of file G4ParticleHPManager.hh.

93 { theElasticCrossSections = val; };

Here is the caller graph for this function:

void G4ParticleHPManager::RegisterElasticFinalStates ( std::vector< G4ParticleHPChannel * > * val )

inline

Definition at line 103 of file G4ParticleHPManager.hh.

103 { theElasticFSs = val; };

Here is the caller graph for this function:

void G4ParticleHPManager::RegisterFissionCrossSections ( G4PhysicsTable * val )

inline

Definition at line 99 of file G4ParticleHPManager.hh.

99 { theFissionCrossSections = val; };

Here is the caller graph for this function:

void G4ParticleHPManager::RegisterFissionFinalStates ( std::vector< G4ParticleHPChannel * > * val )

inline

Definition at line 109 of file G4ParticleHPManager.hh.

109 { theFissionFSs = val; };

Here is the caller graph for this function:

void G4ParticleHPManager::RegisterInelasticCrossSections	(	const G4ParticleDefinition *	particle,
		G4PhysicsTable *	val
	)

Definition at line 220 of file G4ParticleHPManager.cc.

                                                                                                                    { 
    theInelasticCrossSections.insert( std::pair<const G4ParticleDefinition* , G4PhysicsTable* >( particle , val ) ); 
 }

Here is the caller graph for this function:

void G4ParticleHPManager::RegisterInelasticFinalStates	(	const G4ParticleDefinition *	particle,
		std::vector< G4ParticleHPChannelList * > *	val
	)

Definition at line 231 of file G4ParticleHPManager.cc.

                                                                                                                                         { 
    theInelasticFSs.insert ( std::pair<const G4ParticleDefinition*,std::vector<G4ParticleHPChannelList*>*>( particle , val ) ); 
 }

Here is the caller graph for this function:

void G4ParticleHPManager::RegisterThermalScatteringCoherentCrossSections ( std::map< G4int, std::map< G4double, G4ParticleHPVector * > * > * val )

inline

Definition at line 112 of file G4ParticleHPManager.hh.

112 { theTSCoherentCrossSections = val; };

Here is the caller graph for this function:

void G4ParticleHPManager::RegisterThermalScatteringCoherentFinalStates ( std::map< G4int, std::map< G4double, std::vector< std::pair< G4double, G4double > * > * > * > * val )

inline

Definition at line 119 of file G4ParticleHPManager.hh.

119 { theTSCoherentFinalStates = val; };

void G4ParticleHPManager::RegisterThermalScatteringIncoherentCrossSections ( std::map< G4int, std::map< G4double, G4ParticleHPVector * > * > * val )

inline

Definition at line 114 of file G4ParticleHPManager.hh.

114 { theTSIncoherentCrossSections = val; };

Here is the caller graph for this function:

void G4ParticleHPManager::RegisterThermalScatteringIncoherentFinalStates ( std::map< G4int, std::map< G4double, std::vector< E_isoAng * > * > * > * val )

inline

Definition at line 121 of file G4ParticleHPManager.hh.

121 { theTSIncoherentFinalStates = val; };

void G4ParticleHPManager::RegisterThermalScatteringInelasticCrossSections ( std::map< G4int, std::map< G4double, G4ParticleHPVector * > * > * val )

inline

Definition at line 116 of file G4ParticleHPManager.hh.

116 { theTSInelasticCrossSections = val; };

Here is the caller graph for this function:

void G4ParticleHPManager::RegisterThermalScatteringInelasticFinalStates ( std::map< G4int, std::map< G4double, std::vector< E_P_E_isoAng * > * > * > * val )

inline

Definition at line 123 of file G4ParticleHPManager.hh.

123 { theTSInelasticFinalStates = val; };

void G4ParticleHPManager::SetDoNotAdjustFinalState ( G4bool val )

inline

Definition at line 90 of file G4ParticleHPManager.hh.

90 { DO_NOT_ADJUST_FINAL_STATE = val; };

Here is the caller graph for this function:

void G4ParticleHPManager::SetNeglectDoppler ( G4bool val )

inline

Definition at line 89 of file G4ParticleHPManager.hh.

89 { NEGLECT_DOPPLER = val; };

Here is the caller graph for this function:

void G4ParticleHPManager::SetProduceFissionFragments ( G4bool val )

inline

Definition at line 91 of file G4ParticleHPManager.hh.

91 { PRODUCE_FISSION_FRAGMENTS = val; };

Here is the caller graph for this function:

void G4ParticleHPManager::SetSkipMissingIsotopes ( G4bool val )

inline

Definition at line 88 of file G4ParticleHPManager.hh.

88 { SKIP_MISSING_ISOTOPES = val; };

Here is the caller graph for this function:

void G4ParticleHPManager::SetUseOnlyPhotoEvaporation ( G4bool val )

inline

Definition at line 82 of file G4ParticleHPManager.hh.

82 { USE_ONLY_PHOTONEVAPORATION = val; };

Here is the caller graph for this function:

void G4ParticleHPManager::SetVerboseLevel ( G4int i )

Definition at line 190 of file G4ParticleHPManager.cc.

 {
    G4cout << "You are setting a new verbose level for Particle HP package." << G4endl;
    G4cout << "the new value will be used in whole of the Particle HP package, i.e., models and cross sections for Capture, Elastic, Fission and Inelastic interaction." << G4endl;
    verboseLevel = newValue;
 }

Here is the caller graph for this function:

The documentation for this class was generated from the following files:

geant4.10.03.p01/source/processes/hadronic/models/particle_hp/include/G4ParticleHPManager.hh
geant4.10.03.p01/source/processes/hadronic/models/particle_hp/src/G4ParticleHPManager.cc

Public Member Functions

Static Public Member Functions

Detailed Description

Member Function Documentation