| 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 // G4AdjointCrossSurfChecker implementation << 26 // $Id: G4AdjointSimManager.cc 76245 2013-11-08 11:14:32Z gcosmo $
27 // 27 //
28 // ------------------------------------------- << 28 /////////////////////////////////////////////////////////////////////////////
29 // Class Name: G4AdjointCrossSurfChecker << 29 // Class Name: G4AdjointCrossSurfChecker
30 // Author: L. Desorgher, 2007-2009 << 30 // Author: L. Desorgher
31 // Organisation: SpaceIT GmbH << 31 // Organisation: SpaceIT GmbH
32 // Contract: ESA contract 21435/08/NL/AT << 32 // Contract: ESA contract 21435/08/NL/AT
33 // Customer: ESA/ESTEC << 33 // Customer: ESA/ESTEC
34 // ------------------------------------------- << 34 /////////////////////////////////////////////////////////////////////////////
35 35
36 #include "G4AdjointSimManager.hh" 36 #include "G4AdjointSimManager.hh"
37 <<
38 #include "G4AdjointCrossSurfChecker.hh" <<
39 #include "G4AdjointPrimaryGeneratorAction.hh" <<
40 #include "G4AdjointSimMessenger.hh" <<
41 #include "G4AdjointStackingAction.hh" <<
42 #include "G4AdjointSteppingAction.hh" <<
43 #include "G4AdjointTrackingAction.hh" <<
44 #include "G4ParticleTable.hh" <<
45 #include "G4PhysicsLogVector.hh" <<
46 #include "G4Run.hh" 37 #include "G4Run.hh"
47 #include "G4RunManager.hh" 38 #include "G4RunManager.hh"
48 #include "G4WorkerRunManager.hh" << 39
49 #include "G4UserEventAction.hh" 40 #include "G4UserEventAction.hh"
50 #include "G4UserRunAction.hh" <<
51 #include "G4UserStackingAction.hh" <<
52 #include "G4UserSteppingAction.hh" <<
53 #include "G4UserTrackingAction.hh" <<
54 #include "G4VUserPrimaryGeneratorAction.hh" 41 #include "G4VUserPrimaryGeneratorAction.hh"
>> 42 #include "G4UserTrackingAction.hh"
>> 43 #include "G4UserSteppingAction.hh"
>> 44 #include "G4UserStackingAction.hh"
>> 45 #include "G4UserRunAction.hh"
55 46
56 // ------------------------------------------- << 47 #include "G4AdjointPrimaryGeneratorAction.hh"
57 // << 48 #include "G4AdjointSteppingAction.hh"
58 G4ThreadLocal G4AdjointSimManager* G4AdjointSi << 49 #include "G4AdjointStackingAction.hh"
>> 50 #include "G4AdjointTrackingAction.hh"
59 51
60 // ------------------------------------------- << 52 #include "G4AdjointSimMessenger.hh"
61 // <<
62 G4AdjointSimManager::G4AdjointSimManager() <<
63 { <<
64 theAdjointPrimaryGeneratorAction = new G4Adj <<
65 theAdjointSteppingAction = new G4AdjointStep <<
66 theAdjointTrackingAction = new G4AdjointTrac <<
67 theAdjointStackingAction = new G4AdjointStac <<
68 theAdjointTrackingAction->SetListOfPrimaryFw <<
69 theAdjointPrimaryGeneratorAction->GetListOfP <<
70 53
>> 54 #include "G4AdjointCrossSurfChecker.hh"
>> 55
>> 56 #include "G4ParticleTable.hh"
>> 57 #include "G4PhysicsLogVector.hh"
>> 58 /*
>> 59 #ifdef G4MULTITHREADED
>> 60 #include "G4MTAdjointSimManager.hh"
>> 61 #endif
>> 62 */
>> 63
>> 64 ////////////////////////////////////////////////////////////////////////////////
>> 65 //
>> 66 G4ThreadLocal G4AdjointSimManager* G4AdjointSimManager::instance = 0;
>> 67
>> 68 ////////////////////////////////////////////////////////////////////////////////
>> 69 //
>> 70 G4AdjointSimManager::G4AdjointSimManager():
>> 71 fUserRunAction(0), fUserEventAction(0),fUserPrimaryGeneratorAction(0),
>> 72 fUserTrackingAction(0), fUserSteppingAction(0), fUserStackingAction(0),
>> 73 theAdjointRunAction(0), theAdjointEventAction(0)
>> 74 {
>> 75 //instance =this;
>> 76 G4cout<<"G4AdjointSimManager::G4AdjointSimManager() Here"<<std::endl;
>> 77 //Create adjoint actions;
>> 78 //----------------------
>> 79 theAdjointPrimaryGeneratorAction = new G4AdjointPrimaryGeneratorAction();
>> 80 theAdjointSteppingAction = new G4AdjointSteppingAction();
>> 81 theAdjointStackingAction = new G4AdjointStackingAction();
>> 82 theAdjointTrackingAction = new G4AdjointTrackingAction(theAdjointSteppingAction);
>> 83
>> 84 //Create messenger
>> 85 //----------------
71 theMessenger = new G4AdjointSimMessenger(thi 86 theMessenger = new G4AdjointSimMessenger(this);
72 } << 87
>> 88 user_action_already_defined=false;
>> 89 use_user_StackingAction = false;
73 90
74 // ------------------------------------------- << 91 adjoint_sim_mode = false;
>> 92
>> 93 normalisation_mode=3;
>> 94
>> 95 nb_nuc=1.;
>> 96
>> 97 welcome_message =true;
>> 98
>> 99 //Define user action and set this class instance as RunAction
>> 100 //----------------
>> 101 DefineUserActions();
>> 102 G4RunManager* theRunManager = G4RunManager::GetRunManager();
>> 103 theRunManager->SetUserAction(this);
>> 104 /*
>> 105 #ifdef G4MULTITHREADED
>> 106
>> 107 if (theRunManager->GetRunManagerType() == G4RunManager::workerRM){
>> 108 G4cout<<"Here"<<std::endl;
>> 109 //G4MTAdjointSimManager::GetInstance()->RegisterLocalManager(this);
>> 110 G4cout<<"Here1"<<std::endl;
>> 111 }
>> 112 #endif
>> 113 */
>> 114 }
>> 115 ////////////////////////////////////////////////////////////////////////////////
75 // 116 //
76 G4AdjointSimManager::~G4AdjointSimManager() 117 G4AdjointSimManager::~G4AdjointSimManager()
77 { << 118 {
78 delete theAdjointRunAction; << 119 if (theAdjointRunAction) delete theAdjointRunAction;
79 delete theAdjointPrimaryGeneratorAction; << 120 if (theAdjointPrimaryGeneratorAction) delete theAdjointPrimaryGeneratorAction;
80 delete theAdjointSteppingAction; << 121 if (theAdjointSteppingAction) delete theAdjointSteppingAction;
81 delete theAdjointEventAction; << 122 if (theAdjointEventAction) delete theAdjointEventAction;
82 delete theAdjointTrackingAction; << 123 if (theAdjointTrackingAction) delete theAdjointTrackingAction;
83 delete theAdjointStackingAction; << 124 if (theAdjointStackingAction) delete theAdjointStackingAction;
84 delete theMessenger; << 125 if (theMessenger) delete theMessenger;
85 } 126 }
86 << 127 ////////////////////////////////////////////////////////////////////////////////
87 // ------------------------------------------- <<
88 // 128 //
89 G4AdjointSimManager* G4AdjointSimManager::GetI 129 G4AdjointSimManager* G4AdjointSimManager::GetInstance()
90 { 130 {
91 if (instance == nullptr) instance = new G4Ad << 131 if (instance == 0) instance = new G4AdjointSimManager;
92 return instance; 132 return instance;
93 } 133 }
94 << 134 ////////////////////////////////////////////////////////////////////////////////
95 // ------------------------------------------- <<
96 // 135 //
97 void G4AdjointSimManager::RunAdjointSimulation 136 void G4AdjointSimManager::RunAdjointSimulation(G4int nb_evt)
98 { << 137 { if (G4RunManager::GetRunManager()->GetRunManagerType() != G4RunManager::sequentialRM) return; //only for sequential mode
99 <<
100 if (welcome_message) { 138 if (welcome_message) {
101 G4cout << "******************************* << 139 G4cout<<"****************************************************************"<<std::endl;
102 G4cout << "*** Geant4 Reverse/Adjoint Mont << 140 G4cout<<"*** Geant4 Reverse/Adjoint Monte Carlo mode ***"<<std::endl;
103 G4cout << "*** Author: L.Desorgher << 141 G4cout<<"*** Author: L.Desorgher ***"<<std::endl;
104 G4cout << "*** Company: SpaceIT GmbH, << 142 G4cout<<"*** Company: SpaceIT GmbH, Bern, Switzerland ***"<<std::endl;
105 G4cout << "*** Sponsored by: ESA/ESTEC con << 143 G4cout<<"*** Sponsored by: ESA/ESTEC contract contract 21435/08/NL/AT ***"<<std::endl;
106 G4cout << "******************************* << 144 G4cout<<"****************************************************************"<<std::endl;
107 welcome_message = false; << 145 welcome_message=false;
108 } << 146 }
109 << 147
110 // Switch to adjoint simulation mode << 148 //Switch to adjoint simulation mode
111 //------------------------------------------ 149 //---------------------------------------------------------
112 SwitchToAdjointSimulationMode(); 150 SwitchToAdjointSimulationMode();
113 << 151
114 // Make the run << 152 //Make the run
115 //------------ 153 //------------
116 nb_evt_of_last_run = nb_evt; << 154
117 if (G4Threading::G4GetThreadId() < 0){ << 155 nb_evt_of_last_run =nb_evt;
118 G4RunManager::GetRunManager()->BeamOn( << 156 G4RunManager::GetRunManager()->BeamOn(nb_evt*theAdjointPrimaryGeneratorAction->GetNbOfAdjointPrimaryTypes());
119 G4int(nb_evt * theAdjointPrimaryGeneratorA << 157 //G4RunManager::GetRunManager()->BeamOn(theAdjointPrimaryGeneratorAction->GetNbOfAdjointPrimaryTypes()*2*nb_evt);
120 } <<
121 } <<
122 158
123 // ------------------------------------------- << 159 //Back to Fwd Simulation Mode
>> 160 //--------------------------------
>> 161 BackToFwdSimulationMode();
>> 162
>> 163 /*
>> 164 //Register the weight vector
>> 165 //--------------------------
>> 166 std::ofstream FileOutputElectronWeight("ElectronWeight.txt", std::ios::out);
>> 167 FileOutputElectronWeight<<std::setiosflags(std::ios::scientific);
>> 168 FileOutputElectronWeight<<std::setprecision(6);
>> 169 G4bool aBool = electron_last_weight_vector->Store(FileOutputElectronWeight, true);
>> 170 FileOutputElectronWeight.close();
>> 171
>> 172 std::ofstream FileOutputProtonWeight("ProtonWeight.txt", std::ios::out);
>> 173 FileOutputProtonWeight<<std::setiosflags(std::ios::scientific);
>> 174 FileOutputProtonWeight<<std::setprecision(6);
>> 175 aBool = proton_last_weight_vector->Store(FileOutputProtonWeight, true);
>> 176 FileOutputProtonWeight.close();
>> 177
>> 178 std::ofstream FileOutputGammaWeight("GammaWeight.txt", std::ios::out);
>> 179 FileOutputGammaWeight<<std::setiosflags(std::ios::scientific);
>> 180 FileOutputGammaWeight<<std::setprecision(6);
>> 181 aBool = gamma_last_weight_vector->Store(FileOutputGammaWeight, true);
>> 182 FileOutputGammaWeight.close();
>> 183 */
>> 184 }
>> 185 ////////////////////////////////////////////////////////////////////////////////
124 // 186 //
125 void G4AdjointSimManager::SetRestOfAdjointActi 187 void G4AdjointSimManager::SetRestOfAdjointActions()
126 { if (G4Threading::G4GetThreadId() == -1) retu << 188 {
127 G4RunManager* theRunManager = G4RunManager:: << 189 G4RunManager* theRunManager = G4RunManager::GetRunManager();
128 190
129 if (!user_action_already_defined) DefineUser 191 if (!user_action_already_defined) DefineUserActions();
130 192
131 // Replace the user action by the adjoint ac << 193 //Replace the user action by the adjoint actions
132 //------------------------------------------ << 194 //-------------------------------------------------
133 195
134 theRunManager->G4RunManager::SetUserAction(t << 196 theRunManager->SetUserAction(theAdjointEventAction);
135 theRunManager->G4RunManager::SetUserAction(t << 197 theRunManager->SetUserAction(theAdjointSteppingAction);
136 theRunManager->G4RunManager::SetUserAction(t << 198 theRunManager->SetUserAction(theAdjointTrackingAction);
137 } <<
138 199
139 // ------------------------------------------- << 200 }
>> 201 ////////////////////////////////////////////////////////////////////////////////
140 // 202 //
141 void G4AdjointSimManager::SwitchToAdjointSimul 203 void G4AdjointSimManager::SwitchToAdjointSimulationMode()
142 { << 204 { //Replace the user defined actions by the adjoint actions
143 // Replace the user defined actions by the a <<
144 //------------------------------------------ 205 //---------------------------------------------------------
145 SetAdjointActions(); 206 SetAdjointActions();
146 207
147 // Update the list of primaries << 208 //Update the list of primaries
148 //----------------------------- 209 //-----------------------------
149 if (G4Threading::G4GetThreadId() != -1) the << 210 theAdjointPrimaryGeneratorAction->UpdateListOfPrimaryParticles();
150 adjoint_sim_mode = true; << 211 adjoint_sim_mode=true;
151 ID_of_last_particle_that_reach_the_ext_sourc << 212 ID_of_last_particle_that_reach_the_ext_source=0;
152 <<
153 } 213 }
154 << 214 ////////////////////////////////////////////////////////////////////////////////
155 // ------------------------------------------- <<
156 // 215 //
157 void G4AdjointSimManager::BackToFwdSimulationM 216 void G4AdjointSimManager::BackToFwdSimulationMode()
158 { << 217 { //Restore the user defined actions
159 // Restore the user defined actions << 218 //--------------------------------
160 //-------------------------------- << 219 ResetUserActions();
161 ResetUserActions(); << 220 adjoint_sim_mode=false;
162 adjoint_sim_mode = false; <<
163 } 221 }
164 222
165 // ------------------------------------------- << 223 ////////////////////////////////////////////////////////////////////////////////
166 // 224 //
167 void G4AdjointSimManager::SetAdjointActions() 225 void G4AdjointSimManager::SetAdjointActions()
168 { << 226 {
169 auto theRunManager = G4RunManager::GetRunMan << 227 G4RunManager* theRunManager = G4RunManager::GetRunManager();
170 << 228
171 <<
172 if (!user_action_already_defined) DefineUser 229 if (!user_action_already_defined) DefineUserActions();
173 230
174 << 231 //Replace the user action by the adjoint actions
175 // Replace the user action by the adjoint ac << 232 //-------------------------------------------------
176 //------------------------------------------ << 233
177 theRunManager->G4RunManager::SetUserAction(t << 234 theRunManager->SetUserAction(theAdjointPrimaryGeneratorAction);
178 if (G4RunManager::GetRunManager()->GetRunMan << 235 theRunManager->SetUserAction(theAdjointStackingAction);
179 G4RunManager::GetRunManager()->GetRunMan << 236 if (use_user_StackingAction) theAdjointStackingAction->SetUserFwdStackingAction(fUserStackingAction);
180 theRunManager->G4RunManager::SetUserAction(t << 237 else theAdjointStackingAction->SetUserFwdStackingAction(0);
181 theRunManager->G4RunManager::SetUserAction(t << 238 if (theAdjointEventAction) theRunManager->SetUserAction(theAdjointEventAction);
182 if (use_user_StackingAction) << 239 theRunManager->SetUserAction(theAdjointSteppingAction);
183 theAdjointStackingAction->SetUserFwdStacki << 240 theRunManager->SetUserAction(theAdjointTrackingAction);
184 else <<
185 theAdjointStackingAction->SetUserFwdStacki <<
186 theRunManager->G4RunManager::SetUserAction(t <<
187 theRunManager->G4RunManager::SetUserAction(t <<
188 theRunManager->G4RunManager::SetUserAction(t <<
189 if (use_user_TrackingAction) <<
190 theAdjointTrackingAction->SetUserForwardTr <<
191 else <<
192 theAdjointTrackingAction->SetUserForwardTr <<
193 } <<
194 } 241 }
195 << 242 ////////////////////////////////////////////////////////////////////////////////
196 // ------------------------------------------- <<
197 // 243 //
198 void G4AdjointSimManager::SetAdjointPrimaryRun 244 void G4AdjointSimManager::SetAdjointPrimaryRunAndStackingActions()
199 { << 245 {
200 G4RunManager* theRunManager = G4RunManager:: << 246 G4RunManager* theRunManager = G4RunManager::GetRunManager();
201 << 247
202 if (!user_action_already_defined) DefineUser 248 if (!user_action_already_defined) DefineUserActions();
203 << 249
204 // Replace the user action by the adjoint ac << 250 //Replace the user action by the adjoint actions
205 //------------------------------------------ << 251 //-------------------------------------------------
206 << 252
207 theRunManager->G4RunManager::SetUserAction(t << 253 theRunManager->SetUserAction(theAdjointRunAction);
208 if (G4Threading::G4GetThreadId() != -1) { << 254 theRunManager->SetUserAction(theAdjointPrimaryGeneratorAction);
209 theRunManager->G4RunManager::SetUserAction(t << 255 theRunManager->SetUserAction(theAdjointStackingAction);
210 theRunManager->G4RunManager::SetUserAction(t << 256 if (use_user_StackingAction) theAdjointStackingAction->SetUserFwdStackingAction(fUserStackingAction);
211 if (use_user_StackingAction) << 257 else theAdjointStackingAction->SetUserFwdStackingAction(0);
212 theAdjointStackingAction->SetUserFwdStacki <<
213 else <<
214 theAdjointStackingAction->SetUserFwdStacki <<
215 } <<
216 } 258 }
217 << 259 ////////////////////////////////////////////////////////////////////////////////
218 // ------------------------------------------- <<
219 // 260 //
220 void G4AdjointSimManager::ResetUserActions() 261 void G4AdjointSimManager::ResetUserActions()
221 { 262 {
222 G4RunManager* theRunManager = G4RunManager:: << 263 G4RunManager* theRunManager = G4RunManager::GetRunManager();
223 264
224 // Restore the user defined actions << 265 //Restore the user defined actions
225 //------------------------------- 266 //-------------------------------
226 theRunManager->G4RunManager::SetUserAction(f <<
227 if (G4Threading::G4GetThreadId() != -1) { <<
228 theRunManager->G4RunManager::SetUserAction(f <<
229 theRunManager->G4RunManager::SetUserAction(f <<
230 theRunManager->G4RunManager::SetUserAction(f <<
231 theRunManager->G4RunManager::SetUserAction(f <<
232 theRunManager->G4RunManager::SetUserAction(f <<
233 } <<
234 } <<
235 267
236 // ------------------------------------------- << 268 theRunManager->SetUserAction(fUserEventAction);
>> 269 theRunManager->SetUserAction(fUserSteppingAction);
>> 270 theRunManager->SetUserAction(fUserTrackingAction);
>> 271 theRunManager->SetUserAction(fUserPrimaryGeneratorAction);
>> 272 theRunManager->SetUserAction(fUserStackingAction);
>> 273 }
>> 274 ////////////////////////////////////////////////////////////////////////////////
237 // 275 //
238 void G4AdjointSimManager::ResetRestOfUserActio 276 void G4AdjointSimManager::ResetRestOfUserActions()
239 { << 277 {
240 if (G4Threading::G4GetThreadId() == -1) retu << 278 G4RunManager* theRunManager = G4RunManager::GetRunManager();
241 G4RunManager* theRunManager = G4RunManager:: << 279
242 << 280 //Restore the user defined actions
243 // Restore the user defined actions <<
244 //------------------------------- 281 //-------------------------------
245 << 282
246 theRunManager->G4RunManager::SetUserAction(f << 283 theRunManager->SetUserAction(fUserEventAction);
247 theRunManager->G4RunManager::SetUserAction(f << 284 theRunManager->SetUserAction(fUserSteppingAction);
248 theRunManager->G4RunManager::SetUserAction(f << 285 theRunManager->SetUserAction(fUserTrackingAction);
249 } 286 }
250 287
251 // ------------------------------------------- << 288 ////////////////////////////////////////////////////////////////////////////////
252 // 289 //
253 void G4AdjointSimManager::ResetUserPrimaryRunA 290 void G4AdjointSimManager::ResetUserPrimaryRunAndStackingActions()
254 { << 291 {
255 G4RunManager* theRunManager = G4RunManager:: << 292 G4RunManager* theRunManager = G4RunManager::GetRunManager();
256 // Restore the user defined actions << 293 //Restore the user defined actions
257 //------------------------------- 294 //-------------------------------
258 theRunManager->G4RunManager::SetUserAction(f << 295 theRunManager->SetUserAction(fUserRunAction);
259 if (G4Threading::G4GetThreadId() != -1) { << 296 theRunManager->SetUserAction(fUserPrimaryGeneratorAction);
260 theRunManager->G4RunManager::SetUserAction(f << 297 theRunManager->SetUserAction(fUserStackingAction);
261 theRunManager->G4RunManager::SetUserAction(f <<
262 } <<
263 } 298 }
264 << 299 ////////////////////////////////////////////////////////////////////////////////
265 // ------------------------------------------- <<
266 // 300 //
267 void G4AdjointSimManager::DefineUserActions() 301 void G4AdjointSimManager::DefineUserActions()
268 { << 302 {
269 G4RunManager* theRunManager = G4RunManager:: << 303 G4RunManager* theRunManager = G4RunManager::GetRunManager();
270 fUserRunAction = << 304 fUserTrackingAction= const_cast<G4UserTrackingAction* >( theRunManager->GetUserTrackingAction() );
271 const_cast<G4UserRunAction*>(theRunManager << 305 fUserEventAction= const_cast<G4UserEventAction* >( theRunManager->GetUserEventAction() );
272 if (G4Threading::G4GetThreadId() != -1) { << 306 fUserSteppingAction= const_cast<G4UserSteppingAction* >( theRunManager->GetUserSteppingAction() );
273 fUserTrackingAction = const_cast<G4UserTrack << 307 theAdjointSteppingAction->SetUserForwardSteppingAction(fUserSteppingAction);
274 fUserEventAction = const_cast<G4UserEventAct << 308 fUserPrimaryGeneratorAction= const_cast<G4VUserPrimaryGeneratorAction* >( theRunManager->GetUserPrimaryGeneratorAction() );
275 fUserSteppingAction = const_cast<G4UserStepp << 309 fUserRunAction= const_cast<G4UserRunAction*>( theRunManager->GetUserRunAction() );
276 theAdjointSteppingAction->SetUserForwardStep << 310 fUserStackingAction= const_cast<G4UserStackingAction* >( theRunManager->GetUserStackingAction() );
277 fUserPrimaryGeneratorAction = << 311 user_action_already_defined=true;
278 const_cast<G4VUserPrimaryGeneratorAction*> <<
279 fUserStackingAction = const_cast<G4UserStack <<
280 user_action_already_defined = true; <<
281 } <<
282 } <<
283 <<
284 // ------------------------------------------- <<
285 // <<
286 G4bool G4AdjointSimManager::GetAdjointTracking <<
287 { <<
288 return theAdjointTrackingAction->GetIsAdjoin <<
289 } 312 }
290 << 313 ///////////////////////////////////////////////////////////////////////////////
291 // ------------------------------------------- <<
292 // 314 //
293 void G4AdjointSimManager::SetAdjointTrackingMo << 315 void G4AdjointSimManager::SetAdjointTrackingMode(G4bool aBool)//could be removed
294 { 316 {
295 adjoint_tracking_mode = aBool; 317 adjoint_tracking_mode = aBool;
296 << 318
297 if (adjoint_tracking_mode) { 319 if (adjoint_tracking_mode) {
298 SetRestOfAdjointActions(); << 320 SetRestOfAdjointActions();
299 theAdjointStackingAction->SetAdjointMode(t << 321 theAdjointStackingAction->SetAdjointMode(true);
300 theAdjointStackingAction->SetKillTracks(fa << 322 theAdjointStackingAction->SetKillTracks(false);
301 } << 323
>> 324 }
302 else { 325 else {
303 ResetRestOfUserActions(); << 326
304 theAdjointStackingAction->SetAdjointMode(f << 327 ResetRestOfUserActions();
305 if (GetDidAdjParticleReachTheExtSource()) << 328 theAdjointStackingAction->SetAdjointMode(false);
306 theAdjointStackingAction->SetKillTracks( << 329 if (GetDidAdjParticleReachTheExtSource()){
307 RegisterAtEndOfAdjointTrack(); << 330 theAdjointStackingAction->SetKillTracks(false);
308 } << 331 RegisterAtEndOfAdjointTrack();
309 else << 332 }
310 theAdjointStackingAction->SetKillTracks( << 333 else theAdjointStackingAction->SetKillTracks(true);
311 } << 334 }
312 } 335 }
313 << 336 ///////////////////////////////////////////////////////////////////////////////
314 // ------------------------------------------- <<
315 // 337 //
316 G4bool G4AdjointSimManager::GetDidAdjParticleR 338 G4bool G4AdjointSimManager::GetDidAdjParticleReachTheExtSource()
317 { 339 {
318 return (GetNbOfAdointTracksReachingTheExtern << 340 return theAdjointSteppingAction->GetDidAdjParticleReachTheExtSource();
319 } 341 }
320 << 342 ///////////////////////////////////////////////////////////////////////////////
321 // ------------------------------------------- <<
322 // 343 //
323 std::vector<G4ParticleDefinition*>* G4AdjointS << 344 std::vector<G4ParticleDefinition*> G4AdjointSimManager::GetListOfPrimaryFwdParticles()
324 { 345 {
325 return theAdjointPrimaryGeneratorAction->Get 346 return theAdjointPrimaryGeneratorAction->GetListOfPrimaryFwdParticles();
326 } 347 }
327 << 348 ///////////////////////////////////////////////////////////////////////////////
328 // ------------------------------------------- <<
329 // 349 //
330 std::size_t G4AdjointSimManager::GetNbOfPrimar << 350 size_t G4AdjointSimManager::GetNbOfPrimaryFwdParticles()
331 { 351 {
332 return theAdjointPrimaryGeneratorAction->Get << 352 return theAdjointPrimaryGeneratorAction->GetListOfPrimaryFwdParticles().size();
333 } 353 }
334 354
335 // ------------------------------------------- << 355 ///////////////////////////////////////////////////////////////////////////////
336 // 356 //
337 G4ThreeVector G4AdjointSimManager::GetPosition << 357 G4ThreeVector G4AdjointSimManager::GetPositionAtEndOfLastAdjointTrack(){
338 { << 358 return theAdjointTrackingAction->GetPositionAtEndOfLastAdjointTrack();
339 return theAdjointTrackingAction->GetPosition <<
340 } 359 }
341 360
342 // ------------------------------------------- << 361 ///////////////////////////////////////////////////////////////////////////////
343 // 362 //
344 G4ThreeVector G4AdjointSimManager::GetDirectio << 363 G4ThreeVector G4AdjointSimManager::GetDirectionAtEndOfLastAdjointTrack(){
345 { << 364 return theAdjointTrackingAction->GetDirectionAtEndOfLastAdjointTrack();
346 return theAdjointTrackingAction->GetDirectio <<
347 } 365 }
348 << 366 //////////////////////////////////////////////////////////////////////////////
349 // ------------------------------------------- <<
350 // 367 //
351 G4double G4AdjointSimManager::GetEkinAtEndOfLa << 368 G4double G4AdjointSimManager::GetEkinAtEndOfLastAdjointTrack(){
352 { << 369 return theAdjointTrackingAction->GetEkinAtEndOfLastAdjointTrack();
353 return theAdjointTrackingAction->GetEkinAtEn <<
354 } 370 }
355 << 371 ///////////////////////////////////////////////////////////////////////////////
356 // ------------------------------------------- <<
357 // 372 //
358 G4double G4AdjointSimManager::GetEkinNucAtEndO << 373 G4double G4AdjointSimManager::GetEkinNucAtEndOfLastAdjointTrack(){
359 { << 374 return theAdjointTrackingAction->GetEkinNucAtEndOfLastAdjointTrack();
360 return theAdjointTrackingAction->GetEkinNucA <<
361 } 375 }
362 << 376 ///////////////////////////////////////////////////////////////////////////////
363 // ------------------------------------------- <<
364 // 377 //
365 G4double G4AdjointSimManager::GetWeightAtEndOf << 378 G4double G4AdjointSimManager::GetWeightAtEndOfLastAdjointTrack(){
366 { << 379 return theAdjointTrackingAction->GetWeightAtEndOfLastAdjointTrack();
367 return theAdjointTrackingAction->GetWeightAt <<
368 } 380 }
369 << 381 ///////////////////////////////////////////////////////////////////////////////
370 // ------------------------------------------- <<
371 // 382 //
372 G4double G4AdjointSimManager::GetCosthAtEndOfL << 383 G4double G4AdjointSimManager::GetCosthAtEndOfLastAdjointTrack(){
373 { << 384 return theAdjointTrackingAction->GetCosthAtEndOfLastAdjointTrack();
374 return theAdjointTrackingAction->GetCosthAtE <<
375 } 385 }
376 << 386 ///////////////////////////////////////////////////////////////////////////////
377 // ------------------------------------------- <<
378 // 387 //
379 const G4String& G4AdjointSimManager::GetFwdPar 388 const G4String& G4AdjointSimManager::GetFwdParticleNameAtEndOfLastAdjointTrack()
380 { << 389 {return theAdjointTrackingAction->GetFwdParticleNameAtEndOfLastAdjointTrack();
381 return theAdjointTrackingAction->GetFwdParti <<
382 } 390 }
383 << 391 ///////////////////////////////////////////////////////////////////////////////
384 // ------------------------------------------- <<
385 // 392 //
386 G4int G4AdjointSimManager::GetFwdParticlePDGEn << 393 G4int G4AdjointSimManager::GetFwdParticlePDGEncodingAtEndOfLastAdjointTrack(){
387 { << 394 return theAdjointTrackingAction->GetFwdParticlePDGEncodingAtEndOfLastAdjointTrack();
388 return theAdjointTrackingAction->GetFwdParti <<
389 } 395 }
390 396
391 // ------------------------------------------- << 397 ///////////////////////////////////////////////////////////////////////////////
392 // <<
393 G4int G4AdjointSimManager::GetFwdParticleIndex <<
394 { <<
395 return theAdjointTrackingAction->GetLastFwdP <<
396 } <<
397 <<
398 // ------------------------------------------- <<
399 // <<
400 std::size_t G4AdjointSimManager::GetNbOfAdoint <<
401 { <<
402 return theAdjointTrackingAction->GetNbOfAdoi <<
403 } <<
404 <<
405 // ------------------------------------------- <<
406 // <<
407 void G4AdjointSimManager::ClearEndOfAdjointTra <<
408 { <<
409 theAdjointTrackingAction->ClearEndOfAdjointT <<
410 } <<
411 <<
412 // ------------------------------------------- <<
413 // 398 //
414 void G4AdjointSimManager::RegisterAtEndOfAdjoi 399 void G4AdjointSimManager::RegisterAtEndOfAdjointTrack()
415 { 400 {
416 last_pos = theAdjointSteppingAction->GetLast << 401 last_pos = theAdjointSteppingAction->GetLastPosition();
417 last_direction = theAdjointSteppingAction->G 402 last_direction = theAdjointSteppingAction->GetLastMomentum();
418 last_direction /= last_direction.mag(); << 403 last_direction /=last_direction.mag();
419 last_cos_th = last_direction.z(); << 404 last_cos_th = last_direction.z();
420 G4ParticleDefinition* aPartDef = theAdjointS << 405 G4ParticleDefinition* aPartDef= theAdjointSteppingAction->GetLastPartDef();
421 << 406
422 last_fwd_part_name = aPartDef->GetParticleNa << 407 last_fwd_part_name= aPartDef->GetParticleName();
423 << 408
424 last_fwd_part_name.erase(0, 4); << 409 last_fwd_part_name.remove(0,4);
425 << 410
426 last_fwd_part_PDGEncoding = << 411 last_fwd_part_PDGEncoding=G4ParticleTable::GetParticleTable()->FindParticle(last_fwd_part_name)->GetPDGEncoding();
427 G4ParticleTable::GetParticleTable()->FindP << 412
428 << 413 std::vector<G4ParticleDefinition*> aList = theAdjointPrimaryGeneratorAction->GetListOfPrimaryFwdParticles();
429 std::vector<G4ParticleDefinition*>* aList = << 414 last_fwd_part_index=-1;
430 theAdjointPrimaryGeneratorAction->GetListO << 415 size_t i=0;
431 last_fwd_part_index = -1; << 416 while(i<aList.size() && last_fwd_part_index<0) {
432 G4int i = 0; << 417 if (aList[i]->GetParticleName() == last_fwd_part_name) last_fwd_part_index=i;
433 while (i < (G4int)aList->size() && last_fwd_ << 418 i++;
434 if ((*aList)[i]->GetParticleName() == last <<
435 ++i; <<
436 } 419 }
437 << 420
438 last_ekin = theAdjointSteppingAction->GetLas 421 last_ekin = theAdjointSteppingAction->GetLastEkin();
439 last_ekin_nuc = last_ekin; 422 last_ekin_nuc = last_ekin;
440 if (aPartDef->GetParticleType() == "adjoint_ 423 if (aPartDef->GetParticleType() == "adjoint_nucleus") {
441 nb_nuc = static_cast<G4double>(aPartDef->G << 424 nb_nuc=double(aPartDef->GetBaryonNumber());
442 last_ekin_nuc /= nb_nuc; << 425 last_ekin_nuc /=nb_nuc;
443 } 426 }
444 427
445 last_weight = theAdjointSteppingAction->GetL << 428 last_weight = theAdjointSteppingAction->GetLastWeight();
>> 429
>> 430 /* G4PhysicsLogVector* theWeightVector=0;
>> 431 if (last_fwd_part_name =="e-") theWeightVector=electron_last_weight_vector;
>> 432 else if (last_fwd_part_name =="gamma") theWeightVector=gamma_last_weight_vector;
>> 433 else if (last_fwd_part_name =="proton") theWeightVector=proton_last_weight_vector;
>> 434
>> 435 if (theWeightVector){
446 436
447 last_pos_vec.push_back(last_pos); << 437 size_t ind = size_t(std::log10(last_weight/theAdjointPrimaryWeight)*10. + 200);
448 last_direction_vec.push_back(last_direction) << 438 G4double low_val =theWeightVector->GetLowEdgeEnergy(ind);
449 last_ekin_vec.push_back(last_ekin); << 439 G4bool aBool = true;
450 last_ekin_nuc_vec.push_back(last_ekin_nuc); << 440 G4double bin_weight = theWeightVector->GetValue(low_val, aBool)+1.;
451 last_cos_th_vec.push_back(last_cos_th); << 441 theWeightVector->PutValue(ind, bin_weight);
452 last_weight_vec.push_back(last_weight); << 442 }
453 last_fwd_part_PDGEncoding_vec.push_back(last << 443 */
454 last_fwd_part_index_vec.push_back(last_fwd_p << 444 /*if ((last_weight/theAdjointPrimaryWeight)>1.) last_weight*=1000. ;
455 ID_of_last_particle_that_reach_the_ext_sourc << 445 else if ( (last_weight/theAdjointPrimaryWeight)>0.1) last_weight*=100. ;
456 ID_of_last_particle_that_reach_the_ext_sourc << 446 else if ( (last_weight/theAdjointPrimaryWeight)>0.01) last_weight*=10. ;*/
457 ID_of_last_particle_that_reach_the_ext_sou << 447
>> 448
>> 449 //G4cout <<"Last Weight "<<last_weight<<'\t'<<theAdjointPrimaryWeight<<'\t'<<last_weight/theAdjointPrimaryWeight<<std::endl;
>> 450 /*if (last_weight/theAdjointPrimaryWeight >10.) {
>> 451 G4cout<<"Warning a weight increase by a factor : "<<last_weight/theAdjointPrimaryWeight<<std::endl;
>> 452 }
>> 453 */
>> 454
>> 455 ID_of_last_particle_that_reach_the_ext_source++;
458 } 456 }
459 << 457 ///////////////////////////////////////////////////////////////////////////////
460 // ------------------------------------------- <<
461 // 458 //
462 G4bool G4AdjointSimManager::DefineSphericalExt << 459 G4bool G4AdjointSimManager::DefineSphericalExtSource(G4double radius, G4ThreeVector pos)
463 { << 460 {
464 G4double area; << 461 G4double area;
465 return G4AdjointCrossSurfChecker::GetInstanc << 462 return G4AdjointCrossSurfChecker::GetInstance()->AddaSphericalSurface("ExternalSource", radius, pos, area);
466 <<
467 } 463 }
468 << 464 ///////////////////////////////////////////////////////////////////////////////
469 // ------------------------------------------- <<
470 // 465 //
471 G4bool G4AdjointSimManager::DefineSphericalExt << 466 G4bool G4AdjointSimManager::DefineSphericalExtSourceWithCentreAtTheCentreOfAVolume(G4double radius, const G4String& volume_name)
472 G4double radius, const G4String& volume_name <<
473 { 467 {
474 G4double area; << 468 G4double area;
475 G4ThreeVector center; << 469 G4ThreeVector center;
476 return G4AdjointCrossSurfChecker::GetInstanc << 470 return G4AdjointCrossSurfChecker::GetInstance()->AddaSphericalSurfaceWithCenterAtTheCenterOfAVolume( "ExternalSource", radius, volume_name,center, area);
477 ->AddaSphericalSurfaceWithCenterAtTheCente <<
478 <<
479 } 471 }
480 << 472 ///////////////////////////////////////////////////////////////////////////////
481 // ------------------------------------------- <<
482 // 473 //
483 G4bool G4AdjointSimManager::DefineExtSourceOnT << 474 G4bool G4AdjointSimManager::DefineExtSourceOnTheExtSurfaceOfAVolume(const G4String& volume_name)
484 { 475 {
485 G4double area; << 476 G4double area;
486 return G4AdjointCrossSurfChecker::GetInstanc << 477 return G4AdjointCrossSurfChecker::GetInstance()->AddanExtSurfaceOfAvolume( "ExternalSource", volume_name,area);
487 <<
488 } 478 }
489 << 479 ///////////////////////////////////////////////////////////////////////////////
490 // ------------------------------------------- <<
491 // 480 //
492 void G4AdjointSimManager::SetExtSourceEmax(G4d << 481 void G4AdjointSimManager::SetExtSourceEmax(G4double Emax)
493 { 482 {
494 theAdjointSteppingAction->SetExtSourceEMax(E 483 theAdjointSteppingAction->SetExtSourceEMax(Emax);
495 } 484 }
496 << 485 ///////////////////////////////////////////////////////////////////////////////
497 // ------------------------------------------- <<
498 // <<
499 G4bool G4AdjointSimManager::DefineSphericalAdj <<
500 { <<
501 G4double area; <<
502 G4bool aBool = G4AdjointCrossSurfChecker::Ge <<
503 <<
504 theAdjointPrimaryGeneratorAction->SetSpheric <<
505 area_of_the_adjoint_source = area; <<
506 return aBool; <<
507 } <<
508 <<
509 // ------------------------------------------- <<
510 // <<
511 G4bool G4AdjointSimManager::DefineSphericalAdj <<
512 G4double radius, const G4String& volume_name <<
513 { <<
514 G4double area; <<
515 G4ThreeVector center; <<
516 G4bool aBool = <<
517 G4AdjointCrossSurfChecker::GetInstance()-> <<
518 "AdjointSource", radius, volume_name, ce <<
519 theAdjointPrimaryGeneratorAction->SetSpheric <<
520 area_of_the_adjoint_source = area; <<
521 return aBool; <<
522 } <<
523 <<
524 // ------------------------------------------- <<
525 // 486 //
526 G4bool G4AdjointSimManager::DefineAdjointSourc << 487 G4bool G4AdjointSimManager::DefineSphericalAdjointSource(G4double radius, G4ThreeVector pos)
527 { << 488 {
528 G4double area; << 489 G4double area;
529 G4bool aBool = G4AdjointCrossSurfChecker::Ge << 490 G4bool aBool = G4AdjointCrossSurfChecker::GetInstance()->AddaSphericalSurface("AdjointSource", radius, pos, area);
530 "AdjointSource", volume_name, area); << 491 theAdjointPrimaryGeneratorAction->SetSphericalAdjointPrimarySource(radius, pos);
531 area_of_the_adjoint_source = area; << 492 area_of_the_adjoint_source=area;
532 if (aBool) { << 493 return aBool;
533 theAdjointPrimaryGeneratorAction->SetAdjoi << 494 }
534 } << 495 ///////////////////////////////////////////////////////////////////////////////
535 return aBool; << 496 //
>> 497 G4bool G4AdjointSimManager::DefineSphericalAdjointSourceWithCentreAtTheCentreOfAVolume(G4double radius, const G4String& volume_name)
>> 498 {
>> 499 G4double area;
>> 500 G4ThreeVector center;
>> 501 G4bool aBool = G4AdjointCrossSurfChecker::GetInstance()->AddaSphericalSurfaceWithCenterAtTheCenterOfAVolume( "AdjointSource", radius, volume_name,center, area);
>> 502 theAdjointPrimaryGeneratorAction->SetSphericalAdjointPrimarySource(radius, center);
>> 503 area_of_the_adjoint_source=area;
>> 504 return aBool;
>> 505 }
>> 506 ///////////////////////////////////////////////////////////////////////////////
>> 507 //
>> 508 G4bool G4AdjointSimManager::DefineAdjointSourceOnTheExtSurfaceOfAVolume(const G4String& volume_name)
>> 509 {
>> 510 G4double area;
>> 511 G4bool aBool = G4AdjointCrossSurfChecker::GetInstance()->AddanExtSurfaceOfAvolume( "AdjointSource", volume_name,area);
>> 512 area_of_the_adjoint_source=area;
>> 513 if (aBool) {
>> 514 theAdjointPrimaryGeneratorAction->SetAdjointPrimarySourceOnAnExtSurfaceOfAVolume(volume_name);
>> 515 }
>> 516 return aBool;
536 } 517 }
537 << 518 ///////////////////////////////////////////////////////////////////////////////
538 // ------------------------------------------- <<
539 // 519 //
540 void G4AdjointSimManager::SetAdjointSourceEmin 520 void G4AdjointSimManager::SetAdjointSourceEmin(G4double Emin)
541 { 521 {
542 theAdjointPrimaryGeneratorAction->SetEmin(Em 522 theAdjointPrimaryGeneratorAction->SetEmin(Emin);
543 } 523 }
544 << 524 ///////////////////////////////////////////////////////////////////////////////
545 // ------------------------------------------- <<
546 // 525 //
547 void G4AdjointSimManager::SetAdjointSourceEmax 526 void G4AdjointSimManager::SetAdjointSourceEmax(G4double Emax)
548 { 527 {
549 theAdjointPrimaryGeneratorAction->SetEmax(Em 528 theAdjointPrimaryGeneratorAction->SetEmax(Emax);
550 } 529 }
551 << 530 ///////////////////////////////////////////////////////////////////////////////
552 // ------------------------------------------- <<
553 // 531 //
554 void G4AdjointSimManager::ConsiderParticleAsPr 532 void G4AdjointSimManager::ConsiderParticleAsPrimary(const G4String& particle_name)
555 { 533 {
556 theAdjointPrimaryGeneratorAction->ConsiderPa 534 theAdjointPrimaryGeneratorAction->ConsiderParticleAsPrimary(particle_name);
557 } 535 }
558 << 536 ///////////////////////////////////////////////////////////////////////////////
559 // ------------------------------------------- <<
560 // 537 //
561 void G4AdjointSimManager::NeglectParticleAsPri 538 void G4AdjointSimManager::NeglectParticleAsPrimary(const G4String& particle_name)
562 { 539 {
563 theAdjointPrimaryGeneratorAction->NeglectPar 540 theAdjointPrimaryGeneratorAction->NeglectParticleAsPrimary(particle_name);
564 } 541 }
565 << 542 ///////////////////////////////////////////////////////////////////////////////
566 // ------------------------------------------- << 543 //
>> 544 /*void G4AdjointSimManager::SetPrimaryIon(G4int Z, G4int A)
>> 545 {
>> 546 theAdjointPrimaryGeneratorAction->SetPrimaryIon(Z, A);
>> 547 }
>> 548 */
>> 549 ///////////////////////////////////////////////////////////////////////////////
567 // 550 //
568 void G4AdjointSimManager::SetPrimaryIon(G4Part << 551 void G4AdjointSimManager::SetPrimaryIon(G4ParticleDefinition* adjointIon, G4ParticleDefinition* fwdIon)
569 G4Part <<
570 { 552 {
571 theAdjointPrimaryGeneratorAction->SetPrimary 553 theAdjointPrimaryGeneratorAction->SetPrimaryIon(adjointIon, fwdIon);
572 } 554 }
573 << 555 ///////////////////////////////////////////////////////////////////////////////
574 // ------------------------------------------- <<
575 // 556 //
576 const G4String& G4AdjointSimManager::GetPrimar 557 const G4String& G4AdjointSimManager::GetPrimaryIonName()
577 { 558 {
578 return theAdjointPrimaryGeneratorAction->Get 559 return theAdjointPrimaryGeneratorAction->GetPrimaryIonName();
579 } 560 }
580 << 561 ///////////////////////////////////////////////////////////////////////////////
581 // ------------------------------------------- <<
582 // 562 //
583 void G4AdjointSimManager::RegisterAdjointPrima 563 void G4AdjointSimManager::RegisterAdjointPrimaryWeight(G4double aWeight)
584 { 564 {
585 theAdjointPrimaryWeight = aWeight; 565 theAdjointPrimaryWeight = aWeight;
586 theAdjointSteppingAction->SetPrimWeight(aWei 566 theAdjointSteppingAction->SetPrimWeight(aWeight);
587 } << 567 }
588 568
589 // ------------------------------------------- << 569 ///////////////////////////////////////////////////////////////////////////////
590 // 570 //
591 void G4AdjointSimManager::SetAdjointEventActio 571 void G4AdjointSimManager::SetAdjointEventAction(G4UserEventAction* anAction)
592 { 572 {
593 theAdjointEventAction = anAction; 573 theAdjointEventAction = anAction;
594 } 574 }
595 << 575 ///////////////////////////////////////////////////////////////////////////////
596 // ------------------------------------------- <<
597 // 576 //
598 void G4AdjointSimManager::SetAdjointSteppingAc 577 void G4AdjointSimManager::SetAdjointSteppingAction(G4UserSteppingAction* anAction)
599 { 578 {
600 theAdjointSteppingAction->SetUserAdjointStep 579 theAdjointSteppingAction->SetUserAdjointSteppingAction(anAction);
601 } 580 }
602 << 581 ///////////////////////////////////////////////////////////////////////////////
603 // ------------------------------------------- <<
604 // 582 //
605 void G4AdjointSimManager::SetAdjointStackingAc 583 void G4AdjointSimManager::SetAdjointStackingAction(G4UserStackingAction* anAction)
606 { 584 {
607 theAdjointStackingAction->SetUserAdjointStac 585 theAdjointStackingAction->SetUserAdjointStackingAction(anAction);
608 } 586 }
609 587
610 // ------------------------------------------- << 588 ///////////////////////////////////////////////////////////////////////////////
611 // 589 //
612 void G4AdjointSimManager::SetAdjointRunAction( 590 void G4AdjointSimManager::SetAdjointRunAction(G4UserRunAction* anAction)
613 { 591 {
614 theAdjointRunAction = anAction; << 592 theAdjointRunAction=anAction;
615 } << 593 }
616 << 594 ///////////////////////////////////////////////////////////////////////////////
617 // ------------------------------------------- << 595 //
618 // << 596 ///////////////////////////////////////////////////////////////////////////////
619 void G4AdjointSimManager::SetNbOfPrimaryFwdGam <<
620 { <<
621 theAdjointPrimaryGeneratorAction->SetNbPrima <<
622 } <<
623 <<
624 // ------------------------------------------- <<
625 // <<
626 void G4AdjointSimManager::SetNbAdjointPrimaryG <<
627 { <<
628 theAdjointPrimaryGeneratorAction->SetNbAdjoi <<
629 } <<
630 <<
631 // ------------------------------------------- <<
632 // <<
633 void G4AdjointSimManager::SetNbAdjointPrimaryE <<
634 { <<
635 theAdjointPrimaryGeneratorAction->SetNbAdjoi <<
636 } <<
637 <<
638 // ------------------------------------------- <<
639 // 597 //
640 void G4AdjointSimManager::BeginOfRunAction(con 598 void G4AdjointSimManager::BeginOfRunAction(const G4Run* aRun)
641 { if (!adjoint_sim_mode){ <<
642 if(fUserRunAction != nullptr) fUserRunAct <<
643 } <<
644 else { <<
645 if (theAdjointRunAction != nullptr) theAd <<
646 } <<
647 <<
648 //fUserRunAction->BeginOfRunAction(aRun); <<
649 } <<
650 <<
651 // ------------------------------------------- <<
652 // <<
653 void G4AdjointSimManager::EndOfRunAction(const <<
654 { 599 {
655 if (!adjoint_sim_mode) { << 600 G4cout<<"G4AdjointSimManager::BeginOfRunAction"<<std::endl;
656 if (fUserRunAction != nullptr) fUserRunAct <<
657 } <<
658 else if (theAdjointRunAction != nullptr) <<
659 theAdjointRunAction->EndOfRunAction(aRun); <<
660 <<
661 BackToFwdSimulationMode(); <<
662 601
>> 602 if (!adjoint_sim_mode){
>> 603 if(fUserRunAction) fUserRunAction->BeginOfRunAction(aRun);
>> 604 }
>> 605 else {
>> 606 if (theAdjointRunAction) theAdjointRunAction->BeginOfRunAction(aRun);
>> 607 }
663 } 608 }
664 << 609 ///////////////////////////////////////////////////////////////////////////////
665 // ------------------------------------------- <<
666 // 610 //
667 G4ParticleDefinition* G4AdjointSimManager::Get << 611 void G4AdjointSimManager::EndOfRunAction(const G4Run* aRun)
668 { << 612 {if (!adjoint_sim_mode){
669 return theAdjointPrimaryGeneratorAction->Get << 613 if(fUserRunAction) fUserRunAction->EndOfRunAction(aRun);
670 } << 614 }
>> 615 else if (theAdjointRunAction) theAdjointRunAction->EndOfRunAction(aRun);
>> 616 /*
>> 617 #ifdef G4MULTITHREADED
>> 618 if (G4RunManager::GetRunManager()->GetRunManagerType() == G4RunManager::workerRM){
>> 619 if (adjoint_sim_mode) BackToFwdSimulationMode();
>> 620 }
>> 621 #endif
>> 622 */
671 623
672 // ------------------------------------------- <<
673 // <<
674 void G4AdjointSimManager::ResetDidOneAdjPartRe <<
675 { <<
676 theAdjointSteppingAction->ResetDidOneAdjPart <<
677 } 624 }
678 625