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$ 26 // 27 // 27 // 28 // 28 // Joseph Perl 27th January 2002 29 // Joseph Perl 27th January 2002 29 // A base class for a scene handler to export 30 // A base class for a scene handler to export geometry and trajectories 30 // to the HepRep xml file format. 31 // to the HepRep xml file format. 31 32 32 #include "G4HepRepFileSceneHandler.hh" 33 #include "G4HepRepFileSceneHandler.hh" 33 #include "G4HepRepFile.hh" 34 #include "G4HepRepFile.hh" 34 #include "G4HepRepMessenger.hh" 35 #include "G4HepRepMessenger.hh" 35 #include "G4UIcommand.hh" 36 #include "G4UIcommand.hh" 36 37 37 #include "G4PhysicalConstants.hh" 38 #include "G4PhysicalConstants.hh" 38 #include "G4SystemOfUnits.hh" 39 #include "G4SystemOfUnits.hh" 39 #include "G4Version.hh" 40 #include "G4Version.hh" 40 #include "G4VSolid.hh" 41 #include "G4VSolid.hh" 41 #include "G4PhysicalVolumeModel.hh" 42 #include "G4PhysicalVolumeModel.hh" 42 #include "G4VPhysicalVolume.hh" 43 #include "G4VPhysicalVolume.hh" 43 #include "G4LogicalVolume.hh" 44 #include "G4LogicalVolume.hh" 44 #include "G4RotationMatrix.hh" 45 #include "G4RotationMatrix.hh" 45 #include "G4Material.hh" 46 #include "G4Material.hh" 46 #include "G4Polymarker.hh" 47 #include "G4Polymarker.hh" 47 #include "G4Polyline.hh" 48 #include "G4Polyline.hh" 48 #include "G4Text.hh" 49 #include "G4Text.hh" 49 #include "G4Circle.hh" 50 #include "G4Circle.hh" 50 #include "G4Square.hh" 51 #include "G4Square.hh" 51 #include "G4Polyhedron.hh" 52 #include "G4Polyhedron.hh" >> 53 #include "G4NURBS.hh" 52 #include "G4VTrajectory.hh" 54 #include "G4VTrajectory.hh" 53 #include "G4VTrajectoryPoint.hh" 55 #include "G4VTrajectoryPoint.hh" 54 #include "G4TrajectoriesModel.hh" 56 #include "G4TrajectoriesModel.hh" 55 #include "G4VHit.hh" 57 #include "G4VHit.hh" 56 #include "G4AttDef.hh" 58 #include "G4AttDef.hh" 57 #include "G4AttValue.hh" 59 #include "G4AttValue.hh" 58 #include "G4AttCheck.hh" 60 #include "G4AttCheck.hh" 59 #include "G4VisManager.hh" 61 #include "G4VisManager.hh" 60 #include "G4VisTrajContext.hh" 62 #include "G4VisTrajContext.hh" 61 #include "G4VTrajectoryModel.hh" 63 #include "G4VTrajectoryModel.hh" 62 64 63 // HepRep << 65 //HepRep 64 #include "G4HepRepFileXMLWriter.hh" 66 #include "G4HepRepFileXMLWriter.hh" 65 67 66 G4int G4HepRepFileSceneHandler::fSceneIdCount 68 G4int G4HepRepFileSceneHandler::fSceneIdCount = 0; 67 // Counter for HepRep scene handlers. 69 // Counter for HepRep scene handlers. 68 70 69 G4HepRepFileSceneHandler::G4HepRepFileSceneHan 71 G4HepRepFileSceneHandler::G4HepRepFileSceneHandler(G4VGraphicsSystem& system, 70 << 72 const G4String& name): 71 : G4VSceneHandler(system, fSceneIdCount++, n << 73 G4VSceneHandler(system, fSceneIdCount++, name) 72 { 74 { 73 hepRepXMLWriter = ((G4HepRepFile*) (&system) << 75 hepRepXMLWriter = ((G4HepRepFile*)(&system))->GetHepRepXMLWriter(); 74 fileCounter = 0; << 76 fileCounter = 0; 75 << 77 76 inPrimitives2D = false; << 78 inPrimitives2D = false; 77 warnedAbout3DText = false; << 79 warnedAbout3DText = false; 78 warnedAbout2DMarkers = false; << 80 warnedAbout2DMarkers = false; 79 haveVisible = false; << 81 haveVisible = false; 80 drawingTraj = false; << 82 drawingTraj = false; 81 doneInitTraj = false; << 83 doneInitTraj = false; 82 drawingHit = false; << 84 drawingHit = false; 83 doneInitHit = false; << 85 doneInitHit = false; 84 trajContext = 0; << 85 trajAttValues = 0; << 86 trajAttDefs = 0; << 87 hitAttValues = 0; << 88 hitAttDefs = 0; << 89 } << 90 << 91 G4HepRepFileSceneHandler::~G4HepRepFileSceneHa << 92 << 93 void G4HepRepFileSceneHandler::BeginModeling() << 94 { << 95 G4VisManager* visManager = G4VisManag << 96 const G4VTrajectoryModel* model = visManager << 97 trajContext = &model->Ge << 98 << 99 G4VSceneHandler::BeginModeling(); // Requir << 100 } << 101 << 102 void G4HepRepFileSceneHandler::EndModeling() << 103 { << 104 G4VSceneHandler::EndModeling(); // Required << 105 } << 106 << 107 void G4HepRepFileSceneHandler::BeginPrimitives << 108 const G4Transform3D& objectTransformation) << 109 { << 110 #ifdef G4HEPREPFILEDEBUG << 111 G4cout << "G4HepRepFileSceneHandler::BeginPr << 112 #endif << 113 inPrimitives2D = true; << 114 G4VSceneHandler::BeginPrimitives2D(objectTra << 115 } << 116 << 117 void G4HepRepFileSceneHandler::EndPrimitives2D << 118 { << 119 #ifdef G4HEPREPFILEDEBUG << 120 G4cout << "G4HepRepFileSceneHandler::EndPrim << 121 #endif << 122 G4VSceneHandler::EndPrimitives2D(); << 123 inPrimitives2D = false; << 124 } << 125 << 126 #ifdef G4HEPREPFILEDEBUG << 127 void G4HepRepFileSceneHandler::PrintThings() << 128 { << 129 G4cout << " with transformation " << fObjec << 130 G4PhysicalVolumeModel* pPVModel = << 131 dynamic_cast<G4PhysicalVolumeModel*>(fpMod << 132 if(pPVModel) << 133 { << 134 G4VPhysicalVolume* pCurrentPV = pPVModel-> << 135 G4LogicalVolume* pCurrentLV = pPVModel-> << 136 G4int currentDepth = pPVModel-> << 137 G4cout << "\n current physical volume: " << 138 << "\n current logical volume: " < << 139 << "\n current depth of geometry t << 140 } << 141 G4cout << G4endl; << 142 } << 143 #endif << 144 << 145 void G4HepRepFileSceneHandler::AddSolid(const << 146 { << 147 #ifdef G4HEPREPFILEDEBUG << 148 G4cout << "G4HepRepFileSceneHandler::AddSoli << 149 << box.GetName() << G4endl; << 150 PrintThings(); << 151 #endif << 152 << 153 if(drawingTraj) << 154 return; << 155 << 156 if(drawingHit) << 157 InitHit(); << 158 << 159 haveVisible = false; << 160 AddHepRepInstance("Prism", NULL); << 161 << 162 G4HepRepMessenger* messenger = G4HepRepMesse << 163 << 164 // Get and check applicable vis attributes. << 165 fpVisAttribs = fpViewer->GetApplicableVisAtt << 166 if(fpVisAttribs && (fpVisAttribs->IsVisible( << 167 messenger->getCullInvisibles()) << 168 return; << 169 << 170 hepRepXMLWriter->addPrimitive(); << 171 << 172 G4double dx = box.GetXHalfLength(); << 173 G4double dy = box.GetYHalfLength(); << 174 G4double dz = box.GetZHalfLength(); << 175 << 176 G4Point3D vertex1(G4Point3D(dx, dy, -dz)); << 177 G4Point3D vertex2(G4Point3D(dx, -dy, -dz)); << 178 G4Point3D vertex3(G4Point3D(-dx, -dy, -dz)); << 179 G4Point3D vertex4(G4Point3D(-dx, dy, -dz)); << 180 G4Point3D vertex5(G4Point3D(dx, dy, dz)); << 181 G4Point3D vertex6(G4Point3D(dx, -dy, dz)); << 182 G4Point3D vertex7(G4Point3D(-dx, -dy, dz)); << 183 G4Point3D vertex8(G4Point3D(-dx, dy, dz)); << 184 << 185 vertex1 = (fObjectTransformation) *vertex1; << 186 vertex2 = (fObjectTransformation) *vertex2; << 187 vertex3 = (fObjectTransformation) *vertex3; << 188 vertex4 = (fObjectTransformation) *vertex4; << 189 vertex5 = (fObjectTransformation) *vertex5; << 190 vertex6 = (fObjectTransformation) *vertex6; << 191 vertex7 = (fObjectTransformation) *vertex7; << 192 vertex8 = (fObjectTransformation) *vertex8; << 193 << 194 hepRepXMLWriter->addPoint(vertex1.x(), verte << 195 hepRepXMLWriter->addPoint(vertex2.x(), verte << 196 hepRepXMLWriter->addPoint(vertex3.x(), verte << 197 hepRepXMLWriter->addPoint(vertex4.x(), verte << 198 hepRepXMLWriter->addPoint(vertex5.x(), verte << 199 hepRepXMLWriter->addPoint(vertex6.x(), verte << 200 hepRepXMLWriter->addPoint(vertex7.x(), verte << 201 hepRepXMLWriter->addPoint(vertex8.x(), verte << 202 } << 203 << 204 void G4HepRepFileSceneHandler::AddSolid(const << 205 { << 206 #ifdef G4HEPREPFILEDEBUG << 207 G4cout << "G4HepRepFileSceneHandler::AddSoli << 208 << cons.GetName() << G4endl; << 209 PrintThings(); << 210 #endif << 211 << 212 // HepRApp does not correctly represent the << 213 // non-standard angles, let the base class c << 214 G4RotationMatrix r = fObjectTransformation.g << 215 G4bool linedUpWithAnAxis = << 216 (std::fabs(r.phiX()) <= .001 || std::fabs( << 217 std::fabs(r.phiZ()) <= .001 || std::fabs( << 218 std::fabs(r.phiY() - pi) <= .001 || std:: << 219 // G4cout << "Angle X:" << r.phiX() << ", An << 220 // Z:" << r.phiZ() << G4endl; G4cout << "lin << 221 // linedUpWithAnAxis << G4endl; << 222 << 223 // HepRep does not have a primitive for a cu << 224 // so if this cone is cut, let the base clas << 225 // solid to polygons. << 226 G4HepRepMessenger* messenger = G4HepRepMesse << 227 if(cons.GetDeltaPhiAngle() < twopi || !lined << 228 messenger->renderCylAsPolygons()) << 229 { << 230 G4VSceneHandler::AddSolid(cons); // Invok << 231 } << 232 else << 233 { << 234 if(drawingTraj) << 235 return; << 236 << 237 if(drawingHit) << 238 InitHit(); << 239 << 240 haveVisible = false; << 241 AddHepRepInstance("Cylinder", NULL); << 242 << 243 // Get and check applicable vis attributes << 244 fpVisAttribs = fpViewer->GetApplicableVisA << 245 if(fpVisAttribs && (fpVisAttribs->IsVisibl << 246 messenger->getCullInvisibles()) << 247 return; << 248 << 249 G4Point3D vertex1(G4Point3D(0., 0., -cons. << 250 G4Point3D vertex2(G4Point3D(0., 0., cons.G << 251 << 252 vertex1 = (fObjectTransformation) *vertex1 << 253 vertex2 = (fObjectTransformation) *vertex2 << 254 << 255 // Outer cylinder. << 256 hepRepXMLWriter->addPrimitive(); << 257 hepRepXMLWriter->addAttValue("Radius1", me << 258 << 259 hepRepXMLWriter->addAttValue("Radius2", me << 260 << 261 hepRepXMLWriter->addPoint(vertex1.x(), ver << 262 hepRepXMLWriter->addPoint(vertex2.x(), ver << 263 << 264 // Inner cylinder. << 265 hepRepXMLWriter->addPrimitive(); << 266 hepRepXMLWriter->addAttValue("Radius1", me << 267 << 268 hepRepXMLWriter->addAttValue("Radius2", me << 269 << 270 hepRepXMLWriter->addPoint(vertex1.x(), ver << 271 hepRepXMLWriter->addPoint(vertex2.x(), ver << 272 } << 273 } << 274 << 275 void G4HepRepFileSceneHandler::AddSolid(const << 276 { << 277 #ifdef G4HEPREPFILEDEBUG << 278 G4cout << "G4HepRepFileSceneHandler::AddSoli << 279 << tubs.GetName() << G4endl; << 280 PrintThings(); << 281 #endif << 282 << 283 // HepRApp does not correctly represent the << 284 // non-standard angles, let the base class c << 285 G4RotationMatrix r = fObjectTransformation.g << 286 G4bool linedUpWithAnAxis = << 287 (std::fabs(r.phiX()) <= .001 || std::fabs( << 288 std::fabs(r.phiZ()) <= .001 || std::fabs( << 289 std::fabs(r.phiY() - pi) <= .001 || std:: << 290 // G4cout << "Angle X:" << r.phiX() << ", An << 291 // Z:" << r.phiZ() << G4endl; G4cout << "lin << 292 // linedUpWithAnAxis << G4endl; << 293 << 294 // HepRep does not have a primitive for a cu << 295 // so if this cylinder is cut, let the base << 296 // solid to polygons. << 297 G4HepRepMessenger* messenger = G4HepRepMesse << 298 if(tubs.GetDeltaPhiAngle() < twopi || !lined << 299 messenger->renderCylAsPolygons()) << 300 { << 301 G4VSceneHandler::AddSolid(tubs); // Invok << 302 } << 303 else << 304 { << 305 if(drawingTraj) << 306 return; << 307 << 308 if(drawingHit) << 309 InitHit(); << 310 << 311 haveVisible = false; << 312 AddHepRepInstance("Cylinder", NULL); << 313 << 314 // Get and check applicable vis attributes << 315 fpVisAttribs = fpViewer->GetApplicableVisA << 316 if(fpVisAttribs && (fpVisAttribs->IsVisibl << 317 messenger->getCullInvisibles()) << 318 return; << 319 << 320 G4Point3D vertex1(G4Point3D(0., 0., -tubs. << 321 G4Point3D vertex2(G4Point3D(0., 0., tubs.G << 322 << 323 vertex1 = (fObjectTransformation) *vertex1 << 324 vertex2 = (fObjectTransformation) *vertex2 << 325 << 326 // Outer cylinder. << 327 hepRepXMLWriter->addPrimitive(); << 328 hepRepXMLWriter->addAttValue("Radius1", << 329 messenger->ge << 330 hepRepXMLWriter->addAttValue("Radius2", << 331 messenger->ge << 332 hepRepXMLWriter->addPoint(vertex1.x(), ver << 333 hepRepXMLWriter->addPoint(vertex2.x(), ver << 334 << 335 // Inner cylinder. << 336 if(tubs.GetInnerRadius() != 0.) << 337 { << 338 hepRepXMLWriter->addPrimitive(); << 339 hepRepXMLWriter->addAttValue("Radius1", << 340 << 341 hepRepXMLWriter->addAttValue("Radius2", << 342 << 343 hepRepXMLWriter->addPoint(vertex1.x(), v << 344 hepRepXMLWriter->addPoint(vertex2.x(), v << 345 } << 346 } << 347 } << 348 << 349 void G4HepRepFileSceneHandler::AddSolid(const << 350 { << 351 #ifdef G4HEPREPFILEDEBUG << 352 G4cout << "G4HepRepFileSceneHandler::AddSoli << 353 << trd.GetName() << G4endl; << 354 PrintThings(); << 355 #endif << 356 << 357 if(drawingTraj) << 358 return; << 359 << 360 if(drawingHit) << 361 InitHit(); << 362 << 363 haveVisible = false; << 364 AddHepRepInstance("Prism", NULL); << 365 << 366 G4HepRepMessenger* messenger = G4HepRepMesse << 367 << 368 // Get and check applicable vis attributes. << 369 fpVisAttribs = fpViewer->GetApplicableVisAtt << 370 if(fpVisAttribs && (fpVisAttribs->IsVisible( << 371 messenger->getCullInvisibles()) << 372 return; << 373 << 374 hepRepXMLWriter->addPrimitive(); << 375 << 376 G4double dx1 = trd.GetXHalfLength1(); << 377 G4double dy1 = trd.GetYHalfLength1(); << 378 G4double dx2 = trd.GetXHalfLength2(); << 379 G4double dy2 = trd.GetYHalfLength2(); << 380 G4double dz = trd.GetZHalfLength(); << 381 << 382 G4Point3D vertex1(G4Point3D(dx1, dy1, -dz)); << 383 G4Point3D vertex2(G4Point3D(dx1, -dy1, -dz)) << 384 G4Point3D vertex3(G4Point3D(-dx1, -dy1, -dz) << 385 G4Point3D vertex4(G4Point3D(-dx1, dy1, -dz)) << 386 G4Point3D vertex5(G4Point3D(dx2, dy2, dz)); << 387 G4Point3D vertex6(G4Point3D(dx2, -dy2, dz)); << 388 G4Point3D vertex7(G4Point3D(-dx2, -dy2, dz)) << 389 G4Point3D vertex8(G4Point3D(-dx2, dy2, dz)); << 390 << 391 vertex1 = (fObjectTransformation) *vertex1; << 392 vertex2 = (fObjectTransformation) *vertex2; << 393 vertex3 = (fObjectTransformation) *vertex3; << 394 vertex4 = (fObjectTransformation) *vertex4; << 395 vertex5 = (fObjectTransformation) *vertex5; << 396 vertex6 = (fObjectTransformation) *vertex6; << 397 vertex7 = (fObjectTransformation) *vertex7; << 398 vertex8 = (fObjectTransformation) *vertex8; << 399 << 400 hepRepXMLWriter->addPoint(vertex1.x(), verte << 401 hepRepXMLWriter->addPoint(vertex2.x(), verte << 402 hepRepXMLWriter->addPoint(vertex3.x(), verte << 403 hepRepXMLWriter->addPoint(vertex4.x(), verte << 404 hepRepXMLWriter->addPoint(vertex5.x(), verte << 405 hepRepXMLWriter->addPoint(vertex6.x(), verte << 406 hepRepXMLWriter->addPoint(vertex7.x(), verte << 407 hepRepXMLWriter->addPoint(vertex8.x(), verte << 408 } 86 } 409 87 410 void G4HepRepFileSceneHandler::AddSolid(const << 411 { << 412 #ifdef G4HEPREPFILEDEBUG << 413 G4cout << "G4HepRepFileSceneHandler::AddSoli << 414 << trap.GetName() << G4endl; << 415 PrintThings(); << 416 #endif << 417 G4VSceneHandler::AddSolid(trap); // Invoke << 418 } << 419 88 420 void G4HepRepFileSceneHandler::AddSolid(const << 89 G4HepRepFileSceneHandler::~G4HepRepFileSceneHandler() {} 421 { << 422 #ifdef G4HEPREPFILEDEBUG << 423 G4cout << 424 << "G4HepRepFileSceneHandler::AddSolid(con << 425 << sphere.GetName() << G4endl; << 426 PrintThings(); << 427 #endif << 428 G4VSceneHandler::AddSolid(sphere); // Invok << 429 } << 430 << 431 void G4HepRepFileSceneHandler::AddSolid(const << 432 { << 433 #ifdef G4HEPREPFILEDEBUG << 434 G4cout << "G4HepRepFileSceneHandler::AddSoli << 435 << para.GetName() << G4endl; << 436 PrintThings(); << 437 #endif << 438 G4VSceneHandler::AddSolid(para); // Invoke << 439 } << 440 << 441 void G4HepRepFileSceneHandler::AddSolid(const << 442 { << 443 #ifdef G4HEPREPFILEDEBUG << 444 G4cout << 445 << "G4HepRepFileSceneHandler::AddSolid(con << 446 << torus.GetName() << G4endl; << 447 PrintThings(); << 448 #endif << 449 G4VSceneHandler::AddSolid(torus); // Invoke << 450 } << 451 << 452 void G4HepRepFileSceneHandler::AddSolid(const << 453 { << 454 #ifdef G4HEPREPFILEDEBUG << 455 G4cout << "G4HepRepFileSceneHandler::AddSoli << 456 "called for " << 457 << polycone.GetName() << G4endl; << 458 PrintThings(); << 459 #endif << 460 G4VSceneHandler::AddSolid(polycone); // Inv << 461 } << 462 90 463 void G4HepRepFileSceneHandler::AddSolid(const << 464 { << 465 #ifdef G4HEPREPFILEDEBUG << 466 G4cout << "G4HepRepFileSceneHandler::AddSoli << 467 "called for " << 468 << polyhedra.GetName() << G4endl; << 469 PrintThings(); << 470 #endif << 471 G4VSceneHandler::AddSolid(polyhedra); // In << 472 } << 473 91 474 void G4HepRepFileSceneHandler::AddSolid(const << 92 void G4HepRepFileSceneHandler::BeginModeling() { 475 { << 93 G4VisManager* visManager = G4VisManager::GetInstance(); 476 #ifdef G4HEPREPFILEDEBUG << 94 const G4VTrajectoryModel* model = visManager->CurrentTrajDrawModel(); 477 G4cout << "G4HepRepFileSceneHandler::AddSoli << 95 trajContext = & model->GetContext(); 478 << orb.GetName() << G4endl; << 96 479 PrintThings(); << 97 G4VSceneHandler::BeginModeling(); // Required: see G4VSceneHandler.hh. >> 98 } >> 99 >> 100 >> 101 void G4HepRepFileSceneHandler::EndModeling() { >> 102 G4VSceneHandler::EndModeling(); // Required: see G4VSceneHandler.hh. >> 103 } >> 104 >> 105 void G4HepRepFileSceneHandler::BeginPrimitives2D >> 106 (const G4Transform3D& objectTransformation) { >> 107 #ifdef G4HEPREPFILEDEBUG >> 108 G4cout << "G4HepRepFileSceneHandler::BeginPrimitives2D() " << G4endl; >> 109 #endif >> 110 inPrimitives2D = true; >> 111 G4VSceneHandler::BeginPrimitives2D(objectTransformation); >> 112 } >> 113 >> 114 void G4HepRepFileSceneHandler::EndPrimitives2D () { >> 115 #ifdef G4HEPREPFILEDEBUG >> 116 G4cout << "G4HepRepFileSceneHandler::EndPrimitives2D() " << G4endl; >> 117 #endif >> 118 G4VSceneHandler::EndPrimitives2D(); >> 119 inPrimitives2D = false; >> 120 } >> 121 >> 122 >> 123 #ifdef G4HEPREPFILEDEBUG >> 124 void G4HepRepFileSceneHandler::PrintThings() { >> 125 G4cout << >> 126 " with transformation " >> 127 << fObjectTransformation; >> 128 G4PhysicalVolumeModel* pPVModel = >> 129 dynamic_cast<G4PhysicalVolumeModel*>(fpModel); >> 130 if (pPVModel) { >> 131 G4VPhysicalVolume* pCurrentPV = pPVModel->GetCurrentPV(); >> 132 G4LogicalVolume* pCurrentLV = pPVModel->GetCurrentLV(); >> 133 G4int currentDepth = pPVModel->GetCurrentDepth(); >> 134 G4cout << >> 135 "\n current physical volume: " >> 136 << pCurrentPV->GetName() << >> 137 "\n current logical volume: " >> 138 << pCurrentLV->GetName() << >> 139 "\n current depth of geometry tree: " >> 140 << currentDepth; >> 141 } >> 142 G4cout << G4endl; >> 143 } >> 144 #endif >> 145 >> 146 >> 147 void G4HepRepFileSceneHandler::AddSolid(const G4Box& box) { >> 148 #ifdef G4HEPREPFILEDEBUG >> 149 G4cout << >> 150 "G4HepRepFileSceneHandler::AddSolid(const G4Box& box) called for " >> 151 << box.GetName() >> 152 << G4endl; >> 153 PrintThings(); >> 154 #endif >> 155 >> 156 if (drawingTraj) >> 157 return; >> 158 >> 159 if (drawingHit) >> 160 InitHit(); >> 161 >> 162 haveVisible = false; >> 163 AddHepRepInstance("Prism", NULL); >> 164 >> 165 G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance(); >> 166 >> 167 if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles()) >> 168 return; >> 169 >> 170 hepRepXMLWriter->addPrimitive(); >> 171 >> 172 G4double dx = box.GetXHalfLength(); >> 173 G4double dy = box.GetYHalfLength(); >> 174 G4double dz = box.GetZHalfLength(); >> 175 >> 176 G4Point3D vertex1(G4Point3D( dx, dy,-dz)); >> 177 G4Point3D vertex2(G4Point3D( dx,-dy,-dz)); >> 178 G4Point3D vertex3(G4Point3D(-dx,-dy,-dz)); >> 179 G4Point3D vertex4(G4Point3D(-dx, dy,-dz)); >> 180 G4Point3D vertex5(G4Point3D( dx, dy, dz)); >> 181 G4Point3D vertex6(G4Point3D( dx,-dy, dz)); >> 182 G4Point3D vertex7(G4Point3D(-dx,-dy, dz)); >> 183 G4Point3D vertex8(G4Point3D(-dx, dy, dz)); >> 184 >> 185 vertex1 = (fObjectTransformation) * vertex1; >> 186 vertex2 = (fObjectTransformation) * vertex2; >> 187 vertex3 = (fObjectTransformation) * vertex3; >> 188 vertex4 = (fObjectTransformation) * vertex4; >> 189 vertex5 = (fObjectTransformation) * vertex5; >> 190 vertex6 = (fObjectTransformation) * vertex6; >> 191 vertex7 = (fObjectTransformation) * vertex7; >> 192 vertex8 = (fObjectTransformation) * vertex8; >> 193 >> 194 hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z()); >> 195 hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z()); >> 196 hepRepXMLWriter->addPoint(vertex3.x(), vertex3.y(), vertex3.z()); >> 197 hepRepXMLWriter->addPoint(vertex4.x(), vertex4.y(), vertex4.z()); >> 198 hepRepXMLWriter->addPoint(vertex5.x(), vertex5.y(), vertex5.z()); >> 199 hepRepXMLWriter->addPoint(vertex6.x(), vertex6.y(), vertex6.z()); >> 200 hepRepXMLWriter->addPoint(vertex7.x(), vertex7.y(), vertex7.z()); >> 201 hepRepXMLWriter->addPoint(vertex8.x(), vertex8.y(), vertex8.z()); >> 202 } >> 203 >> 204 >> 205 void G4HepRepFileSceneHandler::AddSolid(const G4Cons& cons) { >> 206 #ifdef G4HEPREPFILEDEBUG >> 207 G4cout << >> 208 "G4HepRepFileSceneHandler::AddSolid(const G4Cons& cons) called for " >> 209 << cons.GetName() >> 210 << G4endl; >> 211 PrintThings(); >> 212 #endif >> 213 >> 214 // HepRApp does not correctly represent the end faces of cones at >> 215 // non-standard angles, let the base class convert these solids to polygons. >> 216 G4RotationMatrix r = fObjectTransformation.getRotation(); >> 217 G4bool linedUpWithAnAxis = (std::fabs(r.phiX())<=.001 || >> 218 std::fabs(r.phiY())<=.001 || >> 219 std::fabs(r.phiZ())<=.001 || >> 220 std::fabs(r.phiX()-pi)<=.001 || >> 221 std::fabs(r.phiY()-pi)<=.001 || >> 222 std::fabs(r.phiZ()-pi)<=.001); >> 223 //G4cout << "Angle X:" << r.phiX() << ", Angle Y:" << r.phiY() << ", Angle Z:" << r.phiZ() << G4endl; >> 224 //G4cout << "linedUpWithAnAxis:" << linedUpWithAnAxis << G4endl; >> 225 >> 226 // HepRep does not have a primitive for a cut cone, >> 227 // so if this cone is cut, let the base class convert this >> 228 // solid to polygons. >> 229 G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance(); >> 230 if (cons.GetDeltaPhiAngle() < twopi || !linedUpWithAnAxis || messenger->renderCylAsPolygons()) >> 231 { >> 232 G4VSceneHandler::AddSolid(cons); // Invoke default action. >> 233 } else { >> 234 >> 235 if (drawingTraj) >> 236 return; >> 237 >> 238 if (drawingHit) >> 239 InitHit(); >> 240 >> 241 haveVisible = false; >> 242 AddHepRepInstance("Cylinder", NULL); >> 243 >> 244 if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles()) >> 245 return; >> 246 >> 247 G4Point3D vertex1(G4Point3D( 0., 0., -cons.GetZHalfLength())); >> 248 G4Point3D vertex2(G4Point3D( 0., 0., cons.GetZHalfLength())); >> 249 >> 250 vertex1 = (fObjectTransformation) * vertex1; >> 251 vertex2 = (fObjectTransformation) * vertex2; >> 252 >> 253 // Outer cylinder. >> 254 hepRepXMLWriter->addPrimitive(); >> 255 hepRepXMLWriter->addAttValue("Radius1",messenger->getScale() * cons.GetOuterRadiusMinusZ()); >> 256 hepRepXMLWriter->addAttValue("Radius2",messenger->getScale() * cons.GetOuterRadiusPlusZ()); >> 257 hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z()); >> 258 hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z()); >> 259 >> 260 // Inner cylinder. >> 261 hepRepXMLWriter->addPrimitive(); >> 262 hepRepXMLWriter->addAttValue("Radius1",messenger->getScale() * cons.GetInnerRadiusMinusZ()); >> 263 hepRepXMLWriter->addAttValue("Radius2",messenger->getScale() * cons.GetInnerRadiusPlusZ()); >> 264 hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z()); >> 265 hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z()); >> 266 } >> 267 } >> 268 >> 269 >> 270 void G4HepRepFileSceneHandler::AddSolid(const G4Tubs& tubs) { >> 271 #ifdef G4HEPREPFILEDEBUG >> 272 G4cout << >> 273 "G4HepRepFileSceneHandler::AddSolid(const G4Tubs& tubs) called for " >> 274 << tubs.GetName() >> 275 << G4endl; >> 276 PrintThings(); >> 277 #endif >> 278 >> 279 // HepRApp does not correctly represent the end faces of cylinders at >> 280 // non-standard angles, let the base class convert these solids to polygons. >> 281 G4RotationMatrix r = fObjectTransformation.getRotation(); >> 282 G4bool linedUpWithAnAxis = (std::fabs(r.phiX())<=.001 || >> 283 std::fabs(r.phiY())<=.001 || >> 284 std::fabs(r.phiZ())<=.001 || >> 285 std::fabs(r.phiX()-pi)<=.001 || >> 286 std::fabs(r.phiY()-pi)<=.001 || >> 287 std::fabs(r.phiZ()-pi)<=.001); >> 288 //G4cout << "Angle X:" << r.phiX() << ", Angle Y:" << r.phiY() << ", Angle Z:" << r.phiZ() << G4endl; >> 289 //G4cout << "linedUpWithAnAxis:" << linedUpWithAnAxis << G4endl; >> 290 >> 291 // HepRep does not have a primitive for a cut cylinder, >> 292 // so if this cylinder is cut, let the base class convert this >> 293 // solid to polygons. >> 294 G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance(); >> 295 if (tubs.GetDeltaPhiAngle() < twopi || !linedUpWithAnAxis || messenger->renderCylAsPolygons()) >> 296 { >> 297 G4VSceneHandler::AddSolid(tubs); // Invoke default action. >> 298 } else { >> 299 >> 300 if (drawingTraj) >> 301 return; >> 302 >> 303 if (drawingHit) >> 304 InitHit(); >> 305 >> 306 haveVisible = false; >> 307 AddHepRepInstance("Cylinder", NULL); >> 308 >> 309 if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles()) >> 310 return; >> 311 >> 312 G4Point3D vertex1(G4Point3D( 0., 0., -tubs.GetZHalfLength())); >> 313 G4Point3D vertex2(G4Point3D( 0., 0., tubs.GetZHalfLength())); >> 314 >> 315 vertex1 = (fObjectTransformation) * vertex1; >> 316 vertex2 = (fObjectTransformation) * vertex2; >> 317 >> 318 // Outer cylinder. >> 319 hepRepXMLWriter->addPrimitive(); >> 320 hepRepXMLWriter->addAttValue("Radius1", messenger->getScale() * tubs.GetOuterRadius()); >> 321 hepRepXMLWriter->addAttValue("Radius2", messenger->getScale() * tubs.GetOuterRadius()); >> 322 hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z()); >> 323 hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z()); >> 324 >> 325 // Inner cylinder. >> 326 if (tubs.GetInnerRadius() != 0.) { >> 327 hepRepXMLWriter->addPrimitive(); >> 328 hepRepXMLWriter->addAttValue("Radius1", messenger->getScale() * tubs.GetInnerRadius()); >> 329 hepRepXMLWriter->addAttValue("Radius2", messenger->getScale() * tubs.GetInnerRadius()); >> 330 hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z()); >> 331 hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z()); >> 332 } >> 333 } >> 334 } >> 335 >> 336 >> 337 void G4HepRepFileSceneHandler::AddSolid(const G4Trd& trd) { >> 338 #ifdef G4HEPREPFILEDEBUG >> 339 G4cout << >> 340 "G4HepRepFileSceneHandler::AddSolid(const G4Trd& trd) called for " >> 341 << trd.GetName() >> 342 << G4endl; >> 343 PrintThings(); >> 344 #endif >> 345 >> 346 if (drawingTraj) >> 347 return; >> 348 >> 349 if (drawingHit) >> 350 InitHit(); >> 351 >> 352 haveVisible = false; >> 353 AddHepRepInstance("Prism", NULL); >> 354 >> 355 G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance(); >> 356 >> 357 if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles()) >> 358 return; >> 359 >> 360 hepRepXMLWriter->addPrimitive(); >> 361 >> 362 G4double dx1 = trd.GetXHalfLength1(); >> 363 G4double dy1 = trd.GetYHalfLength1(); >> 364 G4double dx2 = trd.GetXHalfLength2(); >> 365 G4double dy2 = trd.GetYHalfLength2(); >> 366 G4double dz = trd.GetZHalfLength(); >> 367 >> 368 G4Point3D vertex1(G4Point3D( dx1, dy1,-dz)); >> 369 G4Point3D vertex2(G4Point3D( dx1,-dy1,-dz)); >> 370 G4Point3D vertex3(G4Point3D(-dx1,-dy1,-dz)); >> 371 G4Point3D vertex4(G4Point3D(-dx1, dy1,-dz)); >> 372 G4Point3D vertex5(G4Point3D( dx2, dy2, dz)); >> 373 G4Point3D vertex6(G4Point3D( dx2,-dy2, dz)); >> 374 G4Point3D vertex7(G4Point3D(-dx2,-dy2, dz)); >> 375 G4Point3D vertex8(G4Point3D(-dx2, dy2, dz)); >> 376 >> 377 vertex1 = (fObjectTransformation) * vertex1; >> 378 vertex2 = (fObjectTransformation) * vertex2; >> 379 vertex3 = (fObjectTransformation) * vertex3; >> 380 vertex4 = (fObjectTransformation) * vertex4; >> 381 vertex5 = (fObjectTransformation) * vertex5; >> 382 vertex6 = (fObjectTransformation) * vertex6; >> 383 vertex7 = (fObjectTransformation) * vertex7; >> 384 vertex8 = (fObjectTransformation) * vertex8; >> 385 >> 386 hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z()); >> 387 hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z()); >> 388 hepRepXMLWriter->addPoint(vertex3.x(), vertex3.y(), vertex3.z()); >> 389 hepRepXMLWriter->addPoint(vertex4.x(), vertex4.y(), vertex4.z()); >> 390 hepRepXMLWriter->addPoint(vertex5.x(), vertex5.y(), vertex5.z()); >> 391 hepRepXMLWriter->addPoint(vertex6.x(), vertex6.y(), vertex6.z()); >> 392 hepRepXMLWriter->addPoint(vertex7.x(), vertex7.y(), vertex7.z()); >> 393 hepRepXMLWriter->addPoint(vertex8.x(), vertex8.y(), vertex8.z()); >> 394 } >> 395 >> 396 >> 397 void G4HepRepFileSceneHandler::AddSolid(const G4Trap& trap) { >> 398 #ifdef G4HEPREPFILEDEBUG >> 399 G4cout << >> 400 "G4HepRepFileSceneHandler::AddSolid(const G4Trap& trap) called for " >> 401 << trap.GetName() >> 402 << G4endl; >> 403 PrintThings(); >> 404 #endif >> 405 G4VSceneHandler::AddSolid(trap); // Invoke default action. >> 406 } >> 407 >> 408 >> 409 void G4HepRepFileSceneHandler::AddSolid(const G4Sphere& sphere) { >> 410 #ifdef G4HEPREPFILEDEBUG >> 411 G4cout << >> 412 "G4HepRepFileSceneHandler::AddSolid(const G4Sphere& sphere) called for " >> 413 << sphere.GetName() >> 414 << G4endl; >> 415 PrintThings(); >> 416 #endif >> 417 G4VSceneHandler::AddSolid(sphere); // Invoke default action. >> 418 } >> 419 >> 420 >> 421 void G4HepRepFileSceneHandler::AddSolid(const G4Para& para) { >> 422 #ifdef G4HEPREPFILEDEBUG >> 423 G4cout << >> 424 "G4HepRepFileSceneHandler::AddSolid(const G4Para& para) called for " >> 425 << para.GetName() >> 426 << G4endl; >> 427 PrintThings(); >> 428 #endif >> 429 G4VSceneHandler::AddSolid(para); // Invoke default action. >> 430 } >> 431 >> 432 >> 433 void G4HepRepFileSceneHandler::AddSolid(const G4Torus& torus) { >> 434 #ifdef G4HEPREPFILEDEBUG >> 435 G4cout << >> 436 "G4HepRepFileSceneHandler::AddSolid(const G4Torus& torus) called for " >> 437 << torus.GetName() >> 438 << G4endl; >> 439 PrintThings(); >> 440 #endif >> 441 G4VSceneHandler::AddSolid(torus); // Invoke default action. >> 442 } >> 443 >> 444 >> 445 void G4HepRepFileSceneHandler::AddSolid(const G4Polycone& polycone) { >> 446 #ifdef G4HEPREPFILEDEBUG >> 447 G4cout << >> 448 "G4HepRepFileSceneHandler::AddSolid(const G4Polycone& polycone) called for " >> 449 << polycone.GetName() >> 450 << G4endl; >> 451 PrintThings(); >> 452 #endif >> 453 G4VSceneHandler::AddSolid(polycone); // Invoke default action. >> 454 } >> 455 >> 456 >> 457 void G4HepRepFileSceneHandler::AddSolid(const G4Polyhedra& polyhedra) { >> 458 #ifdef G4HEPREPFILEDEBUG >> 459 G4cout << >> 460 "G4HepRepFileSceneHandler::AddSolid(const G4Polyhedra& polyhedra) called for " >> 461 << polyhedra.GetName() >> 462 << G4endl; >> 463 PrintThings(); >> 464 #endif >> 465 G4VSceneHandler::AddSolid(polyhedra); // Invoke default action. >> 466 } >> 467 >> 468 >> 469 void G4HepRepFileSceneHandler::AddSolid(const G4VSolid& solid) { >> 470 #ifdef G4HEPREPFILEDEBUG >> 471 G4cout << >> 472 "G4HepRepFileSceneHandler::AddSolid(const G4Solid& solid) called for " >> 473 << solid.GetName() >> 474 << G4endl; >> 475 PrintThings(); >> 476 #endif >> 477 G4VSceneHandler::AddSolid(solid); // Invoke default action. >> 478 } >> 479 >> 480 >> 481 void G4HepRepFileSceneHandler::AddCompound (const G4VTrajectory& traj) { >> 482 #ifdef G4HEPREPFILEDEBUG >> 483 G4cout << "G4HepRepFileSceneHandler::AddCompound(const G4VTrajectory&) " << G4endl; >> 484 #endif >> 485 >> 486 G4TrajectoriesModel* pTrModel = >> 487 dynamic_cast<G4TrajectoriesModel*>(fpModel); >> 488 if (!pTrModel) G4Exception >> 489 ("G4HepRepFileSceneHandler::AddCompound(const G4VTrajectory&)", >> 490 "vis-HepRep0001", FatalException, "Not a G4TrajectoriesModel."); >> 491 >> 492 // Pointers to hold trajectory attribute values and definitions. >> 493 std::vector<G4AttValue>* rawTrajAttValues = traj.CreateAttValues(); >> 494 trajAttValues = >> 495 new std::vector<G4AttValue>; >> 496 trajAttDefs = >> 497 new std::map<G4String,G4AttDef>; >> 498 >> 499 // Iterators to use with attribute values and definitions. >> 500 std::vector<G4AttValue>::iterator iAttVal; >> 501 std::map<G4String,G4AttDef>::const_iterator iAttDef; >> 502 G4int i; >> 503 >> 504 // Get trajectory attributes and definitions in standard HepRep style >> 505 // (uniform units, 3Vectors decomposed). >> 506 if (rawTrajAttValues) { >> 507 G4bool error = G4AttCheck(rawTrajAttValues, >> 508 traj.GetAttDefs()).Standard(trajAttValues,trajAttDefs); >> 509 if (error) { >> 510 G4cout << "G4HepRepFileSceneHandler::AddCompound(traj):" >> 511 "\nERROR found during conversion to standard trajectory attributes." >> 512 << G4endl; >> 513 } >> 514 #ifdef G4HEPREPFILEDEBUG >> 515 G4cout << >> 516 "G4HepRepFileSceneHandler::AddCompound(traj): standardised attributes:\n" >> 517 << G4AttCheck(trajAttValues,trajAttDefs) << G4endl; >> 518 #endif >> 519 delete rawTrajAttValues; >> 520 } >> 521 >> 522 // Open the HepRep output file if it is not already open. >> 523 CheckFileOpen(); >> 524 >> 525 // Add the Event Data Type if it hasn't already been added. >> 526 if (strcmp("Event Data",hepRepXMLWriter->prevTypeName[0])!=0) { >> 527 hepRepXMLWriter->addType("Event Data",0); >> 528 hepRepXMLWriter->addInstance(); >> 529 } >> 530 >> 531 // Add the Trajectories Type. >> 532 G4String previousName = hepRepXMLWriter->prevTypeName[1]; >> 533 hepRepXMLWriter->addType("Trajectories",1); >> 534 >> 535 // If this is the first trajectory of this event, >> 536 // specify attribute values common to all trajectories. >> 537 if (strcmp("Trajectories",previousName)!=0) { >> 538 hepRepXMLWriter->addAttValue("Layer",100); >> 539 >> 540 // Take all Trajectory attDefs from first trajectory. >> 541 // Would rather be able to get these attDefs without needing a reference from any >> 542 // particular trajectory, but don't know how to do that. >> 543 // Write out trajectory attribute definitions. >> 544 if (trajAttValues && trajAttDefs) { >> 545 for (iAttVal = trajAttValues->begin(); >> 546 iAttVal != trajAttValues->end(); ++iAttVal) { >> 547 iAttDef = trajAttDefs->find(iAttVal->GetName()); >> 548 if (iAttDef != trajAttDefs->end()) { >> 549 // Protect against incorrect use of Category. Anything value other than the >> 550 // standard ones will be considered to be in the physics category. >> 551 G4String category = iAttDef->second.GetCategory(); >> 552 if (strcmp(category,"Draw")!=0 && >> 553 strcmp(category,"Physics")!=0 && >> 554 strcmp(category,"Association")!=0 && >> 555 strcmp(category,"PickAction")!=0) >> 556 category = "Physics"; >> 557 hepRepXMLWriter->addAttDef(iAttVal->GetName(), iAttDef->second.GetDesc(), >> 558 category, iAttDef->second.GetExtra()); >> 559 } >> 560 } >> 561 } >> 562 >> 563 // Take all TrajectoryPoint attDefs from first point of first trajectory. >> 564 // Would rather be able to get these attDefs without needing a reference from any >> 565 // particular point, but don't know how to do that. >> 566 if ((trajContext->GetDrawStepPts() || trajContext->GetDrawAuxPts()) >> 567 && traj.GetPointEntries()>0) { >> 568 G4VTrajectoryPoint* aTrajectoryPoint = traj.GetPoint(0); >> 569 >> 570 // Pointers to hold trajectory point attribute values and definitions. >> 571 std::vector<G4AttValue>* rawPointAttValues = aTrajectoryPoint->CreateAttValues(); >> 572 std::vector<G4AttValue>* pointAttValues = >> 573 new std::vector<G4AttValue>; >> 574 std::map<G4String,G4AttDef>* pointAttDefs = >> 575 new std::map<G4String,G4AttDef>; >> 576 >> 577 // Get first trajectory point's attributes and definitions in standard HepRep style >> 578 // (uniform units, 3Vectors decomposed). >> 579 if (rawPointAttValues) { >> 580 G4bool error = G4AttCheck(rawPointAttValues, >> 581 aTrajectoryPoint->GetAttDefs()).Standard(pointAttValues,pointAttDefs); >> 582 if (error) { >> 583 G4cout << "G4HepRepFileSceneHandler::AddCompound(traj):" >> 584 "\nERROR found during conversion to standard first point attributes." << G4endl; >> 585 } >> 586 >> 587 // Write out point attribute definitions. >> 588 if (pointAttValues && pointAttDefs) { >> 589 for (iAttVal = pointAttValues->begin(); >> 590 iAttVal != pointAttValues->end(); ++iAttVal) { >> 591 iAttDef = >> 592 pointAttDefs->find(iAttVal->GetName()); >> 593 if (iAttDef != pointAttDefs->end()) { >> 594 // Protect against incorrect use of Category. Anything value other than the >> 595 // standard ones will be considered to be in the physics category. >> 596 G4String category = iAttDef->second.GetCategory(); >> 597 if (strcmp(category,"Draw")!=0 && >> 598 strcmp(category,"Physics")!=0 && >> 599 strcmp(category,"Association")!=0 && >> 600 strcmp(category,"PickAction")!=0) >> 601 category = "Physics"; >> 602 // Do not write out the Aux or Pos attribute. Aux does not conform to the HepRep rule >> 603 // that each object can have only one instance of a given AttValue. >> 604 // Both of these attributes are redundant to actual position information of the point. >> 605 if (strcmp(iAttVal->GetName(),"Aux-X")!=0 && >> 606 strcmp(iAttVal->GetName(),"Aux-Y")!=0 && >> 607 strcmp(iAttVal->GetName(),"Aux-Z")!=0 && >> 608 strcmp(iAttVal->GetName(),"Pos-X")!=0 && >> 609 strcmp(iAttVal->GetName(),"Pos-Y")!=0 && >> 610 strcmp(iAttVal->GetName(),"Pos-Z")!=0) >> 611 hepRepXMLWriter->addAttDef(iAttVal->GetName(), iAttDef->second.GetDesc(), >> 612 category, iAttDef->second.GetExtra()); >> 613 } >> 614 } >> 615 } >> 616 delete rawPointAttValues; >> 617 } >> 618 >> 619 // Clean up point attributes. >> 620 if (pointAttValues) >> 621 delete pointAttValues; >> 622 if (pointAttDefs) >> 623 delete pointAttDefs; >> 624 } >> 625 } // end of special treatment for when this is the first trajectory. >> 626 >> 627 // Now that we have written out all of the attributes that are based on the >> 628 // trajectory's particulars, call base class to deconstruct trajectory into polyline and/or points >> 629 // (or nothing if trajectory is to be filtered out). >> 630 // If base class calls for drawing points, no points will actually be drawn there since we >> 631 // instead need to do point drawing from here (in order to obtain the points attributes, >> 632 // not available from AddPrimitive(...point). Instead, such a call will just serve to set the >> 633 // flag that tells us that point drawing was requested for this trajectory (depends on several >> 634 // factors including i_mode, trajContext and filtering). >> 635 drawingTraj = true; >> 636 doneInitTraj = false; >> 637 G4VSceneHandler::AddCompound(traj); >> 638 drawingTraj = false; >> 639 >> 640 // Draw step points. >> 641 if (trajContext->GetDrawStepPts()) { >> 642 if (!doneInitTraj) >> 643 InitTrajectory(); >> 644 // Create Trajectory Points as a subType of Trajectories. >> 645 // Note that we should create this heprep type even if there are no actual points. >> 646 // This allows the user to tell that points don't exist (admittedly odd) rather >> 647 // than that they were omitted by the drawing mode. >> 648 previousName = hepRepXMLWriter->prevTypeName[2]; >> 649 hepRepXMLWriter->addType("Trajectory Step Points",2); >> 650 >> 651 float redness; >> 652 float greenness; >> 653 float blueness; >> 654 G4int markSize; >> 655 G4bool visible; >> 656 G4bool square; >> 657 G4Colour colour = trajContext->GetStepPtsColour(); >> 658 redness = colour.GetRed(); >> 659 greenness = colour.GetGreen(); >> 660 blueness = colour.GetBlue(); >> 661 markSize = (G4int) trajContext->GetStepPtsSize(); >> 662 visible = (G4int) trajContext->GetStepPtsVisible(); >> 663 square = (trajContext->GetStepPtsType()==G4Polymarker::squares); >> 664 >> 665 // Avoiding drawing anything black on black. >> 666 if (redness==0. && greenness==0. && blueness==0.) { >> 667 redness = 1.; >> 668 greenness = 1.; >> 669 blueness = 1.; >> 670 } >> 671 >> 672 // Specify attributes common to all trajectory points. >> 673 if (strcmp("Trajectory Step Points",previousName)!=0) { >> 674 hepRepXMLWriter->addAttValue("DrawAs","Point"); >> 675 hepRepXMLWriter->addAttValue("MarkColor", redness, greenness, blueness); >> 676 hepRepXMLWriter->addAttValue("MarkSize",markSize); >> 677 hepRepXMLWriter->addAttValue("Layer",110); >> 678 hepRepXMLWriter->addAttValue("Visibility",visible); >> 679 if (square) >> 680 hepRepXMLWriter->addAttValue("MarkName","square"); >> 681 else >> 682 hepRepXMLWriter->addAttValue("MarkName","dot"); >> 683 } >> 684 >> 685 // Loop over all points on this trajectory. >> 686 for (i = 0; i < traj.GetPointEntries(); i++) { >> 687 G4VTrajectoryPoint* aTrajectoryPoint = traj.GetPoint(i); >> 688 >> 689 // Each point is a separate instance of the type Trajectory Points. >> 690 hepRepXMLWriter->addInstance(); >> 691 >> 692 // Pointers to hold trajectory point attribute values and definitions. >> 693 std::vector<G4AttValue>* rawPointAttValues = aTrajectoryPoint->CreateAttValues(); >> 694 std::vector<G4AttValue>* pointAttValues = >> 695 new std::vector<G4AttValue>; >> 696 std::map<G4String,G4AttDef>* pointAttDefs = >> 697 new std::map<G4String,G4AttDef>; >> 698 >> 699 // Get trajectory point attributes and definitions in standard HepRep style >> 700 // (uniform units, 3Vectors decomposed). >> 701 if (rawPointAttValues) { >> 702 G4bool error = G4AttCheck(rawPointAttValues, >> 703 aTrajectoryPoint->GetAttDefs()).Standard(pointAttValues,pointAttDefs); >> 704 if (error) { >> 705 G4cout << "G4HepRepFileSceneHandler::AddCompound(traj):" >> 706 "\nERROR found during conversion to standard point attributes." << G4endl; >> 707 } >> 708 >> 709 // Write out point attribute values. >> 710 if (pointAttValues) { >> 711 for (iAttVal = pointAttValues->begin(); >> 712 iAttVal != pointAttValues->end(); ++iAttVal) >> 713 // Do not write out the Aux or Pos attribute. Aux does not conform to the HepRep rule >> 714 // that each object can have only one instance of a given AttValue. >> 715 // Both of these attributes are redundant to actual position information of the point. >> 716 if (strcmp(iAttVal->GetName(),"Aux-X")!=0 && >> 717 strcmp(iAttVal->GetName(),"Aux-Y")!=0 && >> 718 strcmp(iAttVal->GetName(),"Aux-Z")!=0 && >> 719 strcmp(iAttVal->GetName(),"Pos-X")!=0 && >> 720 strcmp(iAttVal->GetName(),"Pos-Y")!=0 && >> 721 strcmp(iAttVal->GetName(),"Pos-Z")!=0) >> 722 hepRepXMLWriter->addAttValue(iAttVal->GetName(), iAttVal->GetValue()); >> 723 delete pointAttValues; >> 724 } >> 725 delete rawPointAttValues; >> 726 } >> 727 >> 728 // Clean up point attributes. >> 729 if (pointAttDefs) >> 730 delete pointAttDefs; >> 731 >> 732 // Each trajectory point is made of a single primitive, a point. >> 733 hepRepXMLWriter->addPrimitive(); >> 734 G4Point3D vertex = aTrajectoryPoint->GetPosition(); >> 735 hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z()); >> 736 } >> 737 } >> 738 >> 739 // Draw Auxiliary Points >> 740 if (trajContext->GetDrawAuxPts()) { >> 741 if (!doneInitTraj) >> 742 InitTrajectory(); >> 743 // Create Trajectory Points as a subType of Trajectories. >> 744 // Note that we should create this heprep type even if there are no actual points. >> 745 // This allows the user to tell that points don't exist (admittedly odd) rather >> 746 // than that they were omitted by the drawing mode. >> 747 previousName = hepRepXMLWriter->prevTypeName[2]; >> 748 hepRepXMLWriter->addType("Trajectory Auxiliary Points",2); >> 749 >> 750 float redness; >> 751 float greenness; >> 752 float blueness; >> 753 G4int markSize; >> 754 G4bool visible; >> 755 G4bool square; >> 756 G4Colour colour = trajContext->GetAuxPtsColour(); >> 757 redness = colour.GetRed(); >> 758 greenness = colour.GetGreen(); >> 759 blueness = colour.GetBlue(); >> 760 markSize = (G4int) trajContext->GetAuxPtsSize(); >> 761 visible = (G4int) trajContext->GetAuxPtsVisible(); >> 762 square = (trajContext->GetAuxPtsType()==G4Polymarker::squares); >> 763 >> 764 // Avoiding drawing anything black on black. >> 765 if (redness==0. && greenness==0. && blueness==0.) { >> 766 redness = 1.; >> 767 greenness = 1.; >> 768 blueness = 1.; >> 769 } >> 770 >> 771 // Specify attributes common to all trajectory points. >> 772 if (strcmp("Trajectory Auxiliary Points",previousName)!=0) { >> 773 hepRepXMLWriter->addAttValue("DrawAs","Point"); >> 774 hepRepXMLWriter->addAttValue("MarkColor", redness, greenness, blueness); >> 775 hepRepXMLWriter->addAttValue("MarkSize",markSize); >> 776 hepRepXMLWriter->addAttValue("Layer",110); >> 777 hepRepXMLWriter->addAttValue("Visibility",visible); >> 778 if (square) >> 779 hepRepXMLWriter->addAttValue("MarkName","Square"); >> 780 else >> 781 hepRepXMLWriter->addAttValue("MarkName","Dot"); >> 782 } >> 783 >> 784 // Loop over all points on this trajectory. >> 785 for (i = 0; i < traj.GetPointEntries(); i++) { >> 786 G4VTrajectoryPoint* aTrajectoryPoint = traj.GetPoint(i); >> 787 >> 788 // Each point is a separate instance of the type Trajectory Points. >> 789 hepRepXMLWriter->addInstance(); >> 790 >> 791 // Pointers to hold trajectory point attribute values and definitions. >> 792 std::vector<G4AttValue>* rawPointAttValues = aTrajectoryPoint->CreateAttValues(); >> 793 std::vector<G4AttValue>* pointAttValues = >> 794 new std::vector<G4AttValue>; >> 795 std::map<G4String,G4AttDef>* pointAttDefs = >> 796 new std::map<G4String,G4AttDef>; >> 797 >> 798 // Get trajectory point attributes and definitions in standard HepRep style >> 799 // (uniform units, 3Vectors decomposed). >> 800 if (rawPointAttValues) { >> 801 G4bool error = G4AttCheck(rawPointAttValues, >> 802 aTrajectoryPoint->GetAttDefs()).Standard(pointAttValues,pointAttDefs); >> 803 if (error) { >> 804 G4cout << "G4HepRepFileSceneHandler::AddCompound(traj):" >> 805 "\nERROR found during conversion to standard point attributes." << G4endl; >> 806 } >> 807 >> 808 // Write out point attribute values. >> 809 if (pointAttValues) { >> 810 for (iAttVal = pointAttValues->begin(); >> 811 iAttVal != pointAttValues->end(); ++iAttVal) >> 812 // Do not write out the Aux or Pos attribute. Aux does not conform to the HepRep rule >> 813 // that each object can have only one instance of a given AttValue. >> 814 // Both of these attributes are redundant to actual position information of the point. >> 815 if (strcmp(iAttVal->GetName(),"Aux-X")!=0 && >> 816 strcmp(iAttVal->GetName(),"Aux-Y")!=0 && >> 817 strcmp(iAttVal->GetName(),"Aux-Z")!=0 && >> 818 strcmp(iAttVal->GetName(),"Pos-X")!=0 && >> 819 strcmp(iAttVal->GetName(),"Pos-Y")!=0 && >> 820 strcmp(iAttVal->GetName(),"Pos-Z")!=0) >> 821 hepRepXMLWriter->addAttValue(iAttVal->GetName(), iAttVal->GetValue()); >> 822 delete pointAttValues; >> 823 } >> 824 delete rawPointAttValues; >> 825 } >> 826 >> 827 // Clean up point attributes. >> 828 if (pointAttDefs) >> 829 delete pointAttDefs; >> 830 >> 831 // Each trajectory point is made of a single primitive, a point. >> 832 G4Point3D vertex = aTrajectoryPoint->GetPosition(); >> 833 >> 834 // Loop over auxiliary points associated with this Trajectory Point. >> 835 const std::vector<G4ThreeVector>* auxiliaries = aTrajectoryPoint->GetAuxiliaryPoints(); >> 836 if (0 != auxiliaries) { >> 837 for (size_t iAux=0; iAux<auxiliaries->size(); ++iAux) { >> 838 const G4ThreeVector auxPos((*auxiliaries)[iAux]); >> 839 hepRepXMLWriter->addPrimitive(); >> 840 hepRepXMLWriter->addPoint(auxPos.x(), auxPos.y(), auxPos.z()); >> 841 } >> 842 } >> 843 } >> 844 } >> 845 } >> 846 >> 847 >> 848 void G4HepRepFileSceneHandler::AddCompound (const G4VHit& hit) { >> 849 #ifdef G4HEPREPFILEDEBUG >> 850 G4cout << "G4HepRepFileSceneHandler::AddCompound(G4VHit&) " << G4endl; >> 851 #endif >> 852 >> 853 // Pointers to hold hit attribute values and definitions. >> 854 std::vector<G4AttValue>* rawHitAttValues = hit.CreateAttValues(); >> 855 hitAttValues = >> 856 new std::vector<G4AttValue>; >> 857 hitAttDefs = >> 858 new std::map<G4String,G4AttDef>; >> 859 >> 860 // Iterators to use with attribute values and definitions. >> 861 std::vector<G4AttValue>::iterator iAttVal; >> 862 std::map<G4String,G4AttDef>::const_iterator iAttDef; >> 863 >> 864 // Get hit attributes and definitions in standard HepRep style >> 865 // (uniform units, 3Vectors decomposed). >> 866 if (rawHitAttValues) { >> 867 G4bool error = G4AttCheck(rawHitAttValues, >> 868 hit.GetAttDefs()).Standard(hitAttValues,hitAttDefs); >> 869 if (error) { >> 870 G4cout << "G4HepRepFileSceneHandler::AddCompound(hit):" >> 871 "\nERROR found during conversion to standard hit attributes." >> 872 << G4endl; >> 873 } >> 874 #ifdef G4HEPREPFILEDEBUG >> 875 G4cout << >> 876 "G4HepRepFileSceneHandler::AddCompound(hit): standardised attributes:\n" >> 877 << G4AttCheck(hitAttValues,hitAttDefs) << G4endl; >> 878 #endif >> 879 delete rawHitAttValues; >> 880 } >> 881 >> 882 // Open the HepRep output file if it is not already open. >> 883 CheckFileOpen(); >> 884 >> 885 // Add the Event Data Type if it hasn't already been added. >> 886 if (strcmp("Event Data",hepRepXMLWriter->prevTypeName[0])!=0) { >> 887 hepRepXMLWriter->addType("Event Data",0); >> 888 hepRepXMLWriter->addInstance(); >> 889 } >> 890 >> 891 // Find out the current HitType. >> 892 G4String hitType = "Hits"; >> 893 if (hitAttValues) { >> 894 G4bool found = false; >> 895 for (iAttVal = hitAttValues->begin(); >> 896 iAttVal != hitAttValues->end() && !found; ++iAttVal) { >> 897 if (strcmp(iAttVal->GetName(),"HitType")==0) { >> 898 hitType = iAttVal->GetValue(); >> 899 found = true; >> 900 } >> 901 } >> 902 } >> 903 >> 904 // Add the Hits Type. >> 905 G4String previousName = hepRepXMLWriter->prevTypeName[1]; >> 906 hepRepXMLWriter->addType(hitType,1); >> 907 >> 908 // If this is the first hit of this event, >> 909 // specify attribute values common to all hits. >> 910 if (strcmp(hitType,previousName)!=0) { >> 911 hepRepXMLWriter->addAttValue("Layer",130); >> 912 >> 913 // Take all Hit attDefs from first hit. >> 914 // Would rather be able to get these attDefs without needing a reference from any >> 915 // particular hit, but don't know how to do that. >> 916 // Write out hit attribute definitions. >> 917 if (hitAttValues && hitAttDefs) { >> 918 for (iAttVal = hitAttValues->begin(); >> 919 iAttVal != hitAttValues->end(); ++iAttVal) { >> 920 iAttDef = hitAttDefs->find(iAttVal->GetName()); >> 921 if (iAttDef != hitAttDefs->end()) { >> 922 // Protect against incorrect use of Category. Anything value other than the >> 923 // standard ones will be considered to be in the physics category. >> 924 G4String category = iAttDef->second.GetCategory(); >> 925 if (strcmp(category,"Draw")!=0 && >> 926 strcmp(category,"Physics")!=0 && >> 927 strcmp(category,"Association")!=0 && >> 928 strcmp(category,"PickAction")!=0) >> 929 category = "Physics"; >> 930 hepRepXMLWriter->addAttDef(iAttVal->GetName(), iAttDef->second.GetDesc(), >> 931 category, iAttDef->second.GetExtra()); >> 932 } >> 933 } >> 934 } >> 935 } // end of special treatment for when this is the first hit. >> 936 >> 937 // Now that we have written out all of the attributes that are based on the >> 938 // hit's particulars, call base class to deconstruct hit into a primitives. >> 939 drawingHit = true; >> 940 doneInitHit = false; >> 941 G4VSceneHandler::AddCompound(hit); // Invoke default action. >> 942 drawingHit = false; >> 943 } >> 944 >> 945 >> 946 void G4HepRepFileSceneHandler::InitTrajectory() { >> 947 if (!doneInitTraj) { >> 948 // For every trajectory, add an instance of Type Trajectory. >> 949 hepRepXMLWriter->addInstance(); >> 950 >> 951 // Write out the trajectory's attribute values. >> 952 if (trajAttValues) { >> 953 std::vector<G4AttValue>::iterator iAttVal; >> 954 for (iAttVal = trajAttValues->begin(); >> 955 iAttVal != trajAttValues->end(); ++iAttVal) >> 956 hepRepXMLWriter->addAttValue(iAttVal->GetName(), iAttVal->GetValue()); >> 957 delete trajAttValues; >> 958 } >> 959 >> 960 // Clean up trajectory attributes. >> 961 if (trajAttDefs) >> 962 delete trajAttDefs; >> 963 >> 964 doneInitTraj = true; >> 965 } >> 966 } >> 967 >> 968 >> 969 void G4HepRepFileSceneHandler::InitHit() { >> 970 if (!doneInitHit) { >> 971 // For every hit, add an instance of Type Hit. >> 972 hepRepXMLWriter->addInstance(); >> 973 >> 974 // Write out the hit's attribute values. >> 975 if (hitAttValues) { >> 976 std::vector<G4AttValue>::iterator iAttVal; >> 977 for (iAttVal = hitAttValues->begin(); >> 978 iAttVal != hitAttValues->end(); ++iAttVal) >> 979 hepRepXMLWriter->addAttValue(iAttVal->GetName(), iAttVal->GetValue()); >> 980 delete hitAttValues; >> 981 } >> 982 >> 983 // Clean up hit attributes. >> 984 if (hitAttDefs) >> 985 delete hitAttDefs; >> 986 >> 987 doneInitHit = true; >> 988 } >> 989 } >> 990 >> 991 >> 992 void G4HepRepFileSceneHandler::AddPrimitive(const G4Polyline& polyline) { >> 993 #ifdef G4HEPREPFILEDEBUG >> 994 G4cout << >> 995 "G4HepRepFileSceneHandler::AddPrimitive(const G4Polyline& polyline) called:" >> 996 "\n polyline: " << polyline >> 997 << G4endl; >> 998 PrintThings(); >> 999 #endif >> 1000 >> 1001 G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance(); >> 1002 >> 1003 if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles()) >> 1004 return; >> 1005 >> 1006 if (inPrimitives2D) { >> 1007 if (!warnedAbout2DMarkers) { >> 1008 G4cout << "HepRepFile does not currently support 2D lines." << G4endl; >> 1009 warnedAbout2DMarkers = true; >> 1010 } >> 1011 return; >> 1012 } >> 1013 >> 1014 if (drawingTraj) >> 1015 InitTrajectory(); >> 1016 >> 1017 if (drawingHit) >> 1018 InitHit(); >> 1019 >> 1020 haveVisible = true; >> 1021 AddHepRepInstance("Line", polyline); >> 1022 >> 1023 hepRepXMLWriter->addPrimitive(); >> 1024 >> 1025 for (size_t i=0; i < polyline.size(); i++) { >> 1026 G4Point3D vertex = (fObjectTransformation) * polyline[i]; >> 1027 hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z()); >> 1028 } >> 1029 } >> 1030 >> 1031 >> 1032 >> 1033 void G4HepRepFileSceneHandler::AddPrimitive (const G4Polymarker& line) { >> 1034 #ifdef G4HEPREPFILEDEBUG >> 1035 G4cout << >> 1036 "G4HepRepFileSceneHandler::AddPrimitive(const G4Polymarker& line) called" >> 1037 << G4endl; >> 1038 PrintThings(); >> 1039 #endif >> 1040 >> 1041 G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance(); >> 1042 >> 1043 if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles()) >> 1044 return; >> 1045 >> 1046 if (inPrimitives2D) { >> 1047 if (!warnedAbout2DMarkers) { >> 1048 G4cout << "HepRepFile does not currently support 2D lines." << G4endl; >> 1049 warnedAbout2DMarkers = true; >> 1050 } >> 1051 return; >> 1052 } >> 1053 >> 1054 MarkerSizeType sizeType; >> 1055 G4double size = GetMarkerSize (line, sizeType); >> 1056 if (sizeType==world) >> 1057 size = 4.; >> 1058 >> 1059 if (drawingTraj) >> 1060 return; >> 1061 >> 1062 if (drawingHit) >> 1063 InitHit(); >> 1064 >> 1065 haveVisible = true; >> 1066 AddHepRepInstance("Point", line); >> 1067 >> 1068 hepRepXMLWriter->addAttValue("MarkName", "Dot"); >> 1069 hepRepXMLWriter->addAttValue("MarkSize", (G4int) size); >> 1070 >> 1071 hepRepXMLWriter->addPrimitive(); >> 1072 >> 1073 for (size_t i=0; i < line.size(); i++) { >> 1074 G4Point3D vertex = (fObjectTransformation) * line[i]; >> 1075 hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z()); >> 1076 } >> 1077 } >> 1078 >> 1079 >> 1080 void G4HepRepFileSceneHandler::AddPrimitive(const G4Text& text) { >> 1081 #ifdef G4HEPREPFILEDEBUG >> 1082 G4cout << >> 1083 "G4HepRepFileSceneHandler::AddPrimitive(const G4Text& text) called:" >> 1084 "\n text: " << text.GetText() >> 1085 << G4endl; >> 1086 PrintThings(); >> 1087 #endif >> 1088 >> 1089 if (!inPrimitives2D) { >> 1090 if (!warnedAbout3DText) { >> 1091 G4cout << "HepRepFile does not currently support 3D text." << G4endl; >> 1092 G4cout << "HepRep browsers can directly display text attributes on request." << G4endl; >> 1093 G4cout << "See Application Developers Guide for how to attach attributes to viewable objects." << G4endl; >> 1094 warnedAbout3DText = true; >> 1095 } >> 1096 return; >> 1097 } >> 1098 >> 1099 MarkerSizeType sizeType; >> 1100 G4double size = GetMarkerSize (text, sizeType); >> 1101 if (sizeType==world) >> 1102 size = 12.; >> 1103 >> 1104 haveVisible = true; >> 1105 AddHepRepInstance("Text", text); >> 1106 >> 1107 hepRepXMLWriter->addAttValue("VAlign", "Top"); >> 1108 hepRepXMLWriter->addAttValue("HAlign", "Left"); >> 1109 hepRepXMLWriter->addAttValue("FontName", "Arial"); >> 1110 hepRepXMLWriter->addAttValue("FontStyle", "Plain"); >> 1111 hepRepXMLWriter->addAttValue("FontSize", (G4int) size); >> 1112 hepRepXMLWriter->addAttValue("FontHasBanner", "TRUE"); >> 1113 hepRepXMLWriter->addAttValue("FontBannerColor", "0,0,0"); >> 1114 >> 1115 const G4Colour& colour = GetTextColour(text); >> 1116 float redness = colour.GetRed(); >> 1117 float greenness = colour.GetGreen(); >> 1118 float blueness = colour.GetBlue(); >> 1119 >> 1120 // Avoiding drawing anything black on black. >> 1121 if (redness==0. && greenness==0. && blueness==0.) { >> 1122 redness = 1.; >> 1123 greenness = 1.; >> 1124 blueness = 1.; >> 1125 } >> 1126 hepRepXMLWriter->addAttValue("FontColor",redness,greenness,blueness); >> 1127 >> 1128 hepRepXMLWriter->addPrimitive(); >> 1129 >> 1130 hepRepXMLWriter->addAttValue("Text", text.GetText()); >> 1131 hepRepXMLWriter->addAttValue("VPos", .99-text.GetYOffset()); >> 1132 hepRepXMLWriter->addAttValue("HPos", text.GetXOffset()); >> 1133 } >> 1134 >> 1135 >> 1136 void G4HepRepFileSceneHandler::AddPrimitive(const G4Circle& circle) { >> 1137 #ifdef G4HEPREPFILEDEBUG >> 1138 G4cout << >> 1139 "G4HepRepFileSceneHandler::AddPrimitive(const G4Circle& circle) called:" >> 1140 "\n radius: " << circle.GetWorldRadius() >> 1141 << G4endl; >> 1142 PrintThings(); >> 1143 #endif >> 1144 >> 1145 G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance(); >> 1146 >> 1147 if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles()) >> 1148 return; >> 1149 >> 1150 if (inPrimitives2D) { >> 1151 if (!warnedAbout2DMarkers) { >> 1152 G4cout << "HepRepFile does not currently support 2D circles." << G4endl; >> 1153 warnedAbout2DMarkers = true; >> 1154 } >> 1155 return; >> 1156 } >> 1157 >> 1158 MarkerSizeType sizeType; >> 1159 G4double size = GetMarkerSize (circle, sizeType); >> 1160 if (sizeType==world) >> 1161 size = 4.; >> 1162 >> 1163 if (drawingTraj) >> 1164 return; >> 1165 >> 1166 if (drawingHit) >> 1167 InitHit(); >> 1168 >> 1169 haveVisible = true; >> 1170 AddHepRepInstance("Point", circle); >> 1171 >> 1172 hepRepXMLWriter->addAttValue("MarkName", "Dot"); >> 1173 hepRepXMLWriter->addAttValue("MarkSize", (G4int) size); >> 1174 >> 1175 hepRepXMLWriter->addPrimitive(); >> 1176 >> 1177 G4Point3D center = (fObjectTransformation) * circle.GetPosition(); >> 1178 hepRepXMLWriter->addPoint(center.x(), center.y(), center.z()); >> 1179 } >> 1180 >> 1181 >> 1182 void G4HepRepFileSceneHandler::AddPrimitive(const G4Square& square) { >> 1183 #ifdef G4HEPREPFILEDEBUG >> 1184 G4cout << >> 1185 "G4HepRepFileSceneHandler::AddPrimitive(const G4Square& square) called:" >> 1186 "\n side: " << square.GetWorldRadius() >> 1187 << G4endl; >> 1188 PrintThings(); >> 1189 #endif >> 1190 >> 1191 G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance(); >> 1192 >> 1193 if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles()) >> 1194 return; >> 1195 >> 1196 if (inPrimitives2D) { >> 1197 if (!warnedAbout2DMarkers) { >> 1198 G4cout << "HepRepFile does not currently support 2D squares." << G4endl; >> 1199 warnedAbout2DMarkers = true; >> 1200 } >> 1201 return; >> 1202 } >> 1203 >> 1204 MarkerSizeType sizeType; >> 1205 G4double size = GetMarkerSize (square, sizeType); >> 1206 if (sizeType==world) >> 1207 size = 4.; >> 1208 >> 1209 if (drawingTraj) >> 1210 return; >> 1211 >> 1212 if (drawingHit) >> 1213 InitHit(); >> 1214 >> 1215 haveVisible = true; >> 1216 AddHepRepInstance("Point", square); >> 1217 >> 1218 hepRepXMLWriter->addAttValue("MarkName", "Square"); >> 1219 hepRepXMLWriter->addAttValue("MarkSize", (G4int) size); >> 1220 >> 1221 hepRepXMLWriter->addPrimitive(); >> 1222 >> 1223 G4Point3D center = (fObjectTransformation) * square.GetPosition(); >> 1224 hepRepXMLWriter->addPoint(center.x(), center.y(), center.z()); >> 1225 } >> 1226 >> 1227 >> 1228 void G4HepRepFileSceneHandler::AddPrimitive(const G4Polyhedron& polyhedron) { >> 1229 #ifdef G4HEPREPFILEDEBUG >> 1230 G4cout << >> 1231 "G4HepRepFileSceneHandler::AddPrimitive(const G4Polyhedron& polyhedron) called." >> 1232 << G4endl; >> 1233 PrintThings(); >> 1234 #endif >> 1235 >> 1236 G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance(); >> 1237 >> 1238 if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles()) >> 1239 return; >> 1240 >> 1241 if(polyhedron.GetNoFacets()==0)return; >> 1242 >> 1243 if (drawingTraj) >> 1244 return; >> 1245 >> 1246 if (drawingHit) >> 1247 InitHit(); >> 1248 >> 1249 haveVisible = true; >> 1250 AddHepRepInstance("Polygon", polyhedron); >> 1251 >> 1252 G4Normal3D surfaceNormal; >> 1253 G4Point3D vertex; >> 1254 >> 1255 G4bool notLastFace; >> 1256 do { >> 1257 hepRepXMLWriter->addPrimitive(); >> 1258 notLastFace = polyhedron.GetNextNormal (surfaceNormal); >> 1259 >> 1260 G4int edgeFlag = 1; >> 1261 G4bool notLastEdge; >> 1262 do { >> 1263 notLastEdge = polyhedron.GetNextVertex (vertex, edgeFlag); >> 1264 vertex = (fObjectTransformation) * vertex; >> 1265 hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z()); >> 1266 } while (notLastEdge); >> 1267 } while (notLastFace); >> 1268 } >> 1269 >> 1270 >> 1271 void G4HepRepFileSceneHandler::AddPrimitive(const G4NURBS&) { >> 1272 #ifdef G4HEPREPFILEDEBUG >> 1273 G4cout << >> 1274 "G4HepRepFileSceneHandler::AddPrimitive(const G4NURBS& nurbs) called." >> 1275 << G4endl; >> 1276 PrintThings(); 480 #endif 1277 #endif 481 G4VSceneHandler::AddSolid(orb); // Invoke d << 1278 G4cout << "G4HepRepFileSceneHandler::AddPrimitive G4NURBS : not implemented. " << G4endl; 482 } 1279 } 483 1280 484 void G4HepRepFileSceneHandler::AddSolid(const << 485 { << 486 #ifdef G4HEPREPFILEDEBUG << 487 G4cout << "G4HepRepFileSceneHandler::AddSoli << 488 "called for " << 489 << ellipsoid.GetName() << G4endl; << 490 PrintThings(); << 491 #endif << 492 G4VSceneHandler::AddSolid(ellipsoid); // In << 493 } << 494 1281 495 void G4HepRepFileSceneHandler::AddSolid(const << 1282 G4HepRepFileXMLWriter *G4HepRepFileSceneHandler::GetHepRepXMLWriter() { 496 { << 1283 return hepRepXMLWriter; 497 #ifdef G4HEPREPFILEDEBUG << 498 G4cout << "G4HepRepFileSceneHandler::AddSoli << 499 "called for " << 500 << tess.GetName() << G4endl; << 501 PrintThings(); << 502 #endif << 503 G4VSceneHandler::AddSolid(tess); // Invoke << 504 } << 505 << 506 void G4HepRepFileSceneHandler::AddSolid(const << 507 { << 508 #ifdef G4HEPREPFILEDEBUG << 509 G4cout << 510 << "G4HepRepFileSceneHandler::AddSolid(con << 511 << solid.GetName() << G4endl; << 512 PrintThings(); << 513 #endif << 514 G4VSceneHandler::AddSolid(solid); // Invoke << 515 } 1284 } 516 1285 517 void G4HepRepFileSceneHandler::AddCompound(con << 518 { << 519 #ifdef G4HEPREPFILEDEBUG << 520 G4cout << "G4HepRepFileSceneHandler::AddComp << 521 << G4endl; << 522 #endif << 523 << 524 G4TrajectoriesModel* pTrModel = dynamic_cast << 525 if(!pTrModel) << 526 G4Exception("G4HepRepFileSceneHandler::Add << 527 "vis-HepRep0001", FatalExcepti << 528 << 529 // Pointers to hold trajectory attribute val << 530 std::vector<G4AttValue>* rawTrajAttValues = << 531 trajAttValues = << 532 trajAttDefs = << 533 << 534 // Iterators to use with attribute values an << 535 std::vector<G4AttValue>::iterator iAttVal; << 536 std::map<G4String, G4AttDef>::const_iterator << 537 G4int i; << 538 << 539 // Get trajectory attributes and definitions << 540 // (uniform units, 3Vectors decomposed). << 541 if(rawTrajAttValues) << 542 { << 543 G4bool error = G4AttCheck(rawTrajAttValues << 544 .Standard(trajAttValues, << 545 if(error) << 546 { << 547 G4cout << 548 << "G4HepRepFileSceneHandler::AddCompo << 549 "\nERROR found during conversion to << 550 << G4endl; << 551 } << 552 #ifdef G4HEPREPFILEDEBUG << 553 G4cout << "G4HepRepFileSceneHandler::AddCo << 554 "attributes:\n" << 555 << G4AttCheck(trajAttValues, trajAt << 556 #endif << 557 delete rawTrajAttValues; << 558 } << 559 << 560 // Open the HepRep output file if it is not << 561 CheckFileOpen(); << 562 << 563 // Add the Event Data Type if it hasn't alre << 564 if(strcmp("Event Data", hepRepXMLWriter->pre << 565 { << 566 hepRepXMLWriter->addType("Event Data", 0); << 567 hepRepXMLWriter->addInstance(); << 568 } << 569 << 570 // Add the Trajectories Type. << 571 G4String previousName = hepRepXMLWriter->pre << 572 hepRepXMLWriter->addType("Trajectories", 1); << 573 << 574 // If this is the first trajectory of this e << 575 // specify attribute values common to all tr << 576 if(strcmp("Trajectories", previousName) != 0 << 577 { << 578 hepRepXMLWriter->addAttValue("Layer", 100) << 579 << 580 // Take all Trajectory attDefs from first << 581 // Would rather be able to get these attDe << 582 // from any particular trajectory, but don << 583 // trajectory attribute definitions. << 584 if(trajAttValues && trajAttDefs) << 585 { << 586 for(iAttVal = trajAttValues->begin(); iA << 587 ++iAttVal) << 588 { << 589 iAttDef = trajAttDefs->find(iAttVal->G << 590 if(iAttDef != trajAttDefs->end()) << 591 { << 592 // Protect against incorrect use of << 593 // than the standard ones will be co << 594 // category. << 595 G4String category = iAttDef->second. << 596 if(strcmp(category, "Draw") != 0 && << 597 strcmp(category, "Physics") != 0 << 598 strcmp(category, "Association") ! << 599 strcmp(category, "PickAction") != << 600 category = "Physics"; << 601 hepRepXMLWriter->addAttDef(iAttVal-> << 602 iAttDef-> << 603 iAttDef-> << 604 } << 605 } << 606 } << 607 << 608 // Take all TrajectoryPoint attDefs from f << 609 // Would rather be able to get these attDe << 610 // from any particular point, but don't kn << 611 if((trajContext->GetDrawStepPts() || trajC << 612 traj.GetPointEntries() > 0) << 613 { << 614 G4VTrajectoryPoint* aTrajectoryPoint = t << 615 << 616 // Pointers to hold trajectory point att << 617 std::vector<G4AttValue>* rawPointAttValu << 618 aTrajectoryPoint->CreateAttValues(); << 619 std::vector<G4AttValue>* pointAttValues << 620 std::map<G4String, G4AttDef>* pointAttDe << 621 new std::map<G4String, G4AttDef>; << 622 << 623 // Get first trajectory point's attribut << 624 // HepRep style (uniform units, 3Vectors << 625 if(rawPointAttValues) << 626 { << 627 G4bool error = << 628 G4AttCheck(rawPointAttValues, aTraje << 629 .Standard(pointAttValues, pointAtt << 630 if(error) << 631 { << 632 G4cout << "G4HepRepFileSceneHandler: << 633 "\nERROR found during conv << 634 "attributes." << 635 << G4endl; << 636 } << 637 << 638 // Write out point attribute definitio << 639 if(pointAttValues && pointAttDefs) << 640 { << 641 for(iAttVal = pointAttValues->begin( << 642 iAttVal != pointAttValues->end() << 643 { << 644 iAttDef = pointAttDefs->find(iAttV << 645 if(iAttDef != pointAttDefs->end()) << 646 { << 647 // Protect against incorrect use << 648 // other than the standard ones << 649 // physics category. << 650 G4String category = iAttDef->sec << 651 if(strcmp(category, "Draw") != 0 << 652 strcmp(category, "Physics") ! << 653 strcmp(category, "Association << 654 strcmp(category, "PickAction" << 655 category = "Physics"; << 656 // Do not write out the Aux or P << 657 // conform to the HepRep rule th << 658 // instance of a given AttValue. << 659 // redundant to actual position << 660 if(strcmp(iAttVal->GetName(), "A << 661 strcmp(iAttVal->GetName(), "A << 662 strcmp(iAttVal->GetName(), "A << 663 strcmp(iAttVal->GetName(), "P << 664 strcmp(iAttVal->GetName(), "P << 665 strcmp(iAttVal->GetName(), "P << 666 hepRepXMLWriter->addAttDef(iAt << 667 iAt << 668 iAt << 669 } << 670 } << 671 } << 672 delete rawPointAttValues; << 673 } << 674 << 675 // Clean up point attributes. << 676 if(pointAttValues) << 677 delete pointAttValues; << 678 if(pointAttDefs) << 679 delete pointAttDefs; << 680 } << 681 } // end of special treatment for when this << 682 << 683 // Now that we have written out all of the a << 684 // trajectory's particulars, call base class << 685 // polyline and/or points (or nothing if tra << 686 // base class calls for drawing points, no p << 687 // since we instead need to do point drawing << 688 // points attributes, not available from Add << 689 // such a call will just serve to set the fl << 690 // drawing was requested for this trajectory << 691 // including trajContext and filtering). << 692 drawingTraj = true; << 693 doneInitTraj = false; << 694 G4VSceneHandler::AddCompound(traj); << 695 drawingTraj = false; << 696 << 697 // Draw step points. << 698 if(trajContext->GetDrawStepPts()) << 699 { << 700 if(!doneInitTraj) << 701 InitTrajectory(); << 702 // Create Trajectory Points as a subType o << 703 // Note that we should create this heprep << 704 // points. This allows the user to tell th << 705 // odd) rather than that they were omitted << 706 previousName = hepRepXMLWriter->prevTypeNa << 707 hepRepXMLWriter->addType("Trajectory Step << 708 << 709 float redness; << 710 float greenness; << 711 float blueness; << 712 G4int markSize; << 713 G4bool visible; << 714 G4bool square; << 715 G4Colour colour = trajContext->GetStepPtsC << 716 redness = colour.GetRed(); << 717 greenness = colour.GetGreen(); << 718 blueness = colour.GetBlue(); << 719 markSize = (G4int) trajContext->Get << 720 visible = (G4int) trajContext->Get << 721 square = (trajContext->GetStepPts << 722 << 723 // Avoiding drawing anything black on blac << 724 if(redness == 0. && greenness == 0. && blu << 725 { << 726 redness = 1.; << 727 greenness = 1.; << 728 blueness = 1.; << 729 } << 730 << 731 // Specify attributes common to all trajec << 732 if(strcmp("Trajectory Step Points", previo << 733 { << 734 hepRepXMLWriter->addAttValue("DrawAs", " << 735 hepRepXMLWriter->addAttValue("MarkColor" << 736 hepRepXMLWriter->addAttValue("MarkSize", << 737 hepRepXMLWriter->addAttValue("Layer", 11 << 738 hepRepXMLWriter->addAttValue("Visibility << 739 if(square) << 740 hepRepXMLWriter->addAttValue("MarkName << 741 else << 742 hepRepXMLWriter->addAttValue("MarkName << 743 } << 744 << 745 // Loop over all points on this trajectory << 746 for(i = 0; i < traj.GetPointEntries(); i++ << 747 { << 748 G4VTrajectoryPoint* aTrajectoryPoint = t << 749 << 750 // Each point is a separate instance of << 751 hepRepXMLWriter->addInstance(); << 752 << 753 // Pointers to hold trajectory point att << 754 std::vector<G4AttValue>* rawPointAttValu << 755 aTrajectoryPoint->CreateAttValues(); << 756 std::vector<G4AttValue>* pointAttValues << 757 std::map<G4String, G4AttDef>* pointAttDe << 758 new std::map<G4String, G4AttDef>; << 759 << 760 // Get trajectory point attributes and d << 761 // style (uniform units, 3Vectors decomp << 762 if(rawPointAttValues) << 763 { << 764 G4bool error = << 765 G4AttCheck(rawPointAttValues, aTraje << 766 .Standard(pointAttValues, pointAtt << 767 if(error) << 768 { << 769 G4cout << 770 << "G4HepRepFileSceneHandler::AddC << 771 "\nERROR found during conversio << 772 << G4endl; << 773 } << 774 << 775 // Write out point attribute values. << 776 if(pointAttValues) << 777 { << 778 for(iAttVal = pointAttValues->begin( << 779 iAttVal != pointAttValues->end() << 780 // Do not write out the Aux or Pos << 781 // to the HepRep rule that each ob << 782 // a given AttValue. Both of these << 783 // actual position information of << 784 if(strcmp(iAttVal->GetName(), "Aux << 785 strcmp(iAttVal->GetName(), "Aux << 786 strcmp(iAttVal->GetName(), "Aux << 787 strcmp(iAttVal->GetName(), "Pos << 788 strcmp(iAttVal->GetName(), "Pos << 789 strcmp(iAttVal->GetName(), "Pos << 790 hepRepXMLWriter->addAttValue(iAt << 791 iAt << 792 } << 793 } << 794 << 795 // Clean up point attributes. << 796 delete pointAttDefs; << 797 delete pointAttValues; << 798 delete rawPointAttValues; << 799 << 800 // Each trajectory point is made of a si << 801 hepRepXMLWriter->addPrimitive(); << 802 G4Point3D vertex = aTrajectoryPoint->Get << 803 hepRepXMLWriter->addPoint(vertex.x(), ve << 804 } << 805 } << 806 << 807 // Draw Auxiliary Points << 808 if(trajContext->GetDrawAuxPts()) << 809 { << 810 if(!doneInitTraj) << 811 InitTrajectory(); << 812 // Create Trajectory Points as a subType o << 813 // Note that we should create this heprep << 814 // points. This allows the user to tell th << 815 // odd) rather than that they were omitted << 816 previousName = hepRepXMLWriter->prevTypeNa << 817 hepRepXMLWriter->addType("Trajectory Auxil << 818 << 819 float redness; << 820 float greenness; << 821 float blueness; << 822 G4int markSize; << 823 G4bool visible; << 824 G4bool square; << 825 G4Colour colour = trajContext->GetAuxPtsCo << 826 redness = colour.GetRed(); << 827 greenness = colour.GetGreen(); << 828 blueness = colour.GetBlue(); << 829 markSize = (G4int) trajContext->Get << 830 visible = (G4int) trajContext->Get << 831 square = (trajContext->GetAuxPtsT << 832 << 833 // Avoiding drawing anything black on blac << 834 if(redness == 0. && greenness == 0. && blu << 835 { << 836 redness = 1.; << 837 greenness = 1.; << 838 blueness = 1.; << 839 } << 840 << 841 // Specify attributes common to all trajec << 842 if(strcmp("Trajectory Auxiliary Points", p << 843 { << 844 hepRepXMLWriter->addAttValue("DrawAs", " << 845 hepRepXMLWriter->addAttValue("MarkColor" << 846 hepRepXMLWriter->addAttValue("MarkSize", << 847 hepRepXMLWriter->addAttValue("Layer", 11 << 848 hepRepXMLWriter->addAttValue("Visibility << 849 if(square) << 850 hepRepXMLWriter->addAttValue("MarkName << 851 else << 852 hepRepXMLWriter->addAttValue("MarkName << 853 } << 854 << 855 // Loop over all points on this trajectory << 856 for(i = 0; i < traj.GetPointEntries(); i++ << 857 { << 858 G4VTrajectoryPoint* aTrajectoryPoint = t << 859 << 860 // Each point is a separate instance of << 861 hepRepXMLWriter->addInstance(); << 862 << 863 // Pointers to hold trajectory point att << 864 std::vector<G4AttValue>* rawPointAttValu << 865 aTrajectoryPoint->CreateAttValues(); << 866 std::vector<G4AttValue>* pointAttValues << 867 std::map<G4String, G4AttDef>* pointAttDe << 868 new std::map<G4String, G4AttDef>; << 869 << 870 // Get trajectory point attributes and d << 871 // style (uniform units, 3Vectors decomp << 872 if(rawPointAttValues) << 873 { << 874 G4bool error = << 875 G4AttCheck(rawPointAttValues, aTraje << 876 .Standard(pointAttValues, pointAtt << 877 if(error) << 878 { << 879 G4cout << 880 << "G4HepRepFileSceneHandler::AddC << 881 "\nERROR found during conversio << 882 << G4endl; << 883 } << 884 << 885 // Write out point attribute values. << 886 if(pointAttValues) << 887 { << 888 for(iAttVal = pointAttValues->begin( << 889 iAttVal != pointAttValues->end() << 890 // Do not write out the Aux or Pos << 891 // to the HepRep rule that each ob << 892 // a given AttValue. Both of these << 893 // actual position information of << 894 if(strcmp(iAttVal->GetName(), "Aux << 895 strcmp(iAttVal->GetName(), "Aux << 896 strcmp(iAttVal->GetName(), "Aux << 897 strcmp(iAttVal->GetName(), "Pos << 898 strcmp(iAttVal->GetName(), "Pos << 899 strcmp(iAttVal->GetName(), "Pos << 900 hepRepXMLWriter->addAttValue(iAt << 901 iAt << 902 } << 903 } << 904 << 905 // Clean up point attributes. << 906 delete pointAttDefs; << 907 delete pointAttValues; << 908 delete rawPointAttValues; << 909 << 910 // Each trajectory point is made of a si << 911 G4Point3D vertex = aTrajectoryPoint->Get << 912 << 913 // Loop over auxiliary points associated << 914 const std::vector<G4ThreeVector>* auxili << 915 aTrajectoryPoint->GetAuxiliaryPoints() << 916 if(0 != auxiliaries) << 917 { << 918 for(size_t iAux = 0; iAux < auxiliarie << 919 { << 920 const G4ThreeVector auxPos((*auxilia << 921 hepRepXMLWriter->addPrimitive(); << 922 hepRepXMLWriter->addPoint(auxPos.x() << 923 } << 924 } << 925 } << 926 } << 927 } << 928 << 929 void G4HepRepFileSceneHandler::AddCompound(con << 930 { << 931 #ifdef G4HEPREPFILEDEBUG << 932 G4cout << "G4HepRepFileSceneHandler::AddComp << 933 #endif << 934 << 935 // Pointers to hold hit attribute values and << 936 std::vector<G4AttValue>* rawHitAttValues = h << 937 hitAttValues = n << 938 hitAttDefs = n << 939 << 940 // Iterators to use with attribute values an << 941 std::vector<G4AttValue>::iterator iAttVal; << 942 std::map<G4String, G4AttDef>::const_iterator << 943 << 944 // Get hit attributes and definitions in sta << 945 // (uniform units, 3Vectors decomposed). << 946 if(rawHitAttValues) << 947 { << 948 G4bool error = G4AttCheck(rawHitAttValues, << 949 .Standard(hitAttValues, h << 950 if(error) << 951 { << 952 G4cout << "G4HepRepFileSceneHandler::Add << 953 "\nERROR found during conversi << 954 << G4endl; << 955 } << 956 #ifdef G4HEPREPFILEDEBUG << 957 G4cout << "G4HepRepFileSceneHandler::AddCo << 958 "attributes:\n" << 959 << G4AttCheck(hitAttValues, hitAttD << 960 #endif << 961 delete rawHitAttValues; << 962 } << 963 << 964 // Open the HepRep output file if it is not << 965 CheckFileOpen(); << 966 << 967 // Add the Event Data Type if it hasn't alre << 968 if(strcmp("Event Data", hepRepXMLWriter->pre << 969 { << 970 hepRepXMLWriter->addType("Event Data", 0); << 971 hepRepXMLWriter->addInstance(); << 972 } << 973 << 974 // Find out the current HitType. << 975 G4String hitType = "Hits"; << 976 if(hitAttValues) << 977 { << 978 G4bool found = false; << 979 for(iAttVal = hitAttValues->begin(); << 980 iAttVal != hitAttValues->end() && !fou << 981 { << 982 if(strcmp(iAttVal->GetName(), "HitType") << 983 { << 984 hitType = iAttVal->GetValue(); << 985 found = true; << 986 } << 987 } << 988 } << 989 << 990 // Add the Hits Type. << 991 G4String previousName = hepRepXMLWriter->pre << 992 hepRepXMLWriter->addType(hitType, 1); << 993 << 994 // If this is the first hit of this event, << 995 // specify attribute values common to all hi << 996 if(strcmp(hitType, previousName) != 0) << 997 { << 998 hepRepXMLWriter->addAttValue("Layer", 130) << 999 << 1000 // Take all Hit attDefs from first hit. << 1001 // Would rather be able to get these attD << 1002 // from any particular hit, but don't kno << 1003 // attribute definitions. << 1004 if(hitAttValues && hitAttDefs) << 1005 { << 1006 for(iAttVal = hitAttValues->begin(); iA << 1007 ++iAttVal) << 1008 { << 1009 iAttDef = hitAttDefs->find(iAttVal->G << 1010 if(iAttDef != hitAttDefs->end()) << 1011 { << 1012 // Protect against incorrect use of << 1013 // than the standard ones will be c << 1014 // category. << 1015 G4String category = iAttDef->second << 1016 if(strcmp(category, "Draw") != 0 && << 1017 strcmp(category, "Physics") != 0 << 1018 strcmp(category, "Association") << 1019 strcmp(category, "PickAction") ! << 1020 category = "Physics"; << 1021 hepRepXMLWriter->addAttDef(iAttVal- << 1022 iAttDef- << 1023 iAttDef- << 1024 } << 1025 } << 1026 } << 1027 } // end of special treatment for when thi << 1028 << 1029 // Now that we have written out all of the << 1030 // hit's particulars, call base class to de << 1031 drawingHit = true; << 1032 doneInitHit = false; << 1033 G4VSceneHandler::AddCompound(hit); // Invo << 1034 drawingHit = false; << 1035 } << 1036 << 1037 void G4HepRepFileSceneHandler::InitTrajectory << 1038 { << 1039 if(!doneInitTraj) << 1040 { << 1041 // For every trajectory, add an instance << 1042 hepRepXMLWriter->addInstance(); << 1043 << 1044 // Write out the trajectory's attribute v << 1045 if(trajAttValues) << 1046 { << 1047 std::vector<G4AttValue>::iterator iAttV << 1048 for(iAttVal = trajAttValues->begin(); i << 1049 ++iAttVal) << 1050 hepRepXMLWriter->addAttValue(iAttVal- << 1051 delete trajAttValues; << 1052 } << 1053 << 1054 // Clean up trajectory attributes. << 1055 if(trajAttDefs) << 1056 delete trajAttDefs; << 1057 << 1058 doneInitTraj = true; << 1059 } << 1060 } << 1061 << 1062 void G4HepRepFileSceneHandler::InitHit() << 1063 { << 1064 if(!doneInitHit) << 1065 { << 1066 // For every hit, add an instance of Type << 1067 hepRepXMLWriter->addInstance(); << 1068 << 1069 // Write out the hit's attribute values. << 1070 if(hitAttValues) << 1071 { << 1072 std::vector<G4AttValue>::iterator iAttV << 1073 for(iAttVal = hitAttValues->begin(); iA << 1074 ++iAttVal) << 1075 hepRepXMLWriter->addAttValue(iAttVal- << 1076 delete hitAttValues; << 1077 } << 1078 << 1079 // Clean up hit attributes. << 1080 if(hitAttDefs) << 1081 delete hitAttDefs; << 1082 << 1083 doneInitHit = true; << 1084 } << 1085 } << 1086 << 1087 void G4HepRepFileSceneHandler::AddPrimitive(c << 1088 { << 1089 #ifdef G4HEPREPFILEDEBUG << 1090 G4cout << "G4HepRepFileSceneHandler::AddPri << 1091 "polyline) called:" << 1092 "\n polyline: " << 1093 << polyline << G4endl; << 1094 PrintThings(); << 1095 #endif << 1096 << 1097 G4HepRepMessenger* messenger = G4HepRepMess << 1098 << 1099 if(fpVisAttribs && (fpVisAttribs->IsVisible << 1100 messenger->getCullInvisibles()) << 1101 return; << 1102 << 1103 if(inPrimitives2D) << 1104 { << 1105 if(!warnedAbout2DMarkers) << 1106 { << 1107 G4cout << "HepRepFile does not currentl << 1108 warnedAbout2DMarkers = true; << 1109 } << 1110 return; << 1111 } << 1112 << 1113 if(drawingTraj) << 1114 InitTrajectory(); << 1115 << 1116 if(drawingHit) << 1117 InitHit(); << 1118 << 1119 haveVisible = true; << 1120 AddHepRepInstance("Line", polyline); << 1121 << 1122 hepRepXMLWriter->addPrimitive(); << 1123 << 1124 for(size_t i = 0; i < polyline.size(); i++) << 1125 { << 1126 G4Point3D vertex = (fObjectTransformation << 1127 hepRepXMLWriter->addPoint(vertex.x(), ver << 1128 } << 1129 } << 1130 << 1131 void G4HepRepFileSceneHandler::AddPrimitive(c << 1132 { << 1133 #ifdef G4HEPREPFILEDEBUG << 1134 G4cout << 1135 << "G4HepRepFileSceneHandler::AddPrimitiv << 1136 << G4endl; << 1137 PrintThings(); << 1138 #endif << 1139 << 1140 G4HepRepMessenger* messenger = G4HepRepMess << 1141 << 1142 if(fpVisAttribs && (fpVisAttribs->IsVisible << 1143 messenger->getCullInvisibles()) << 1144 return; << 1145 << 1146 if(inPrimitives2D) << 1147 { << 1148 if(!warnedAbout2DMarkers) << 1149 { << 1150 G4cout << "HepRepFile does not currentl << 1151 warnedAbout2DMarkers = true; << 1152 } << 1153 return; << 1154 } << 1155 << 1156 MarkerSizeType sizeType; << 1157 G4double size = GetMarkerSize(line, sizeTyp << 1158 if(sizeType == world) << 1159 size = 4.; << 1160 << 1161 if(drawingTraj) << 1162 return; << 1163 << 1164 if(drawingHit) << 1165 InitHit(); << 1166 << 1167 haveVisible = true; << 1168 AddHepRepInstance("Point", line); << 1169 << 1170 hepRepXMLWriter->addAttValue("MarkName", "D << 1171 hepRepXMLWriter->addAttValue("MarkSize", (G << 1172 << 1173 hepRepXMLWriter->addPrimitive(); << 1174 << 1175 for(size_t i = 0; i < line.size(); i++) << 1176 { << 1177 G4Point3D vertex = (fObjectTransformation << 1178 hepRepXMLWriter->addPoint(vertex.x(), ver << 1179 } << 1180 } << 1181 << 1182 void G4HepRepFileSceneHandler::AddPrimitive(c << 1183 { << 1184 #ifdef G4HEPREPFILEDEBUG << 1185 G4cout << "G4HepRepFileSceneHandler::AddPri << 1186 "\n text: " << 1187 << text.GetText() << G4endl; << 1188 PrintThings(); << 1189 #endif << 1190 << 1191 if(!inPrimitives2D) << 1192 { << 1193 if(!warnedAbout3DText) << 1194 { << 1195 G4cout << "HepRepFile does not currentl << 1196 G4cout << 1197 << "HepRep browsers can directly disp << 1198 << G4endl; << 1199 G4cout << "See Application Developers G << 1200 "to viewable objects." << 1201 << G4endl; << 1202 warnedAbout3DText = true; << 1203 } << 1204 return; << 1205 } << 1206 << 1207 MarkerSizeType sizeType; << 1208 G4double size = GetMarkerSize(text, sizeTyp << 1209 if(sizeType == world) << 1210 size = 12.; << 1211 << 1212 haveVisible = true; << 1213 AddHepRepInstance("Text", text); << 1214 << 1215 hepRepXMLWriter->addAttValue("VAlign", "Top << 1216 hepRepXMLWriter->addAttValue("HAlign", "Lef << 1217 hepRepXMLWriter->addAttValue("FontName", "A << 1218 hepRepXMLWriter->addAttValue("FontStyle", " << 1219 hepRepXMLWriter->addAttValue("FontSize", (G << 1220 hepRepXMLWriter->addAttValue("FontHasBanner << 1221 hepRepXMLWriter->addAttValue("FontBannerCol << 1222 << 1223 const G4Colour& colour = GetTextColour(text << 1224 float redness = colour.GetRed(); << 1225 float greenness = colour.GetGreen(); << 1226 float blueness = colour.GetBlue(); << 1227 << 1228 // Avoiding drawing anything black on black << 1229 if(redness == 0. && greenness == 0. && blue << 1230 { << 1231 redness = 1.; << 1232 greenness = 1.; << 1233 blueness = 1.; << 1234 } << 1235 hepRepXMLWriter->addAttValue("FontColor", r << 1236 << 1237 hepRepXMLWriter->addPrimitive(); << 1238 << 1239 hepRepXMLWriter->addAttValue("Text", text.G << 1240 hepRepXMLWriter->addAttValue("VPos", .99 - << 1241 hepRepXMLWriter->addAttValue("HPos", text.G << 1242 } << 1243 << 1244 void G4HepRepFileSceneHandler::AddPrimitive(c << 1245 { << 1246 #ifdef G4HEPREPFILEDEBUG << 1247 G4cout << 1248 << "G4HepRepFileSceneHandler::AddPrimitiv << 1249 "\n radius: " << 1250 << circle.GetWorldRadius() << G4endl; << 1251 PrintThings(); << 1252 #endif << 1253 << 1254 G4HepRepMessenger* messenger = G4HepRepMess << 1255 << 1256 if(fpVisAttribs && (fpVisAttribs->IsVisible << 1257 messenger->getCullInvisibles()) << 1258 return; << 1259 << 1260 if(inPrimitives2D) << 1261 { << 1262 if(!warnedAbout2DMarkers) << 1263 { << 1264 G4cout << "HepRepFile does not currentl << 1265 warnedAbout2DMarkers = true; << 1266 } << 1267 return; << 1268 } << 1269 << 1270 MarkerSizeType sizeType; << 1271 G4double size = GetMarkerSize(circle, sizeT << 1272 if(sizeType == world) << 1273 size = 4.; << 1274 << 1275 if(drawingTraj) << 1276 return; << 1277 << 1278 if(drawingHit) << 1279 InitHit(); << 1280 << 1281 haveVisible = true; << 1282 AddHepRepInstance("Point", circle); << 1283 << 1284 hepRepXMLWriter->addAttValue("MarkName", "D << 1285 hepRepXMLWriter->addAttValue("MarkSize", (G << 1286 << 1287 hepRepXMLWriter->addPrimitive(); << 1288 << 1289 G4Point3D center = (fObjectTransformation) << 1290 hepRepXMLWriter->addPoint(center.x(), cente << 1291 } << 1292 << 1293 void G4HepRepFileSceneHandler::AddPrimitive(c << 1294 { << 1295 #ifdef G4HEPREPFILEDEBUG << 1296 G4cout << 1297 << "G4HepRepFileSceneHandler::AddPrimitiv << 1298 "\n side: " << 1299 << square.GetWorldRadius() << G4endl; << 1300 PrintThings(); << 1301 #endif << 1302 << 1303 G4HepRepMessenger* messenger = G4HepRepMess << 1304 << 1305 if(fpVisAttribs && (fpVisAttribs->IsVisible << 1306 messenger->getCullInvisibles()) << 1307 return; << 1308 << 1309 if(inPrimitives2D) << 1310 { << 1311 if(!warnedAbout2DMarkers) << 1312 { << 1313 G4cout << "HepRepFile does not currentl << 1314 warnedAbout2DMarkers = true; << 1315 } << 1316 return; << 1317 } << 1318 << 1319 MarkerSizeType sizeType; << 1320 G4double size = GetMarkerSize(square, sizeT << 1321 if(sizeType == world) << 1322 size = 4.; << 1323 << 1324 if(drawingTraj) << 1325 return; << 1326 << 1327 if(drawingHit) << 1328 InitHit(); << 1329 << 1330 haveVisible = true; << 1331 AddHepRepInstance("Point", square); << 1332 << 1333 hepRepXMLWriter->addAttValue("MarkName", "S << 1334 hepRepXMLWriter->addAttValue("MarkSize", (G << 1335 << 1336 hepRepXMLWriter->addPrimitive(); << 1337 << 1338 G4Point3D center = (fObjectTransformation) << 1339 hepRepXMLWriter->addPoint(center.x(), cente << 1340 } << 1341 << 1342 void G4HepRepFileSceneHandler::AddPrimitive(c << 1343 { << 1344 #ifdef G4HEPREPFILEDEBUG << 1345 G4cout << "G4HepRepFileSceneHandler::AddPri << 1346 "polyhedron) called." << 1347 << G4endl; << 1348 PrintThings(); << 1349 #endif << 1350 << 1351 G4HepRepMessenger* messenger = G4HepRepMess << 1352 << 1353 if(fpVisAttribs && (fpVisAttribs->IsVisible << 1354 messenger->getCullInvisibles()) << 1355 return; << 1356 << 1357 if(polyhedron.GetNoFacets() == 0) << 1358 return; << 1359 << 1360 if(drawingTraj) << 1361 return; << 1362 << 1363 if(drawingHit) << 1364 InitHit(); << 1365 << 1366 haveVisible = true; << 1367 AddHepRepInstance("Polygon", polyhedron); << 1368 << 1369 G4Normal3D surfaceNormal; << 1370 G4Point3D vertex; << 1371 << 1372 G4bool notLastFace; << 1373 do << 1374 { << 1375 hepRepXMLWriter->addPrimitive(); << 1376 notLastFace = polyhedron.GetNextNormal(su << 1377 << 1378 G4int edgeFlag = 1; << 1379 G4bool notLastEdge; << 1380 do << 1381 { << 1382 notLastEdge = polyhedron.GetNextVertex( << 1383 vertex = (fObjectTransformation) * << 1384 hepRepXMLWriter->addPoint(vertex.x(), v << 1385 } while(notLastEdge); << 1386 } while(notLastFace); << 1387 } << 1388 << 1389 G4HepRepFileXMLWriter* G4HepRepFileSceneHandl << 1390 { << 1391 return hepRepXMLWriter; << 1392 } << 1393 1286 1394 void G4HepRepFileSceneHandler::AddHepRepInsta 1287 void G4HepRepFileSceneHandler::AddHepRepInstance(const char* primName, 1395 << 1288 const G4Visible visible) { 1396 { << 1397 #ifdef G4HEPREPFILEDEBUG 1289 #ifdef G4HEPREPFILEDEBUG 1398 G4cout << "G4HepRepFileSceneHandler::AddHep << 1290 G4cout << 1399 #endif << 1291 "G4HepRepFileSceneHandler::AddHepRepInstance called." 1400 << 1292 << G4endl; 1401 // Open the HepRep output file if it is not << 1293 #endif 1402 CheckFileOpen(); << 1294 1403 << 1295 // Open the HepRep output file if it is not already open. 1404 G4VPhysicalVolume* pCurrentPV = 0; << 1296 CheckFileOpen(); 1405 G4LogicalVolume* pCurrentLV = 0; << 1297 1406 G4int currentDepth = 0; << 1298 G4VPhysicalVolume* pCurrentPV = 0; 1407 G4PhysicalVolumeModel* pPVModel = << 1299 G4LogicalVolume* pCurrentLV = 0; 1408 dynamic_cast<G4PhysicalVolumeModel*>(fpMo << 1300 G4int currentDepth = 0; 1409 if(pPVModel) << 1301 G4PhysicalVolumeModel* pPVModel = dynamic_cast<G4PhysicalVolumeModel*>(fpModel); 1410 { << 1302 if (pPVModel) { 1411 pCurrentPV = pPVModel->GetCurrentPV(); << 1303 pCurrentPV = pPVModel->GetCurrentPV(); 1412 pCurrentLV = pPVModel->GetCurrentLV(); << 1304 pCurrentLV = pPVModel->GetCurrentLV(); 1413 currentDepth = pPVModel->GetCurrentDepth( << 1305 currentDepth = pPVModel->GetCurrentDepth(); 1414 } << 1306 } 1415 << 1307 1416 #ifdef G4HEPREPFILEDEBUG << 1308 #ifdef G4HEPREPFILEDEBUG 1417 G4cout << "pCurrentPV:" << pCurrentPV << 1309 G4cout << 1418 << ", readyForTransients:" << fReady << 1310 "pCurrentPV:" << pCurrentPV << ", readyForTransients:" << fReadyForTransients 1419 #endif << 1311 << G4endl; 1420 << 1312 #endif 1421 if(drawingTraj || drawingHit) << 1313 1422 { << 1314 if (drawingTraj || drawingHit) { 1423 // In this case, HepRep type, layer and i << 1315 // In this case, HepRep type, layer and instance were already created 1424 // in the AddCompound method. << 1316 // in the AddCompound method. 1425 } << 1317 } 1426 else if(fReadyForTransients) << 1318 else if (fReadyForTransients) { 1427 { << 1319 if (strcmp("Event Data",hepRepXMLWriter->prevTypeName[0])!=0) { 1428 if(strcmp("Event Data", hepRepXMLWriter-> << 1320 hepRepXMLWriter->addType("Event Data",0); 1429 { << 1321 hepRepXMLWriter->addInstance(); 1430 hepRepXMLWriter->addType("Event Data", << 1322 } 1431 hepRepXMLWriter->addInstance(); << 1323 1432 } << 1324 // Applications have the option of either calling AddSolid(G4VTrajectory&) and 1433 << 1325 // AddSolid(G4VHits&), or of just decomposing these into simpler primitives. 1434 // Applications have the option of either << 1326 // In the former case, drawing will be handled above and will include setting of 1435 // and AddSolid(G4VHits&), or of just dec << 1327 // physics attributes. 1436 // primitives. In the former case, drawin << 1328 // In the latter case, which is an older style of working, we end up drawing the 1437 // include setting of physics attributes. << 1329 // trajectories and hits here, where we have no access to physics attributes. 1438 // older style of working, we end up draw << 1330 // We receive primitives here. We can figure out that these are transients, but we 1439 // where we have no access to physics att << 1331 // have to guess exactly what these transients represent. 1440 // here. We can figure out that these ar << 1332 // We assume the primitives are being used as in G4VTrajectory, hence we assume: 1441 // exactly what these transients represen << 1333 // Lines are Trajectories 1442 // being used as in G4VTrajectory, hence << 1334 // Squares that come after we've seen trajectories are Auxiliary Points 1443 // Squares that come after we've seen tra << 1335 // Circles that come after we've seen trajectories are Step Points 1444 // Circles that come after we've seen tra << 1336 // Other primitives are Hits 1445 // Other primitives are Hits << 1337 1446 << 1338 int layer; 1447 int layer; << 1339 1448 << 1340 if (strcmp("Text",primName)==0) { 1449 if(strcmp("Text", primName) == 0) << 1341 hepRepXMLWriter->addType("EventID",1); 1450 { << 1342 } else { 1451 hepRepXMLWriter->addType("EventID", 1); << 1343 if (strcmp("Line",primName)==0) { 1452 } << 1344 hepRepXMLWriter->addType("TransientPolylines",1); 1453 else << 1345 layer = 100; 1454 { << 1346 } else { 1455 if(strcmp("Line", primName) == 0) << 1347 if (strcmp(hepRepXMLWriter->prevTypeName[1],"TransientPolylines")==0 && 1456 { << 1348 strcmp("Square",primName)==0) 1457 hepRepXMLWriter->addType("TransientPo << 1349 { 1458 layer = 100; << 1350 hepRepXMLWriter->addType("AuxiliaryPoints",2); 1459 } << 1351 layer = 110; 1460 else << 1352 } else { 1461 { << 1353 if (strcmp(hepRepXMLWriter->prevTypeName[1],"TransientPolylines")==0 && 1462 if(strcmp(hepRepXMLWriter->prevTypeNa << 1354 strcmp("Circle",primName)==0) 1463 0 && << 1355 { 1464 strcmp("Square", primName) == 0) << 1356 hepRepXMLWriter->addType("StepPoints",2); 1465 { << 1357 layer = 120; 1466 hepRepXMLWriter->addType("Auxiliary << 1358 } else { 1467 layer = 110; << 1359 hepRepXMLWriter->addType("Hits",1); 1468 } << 1360 layer = 130; 1469 else << 1361 } 1470 { << 1362 } 1471 if(strcmp(hepRepXMLWriter->prevType << 1363 } 1472 0 && << 1364 hepRepXMLWriter->addAttValue("Layer",layer); 1473 strcmp("Circle", primName) == 0) << 1365 } 1474 { << 1366 1475 hepRepXMLWriter->addType("StepPoi << 1367 hepRepXMLWriter->addInstance(); 1476 layer = 120; << 1368 1477 } << 1369 // Handle Type declaration for Axes, Ruler, etc. 1478 else << 1370 } else if (pCurrentPV==0) { 1479 { << 1371 if (strcmp("AxesEtc",hepRepXMLWriter->prevTypeName[0])!=0) { 1480 hepRepXMLWriter->addType("Hits", << 1372 hepRepXMLWriter->addType("AxesEtc",0); 1481 layer = 130; << 1373 hepRepXMLWriter->addInstance(); 1482 } << 1374 } 1483 } << 1375 1484 } << 1376 int layer; 1485 hepRepXMLWriter->addAttValue("Layer", l << 1377 1486 } << 1378 if (strcmp("Text",primName)==0) { 1487 << 1379 hepRepXMLWriter->addType("Text",1); 1488 hepRepXMLWriter->addInstance(); << 1380 } else { 1489 << 1381 if (strcmp("Line",primName)==0) { 1490 // Handle Type declaration for Axes, Rule << 1382 hepRepXMLWriter->addType("Polylines",1); 1491 } << 1383 layer = 100; 1492 else if(pCurrentPV == 0) << 1384 } else { 1493 { << 1385 hepRepXMLWriter->addType("Points",1); 1494 if(strcmp("AxesEtc", hepRepXMLWriter->pre << 1386 layer = 130; 1495 { << 1387 } 1496 hepRepXMLWriter->addType("AxesEtc", 0); << 1388 hepRepXMLWriter->addAttValue("Layer",layer); 1497 hepRepXMLWriter->addInstance(); << 1389 } 1498 } << 1390 1499 << 1391 hepRepXMLWriter->addInstance(); 1500 int layer; << 1392 1501 << 1393 // Handle Type declaration for Detector Geometry, 1502 if(strcmp("Text", primName) == 0) << 1394 // replacing G4's top geometry level name "worldPhysical" with the 1503 { << 1395 // name "Detector Geometry". 1504 hepRepXMLWriter->addType("Text", 1); << 1396 } else { 1505 } << 1397 //G4cout << "CurrentDepth" << currentDepth << G4endl; 1506 else << 1398 //G4cout << "currentName" << pCurrentPV->GetName() << G4endl; 1507 { << 1399 if (strcmp("Detector Geometry",hepRepXMLWriter->prevTypeName[0])!=0) { 1508 if(strcmp("Line", primName) == 0) << 1400 //G4cout << "Adding Det Geom type" << G4endl; 1509 { << 1401 hepRepXMLWriter->addType("Detector Geometry",0); 1510 hepRepXMLWriter->addType("Polylines", << 1402 hepRepXMLWriter->addInstance(); 1511 layer = 100; << 1403 } 1512 } << 1404 1513 else << 1405 // Re-insert any layers of the hierarchy that were removed by G4's culling process. 1514 { << 1406 // Don't bother checking if same type name as last instance. 1515 hepRepXMLWriter->addType("Points", 1) << 1407 if(strcmp(hepRepXMLWriter->prevTypeName[currentDepth+1],pCurrentPV->GetName())!=0) { 1516 layer = 130; << 1408 //G4cout << "Looking for mother of:" << pCurrentLV->GetName() << G4endl; 1517 } << 1409 typedef G4PhysicalVolumeModel::G4PhysicalVolumeNodeID PVNodeID; 1518 hepRepXMLWriter->addAttValue("Layer", l << 1410 typedef std::vector<PVNodeID> PVPath; 1519 } << 1411 const PVPath& drawnPVPath = pPVModel->GetDrawnPVPath(); 1520 << 1412 PVPath::const_reverse_iterator ri = ++drawnPVPath.rbegin(); 1521 hepRepXMLWriter->addInstance(); << 1413 G4int drawnMotherDepth; 1522 << 1414 if (ri != drawnPVPath.rend()) { 1523 // Handle Type declaration for Detector G << 1415 // This volume has a mother. 1524 // replacing G4's top geometry level name << 1416 drawnMotherDepth = ri->GetNonCulledDepth(); 1525 // name "Detector Geometry". << 1417 //G4cout << "drawnMotherDepth" << drawnMotherDepth << G4endl; 1526 } << 1418 } else { 1527 else << 1419 // This volume has no mother. Must be a top level volume. 1528 { << 1420 drawnMotherDepth = -1; 1529 // G4cout << "CurrentDepth" << currentDep << 1421 //G4cout << "Mother must be very top" << G4endl; 1530 // G4cout << "currentName" << pCurrentPV- << 1422 } 1531 if(strcmp("Detector Geometry", hepRepXMLW << 1423 1532 { << 1424 while (drawnMotherDepth < (currentDepth-1)) { 1533 // G4cout << "Adding Det Geom type" << << 1425 G4String culledParentName = "Culled parent of " + pCurrentPV->GetName(); 1534 hepRepXMLWriter->addType("Detector Geom << 1426 //G4cout << "Inserting culled layer " << culledParentName << " at depth:" << drawnMotherDepth+2 << G4endl; 1535 hepRepXMLWriter->addInstance(); << 1427 hepRepXMLWriter->addType(culledParentName, drawnMotherDepth+2); 1536 } << 1428 hepRepXMLWriter->addInstance(); 1537 << 1429 drawnMotherDepth ++; 1538 // Re-insert any layers of the hierarchy << 1430 } 1539 // process. Don't bother checking if same << 1431 } 1540 if(strcmp(hepRepXMLWriter->prevTypeName[c << 1432 1541 pCurrentPV->GetName()) != 0) << 1433 // Add the HepRepType for the current volume. 1542 { << 1434 hepRepXMLWriter->addType(pCurrentPV->GetName(),currentDepth+1); 1543 // G4cout << "Looking for mother of:" < << 1435 hepRepXMLWriter->addInstance(); 1544 typedef G4PhysicalVolumeModel::G4Physic << 1436 1545 typedef std::vector<PVNodeID> PVPath; << 1437 G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance(); 1546 const PVPath& drawnPVPath = pPV << 1438 1547 PVPath::const_reverse_iterator ri = ++d << 1439 if (fpVisAttribs && (fpVisAttribs->IsVisible()==0) && messenger->getCullInvisibles()) 1548 G4int drawnMotherDepth; << 1440 return; 1549 if(ri != drawnPVPath.rend()) << 1441 1550 { << 1442 // Additional attributes. 1551 // This volume has a mother. << 1443 hepRepXMLWriter->addAttValue("Layer",hepRepXMLWriter->typeDepth); 1552 drawnMotherDepth = ri->GetNonCulledDe << 1444 hepRepXMLWriter->addAttValue("LVol", pCurrentLV->GetName()); 1553 // G4cout << "drawnMotherDepth" << dr << 1445 G4Region* region = pCurrentLV->GetRegion(); 1554 } << 1446 G4String regionName = region? region->GetName(): G4String("No region"); 1555 else << 1447 hepRepXMLWriter->addAttValue("Region", regionName); 1556 { << 1448 hepRepXMLWriter->addAttValue("RootRegion", pCurrentLV->IsRootRegion()); 1557 // This volume has no mother. Must b << 1449 hepRepXMLWriter->addAttValue("Solid", pCurrentLV->GetSolid()->GetName()); 1558 drawnMotherDepth = -1; << 1450 hepRepXMLWriter->addAttValue("EType", pCurrentLV->GetSolid()->GetEntityType()); 1559 // G4cout << "Mother must be very top << 1451 G4Material * material = pPVModel->GetCurrentMaterial(); 1560 } << 1452 G4String matName = material? material->GetName(): G4String("No material"); 1561 << 1453 hepRepXMLWriter->addAttValue("Material", matName); 1562 while(drawnMotherDepth < (currentDepth << 1454 G4double matDensity = material? material->GetDensity(): 0.; 1563 { << 1455 hepRepXMLWriter->addAttValue("Density", matDensity*m3/kg); 1564 G4String culledParentName = "Culled p << 1456 G4State matState = material? material->GetState(): kStateUndefined; 1565 // G4cout << "Inserting culled layer << 1457 hepRepXMLWriter->addAttValue("State", matState); 1566 // depth:" << drawnMotherDepth+2 << G << 1458 G4double matRadlen = material? material->GetRadlen(): 0.; 1567 hepRepXMLWriter->addType(culledParent << 1459 hepRepXMLWriter->addAttValue("Radlen", matRadlen/m); 1568 hepRepXMLWriter->addInstance(); << 1460 } 1569 drawnMotherDepth++; << 1461 1570 } << 1462 hepRepXMLWriter->addAttValue("DrawAs",primName); 1571 } << 1463 1572 << 1464 // Handle color and visibility attributes. 1573 // Add the HepRepType for the current vol << 1465 float redness; 1574 hepRepXMLWriter->addType(pCurrentPV->GetN << 1466 float greenness; 1575 hepRepXMLWriter->addInstance(); << 1467 float blueness; 1576 << 1468 G4bool isVisible; 1577 G4HepRepMessenger* messenger = G4HepRepMe << 1469 1578 << 1470 if (fpVisAttribs || haveVisible) { 1579 if(fpVisAttribs && (fpVisAttribs->IsVisib << 1471 G4Colour colour; 1580 messenger->getCullInvisibles()) << 1472 1581 return; << 1473 if (fpVisAttribs) { 1582 << 1474 colour = fpVisAttribs->GetColour(); 1583 // Additional attributes. << 1475 isVisible = fpVisAttribs->IsVisible(); 1584 hepRepXMLWriter->addAttValue("Layer", hep << 1476 } else { 1585 hepRepXMLWriter->addAttValue("LVol", pCur << 1477 colour = GetColour(visible); 1586 G4Region* region = pCurrentLV->GetRegi << 1478 isVisible = fpViewer-> 1587 G4String regionName = region ? region->Ge << 1479 GetApplicableVisAttributes(visible.GetVisAttributes())->IsVisible(); 1588 hepRepXMLWriter->addAttValue("Region", re << 1480 } 1589 hepRepXMLWriter->addAttValue("RootRegion" << 1481 1590 hepRepXMLWriter->addAttValue("Solid", pCu << 1482 redness = colour.GetRed(); 1591 hepRepXMLWriter->addAttValue("EType", << 1483 greenness = colour.GetGreen(); 1592 pCurrentLV-> << 1484 blueness = colour.GetBlue(); 1593 G4Material* material = pPVModel->GetCurre << 1485 1594 G4String matName = material ? material->G << 1486 // Avoiding drawing anything black on black. 1595 hepRepXMLWriter->addAttValue("Material", << 1487 if (redness==0. && greenness==0. && blueness==0.) { 1596 G4double matDensity = material ? material << 1488 redness = 1.; 1597 hepRepXMLWriter->addAttValue("Density", m << 1489 greenness = 1.; 1598 G4State matState = material ? material->G << 1490 blueness = 1.; 1599 hepRepXMLWriter->addAttValue("State", mat << 1491 } 1600 G4double matRadlen = material ? material- << 1492 } else { 1601 hepRepXMLWriter->addAttValue("Radlen", ma << 1493 #ifdef G4HEPREPFILEDEBUG 1602 } << 1494 G4cout << 1603 << 1495 "G4HepRepFileSceneHandler::AddHepRepInstance using default colour." 1604 hepRepXMLWriter->addAttValue("DrawAs", prim << 1496 << G4endl; 1605 << 1497 #endif 1606 // Handle color and visibility attributes. << 1498 redness = 1.; 1607 float redness; << 1499 greenness = 1.; 1608 float greenness; << 1500 blueness = 1.; 1609 float blueness; << 1501 isVisible = true; 1610 G4bool isVisible; << 1502 } 1611 << 1503 1612 if(fpVisAttribs || haveVisible) << 1504 if (strcmp(primName,"Point")==0) 1613 { << 1505 hepRepXMLWriter->addAttValue("MarkColor",redness,greenness,blueness); 1614 G4Colour colour; << 1506 else 1615 << 1507 hepRepXMLWriter->addAttValue("LineColor",redness,greenness,blueness); 1616 if(fpVisAttribs) << 1508 1617 { << 1509 hepRepXMLWriter->addAttValue("Visibility",isVisible); 1618 colour = fpVisAttribs->GetColour(); << 1510 } 1619 isVisible = fpVisAttribs->IsVisible(); << 1511 1620 } << 1512 1621 else << 1513 void G4HepRepFileSceneHandler::CheckFileOpen() { 1622 { << 1514 #ifdef G4HEPREPFILEDEBUG 1623 colour = visible.GetVisAttributes()->Ge << 1515 G4cout << 1624 isVisible = << 1516 "G4HepRepFileSceneHandler::CheckFileOpen called." 1625 fpViewer->GetApplicableVisAttributes( << 1517 << G4endl; 1626 ->IsVisible(); << 1518 #endif 1627 } << 1519 1628 << 1520 if (!hepRepXMLWriter->isOpen) { 1629 redness = colour.GetRed(); << 1521 G4String newFileSpec; 1630 greenness = colour.GetGreen(); << 1522 1631 blueness = colour.GetBlue(); << 1523 G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance(); 1632 << 1524 1633 // Avoiding drawing anything black on bla << 1525 if (messenger->getOverwrite()) { 1634 if(redness == 0. && greenness == 0. && bl << 1526 newFileSpec = messenger->getFileDir()+messenger->getFileName()+".heprep"; 1635 { << 1527 } else { 1636 redness = 1.; << 1528 newFileSpec = messenger->getFileDir()+messenger->getFileName()+G4UIcommand::ConvertToString(fileCounter)+".heprep"; 1637 greenness = 1.; << 1529 } 1638 blueness = 1.; << 1530 1639 } << 1531 G4cout << "HepRepFile writing to " << newFileSpec << G4endl; 1640 } << 1532 1641 else << 1533 hepRepXMLWriter->open(newFileSpec); 1642 { << 1534 1643 #ifdef G4HEPREPFILEDEBUG << 1535 if (!messenger->getOverwrite()) 1644 G4cout << 1536 fileCounter++; 1645 << "G4HepRepFileSceneHandler::AddHepRep << 1537 1646 << G4endl; << 1538 hepRepXMLWriter->addAttDef("Generator", "HepRep Data Generator", "Physics",""); 1647 #endif << 1539 G4String versionString = G4Version; 1648 redness = 1.; << 1540 versionString = versionString.substr(1,versionString.size()-2); 1649 greenness = 1.; << 1541 versionString = " Geant4 version " + versionString + " " + G4Date; 1650 blueness = 1.; << 1542 hepRepXMLWriter->addAttValue("Generator", versionString); 1651 isVisible = true; << 1543 1652 } << 1544 hepRepXMLWriter->addAttDef("LVol", "Logical Volume", "Physics",""); 1653 << 1545 hepRepXMLWriter->addAttDef("Region", "Cuts Region", "Physics",""); 1654 if(strcmp(primName, "Point") == 0) << 1546 hepRepXMLWriter->addAttDef("RootRegion", "Root Region", "Physics",""); 1655 hepRepXMLWriter->addAttValue("MarkColor", << 1547 hepRepXMLWriter->addAttDef("Solid", "Solid Name", "Physics",""); 1656 else << 1548 hepRepXMLWriter->addAttDef("EType", "Entity Type", "Physics",""); 1657 hepRepXMLWriter->addAttValue("LineColor", << 1549 hepRepXMLWriter->addAttDef("Material", "Material Name", "Physics",""); 1658 << 1550 hepRepXMLWriter->addAttDef("Density", "Material Density", "Physics","kg/m3"); 1659 hepRepXMLWriter->addAttValue("Visibility", << 1551 hepRepXMLWriter->addAttDef("State", "Material State", "Physics",""); 1660 } << 1552 hepRepXMLWriter->addAttDef("Radlen", "Material Radiation Length", "Physics","m"); 1661 << 1553 } 1662 void G4HepRepFileSceneHandler::CheckFileOpen( << 1554 } 1663 { << 1555 1664 #ifdef G4HEPREPFILEDEBUG << 1556 1665 G4cout << "G4HepRepFileSceneHandler::CheckF << 1557 void G4HepRepFileSceneHandler::ClearTransientStore() { 1666 #endif << 1558 // This is typically called after an update and before drawing hits 1667 << 1559 // of the next event. To simulate the clearing of "transients" 1668 if(!hepRepXMLWriter->isOpen) << 1560 // (hits, etc.) the detector is redrawn... 1669 { << 1561 if (fpViewer) { 1670 G4String newFileSpec; << 1562 fpViewer -> SetView(); 1671 << 1563 fpViewer -> ClearView(); 1672 G4HepRepMessenger* messenger = G4HepRepMe << 1564 fpViewer -> DrawView(); 1673 << 1565 } 1674 if(messenger->getOverwrite()) << 1675 { << 1676 newFileSpec = << 1677 messenger->getFileDir() + messenger-> << 1678 } << 1679 else << 1680 { << 1681 newFileSpec = messenger->getFileDir() + << 1682 G4UIcommand::ConvertToStr << 1683 } << 1684 << 1685 G4cout << "HepRepFile writing to " << new << 1686 << 1687 hepRepXMLWriter->open(newFileSpec); << 1688 << 1689 if(!messenger->getOverwrite()) << 1690 fileCounter++; << 1691 << 1692 hepRepXMLWriter->addAttDef("Generator", " << 1693 ""); << 1694 G4String versionString = G4Version; << 1695 versionString = versionString.su << 1696 versionString = " Geant4 version " + vers << 1697 hepRepXMLWriter->addAttValue("Generator", << 1698 << 1699 hepRepXMLWriter->addAttDef("LVol", "Logic << 1700 hepRepXMLWriter->addAttDef("Region", "Cut << 1701 hepRepXMLWriter->addAttDef("RootRegion", << 1702 hepRepXMLWriter->addAttDef("Solid", "Soli << 1703 hepRepXMLWriter->addAttDef("EType", "Enti << 1704 hepRepXMLWriter->addAttDef("Material", "M << 1705 hepRepXMLWriter->addAttDef("Density", "Ma << 1706 "kg/m3"); << 1707 hepRepXMLWriter->addAttDef("State", "Mate << 1708 hepRepXMLWriter->addAttDef("Radlen", "Mat << 1709 "m"); << 1710 } << 1711 } << 1712 << 1713 void G4HepRepFileSceneHandler::ClearTransient << 1714 { << 1715 // This is typically called after an update << 1716 // of the next event. To simulate the clea << 1717 // (hits, etc.) the detector is redrawn... << 1718 if(fpViewer) << 1719 { << 1720 fpViewer->SetView(); << 1721 fpViewer->ClearView(); << 1722 fpViewer->DrawView(); << 1723 } << 1724 } 1566 } 1725 1567