Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/HepRep/src/G4HepRepFileXMLWriter.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /visualization/HepRep/src/G4HepRepFileXMLWriter.cc (Version 11.3.0) and /visualization/HepRep/src/G4HepRepFileXMLWriter.cc (Version 11.1.1)


  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 //--------------------------------------------     26 //--------------------------------------------------------------------------
 27 // File and Version Information:                   27 // File and Version Information:
 28 //                                                 28 //
 29 // Description:                                    29 // Description:
 30 //  Create a HepRep XML File (HepRep version 1     30 //  Create a HepRep XML File (HepRep version 1).
 31 //                                                 31 //
 32 // Environment:                                    32 // Environment:
 33 //  Software developed for the general High En     33 //  Software developed for the general High Energy Physics community.
 34 //                                                 34 //
 35 // Author :                                        35 // Author :
 36 //       J. Perl                    Original A     36 //       J. Perl                    Original Author
 37 //                                                 37 //
 38 // Copyright Information:                          38 // Copyright Information:
 39 //      Copyright (C) 2001          Stanford L     39 //      Copyright (C) 2001          Stanford Linear Accelerator Center
 40 //--------------------------------------------     40 //------------------------------------------------------------------------
 41                                                    41 
 42 #include "G4HepRepFileXMLWriter.hh"                42 #include "G4HepRepFileXMLWriter.hh"
 43                                                    43 
 44 #include "G4HepRepMessenger.hh"                    44 #include "G4HepRepMessenger.hh"
 45 #include "G4ios.hh"                                45 #include "G4ios.hh"
 46                                                    46 
 47 G4HepRepFileXMLWriter::G4HepRepFileXMLWriter()     47 G4HepRepFileXMLWriter::G4HepRepFileXMLWriter()
 48 {                                                  48 {
 49   isOpen = false;                                  49   isOpen = false;
 50   init();                                          50   init();
 51 }                                                  51 }
 52                                                    52 
 53 void G4HepRepFileXMLWriter::init()                 53 void G4HepRepFileXMLWriter::init()
 54 {                                                  54 {
 55   typeDepth = -1;                                  55   typeDepth = -1;
 56                                                    56 
 57   int i = -1;                                      57   int i = -1;
 58   while(i++ < 49)                                  58   while(i++ < 49)
 59   {                                                59   {
 60     prevTypeName[i] = new char[1];                 60     prevTypeName[i] = new char[1];
 61     strcpy(prevTypeName[i], "");                   61     strcpy(prevTypeName[i], "");
 62                                                    62 
 63     inType[i]     = false;                         63     inType[i]     = false;
 64     inInstance[i] = false;                         64     inInstance[i] = false;
 65   }                                                65   }
 66                                                    66 
 67   inPrimitive = false;                             67   inPrimitive = false;
 68   inPoint     = false;                             68   inPoint     = false;
 69 }                                                  69 }
 70                                                    70 
 71 void G4HepRepFileXMLWriter::addType(const char     71 void G4HepRepFileXMLWriter::addType(const char* name, int newTypeDepth)
 72 {                                                  72 {
 73   if(fout.good())                                  73   if(fout.good())
 74   {                                                74   {
 75     // Flatten structure if it exceeds maximum     75     // Flatten structure if it exceeds maximum allowed typeDepth of 49.
 76     if(newTypeDepth > 49)                          76     if(newTypeDepth > 49)
 77       newTypeDepth = 49;                           77       newTypeDepth = 49;
 78                                                    78 
 79     if(newTypeDepth < 0)                           79     if(newTypeDepth < 0)
 80       newTypeDepth = 0;                            80       newTypeDepth = 0;
 81                                                    81 
 82     // Insert any layers that are missing from     82     // Insert any layers that are missing from the hierarchy (protects against
 83     // callers that skip from, say, layer 1 to     83     // callers that skip from, say, layer 1 to layer 3 with no layer 2).
 84     while(typeDepth < (newTypeDepth - 1))          84     while(typeDepth < (newTypeDepth - 1))
 85     {                                              85     {
 86       addType("Layer Inserted by G4HepRepFileX     86       addType("Layer Inserted by G4HepRepFileXMLWriter", typeDepth + 1);
 87       addInstance();                               87       addInstance();
 88     }                                              88     }
 89                                                    89 
 90     // If moving closer to the root, close pre     90     // If moving closer to the root, close previously open types.
 91     while(newTypeDepth < typeDepth)                91     while(newTypeDepth < typeDepth)
 92       endType();                                   92       endType();
 93                                                    93 
 94     // Close any remaining primitives of the c     94     // Close any remaining primitives of the current instance.
 95     endPrimitive();                                95     endPrimitive();
 96                                                    96 
 97     // If this is a new type name for the curr     97     // If this is a new type name for the current depth, declare the
 98     // new Type.  Otherwise, it is just anothe     98     // new Type.  Otherwise, it is just another Instance of the current Type.
 99     if(strcmp(name, prevTypeName[newTypeDepth]     99     if(strcmp(name, prevTypeName[newTypeDepth]) != 0)
100     {                                             100     {
101       if(inType[newTypeDepth])                    101       if(inType[newTypeDepth])
102         endType();                                102         endType();
103                                                   103 
104       prevTypeName[newTypeDepth] = new char[st    104       prevTypeName[newTypeDepth] = new char[strlen(name) + 1];
105       strcpy(prevTypeName[newTypeDepth], name)    105       strcpy(prevTypeName[newTypeDepth], name);
106                                                   106 
107       inType[newTypeDepth] = true;                107       inType[newTypeDepth] = true;
108       indent();                                   108       indent();
109       fout << "<heprep:type version=\"null\" n    109       fout << "<heprep:type version=\"null\" name=\"" << name << "\">"
110            << G4endl;                             110            << G4endl;
111                                                   111 
112       typeDepth = newTypeDepth;                   112       typeDepth = newTypeDepth;
113     }                                             113     }
114   }                                               114   }
115   else                                            115   else
116   {                                               116   {
117 #ifdef G4HEPREPFILEDEBUG                          117 #ifdef G4HEPREPFILEDEBUG
118     G4cout << "G4HepRepFileXMLWriter:addType N    118     G4cout << "G4HepRepFileXMLWriter:addType No file is currently open."
119            << G4endl;                             119            << G4endl;
120 #endif                                            120 #endif
121   }                                               121   }
122 }                                                 122 }
123                                                   123 
124 void G4HepRepFileXMLWriter::addInstance()         124 void G4HepRepFileXMLWriter::addInstance()
125 {                                                 125 {
126   if(fout.good())                                 126   if(fout.good())
127   {                                               127   {
128     if(inType[typeDepth])                         128     if(inType[typeDepth])
129     {                                             129     {
130       endInstance();                              130       endInstance();
131       inInstance[typeDepth] = true;               131       inInstance[typeDepth] = true;
132       indent();                                   132       indent();
133       fout << "<heprep:instance>" << G4endl;      133       fout << "<heprep:instance>" << G4endl;
134     }                                             134     }
135     else                                          135     else
136     {                                             136     {
137 #ifdef G4HEPREPFILEDEBUG                          137 #ifdef G4HEPREPFILEDEBUG
138       G4cout                                      138       G4cout
139         << "G4HepRepFileXMLWriter:addInstance     139         << "G4HepRepFileXMLWriter:addInstance No HepRep Type is currently open"
140         << G4endl;                                140         << G4endl;
141 #endif                                            141 #endif
142     }                                             142     }
143   }                                               143   }
144   else                                            144   else
145   {                                               145   {
146 #ifdef G4HEPREPFILEDEBUG                          146 #ifdef G4HEPREPFILEDEBUG
147     G4cout << "G4HepRepFileXMLWriter:addInstan    147     G4cout << "G4HepRepFileXMLWriter:addInstance No file is currently open"
148            << G4endl;                             148            << G4endl;
149 #endif                                            149 #endif
150   }                                               150   }
151 }                                                 151 }
152                                                   152 
153 void G4HepRepFileXMLWriter::addPrimitive()        153 void G4HepRepFileXMLWriter::addPrimitive()
154 {                                                 154 {
155   if(fout.good())                                 155   if(fout.good())
156   {                                               156   {
157     if(inInstance[typeDepth])                     157     if(inInstance[typeDepth])
158     {                                             158     {
159       endPrimitive();                             159       endPrimitive();
160       inPrimitive = true;                         160       inPrimitive = true;
161       indent();                                   161       indent();
162       fout << "<heprep:primitive>" << G4endl;     162       fout << "<heprep:primitive>" << G4endl;
163     }                                             163     }
164     else                                          164     else
165     {                                             165     {
166 #ifdef G4HEPREPFILEDEBUG                          166 #ifdef G4HEPREPFILEDEBUG
167       G4cout << "G4HepRepFileXMLWriter:addPrim    167       G4cout << "G4HepRepFileXMLWriter:addPrimitive No HepRep Instance is "
168                 "currently open"                  168                 "currently open"
169              << G4endl;                           169              << G4endl;
170 #endif                                            170 #endif
171     }                                             171     }
172   }                                               172   }
173   else                                            173   else
174   {                                               174   {
175 #ifdef G4HEPREPFILEDEBUG                          175 #ifdef G4HEPREPFILEDEBUG
176     G4cout << "G4HepRepFileXMLWriter:addPrimit    176     G4cout << "G4HepRepFileXMLWriter:addPrimitive No file is currently open"
177            << G4endl;                             177            << G4endl;
178 #endif                                            178 #endif
179   }                                               179   }
180 }                                                 180 }
181                                                   181 
182 void G4HepRepFileXMLWriter::addPoint(double x,    182 void G4HepRepFileXMLWriter::addPoint(double x, double y, double z)
183 {                                                 183 {
184   if(fout.good())                                 184   if(fout.good())
185   {                                               185   {
186     if(inPrimitive)                               186     if(inPrimitive)
187     {                                             187     {
188       endPoint();                                 188       endPoint();
189       inPoint = true;                             189       inPoint = true;
190       indent();                                   190       indent();
191                                                   191 
192       // Include scale and center values          192       // Include scale and center values
193       G4HepRepMessenger* messenger = G4HepRepM    193       G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
194       G4double scale               = messenger    194       G4double scale               = messenger->getScale();
195       G4ThreeVector center         = messenger    195       G4ThreeVector center         = messenger->getCenter();
196       G4double xNew                = scale * (    196       G4double xNew                = scale * (x - center.x());
197       G4double yNew                = scale * (    197       G4double yNew                = scale * (y - center.y());
198       G4double zNew                = scale * (    198       G4double zNew                = scale * (z - center.z());
199                                                   199 
200       fout << "<heprep:point x=\"" << xNew <<     200       fout << "<heprep:point x=\"" << xNew << "\" y=\"" << yNew << "\" z=\""
201            << zNew << "\">" << G4endl;            201            << zNew << "\">" << G4endl;
202     }                                             202     }
203     else                                          203     else
204     {                                             204     {
205 #ifdef G4HEPREPFILEDEBUG                          205 #ifdef G4HEPREPFILEDEBUG
206       G4cout << "G4HepRepFileXMLWriter:addPoin    206       G4cout << "G4HepRepFileXMLWriter:addPoint No HepRep Primitive is "
207                 "currently open"                  207                 "currently open"
208              << G4endl;                           208              << G4endl;
209 #endif                                            209 #endif
210     }                                             210     }
211   }                                               211   }
212   else                                            212   else
213   {                                               213   {
214 #ifdef G4HEPREPFILEDEBUG                          214 #ifdef G4HEPREPFILEDEBUG
215     G4cout << "G4HepRepFileXMLWriter:addPoint     215     G4cout << "G4HepRepFileXMLWriter:addPoint No file is currently open"
216            << G4endl;                             216            << G4endl;
217 #endif                                            217 #endif
218   }                                               218   }
219 }                                                 219 }
220                                                   220 
221 void G4HepRepFileXMLWriter::addAttDef(const ch    221 void G4HepRepFileXMLWriter::addAttDef(const char* name, const char* desc,
222                                       const ch    222                                       const char* type, const char* extra)
223 {                                                 223 {
224   if(fout.good())                                 224   if(fout.good())
225   {                                               225   {
226     indent();                                     226     indent();
227     fout << "  <heprep:attdef extra=\"" << ext    227     fout << "  <heprep:attdef extra=\"" << extra << "\" name=\"" << name
228          << "\" type=\"" << type << "\"" << G4    228          << "\" type=\"" << type << "\"" << G4endl;
229     indent();                                     229     indent();
230     fout << "  desc=\"" << desc << "\"/>" << G    230     fout << "  desc=\"" << desc << "\"/>" << G4endl;
231   }                                               231   }
232   else                                            232   else
233   {                                               233   {
234 #ifdef G4HEPREPFILEDEBUG                          234 #ifdef G4HEPREPFILEDEBUG
235     G4cout << "G4HepRepFileXMLWriter:addAttDef    235     G4cout << "G4HepRepFileXMLWriter:addAttDef No file is currently open"
236            << G4endl;                             236            << G4endl;
237 #endif                                            237 #endif
238   }                                               238   }
239 }                                                 239 }
240                                                   240 
241 // Four methods to fill attValues                 241 // Four methods to fill attValues
242 void G4HepRepFileXMLWriter::addAttValue(const     242 void G4HepRepFileXMLWriter::addAttValue(const char* name, const char* value)
243 {                                                 243 {
244   if(fout.good())                                 244   if(fout.good())
245   {                                               245   {
246     indent();                                     246     indent();
247     fout << "  <heprep:attvalue showLabel=\"NO    247     fout << "  <heprep:attvalue showLabel=\"NONE\" name=\"" << name << "\""
248          << G4endl;                               248          << G4endl;
249     indent();                                     249     indent();
250     fout << "    value=\"" << value << "\"/>"     250     fout << "    value=\"" << value << "\"/>" << G4endl;
251   }                                               251   }
252   else                                            252   else
253   {                                               253   {
254 #ifdef G4HEPREPFILEDEBUG                          254 #ifdef G4HEPREPFILEDEBUG
255     G4cout << "G4HepRepFileXMLWriter:addAttVal    255     G4cout << "G4HepRepFileXMLWriter:addAttValue No file is currently open"
256            << G4endl;                             256            << G4endl;
257 #endif                                            257 #endif
258   }                                               258   }
259 }                                                 259 }
260                                                   260 
261 void G4HepRepFileXMLWriter::addAttValue(const     261 void G4HepRepFileXMLWriter::addAttValue(const char* name, double value)
262 {                                                 262 {
263   if(fout.good())                                 263   if(fout.good())
264   {                                               264   {
265     indent();                                     265     indent();
266     fout << "  <heprep:attvalue showLabel=\"NO    266     fout << "  <heprep:attvalue showLabel=\"NONE\" name=\"" << name << "\""
267          << G4endl;                               267          << G4endl;
268     indent();                                     268     indent();
269     fout << "    value=\"" << value << "\"/>"     269     fout << "    value=\"" << value << "\"/>" << G4endl;
270   }                                               270   }
271   else                                            271   else
272   {                                               272   {
273 #ifdef G4HEPREPFILEDEBUG                          273 #ifdef G4HEPREPFILEDEBUG
274     G4cout << "G4HepRepFileXMLWriter:addAttVal    274     G4cout << "G4HepRepFileXMLWriter:addAttValue No file is currently open"
275            << G4endl;                             275            << G4endl;
276 #endif                                            276 #endif
277   }                                               277   }
278 }                                                 278 }
279                                                   279 
280 void G4HepRepFileXMLWriter::addAttValue(const     280 void G4HepRepFileXMLWriter::addAttValue(const char* name, int value)
281 {                                                 281 {
282   if(fout.good())                                 282   if(fout.good())
283   {                                               283   {
284     indent();                                     284     indent();
285     fout << "  <heprep:attvalue showLabel=\"NO    285     fout << "  <heprep:attvalue showLabel=\"NONE\" name=\"" << name << "\""
286          << G4endl;                               286          << G4endl;
287     indent();                                     287     indent();
288     fout << "    value=\"" << value << "\"/>"     288     fout << "    value=\"" << value << "\"/>" << G4endl;
289   }                                               289   }
290   else                                            290   else
291   {                                               291   {
292 #ifdef G4HEPREPFILEDEBUG                          292 #ifdef G4HEPREPFILEDEBUG
293     G4cout << "G4HepRepFileXMLWriter:addAttVal    293     G4cout << "G4HepRepFileXMLWriter:addAttValue No file is currently open"
294            << G4endl;                             294            << G4endl;
295 #endif                                            295 #endif
296   }                                               296   }
297 }                                                 297 }
298                                                   298 
299 void G4HepRepFileXMLWriter::addAttValue(const     299 void G4HepRepFileXMLWriter::addAttValue(const char* name, bool value)
300 {                                                 300 {
301   if(fout.good())                                 301   if(fout.good())
302   {                                               302   {
303     indent();                                     303     indent();
304     fout << "  <heprep:attvalue showLabel=\"NO    304     fout << "  <heprep:attvalue showLabel=\"NONE\" name=\"" << name << "\""
305          << G4endl;                               305          << G4endl;
306     indent();                                     306     indent();
307     if(value)                                     307     if(value)
308       fout << "    value=\"True\"/>" << G4endl    308       fout << "    value=\"True\"/>" << G4endl;
309     else                                          309     else
310       fout << "    value=\"False\"/>" << G4end    310       fout << "    value=\"False\"/>" << G4endl;
311   }                                               311   }
312   else                                            312   else
313   {                                               313   {
314 #ifdef G4HEPREPFILEDEBUG                          314 #ifdef G4HEPREPFILEDEBUG
315     G4cout << "G4HepRepFileXMLWriter:addAttVal    315     G4cout << "G4HepRepFileXMLWriter:addAttValue No file is currently open"
316            << G4endl;                             316            << G4endl;
317 #endif                                            317 #endif
318   }                                               318   }
319 }                                                 319 }
320                                                   320 
321 void G4HepRepFileXMLWriter::addAttValue(const     321 void G4HepRepFileXMLWriter::addAttValue(const char* name, double value1,
322                                         double    322                                         double value2, double value3)
323 {                                                 323 {
324   if(fout.good())                                 324   if(fout.good())
325   {                                               325   {
326     int redness   = int(value1 * 255.);           326     int redness   = int(value1 * 255.);
327     int greenness = int(value2 * 255.);           327     int greenness = int(value2 * 255.);
328     int blueness  = int(value3 * 255.);           328     int blueness  = int(value3 * 255.);
329     indent();                                     329     indent();
330     fout << "  <heprep:attvalue showLabel=\"NO    330     fout << "  <heprep:attvalue showLabel=\"NONE\" name=\"" << name << "\""
331          << G4endl;                               331          << G4endl;
332     indent();                                     332     indent();
333     fout << "    value=\"" << redness << "," <    333     fout << "    value=\"" << redness << "," << greenness << "," << blueness
334          << "\"/>" << G4endl;                     334          << "\"/>" << G4endl;
335   }                                               335   }
336   else                                            336   else
337   {                                               337   {
338 #ifdef G4HEPREPFILEDEBUG                          338 #ifdef G4HEPREPFILEDEBUG
339     G4cout << "G4HepRepFileXMLWriter:addAttVal    339     G4cout << "G4HepRepFileXMLWriter:addAttValue No file is currently open"
340            << G4endl;                             340            << G4endl;
341 #endif                                            341 #endif
342   }                                               342   }
343 }                                                 343 }
344                                                   344 
345 void G4HepRepFileXMLWriter::open(const char* f    345 void G4HepRepFileXMLWriter::open(const char* fileSpec)
346 {                                                 346 {
347   if(isOpen)                                      347   if(isOpen)
348     close();                                      348     close();
349                                                   349 
350   fout.open(fileSpec);                            350   fout.open(fileSpec);
351                                                   351 
352   if(fout.good())                                 352   if(fout.good())
353   {                                               353   {
354     fout << "<?xml version=\"1.0\" ?>" << G4en    354     fout << "<?xml version=\"1.0\" ?>" << G4endl;
355     fout << "<heprep:heprep "                     355     fout << "<heprep:heprep "
356             "xmlns:heprep=\"http://www.slac.st    356             "xmlns:heprep=\"http://www.slac.stanford.edu/~perl/heprep/\""
357          << G4endl;                               357          << G4endl;
358     fout << "  xmlns:xsi=\"http://www.w3.org/1    358     fout << "  xmlns:xsi=\"http://www.w3.org/1999/XMLSchema-instance\" "
359             "xsi:schemaLocation=\"HepRep.xsd\"    359             "xsi:schemaLocation=\"HepRep.xsd\">"
360          << G4endl;                               360          << G4endl;
361                                                   361 
362     isOpen = true;                                362     isOpen = true;
363     init();                                       363     init();
364   }                                               364   }
365   else                                            365   else
366   {                                               366   {
367     G4cout << "G4HepRepFileXMLWriter:open Unab    367     G4cout << "G4HepRepFileXMLWriter:open Unable to write to file " << fileSpec
368            << G4endl;                             368            << G4endl;
369   }                                               369   }
370 }                                                 370 }
371                                                   371 
372 void G4HepRepFileXMLWriter::close()               372 void G4HepRepFileXMLWriter::close()
373 {                                                 373 {
374   // Close any remaining open Types               374   // Close any remaining open Types
375   endTypes();                                     375   endTypes();
376                                                   376 
377   if(fout.good())                                 377   if(fout.good())
378   {                                               378   {
379     fout << "</heprep:heprep>" << G4endl;         379     fout << "</heprep:heprep>" << G4endl;
380     fout.close();                                 380     fout.close();
381     isOpen = false;                               381     isOpen = false;
382   }                                               382   }
383   else                                            383   else
384   {                                               384   {
385     G4cout << "G4HepRepFileXMLWriter:close No     385     G4cout << "G4HepRepFileXMLWriter:close No file is currently open" << G4endl;
386   }                                               386   }
387 }                                                 387 }
388                                                   388 
389 void G4HepRepFileXMLWriter::endTypes()            389 void G4HepRepFileXMLWriter::endTypes()
390 {                                                 390 {
391   // Close any remaining open Types               391   // Close any remaining open Types
392   while(typeDepth > -1)                           392   while(typeDepth > -1)
393     endType();                                    393     endType();
394 }                                                 394 }
395                                                   395 
396 void G4HepRepFileXMLWriter::endType()             396 void G4HepRepFileXMLWriter::endType()
397 {                                                 397 {
398   endInstance();                                  398   endInstance();
399   indent();                                       399   indent();
400   fout << "</heprep:type>" << G4endl;             400   fout << "</heprep:type>" << G4endl;
401   inType[typeDepth] = false;                      401   inType[typeDepth] = false;
402   delete[] prevTypeName[typeDepth];               402   delete[] prevTypeName[typeDepth];
403   prevTypeName[typeDepth] = new char[1];          403   prevTypeName[typeDepth] = new char[1];
404   strcpy(prevTypeName[typeDepth], "");            404   strcpy(prevTypeName[typeDepth], "");
405   typeDepth--;                                    405   typeDepth--;
406 }                                                 406 }
407                                                   407 
408 void G4HepRepFileXMLWriter::endInstance()         408 void G4HepRepFileXMLWriter::endInstance()
409 {                                                 409 {
410   if(inInstance[typeDepth])                       410   if(inInstance[typeDepth])
411   {                                               411   {
412     endPrimitive();                               412     endPrimitive();
413     indent();                                     413     indent();
414     fout << "</heprep:instance>" << G4endl;       414     fout << "</heprep:instance>" << G4endl;
415     inInstance[typeDepth] = false;                415     inInstance[typeDepth] = false;
416   }                                               416   }
417 }                                                 417 }
418                                                   418 
419 void G4HepRepFileXMLWriter::endPrimitive()        419 void G4HepRepFileXMLWriter::endPrimitive()
420 {                                                 420 {
421   if(inPrimitive)                                 421   if(inPrimitive)
422   {                                               422   {
423     endPoint();                                   423     endPoint();
424     indent();                                     424     indent();
425     fout << "</heprep:primitive>" << G4endl;      425     fout << "</heprep:primitive>" << G4endl;
426     inPrimitive = false;                          426     inPrimitive = false;
427   }                                               427   }
428 }                                                 428 }
429                                                   429 
430 void G4HepRepFileXMLWriter::endPoint()            430 void G4HepRepFileXMLWriter::endPoint()
431 {                                                 431 {
432   if(inPoint)                                     432   if(inPoint)
433   {                                               433   {
434     indent();                                     434     indent();
435     fout << "</heprep:point>" << G4endl;          435     fout << "</heprep:point>" << G4endl;
436     inPoint = false;                              436     inPoint = false;
437   }                                               437   }
438 }                                                 438 }
439                                                   439 
440 void G4HepRepFileXMLWriter::indent()              440 void G4HepRepFileXMLWriter::indent()
441 {                                                 441 {
442   if(fout.good())                                 442   if(fout.good())
443   {                                               443   {
444     int i = 0;                                    444     int i = 0;
445     while(inType[i] && i < 12)                    445     while(inType[i] && i < 12)
446     {                                             446     {
447       fout << "  ";                               447       fout << "  ";
448       if(inInstance[i])                           448       if(inInstance[i])
449         fout << "  ";                             449         fout << "  ";
450       i++;                                        450       i++;
451     }                                             451     }
452                                                   452 
453     if(inPrimitive)                               453     if(inPrimitive)
454       fout << "  ";                               454       fout << "  ";
455     if(inPoint)                                   455     if(inPoint)
456       fout << "  ";                               456       fout << "  ";
457   }                                               457   }
458 }                                                 458 }
459                                                   459