Geant4 11.3.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | Public Attributes | List of all members
G4HepRepFileXMLWriter Class Reference

#include <G4HepRepFileXMLWriter.hh>

Public Member Functions

 G4HepRepFileXMLWriter ()
 
void addType (const char *name, int newTypeDepth)
 
void addInstance ()
 
void addPrimitive ()
 
void addPoint (double x, double y, double z)
 
void addAttDef (const char *name, const char *desc, const char *type, const char *extra)
 
void addAttValue (const char *name, const char *value)
 
void addAttValue (const char *name, double value)
 
void addAttValue (const char *name, int value)
 
void addAttValue (const char *name, bool value)
 
void addAttValue (const char *name, double value1, double value2, double value3)
 
void open (const char *filespec)
 
void close ()
 
void endTypes ()
 

Public Attributes

bool isOpen
 
int typeDepth
 
bool inType [50]
 
bool inInstance [50]
 
char * prevTypeName [50]
 

Detailed Description

Definition at line 50 of file G4HepRepFileXMLWriter.hh.

Constructor & Destructor Documentation

◆ G4HepRepFileXMLWriter()

G4HepRepFileXMLWriter::G4HepRepFileXMLWriter ( )

Definition at line 47 of file G4HepRepFileXMLWriter.cc.

48{
49 isOpen = false;
50 init();
51}

Member Function Documentation

◆ addAttDef()

void G4HepRepFileXMLWriter::addAttDef ( const char * name,
const char * desc,
const char * type,
const char * extra )

Definition at line 221 of file G4HepRepFileXMLWriter.cc.

223{
224 if(fout.good())
225 {
226 indent();
227 fout << " <heprep:attdef extra=\"" << extra << "\" name=\"" << name
228 << "\" type=\"" << type << "\"" << G4endl;
229 indent();
230 fout << " desc=\"" << desc << "\"/>" << G4endl;
231 }
232 else
233 {
234#ifdef G4HEPREPFILEDEBUG
235 G4cout << "G4HepRepFileXMLWriter:addAttDef No file is currently open"
236 << G4endl;
237#endif
238 }
239}
G4endl
#define G4endl
Definition G4ios.hh:67
G4cout
G4GLOB_DLL std::ostream G4cout
G4InuclParticleNames::name
const char * name(G4int ptype)
Definition G4InuclParticleNames.hh:76

◆ addAttValue() [1/5]

void G4HepRepFileXMLWriter::addAttValue ( const char * name,
bool value )

Definition at line 299 of file G4HepRepFileXMLWriter.cc.

300{
301 if(fout.good())
302 {
303 indent();
304 fout << " <heprep:attvalue showLabel=\"NONE\" name=\"" << name << "\""
305 << G4endl;
306 indent();
307 if(value)
308 fout << " value=\"True\"/>" << G4endl;
309 else
310 fout << " value=\"False\"/>" << G4endl;
311 }
312 else
313 {
314#ifdef G4HEPREPFILEDEBUG
315 G4cout << "G4HepRepFileXMLWriter:addAttValue No file is currently open"
316 << G4endl;
317#endif
318 }
319}

◆ addAttValue() [2/5]

void G4HepRepFileXMLWriter::addAttValue ( const char * name,
const char * value )

Definition at line 242 of file G4HepRepFileXMLWriter.cc.

243{
244 if(fout.good())
245 {
246 indent();
247 fout << " <heprep:attvalue showLabel=\"NONE\" name=\"" << name << "\""
248 << G4endl;
249 indent();
250 fout << " value=\"" << value << "\"/>" << G4endl;
251 }
252 else
253 {
254#ifdef G4HEPREPFILEDEBUG
255 G4cout << "G4HepRepFileXMLWriter:addAttValue No file is currently open"
256 << G4endl;
257#endif
258 }
259}

◆ addAttValue() [3/5]

void G4HepRepFileXMLWriter::addAttValue ( const char * name,
double value )

Definition at line 261 of file G4HepRepFileXMLWriter.cc.

262{
263 if(fout.good())
264 {
265 indent();
266 fout << " <heprep:attvalue showLabel=\"NONE\" name=\"" << name << "\""
267 << G4endl;
268 indent();
269 fout << " value=\"" << value << "\"/>" << G4endl;
270 }
271 else
272 {
273#ifdef G4HEPREPFILEDEBUG
274 G4cout << "G4HepRepFileXMLWriter:addAttValue No file is currently open"
275 << G4endl;
276#endif
277 }
278}

◆ addAttValue() [4/5]

void G4HepRepFileXMLWriter::addAttValue ( const char * name,
double value1,
double value2,
double value3 )

Definition at line 321 of file G4HepRepFileXMLWriter.cc.

