| Geant4 Cross Reference |
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 // INCL++ intra-nuclear cascade model 26 // INCL++ intra-nuclear cascade model
27 // Alain Boudard, CEA-Saclay, France 27 // Alain Boudard, CEA-Saclay, France
28 // Joseph Cugnon, University of Liege, Belgium 28 // Joseph Cugnon, University of Liege, Belgium
29 // Jean-Christophe David, CEA-Saclay, France 29 // Jean-Christophe David, CEA-Saclay, France
30 // Pekka Kaitaniemi, CEA-Saclay, France, and H 30 // Pekka Kaitaniemi, CEA-Saclay, France, and Helsinki Institute of Physics, Finland
31 // Sylvie Leray, CEA-Saclay, France 31 // Sylvie Leray, CEA-Saclay, France
32 // Davide Mancusi, CEA-Saclay, France 32 // Davide Mancusi, CEA-Saclay, France
33 // 33 //
34 #define INCLXX_IN_GEANT4_MODE 1 34 #define INCLXX_IN_GEANT4_MODE 1
35 35
36 #include "globals.hh" 36 #include "globals.hh"
37 37
38 /** \file G4INCLXXInterfaceStore.cc 38 /** \file G4INCLXXInterfaceStore.cc
39 * \brief The G4INCLXXInterfaceStore class imp 39 * \brief The G4INCLXXInterfaceStore class implementation
40 * 40 *
41 * \date 24 May 2012 41 * \date 24 May 2012
42 * \author Davide Mancusi 42 * \author Davide Mancusi
43 */ 43 */
44 44
45 #include "G4INCLXXInterfaceStore.hh" 45 #include "G4INCLXXInterfaceStore.hh"
46 #include "G4INCLXXInterfaceMessenger.hh" 46 #include "G4INCLXXInterfaceMessenger.hh"
47 #include "G4INCLConfigEnums.hh" 47 #include "G4INCLConfigEnums.hh"
48 #include "G4SystemOfUnits.hh" 48 #include "G4SystemOfUnits.hh"
49 #include "G4HadronicInteraction.hh" 49 #include "G4HadronicInteraction.hh"
50 #include "G4HadronicInteractionRegistry.hh" 50 #include "G4HadronicInteractionRegistry.hh"
51 #include "G4INCLXXInterface.hh" 51 #include "G4INCLXXInterface.hh"
52 #include "G4INCLConfig.hh" 52 #include "G4INCLConfig.hh"
53 #include "G4AblaInterface.hh" 53 #include "G4AblaInterface.hh"
54 #include "G4HadronicParameters.hh" 54 #include "G4HadronicParameters.hh"
55 #include <vector> 55 #include <vector>
56 56
57 G4ThreadLocal G4INCLXXInterfaceStore *G4INCLXX 57 G4ThreadLocal G4INCLXXInterfaceStore *G4INCLXXInterfaceStore::theInstance = NULL;
58 58
59 G4INCLXXInterfaceStore::G4INCLXXInterfaceStore 59 G4INCLXXInterfaceStore::G4INCLXXInterfaceStore() :
60 accurateProjectile(true), 60 accurateProjectile(true),
61 theMaxProjMassINCL(18), 61 theMaxProjMassINCL(18),
62 cascadeMinEnergyPerNucleon(1.*MeV), 62 cascadeMinEnergyPerNucleon(1.*MeV),
63 conservationTolerance(5*MeV), 63 conservationTolerance(5*MeV),
64 theINCLModel(NULL), 64 theINCLModel(NULL),
65 theTally(NULL), 65 theTally(NULL),
66 nWarnings(0), 66 nWarnings(0),
67 maxWarnings(50) 67 maxWarnings(50)
68 { 68 {
69 constructINCLXXVersionName(); 69 constructINCLXXVersionName();
70 theINCLXXInterfaceMessenger = new G4INCLXXIn 70 theINCLXXInterfaceMessenger = new G4INCLXXInterfaceMessenger(this);
71 } 71 }
72 72
73 G4INCLXXInterfaceStore::~G4INCLXXInterfaceStor 73 G4INCLXXInterfaceStore::~G4INCLXXInterfaceStore() {
74 delete theINCLXXInterfaceMessenger; 74 delete theINCLXXInterfaceMessenger;
75 delete theINCLModel; 75 delete theINCLModel;
76 } 76 }
77 77
78 void G4INCLXXInterfaceStore::DeleteModel() { 78 void G4INCLXXInterfaceStore::DeleteModel() {
79 delete theINCLModel; theINCLModel=NULL; 79 delete theINCLModel; theINCLModel=NULL;
80 } 80 }
81 81
82 G4INCLXXInterfaceStore *G4INCLXXInterfaceStore 82 G4INCLXXInterfaceStore *G4INCLXXInterfaceStore::GetInstance() {
83 if(!theInstance) 83 if(!theInstance)
84 theInstance = new G4INCLXXInterfaceStore; 84 theInstance = new G4INCLXXInterfaceStore;
85 return theInstance; 85 return theInstance;
86 } 86 }
87 87
88 void G4INCLXXInterfaceStore::DeleteInstance() 88 void G4INCLXXInterfaceStore::DeleteInstance() {
89 delete theInstance; 89 delete theInstance;
90 theInstance = NULL; 90 theInstance = NULL;
91 } 91 }
92 92
93 G4INCL::INCL *G4INCLXXInterfaceStore::GetINCLM 93 G4INCL::INCL *G4INCLXXInterfaceStore::GetINCLModel() {
94 if(!theINCLModel) { 94 if(!theINCLModel) {
95 G4INCL::Config *aConfig = new G4INCL::Conf 95 G4INCL::Config *aConfig = new G4INCL::Config(theConfig);
96 theINCLModel = new G4INCL::INCL(aConfig); 96 theINCLModel = new G4INCL::INCL(aConfig);
97 // ownership of the aConfig object is take 97 // ownership of the aConfig object is taken over by the INCL model engine
98 } 98 }
99 return theINCLModel; 99 return theINCLModel;
100 } 100 }
101 101
102 void G4INCLXXInterfaceStore::constructINCLXXVe 102 void G4INCLXXInterfaceStore::constructINCLXXVersionName() {
103 const std::string versionID = G4INCL_VERSION 103 const std::string versionID = G4INCL_VERSION_ID;
104 const size_t lastDash = versionID.find_last_ 104 const size_t lastDash = versionID.find_last_of("-");
105 versionName = "INCL++ " + versionID.substr(0 105 versionName = "INCL++ " + versionID.substr(0,lastDash);
106 } 106 }
107 107
108 const std::string &G4INCLXXInterfaceStore::get 108 const std::string &G4INCLXXInterfaceStore::getINCLXXVersionName() {
109 return versionName; 109 return versionName;
110 } 110 }
111 111
112 112
113 113
114 void G4INCLXXInterfaceStore::SetAccurateProjec 114 void G4INCLXXInterfaceStore::SetAccurateProjectile(const G4bool b) {
115 if(accurateProjectile!=b) { 115 if(accurateProjectile!=b) {
116 // Parameter is changed, emit a big warnin 116 // Parameter is changed, emit a big warning message
117 std::stringstream ss; 117 std::stringstream ss;
118 ss << "Switching from " 118 ss << "Switching from "
119 << (accurateProjectile ? "\"accurate pro 119 << (accurateProjectile ? "\"accurate projectile\" mode to \"accurate target\"" : "\"accurate target\" mode to \"accurate projectile\"")
120 << " mode." 120 << " mode."
121 << G4endl 121 << G4endl
122 << "Do this ONLY if you fully understand 122 << "Do this ONLY if you fully understand what it does!";
123 EmitBigWarning(ss.str()); 123 EmitBigWarning(ss.str());
124 } 124 }
125 125
126 // No need to delete the model for this para 126 // No need to delete the model for this parameter
127 127
128 accurateProjectile=b; 128 accurateProjectile=b;
129 } 129 }
130 130
131 void G4INCLXXInterfaceStore::SetMaxClusterMass 131 void G4INCLXXInterfaceStore::SetMaxClusterMass(const G4int aMass) {
132 const G4int theMaxClusterMass = theConfig.ge 132 const G4int theMaxClusterMass = theConfig.getClusterMaxMass();
133 if(theMaxClusterMass!=aMass) { 133 if(theMaxClusterMass!=aMass) {
134 // Parameter is changed, emit a big warnin 134 // Parameter is changed, emit a big warning message
135 std::stringstream ss; 135 std::stringstream ss;
136 ss << "Changing maximum cluster mass from 136 ss << "Changing maximum cluster mass from "
137 << theMaxClusterMass 137 << theMaxClusterMass
138 << " to " 138 << " to "
139 << aMass 139 << aMass
140 << "." 140 << "."
141 << G4endl 141 << G4endl
142 << "Do this ONLY if you fully understand 142 << "Do this ONLY if you fully understand what this setting does!";
143 EmitBigWarning(ss.str()); 143 EmitBigWarning(ss.str());
144 144
145 // We must delete the model object to make 145 // We must delete the model object to make sure that we use the new
146 // parameter 146 // parameter
147 DeleteModel(); 147 DeleteModel();
148 148
149 theConfig.setClusterMaxMass(aMass); 149 theConfig.setClusterMaxMass(aMass);
150 } 150 }
151 } 151 }
152 152
153 153
154 154
155 155
156 G4bool G4INCLXXInterfaceStore::GetAccurateProj 156 G4bool G4INCLXXInterfaceStore::GetAccurateProjectile() const { return accurateProjectile; }
157 157
158 G4double G4INCLXXInterfaceStore::GetCascadeMin 158 G4double G4INCLXXInterfaceStore::GetCascadeMinEnergyPerNucleon() const { return cascadeMinEnergyPerNucleon; }
159 159
160 G4INCL::Config &G4INCLXXInterfaceStore::GetINC 160 G4INCL::Config &G4INCLXXInterfaceStore::GetINCLConfig() {
161 DeleteModel(); // in case the Config is modi 161 DeleteModel(); // in case the Config is modified
162 return theConfig; 162 return theConfig;
163 } 163 }
164 164
165 G4double G4INCLXXInterfaceStore::GetConservati 165 G4double G4INCLXXInterfaceStore::GetConservationTolerance() const { return conservationTolerance; }
166 166
167 167
168 168
169 169
170 G4int G4INCLXXInterfaceStore::GetMaxProjMassIN 170 G4int G4INCLXXInterfaceStore::GetMaxProjMassINCL() const { return theMaxProjMassINCL; }
171 171
172 void G4INCLXXInterfaceStore::EmitWarning(const 172 void G4INCLXXInterfaceStore::EmitWarning(const G4String &message) {
173 if(++nWarnings<=maxWarnings) { 173 if(++nWarnings<=maxWarnings) {
174 G4cout << "[INCL++] Warning: " << message 174 G4cout << "[INCL++] Warning: " << message << G4endl;
175 if(nWarnings==maxWarnings) { 175 if(nWarnings==maxWarnings) {
176 G4cout << "[INCL++] INCL++ has already e 176 G4cout << "[INCL++] INCL++ has already emitted " << maxWarnings << " warnings and will emit no more." << G4endl;
177 } 177 }
178 } 178 }
179 } 179 }
180 180
181 void G4INCLXXInterfaceStore::EmitBigWarning(co 181 void G4INCLXXInterfaceStore::EmitBigWarning(const G4String &message) const {
182 // Disable the printing when global hadronic 182 // Disable the printing when global hadronic verbosity is zero
183 // (which can be issued via the UI command " 183 // (which can be issued via the UI command "/process/had/verbose 0" )
184 if ( G4HadronicParameters::Instance()->GetVe << 184 if ( G4HadronicParameters::Instance()->GetVerboseLevel() == 0 ) return;
185 G4cout 185 G4cout
186 << G4endl 186 << G4endl
187 << "====================================== 187 << "================================================================================"
188 << G4endl 188 << G4endl
189 << " INCL+ 189 << " INCL++ WARNING "
190 << G4endl 190 << G4endl
191 << message 191 << message
192 << G4endl 192 << G4endl
193 << "====================================== 193 << "================================================================================"
194 << G4endl 194 << G4endl
195 << G4endl; 195 << G4endl;
196 } 196 }
197 197
198 void G4INCLXXInterfaceStore::SetCascadeMinEner 198 void G4INCLXXInterfaceStore::SetCascadeMinEnergyPerNucleon(const G4double anEnergy) {
199 if(cascadeMinEnergyPerNucleon!=anEnergy) { 199 if(cascadeMinEnergyPerNucleon!=anEnergy) {
200 // Parameter is changed, emit a big warnin 200 // Parameter is changed, emit a big warning message
201 std::stringstream ss; 201 std::stringstream ss;
202 ss << "Changing minimim cascade energy fro 202 ss << "Changing minimim cascade energy from "
203 << cascadeMinEnergyPerNucleon / MeV 203 << cascadeMinEnergyPerNucleon / MeV
204 << " to " 204 << " to "
205 << anEnergy / MeV 205 << anEnergy / MeV
206 << " MeV." 206 << " MeV."
207 << G4endl 207 << G4endl
208 << "Do this ONLY if you fully understand 208 << "Do this ONLY if you fully understand what this setting does!";
209 EmitBigWarning(ss.str()); 209 EmitBigWarning(ss.str());
210 } 210 }
211 211
212 // No need to delete the model object 212 // No need to delete the model object
213 213
214 cascadeMinEnergyPerNucleon=anEnergy; 214 cascadeMinEnergyPerNucleon=anEnergy;
215 } 215 }
216 216
217 void G4INCLXXInterfaceStore::SetConservationTo 217 void G4INCLXXInterfaceStore::SetConservationTolerance(const G4double aTolerance) {
218 conservationTolerance = aTolerance; 218 conservationTolerance = aTolerance;
219 } 219 }
220 220
221 G4INCLXXVInterfaceTally *G4INCLXXInterfaceStor 221 G4INCLXXVInterfaceTally *G4INCLXXInterfaceStore::GetTally() const { return theTally; }
222 222
223 void G4INCLXXInterfaceStore::SetTally(G4INCLXX 223 void G4INCLXXInterfaceStore::SetTally(G4INCLXXVInterfaceTally * const aTally) { theTally = aTally; }
224 224
225 void G4INCLXXInterfaceStore::SetINCLPhysics(co 225 void G4INCLXXInterfaceStore::SetINCLPhysics(const G4String &option) {
226 if(option == "default") { 226 if(option == "default") {
227 theConfig.init(); 227 theConfig.init();
228 } else if(option == "incl42") { 228 } else if(option == "incl42") {
229 const G4String message = "Changing INCL++ 229 const G4String message = "Changing INCL++ physics to mimic INCL4.2. Do this ONLY if you fully understand the implications!";
230 EmitBigWarning(message); 230 EmitBigWarning(message);
231 231
232 theConfig.setPotentialType(G4INCL::Constan 232 theConfig.setPotentialType(G4INCL::ConstantPotential);
233 theConfig.setPionPotential(false); 233 theConfig.setPionPotential(false);
234 theConfig.setLocalEnergyBBType(G4INCL::Nev 234 theConfig.setLocalEnergyBBType(G4INCL::NeverLocalEnergy);
235 theConfig.setLocalEnergyPiType(G4INCL::Nev 235 theConfig.setLocalEnergyPiType(G4INCL::NeverLocalEnergy);
236 theConfig.setBackToSpectator(false); 236 theConfig.setBackToSpectator(false);
237 theConfig.setClusterAlgorithm(G4INCL::NoCl 237 theConfig.setClusterAlgorithm(G4INCL::NoClusterAlgorithm);
238 theConfig.setCoulombType(G4INCL::NoCoulomb 238 theConfig.setCoulombType(G4INCL::NoCoulomb);
239 // UseRealMasses intentionally left out be 239 // UseRealMasses intentionally left out because it creates problems with
240 // energy conservation 240 // energy conservation
241 // theConfig.setUseRealMasses(false); 241 // theConfig.setUseRealMasses(false);
242 theConfig.setCrossSectionsType(G4INCL::INC 242 theConfig.setCrossSectionsType(G4INCL::INCL46CrossSections);
243 } else { 243 } else {
244 G4Exception("G4INCLXXInterfaceStore::SetIN 244 G4Exception("G4INCLXXInterfaceStore::SetINCLPhysics", "INCLXX0001", FatalErrorInArgument,
245 "SetINCLPhysics argument must 245 "SetINCLPhysics argument must be one of: default, incl42"
246 ); 246 );
247 } 247 }
248 } 248 }
249 249
250 void G4INCLXXInterfaceStore::UseAblaDeExcitati 250 void G4INCLXXInterfaceStore::UseAblaDeExcitation() {
251 // Get hold of pointers to the INCL++ model 251 // Get hold of pointers to the INCL++ model interfaces
252 std::vector<G4HadronicInteraction *> const & 252 std::vector<G4HadronicInteraction *> const &interactions = G4HadronicInteractionRegistry::Instance()
253 ->FindAllModels(G4INCLXXInterfaceStore::Ge 253 ->FindAllModels(G4INCLXXInterfaceStore::GetInstance()->getINCLXXVersionName());
254 for(std::vector<G4HadronicInteraction *>::co 254 for(std::vector<G4HadronicInteraction *>::const_iterator iInter=interactions.begin(), e=interactions.end();
255 iInter!=e; ++iInter) { 255 iInter!=e; ++iInter) {
256 G4INCLXXInterface *theINCLInterface = dyna 256 G4INCLXXInterface *theINCLInterface = dynamic_cast<G4INCLXXInterface*>(*iInter);
257 if(theINCLInterface) { 257 if(theINCLInterface) {
258 // Instantiate the ABLA model 258 // Instantiate the ABLA model
259 G4HadronicInteraction *interaction = G4H 259 G4HadronicInteraction *interaction = G4HadronicInteractionRegistry::Instance()->FindModel("ABLA");
260 G4AblaInterface *theAblaInterface = dyna 260 G4AblaInterface *theAblaInterface = dynamic_cast<G4AblaInterface*>(interaction);
261 if(!theAblaInterface) 261 if(!theAblaInterface)
262 theAblaInterface = new G4AblaInterface 262 theAblaInterface = new G4AblaInterface;
263 // Couple INCL++ to ABLA 263 // Couple INCL++ to ABLA
264 G4cout << "Coupling INCLXX to ABLA" << G 264 G4cout << "Coupling INCLXX to ABLA" << G4endl;
265 theINCLInterface->SetDeExcitation(theAbl 265 theINCLInterface->SetDeExcitation(theAblaInterface);
266 } 266 }
267 } 267 }
268 } 268 }
269 269