Geant4-11
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 (ivana@ipno.in2p3.fr)
28
29#include "G4P2Messenger.hh"
30#include "G4VAnalysisManager.hh"
31
32#include "G4UIdirectory.hh"
33#include "G4UIcommand.hh"
34#include "G4UIparameter.hh"
35
36using namespace G4Analysis;
37
38//_____________________________________________________________________________
39G4P2Messenger::G4P2Messenger(G4VAnalysisManager* manager)
40 : G4UImessenger(),
41 fManager(manager)
42{
43 fHelper = std::make_unique<G4AnalysisMessengerHelper>("p2");
44
45 fDirectory = fHelper->CreateHnDirectory();
46
47 CreateP2Cmd();
48
49 SetP2Cmd();
50 fSetP2XCmd = fHelper->CreateSetBinsCommand("x", this);
51 fSetP2YCmd = fHelper->CreateSetBinsCommand("y", this);
52 fSetP2ZCmd = fHelper->CreateSetValuesCommand("z", this);
53
54 fSetP2TitleCmd = fHelper->CreateSetTitleCommand(this);
55 fSetP2XAxisCmd = fHelper->CreateSetAxisCommand("x", this);
56 fSetP2YAxisCmd = fHelper->CreateSetAxisCommand("y", this);
57 fSetP2ZAxisCmd = fHelper->CreateSetAxisCommand("z", this);
58 fSetP2XAxisLogCmd = fHelper->CreateSetAxisLogCommand("x", this);
59 fSetP2YAxisLogCmd = fHelper->CreateSetAxisLogCommand("y", this);
60 fSetP2ZAxisLogCmd = fHelper->CreateSetAxisLogCommand("z", this);
61}
62
63//_____________________________________________________________________________
64G4P2Messenger::~G4P2Messenger() = default;
65
66//
67// private functions
68//
69
70//_____________________________________________________________________________
71void G4P2Messenger::CreateP2Cmd()
72{
73 auto p2Name = new G4UIparameter("name", 's', false);
74 p2Name->SetGuidance("Profile name (label)");
75
76 auto p2Title = new G4UIparameter("title", 's', false);
77 p2Title->SetGuidance("Profile title");
78
79 auto p2xNbins0 = new G4UIparameter("xnbins0", 'i', true);
80 p2xNbins0->SetGuidance("Number of x-bins (default = 100)");
81 p2xNbins0->SetGuidance("Can be reset with /analysis/p2/set command");
82 p2xNbins0->SetDefaultValue(100);
83
84 auto p2xValMin0 = new G4UIparameter("xvalMin0", 'd', true);
85 p2xValMin0->SetGuidance("Minimum x-value, expressed in unit (default = 0.)");
86 p2xValMin0->SetGuidance("Can be reset with /analysis/p2/set command");
87 p2xValMin0->SetDefaultValue(0.);
88
89 auto p2xValMax0 = new G4UIparameter("xvalMax0", 'd', true);
90 p2xValMax0->SetGuidance("Maximum x-value, expressed in unit (default = 1.)");
91 p2xValMax0->SetGuidance("Can be reset with /analysis/p2/set command");
92 p2xValMax0->SetDefaultValue(1.);
93
94 auto p2xValUnit0 = new G4UIparameter("xvalUnit0", 's', true);
95 p2xValUnit0->SetGuidance("The unit applied to filled x-values and xvalMin0, xvalMax0");
96 p2xValUnit0->SetDefaultValue("none");
97
98 auto p2xValFcn0 = new G4UIparameter("xvalFcn0", 's', true);
99 G4String fcnxGuidance = "The function applied to filled x-values (log, log10, exp, none).";
100 p2xValFcn0->SetGuidance(fcnxGuidance);
101 p2xValFcn0->SetParameterCandidates("log log10 exp none");
102 p2xValFcn0->SetDefaultValue("none");
103
104 auto p2xValBinScheme0 = new G4UIparameter("xvalBinScheme0", 's', true);
105 G4String binSchemeGuidance = "The binning scheme (linear, log).";
106 p2xValBinScheme0->SetParameterCandidates("linear log");
107 p2xValBinScheme0->SetGuidance(binSchemeGuidance);
108 p2xValBinScheme0->SetDefaultValue("linear");
109
110 auto p2yNbins0 = new G4UIparameter("ynbins0", 'i', true);
111 p2yNbins0->SetGuidance("Number of y-bins (default = 100)");
112 p2yNbins0->SetGuidance("Can be reset with /analysis/p2/set command");
113 p2yNbins0->SetDefaultValue(100);
114
115 auto p2yValMin0 = new G4UIparameter("yvalMin0", 'd', true);
116 p2yValMin0->SetGuidance("Minimum y-value, expressed in unit (default = 0.)");
117 p2yValMin0->SetGuidance("Can be reset with /analysis/p2/set command");
118 p2yValMin0->SetDefaultValue(0.);
119
120 auto p2yValMax0 = new G4UIparameter("yvalMax0", 'd', true);
121 p2yValMax0->SetGuidance("Maximum y-value, expressed in unit (default = 1.)");
122 p2yValMax0->SetGuidance("Can be reset with /analysis/p2/set command");
123 p2yValMax0->SetDefaultValue(1.);
124
125 auto p2yValUnit0 = new G4UIparameter("yvalUnit0", 's', true);
126 p2yValUnit0->SetGuidance("The unit applied to filled y-values and yvalMin0, yvalMax0");
127 p2yValUnit0->SetDefaultValue("none");
128
129 auto p2yValFcn0 = new G4UIparameter("yvalFcn0", 's', true);
130 G4String fcnyGuidance = "The function applied to filled y-values (log, log10, exp, none).";
131 p2yValFcn0->SetGuidance(fcnyGuidance);
132 p2yValFcn0->SetParameterCandidates("log log10 exp none");
133 p2yValFcn0->SetDefaultValue("none");
134
135 auto p2yValBinScheme0 = new G4UIparameter("yvalBinScheme0", 's', true);
136 p2yValBinScheme0->SetParameterCandidates("linear log");
137 p2yValBinScheme0->SetGuidance(binSchemeGuidance);
138 p2yValBinScheme0->SetDefaultValue("linear");
139
140 auto p2zValMin0 = new G4UIparameter("zvalMin0", 'd', true);
141 p2zValMin0->SetGuidance("Minimum z-value, expressed in unit (default = 0.)");
142 p2zValMin0->SetGuidance("Can be reset with /analysis/p2/set command");
143 p2zValMin0->SetDefaultValue(0.);
144
145 auto p2zValMax0 = new G4UIparameter("zvalMax0", 'd', true);
146 p2zValMax0->SetGuidance("Maximum z-value, expressed in unit (default = 1.)");
147 p2zValMax0->SetGuidance("Can be reset with /analysis/p2/set command");
148 p2zValMax0->SetDefaultValue(1.);
149
150 auto p2zValUnit0 = new G4UIparameter("zvalUnit0", 's', true);
151 p2zValUnit0->SetGuidance("The unit applied to filled z-values and zvalMin0, zvalMax0");
152 p2zValUnit0->SetDefaultValue("none");
153
154 auto p2zValFcn0 = new G4UIparameter("zvalFcn0", 's', true);
155 G4String fcnzGuidance = "The function applied to filled z-values (log, log10, exp, none).";
156 p2zValFcn0->SetGuidance(fcnzGuidance);
157 p2zValFcn0->SetParameterCandidates("log log10 exp none");
158 p2zValFcn0->SetDefaultValue("none");
159
160 fCreateP2Cmd = std::make_unique<G4UIcommand>("/analysis/p2/create", this);
161 fCreateP2Cmd->SetGuidance("Create 2D profile");
162 fCreateP2Cmd->SetParameter(p2Name);
163 fCreateP2Cmd->SetParameter(p2Title);
164 fCreateP2Cmd->SetParameter(p2xNbins0);
165 fCreateP2Cmd->SetParameter(p2xValMin0);
166 fCreateP2Cmd->SetParameter(p2xValMax0);
167 fCreateP2Cmd->SetParameter(p2xValUnit0);
168 fCreateP2Cmd->SetParameter(p2xValFcn0);
169 fCreateP2Cmd->SetParameter(p2xValBinScheme0);
170 fCreateP2Cmd->SetParameter(p2yNbins0);
171 fCreateP2Cmd->SetParameter(p2yValMin0);
172 fCreateP2Cmd->SetParameter(p2yValMax0);
173 fCreateP2Cmd->SetParameter(p2yValUnit0);
174 fCreateP2Cmd->SetParameter(p2yValFcn0);
175 fCreateP2Cmd->SetParameter(p2yValBinScheme0);
176 fCreateP2Cmd->SetParameter(p2zValMin0);
177 fCreateP2Cmd->SetParameter(p2zValMax0);
178 fCreateP2Cmd->SetParameter(p2zValUnit0);
179 fCreateP2Cmd->SetParameter(p2zValFcn0);
180 fCreateP2Cmd->AvailableForStates(G4State_PreInit, G4State_Idle);
181}
182
183
184//_____________________________________________________________________________
185void G4P2Messenger::SetP2Cmd()
186{
187 auto p2Id = new G4UIparameter("id", 'i', false);
188 p2Id->SetGuidance("Profile id");
189 p2Id->SetParameterRange("id>=0");
190
191 auto p2xNbins = new G4UIparameter("xnbins", 'i', false);
192 p2xNbins->SetGuidance("Number of x-bins");
193
194 auto p2xValMin = new G4UIparameter("xvalMin", 'd', false);
195 p2xValMin->SetGuidance("Minimum x-value, expressed in unit");
196
197 auto p2xValMax = new G4UIparameter("xvalMax", 'd', false);
198 p2xValMax->SetGuidance("Maximum x-value, expressed in unit");
199
200 auto p2xValUnit = new G4UIparameter("xvalUnit", 's', true);
201 p2xValUnit->SetGuidance("The unit applied to filled x-values and xvalMin0, xvalMax0");
202 p2xValUnit->SetDefaultValue("none");
203
204 auto p2xValFcn = new G4UIparameter("xvalFcn", 's', true);
205 p2xValFcn->SetParameterCandidates("log log10 exp none");
206 G4String fcnxGuidance = "The function applied to filled x-values (log, log10, exp, none).";
207 p2xValFcn->SetGuidance(fcnxGuidance);
208 p2xValFcn->SetDefaultValue("none");
209
210 auto p2xValBinScheme = new G4UIparameter("xvalBinScheme", 's', true);
211 G4String binSchemeGuidance = "The binning scheme (linear, log).";
212 p2xValBinScheme->SetParameterCandidates("linear log");
213 p2xValBinScheme->SetGuidance(binSchemeGuidance);
214 p2xValBinScheme->SetDefaultValue("linear");
215
216 auto p2yNbins = new G4UIparameter("nybins", 'i', true);
217 p2yNbins->SetGuidance("Number of y-bins");
218
219 auto p2yValMin = new G4UIparameter("yvalMin", 'd', true);
220 p2yValMin->SetGuidance("Minimum y-value, expressed in unit");
221
222 auto p2yValMax = new G4UIparameter("yvalMax", 'd', true);
223 p2yValMax->SetGuidance("Maximum y-value, expressed in unit");
224
225 auto p2yValUnit = new G4UIparameter("yvalUnit", 's', true);
226 p2yValUnit->SetGuidance("The unit applied to filled y-values and yvalMin0, yvalMax0");
227 p2yValUnit->SetDefaultValue("none");
228
229 auto p2yValFcn = new G4UIparameter("yvalFcn", 's', true);
230 p2yValFcn->SetParameterCandidates("log log10 exp none");
231 G4String fcnyGuidance = "The function applied to filled y-values (log, log10, exp, none).";
232 p2yValFcn->SetGuidance(fcnyGuidance);
233 p2yValFcn->SetDefaultValue("none");
234
235 auto p2yValBinScheme = new G4UIparameter("yvalBinScheme", 's', true);
236 p2yValBinScheme->SetParameterCandidates("linear log");
237 p2yValBinScheme->SetGuidance(binSchemeGuidance);
238 p2yValBinScheme->SetDefaultValue("linear");
239
240 auto p2zValMin = new G4UIparameter("zvalMin", 'd', true);
241 p2zValMin->SetGuidance("Minimum z-value, expressed in unit");
242
243 auto p2zValMax = new G4UIparameter("zvalMax", 'd', true);
244 p2zValMax->SetGuidance("Maximum z-value, expressed in unit");
245
246 auto p2zValUnit = new G4UIparameter("zvalUnit", 's', true);
247 p2zValUnit->SetGuidance("The unit applied to filled z-values and zvalMin0, zvalMax0");
248 p2zValUnit->SetDefaultValue("none");
249
250 auto p2zValFcn = new G4UIparameter("zvalFcn", 's', true);
251 p2zValFcn->SetParameterCandidates("log log10 exp none");
252 G4String fcnzGuidance = "The function applied to filled z-values (log, log10, exp, none).";
253 p2zValFcn->SetGuidance(fcnzGuidance);
254 p2zValFcn->SetDefaultValue("none");
255
256 fSetP2Cmd = std::make_unique<G4UIcommand>("/analysis/p2/set", this);
257 fSetP2Cmd->SetGuidance("Set parameters for the 2D profile of given id:");
258 fSetP2Cmd->SetGuidance(" nxbins; xvalMin; xvalMax; xunit; xbinScheme");
259 fSetP2Cmd->SetGuidance(" nybins; yvalMin; yvalMax; yunit; ybinScheme");
260 fSetP2Cmd->SetGuidance(" zvalMin; zvalMax; zunit; zfunction");
261 fSetP2Cmd->SetParameter(p2Id);
262 fSetP2Cmd->SetParameter(p2xNbins);
263 fSetP2Cmd->SetParameter(p2xValMin);
264 fSetP2Cmd->SetParameter(p2xValMax);
265 fSetP2Cmd->SetParameter(p2xValUnit);
266 fSetP2Cmd->SetParameter(p2xValFcn);
267 fSetP2Cmd->SetParameter(p2xValBinScheme);
268 fSetP2Cmd->SetParameter(p2yNbins);
269 fSetP2Cmd->SetParameter(p2yValMin);
270 fSetP2Cmd->SetParameter(p2yValMax);
271 fSetP2Cmd->SetParameter(p2yValUnit);
272 fSetP2Cmd->SetParameter(p2yValFcn);
273 fSetP2Cmd->SetParameter(p2yValBinScheme);
274 fSetP2Cmd->SetParameter(p2zValMin);
275 fSetP2Cmd->SetParameter(p2zValMax);
276 fSetP2Cmd->SetParameter(p2zValUnit);
277 fSetP2Cmd->SetParameter(p2zValFcn);
278 fSetP2Cmd->AvailableForStates(G4State_PreInit, G4State_Idle);
279}
280
281
282//
283// public functions
284//
285
286//_____________________________________________________________________________
287void G4P2Messenger::SetNewValue(G4UIcommand* command, G4String newValues)
288{
289 // tokenize parameters in a vector
290 std::vector<G4String> parameters;
291 G4Analysis::Tokenize(newValues, parameters);
292 // check consistency
293 if ( parameters.size() != command->GetParameterEntries() ) {
294 // Should never happen but let's check anyway for consistency
295 fHelper->WarnAboutParameters(command, parameters.size());
296 return;
297 }
298
299 if ( command == fCreateP2Cmd.get() ) {
300 auto counter = 0;
301 auto name = parameters[counter++];
302 auto title = parameters[counter++];
303 G4AnalysisMessengerHelper::BinData xdata;
304 fHelper->GetBinData(xdata, parameters, counter);
305 auto xunit = GetUnitValue(xdata.fSunit);
306 G4AnalysisMessengerHelper::BinData ydata;
307 fHelper->GetBinData(ydata, parameters, counter);
308 auto yunit = GetUnitValue(ydata.fSunit);
309 G4AnalysisMessengerHelper::ValueData zdata;
310 fHelper->GetValueData(zdata, parameters, counter);
311 auto zunit = GetUnitValue(zdata.fSunit);
312 fManager->CreateP2(name, title,
313 xdata.fNbins, xdata.fVmin*xunit, xdata.fVmax*xunit,
314 ydata.fNbins, ydata.fVmin*yunit, ydata.fVmax*yunit,
315 zdata.fVmin*zunit, zdata.fVmax*zunit,
316 xdata.fSunit, ydata.fSunit, zdata.fSunit,
317 xdata.fSfcn, ydata.fSfcn, zdata.fSfcn,
318 xdata.fSbinScheme, ydata.fSbinScheme);
319 }
320 else if ( command == fSetP2Cmd.get() ) {
321 auto counter = 0;
322 auto id = G4UIcommand::ConvertToInt(parameters[counter++]);
323 G4AnalysisMessengerHelper::BinData xdata;
324 fHelper->GetBinData(xdata, parameters, counter);
325 auto xunit = GetUnitValue(xdata.fSunit);
326 G4AnalysisMessengerHelper::BinData ydata;
327 fHelper->GetBinData(ydata, parameters, counter);
328 auto yunit = GetUnitValue(ydata.fSunit);
329 G4AnalysisMessengerHelper::ValueData zdata;
330 fHelper->GetValueData(zdata, parameters, counter);
331 auto zunit = GetUnitValue(zdata.fSunit);
332 fManager->SetP2(id,
333 xdata.fNbins, xdata.fVmin*xunit, xdata.fVmax*xunit,
334 ydata.fNbins, ydata.fVmin*yunit, ydata.fVmax*yunit,
335 zdata.fVmin*zunit, zdata.fVmax*zunit,
336 xdata.fSunit, ydata.fSunit, zdata.fSunit,
337 xdata.fSfcn, ydata.fSfcn, zdata.fSfcn,
338 xdata.fSbinScheme, ydata.fSbinScheme);
339 }
340 else if ( command == fSetP2XCmd.get() ) {
341 // Only save values
342 auto counter = 0;
343 fXId = G4UIcommand::ConvertToInt(parameters[counter++]);
344 fHelper->GetBinData(fXData, parameters, counter);
345 }
346 else if ( command == fSetP2YCmd.get() ) {
347 // Save values
348 auto counter = 0;
349 fYId = G4UIcommand::ConvertToInt(parameters[counter++]);
350 // Check if setX command was called
351 if ( fXId == -1 || fXId != fYId ) {
352 fHelper->WarnAboutSetCommands();
353 return;
354 }
355 fHelper->GetBinData(fYData, parameters, counter);
356 // Set values
357 // (another set may follow if setZ is also called)
358 auto xunit = GetUnitValue(fXData.fSunit);
359 auto yunit = GetUnitValue(fYData.fSunit);
360 fManager->SetP2(fYId,
361 fXData.fNbins, fXData.fVmin*xunit, fXData.fVmax*xunit,
362 fYData.fNbins, fYData.fVmin*yunit, fYData.fVmax*yunit,
363 0., 0.,
364 fXData.fSunit, fYData.fSunit, "none",
365 fXData.fSfcn, fYData.fSfcn, "none",
366 fXData.fSbinScheme, fYData.fSbinScheme);
367 }
368 else if ( command == fSetP2ZCmd.get() ) {
369 auto counter = 0;
370 auto id = G4UIcommand::ConvertToInt(parameters[counter++]);
371 // Check if setX and setY command was called
372 if ( fXId == -1 || fXId != id ||
373 fYId == -1 || fYId != id ) {
374 fHelper->WarnAboutSetCommands();
375 return;
376 }
377 auto xunit = GetUnitValue(fXData.fSunit);
378 auto yunit = GetUnitValue(fYData.fSunit);
379 G4AnalysisMessengerHelper::ValueData zdata;
380 fHelper->GetValueData(zdata, parameters, counter);
381 auto zunit = GetUnitValue(zdata.fSunit);
382 fManager->SetP2(id,
383 fXData.fNbins, fXData.fVmin*xunit, fXData.fVmax*xunit,
384 fYData.fNbins, fYData.fVmin*yunit, fYData.fVmax*yunit,
385 zdata.fVmin*zunit, zdata.fVmax*zunit,
386 fXData.fSunit, fYData.fSunit, zdata.fSunit,
387 fXData.fSfcn, fYData.fSfcn, zdata.fSfcn,
388 fXData.fSbinScheme, fYData.fSbinScheme);
389 fXId = -1;
390 fYId = -1;
391 }
392 else if ( command == fSetP2TitleCmd.get() ) {
393 auto counter = 0;
394 auto id = G4UIcommand::ConvertToInt(parameters[counter++]);
395 auto title = parameters[counter++];
396 fManager->SetP2Title(id, title);
397 }
398 else if ( command == fSetP2XAxisCmd.get() ) {
399 auto counter = 0;
400 auto id = G4UIcommand::ConvertToInt(parameters[counter++]);
401 auto xaxis = parameters[counter++];
402 fManager->SetP2XAxisTitle(id, xaxis);
403 }
404 else if ( command == fSetP2YAxisCmd.get() ) {
405 auto counter = 0;
406 auto id = G4UIcommand::ConvertToInt(parameters[counter++]);
407 auto yaxis = parameters[counter++];
408 fManager->SetP2YAxisTitle(id, yaxis);
409 }
410 else if ( command == fSetP2ZAxisCmd.get() ) {
411 auto counter = 0;
412 auto id = G4UIcommand::ConvertToInt(parameters[counter++]);
413 auto zaxis = parameters[counter++];
414 fManager->SetP2ZAxisTitle(id, zaxis);
415 }
416 else if ( command == fSetP2XAxisLogCmd.get() ) {
417 auto counter = 0;
418 auto id = G4UIcommand::ConvertToInt(parameters[counter++]);
419 auto xaxisLog = G4UIcommand::ConvertToBool(parameters[counter++]);
420 fManager->SetP2XAxisIsLog(id, xaxisLog);
421 }
422 else if ( command == fSetP2YAxisLogCmd.get() ) {
423 auto counter = 0;
424 auto id = G4UIcommand::ConvertToInt(parameters[counter++]);
425 auto yaxisLog = G4UIcommand::ConvertToBool(parameters[counter++]);
426 fManager->SetP2YAxisIsLog(id, yaxisLog);
427 }
428 else if ( command == fSetP2ZAxisLogCmd.get() ) {
429 auto counter = 0;
430 auto id = G4UIcommand::ConvertToInt(parameters[counter++]);
431 auto zaxisLog = G4UIcommand::ConvertToBool(parameters[counter++]);
432 fManager->SetP2ZAxisIsLog(id, zaxisLog);
433 }
434}
G4State_Idle
@ G4State_Idle
Definition: G4ApplicationState.hh:86
G4State_PreInit
@ G4State_PreInit
Definition: G4ApplicationState.hh:84
G4P2Messenger::fSetP2XAxisLogCmd
std::unique_ptr< G4UIcommand > fSetP2XAxisLogCmd
Definition: G4P2Messenger.hh:73
G4P2Messenger::fSetP2TitleCmd
std::unique_ptr< G4UIcommand > fSetP2TitleCmd
Definition: G4P2Messenger.hh:69
G4P2Messenger::G4P2Messenger
G4P2Messenger()=delete
G4P2Messenger::fDirectory
std::unique_ptr< G4UIdirectory > fDirectory
Definition: G4P2Messenger.hh:62
G4P2Messenger::fXData
G4AnalysisMessengerHelper::BinData fXData
Definition: G4P2Messenger.hh:79
G4P2Messenger::fSetP2YCmd
std::unique_ptr< G4UIcommand > fSetP2YCmd
Definition: G4P2Messenger.hh:67
G4P2Messenger::fSetP2XCmd
std::unique_ptr< G4UIcommand > fSetP2XCmd
Definition: G4P2Messenger.hh:66
G4P2Messenger::SetNewValue
virtual void SetNewValue(G4UIcommand *command, G4String value) final
Definition: G4P2Messenger.cc:287
G4P2Messenger::fSetP2XAxisCmd
std::unique_ptr< G4UIcommand > fSetP2XAxisCmd
Definition: G4P2Messenger.hh:70
G4P2Messenger::fSetP2ZAxisCmd
std::unique_ptr< G4UIcommand > fSetP2ZAxisCmd
Definition: G4P2Messenger.hh:72
G4P2Messenger::fSetP2ZCmd
std::unique_ptr< G4UIcommand > fSetP2ZCmd
Definition: G4P2Messenger.hh:68
G4P2Messenger::fYData
G4AnalysisMessengerHelper::BinData fYData
Definition: G4P2Messenger.hh:80
G4P2Messenger::fManager
G4VAnalysisManager * fManager
Associated class.
Definition: G4P2Messenger.hh:60
G4P2Messenger::~G4P2Messenger
virtual ~G4P2Messenger()
G4P2Messenger::fCreateP2Cmd
std::unique_ptr< G4UIcommand > fCreateP2Cmd
Definition: G4P2Messenger.hh:64
G4P2Messenger::CreateP2Cmd
void CreateP2Cmd()
Definition: G4P2Messenger.cc:71
G4P2Messenger::fSetP2YAxisLogCmd
std::unique_ptr< G4UIcommand > fSetP2YAxisLogCmd
Definition: G4P2Messenger.hh:74
G4P2Messenger::fSetP2Cmd
std::unique_ptr< G4UIcommand > fSetP2Cmd
Definition: G4P2Messenger.hh:65
G4P2Messenger::fSetP2ZAxisLogCmd
std::unique_ptr< G4UIcommand > fSetP2ZAxisLogCmd
Definition: G4P2Messenger.hh:75
G4P2Messenger::fHelper
std::unique_ptr< G4AnalysisMessengerHelper > fHelper
Definition: G4P2Messenger.hh:61
G4P2Messenger::fSetP2YAxisCmd
std::unique_ptr< G4UIcommand > fSetP2YAxisCmd
Definition: G4P2Messenger.hh:71
G4UIcommand::GetParameterEntries
std::size_t GetParameterEntries() const
Definition: G4UIcommand.hh:138
G4UIcommand::ConvertToInt
static G4int ConvertToInt(const char *st)
Definition: G4UIcommand.cc:557
G4UIcommand::ConvertToBool
static G4bool ConvertToBool(const char *st)
Definition: G4UIcommand.cc:545
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:609
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:698
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:162
G4Analysis::GetUnitValue
G4double GetUnitValue(const G4String &unit)
Definition: G4AnalysisUtilities.cc:141
G4InuclParticleNames::name
const char * name(G4int ptype)
Definition: G4InuclParticleNames.hh:76
Generated by doxygen 1.9.3