323{
324 if(fout.good())
325 {
326 int redness = int(value1 * 255.);
327 int greenness = int(value2 * 255.);
328 int blueness = int(value3 * 255.);
329 indent();
330 fout << " <heprep:attvalue showLabel=\"NONE\" name=\"" << name << "\""
331 << G4endl;
332 indent();
333 fout << " value=\"" << redness << "," << greenness << "," << blueness
334 << "\"/>" << G4endl;
335 }
336 else
337 {
338#ifdef G4HEPREPFILEDEBUG
339 G4cout << "G4HepRepFileXMLWriter:addAttValue No file is currently open"
340 << G4endl;
341#endif
342 }
343}

◆ addAttValue() [5/5]

void G4HepRepFileXMLWriter::addAttValue ( const char * name,
int value )

Definition at line 280 of file G4HepRepFileXMLWriter.cc.

281{
282 if(fout.good())
283 {
284 indent();
285 fout << " <heprep:attvalue showLabel=\"NONE\" name=\"" << name << "\""
286 << G4endl;
287 indent();
288 fout << " value=\"" << value << "\"/>" << G4endl;
289 }
290 else
291 {
292#ifdef G4HEPREPFILEDEBUG
293 G4cout << "G4HepRepFileXMLWriter:addAttValue No file is currently open"
294 << G4endl;
295#endif
296 }
297}

◆ addInstance()

void G4HepRepFileXMLWriter::addInstance ( )

Definition at line 124 of file G4HepRepFileXMLWriter.cc.

125{
126 if(fout.good())
127 {
128 if(inType[typeDepth])
129 {
130 endInstance();
131 inInstance[typeDepth] = true;
132 indent();
133 fout << "<heprep:instance>" << G4endl;
134 }
135 else
136 {
137#ifdef G4HEPREPFILEDEBUG
138 G4cout
139 << "G4HepRepFileXMLWriter:addInstance No HepRep Type is currently open"
140 << G4endl;
141#endif
142 }
143 }
144 else
145 {
146#ifdef G4HEPREPFILEDEBUG
147 G4cout << "G4HepRepFileXMLWriter:addInstance No file is currently open"
148 << G4endl;
149#endif
150 }
151}

Referenced by addType().

◆ addPoint()

void G4HepRepFileXMLWriter::addPoint ( double x,
double y,
double z )

Definition at line 182 of file G4HepRepFileXMLWriter.cc.

183{
184 if(fout.good())
185 {
186 if(inPrimitive)
187 {
188 endPoint();
189 inPoint = true;
190 indent();
191
192 // Include scale and center values
193 G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
194 G4double scale = messenger->getScale();
195 G4ThreeVector center = messenger->getCenter();
196 G4double xNew = scale * (x - center.x());
197 G4double yNew = scale * (y - center.y());
198 G4double zNew = scale * (z - center.z());
199
200 fout << "<heprep:point x=\"" << xNew << "\" y=\"" << yNew << "\" z=\""
201 << zNew << "\">" << G4endl;
202 }
203 else
204 {
205#ifdef G4HEPREPFILEDEBUG
206 G4cout << "G4HepRepFileXMLWriter:addPoint No HepRep Primitive is "
207 "currently open"
208 << G4endl;
209#endif
210 }
211 }
212 else
213 {
214#ifdef G4HEPREPFILEDEBUG
215 G4cout << "G4HepRepFileXMLWriter:addPoint No file is currently open"
216 << G4endl;
217#endif
218 }
219}
G4ThreeVector
CLHEP::Hep3Vector G4ThreeVector
Definition G4ThreeVector.hh:36
G4double
double G4double
Definition G4Types.hh:83
CLHEP::Hep3Vector::z
double z() const
CLHEP::Hep3Vector::x
double x() const
CLHEP::Hep3Vector::y
double y() const
G4HepRepMessenger::getScale
virtual G4double getScale()
Definition G4HepRepMessenger.cc:315
G4HepRepMessenger::GetInstance
static G4HepRepMessenger * GetInstance()
Definition G4HepRepMessenger.cc:31
G4HepRepMessenger::getCenter
virtual G4ThreeVector getCenter()
Definition G4HepRepMessenger.cc:317

◆ addPrimitive()

void G4HepRepFileXMLWriter::addPrimitive ( )

Definition at line 153 of file G4HepRepFileXMLWriter.cc.

154{
155 if(fout.good())
156 {
157 if(inInstance[typeDepth])
158 {
159 endPrimitive();
160 inPrimitive = true;
161 indent();
162 fout << "<heprep:primitive>" << G4endl;
163 }
164 else
165 {
166#ifdef G4HEPREPFILEDEBUG
167 G4cout << "G4HepRepFileXMLWriter:addPrimitive No HepRep Instance is "
168 "currently open"
169 << G4endl;
170#endif
171 }
172 }
173 else
174 {
175#ifdef G4HEPREPFILEDEBUG
176 G4cout << "G4HepRepFileXMLWriter:addPrimitive No file is currently open"
177 << G4endl;
178#endif
179 }
180}

