| 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 // $Id: G4HepRepMessenger.cc 66870 2013-01-14 23:38:59Z adotti $
26 // 27 //
27 #include "G4HepRepMessenger.hh" 28 #include "G4HepRepMessenger.hh"
28 29
29 G4HepRepMessenger* G4HepRepMessenger::fpInstan << 30 G4HepRepMessenger*
>> 31 G4HepRepMessenger::fpInstance = 0;
30 32
31 G4HepRepMessenger* G4HepRepMessenger::GetInsta << 33 G4HepRepMessenger*
>> 34 G4HepRepMessenger::GetInstance()
32 { 35 {
33 if(!fpInstance) << 36 if (!fpInstance) fpInstance = new G4HepRepMessenger;
34 fpInstance = new G4HepRepMessenger; << 37 return fpInstance;
35 return fpInstance; << 38 }
36 } <<
37 <<
38 G4HepRepMessenger::G4HepRepMessenger() <<
39 : fileDir("") <<
40 , fileName("G4Data") <<
41 , overwrite(false) <<
42 , cullInvisibles(false) <<
43 , cylAsPolygons(false) <<
44 , scale(1.) <<
45 , suffix("") <<
46 , geometry(true) <<
47 , pointAttributes(false) <<
48 , solids(true) <<
49 , invisibles(true) <<
50 { <<
51 heprepDirectory = new G4UIdirectory("/vis/he <<
52 heprepDirectory->SetGuidance("HepRep command <<
53 39
54 setFileDirCommand = new G4UIcmdWithAString(" << 40 G4HepRepMessenger::G4HepRepMessenger() :
55 setFileDirCommand->SetGuidance("Set director << 41 fileDir(""),
56 setFileDirCommand->SetGuidance( << 42 fileName("G4Data"),
57 "This command is used by HepRepFile, not b << 43 overwrite(false),
58 setFileDirCommand->SetParameterName("directo << 44 cullInvisibles(false),
59 if(std::getenv("G4HEPREPFILE_DIR") == NULL) << 45 cylAsPolygons(false),
60 { << 46 scale(1.),
61 setFileDirCommand->SetDefaultValue(""); << 47 suffix (""),
62 } << 48 geometry(true),
63 else << 49 solids(true),
64 { << 50 invisibles(true) {
65 setFileDirCommand->SetDefaultValue(std::ge << 51
66 fileDir = std::getenv("G4HEPREPFILE_DIR"); << 52 heprepDirectory = new G4UIdirectory("/vis/heprep/");
67 } << 53 heprepDirectory->SetGuidance("HepRep commands.");
68 setFileDirCommand->AvailableForStates(G4Stat << 54
69 << 55 setFileDirCommand = new G4UIcmdWithAString("/vis/heprep/setFileDir", this);
70 setFileNameCommand = new G4UIcmdWithAString( << 56 setFileDirCommand->SetGuidance("Set directory for output.");
71 setFileNameCommand->SetGuidance("Set file na << 57 setFileDirCommand->SetGuidance("This command is used by HepRepFile, not by HepRepXML.");
72 setFileNameCommand->SetGuidance( << 58 setFileDirCommand->SetParameterName("directory",false);
73 "This command is used by HepRepFile, not b << 59 if ( getenv( "G4HEPREPFILE_DIR" ) == NULL ) {
74 setFileNameCommand->SetParameterName("direct << 60 setFileDirCommand->SetDefaultValue("");
75 if(std::getenv("G4HEPREPFILE_NAME") == NULL) << 61 } else {
76 { << 62 setFileDirCommand->SetDefaultValue(getenv("G4HEPREPFILE_DIR"));
77 setFileNameCommand->SetDefaultValue("G4Dat << 63 fileDir = getenv("G4HEPREPFILE_DIR");
78 } << 64 }
79 else << 65 setFileDirCommand->AvailableForStates(G4State_Idle);
80 { << 66
81 setFileNameCommand->SetDefaultValue(std::g << 67 setFileNameCommand = new G4UIcmdWithAString("/vis/heprep/setFileName", this);
82 fileName = std::getenv("G4HEPREPFILE_NAME" << 68 setFileNameCommand->SetGuidance("Set file name for output.");
83 } << 69 setFileNameCommand->SetGuidance("This command is used by HepRepFile, not by HepRepXML.");
84 setFileNameCommand->AvailableForStates(G4Sta << 70 setFileNameCommand->SetParameterName("directory",false);
85 << 71 if ( getenv( "G4HEPREPFILE_NAME" ) == NULL ) {
86 setOverwriteCommand = new G4UIcmdWithABool(" << 72 setFileNameCommand->SetDefaultValue("G4Data");
87 setOverwriteCommand->SetGuidance( << 73 } else {
88 "Set true to write all output to exact sam << 74 setFileNameCommand->SetDefaultValue(getenv("G4HEPREPFILE_NAME"));
89 setOverwriteCommand->SetGuidance( << 75 fileName = getenv("G4HEPREPFILE_NAME");
90 "Set false to increment the file name for << 76 }
91 setOverwriteCommand->SetGuidance( << 77 setFileNameCommand->AvailableForStates(G4State_Idle);
92 "This command is used by HepRepFile, not b << 78
93 setOverwriteCommand->SetParameterName("flag" << 79 setOverwriteCommand = new G4UIcmdWithABool("/vis/heprep/setOverwrite", this);
94 if(std::getenv("G4HEPREPFILE_OVERWRITE") == << 80 setOverwriteCommand->SetGuidance("Set true to write all output to exact same file name.");
95 { << 81 setOverwriteCommand->SetGuidance("Set false to increment the file name for each new output.");
96 setOverwriteCommand->SetDefaultValue(false << 82 setOverwriteCommand->SetGuidance("This command is used by HepRepFile, not by HepRepXML.");
97 } << 83 setOverwriteCommand->SetParameterName("flag",false);
98 else << 84 if ( getenv( "G4HEPREPFILE_OVERWRITE" ) == NULL ) {
99 { << 85 setOverwriteCommand->SetDefaultValue(false);
100 setOverwriteCommand->SetDefaultValue(std:: << 86 } else {
101 overwrite = << 87 setOverwriteCommand->SetDefaultValue(getenv("G4HEPREPFILE_OVERWRITE"));
102 setOverwriteCommand->ConvertToBool(std:: << 88 overwrite = setOverwriteCommand->ConvertToBool(getenv("G4HEPREPFILE_OVERWRITE"));
103 } << 89 }
104 setOverwriteCommand->AvailableForStates(G4St << 90 setOverwriteCommand->AvailableForStates(G4State_Idle);
105 << 91
106 setCullInvisiblesCommand = << 92 setCullInvisiblesCommand = new G4UIcmdWithABool("/vis/heprep/setCullInvisibles", this);
107 new G4UIcmdWithABool("/vis/heprep/setCullI << 93 setCullInvisiblesCommand->SetGuidance("Remove invisible objects from output file.");
108 setCullInvisiblesCommand->SetGuidance( << 94 setCullInvisiblesCommand->SetGuidance("This command is used by HepRepFile, not by HepRepXML.");
109 "Remove invisible objects from output file << 95 setCullInvisiblesCommand->SetParameterName("flag",false);
110 setCullInvisiblesCommand->SetGuidance( << 96 if ( getenv( "G4HEPREPFILE_CULL" ) == NULL ) {
111 "This command is used by HepRepFile, not b << 97 setCullInvisiblesCommand->SetDefaultValue(false);
112 setCullInvisiblesCommand->SetParameterName(" << 98 } else {
113 if(std::getenv("G4HEPREPFILE_CULL") == NULL) << 99 setCullInvisiblesCommand->SetDefaultValue(getenv("G4HEPREPFILE_CULL"));
114 { << 100 cullInvisibles = setCullInvisiblesCommand->ConvertToBool(getenv("G4HEPREPFILE_CULL"));
115 setCullInvisiblesCommand->SetDefaultValue( << 101 }
116 } << 102 setCullInvisiblesCommand->AvailableForStates(G4State_Idle);
117 else << 103
118 { << 104 renderCylAsPolygonsCommand = new G4UIcmdWithABool("/vis/heprep/renderCylAsPolygons", this);
119 setCullInvisiblesCommand->SetDefaultValue( << 105 renderCylAsPolygonsCommand->SetGuidance("Render cylinders and cones as polygons.");
120 cullInvisibles = << 106 renderCylAsPolygonsCommand->SetGuidance("This command is used by HepRepFile, not by HepRepXML.");
121 setCullInvisiblesCommand->ConvertToBool( << 107 renderCylAsPolygonsCommand->SetParameterName("flag",false);
122 } << 108 renderCylAsPolygonsCommand->SetDefaultValue(false);
123 setCullInvisiblesCommand->AvailableForStates << 109 renderCylAsPolygonsCommand->AvailableForStates(G4State_Idle);
124 << 110
125 renderCylAsPolygonsCommand = << 111 setScaleCommand = new G4UIcmdWithADouble("/vis/heprep/scale",this);
126 new G4UIcmdWithABool("/vis/heprep/renderCy << 112 setScaleCommand->SetGuidance("Re-Scale coordinates.");
127 renderCylAsPolygonsCommand->SetGuidance( << 113 setScaleCommand->SetParameterName("Scale",true);
128 "Render cylinders and cones as polygons.") << 114 setScaleCommand->SetDefaultValue(1.);
129 renderCylAsPolygonsCommand->SetGuidance( << 115 setScaleCommand->SetRange("Scale > 0");
130 "This command is used by HepRepFile, not b << 116
131 renderCylAsPolygonsCommand->SetParameterName << 117 setCenterCommand = new G4UIcmdWith3VectorAndUnit("/vis/heprep/center",this);
132 renderCylAsPolygonsCommand->SetDefaultValue( << 118 setCenterCommand->SetGuidance("Re-Center coordinates.");
133 renderCylAsPolygonsCommand->AvailableForStat << 119 setCenterCommand->SetParameterName("CenterX","CenterY","CenterZ",true);
134 << 120 setCenterCommand->SetDefaultValue(G4ThreeVector(0.,0.,0.));
135 setScaleCommand = new G4UIcmdWithADouble("/v << 121 setCenterCommand->SetDefaultUnit("m");
136 setScaleCommand->SetGuidance("Re-Scale coord << 122
137 setScaleCommand->SetParameterName("Scale", t << 123 setEventNumberSuffixCommand = new G4UIcmdWithAString("/vis/heprep/setEventNumberSuffix", this);
138 setScaleCommand->SetDefaultValue(1.); << 124 setEventNumberSuffixCommand->SetGuidance("Write separate event files, appended with given suffix.");
139 setScaleCommand->SetRange("Scale > 0"); << 125 setEventNumberSuffixCommand->SetGuidance("Define the suffix with a pattern such as '-0000'.");
140 << 126 setEventNumberSuffixCommand->SetGuidance("This command is used by HepRepXML, not by HepRepFile.");
141 setCenterCommand = new G4UIcmdWith3VectorAnd << 127 setEventNumberSuffixCommand->SetParameterName("suffix",false);
142 setCenterCommand->SetGuidance("Re-Center coo << 128 setEventNumberSuffixCommand->SetDefaultValue("");
143 setCenterCommand->SetParameterName("CenterX" << 129 setEventNumberSuffixCommand->AvailableForStates(G4State_Idle);
144 setCenterCommand->SetDefaultValue(G4ThreeVec << 130
145 setCenterCommand->SetDefaultUnit("m"); << 131 appendGeometryCommand = new G4UIcmdWithABool("/vis/heprep/appendGeometry", this);
146 << 132 appendGeometryCommand->SetGuidance("Appends copy of geometry to every event.");
147 setEventNumberSuffixCommand = << 133 appendGeometryCommand->SetGuidance("This command is used by HepRepXML, not by HepRepFile.");
148 new G4UIcmdWithAString("/vis/heprep/setEve << 134 appendGeometryCommand->SetParameterName("flag",false);
149 setEventNumberSuffixCommand->SetGuidance( << 135 appendGeometryCommand->SetDefaultValue(true);
150 "Write separate event files, appended with << 136 appendGeometryCommand->AvailableForStates(G4State_Idle);
151 setEventNumberSuffixCommand->SetGuidance( << 137
152 "Define the suffix with a pattern such as << 138 addPointAttributesCommand = new G4UIcmdWithABool("/vis/heprep/addPointAttributes", this);
153 setEventNumberSuffixCommand->SetGuidance( << 139 addPointAttributesCommand->SetGuidance("Adds point attributes to the points of trajectories.");
154 "This command is used by HepRepXML, not by << 140 addPointAttributesCommand->SetGuidance("This command is used by HepRepXML, not by HepRepFile.");
155 setEventNumberSuffixCommand->SetParameterNam << 141 addPointAttributesCommand->SetParameterName("flag",false);
156 setEventNumberSuffixCommand->SetDefaultValue << 142 addPointAttributesCommand->SetDefaultValue(false);
157 setEventNumberSuffixCommand->AvailableForSta << 143 addPointAttributesCommand->AvailableForStates(G4State_Idle);
158 << 144
159 appendGeometryCommand = << 145 useSolidsCommand = new G4UIcmdWithABool("/vis/heprep/useSolids", this);
160 new G4UIcmdWithABool("/vis/heprep/appendGe << 146 useSolidsCommand->SetGuidance("Use HepRep Solids, rather than Geant4 Primitives.");
161 appendGeometryCommand->SetGuidance( << 147 useSolidsCommand->SetGuidance("This command is used by HepRepXML, not by HepRepFile..");
162 "Appends copy of geometry to every event." << 148 useSolidsCommand->SetParameterName("flag",false);
163 appendGeometryCommand->SetGuidance( << 149 useSolidsCommand->SetDefaultValue(true);
164 "This command is used by HepRepXML, not by << 150 useSolidsCommand->AvailableForStates(G4State_Idle);
165 appendGeometryCommand->SetParameterName("fla <<
166 appendGeometryCommand->SetDefaultValue(true) <<
167 appendGeometryCommand->AvailableForStates(G4 <<
168 <<
169 addPointAttributesCommand = <<
170 new G4UIcmdWithABool("/vis/heprep/addPoint <<
171 addPointAttributesCommand->SetGuidance( <<
172 "Adds point attributes to the points of tr <<
173 addPointAttributesCommand->SetGuidance( <<
174 "This command is used by HepRepXML, not by <<
175 addPointAttributesCommand->SetParameterName( <<
176 addPointAttributesCommand->SetDefaultValue(f <<
177 addPointAttributesCommand->AvailableForState <<
178 <<
179 useSolidsCommand = new G4UIcmdWithABool("/vi <<
180 useSolidsCommand->SetGuidance( <<
181 "Use HepRep Solids, rather than Geant4 Pri <<
182 useSolidsCommand->SetGuidance( <<
183 "This command is used by HepRepXML, not by <<
184 useSolidsCommand->SetParameterName("flag", f <<
185 useSolidsCommand->SetDefaultValue(true); <<
186 useSolidsCommand->AvailableForStates(G4State <<
187 } 151 }
188 152
189 G4HepRepMessenger::~G4HepRepMessenger() << 153 G4HepRepMessenger::~G4HepRepMessenger() {
190 { << 154 delete setFileDirCommand;
191 delete setFileDirCommand; << 155 delete setFileNameCommand;
192 delete setFileNameCommand; << 156 delete setOverwriteCommand;
193 delete setOverwriteCommand; << 157 delete setCullInvisiblesCommand;
194 delete setCullInvisiblesCommand; << 158 delete renderCylAsPolygonsCommand;
195 delete renderCylAsPolygonsCommand; << 159 delete setScaleCommand;
196 delete setScaleCommand; << 160 delete setCenterCommand;
197 delete setCenterCommand; << 161 delete setEventNumberSuffixCommand;
198 delete setEventNumberSuffixCommand; << 162 delete appendGeometryCommand;
199 delete appendGeometryCommand; << 163 delete addPointAttributesCommand;
200 delete addPointAttributesCommand; << 164 delete useSolidsCommand;
201 delete useSolidsCommand; << 165 delete heprepDirectory;
202 delete heprepDirectory; <<
203 } 166 }
204 167
205 G4String G4HepRepMessenger::GetCurrentValue(G4 << 168 G4String G4HepRepMessenger::GetCurrentValue(G4UIcommand * command) {
206 { << 169 if (command==setFileDirCommand) {
207 if(command == setFileDirCommand) << 170 return fileDir;
208 { << 171 } else if (command==setFileNameCommand) {
>> 172 return fileName;
>> 173 } else if (command==setOverwriteCommand) {
>> 174 return overwrite;
>> 175 } else if (command==setCullInvisiblesCommand) {
>> 176 return cullInvisibles;
>> 177 } else if (command==renderCylAsPolygonsCommand) {
>> 178 return renderCylAsPolygonsCommand->ConvertToString(cylAsPolygons);
>> 179 } else if (command==setScaleCommand) {
>> 180 return setScaleCommand->ConvertToString(scale);
>> 181 } else if (command==setCenterCommand) {
>> 182 return setCenterCommand->ConvertToString(center,"m");
>> 183 } else if (command==setEventNumberSuffixCommand) {
>> 184 return suffix;
>> 185 } else if (command==appendGeometryCommand) {
>> 186 return appendGeometryCommand->ConvertToString(geometry);
>> 187 } else if (command==addPointAttributesCommand) {
>> 188 return addPointAttributesCommand->ConvertToString(pointAttributes);
>> 189 } else if (command==useSolidsCommand) {
>> 190 return useSolidsCommand->ConvertToString(solids);
>> 191 } else {
>> 192 return "";
>> 193 }
>> 194 }
>> 195
>> 196 void G4HepRepMessenger::SetNewValue(G4UIcommand * command, G4String newValue) {
>> 197 if (command==setFileDirCommand) {
>> 198 fileDir = newValue;
>> 199 } else if (command==setFileNameCommand) {
>> 200 fileName = newValue;
>> 201 } else if (command==setOverwriteCommand) {
>> 202 overwrite = setOverwriteCommand->GetNewBoolValue(newValue);
>> 203 } else if (command==setCullInvisiblesCommand) {
>> 204 cullInvisibles = setCullInvisiblesCommand->GetNewBoolValue(newValue);
>> 205 } else if (command==renderCylAsPolygonsCommand) {
>> 206 cylAsPolygons = renderCylAsPolygonsCommand->GetNewBoolValue(newValue);
>> 207 } else if (command==setScaleCommand) {
>> 208 scale = setScaleCommand->GetNewDoubleValue(newValue);
>> 209 } else if (command==setCenterCommand) {
>> 210 center = setCenterCommand->GetNew3VectorValue(newValue);
>> 211 } else if (command==setEventNumberSuffixCommand) {
>> 212 suffix = newValue;
>> 213 } else if (command==appendGeometryCommand) {
>> 214 geometry = appendGeometryCommand->GetNewBoolValue(newValue);
>> 215 } else if (command==addPointAttributesCommand) {
>> 216 pointAttributes = addPointAttributesCommand->GetNewBoolValue(newValue);
>> 217 } else if (command==useSolidsCommand) {
>> 218 solids = useSolidsCommand->GetNewBoolValue(newValue);
>> 219 }
>> 220 }
>> 221
>> 222 G4String G4HepRepMessenger::getFileDir() {
209 return fileDir; 223 return fileDir;
210 } << 224 }
211 else if(command == setFileNameCommand) << 225
212 { << 226 G4String G4HepRepMessenger::getFileName() {
213 return fileName; 227 return fileName;
214 } << 228 }
215 else if(command == setOverwriteCommand) << 229
216 { << 230 G4bool G4HepRepMessenger::getOverwrite() {
217 return G4UIcommand::ConvertToString(overwr << 231 return overwrite;
218 } << 232 }
219 else if(command == setCullInvisiblesCommand) << 233
220 { << 234 G4bool G4HepRepMessenger::getCullInvisibles() {
221 return G4UIcommand::ConvertToString(cullIn << 235 return cullInvisibles;
222 } << 236 }
223 else if(command == renderCylAsPolygonsComman << 237
224 { << 238 G4bool G4HepRepMessenger::renderCylAsPolygons() {
225 return renderCylAsPolygonsCommand->Convert << 239 return cylAsPolygons;
226 } << 240 }
227 else if(command == setScaleCommand) << 241
228 { << 242 G4double G4HepRepMessenger::getScale() {
229 return setScaleCommand->ConvertToString(sc << 243 return scale;
230 } << 244 }
231 else if(command == setCenterCommand) << 245
232 { << 246 G4ThreeVector G4HepRepMessenger::getCenter() {
233 return setCenterCommand->ConvertToString(c << 247 return center;
234 } << 248 }
235 else if(command == setEventNumberSuffixComma << 249
236 { << 250 G4String G4HepRepMessenger::getEventNumberSuffix() {
237 return suffix; 251 return suffix;
238 } <<
239 else if(command == appendGeometryCommand) <<
240 { <<
241 return appendGeometryCommand->ConvertToStr <<
242 } <<
243 else if(command == addPointAttributesCommand <<
244 { <<
245 return addPointAttributesCommand->ConvertT <<
246 } <<
247 else if(command == useSolidsCommand) <<
248 { <<
249 return useSolidsCommand->ConvertToString(s <<
250 } <<
251 else <<
252 { <<
253 return ""; <<
254 } <<
255 } 252 }
256 253
257 void G4HepRepMessenger::SetNewValue(G4UIcomman << 254 G4bool G4HepRepMessenger::appendGeometry() {
258 { << 255 return geometry;
259 if(command == setFileDirCommand) << 256 }
260 { <<
261 fileDir = newValue; <<
262 } <<
263 else if(command == setFileNameCommand) <<
264 { <<
265 fileName = newValue; <<
266 } <<
267 else if(command == setOverwriteCommand) <<
268 { <<
269 overwrite = setOverwriteCommand->GetNewBoo <<
270 } <<
271 else if(command == setCullInvisiblesCommand) <<
272 { <<
273 cullInvisibles = setCullInvisiblesCommand- <<
274 } <<
275 else if(command == renderCylAsPolygonsComman <<
276 { <<
277 cylAsPolygons = renderCylAsPolygonsCommand <<
278 } <<
279 else if(command == setScaleCommand) <<
280 { <<
281 scale = setScaleCommand->GetNewDoubleValue <<
282 } <<
283 else if(command == setCenterCommand) <<
284 { <<
285 center = setCenterCommand->GetNew3VectorVa <<
286 } <<
287 else if(command == setEventNumberSuffixComma <<
288 { <<
289 suffix = newValue; <<
290 } <<
291 else if(command == appendGeometryCommand) <<
292 { <<
293 geometry = appendGeometryCommand->GetNewBo <<
294 } <<
295 else if(command == addPointAttributesCommand <<
296 { <<
297 pointAttributes = addPointAttributesComman <<
298 } <<
299 else if(command == useSolidsCommand) <<
300 { <<
301 solids = useSolidsCommand->GetNewBoolValue <<
302 } <<
303 } <<
304 <<
305 G4String G4HepRepMessenger::getFileDir() { ret <<
306 <<
307 G4String G4HepRepMessenger::getFileName() { re <<
308 <<
309 G4bool G4HepRepMessenger::getOverwrite() { ret <<
310 <<
311 G4bool G4HepRepMessenger::getCullInvisibles() <<
312 <<
313 G4bool G4HepRepMessenger::renderCylAsPolygons( <<
314 <<
315 G4double G4HepRepMessenger::getScale() { retur <<
316 <<
317 G4ThreeVector G4HepRepMessenger::getCenter() { <<
318 <<
319 G4String G4HepRepMessenger::getEventNumberSuff <<
320 257
321 G4bool G4HepRepMessenger::appendGeometry() { r << 258 G4bool G4HepRepMessenger::addPointAttributes() {
>> 259 return pointAttributes;
>> 260 }
322 261
323 G4bool G4HepRepMessenger::addPointAttributes() << 262 G4bool G4HepRepMessenger::useSolids() {
>> 263 return solids;
>> 264 }
324 265
325 G4bool G4HepRepMessenger::useSolids() { return << 266 G4bool G4HepRepMessenger::writeInvisibles() {
>> 267 return invisibles;
>> 268 }
326 269
327 G4bool G4HepRepMessenger::writeInvisibles() { <<
328 270