source: trunk/examples/advanced/radiation_monitor/materials/src/RadmonMaterialsMessenger.cc @ 1321

Last change on this file since 1321 was 807, checked in by garnier, 16 years ago

update
File size: 13.7 KB
Line 
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// File name:     RadmonMaterialsMessenger.cc
28// Creation date: Sep 2005
29// Main author:   Riccardo Capra <capra@ge.infn.it>
30//
31// Id:            $Id: RadmonMaterialsMessenger.cc,v 1.4 2006/06/29 16:16:53 gunter Exp $
32// Tag:           $Name:  $
33//
34
35// Messenger commands path
36#define COMMANDS_PATH "/radmon/materials/"
37
38// Include files
39#include "RadmonMaterialsMessenger.hh"
40#include "RadmonMaterialsManager.hh"
41#include "G4UnitsTable.hh"
42
43
44
45                                                RadmonMaterialsMessenger :: RadmonMaterialsMessenger(RadmonMaterialsManager * manager)
46:
47 RadmonMessenger(COMMANDS_PATH, "Interactive materials definition commands."),
48 materialsManager(manager),
49 RADMON_INITIALIZE_COMMAND(CreateElement),
50 RADMON_INITIALIZE_COMMAND(CreateMaterial),
51 RADMON_INITIALIZE_COMMAND(AddComponentByAtoms),
52 RADMON_INITIALIZE_COMMAND(AddComponentByFraction),
53 RADMON_INITIALIZE_COMMAND(SetMaterialColor),
54 RADMON_INITIALIZE_COMMAND(SetMaterialTrasparency),
55 RADMON_INITIALIZE_COMMAND(SetMaterialVisibility),
56 RADMON_INITIALIZE_COMMAND(SetMaterialStyle),
57 RADMON_INITIALIZE_COMMAND(Dump),
58 RADMON_INITIALIZE_COMMAND(Insert),
59 RADMON_INITIALIZE_COMMAND(Save)
60{
61 RADMON_CREATE_COMMAND_5ARGS(CreateElement,             "Creates a new element",                                                        "material", "symbol", "Z", "A", "unit");
62 RADMON_CREATE_COMMAND_4ARGS(CreateMaterial,            "Creates a new material",                                                       "material", "density", "unit", "totComponents");
63 RADMON_CREATE_COMMAND_3ARGS(AddComponentByAtoms,       "Adds a element into a material specifying the number of atoms",                "material", "element", "atoms");
64 RADMON_CREATE_COMMAND_3ARGS(AddComponentByFraction,    "Adds a element or material into another material specifying the percentage",   "material", "component", "fraction");
65 RADMON_CREATE_COMMAND_4ARGS(SetMaterialColor,          "Set default color for all elements made of this material",                     "material", "red", "green", "blue");
66 RADMON_CREATE_COMMAND_2ARGS(SetMaterialTrasparency,    "Set default trasparency for all elements made of this material",               "material", "alpha");
67 RADMON_CREATE_COMMAND_2ARGS(SetMaterialVisibility,     "Set default visibility for all elements made of this material",                "material", "visibility");
68 RADMON_CREATE_COMMAND_2ARGS(SetMaterialStyle,          "Set default style for all elements made of this material",                     "material", "style");
69 RADMON_CREATE_COMMAND_0ARGS(Dump,                      "Print currently declared elements and materials");
70 RADMON_CREATE_COMMAND_1ARG (Insert,                    "Inserts elements and materials from file",                                     "fileName");
71 RADMON_CREATE_COMMAND_1ARG (Save,                      "Saves a elements and materials declarations into a file",                      "fileName");
72}
73
74
75
76                                                RadmonMaterialsMessenger :: ~RadmonMaterialsMessenger()
77{
78 RADMON_DESTROY_COMMAND(Save);
79 RADMON_DESTROY_COMMAND(Insert);
80 RADMON_DESTROY_COMMAND(Dump);
81 RADMON_DESTROY_COMMAND(SetMaterialStyle);
82 RADMON_DESTROY_COMMAND(SetMaterialVisibility);
83 RADMON_DESTROY_COMMAND(SetMaterialTrasparency);
84 RADMON_DESTROY_COMMAND(SetMaterialColor);
85 RADMON_DESTROY_COMMAND(AddComponentByFraction);
86 RADMON_DESTROY_COMMAND(AddComponentByAtoms);
87 RADMON_DESTROY_COMMAND(CreateMaterial);
88 RADMON_DESTROY_COMMAND(CreateElement);
89}
90
91
92
93
94
95G4String                                        RadmonMaterialsMessenger :: GetCurrentValue(G4UIcommand * /* command */)
96{
97 G4cout << "RadmonMaterialsMessenger::GetCurrentValue(): Not supported" << G4endl;
98 
99 return G4String();
100}
101
102
103
104void                                            RadmonMaterialsMessenger :: SetNewValue(G4UIcommand * command, G4String newValue)
105{
106 RADMON_BEGIN_LIST_SET_COMMANDS
107  RADMON_SET_COMMAND(CreateElement)
108  RADMON_SET_COMMAND(CreateMaterial)
109  RADMON_SET_COMMAND(AddComponentByAtoms)
110  RADMON_SET_COMMAND(AddComponentByFraction)
111  RADMON_SET_COMMAND(SetMaterialColor)
112  RADMON_SET_COMMAND(SetMaterialTrasparency)
113  RADMON_SET_COMMAND(SetMaterialVisibility)
114  RADMON_SET_COMMAND(SetMaterialStyle)
115  RADMON_SET_COMMAND(Dump)
116  RADMON_SET_COMMAND(Insert)
117  RADMON_SET_COMMAND(Save)
118 RADMON_END_LIST_SET_COMMANDS
119}
120
121
122
123
124
125// Events
126void                                            RadmonMaterialsMessenger :: OnCreateElement(const G4String & value)
127{
128 G4String args[5];
129
130 if (!ProcessArguments(value, 5, args))
131  return; 
132
133 G4double z(G4UIcommand::ConvertToDouble(args[2]));
134 
135 if (z<=0.)
136 {
137  G4cout << "RadmonMaterialsMessenger::OnCreateElement(): z must be positive." << G4endl;
138  return;
139 }
140 
141 G4double a(GetUnit(args[4], "Molar Mass"));
142 
143 if (a<0.)
144  return;
145 
146 a*=G4UIcommand::ConvertToDouble(args[3]);
147 
148 if (a<=0.)
149 {
150  G4cout << "RadmonMaterialsMessenger::OnCreateElement(): a must be positive." << G4endl;
151  return;
152 }
153
154 materialsManager->CreateElement(args[0], args[1], z, a);
155}
156
157
158
159void                                            RadmonMaterialsMessenger :: OnCreateMaterial(const G4String & value)
160{
161 G4String args[4];
162
163 if (!ProcessArguments(value, 4, args))
164  return; 
165
166 G4double density(GetUnit(args[2], "Volumic Mass"));
167 
168 if (density<0.)
169  return;
170 
171 density*=G4UIcommand::ConvertToDouble(args[1]);
172 
173 if (density<=0.)
174 {
175  G4cout << "RadmonMaterialsMessenger::OnCreateMaterial(): Material density must be positive." << G4endl;
176  return;
177 }
178 
179 G4int components(G4UIcommand::ConvertToInt(args[3]));
180 
181 if (components<0)
182 {
183  G4cout << "RadmonMaterialsMessenger::OnCreateMaterial(): Number of components must be positive (>=0)." << G4endl;
184  return;
185 }
186
187 materialsManager->CreateMaterial(args[0], density, components);
188}
189
190
191
192void                                            RadmonMaterialsMessenger :: OnAddComponentByAtoms(const G4String & value)
193{
194 G4String args[3];
195
196 if (!ProcessArguments(value, 3, args))
197  return; 
198
199 if (!materialsManager->IsIncompleteMaterial(args[0]))
200 {
201  if (!materialsManager->ExistsMaterial(args[0]))
202   G4cout << "RadmonMaterialsMessenger::OnAddComponentByAtoms(): Material \"" << args[0] << "\" not found." << G4endl;
203  else
204   G4cout << "RadmonMaterialsMessenger::OnAddComponentByAtoms(): No more components to be added to \"" << args[0] << "\"." << G4endl;
205  return;
206 }
207
208 if (!materialsManager->ExistsElement(args[1]))
209 {
210  G4cout << "RadmonMaterialsMessenger::OnAddComponentByAtoms(): Element \"" << args[1] << "\" not found." << G4endl;
211  return;
212 }
213
214 G4int atoms(G4UIcommand::ConvertToInt(args[2]));
215 
216 if (atoms<=0)
217 {
218  G4cout << "RadmonMaterialsMessenger::OnAddComponentByAtoms(): Number of atoms must be positive (>0)." << G4endl;
219  return;
220 }
221
222 materialsManager->AddComponentByAtoms(args[0], args[1], atoms); 
223}
224
225
226
227void                                            RadmonMaterialsMessenger :: OnAddComponentByFraction(const G4String & value)
228{
229 G4String args[3];
230
231 if (!ProcessArguments(value, 3, args))
232  return; 
233
234 if (!materialsManager->IsIncompleteMaterial(args[0]))
235 {
236  if (!materialsManager->ExistsMaterial(args[0]))
237   G4cout << "RadmonMaterialsMessenger::OnAddComponentByFraction(): Material \"" << args[0] << "\" not found." << G4endl;
238  else
239   G4cout << "RadmonMaterialsMessenger::OnAddComponentByFraction(): No more components to be added to \"" << args[0] << "\"." << G4endl;
240  return;
241 }
242
243 if ((!materialsManager->ExistsElement(args[1])) && (!materialsManager->ExistsMaterial(args[1])))
244 {
245  G4cout << "RadmonMaterialsMessenger::OnAddComponentByFraction(): Element/Material \"" << args[1] << "\" not found." << G4endl;
246  return;
247 }
248
249 G4double fraction(G4UIcommand::ConvertToDouble(args[2]));
250 
251 if (fraction<=0)
252 {
253  G4cout << "RadmonMaterialsMessenger::OnAddComponentByFraction(): Material fraction must be positive (>0)." << G4endl;
254  return;
255 }
256
257 materialsManager->AddComponentByFraction(args[0], args[1], fraction); 
258}
259
260
261
262void                                            RadmonMaterialsMessenger :: OnSetMaterialColor(const G4String & value)
263{
264 G4String args[4];
265 
266 if (!ProcessArguments(value, 4, args))
267  return;
268 
269 if (!materialsManager->ExistsMaterial(args[0]) && !materialsManager->IsIncompleteMaterial(args[0]))
270 {
271  G4cout << "RadmonMaterialsMessenger::OnSetMaterialColor(): Material \"" << args[0] << "\" not found." << G4endl;
272  return;
273 }
274 
275 G4double red(G4UIcommand::ConvertToDouble(args[1]));
276 G4double green(G4UIcommand::ConvertToDouble(args[2]));
277 G4double blue(G4UIcommand::ConvertToDouble(args[3]));
278 
279 if (red<0. || red>1. || green<0. || green>1. || blue<0. || blue>1.)
280 {
281  G4cout << "RadmonMaterialsMessenger::OnSetMaterialColor(): Red, green and blue components must be set between 0 and 1." << G4endl;
282  return;
283 }
284 
285 materialsManager->SetMaterialColor(args[0], G4Color(red, green, blue, materialsManager->GetMaterialColor(args[0]).GetAlpha()));
286}
287
288
289
290void                                            RadmonMaterialsMessenger :: OnSetMaterialTrasparency(const G4String & value)
291{
292 G4String args[2];
293 
294 if (!ProcessArguments(value, 2, args))
295  return;
296 
297 if (!materialsManager->ExistsMaterial(args[0]) && !materialsManager->IsIncompleteMaterial(args[0]))
298 {
299  G4cout << "RadmonMaterialsMessenger::OnSetMaterialTrasparency(): Material \"" << args[0] << "\" not found." << G4endl;
300  return;
301 }
302 
303 G4double alpha(G4UIcommand::ConvertToDouble(args[1]));
304 
305 if (alpha<0. || alpha>1.)
306 {
307  G4cout << "RadmonMaterialsMessenger::OnSetMaterialTrasparency(): Alpha component must be set between 0 and 1." << G4endl;
308  return;
309 }
310 
311 const G4Color &c(materialsManager->GetMaterialColor(args[0]));
312 materialsManager->SetMaterialColor(args[0], G4Color(c.GetRed(), c.GetGreen(), c.GetBlue(), alpha));
313}
314
315
316
317void                                            RadmonMaterialsMessenger :: OnSetMaterialVisibility(const G4String & value)
318{
319 G4String args[2];
320 
321 if (!ProcessArguments(value, 2, args))
322  return;
323 
324 if (!materialsManager->ExistsMaterial(args[0]) && !materialsManager->IsIncompleteMaterial(args[0]))
325 {
326  G4cout << "RadmonMaterialsMessenger::OnSetMaterialVisibility(): Material \"" << args[0] << "\" not found." << G4endl;
327  return;
328 }
329 
330 if (args[1]=="hidden")
331  materialsManager->SetMaterialVisibility(args[0], false);
332 else if (args[1]=="visible")
333  materialsManager->SetMaterialVisibility(args[0], true);
334 else
335  G4cout << "RadmonMaterialsMessenger::OnSetMaterialVisibility(): Visibility must be set to visible or hidden." << G4endl;
336}
337
338
339
340void                                            RadmonMaterialsMessenger :: OnSetMaterialStyle(const G4String & value)
341{
342 G4String args[2];
343 
344 if (!ProcessArguments(value, 2, args))
345  return;
346 
347 if (!materialsManager->ExistsMaterial(args[0]) && !materialsManager->IsIncompleteMaterial(args[0]))
348 {
349  G4cout << "RadmonMaterialsMessenger::OnSetMaterialStyle(): Material \"" << args[0] << "\" not found." << G4endl;
350  return;
351 }
352 
353 if (args[1]=="wireframe")
354  materialsManager->SetMaterialForceWireframe(args[0], true);
355 else if (args[1]=="solid")
356  materialsManager->SetMaterialForceSolid(args[0], true);
357 else if (args[1]=="default")
358 {
359  materialsManager->SetMaterialForceWireframe(args[0], false);
360  materialsManager->SetMaterialForceSolid(args[0], false);
361 }
362 else
363  G4cout << "RadmonMaterialsMessenger::OnSetMaterialStyle(): Style must be set to wireframe, solid or default." << G4endl;
364}
365
366
367
368void                                            RadmonMaterialsMessenger :: OnDump(const G4String & /* value */)
369{
370 materialsManager->Dump(G4cout, "- ");
371 G4cout << G4endl;
372}
373
374
375
376void                                            RadmonMaterialsMessenger :: OnInsert(const G4String & value)
377{
378 G4String args[1];
379
380 if (!ProcessArguments(value, 1, args))
381  return; 
382 
383 std::istream * in(OpenForInput(args[0]));
384 
385 if (!in)
386  return;
387
388 if (!materialsManager->Insert(*in)) 
389  G4cout << "RadmonMaterialsMessenger::OnInsert(): Error reading from file \"" << args[0] << "\"." << G4endl;
390 
391 delete in;
392}
393
394
395
396void                                            RadmonMaterialsMessenger :: OnSave(const G4String & value)
397{
398 G4String args[1];
399
400 if (!ProcessArguments(value, 1, args))
401  return; 
402 
403 std::ostream * out(OpenForOutput(args[0]));
404 
405 if (!out)
406  return;
407
408 if (!materialsManager->Save(*out))
409  G4cout << "RadmonMaterialsMessenger::OnSave(): Cannot write layout into file \"" << args[0] << "\"." << G4endl;
410 
411 delete out;
412}
413
Note: See TracBrowser for help on using the repository browser.