◆ addType()

void G4HepRepFileXMLWriter::addType ( const char * name,
int newTypeDepth )

Definition at line 71 of file G4HepRepFileXMLWriter.cc.

72{
73 if(fout.good())
74 {
75 // Flatten structure if it exceeds maximum allowed typeDepth of 49.
76 if(newTypeDepth > 49)
77 newTypeDepth = 49;
78
79 if(newTypeDepth < 0)
80 newTypeDepth = 0;
81
82 // Insert any layers that are missing from the hierarchy (protects against
83 // callers that skip from, say, layer 1 to layer 3 with no layer 2).
84 while(typeDepth < (newTypeDepth - 1))
85 {
86 addType("Layer Inserted by G4HepRepFileXMLWriter", typeDepth + 1);
87 addInstance();
88 }
89
90 // If moving closer to the root, close previously open types.
91 while(newTypeDepth < typeDepth)
92 endType();
93
94 // Close any remaining primitives of the current instance.
95 endPrimitive();
96
97 // If this is a new type name for the current depth, declare the
98 // new Type. Otherwise, it is just another Instance of the current Type.
99 if(strcmp(name, prevTypeName[newTypeDepth]) != 0)
100 {
101 if(inType[newTypeDepth])
102 endType();
103
104 prevTypeName[newTypeDepth] = new char[strlen(name) + 1];
105 strcpy(prevTypeName[newTypeDepth], name);
106
107 inType[newTypeDepth] = true;
108 indent();
109 fout << "<heprep:type version=\"null\" name=\"" << name << "\">"
110 << G4endl;
111
112 typeDepth = newTypeDepth;
113 }
114 }
115 else
116 {
117#ifdef G4HEPREPFILEDEBUG
118 G4cout << "G4HepRepFileXMLWriter:addType No file is currently open."
119 << G4endl;
120#endif
121 }
122}
G4HepRepFileXMLWriter::addType
void addType(const char *name, int newTypeDepth)
Definition G4HepRepFileXMLWriter.cc:71

Referenced by addType().

◆ close()

void G4HepRepFileXMLWriter::close ( )

Definition at line 372 of file G4HepRepFileXMLWriter.cc.

373{
374 // Close any remaining open Types
375 endTypes();
376
377 if(fout.good())
378 {
379 fout << "</heprep:heprep>" << G4endl;
380 fout.close();
381 isOpen = false;
382 }
383 else
384 {
385 G4cout << "G4HepRepFileXMLWriter:close No file is currently open" << G4endl;
386 }
387}

Referenced by open().

◆ endTypes()

void G4HepRepFileXMLWriter::endTypes ( )

Definition at line 389 of file G4HepRepFileXMLWriter.cc.

390{
391 // Close any remaining open Types
392 while(typeDepth > -1)
393 endType();
394}

Referenced by close().

◆ open()

void G4HepRepFileXMLWriter::open ( const char * filespec)

Definition at line 345 of file G4HepRepFileXMLWriter.cc.

346{
347 if(isOpen)
348 close();
349
350 fout.open(fileSpec);
351
352 if(fout.good())
353 {
354 fout << "<?xml version=\"1.0\" ?>" << G4endl;
355 fout << "<heprep:heprep "
356 "xmlns:heprep=\"http://www.slac.stanford.edu/~perl/heprep/\""
357 << G4endl;
358 fout << " xmlns:xsi=\"http://www.w3.org/1999/XMLSchema-instance\" "
359 "xsi:schemaLocation=\"HepRep.xsd\">"
360 << G4endl;
361
362 isOpen = true;
363 init();
364 }
365 else
366 {
367 G4cout << "G4HepRepFileXMLWriter:open Unable to write to file " << fileSpec
368 << G4endl;
369 }
370}

Member Data Documentation

◆ inInstance

bool G4HepRepFileXMLWriter::inInstance[50]

Definition at line 82 of file G4HepRepFileXMLWriter.hh.

Referenced by addInstance(), and addPrimitive().

◆ inType

bool G4HepRepFileXMLWriter::inType[50]

Definition at line 81 of file G4HepRepFileXMLWriter.hh.

Referenced by addInstance(), and addType().

◆ isOpen

bool G4HepRepFileXMLWriter::isOpen

Definition at line 79 of file G4HepRepFileXMLWriter.hh.

Referenced by close(), G4HepRepFileXMLWriter(), and open().

◆ prevTypeName

char* G4HepRepFileXMLWriter::prevTypeName[50]

Definition at line 83 of file G4HepRepFileXMLWriter.hh.

Referenced by addType().

◆ typeDepth

int G4HepRepFileXMLWriter::typeDepth

Definition at line 80 of file G4HepRepFileXMLWriter.hh.

Referenced by addInstance(), addPrimitive(), addType(), and endTypes().

The documentation for this class was generated from the following files: