Geant4 10.7.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4P2Messenger.cc
Go to the documentation of this file.
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26
27// Author: Ivana Hrivnacova, 24/07/2014 ([email protected])
28
29#include "G4P2Messenger.hh"
30#include "G4VAnalysisManager.hh"
31#include "G4AnalysisUtilities.hh"
32
33#include "G4UIdirectory.hh"
34#include "G4UIcommand.hh"
35#include "G4UIparameter.hh"
36
37#include <iostream>
38
39using namespace G4Analysis;
40
41//_____________________________________________________________________________
42G4P2Messenger::G4P2Messenger(G4VAnalysisManager* manager)
43 : G4UImessenger(),
44 fManager(manager),
45 fHelper(nullptr),
46 fDirectory(nullptr),
47 fCreateP2Cmd(nullptr),
48 fSetP2Cmd(nullptr),
49 fSetP2XCmd(nullptr),
50 fSetP2YCmd(nullptr),
51 fSetP2ZCmd(nullptr),
52 fSetP2TitleCmd(nullptr),
53 fSetP2XAxisCmd(nullptr),
54 fSetP2YAxisCmd(nullptr),
55 fXId(-1),
56 fYId(-1),
57 fXData(),
58 fYData()
59{
60 fHelper = G4Analysis::make_unique<G4AnalysisMessengerHelper>("p2");
61
62 fDirectory = fHelper->CreateHnDirectory();
63
64 CreateP2Cmd();
65
66 SetP2Cmd();
67 fSetP2XCmd = fHelper->CreateSetBinsCommand("x", this);
68 fSetP2YCmd = fHelper->CreateSetBinsCommand("y", this);
69 fSetP2ZCmd = fHelper->CreateSetValuesCommand("z", this);
70
71 fSetP2TitleCmd = fHelper->CreateSetTitleCommand(this);
72 fSetP2XAxisCmd = fHelper->CreateSetAxisCommand("x", this);
73 fSetP2YAxisCmd = fHelper->CreateSetAxisCommand("y", this);
74 fSetP2ZAxisCmd = fHelper->CreateSetAxisCommand("z", this);
75 fSetP2XAxisLogCmd = fHelper->CreateSetAxisLogCommand("x", this);
76 fSetP2YAxisLogCmd = fHelper->CreateSetAxisLogCommand("y", this);
77 fSetP2ZAxisLogCmd = fHelper->CreateSetAxisLogCommand("z", this);
78}
79
80//_____________________________________________________________________________
81G4P2Messenger::~G4P2Messenger()
82{}
83
84//
85// private functions
86//
87
88//_____________________________________________________________________________
89void G4P2Messenger::CreateP2Cmd()
90{
91 auto p2Name = new G4UIparameter("name", 's', false);
92 p2Name->SetGuidance("Profile name (label)");
93
94 auto p2Title = new G4UIparameter("title", 's', false);
95 p2Title->SetGuidance("Profile title");
96
97 auto p2xNbins0 = new G4UIparameter("xnbins0", 'i', true);
98 p2xNbins0->SetGuidance("Number of x-bins (default = 100)");
99 p2xNbins0->SetGuidance("Can be reset with /analysis/p2/set command");
100 p2xNbins0->SetDefaultValue(100);
101
102 auto p2xValMin0 = new G4UIparameter("xvalMin0", 'd', true);
103 p2xValMin0->SetGuidance("Minimum x-value, expressed in unit (default = 0.)");
104 p2xValMin0->SetGuidance("Can be reset with /analysis/p2/set command");
105 p2xValMin0->SetDefaultValue(0.);
106
107 auto p2xValMax0 = new G4UIparameter("xvalMax0", 'd', true);
108 p2xValMax0->SetGuidance("Maximum x-value, expressed in unit (default = 1.)");
109 p2xValMax0->SetGuidance("Can be reset with /analysis/p2/set command");
110 p2xValMax0->SetDefaultValue(1.);
111
112 auto p2xValUnit0 = new G4UIparameter("xvalUnit0", 's', true);
113 p2xValUnit0->SetGuidance("The unit applied to filled x-values and xvalMin0, xvalMax0");
114 p2xValUnit0->SetDefaultValue("none");
115
116 auto p2xValFcn0 = new G4UIparameter("xvalFcn0", 's', true);
117 G4String fcnxGuidance = "The function applied to filled x-values (log, log10, exp, none).";
118 p2xValFcn0->SetGuidance(fcnxGuidance);
119 p2xValFcn0->SetParameterCandidates("log log10 exp none");
120 p2xValFcn0->SetDefaultValue("none");
121
122 auto p2xValBinScheme0 = new G4UIparameter("xvalBinScheme0", 's', true);
123 G4String binSchemeGuidance = "The binning scheme (linear, log).";
124 p2xValBinScheme0->SetParameterCandidates("linear log");
125 p2xValBinScheme0->SetGuidance(binSchemeGuidance);
126 p2xValBinScheme0->SetDefaultValue("linear");
127
128 auto p2yNbins0 = new G4UIparameter("ynbins0", 'i', true);
129 p2yNbins0->SetGuidance("Number of y-bins (default = 100)");
130 p2yNbins0->SetGuidance("Can be reset with /analysis/p2/set command");
131 p2yNbins0->SetDefaultValue(100);
132
133 auto p2yValMin0 = new G4UIparameter("yvalMin0", 'd', true);
134 p2yValMin0->SetGuidance("Minimum y-value, expressed in unit (default = 0.)");
135 p2yValMin0->SetGuidance("Can be reset with /analysis/p2/set command");
136 p2yValMin0->SetDefaultValue(0.);
137
138 auto p2yValMax0 = new G4UIparameter("yvalMax0", 'd', true);
139 p2yValMax0->SetGuidance("Maximum y-value, expressed in unit (default = 1.)");
140 p2yValMax0->SetGuidance("Can be reset with /analysis/p2/set command");
141 p2yValMax0->SetDefaultValue(1.);
142
143 auto p2yValUnit0 = new G4UIparameter("yvalUnit0", 's', true);
144 p2yValUnit0->SetGuidance("The unit applied to filled y-values and yvalMin0, yvalMax0");
145 p2yValUnit0->SetDefaultValue("none");
146
147 auto p2yValFcn0 = new G4UIparameter("yvalFcn0", 's', true);
148 G4String fcnyGuidance = "The function applied to filled y-values (log, log10, exp, none).";
149 p2yValFcn0->SetGuidance(fcnyGuidance);
150 p2yValFcn0->SetParameterCandidates("log log10 exp none");
151 p2yValFcn0->SetDefaultValue("none");
152
153 auto p2yValBinScheme0 = new G4UIparameter("yvalBinScheme0", 's', true);
154 p2yValBinScheme0->SetParameterCandidates("linear log");
155 p2yValBinScheme0->SetGuidance(binSchemeGuidance);
156 p2yValBinScheme0->SetDefaultValue("linear");
157
158 auto p2zValMin0 = new G4UIparameter("zvalMin0", 'd', true);
159 p2zValMin0->SetGuidance("Minimum z-value, expressed in unit (default = 0.)");
160 p2zValMin0->SetGuidance("Can be reset with /analysis/p2/set command");
161 p2zValMin0->SetDefaultValue(0.);
162
163 auto p2zValMax0 = new G4UIparameter("zvalMax0", 'd', true);
164 p2zValMax0->SetGuidance("Maximum z-value, expressed in unit (default = 1.)");
165 p2zValMax0->SetGuidance("Can be reset with /analysis/p2/set command");
166 p2zValMax0->SetDefaultValue(1.);
167
168 auto p2zValUnit0 = new G4UIparameter("zvalUnit0", 's', true);
169 p2zValUnit0->SetGuidance("The unit applied to filled z-values and zvalMin0, zvalMax0");
170 p2zValUnit0->SetDefaultValue("none");
171
172 auto p2zValFcn0 = new G4UIparameter("zvalFcn0", 's', true);
173 G4String fcnzGuidance = "The function applied to filled z-values (log, log10, exp, none).";
174 p2zValFcn0->SetGuidance(fcnzGuidance);
175 p2zValFcn0->SetParameterCandidates("log log10 exp none");
176 p2zValFcn0->SetDefaultValue("none");
177
178 fCreateP2Cmd = G4Analysis::make_unique<G4UIcommand>("/analysis/p2/create", this);
179 fCreateP2Cmd->SetGuidance("Create 2D profile");
180 fCreateP2Cmd->SetParameter(p2Name);
181 fCreateP2Cmd->SetParameter(p2Title);
182 fCreateP2Cmd->SetParameter(p2xNbins0);
183 fCreateP2Cmd->SetParameter(p2xValMin0);
184 fCreateP2Cmd->SetParameter(p2xValMax0);
185 fCreateP2Cmd->SetParameter(p2xValUnit0);
186 fCreateP2Cmd->SetParameter(p2xValFcn0);
187 fCreateP2Cmd->SetParameter(p2xValBinScheme0);
188 fCreateP2Cmd->SetParameter(p2yNbins0);
189 fCreateP2Cmd->SetParameter(p2yValMin0);
190 fCreateP2Cmd->SetParameter(p2yValMax0);
191 fCreateP2Cmd->SetParameter(p2yValUnit0);
192 fCreateP2Cmd->SetParameter(p2yValFcn0);
193 fCreateP2Cmd->SetParameter(p2yValBinScheme0);
194 fCreateP2Cmd->SetParameter(p2zValMin0);
195 fCreateP2Cmd->SetParameter(p2zValMax0);
196 fCreateP2Cmd->SetParameter(p2zValUnit0);
197 fCreateP2Cmd->SetParameter(p2zValFcn0);
198 fCreateP2Cmd->AvailableForStates(G4State_PreInit, G4State_Idle);
199}
200
201
202//_____________________________________________________________________________
203void G4P2Messenger::SetP2Cmd()
204{
205 auto p2Id = new G4UIparameter("id", 'i', false);
206 p2Id->SetGuidance("Profile id");
207 p2Id->SetParameterRange("id>=0");
208
209 auto p2xNbins = new G4UIparameter("xnbins", 'i', false);
210 p2xNbins->SetGuidance("Number of x-bins");
211
212 auto p2xValMin = new G4UIparameter("xvalMin", 'd', false);
213 p2xValMin->SetGuidance("Minimum x-value, expressed in unit");
214
215 auto p2xValMax = new G4UIparameter("xvalMax", 'd', false);
216 p2xValMax->SetGuidance("Maximum x-value, expressed in unit");
217
218 auto p2xValUnit = new G4UIparameter("xvalUnit", 's', true);
219 p2xValUnit->SetGuidance("The unit applied to filled x-values and xvalMin0, xvalMax0");
220 p2xValUnit->SetDefaultValue("none");
221
222 auto p2xValFcn = new G4UIparameter("xvalFcn", 's', true);
223 p2xValFcn->SetParameterCandidates("log log10 exp none");
224 G4String fcnxGuidance = "The function applied to filled x-values (log, log10, exp, none).";
225 p2xValFcn->SetGuidance(fcnxGuidance);
226 p2xValFcn->SetDefaultValue("none");
227
228 auto p2xValBinScheme = new G4UIparameter("xvalBinScheme", 's', true);
229 G4String binSchemeGuidance = "The binning scheme (linear, log).";
230 p2xValBinScheme->SetParameterCandidates("linear log");
231 p2xValBinScheme->SetGuidance(binSchemeGuidance);
232 p2xValBinScheme->SetDefaultValue("linear");
233
234 auto p2yNbins = new G4UIparameter("nybins", 'i', true);
235 p2yNbins->SetGuidance("Number of y-bins");
236
237 auto p2yValMin = new G4UIparameter("yvalMin", 'd', true);
238 p2yValMin->SetGuidance("Minimum y-value, expressed in unit");
239
240 auto p2yValMax = new G4UIparameter("yvalMax", 'd', true);
241 p2yValMax->SetGuidance("Maximum y-value, expressed in unit");
242
243 auto p2yValUnit = new G4UIparameter("yvalUnit", 's', true);
244 p2yValUnit->SetGuidance("The unit applied to filled y-values and yvalMin0, yvalMax0");
245 p2yValUnit->SetDefaultValue("none");
246
247 auto p2yValFcn = new G4UIparameter("yvalFcn", 's', true);
248 p2yValFcn->SetParameterCandidates("log log10 exp none");
249 G4String fcnyGuidance = "The function applied to filled y-values (log, log10, exp, none).";
250 p2yValFcn->SetGuidance(fcnyGuidance);
251 p2yValFcn->SetDefaultValue("none");
252
253 auto p2yValBinScheme = new G4UIparameter("yvalBinScheme", 's', true);
254 p2yValBinScheme->SetParameterCandidates("linear log");
255 p2yValBinScheme->SetGuidance(binSchemeGuidance);
256 p2yValBinScheme->SetDefaultValue("linear");
257
258 auto p2zValMin = new G4UIparameter("zvalMin", 'd', true);
259 p2zValMin->SetGuidance("Minimum z-value, expressed in unit");
260
261 auto p2zValMax = new G4UIparameter("zvalMax", 'd', true);
262 p2zValMax->SetGuidance("Maximum z-value, expressed in unit");
263
264 auto p2zValUnit = new G4UIparameter("zvalUnit", 's', true);
265 p2zValUnit->SetGuidance("The unit applied to filled z-values and zvalMin0, zvalMax0");
266 p2zValUnit->SetDefaultValue("none");
267
268 auto p2zValFcn = new G4UIparameter("zvalFcn", 's', true);
269 p2zValFcn->SetParameterCandidates("log log10 exp none");
270 G4String fcnzGuidance = "The function applied to filled z-values (log, log10, exp, none).";
271 p2zValFcn->SetGuidance(fcnzGuidance);
272 p2zValFcn->SetDefaultValue("none");
273
274 fSetP2Cmd = G4Analysis::make_unique<G4UIcommand>("/analysis/p2/set", this);
275 fSetP2Cmd->SetGuidance("Set parameters for the 2D profile of given id:");
276 fSetP2Cmd->SetGuidance(" nxbins; xvalMin; xvalMax; xunit; xbinScheme");
277 fSetP2Cmd->SetGuidance(" nybins; yvalMin; yvalMax; yunit; ybinScheme");
278 fSetP2Cmd->SetGuidance(" zvalMin; zvalMax; zunit; zfunction");
279 fSetP2Cmd->SetParameter(p2Id);
280 fSetP2Cmd->SetParameter(p2xNbins);
281 fSetP2Cmd->SetParameter(p2xValMin);
282 fSetP2Cmd->SetParameter(p2xValMax);
283 fSetP2Cmd->SetParameter(p2xValUnit);
284 fSetP2Cmd->SetParameter(p2xValFcn);
285 fSetP2Cmd->SetParameter(p2xValBinScheme);
286 fSetP2Cmd->SetParameter(p2yNbins);
287 fSetP2Cmd->SetParameter(p2yValMin);
288 fSetP2Cmd->SetParameter(p2yValMax);
289 fSetP2Cmd->SetParameter(p2yValUnit);
290 fSetP2Cmd->SetParameter(p2yValFcn);
291 fSetP2Cmd->SetParameter(p2yValBinScheme);
292 fSetP2Cmd->SetParameter(p2zValMin);
293 fSetP2Cmd->SetParameter(p2zValMax);
294 fSetP2Cmd->SetParameter(p2zValUnit);
295 fSetP2Cmd->SetParameter(p2zValFcn);
296 fSetP2Cmd->AvailableForStates(G4State_PreInit, G4State_Idle);
297}
298
299
300//
301// public functions
302//
303
304//_____________________________________________________________________________
305void G4P2Messenger::SetNewValue(G4UIcommand* command, G4String newValues)
306{
307 // tokenize parameters in a vector
308 std::vector<G4String> parameters;
309 G4Analysis::Tokenize(newValues, parameters);
310 // check consistency
311 if ( parameters.size() != command->GetParameterEntries() ) {
312 // Should never happen but let's check anyway for consistency
313 fHelper->WarnAboutParameters(command, parameters.size());
314 return;
315 }
316
317 if ( command == fCreateP2Cmd.get() ) {
318 auto counter = 0;
319 auto name = parameters[counter++];
320 auto title = parameters[counter++];
321 G4AnalysisMessengerHelper::BinData xdata;
322 fHelper->GetBinData(xdata, parameters, counter);
323 auto xunit = GetUnitValue(xdata.fSunit);
324 G4AnalysisMessengerHelper::BinData ydata;
325 fHelper->GetBinData(ydata, parameters, counter);
326 auto yunit = GetUnitValue(ydata.fSunit);
327 G4AnalysisMessengerHelper::ValueData zdata;
328 fHelper->GetValueData(zdata, parameters, counter);
329 auto zunit = GetUnitValue(zdata.fSunit);
330 fManager->CreateP2(name, title,
331 xdata.fNbins, xdata.fVmin*xunit, xdata.fVmax*xunit,
332 ydata.fNbins, ydata.fVmin*yunit, ydata.fVmax*yunit,
333 zdata.fVmin*zunit, zdata.fVmax*zunit,
334 xdata.fSunit, ydata.fSunit, zdata.fSunit,
335 xdata.fSfcn, ydata.fSfcn, zdata.fSfcn,
336 xdata.fSbinScheme, ydata.fSbinScheme);
337 }
338 else if ( command == fSetP2Cmd.get() ) {
339 auto counter = 0;
340 auto id = G4UIcommand::ConvertToInt(parameters[counter++]);
341 G4AnalysisMessengerHelper::BinData xdata;
342 fHelper->GetBinData(xdata, parameters, counter);
343 auto xunit = GetUnitValue(xdata.fSunit);
344 G4AnalysisMessengerHelper::BinData ydata;
345 fHelper->GetBinData(ydata, parameters, counter);
346 auto yunit = GetUnitValue(ydata.fSunit);
347 G4AnalysisMessengerHelper::ValueData zdata;
348 fHelper->GetValueData(zdata, parameters, counter);
349 auto zunit = GetUnitValue(zdata.fSunit);
350 fManager->SetP2(id,
351 xdata.fNbins, xdata.fVmin*xunit, xdata.fVmax*xunit,
352 ydata.fNbins, ydata.fVmin*yunit, ydata.fVmax*yunit,
353 zdata.fVmin*zunit, zdata.fVmax*zunit,
354 xdata.fSunit, ydata.fSunit, zdata.fSunit,
355 xdata.fSfcn, ydata.fSfcn, zdata.fSfcn,
356 xdata.fSbinScheme, ydata.fSbinScheme);
357 }
358 else if ( command == fSetP2XCmd.get() ) {
359 // Only save values
360 auto counter = 0;
361 fXId = G4UIcommand::ConvertToInt(parameters[counter++]);
362 fHelper->GetBinData(fXData, parameters, counter);
363 }
364 else if ( command == fSetP2YCmd.get() ) {
365 // Save values
366 auto counter = 0;
367 fYId = G4UIcommand::ConvertToInt(parameters[counter++]);
368 // Check if setX command was called
369 if ( fXId == -1 || fXId != fYId ) {
370 fHelper->WarnAboutSetCommands();
371 return;
372 }
373 fHelper->GetBinData(fYData, parameters, counter);
374 // Set values
375 // (another set may follow if setZ is also called)
376 auto xunit = GetUnitValue(fXData.fSunit);
377 auto yunit = GetUnitValue(fYData.fSunit);
378 fManager->SetP2(fYId,
379 fXData.fNbins, fXData.fVmin*xunit, fXData.fVmax*xunit,
380 fYData.fNbins, fYData.fVmin*yunit, fYData.fVmax*yunit,
381 0., 0.,
382 fXData.fSunit, fYData.fSunit, "none",
383 fXData.fSfcn, fYData.fSfcn, "none",
384 fXData.fSbinScheme, fYData.fSbinScheme);
385 }
386 else if ( command == fSetP2ZCmd.get() ) {
387 auto counter = 0;
388 auto id = G4UIcommand::ConvertToInt(parameters[counter++]);
389 // Check if setX and setY command was called
390 if ( fXId == -1 || fXId != id ||
391 fYId == -1 || fYId != id ) {
392 fHelper->WarnAboutSetCommands();
393 return;
394 }
395 auto xunit = GetUnitValue(fXData.fSunit);
396 auto yunit = GetUnitValue(fYData.fSunit);
397 G4AnalysisMessengerHelper::ValueData zdata;
398 fHelper->GetValueData(zdata, parameters, counter);
399 auto zunit = GetUnitValue(zdata.fSunit);
400 fManager->SetP2(id,
401 fXData.fNbins, fXData.fVmin*xunit, fXData.fVmax*xunit,
402 fYData.fNbins, fYData.fVmin*yunit, fYData.fVmax*yunit,
403 zdata.fVmin*zunit, zdata.fVmax*zunit,
404 fXData.fSunit, fYData.fSunit, zdata.fSunit,
405 fXData.fSfcn, fYData.fSfcn, zdata.fSfcn,
406 fXData.fSbinScheme, fYData.fSbinScheme);
407 fXId = -1;
408 fYId = -1;
409 }
410 else if ( command == fSetP2TitleCmd.get() ) {
411 auto counter = 0;
412 auto id = G4UIcommand::ConvertToInt(parameters[counter++]);
413 auto title = parameters[counter++];
414 fManager->SetP2Title(id, title);
415 }
416 else if ( command == fSetP2XAxisCmd.get() ) {
417 auto counter = 0;
418 auto id = G4UIcommand::ConvertToInt(parameters[counter++]);
419 auto xaxis = parameters[counter++];
420 fManager->SetP2XAxisTitle(id, xaxis);
421 }
422 else if ( command == fSetP2YAxisCmd.get() ) {
423 auto counter = 0;
424 auto id = G4UIcommand::ConvertToInt(parameters[counter++]);
425 auto yaxis = parameters[counter++];
426 fManager->SetP2YAxisTitle(id, yaxis);
427 }
428 else if ( command == fSetP2ZAxisCmd.get() ) {
429 auto counter = 0;
430 auto id = G4UIcommand::ConvertToInt(parameters[counter++]);
431 auto zaxis = parameters[counter++];
432 fManager->SetP2ZAxisTitle(id, zaxis);
433 }
434 else if ( command == fSetP2XAxisLogCmd.get() ) {
435 auto counter = 0;
436 auto id = G4UIcommand::ConvertToInt(parameters[counter++]);
437 auto xaxisLog = G4UIcommand::ConvertToBool(parameters[counter++]);
438 fManager->SetP2XAxisIsLog(id, xaxisLog);
439 }
440 else if ( command == fSetP2YAxisLogCmd.get() ) {
441 auto counter = 0;
442 auto id = G4UIcommand::ConvertToInt(parameters[counter++]);
443 auto yaxisLog = G4UIcommand::ConvertToBool(parameters[counter++]);
444 fManager->SetP2YAxisIsLog(id, yaxisLog);
445 }
446 else if ( command == fSetP2ZAxisLogCmd.get() ) {
447 auto counter = 0;
448 auto id = G4UIcommand::ConvertToInt(parameters[counter++]);
449 auto zaxisLog = G4UIcommand::ConvertToBool(parameters[counter++]);
450 fManager->SetP2ZAxisIsLog(id, zaxisLog);
451 }
452}
G4State_Idle
@ G4State_Idle
Definition: G4ApplicationState.hh:86
G4State_PreInit
@ G4State_PreInit
Definition: G4ApplicationState.hh:84
G4P2Messenger::SetNewValue
virtual void SetNewValue(G4UIcommand *command, G4String value) final
Definition: G4P2Messenger.cc:305
G4P2Messenger::G4P2Messenger
G4P2Messenger(G4VAnalysisManager *manager)
Definition: G4P2Messenger.cc:42
G4P2Messenger::~G4P2Messenger
virtual ~G4P2Messenger()
Definition: G4P2Messenger.cc:81
G4UIcommand::GetParameterEntries
std::size_t GetParameterEntries() const
Definition: G4UIcommand.hh:138
G4UIcommand::ConvertToInt
static G4int ConvertToInt(const char *st)
Definition: G4UIcommand.cc:543
G4UIcommand::ConvertToBool
static G4bool ConvertToBool(const char *st)
Definition: G4UIcommand.cc:530
G4VAnalysisManager::SetP2YAxisTitle
G4bool SetP2YAxisTitle(G4int id, const G4String &title)
G4VAnalysisManager::CreateP2
G4int CreateP2(const G4String &name, const G4String &title, G4int nxbins, G4double xmin, G4double xmax, G4int nybins, G4double ymin, G4double ymax, G4double zmin=0, G4double zmax=0, const G4String &xunitName="none", const G4String &yunitName="none", const G4String &zunitName="none", const G4String &xfcnName="none", const G4String &yfcnName="none", const G4String &zfcnName="none", const G4String &xbinSchemeName="linear", const G4String &ybinSchemeName="linear")
Definition: G4VAnalysisManager.cc:613
G4VAnalysisManager::SetP2ZAxisIsLog
G4bool SetP2ZAxisIsLog(G4int id, G4bool isLog)
G4VAnalysisManager::SetP2
G4bool SetP2(G4int id, G4int nxbins, G4double xmin, G4double xmax, G4int nybins, G4double ymin, G4double ymax, G4double zmin=0, G4double zmax=0, const G4String &xunitName="none", const G4String &yunitName="none", const G4String &zunitName="none", const G4String &xfcnName="none", const G4String &yfcnName="none", const G4String &zfcnName="none", const G4String &xbinSchemeName="linear", const G4String &ybinSchemeName="linear")
Definition: G4VAnalysisManager.cc:702
G4VAnalysisManager::SetP2Title
G4bool SetP2Title(G4int id, const G4String &title)
G4VAnalysisManager::SetP2ZAxisTitle
G4bool SetP2ZAxisTitle(G4int id, const G4String &title)
G4VAnalysisManager::SetP2YAxisIsLog
G4bool SetP2YAxisIsLog(G4int id, G4bool isLog)
G4VAnalysisManager::SetP2XAxisIsLog
G4bool SetP2XAxisIsLog(G4int id, G4bool isLog)
G4VAnalysisManager::SetP2XAxisTitle
G4bool SetP2XAxisTitle(G4int id, const G4String &title)
G4Analysis::Tokenize
void Tokenize(const G4String &line, std::vector< G4String > &tokens)
Definition: G4AnalysisUtilities.cc:173
G4Analysis::GetUnitValue
G4double GetUnitValue(const G4String &unit)
Definition: G4AnalysisUtilities.cc:152