lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
de4f28d823f824725898d2ee37aaca96b10a1386
geant4/source/processes/hadronic/util/src/G4HadronicDeveloperParameters.cc
T
Gabriele Cosmo fc6af9e721 Import Geant4 10.4.0 source tree
2017-12-08 12:52:30 +01:00

340 lines
13 KiB
C++
Raw Blame History

//
// ********************************************************************
// * 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. *
// ********************************************************************
//
#include"G4HadronicDeveloperParameters.hh"
G4HadronicDeveloperParameters& G4HadronicDeveloperParameters::GetInstance(){
static G4HadronicDeveloperParameters instance;
return instance;
}
G4HadronicDeveloperParameters::G4HadronicDeveloperParameters(){
}
G4HadronicDeveloperParameters::G4HadronicDeveloperParameters( const G4HadronicDeveloperParameters& ){
}
G4bool G4HadronicDeveloperParameters::SetDefault( const std::string name , const G4bool value ){
G4bool status = false;
const std::map< std::string , const G4bool >::iterator it = b_defaults.find( name );
if ( it == b_defaults.end() ) {
status = true;
b_defaults.insert( std::pair<std::string, const G4bool>( name , value ) );
b_values.insert( std::pair<std::string, G4bool>( name , value ) );
} else {
/*error*/
issue_is_already_defined( name );
}
return status;
}
G4bool G4HadronicDeveloperParameters::SetDefault( const std::string name , const G4int value , G4int lower_limit , G4int upper_limit ){
G4bool status = false;
const std::map< std::string , const G4int >::iterator it = i_defaults.find( name );
if ( it == i_defaults.end() ) {
status = true;
i_defaults.insert( std::pair<std::string, const G4int>( name , value ) );
i_values.insert( std::pair<std::string, G4int>( name , value ) );
i_limits.insert( std::pair< std::string,std::pair< const G4int , const G4int> >( name, std::pair< const G4int , const G4int> ( lower_limit , upper_limit ) ) );
} else {
/*error*/
issue_is_already_defined( name );
}
return status;
}
G4bool G4HadronicDeveloperParameters::SetDefault( const std::string name , const G4double value , G4double lower_limit , G4double upper_limit ){
G4bool status = false;
const std::map< std::string , const G4double >::iterator it = defaults.find( name );
if ( it == defaults.end() ) {
status = true;
defaults.insert( std::pair<std::string, const G4double>( name , value ) );
values.insert( std::pair<std::string, G4double>( name , value ) );
limits.insert( std::pair< std::string,std::pair< const G4double , const G4double> >( name, std::pair< const G4double , const G4double> ( lower_limit , upper_limit ) ) );
} else {
/*error*/
issue_is_already_defined( name );
}
return status;
}
G4bool G4HadronicDeveloperParameters::Set( const std::string name , const G4bool value ){
G4bool status = false;
const std::map<std::string,G4bool>::iterator it = b_values.find( name );
if ( it != b_values.end() ) {
if ( it->second == b_defaults.find(name)->second ) {
status = true;
it->second = value;
} else {
/*change more than once*/
issue_has_changed( name );
}
} else {
/*Parameter of "name" does not exist*/
issue_no_param( name );
}
return status;
}
G4bool G4HadronicDeveloperParameters::Set( const std::string name , const G4int value ){
G4bool status = false;
const std::map<std::string,G4int>::iterator it = i_values.find( name );
if ( it != i_values.end() ) {
if ( it->second == i_defaults.find(name)->second ) {
if ( check_value_within_limits( i_limits.find(name)->second , value ) ) {
/*value is OK*/
status = true;
it->second = value;
} else {
/*Value is outside of valid range*/
issue_non_eligible_value( name );
}
} else {
/*change more than once*/
issue_has_changed( name );
}
} else {
/*Parameter of "name" does not exist*/
issue_no_param( name );
}
return status;
}
G4bool G4HadronicDeveloperParameters::Set( const std::string name , const G4double value ){
G4bool status = false;
const std::map<std::string,G4double>::iterator it = values.find( name );
if ( it != values.end() ) {
if ( it->second == defaults.find(name)->second ) {
if ( check_value_within_limits( limits.find(name)->second , value ) ) {
/*value is OK*/
status = true;
it->second = value;
} else {
/*Value is outside of valid range*/
issue_non_eligible_value( name );
}
} else {
/*change more than once*/
issue_has_changed( name );
}
} else {
/*Parameter of "name" does not exist*/
issue_no_param( name );
}
return status;
}
G4bool G4HadronicDeveloperParameters::GetDefault( const std::string name , G4bool& value ) {
G4bool status = false;
const std::map<std::string,const G4bool>::iterator it = b_defaults.find( name );
if ( it != b_defaults.end() ) {
status = true;
value = it->second;
} else {
/*Parameter of "name" does not exist*/
issue_no_param( name );
}
return status;
}
G4bool G4HadronicDeveloperParameters::GetDefault( const std::string name , G4int& value ) {
G4bool status = false;
const std::map<std::string,const G4int>::iterator it = i_defaults.find( name );
if ( it != i_defaults.end() ) {
status = true;
value = it->second;
} else {
/*Parameter of "name" does not exist*/
issue_no_param( name );
}
return status;
}
G4bool G4HadronicDeveloperParameters::GetDefault( const std::string name , G4double& value ) {
G4bool status = false;
const std::map<std::string,const G4double>::iterator it = defaults.find( name );
if ( it != defaults.end() ) {
status = true;
value = it->second;
} else {
/*Parameter of "name" does not exist*/
issue_no_param( name );
}
return status;
}
G4bool G4HadronicDeveloperParameters::Get( const std::string name , G4double& value ) {
return get( name , value );
}
G4bool G4HadronicDeveloperParameters::DeveloperGet( const std::string name , G4double& value ) {
return get( name , value , true );
}
G4bool G4HadronicDeveloperParameters::get( const std::string name , G4bool& value , G4bool check_change ) {
G4bool status = false;
const std::map<std::string,G4bool>::iterator it = b_values.find( name );
if ( it != b_values.end() ) {
status = true;
value = it->second;
if ( check_change && value != b_defaults.find(name)->second ) {
//Parameter "name" has changed from default
issue_is_modified( name );
}
} else {
//Parameter of "name" does not exist
issue_no_param( name );
}
return status;
}
G4bool G4HadronicDeveloperParameters::Get( const std::string name , G4int& value ) {
return get( name , value );
}
G4bool G4HadronicDeveloperParameters::DeveloperGet( const std::string name , G4int& value ) {
return get( name , value , true );
}
G4bool G4HadronicDeveloperParameters::get( const std::string name , G4int& value , G4bool check_change ) {
G4bool status = false;
const std::map<std::string,G4int>::iterator it = i_values.find( name );
if ( it != i_values.end() ) {
status = true;
value = it->second;
if ( check_change && value != i_defaults.find(name)->second ) {
//Parameter "name" has changed from default
issue_is_modified( name );
}
} else {
//Parameter of "name" does not exist
issue_no_param( name );
}
return status;
}
G4bool G4HadronicDeveloperParameters::Get( const std::string name , G4bool& value ) {
return get( name , value );
}
G4bool G4HadronicDeveloperParameters::DeveloperGet( const std::string name , G4bool& value ) {
return get( name , value , true );
}
G4bool G4HadronicDeveloperParameters::get( const std::string name , G4double& value , G4bool check_change ) {
G4bool status = false;
const std::map<std::string,G4double>::iterator it = values.find( name );
if ( it != values.end() ) {
status = true;
value = it->second;
if ( check_change && value != defaults.find(name)->second ) {
/*Parameter "name" has changed from default*/
issue_is_modified( name );
}
} else {
/*Parameter of "name" does not exist*/
issue_no_param( name );
}
return status;
}
void G4HadronicDeveloperParameters::Dump( const std::string name ) {
//const std::map<std::string,G4double>::iterator it = values.find( name );
if ( b_values.find( name ) != b_values.end() ) {
G4cout << "G4HadronicDeveloperParameters: "
<< "name = " << name
<< ", default value = " << b_defaults.find( name )->second
<< ", current value = " << b_values.find( name )->second
<< "." << G4endl;
} else if ( i_values.find( name ) != i_values.end() ) {
G4cout << "G4HadronicDeveloperParameters: "
<< "name = " << name
<< ", default value = " << i_defaults.find( name )->second
<< ", lower limit = " << i_limits.find( name )->second.first
<< ", upper limit = " << i_limits.find( name )->second.second
<< ", current value = " << i_values.find( name )->second
<< "." << G4endl;
} else if ( values.find( name ) != values.end() ) {
G4cout << "G4HadronicDeveloperParameters: "
<< "name = " << name
<< ", default value = " << defaults.find( name )->second
<< ", lower limit = " << limits.find( name )->second.first
<< ", upper limit = " << limits.find( name )->second.second
<< ", current value = " << values.find( name )->second
<< "." << G4endl;
} else {
/*Parameter of "name" does not exist*/
issue_no_param( name );
}
}
G4bool G4HadronicDeveloperParameters::check_value_within_limits( std::pair<const G4double,const G4double>& alimits , const G4double value ){
if ( alimits.first <= value && value <= alimits.second ) {
return true;
} else {
return false;
}
}
G4bool G4HadronicDeveloperParameters::check_value_within_limits( std::pair<const G4int,const G4int>& alimits , const G4int value ){
if ( alimits.first <= value && value <= alimits.second ) {
return true;
} else {
return false;
}
}
void G4HadronicDeveloperParameters::issue_no_param( const std::string& name ){
std::string text("Parameter ");
text += name;
text += " does not exist.";
G4Exception( "G4HadronicDeveloperParameters" , "HadDevPara_001", FatalException , text.c_str() );
}
void G4HadronicDeveloperParameters::issue_has_changed( const std::string& name ) {
std::string text("Parameter ");
text += name;
text += " has already been changed once.";
G4Exception( "G4HadronicDeveloperParameters" , "HadDevPara_002", FatalException , text.c_str() );
}
void G4HadronicDeveloperParameters::issue_non_eligible_value( const std::string& name ) {
std::string text("The value of the parameter ");
text += name;
text += " is outside the allowable range.";
G4Exception( "G4HadronicDeveloperParameters" , "HadDevPara_003", FatalException , text.c_str() );
}
void G4HadronicDeveloperParameters::issue_is_already_defined( const std::string& name ) {
std::string text("Parameter ");
text += name;
text += " is already defined.";
G4Exception( "G4HadronicDeveloperParameters" , "HadDevPara_004", FatalException , text.c_str() );
}
void G4HadronicDeveloperParameters::issue_is_modified( const std::string& name ) {
std::string text("Parameter ");
text += name;
text += " has changed from default value.";
G4Exception( "G4HadronicDeveloperParameters" , "HadDevPara_005", JustWarning , text.c_str() );
}
Reference in New Issue View Git Blame Copy Permalink