source: trunk/documents/UserDoc/UsersGuides/ForApplicationDeveloper/html/GettingStarted/executeProgram.html

Last change on this file was 1208, checked in by garnier, 16 years ago

CVS update
File size: 10.9 KB
Line 
1<HTML>
2<TITLE>
3</TITLE>
4<!-- Changed by: Katsuya Amako, 30-Jul-1998 -->
5<!-- Changed by: Michel MAIRE, 3-Aug-1998 -->
6<!-- Changed by: Katsuya Amako, 16-Nov-1998 -->
7<!-- Changed by: Dennis Wright, 28-Nov-2001 -->
8<!-- Proof read by: Joe Chuma, 15-Jun-1999 -->
9<BODY>
10<TABLE WIDTH="100%"><TR>
11<TD>
12
13
14<A HREF="index.html">
15<IMG SRC="../../../../resources/html/IconsGIF/Contents.gif" ALT="Contents"></A>
16<A HREF="graphicalUserInterface.html">
17<IMG SRC="../../../../resources/html/IconsGIF/Previous.gif" ALT="Previous"></A>
18<A HREF="visualization.html">
19<IMG SRC="../../../../resources/html/IconsGIF/Next.gif" ALT="Next"></A>
20</TD>
21<TD ALIGN="Right">
22<FONT SIZE="-1" COLOR="#238E23">
23<B>Geant4 User's Guide</B>
24<BR>
25<B>For Application Developers</B>
26<BR>
27<B>Getting Started with Geant4</B>
28</FONT>
29</TD>
30</TR></TABLE>
31<BR><BR>
32
33<P ALIGN="Center">
34<FONT SIZE="+3" COLOR="#238E23">
35<B>2.9 How to Execute a Program</B>
36</FONT>
37<BR><BR>
38
39<HR ALIGN="Center" SIZE="7%">
40<p>
41
42<a name="2.9.1">
43<H2>2.9.1 Introduction</H2></a>
44
45 A Geant4 application can be run either in
46<UL>
47 <LI>`purely hard-coded` batch mode
48 <LI>batch mode, but reading a macro of commands
49 <LI>interactive mode, driven by command lines
50 <LI>interactive mode via a Graphical User Interface
51</UL>
52 The last mode will be covered in <a href="graphicalUserInterface.html">Section 2.8</a>. The first three modes are explained here.
53<P>
54
55<hr>
56<a name="2.9.2">
57<H2>2.9.2 'Hard-coded' Batch Mode</H2></a>
58
59 Below is an example of the main program for an application which will run
60 in batch mode.
61<p>
62<center>
63<table border=2 cellpadding=10>
64<tr>
65<td>
66<PRE>
67int main()
68{
69 // Construct the default run manager
70 G4RunManager* runManager = new G4RunManager;
71
72 // set mandatory initialization classes
73 runManager->SetUserInitialization(new ExN01DetectorConstruction);
74 runManager->SetUserInitialization(new ExN01PhysicsList);
75
76 // set mandatory user action class
77 runManager->SetUserAction(new ExN01PrimaryGeneratorAction);
78
79 // Initialize G4 kernel
80 runManager->Initialize();
81
82 // start a run
83 int numberOfEvent = 1000;
84 runManager->BeamOn(numberOfEvent);
85
86 // job termination
87 delete runManager;
88 return 0;
89}
90</PRE>
91</td>
92</tr>
93<tr>
94<td align=center>
95 Source listing 2.9.1<BR>
96 An example of the <tt>main()</tt> routine for an application
97 which will run in batch mode.
98</td>
99</tr>
100</table></center>
101<p>
102 Even the number of events in the run is `frozen`. To change this number
103 you must at least recompile <tt>main()</tt>.
104<P>
105
106<HR>
107<a name="2.9.3">
108<H2>2.9.3 Batch Mode with Macro File</H2></a>
109
110Below is an example of the main program for an application which will run
111in batch mode, but reading a file of commands.
112<p>
113<center>
114<table border=2 cellpadding=10>
115<tr>
116<td>
117<PRE>
118int main(int argc,char** argv) {
119
120 // Construct the default run manager
121 G4RunManager * runManager = new G4RunManager;
122
123 // set mandatory initialization classes
124 runManager->SetUserInitialization(new MyDetectorConstruction);
125 runManager->SetUserInitialization(new MyPhysicsList);
126
127 // set mandatory user action class
128 runManager->SetUserAction(new MyPrimaryGeneratorAction);
129
130 // Initialize G4 kernel
131 runManager->Initialize();
132
133 //read a macro file of commands
134 G4UImanager * UI = G4UImanager::getUIpointer();
135 G4String command = "/control/execute ";
136 G4String fileName = argv[1];
137 UI->applyCommand(command+fileName);
138
139 delete runManager;
140 return 0;
141}
142</PRE>
143</td>
144</tr>
145<tr>
146<td align=center>
147 Source listing 2.9.2<BR>
148 An example of the <tt>main()</tt> routine for an application which will run
149 in batch mode, but reading a file of commands.
150</td>
151</tr>
152</table></center>
153<p>
154 This example will be executed with the command:
155<PRE>
156 > myProgram run1.mac
157</PRE>
158<p>
159 where <tt>myProgram</tt> is the name of your executable and <TT>run1.mac</TT>
160 is a macro of commands located in the current directory, which could
161 look like:
162<p>
163<center>
164<table border=2 cellpadding=10>
165<tr>
166<td>
167<PRE>
168#
169# Macro file for "myProgram.cc"
170#
171# set verbose level for this run
172#
173/run/verbose 2
174/event/verbose 0
175/tracking/verbose 1
176#
177# Set the initial kinematic and run 100 events
178# electron 1 GeV to the direction (1.,0.,0.)
179#
180/gun/particle e-
181/gun/energy 1 GeV
182/run/beamOn 100
183</PRE>
184</td>
185</tr>
186<tr>
187<td align=center>
188 Source listing 2.9.3<BR>
189 A typical command macro.
190</td>
191</tr>
192</table></center>
193<p>
194 Indeed, you can re-execute your program with different run conditions without
195 recompiling anything.
196<P>
197<table>
198<tr>
199<td valign=top>Digression:
200<td>many G4 category of classes have a verbose flag which controls
201 the level of 'verbosity'.<br>
202 Usually <TT>verbose=0</TT> means silent. For instance
203<UL>
204<LI><t>/run/verbose</t> is for the <t>RunManager</t>
205<LI><t>/event/verbose</t> is for the <t>EventManager</t>
206<LI><t>/tracking/verbose</t> is for the <t>TrackingManager</t>
207<LI>...etc...
208</UL>
209</table>
210<P>
211
212<HR>
213<a name="2.9.4">
214<H2>2.9.4 Interactive Mode Driven by Command Lines</H2></a>
215
216 Below is an example of the main program for an application which will run
217 interactively, waiting for command lines entered from the keyboard.
218<p>
219<center>
220<table border=2 cellpadding=10>
221<tr>
222<td>
223<PRE>
224int main(int argc,char** argv) {
225
226 // Construct the default run manager
227 G4RunManager * runManager = new G4RunManager;
228
229 // set mandatory initialization classes
230 runManager->SetUserInitialization(new MyDetectorConstruction);
231 runManager->SetUserInitialization(new MyPhysicsList);
232
233 // visualization manager
234 G4VisManager* visManager = new G4VisExecutive;
235 visManager->Initialize();
236
237 // set user action classes
238 runManager->SetUserAction(new MyPrimaryGeneratorAction);
239 runManager->SetUserAction(new MyRunAction);
240 runManager->SetUserAction(new MyEventAction);
241 runManager->SetUserAction(new MySteppingAction);
242
243 // Initialize G4 kernel
244 runManager->Initialize();
245
246 // Define UI terminal for interactive mode
247 G4UIsession * session = new G4UIterminal;
248 session->SessionStart();
249 delete session;
250
251 // job termination
252 delete visManager;
253 delete runManager;
254
255 return 0;
256}
257</PRE>
258</td>
259</tr>
260<tr>
261<td align=center>
262 Source listing 2.9.4<BR>
263 An example of the <tt>main()</tt> routine for an application which will run
264 interactively, waiting for commands from the keyboard.
265</td>
266</tr>
267</table></center>
268<p>
269 This example will be executed with the command:
270<PRE>
271 > myProgram
272</PRE>
273 where <TT>myProgram</TT> is the name of your executable.
274<P>
275 The G4 kernel will prompt:
276<PRE>
277 Idle>
278</PRE>
279 and you can start your session. An example session could be:
280<p>
281 Create an empty scene ("world" is default):
282<PRE>
283 Idle> /vis/scene/create
284</PRE>
285 Add a volume to the scene:
286<PRE>
287 Idle> /vis/scene/add/volume
288</PRE>
289 Create a scene handler for a specific graphics system.
290 Change the next line to choose another graphic system:
291<PRE>
292 Idle> /vis/sceneHandler/create OGLIX
293</PRE>
294 Create a viewer:
295<PRE>
296 Idle> /vis/viewer/create
297</PRE>
298 Draw the scene, etc.:
299<PRE>
300 Idle> /vis/scene/notifyHandlers
301 Idle> /run/verbose 0
302 Idle> /event/verbose 0
303 Idle> /tracking/verbose 1
304 Idle> /gun/particle mu+
305 Idle> /gun/energy 10 GeV
306 Idle> /run/beamOn 1
307 Idle> /gun/particle proton
308 Idle> /gun/energy 100 MeV
309 Idle> /run/beamOn 3
310 Idle> exit
311</PRE>
312<p>
313 For the meaning of the machine state <TT>Idle</TT>, see
314 <a href="../Fundamentals/run.html#3.4.2">Section 3.4.2</a>.
315<P>
316This mode is useful for running a few events in debug mode and visualizing
317them. Notice that the <i>VisManager</I> is created in the <tt>main()</tt>,
318and the visualization system is choosen via the command:
319<PRE>
320 /vis/sceneHandler/create OGLIX
321</PRE>
322<P>
323
324<HR>
325<a name="2.9.5">
326<H2>2.9.5 General Case</H2></a>
327
328 Most of the examples in the <TT>$G4INSTALL/examples/</TT> directory
329 have the following <TT>main()</TT>, which covers cases 2 and 3 above.
330 Thus, the application can be run either in batch or interactive mode.
331<p>
332<center>
333<table border=2 cellpadding=10>
334<tr>
335<td>
336<PRE>
337int main(int argc,char** argv) {
338
339 // Construct the default run manager
340 G4RunManager * runManager = new G4RunManager;
341
342 // set mandatory initialization classes
343 N03DetectorConstruction* detector = new N03DetectorConstruction;
344 runManager->SetUserInitialization(detector);
345 runManager->SetUserInitialization(new N03PhysicsList);
346
347#ifdef G4VIS_USE
348 // visualization manager
349 G4VisManager* visManager = new G4VisExecutive;
350 visManager->Initialize();
351#endif
352
353 // set user action classes
354 runManager->SetUserAction(new N03PrimaryGeneratorAction(detector));
355 runManager->SetUserAction(new N03RunAction);
356 runManager->SetUserAction(new N03EventAction);
357 runManager->SetUserAction(new N03SteppingAction);
358
359 // get the pointer to the User Interface manager
360 G4UImanager* UI = G4UImanager::GetUIpointer();
361
362 if (argc==1) // Define UI terminal for interactive mode
363 {
364 G4UIsession * session = new G4UIterminal;
365 UI->ApplyCommand("/control/execute prerunN03.mac");
366 session->SessionStart();
367 delete session;
368 }
369 else // Batch mode
370 {
371 G4String command = "/control/execute ";
372 G4String fileName = argv[1];
373 UI->ApplyCommand(command+fileName);
374 }
375
376 // job termination
377#ifdef G4VIS_USE
378 delete visManager;
379#endif
380 delete runManager;
381
382 return 0;
383}
384</PRE>
385</td>
386</tr>
387<tr>
388<td align=center>
389 Source listing 2.9.5<BR>
390 The typical <tt>main()</tt> routine from the examples directory.
391</td>
392</tr>
393</table></center>
394<p>
395 Notice that the visualization system is under the control of the precompiler
396 variable <TT>G4VIS_USE</TT>.
397 Notice also that, in interactive mode, few intializations have been put in the
398 macro <TT>prerunN03.mac</TT> which is executed before the session start.
399<p>
400<center>
401<table border=2 cellpadding=10>
402<tr>
403<td>
404<PRE>
405 # Macro file for the initialization phase of "exampleN03.cc"
406 #
407 # Sets some default verbose flags
408 # and initializes the graphics.
409 #
410 /control/verbose 2
411 /control/saveHistory
412 /run/verbose 2
413 #
414 /run/particle/dumpCutValues
415 #
416 # Create empty scene ("world" is default)
417 /vis/scene/create
418 #
419 # Add volume to scene
420 /vis/scene/add/volume
421 #
422 # Create a scene handler for a specific graphics system
423 # Edit the next line(s) to choose another graphic system
424 #
425 #/vis/sceneHandler/create DAWNFILE
426 /vis/sceneHandler/create OGLIX
427 #
428 # Create a viewer
429 /vis/viewer/create
430 #
431 # Draw scene
432 /vis/scene/notifyHandlers
433 #
434 # for drawing the tracks
435 # if too many tracks cause core dump => storeTrajectory 0
436 /tracking/storeTrajectory 1
437 #/vis/scene/include/trajectories
438</PRE>
439</td>
440</tr>
441<tr>
442<td align=center>
443 Source listing 2.9.6<BR>
444 The <tt>prerunN03.mac</tt> macro.
445</td>
446</tr>
447</table></center>
448<P>
449 Also, this example demonstrates that you can read and execute a macro interactively:
450<PRE>
451 Idle> /control/execute mySubMacro.mac
452</PRE>
453<p>
454
455<HR>
456<A HREF="../../../../Authors/html/subjectsToAuthors.html">
457<I>About the authors</I></A>
458
459</BODY>
460</HTML>
Note: See TracBrowser for help on using the repository browser.