Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/hadronic/util/src/G4HadronicDeveloperParameters.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /processes/hadronic/util/src/G4HadronicDeveloperParameters.cc (Version 11.3.0) and /processes/hadronic/util/src/G4HadronicDeveloperParameters.cc (Version 10.7.p3)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 #include"G4HadronicDeveloperParameters.hh"         26 #include"G4HadronicDeveloperParameters.hh"
 27                                                    27 
 28 G4HadronicDeveloperParameters& G4HadronicDevel     28 G4HadronicDeveloperParameters& G4HadronicDeveloperParameters::GetInstance(){
 29     static  G4HadronicDeveloperParameters inst     29     static  G4HadronicDeveloperParameters instance;
 30     return instance;                               30     return instance;
 31 }                                                  31 }
 32                                                    32 
 33 G4HadronicDeveloperParameters::G4HadronicDevel     33 G4HadronicDeveloperParameters::G4HadronicDeveloperParameters(){
 34 }                                                  34 }
 35                                                    35 
 36 G4HadronicDeveloperParameters::G4HadronicDevel     36 G4HadronicDeveloperParameters::G4HadronicDeveloperParameters( const G4HadronicDeveloperParameters& ){ 
 37 }                                                  37 }
 38                                                    38 
 39 G4bool G4HadronicDeveloperParameters::SetDefau <<  39 G4bool G4HadronicDeveloperParameters::SetDefault( const std::string name , const G4bool value ){
 40    G4bool status = false;                          40    G4bool status = false;
 41    const std::map< G4String , const G4bool >:: <<  41    const std::map< std::string , const G4bool >::iterator it = b_defaults.find( name );
 42    if ( it == b_defaults.cend() ) {            <<  42    if ( it == b_defaults.end() ) {
 43       status = true;                               43       status = true;
 44       b_defaults.insert( std::pair<G4String, c <<  44       b_defaults.insert( std::pair<std::string, const G4bool>( name , value ) );
 45       b_values.insert( std::pair<G4String, G4b <<  45       b_values.insert( std::pair<std::string, G4bool>( name , value ) );
 46    } else {                                        46    } else {
 47             /*error*/                              47             /*error*/
 48       issue_is_already_defined( name );            48       issue_is_already_defined( name );
 49    }                                               49    }
 50    return status;                                  50    return status;
 51 }                                                  51 }
 52                                                    52 
 53 G4bool G4HadronicDeveloperParameters::SetDefau <<  53 G4bool G4HadronicDeveloperParameters::SetDefault( const std::string name , const G4int value , G4int lower_limit , G4int upper_limit ){
 54    G4bool status = false;                          54    G4bool status = false;
 55    const std::map< G4String , const G4int >::c <<  55    const std::map< std::string , const G4int >::iterator it = i_defaults.find( name );
 56    if ( it == i_defaults.cend() ) {            <<  56    if ( it == i_defaults.end() ) {
 57       status = true;                               57       status = true;
 58       i_defaults.insert( std::pair<G4String, c <<  58       i_defaults.insert( std::pair<std::string, const G4int>( name , value ) );
 59       i_values.insert( std::pair<G4String, G4i <<  59       i_values.insert( std::pair<std::string, G4int>( name , value ) );
 60       i_limits.insert( std::pair< G4String,std <<  60       i_limits.insert( std::pair< std::string,std::pair< const G4int , const G4int> >( name, std::pair< const G4int , const G4int> ( lower_limit , upper_limit ) ) );
 61    } else {                                        61    } else {
 62             /*error*/                              62             /*error*/
 63       issue_is_already_defined( name );            63       issue_is_already_defined( name );
 64    }                                               64    }
 65    return status;                                  65    return status;
 66 }                                                  66 }
 67                                                    67 
 68 G4bool G4HadronicDeveloperParameters::SetDefau <<  68 G4bool G4HadronicDeveloperParameters::SetDefault( const std::string name , const G4double value , G4double lower_limit , G4double upper_limit ){
 69    G4bool status = false;                          69    G4bool status = false;
 70    const std::map< G4String , const G4double > <<  70    const std::map< std::string , const G4double >::iterator it = defaults.find( name );
 71    if ( it == defaults.cend() ) {              <<  71    if ( it == defaults.end() ) {
 72       status = true;                               72       status = true;
 73       defaults.insert( std::pair<G4String, con <<  73       defaults.insert( std::pair<std::string, const G4double>( name , value ) );
 74       values.insert( std::pair<G4String, G4dou <<  74       values.insert( std::pair<std::string, G4double>( name , value ) );
 75       limits.insert( std::pair< G4String,std:: <<  75       limits.insert( std::pair< std::string,std::pair< const G4double , const G4double> >( name, std::pair< const G4double , const G4double> ( lower_limit , upper_limit ) ) );
 76    } else {                                        76    } else {
 77             /*error*/                              77             /*error*/
 78       issue_is_already_defined( name );            78       issue_is_already_defined( name );
 79    }                                               79    }
 80    return status;                                  80    return status;
 81 }                                                  81 }
 82                                                    82 
 83 G4bool G4HadronicDeveloperParameters::Set( con <<  83 G4bool G4HadronicDeveloperParameters::Set( const std::string name , const G4bool value ){
 84    G4bool status = false;                          84    G4bool status = false;
 85    const std::map<G4String,G4bool>::iterator i <<  85    const std::map<std::string,G4bool>::iterator it = b_values.find( name );
 86    if ( it != b_values.cend() ) {              <<  86    if ( it != b_values.end() ) {
 87       if ( it->second == b_defaults.find(name)     87       if ( it->second == b_defaults.find(name)->second ) {
 88          status = true;                            88          status = true;
 89          it->second = value;                       89          it->second = value;
 90       } else {                                     90       } else {
 91          /*change more than once*/                 91          /*change more than once*/
 92          issue_has_changed( name );                92          issue_has_changed( name );
 93       }                                            93       }
 94    } else {                                        94    } else {
 95       /*Parameter of "name" does not exist*/       95       /*Parameter of "name" does not exist*/
 96       issue_no_param( name );                      96       issue_no_param( name );
 97    }                                               97    }
 98    return status;                                  98    return status;
 99 }                                                  99 }
100                                                   100 
101 G4bool G4HadronicDeveloperParameters::Set( con << 101 G4bool G4HadronicDeveloperParameters::Set( const std::string name , const G4int value ){
102    G4bool status = false;                         102    G4bool status = false;
103    const std::map<G4String,G4int>::iterator it << 103    const std::map<std::string,G4int>::iterator it = i_values.find( name );
104    if ( it != i_values.cend() ) {              << 104    if ( it != i_values.end() ) {
105       if ( it->second == i_defaults.find(name)    105       if ( it->second == i_defaults.find(name)->second ) {
106          if ( check_value_within_limits( i_lim    106          if ( check_value_within_limits( i_limits.find(name)->second , value ) ) {
107             /*value is OK*/                       107             /*value is OK*/
108             status = true;                        108             status = true;
109             it->second = value;                   109             it->second = value;
110          } else {                                 110          } else {
111             /*Value is outside of valid range*    111             /*Value is outside of valid range*/
112             issue_non_eligible_value( name );     112             issue_non_eligible_value( name );
113          }                                        113          }
114       } else {                                    114       } else {
115          /*change more than once*/                115          /*change more than once*/
116          issue_has_changed( name );               116          issue_has_changed( name );
117       }                                           117       }
118    } else {                                       118    } else {
119       /*Parameter of "name" does not exist*/      119       /*Parameter of "name" does not exist*/
120       issue_no_param( name );                     120       issue_no_param( name );
121    }                                              121    }
122    return status;                                 122    return status;
123 }                                                 123 }
124                                                   124 
125 G4bool G4HadronicDeveloperParameters::Set( con << 125 G4bool G4HadronicDeveloperParameters::Set( const std::string name , const G4double value ){
126    G4bool status = false;                         126    G4bool status = false;
127    const std::map<G4String,G4double>::iterator << 127    const std::map<std::string,G4double>::iterator it = values.find( name );
128    if ( it != values.cend() ) {                << 128    if ( it != values.end() ) {
129       if ( it->second == defaults.find(name)->    129       if ( it->second == defaults.find(name)->second ) {
130          if ( check_value_within_limits( limit    130          if ( check_value_within_limits( limits.find(name)->second , value ) ) {
131             /*value is OK*/                       131             /*value is OK*/
132             status = true;                        132             status = true;
133             it->second = value;                   133             it->second = value;
134          } else {                                 134          } else {
135             /*Value is outside of valid range*    135             /*Value is outside of valid range*/
136             issue_non_eligible_value( name );     136             issue_non_eligible_value( name );
137          }                                        137          }
138       } else {                                    138       } else {
139          /*change more than once*/                139          /*change more than once*/
140          issue_has_changed( name );               140          issue_has_changed( name );
141       }                                           141       }
142    } else {                                       142    } else {
143       /*Parameter of "name" does not exist*/      143       /*Parameter of "name" does not exist*/
144       issue_no_param( name );                     144       issue_no_param( name );
145    }                                              145    }
146    return status;                                 146    return status;
147 }                                                 147 }
148                                                   148 
149 G4bool G4HadronicDeveloperParameters::GetDefau << 149 G4bool G4HadronicDeveloperParameters::GetDefault( const std::string name , G4bool& value ) {
150    G4bool status = false;                         150    G4bool status = false;
151    const std::map<G4String,const G4bool>::cons << 151    const std::map<std::string,const G4bool>::iterator it = b_defaults.find( name );
152    if ( it != b_defaults.cend() ) {            << 152    if ( it != b_defaults.end() ) {
153       status = true;                              153       status = true;
154       value = it->second;                         154       value = it->second;
155    } else {                                       155    } else { 
156       /*Parameter of "name" does not exist*/      156       /*Parameter of "name" does not exist*/
157       issue_no_param( name );                     157       issue_no_param( name );
158    }                                              158    }
159    return status;                                 159    return status;
160 }                                                 160 }
161                                                   161 
162 G4bool G4HadronicDeveloperParameters::GetDefau << 162 G4bool G4HadronicDeveloperParameters::GetDefault( const std::string name , G4int& value ) {
163    G4bool status = false;                         163    G4bool status = false;
164    const std::map<G4String,const G4int>::const << 164    const std::map<std::string,const G4int>::iterator it = i_defaults.find( name );
165    if ( it != i_defaults.cend() ) {            << 165    if ( it != i_defaults.end() ) {
166       status = true;                              166       status = true;
167       value = it->second;                         167       value = it->second;
168    } else {                                       168    } else { 
169       /*Parameter of "name" does not exist*/      169       /*Parameter of "name" does not exist*/
170       issue_no_param( name );                     170       issue_no_param( name );
171    }                                              171    }
172    return status;                                 172    return status;
173 }                                                 173 }
174                                                   174 
175 G4bool G4HadronicDeveloperParameters::GetDefau << 175 G4bool G4HadronicDeveloperParameters::GetDefault( const std::string name , G4double& value ) {
176    G4bool status = false;                         176    G4bool status = false;
177    const std::map<G4String,const G4double>::co << 177    const std::map<std::string,const G4double>::iterator it = defaults.find( name );
178    if ( it != defaults.cend() ) {              << 178    if ( it != defaults.end() ) {
179       status = true;                              179       status = true;
180       value = it->second;                         180       value = it->second;
181    } else {                                       181    } else { 
182       /*Parameter of "name" does not exist*/      182       /*Parameter of "name" does not exist*/
183       issue_no_param( name );                     183       issue_no_param( name );
184    }                                              184    }
185    return status;                                 185    return status;
186 }                                                 186 }
187                                                   187 
188 G4bool G4HadronicDeveloperParameters::Get( con << 188 G4bool G4HadronicDeveloperParameters::Get( const std::string name , G4double& value ) {
189    return get( name , value );                    189    return get( name , value );
190 }                                                 190 }
191                                                   191 
192 G4bool G4HadronicDeveloperParameters::Develope << 192 G4bool G4HadronicDeveloperParameters::DeveloperGet( const std::string name , G4double& value ) {
193    return get( name , value , true );             193    return get( name , value , true );
194 }                                                 194 }
195                                                   195 
196 G4bool G4HadronicDeveloperParameters::get( con << 196 G4bool G4HadronicDeveloperParameters::get( const std::string name , G4bool& value , G4bool check_change ) {
197    G4bool status = false;                         197    G4bool status = false;
198    const std::map<G4String,G4bool>::const_iter << 198    const std::map<std::string,G4bool>::iterator it = b_values.find( name );
199    if ( it != b_values.cend() ) {              << 199    if ( it != b_values.end() ) {
200       status = true;                              200       status = true;
201       value = it->second;                         201       value = it->second;
202       if ( check_change && value != b_defaults    202       if ( check_change && value != b_defaults.find(name)->second ) {
203          //Parameter "name" has changed from d    203          //Parameter "name" has changed from default
204          issue_is_modified( name );               204          issue_is_modified( name );
205       }                                           205       }
206    } else {                                       206    } else { 
207       //Parameter of "name" does not exist        207       //Parameter of "name" does not exist
208       issue_no_param( name );                     208       issue_no_param( name );
209    }                                              209    }
210    return status;                                 210    return status;
211 }                                                 211 }
212                                                   212 
213 G4bool G4HadronicDeveloperParameters::Get( con << 213 G4bool G4HadronicDeveloperParameters::Get( const std::string name , G4int& value ) {
214    return get( name , value );                    214    return get( name , value );
215 }                                                 215 }
216                                                   216 
217 G4bool G4HadronicDeveloperParameters::Develope << 217 G4bool G4HadronicDeveloperParameters::DeveloperGet( const std::string name , G4int& value ) {
218    return get( name , value , true );             218    return get( name , value , true );
219 }                                                 219 }
220                                                   220 
221 G4bool G4HadronicDeveloperParameters::get( con << 221 G4bool G4HadronicDeveloperParameters::get( const std::string name , G4int& value , G4bool check_change ) {
222    G4bool status = false;                         222    G4bool status = false;
223    const std::map<G4String,G4int>::const_itera << 223    const std::map<std::string,G4int>::iterator it = i_values.find( name );
224    if ( it != i_values.cend() ) {              << 224    if ( it != i_values.end() ) {
225       status = true;                              225       status = true;
226       value = it->second;                         226       value = it->second;
227       if ( check_change && value != i_defaults    227       if ( check_change && value != i_defaults.find(name)->second ) {
228          //Parameter "name" has changed from d    228          //Parameter "name" has changed from default
229          issue_is_modified( name );               229          issue_is_modified( name );
230       }                                           230       }
231    } else {                                       231    } else { 
232       //Parameter of "name" does not exist        232       //Parameter of "name" does not exist
233       issue_no_param( name );                     233       issue_no_param( name );
234    }                                              234    }
235    return status;                                 235    return status;
236 }                                                 236 }
237                                                   237 
238 G4bool G4HadronicDeveloperParameters::Get( con << 238 G4bool G4HadronicDeveloperParameters::Get( const std::string name , G4bool& value ) {
239    return get( name , value );                    239    return get( name , value );
240 }                                                 240 }
241                                                   241 
242 G4bool G4HadronicDeveloperParameters::Develope << 242 G4bool G4HadronicDeveloperParameters::DeveloperGet( const std::string name , G4bool& value ) {
243    return get( name , value , true );             243    return get( name , value , true );
244 }                                                 244 }
245                                                   245 
246 G4bool G4HadronicDeveloperParameters::get( con << 246 G4bool G4HadronicDeveloperParameters::get( const std::string name , G4double& value , G4bool check_change ) {
247    G4bool status = false;                         247    G4bool status = false;
248    const std::map<G4String,G4double>::const_it << 248    const std::map<std::string,G4double>::iterator it = values.find( name );
249    if ( it != values.cend() ) {                << 249    if ( it != values.end() ) {
250       status = true;                              250       status = true;
251       value = it->second;                         251       value = it->second;
252       if ( check_change && value != defaults.f    252       if ( check_change && value != defaults.find(name)->second ) {
253          /*Parameter "name" has changed from d    253          /*Parameter "name" has changed from default*/
254          issue_is_modified( name );               254          issue_is_modified( name );
255       }                                           255       }
256    } else {                                       256    } else { 
257       /*Parameter of "name" does not exist*/      257       /*Parameter of "name" does not exist*/
258       issue_no_param( name );                     258       issue_no_param( name );
259    }                                              259    }
260    return status;                                 260    return status;
261 }                                                 261 }
262                                                   262 
263 void G4HadronicDeveloperParameters::Dump( cons << 263 void G4HadronicDeveloperParameters::Dump( const std::string name ) {
264    //const std::map<G4String,G4double>::const_ << 264    //const std::map<std::string,G4double>::iterator it = values.find( name );
265    if ( b_values.find( name ) != b_values.cend << 265    if ( b_values.find( name ) != b_values.end() ) {
266       G4cout << "G4HadronicDeveloperParameters    266       G4cout << "G4HadronicDeveloperParameters: "
267       << "name = " << name                        267       << "name = " << name 
268       << ", default value = " << b_defaults.fi    268       << ", default value = " << b_defaults.find( name )->second
269       << ", current value = " << b_values.find    269       << ", current value = " << b_values.find( name )->second
270       << "." << G4endl;                           270       << "." << G4endl;
271    } else if ( i_values.find( name ) != i_valu << 271    } else if ( i_values.find( name ) != i_values.end() ) {
272       G4cout << "G4HadronicDeveloperParameters    272       G4cout << "G4HadronicDeveloperParameters: "
273       << "name = " << name                        273       << "name = " << name 
274       << ", default value = " << i_defaults.fi    274       << ", default value = " << i_defaults.find( name )->second
275       << ", lower limit = " << i_limits.find(     275       << ", lower limit = " << i_limits.find( name )->second.first
276       << ", upper limit = " << i_limits.find(     276       << ", upper limit = " << i_limits.find( name )->second.second
277       << ", current value = " << i_values.find    277       << ", current value = " << i_values.find( name )->second
278       << "." << G4endl;                           278       << "." << G4endl;
279    } else if ( values.find( name ) != values.c << 279    } else if ( values.find( name ) != values.end() ) {
280       G4cout << "G4HadronicDeveloperParameters    280       G4cout << "G4HadronicDeveloperParameters: "
281       << "name = " << name                        281       << "name = " << name 
282       << ", default value = " << defaults.find    282       << ", default value = " << defaults.find( name )->second
283       << ", lower limit = " << limits.find( na    283       << ", lower limit = " << limits.find( name )->second.first
284       << ", upper limit = " << limits.find( na    284       << ", upper limit = " << limits.find( name )->second.second
285       << ", current value = " << values.find(     285       << ", current value = " << values.find( name )->second
286       << "." << G4endl;                           286       << "." << G4endl;
287    } else {                                       287    } else {
288       /*Parameter of "name" does not exist*/      288       /*Parameter of "name" does not exist*/
289       issue_no_param( name );                     289       issue_no_param( name );
290    }                                              290    }
291 }                                                 291 }
292                                                   292 
293 G4bool G4HadronicDeveloperParameters::check_va    293 G4bool G4HadronicDeveloperParameters::check_value_within_limits( std::pair<const G4double,const G4double>& alimits , const G4double value ){
294    if ( alimits.first <= value && value <= ali    294    if ( alimits.first <= value && value <= alimits.second ) {
295       return true;                                295       return true;
296    } else {                                       296    } else {
297       return false;                               297       return false;
298    }                                              298    }
299 }                                                 299 }
300                                                   300 
301 G4bool G4HadronicDeveloperParameters::check_va    301 G4bool G4HadronicDeveloperParameters::check_value_within_limits( std::pair<const G4int,const G4int>& alimits , const G4int value ){
302    if ( alimits.first <= value && value <= ali    302    if ( alimits.first <= value && value <= alimits.second ) {
303       return true;                                303       return true;
304    } else {                                       304    } else {
305       return false;                               305       return false;
306    }                                              306    }
307 }                                                 307 }
308                                                   308 
309 void G4HadronicDeveloperParameters::issue_no_p << 309 void G4HadronicDeveloperParameters::issue_no_param( const std::string& name ){
310    G4String text("Parameter ");                << 310    std::string text("Parameter ");
311    text += name;                                  311    text += name;  
312    text += " does not exist.";                    312    text += " does not exist.";
313    G4Exception( "G4HadronicDeveloperParameters << 313    G4Exception( "G4HadronicDeveloperParameters" , "HadDevPara_001", FatalException , text.c_str() );
314 }                                                 314 }
315                                                   315 
316 void G4HadronicDeveloperParameters::issue_has_ << 316 void G4HadronicDeveloperParameters::issue_has_changed( const std::string& name ) {
317    G4String text("Parameter ");                << 317    std::string text("Parameter ");
318    text += name;                                  318    text += name;  
319    text += " has already been changed once.";     319    text += " has already been changed once.";
320    G4Exception( "G4HadronicDeveloperParameters << 320    G4Exception( "G4HadronicDeveloperParameters" , "HadDevPara_002", FatalException , text.c_str() );
321 }                                                 321 }
322 void G4HadronicDeveloperParameters::issue_non_ << 322 void G4HadronicDeveloperParameters::issue_non_eligible_value( const std::string& name ) {
323    G4String text("The value of the parameter " << 323    std::string text("The value of the parameter ");
324    text += name;                                  324    text += name;  
325    text += " is outside the allowable range.";    325    text += " is outside the allowable range.";
326    G4Exception( "G4HadronicDeveloperParameters << 326    G4Exception( "G4HadronicDeveloperParameters" , "HadDevPara_003", FatalException , text.c_str() );
327 }                                                 327 }
328 void G4HadronicDeveloperParameters::issue_is_a << 328 void G4HadronicDeveloperParameters::issue_is_already_defined( const std::string& name ) {
329    G4String text("Parameter ");                << 329    std::string text("Parameter ");
330    text += name;                                  330    text += name;  
331    text += " is already defined.";                331    text += " is already defined.";
332    G4Exception( "G4HadronicDeveloperParameters << 332    G4Exception( "G4HadronicDeveloperParameters" , "HadDevPara_004", FatalException , text.c_str() );
333 }                                                 333 }
334 void G4HadronicDeveloperParameters::issue_is_m << 334 void G4HadronicDeveloperParameters::issue_is_modified( const std::string& name ) {
335    G4String text("Parameter ");                << 335    std::string text("Parameter ");
336    text += name;                                  336    text += name;  
337    text += " has changed from default value.";    337    text += " has changed from default value.";
338    G4Exception( "G4HadronicDeveloperParameters << 338    G4Exception( "G4HadronicDeveloperParameters" , "HadDevPara_005", JustWarning , text.c_str() );
339 }                                                 339 }
340                                                   340