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