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