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

#include <G4HepRepFileSceneHandler.hh>

+ Inheritance diagram for G4HepRepFileSceneHandler:

Public Member Functions

 G4HepRepFileSceneHandler (G4VGraphicsSystem &system, const G4String &name)
 
virtual ~G4HepRepFileSceneHandler ()
 
void AddSolid (const G4Box &)
 
void AddSolid (const G4Cons &)
 
void AddSolid (const G4Tubs &)
 
void AddSolid (const G4Trd &)
 
void AddSolid (const G4Trap &)
 
void AddSolid (const G4Sphere &)
 
void AddSolid (const G4Para &)
 
void AddSolid (const G4Torus &)
 
void AddSolid (const G4Polycone &)
 
void AddSolid (const G4Polyhedra &)
 
void AddSolid (const G4Orb &)
 
void AddSolid (const G4Ellipsoid &)
 
void AddSolid (const G4TessellatedSolid &)
 
void AddSolid (const G4VSolid &)
 
void AddCompound (const G4VTrajectory &)
 
void InitTrajectory ()
 
void AddCompound (const G4VHit &)
 
void InitHit ()
 
void AddPrimitive (const G4Polyline &)
 
void AddPrimitive (const G4Text &)
 
void AddPrimitive (const G4Circle &)
 
void AddPrimitive (const G4Square &)
 
void AddPrimitive (const G4Polyhedron &)
 
void AddPrimitive (const G4Polymarker &)
 
void BeginModeling ()
 
void EndModeling ()
 
void BeginPrimitives2D (const G4Transform3D &objectTransformation)
 
void EndPrimitives2D ()
 
void ClearTransientStore ()
 
G4HepRepFileXMLWriter * GetHepRepXMLWriter ()
 
virtual void AddCompound (const G4VTrajectory &)
 
virtual void AddCompound (const G4VHit &)
 
virtual void AddCompound (const G4VDigi &)
 
virtual void AddCompound (const G4THitsMap< G4double > &)
 
virtual void AddCompound (const G4THitsMap< G4StatDouble > &)
 
virtual void AddCompound (const G4Mesh &)
 
virtual void AddPrimitive (const G4Polyline &)=0
 
virtual void AddPrimitive (const G4Text &)=0
 
virtual void AddPrimitive (const G4Circle &)=0
 
virtual void AddPrimitive (const G4Square &)=0
 
virtual void AddPrimitive (const G4Polymarker &)
 
virtual void AddPrimitive (const G4Polyhedron &)=0
 
virtual void AddPrimitive (const G4Plotter &)
 
- Public Member Functions inherited from G4VSceneHandler
 G4VSceneHandler (G4VGraphicsSystem &system, G4int id, const G4String &name="")
 
virtual ~G4VSceneHandler ()
 
virtual void PreAddSolid (const G4Transform3D &objectTransformation, const G4VisAttributes &)
 
virtual void PostAddSolid ()
 
virtual void AddSolid (const G4Box &)
 
virtual void AddSolid (const G4Cons &)
 
virtual void AddSolid (const G4Orb &)
 
virtual void AddSolid (const G4Para &)
 
virtual void AddSolid (const G4Sphere &)
 
virtual void AddSolid (const G4Torus &)
 
virtual void AddSolid (const G4Trap &)
 
virtual void AddSolid (const G4Trd &)
 
virtual void AddSolid (const G4Tubs &)
 
virtual void AddSolid (const G4Ellipsoid &)
 
virtual void AddSolid (const G4Polycone &)
 
virtual void AddSolid (const G4Polyhedra &)
 
virtual void AddSolid (const G4TessellatedSolid &)
 
virtual void AddSolid (const G4VSolid &)
 
virtual void AddCompound (const G4VTrajectory &)
 
virtual void AddCompound (const G4VHit &)
 
virtual void AddCompound (const G4VDigi &)
 
virtual void AddCompound (const G4THitsMap< G4double > &)
 
virtual void AddCompound (const G4THitsMap< G4StatDouble > &)
 
virtual void AddCompound (const G4Mesh &)
 
virtual void BeginModeling ()
 
virtual void EndModeling ()
 
virtual void BeginPrimitives (const G4Transform3D &objectTransformation=G4Transform3D())
 
virtual void EndPrimitives ()
 
virtual void BeginPrimitives2D (const G4Transform3D &objectTransformation=G4Transform3D())
 
virtual void EndPrimitives2D ()
 
virtual void AddPrimitive (const G4Polyline &)=0
 
virtual void AddPrimitive (const G4Text &)=0
 
virtual void AddPrimitive (const G4Circle &)=0
 
virtual void AddPrimitive (const G4Square &)=0
 
virtual void AddPrimitive (const G4Polymarker &)
 
virtual void AddPrimitive (const G4Polyhedron &)=0
 
virtual void AddPrimitive (const G4Plotter &)
 
virtual const G4VisExtent & GetExtent () const
 
const G4String & GetName () const
 
G4int GetSceneHandlerId () const
 
G4int GetViewCount () const
 
G4VGraphicsSystem * GetGraphicsSystem () const
 
G4Scene * GetScene () const
 
const G4ViewerList & GetViewerList () const
 
G4VModel * GetModel () const
 
G4VViewer * GetCurrentViewer () const
 
G4bool GetMarkForClearingTransientStore () const
 
G4bool IsReadyForTransients () const
 
G4bool GetTransientsDrawnThisEvent () const
 
G4bool GetTransientsDrawnThisRun () const
 
const G4Transform3D & GetObjectTransformation () const
 
void SetName (const G4String &)
 
void SetCurrentViewer (G4VViewer *)
 
virtual void SetScene (G4Scene *)
 
G4ViewerList & SetViewerList ()
 
void SetModel (G4VModel *)
 
void SetMarkForClearingTransientStore (G4bool)
 
void SetTransientsDrawnThisEvent (G4bool)
 
void SetTransientsDrawnThisRun (G4bool)
 
void SetObjectTransformation (const G4Transform3D &)
 
const G4Colour & GetColour ()
 
const G4Colour & GetColor ()
 
const G4Colour & GetColour (const G4Visible &)
 
const G4Colour & GetColor (const G4Visible &)
 
const G4Colour & GetTextColour (const G4Text &)
 
const G4Colour & GetTextColor (const G4Text &)
 
G4double GetLineWidth (const G4VisAttributes *)
 
G4ViewParameters::DrawingStyle GetDrawingStyle (const G4VisAttributes *)
 
G4int GetNumberOfCloudPoints (const G4VisAttributes *) const
 
G4bool GetAuxEdgeVisible (const G4VisAttributes *)
 
G4int GetNoOfSides (const G4VisAttributes *)
 
G4double GetMarkerSize (const G4VMarker &, MarkerSizeType &)
 
G4double GetMarkerDiameter (const G4VMarker &, MarkerSizeType &)
 
G4double GetMarkerRadius (const G4VMarker &, MarkerSizeType &)
 
G4ModelingParameters * CreateModelingParameters ()
 
void DrawEvent (const G4Event *)
 
void DrawEndOfRunModels ()
 
template<class T >
void AddSolidT (const T &solid)
 
template<class T >
void AddSolidWithAuxiliaryEdges (const T &solid)
 
G4int IncrementViewCount ()
 
virtual void ClearStore ()
 
virtual void ClearTransientStore ()
 
void AddViewerToList (G4VViewer *pView)
 
void RemoveViewerFromList (G4VViewer *pView)
 
- Public Member Functions inherited from G4VGraphicsScene
 G4VGraphicsScene ()
 
virtual ~G4VGraphicsScene ()
 
virtual void PreAddSolid (const G4Transform3D &objectTransformation, const G4VisAttributes &visAttribs)=0
 
virtual void PostAddSolid ()=0
 
virtual void AddSolid (const G4Box &)=0
 
virtual void AddSolid (const G4Cons &)=0
 
virtual void AddSolid (const G4Orb &)=0
 
virtual void AddSolid (const G4Para &)=0
 
virtual void AddSolid (const G4Sphere &)=0
 
virtual void AddSolid (const G4Torus &)=0
 
virtual void AddSolid (const G4Trap &)=0
 
virtual void AddSolid (const G4Trd &)=0
 
virtual void AddSolid (const G4Tubs &)=0
 
virtual void AddSolid (const G4Ellipsoid &)=0
 
virtual void AddSolid (const G4Polycone &)=0
 
virtual void AddSolid (const G4Polyhedra &)=0
 
virtual void AddSolid (const G4TessellatedSolid &)=0
 
virtual void AddSolid (const G4VSolid &)=0
 
virtual void AddCompound (const G4VTrajectory &)=0
 
virtual void AddCompound (const G4VHit &)=0
 
virtual void AddCompound (const G4VDigi &)=0
 
virtual void AddCompound (const G4THitsMap< G4double > &)=0
 
virtual void AddCompound (const G4THitsMap< G4StatDouble > &)=0
 
virtual void AddCompound (const G4Mesh &)=0
 
virtual void BeginPrimitives (const G4Transform3D &objectTransformation=G4Transform3D())=0
 
virtual void EndPrimitives ()=0
 
virtual void BeginPrimitives2D (const G4Transform3D &objectTransformation=G4Transform3D())=0
 
virtual void EndPrimitives2D ()=0
 
virtual void AddPrimitive (const G4Polyline &)=0
 
virtual void AddPrimitive (const G4Text &)=0
 
virtual void AddPrimitive (const G4Circle &)=0
 
virtual void AddPrimitive (const G4Square &)=0
 
virtual void AddPrimitive (const G4Polymarker &)=0
 
virtual void AddPrimitive (const G4Polyhedron &)=0
 
virtual void AddPrimitive (const G4Plotter &)=0
 
virtual const G4VisExtent & GetExtent () const
 

Static Protected Attributes

static G4int fSceneIdCount = 0
 

Additional Inherited Members

- Public Types inherited from G4VSceneHandler
enum  MarkerSizeType { world , screen }
 
- Protected Member Functions inherited from G4VSceneHandler
virtual void ProcessScene ()
 
virtual void RequestPrimitives (const G4VSolid &solid)
 
virtual G4DisplacedSolid * CreateSectionSolid ()
 
virtual G4DisplacedSolid * CreateCutawaySolid ()
 
void LoadAtts (const G4Visible &, G4AttHolder *)
 
void StandardSpecialMeshRendering (const G4Mesh &)
 
void Draw3DRectMeshAsDots (const G4Mesh &)
 
void Draw3DRectMeshAsSurfaces (const G4Mesh &)
 
void DrawTetMeshAsDots (const G4Mesh &)
 
void DrawTetMeshAsSurfaces (const G4Mesh &)
 
G4ThreeVector GetPointInBox (const G4ThreeVector &pos, G4double halfX, G4double halfY, G4double halfZ) const
 
G4ThreeVector GetPointInTet (const std::vector< G4ThreeVector > &vertices) const
 
- Protected Attributes inherited from G4VSceneHandler
G4VGraphicsSystem & fSystem
 
const G4int fSceneHandlerId
 
G4String fName
 
G4int fViewCount
 
G4ViewerList fViewerList
 
G4VViewer * fpViewer
 
G4Scene * fpScene
 
G4bool fMarkForClearingTransientStore
 
G4bool fReadyForTransients
 
G4bool fTransientsDrawnThisEvent
 
G4bool fTransientsDrawnThisRun
 
G4bool fProcessingSolid
 
G4bool fProcessing2D
 
G4VModel * fpModel
 
G4Transform3D fObjectTransformation
 
G4int fNestingDepth
 
const G4VisAttributes * fpVisAttribs
 
const G4Transform3D fIdentityTransformation
 

Detailed Description

Definition at line 58 of file G4HepRepFileSceneHandler.hh.

Constructor & Destructor Documentation

◆ G4HepRepFileSceneHandler()

G4HepRepFileSceneHandler::G4HepRepFileSceneHandler ( G4VGraphicsSystem &  system,
const G4String &  name 
)

Definition at line 69 of file G4HepRepFileSceneHandler.cc.

71 : G4VSceneHandler(system, fSceneIdCount++, name)
72{
73 hepRepXMLWriter = ((G4HepRepFile*) (&system))->GetHepRepXMLWriter();
74 fileCounter = 0;
75
76 inPrimitives2D = false;
77 warnedAbout3DText = false;
78 warnedAbout2DMarkers = false;
79 haveVisible = false;
80 drawingTraj = false;
81 doneInitTraj = false;
82 drawingHit = false;
83 doneInitHit = false;
84 trajContext = 0;
85 trajAttValues = 0;
86 trajAttDefs = 0;
87 hitAttValues = 0;
88 hitAttDefs = 0;
89}
G4HepRepFileSceneHandler::GetHepRepXMLWriter
G4HepRepFileXMLWriter * GetHepRepXMLWriter()
Definition: G4HepRepFileSceneHandler.cc:1389

◆ ~G4HepRepFileSceneHandler()

G4HepRepFileSceneHandler::~G4HepRepFileSceneHandler ( )
virtual

Definition at line 91 of file G4HepRepFileSceneHandler.cc.

91{}

Member Function Documentation

◆ AddCompound() [1/8]

void G4VSceneHandler::AddCompound ( const G4Mesh &  mesh)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 133 of file G4VSceneHandler.cc.

432{
433 G4warn <<
434 "There has been an attempt to draw a mesh with option \""
435 << fpViewer->GetViewParameters().GetSpecialMeshRenderingOption()
436 << "\":\n" << mesh
437 << "but it is not of a recognised type or is not implemented"
438 "\nby the current graphics driver. Instead we draw its"
439 "\ncontainer \"" << mesh.GetContainerVolume()->GetName() << "\"."
440 << G4endl;
441 const auto& pv = mesh.GetContainerVolume();
442 const auto& lv = pv->GetLogicalVolume();
443 const auto& solid = lv->GetSolid();
444 const auto& transform = mesh.GetTransform();
445 // Make sure container is visible
446 G4VisAttributes tmpVisAtts; // Visible, white, not forced.
447 const auto& saveVisAtts = lv->GetVisAttributes();
448 if (saveVisAtts) {
449 tmpVisAtts = *saveVisAtts;
450 tmpVisAtts.SetVisibility(true);
451 auto colour = saveVisAtts->GetColour();
452 colour.SetAlpha(1.);
453 tmpVisAtts.SetColour(colour);
454 }
455 // Draw container
456 PreAddSolid(transform,tmpVisAtts);
457 solid->DescribeYourselfTo(*this);
458 PostAddSolid();
459 // Restore vis attributes
460 lv->SetVisAttributes(saveVisAtts);
461}
G4warn
#define G4warn
Definition: G4Scene.cc:41
G4endl
#define G4endl
Definition: G4ios.hh:57
G4LogicalVolume::GetSolid
G4VSolid * GetSolid() const
Definition: G4LogicalVolume.cc:413
G4Mesh::GetContainerVolume
G4VPhysicalVolume * GetContainerVolume() const
Definition: G4Mesh.hh:73
G4Mesh::GetTransform
const G4Transform3D & GetTransform() const
Definition: G4Mesh.hh:77
G4VPhysicalVolume::GetLogicalVolume
G4LogicalVolume * GetLogicalVolume() const
G4VPhysicalVolume::GetName
const G4String & GetName() const
G4VSceneHandler::PreAddSolid
virtual void PreAddSolid(const G4Transform3D &objectTransformation, const G4VisAttributes &)
Definition: G4VSceneHandler.cc:149
G4VSceneHandler::fpViewer
G4VViewer * fpViewer
Definition: G4VSceneHandler.hh:439
G4VSceneHandler::PostAddSolid
virtual void PostAddSolid()
Definition: G4VSceneHandler.cc:156
G4VViewer::GetViewParameters
const G4ViewParameters & GetViewParameters() const
G4ViewParameters::GetSpecialMeshRenderingOption
SMROption GetSpecialMeshRenderingOption() const
G4VisAttributes::SetColour
void SetColour(const G4Colour &)
G4VisAttributes::SetVisibility
void SetVisibility(G4bool=true)

◆ AddCompound() [2/8]

void G4VSceneHandler::AddCompound ( const G4THitsMap< G4double > &  hits)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 131 of file G4VSceneHandler.cc.

345 {
346 using MeshScoreMap = G4VScoringMesh::MeshScoreMap;
347 //G4cout << "AddCompound: hits: " << &hits << G4endl;
348 G4bool scoreMapHits = false;
349 G4ScoringManager* scoringManager = G4ScoringManager::GetScoringManagerIfExist();
350 if (scoringManager) {
351 std::size_t nMeshes = scoringManager->GetNumberOfMesh();
352 for (std::size_t iMesh = 0; iMesh < nMeshes; ++iMesh) {
353 G4VScoringMesh* mesh = scoringManager->GetMesh((G4int)iMesh);
354 if (mesh && mesh->IsActive()) {
355 MeshScoreMap scoreMap = mesh->GetScoreMap();
356 const G4String& mapNam = const_cast<G4THitsMap<G4double>&>(hits).GetName();
357 for(MeshScoreMap::const_iterator i = scoreMap.cbegin();
358 i != scoreMap.cend(); ++i) {
359 const G4String& scoreMapName = i->first;
360 if (scoreMapName == mapNam) {
361 G4DefaultLinearColorMap colorMap("G4VSceneHandlerColorMap");
362 scoreMapHits = true;
363 mesh->DrawMesh(scoreMapName, &colorMap);
364 }
365 }
366 }
367 }
368 }
369 if (scoreMapHits) {
370 static G4bool first = true;
371 if (first) {
372 first = false;
373 G4cout <<
374 "Scoring map drawn with default parameters."
375 "\n To get gMocren file for gMocren browser:"
376 "\n /vis/open gMocrenFile"
377 "\n /vis/viewer/flush"
378 "\n Many other options available with /score/draw... commands."
379 "\n You might want to \"/vis/viewer/set/autoRefresh false\"."
380 << G4endl;
381 }
382 } else { // Not score map hits. Just call DrawAllHits.
383 // Cast away const because DrawAllHits is non-const!!!!
384 const_cast<G4THitsMap<G4double>&>(hits).DrawAllHits();
385 }
386}
G4bool
bool G4bool
Definition: G4Types.hh:86
G4int
int G4int
Definition: G4Types.hh:85
G4cout
G4GLOB_DLL std::ostream G4cout
G4ScoringManager::GetMesh
G4VScoringMesh * GetMesh(G4int i) const
Definition: G4ScoringManager.hh:119
G4ScoringManager::GetNumberOfMesh
size_t GetNumberOfMesh() const
Definition: G4ScoringManager.hh:112
G4ScoringManager::GetScoringManagerIfExist
static G4ScoringManager * GetScoringManagerIfExist()
Definition: G4ScoringManager.cc:51
G4VSceneHandler::GetName
const G4String & GetName() const
G4VScoringMesh::IsActive
G4bool IsActive() const
Definition: G4VScoringMesh.hh:87
G4VScoringMesh::MeshScoreMap
std::map< G4String, RunScore * > MeshScoreMap
Definition: G4VScoringMesh.hh:68
G4VScoringMesh::DrawMesh
void DrawMesh(const G4String &psName, G4VScoreColorMap *colorMap, G4int axflg=111)
Definition: G4VScoringMesh.cc:347
G4VScoringMesh::GetScoreMap
MeshScoreMap GetScoreMap() const
Definition: G4VScoringMesh.hh:180

◆ AddCompound() [3/8]

void G4VSceneHandler::AddCompound ( const G4THitsMap< G4StatDouble > &  hits)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 132 of file G4VSceneHandler.cc.

388 {
389 using MeshScoreMap = G4VScoringMesh::MeshScoreMap;
390 //G4cout << "AddCompound: hits: " << &hits << G4endl;
391 G4bool scoreMapHits = false;
392 G4ScoringManager* scoringManager = G4ScoringManager::GetScoringManagerIfExist();
393 if (scoringManager) {
394 std::size_t nMeshes = scoringManager->GetNumberOfMesh();
395 for (std::size_t iMesh = 0; iMesh < nMeshes; ++iMesh) {
396 G4VScoringMesh* mesh = scoringManager->GetMesh((G4int)iMesh);
397 if (mesh && mesh->IsActive()) {
398 MeshScoreMap scoreMap = mesh->GetScoreMap();
399 for(MeshScoreMap::const_iterator i = scoreMap.cbegin();
400 i != scoreMap.cend(); ++i) {
401 const G4String& scoreMapName = i->first;
402 const G4THitsMap<G4StatDouble>* foundHits = i->second;
403 if (foundHits == &hits) {
404 G4DefaultLinearColorMap colorMap("G4VSceneHandlerColorMap");
405 scoreMapHits = true;
406 mesh->DrawMesh(scoreMapName, &colorMap);
407 }
408 }
409 }
410 }
411 }
412 if (scoreMapHits) {
413 static G4bool first = true;
414 if (first) {
415 first = false;
416 G4cout <<
417 "Scoring map drawn with default parameters."
418 "\n To get gMocren file for gMocren browser:"
419 "\n /vis/open gMocrenFile"
420 "\n /vis/viewer/flush"
421 "\n Many other options available with /score/draw... commands."
422 "\n You might want to \"/vis/viewer/set/autoRefresh false\"."
423 << G4endl;
424 }
425 } else { // Not score map hits. Just call DrawAllHits.
426 // Cast away const because DrawAllHits is non-const!!!!
427 const_cast<G4THitsMap<G4StatDouble>&>(hits).DrawAllHits();
428 }
429}

◆ AddCompound() [4/8]

void G4VSceneHandler::AddCompound ( const G4VDigi &  digi)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 130 of file G4VSceneHandler.cc.

340 {
341 // Cast away const because Draw is non-const!!!!
342 const_cast<G4VDigi&>(digi).Draw();
343}

◆ AddCompound() [5/8]

void G4VSceneHandler::AddCompound ( const G4VHit &  hit)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 129 of file G4VSceneHandler.cc.

335 {
336 // Cast away const because Draw is non-const!!!!
337 const_cast<G4VHit&>(hit).Draw();
338}
G4VHit
Definition: G4VHit.hh:48

◆ AddCompound() [6/8]

void G4HepRepFileSceneHandler::AddCompound ( const G4VHit &  hit)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 929 of file G4HepRepFileSceneHandler.cc.

930{
931#ifdef G4HEPREPFILEDEBUG
932 G4cout << "G4HepRepFileSceneHandler::AddCompound(G4VHit&) " << G4endl;
933#endif
934
935 // Pointers to hold hit attribute values and definitions.
936 std::vector<G4AttValue>* rawHitAttValues = hit.CreateAttValues();
937 hitAttValues = new std::vector<G4AttValue>;
938 hitAttDefs = new std::map<G4String, G4AttDef>;
939
940 // Iterators to use with attribute values and definitions.
941 std::vector<G4AttValue>::iterator iAttVal;
942 std::map<G4String, G4AttDef>::const_iterator iAttDef;
943
944 // Get hit attributes and definitions in standard HepRep style
945 // (uniform units, 3Vectors decomposed).
946 if(rawHitAttValues)
947 {
948 G4bool error = G4AttCheck(rawHitAttValues, hit.GetAttDefs())
949 .Standard(hitAttValues, hitAttDefs);
950 if(error)
951 {
952 G4cout << "G4HepRepFileSceneHandler::AddCompound(hit):"
953 "\nERROR found during conversion to standard hit attributes."
954 << G4endl;
955 }
956#ifdef G4HEPREPFILEDEBUG
957 G4cout << "G4HepRepFileSceneHandler::AddCompound(hit): standardised "
958 "attributes:\n"
959 << G4AttCheck(hitAttValues, hitAttDefs) << G4endl;
960#endif
961 delete rawHitAttValues;
962 }
963
964 // Open the HepRep output file if it is not already open.
965 CheckFileOpen();
966
967 // Add the Event Data Type if it hasn't already been added.
968 if(strcmp("Event Data", hepRepXMLWriter->prevTypeName[0]) != 0)
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() && !found; ++iAttVal)
981 {
982 if(strcmp(iAttVal->GetName(), "HitType") == 0)
983 {
984 hitType = iAttVal->GetValue();
985 found = true;
986 }
987 }
988 }
989
990 // Add the Hits Type.
991 G4String previousName = hepRepXMLWriter->prevTypeName[1];
992 hepRepXMLWriter->addType(hitType, 1);
993
994 // If this is the first hit of this event,
995 // specify attribute values common to all hits.
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 attDefs without needing a reference
1002 // from any particular hit, but don't know how to do that. Write out hit
1003 // attribute definitions.
1004 if(hitAttValues && hitAttDefs)
1005 {
1006 for(iAttVal = hitAttValues->begin(); iAttVal != hitAttValues->end();
1007 ++iAttVal)
1008 {
1009 iAttDef = hitAttDefs->find(iAttVal->GetName());
1010 if(iAttDef != hitAttDefs->end())
1011 {
1012 // Protect against incorrect use of Category. Anything value other
1013 // than the standard ones will be considered to be in the physics
1014 // category.
1015 G4String category = iAttDef->second.GetCategory();
1016 if(strcmp(category, "Draw") != 0 &&
1017 strcmp(category, "Physics") != 0 &&
1018 strcmp(category, "Association") != 0 &&
1019 strcmp(category, "PickAction") != 0)
1020 category = "Physics";
1021 hepRepXMLWriter->addAttDef(iAttVal->GetName(),
1022 iAttDef->second.GetDesc(), category,
1023 iAttDef->second.GetExtra());
1024 }
1025 }
1026 }
1027 } // end of special treatment for when this is the first hit.
1028
1029 // Now that we have written out all of the attributes that are based on the
1030 // hit's particulars, call base class to deconstruct hit into a primitives.
1031 drawingHit = true;
1032 doneInitHit = false;
1033 G4VSceneHandler::AddCompound(hit); // Invoke default action.
1034 drawingHit = false;
1035}
G4AttCheck::Standard
G4bool Standard(std::vector< G4AttValue > *standardValues, std::map< G4String, G4AttDef > *standardDefinitions) const
Definition: G4AttCheck.cc:348
G4HepRepFileXMLWriter::addAttValue
void addAttValue(const char *name, const char *value)
Definition: G4HepRepFileXMLWriter.cc:242
G4HepRepFileXMLWriter::addType
void addType(const char *name, int newTypeDepth)
Definition: G4HepRepFileXMLWriter.cc:71
G4HepRepFileXMLWriter::addAttDef
void addAttDef(const char *name, const char *desc, const char *type, const char *extra)
Definition: G4HepRepFileXMLWriter.cc:221
G4VHit::CreateAttValues
virtual std::vector< G4AttValue > * CreateAttValues() const
Definition: G4VHit.hh:64
G4VHit::GetAttDefs
virtual const std::map< G4String, G4AttDef > * GetAttDefs() const
Definition: G4VHit.hh:58
G4VSceneHandler::AddCompound
virtual void AddCompound(const G4VTrajectory &)
Definition: G4VSceneHandler.cc:323

◆ AddCompound() [7/8]

void G4VSceneHandler::AddCompound ( const G4VTrajectory &  traj)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 128 of file G4VSceneHandler.cc.

323 {
324 G4TrajectoriesModel* trajectoriesModel =
325 dynamic_cast<G4TrajectoriesModel*>(fpModel);
326 if (trajectoriesModel)
327 traj.DrawTrajectory();
328 else {
329 G4Exception
330 ("G4VSceneHandler::AddCompound(const G4VTrajectory&)",
331 "visman0105", FatalException, "Not a G4TrajectoriesModel.");
332 }
333}
FatalException
@ FatalException
Definition: G4ExceptionSeverity.hh:61
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.cc:59
G4VTrajectory::DrawTrajectory
virtual void DrawTrajectory() const
Definition: G4VTrajectory.cc:120

◆ AddCompound() [8/8]

void G4HepRepFileSceneHandler::AddCompound ( const G4VTrajectory &  traj)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 517 of file G4HepRepFileSceneHandler.cc.

518{
519#ifdef G4HEPREPFILEDEBUG
520 G4cout << "G4HepRepFileSceneHandler::AddCompound(const G4VTrajectory&) "
521 << G4endl;
522#endif
523
524 G4TrajectoriesModel* pTrModel = dynamic_cast<G4TrajectoriesModel*>(fpModel);
525 if(!pTrModel)
526 G4Exception("G4HepRepFileSceneHandler::AddCompound(const G4VTrajectory&)",
527 "vis-HepRep0001", FatalException, "Not a G4TrajectoriesModel.");
528
529 // Pointers to hold trajectory attribute values and definitions.
530 std::vector<G4AttValue>* rawTrajAttValues = traj.CreateAttValues();
531 trajAttValues = new std::vector<G4AttValue>;
532 trajAttDefs = new std::map<G4String, G4AttDef>;
533
534 // Iterators to use with attribute values and definitions.
535 std::vector<G4AttValue>::iterator iAttVal;
536 std::map<G4String, G4AttDef>::const_iterator iAttDef;
537 G4int i;
538
539 // Get trajectory attributes and definitions in standard HepRep style
540 // (uniform units, 3Vectors decomposed).
541 if(rawTrajAttValues)
542 {
543 G4bool error = G4AttCheck(rawTrajAttValues, traj.GetAttDefs())
544 .Standard(trajAttValues, trajAttDefs);
545 if(error)
546 {
547 G4cout
548 << "G4HepRepFileSceneHandler::AddCompound(traj):"
549 "\nERROR found during conversion to standard trajectory attributes."
550 << G4endl;
551 }
552#ifdef G4HEPREPFILEDEBUG
553 G4cout << "G4HepRepFileSceneHandler::AddCompound(traj): standardised "
554 "attributes:\n"
555 << G4AttCheck(trajAttValues, trajAttDefs) << G4endl;
556#endif
557 delete rawTrajAttValues;
558 }
559
560 // Open the HepRep output file if it is not already open.
561 CheckFileOpen();
562
563 // Add the Event Data Type if it hasn't already been added.
564 if(strcmp("Event Data", hepRepXMLWriter->prevTypeName[0]) != 0)
565 {
566 hepRepXMLWriter->addType("Event Data", 0);
567 hepRepXMLWriter->addInstance();
568 }
569
570 // Add the Trajectories Type.
571 G4String previousName = hepRepXMLWriter->prevTypeName[1];
572 hepRepXMLWriter->addType("Trajectories", 1);
573
574 // If this is the first trajectory of this event,
575 // specify attribute values common to all trajectories.
576 if(strcmp("Trajectories", previousName) != 0)
577 {
578 hepRepXMLWriter->addAttValue("Layer", 100);
579
580 // Take all Trajectory attDefs from first trajectory.
581 // Would rather be able to get these attDefs without needing a reference
582 // from any particular trajectory, but don't know how to do that. Write out
583 // trajectory attribute definitions.
584 if(trajAttValues && trajAttDefs)
585 {
586 for(iAttVal = trajAttValues->begin(); iAttVal != trajAttValues->end();
587 ++iAttVal)
588 {
589 iAttDef = trajAttDefs->find(iAttVal->GetName());
590 if(iAttDef != trajAttDefs->end())
591 {
592 // Protect against incorrect use of Category. Anything value other
593 // than the standard ones will be considered to be in the physics
594 // category.
595 G4String category = iAttDef->second.GetCategory();
596 if(strcmp(category, "Draw") != 0 &&
597 strcmp(category, "Physics") != 0 &&
598 strcmp(category, "Association") != 0 &&
599 strcmp(category, "PickAction") != 0)
600 category = "Physics";
601 hepRepXMLWriter->addAttDef(iAttVal->GetName(),
602 iAttDef->second.GetDesc(), category,
603 iAttDef->second.GetExtra());
604 }
605 }
606 }
607
608 // Take all TrajectoryPoint attDefs from first point of first trajectory.
609 // Would rather be able to get these attDefs without needing a reference
610 // from any particular point, but don't know how to do that.
611 if((trajContext->GetDrawStepPts() || trajContext->GetDrawAuxPts()) &&
612 traj.GetPointEntries() > 0)
613 {
614 G4VTrajectoryPoint* aTrajectoryPoint = traj.GetPoint(0);
615
616 // Pointers to hold trajectory point attribute values and definitions.
617 std::vector<G4AttValue>* rawPointAttValues =
618 aTrajectoryPoint->CreateAttValues();
619 std::vector<G4AttValue>* pointAttValues = new std::vector<G4AttValue>;
620 std::map<G4String, G4AttDef>* pointAttDefs =
621 new std::map<G4String, G4AttDef>;
622
623 // Get first trajectory point's attributes and definitions in standard
624 // HepRep style (uniform units, 3Vectors decomposed).
625 if(rawPointAttValues)
626 {
627 G4bool error =
628 G4AttCheck(rawPointAttValues, aTrajectoryPoint->GetAttDefs())
629 .Standard(pointAttValues, pointAttDefs);
630 if(error)
631 {
632 G4cout << "G4HepRepFileSceneHandler::AddCompound(traj):"
633 "\nERROR found during conversion to standard first point "
634 "attributes."
635 << G4endl;
636 }
637
638 // Write out point attribute definitions.
639 if(pointAttValues && pointAttDefs)
640 {
641 for(iAttVal = pointAttValues->begin();
642 iAttVal != pointAttValues->end(); ++iAttVal)
643 {
644 iAttDef = pointAttDefs->find(iAttVal->GetName());
645 if(iAttDef != pointAttDefs->end())
646 {
647 // Protect against incorrect use of Category. Anything value
648 // other than the standard ones will be considered to be in the
649 // physics category.
650 G4String category = iAttDef->second.GetCategory();
651 if(strcmp(category, "Draw") != 0 &&
652 strcmp(category, "Physics") != 0 &&
653 strcmp(category, "Association") != 0 &&
654 strcmp(category, "PickAction") != 0)
655 category = "Physics";
656 // Do not write out the Aux or Pos attribute. Aux does not
657 // conform to the HepRep rule that each object can have only one
658 // instance of a given AttValue. Both of these attributes are
659 // redundant to actual position information of the point.
660 if(strcmp(iAttVal->GetName(), "Aux-X") != 0 &&
661 strcmp(iAttVal->GetName(), "Aux-Y") != 0 &&
662 strcmp(iAttVal->GetName(), "Aux-Z") != 0 &&
663 strcmp(iAttVal->GetName(), "Pos-X") != 0 &&
664 strcmp(iAttVal->GetName(), "Pos-Y") != 0 &&
665 strcmp(iAttVal->GetName(), "Pos-Z") != 0)
666 hepRepXMLWriter->addAttDef(iAttVal->GetName(),
667 iAttDef->second.GetDesc(), category,
668 iAttDef->second.GetExtra());
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 is the first trajectory.
682
683 // Now that we have written out all of the attributes that are based on the
684 // trajectory's particulars, call base class to deconstruct trajectory into
685 // polyline and/or points (or nothing if trajectory is to be filtered out). If
686 // base class calls for drawing points, no points will actually be drawn there
687 // since we instead need to do point drawing from here (in order to obtain the
688 // points attributes, not available from AddPrimitive(...point). Instead,
689 // such a call will just serve to set the flag that tells us that point
690 // drawing was requested for this trajectory (depends on several factors
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 of Trajectories.
703 // Note that we should create this heprep type even if there are no actual
704 // points. This allows the user to tell that points don't exist (admittedly
705 // odd) rather than that they were omitted by the drawing mode.
706 previousName = hepRepXMLWriter->prevTypeName[2];
707 hepRepXMLWriter->addType("Trajectory Step Points", 2);
708
709 float redness;
710 float greenness;
711 float blueness;
712 G4int markSize;
713 G4bool visible;
714 G4bool square;
715 G4Colour colour = trajContext->GetStepPtsColour();
716 redness = colour.GetRed();
717 greenness = colour.GetGreen();
718 blueness = colour.GetBlue();
719 markSize = (G4int) trajContext->GetStepPtsSize();
720 visible = (G4int) trajContext->GetStepPtsVisible();
721 square = (trajContext->GetStepPtsType() == G4Polymarker::squares);
722
723 // Avoiding drawing anything black on black.
724 if(redness == 0. && greenness == 0. && blueness == 0.)
725 {
726 redness = 1.;
727 greenness = 1.;
728 blueness = 1.;
729 }
730
731 // Specify attributes common to all trajectory points.
732 if(strcmp("Trajectory Step Points", previousName) != 0)
733 {
734 hepRepXMLWriter->addAttValue("DrawAs", "Point");
735 hepRepXMLWriter->addAttValue("MarkColor", redness, greenness, blueness);
736 hepRepXMLWriter->addAttValue("MarkSize", markSize);
737 hepRepXMLWriter->addAttValue("Layer", 110);
738 hepRepXMLWriter->addAttValue("Visibility", visible);
739 if(square)
740 hepRepXMLWriter->addAttValue("MarkName", "square");
741 else
742 hepRepXMLWriter->addAttValue("MarkName", "dot");
743 }
744
745 // Loop over all points on this trajectory.
746 for(i = 0; i < traj.GetPointEntries(); i++)
747 {
748 G4VTrajectoryPoint* aTrajectoryPoint = traj.GetPoint(i);
749
750 // Each point is a separate instance of the type Trajectory Points.
751 hepRepXMLWriter->addInstance();
752
753 // Pointers to hold trajectory point attribute values and definitions.
754 std::vector<G4AttValue>* rawPointAttValues =
755 aTrajectoryPoint->CreateAttValues();
756 std::vector<G4AttValue>* pointAttValues = new std::vector<G4AttValue>;
757 std::map<G4String, G4AttDef>* pointAttDefs =
758 new std::map<G4String, G4AttDef>;
759
760 // Get trajectory point attributes and definitions in standard HepRep
761 // style (uniform units, 3Vectors decomposed).
762 if(rawPointAttValues)
763 {
764 G4bool error =
765 G4AttCheck(rawPointAttValues, aTrajectoryPoint->GetAttDefs())
766 .Standard(pointAttValues, pointAttDefs);
767 if(error)
768 {
769 G4cout
770 << "G4HepRepFileSceneHandler::AddCompound(traj):"
771 "\nERROR found during conversion to standard point attributes."
772 << G4endl;
773 }
774
775 // Write out point attribute values.
776 if(pointAttValues)
777 {
778 for(iAttVal = pointAttValues->begin();
779 iAttVal != pointAttValues->end(); ++iAttVal)
780 // Do not write out the Aux or Pos attribute. Aux does not conform
781 // to the HepRep rule that each object can have only one instance of
782 // a given AttValue. Both of these attributes are redundant to
783 // actual position information of the point.
784 if(strcmp(iAttVal->GetName(), "Aux-X") != 0 &&
785 strcmp(iAttVal->GetName(), "Aux-Y") != 0 &&
786 strcmp(iAttVal->GetName(), "Aux-Z") != 0 &&
787 strcmp(iAttVal->GetName(), "Pos-X") != 0 &&
788 strcmp(iAttVal->GetName(), "Pos-Y") != 0 &&
789 strcmp(iAttVal->GetName(), "Pos-Z") != 0)
790 hepRepXMLWriter->addAttValue(iAttVal->GetName(),
791 iAttVal->GetValue());
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 single primitive, a point.
801 hepRepXMLWriter->addPrimitive();
802 G4Point3D vertex = aTrajectoryPoint->GetPosition();
803 hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z());
804 }
805 }
806
807 // Draw Auxiliary Points
808 if(trajContext->GetDrawAuxPts())
809 {
810 if(!doneInitTraj)
811 InitTrajectory();
812 // Create Trajectory Points as a subType of Trajectories.
813 // Note that we should create this heprep type even if there are no actual
814 // points. This allows the user to tell that points don't exist (admittedly
815 // odd) rather than that they were omitted by the drawing mode.
816 previousName = hepRepXMLWriter->prevTypeName[2];
817 hepRepXMLWriter->addType("Trajectory Auxiliary Points", 2);
818
819 float redness;
820 float greenness;
821 float blueness;
822 G4int markSize;
823 G4bool visible;
824 G4bool square;
825 G4Colour colour = trajContext->GetAuxPtsColour();
826 redness = colour.GetRed();
827 greenness = colour.GetGreen();
828 blueness = colour.GetBlue();
829 markSize = (G4int) trajContext->GetAuxPtsSize();
830 visible = (G4int) trajContext->GetAuxPtsVisible();
831 square = (trajContext->GetAuxPtsType() == G4Polymarker::squares);
832
833 // Avoiding drawing anything black on black.
834 if(redness == 0. && greenness == 0. && blueness == 0.)
835 {
836 redness = 1.;
837 greenness = 1.;
838 blueness = 1.;
839 }
840
841 // Specify attributes common to all trajectory points.
842 if(strcmp("Trajectory Auxiliary Points", previousName) != 0)
843 {
844 hepRepXMLWriter->addAttValue("DrawAs", "Point");
845 hepRepXMLWriter->addAttValue("MarkColor", redness, greenness, blueness);
846 hepRepXMLWriter->addAttValue("MarkSize", markSize);
847 hepRepXMLWriter->addAttValue("Layer", 110);
848 hepRepXMLWriter->addAttValue("Visibility", visible);
849 if(square)
850 hepRepXMLWriter->addAttValue("MarkName", "Square");
851 else
852 hepRepXMLWriter->addAttValue("MarkName", "Dot");
853 }
854
855 // Loop over all points on this trajectory.
856 for(i = 0; i < traj.GetPointEntries(); i++)
857 {
858 G4VTrajectoryPoint* aTrajectoryPoint = traj.GetPoint(i);
859
860 // Each point is a separate instance of the type Trajectory Points.
861 hepRepXMLWriter->addInstance();
862
863 // Pointers to hold trajectory point attribute values and definitions.
864 std::vector<G4AttValue>* rawPointAttValues =
865 aTrajectoryPoint->CreateAttValues();
866 std::vector<G4AttValue>* pointAttValues = new std::vector<G4AttValue>;
867 std::map<G4String, G4AttDef>* pointAttDefs =
868 new std::map<G4String, G4AttDef>;
869
870 // Get trajectory point attributes and definitions in standard HepRep
871 // style (uniform units, 3Vectors decomposed).
872 if(rawPointAttValues)
873 {
874 G4bool error =
875 G4AttCheck(rawPointAttValues, aTrajectoryPoint->GetAttDefs())
876 .Standard(pointAttValues, pointAttDefs);
877 if(error)
878 {
879 G4cout
880 << "G4HepRepFileSceneHandler::AddCompound(traj):"
881 "\nERROR found during conversion to standard point attributes."
882 << G4endl;
883 }
884
885 // Write out point attribute values.
886 if(pointAttValues)
887 {
888 for(iAttVal = pointAttValues->begin();
889 iAttVal != pointAttValues->end(); ++iAttVal)
890 // Do not write out the Aux or Pos attribute. Aux does not conform
891 // to the HepRep rule that each object can have only one instance of
892 // a given AttValue. Both of these attributes are redundant to
893 // actual position information of the point.
894 if(strcmp(iAttVal->GetName(), "Aux-X") != 0 &&
895 strcmp(iAttVal->GetName(), "Aux-Y") != 0 &&
896 strcmp(iAttVal->GetName(), "Aux-Z") != 0 &&
897 strcmp(iAttVal->GetName(), "Pos-X") != 0 &&
898 strcmp(iAttVal->GetName(), "Pos-Y") != 0 &&
899 strcmp(iAttVal->GetName(), "Pos-Z") != 0)
900 hepRepXMLWriter->addAttValue(iAttVal->GetName(),
901 iAttVal->GetValue());
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 single primitive, a point.
911 G4Point3D vertex = aTrajectoryPoint->GetPosition();
912
913 // Loop over auxiliary points associated with this Trajectory Point.
914 const std::vector<G4ThreeVector>* auxiliaries =
915 aTrajectoryPoint->GetAuxiliaryPoints();
916 if(0 != auxiliaries)
917 {
918 for(size_t iAux = 0; iAux < auxiliaries->size(); ++iAux)
919 {
920 const G4ThreeVector auxPos((*auxiliaries)[iAux]);
921 hepRepXMLWriter->addPrimitive();
922 hepRepXMLWriter->addPoint(auxPos.x(), auxPos.y(), auxPos.z());
923 }
924 }
925 }
926 }
927}
G4Colour::GetBlue
G4double GetBlue() const
Definition: G4Colour.hh:154
G4Colour::GetRed
G4double GetRed() const
Definition: G4Colour.hh:152
G4Colour::GetGreen
G4double GetGreen() const
Definition: G4Colour.hh:153
G4HepRepFileXMLWriter::addPoint
void addPoint(double x, double y, double z)
Definition: G4HepRepFileXMLWriter.cc:182
G4VTrajectoryPoint::CreateAttValues
virtual std::vector< G4AttValue > * CreateAttValues() const
Definition: G4VTrajectoryPoint.hh:80
G4VTrajectoryPoint::GetAuxiliaryPoints
virtual const std::vector< G4ThreeVector > * GetAuxiliaryPoints() const
Definition: G4VTrajectoryPoint.hh:64
G4VTrajectoryPoint::GetPosition
virtual const G4ThreeVector GetPosition() const =0
G4VTrajectoryPoint::GetAttDefs
virtual const std::map< G4String, G4AttDef > * GetAttDefs() const
Definition: G4VTrajectoryPoint.hh:72
G4VTrajectory::GetPoint
virtual G4VTrajectoryPoint * GetPoint(G4int i) const =0
G4VTrajectory::GetPointEntries
virtual G4int GetPointEntries() const =0
G4VTrajectory::CreateAttValues
virtual std::vector< G4AttValue > * CreateAttValues() const
Definition: G4VTrajectory.hh:99
G4VTrajectory::GetAttDefs
virtual const std::map< G4String, G4AttDef > * GetAttDefs() const
Definition: G4VTrajectory.hh:93
G4VisTrajContext::GetDrawAuxPts
G4bool GetDrawAuxPts() const
G4VisTrajContext::GetStepPtsColour
G4Colour GetStepPtsColour() const
G4VisTrajContext::GetStepPtsSize
G4double GetStepPtsSize() const
G4VisTrajContext::GetAuxPtsType
G4Polymarker::MarkerType GetAuxPtsType() const
G4VisTrajContext::GetAuxPtsSize
G4double GetAuxPtsSize() const
G4VisTrajContext::GetAuxPtsColour
G4Colour GetAuxPtsColour() const
G4VisTrajContext::GetAuxPtsVisible
G4bool GetAuxPtsVisible() const
G4VisTrajContext::GetStepPtsVisible
G4bool GetStepPtsVisible() const
G4VisTrajContext::GetStepPtsType
G4Polymarker::MarkerType GetStepPtsType() const
G4VisTrajContext::GetDrawStepPts
G4bool GetDrawStepPts() const

◆ AddPrimitive() [1/13]

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Circle &  circle)
virtual

Implements G4VSceneHandler.

Definition at line 1244 of file G4HepRepFileSceneHandler.cc.

1245{
1246#ifdef G4HEPREPFILEDEBUG
1247 G4cout
1248 << "G4HepRepFileSceneHandler::AddPrimitive(const G4Circle& circle) called:"
1249 "\n radius: "
1250 << circle.GetWorldRadius() << G4endl;
1251 PrintThings();
1252#endif
1253
1254 G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
1255
1256 if(fpVisAttribs && (fpVisAttribs->IsVisible() == 0) &&
1257 messenger->getCullInvisibles())
1258 return;
1259
1260 if(inPrimitives2D)
1261 {
1262 if(!warnedAbout2DMarkers)
1263 {
1264 G4cout << "HepRepFile does not currently support 2D circles." << G4endl;
1265 warnedAbout2DMarkers = true;
1266 }
1267 return;
1268 }
1269
1270 MarkerSizeType sizeType;
1271 G4double size = GetMarkerSize(circle, sizeType);
1272 if(sizeType == world)
1273 size = 4.;
1274
1275 if(drawingTraj)
1276 return;
1277
1278 if(drawingHit)
1279 InitHit();
1280
1281 haveVisible = true;
1282 AddHepRepInstance("Point", circle);
1283
1284 hepRepXMLWriter->addAttValue("MarkName", "Dot");
1285 hepRepXMLWriter->addAttValue("MarkSize", (G4int) size);
1286
1287 hepRepXMLWriter->addPrimitive();
1288
1289 G4Point3D center = (fObjectTransformation) *circle.GetPosition();
1290 hepRepXMLWriter->addPoint(center.x(), center.y(), center.z());
1291}
G4double
double G4double
Definition: G4Types.hh:83
G4HepRepMessenger::getCullInvisibles
virtual G4bool getCullInvisibles()
Definition: G4HepRepMessenger.cc:311
G4HepRepMessenger::GetInstance
static G4HepRepMessenger * GetInstance()
Definition: G4HepRepMessenger.cc:31
G4VMarker::GetPosition
G4Point3D GetPosition() const
G4VMarker::GetWorldRadius
G4double GetWorldRadius() const
G4VSceneHandler::fObjectTransformation
G4Transform3D fObjectTransformation
Definition: G4VSceneHandler.hh:449
G4VSceneHandler::GetMarkerSize
G4double GetMarkerSize(const G4VMarker &, MarkerSizeType &)
Definition: G4VSceneHandler.cc:1161
G4VSceneHandler::fpVisAttribs
const G4VisAttributes * fpVisAttribs
Definition: G4VSceneHandler.hh:452
G4VisAttributes::IsVisible
G4bool IsVisible() const

◆ AddPrimitive() [2/13]

virtual void G4VSceneHandler::AddPrimitive ( const G4Circle &  )
virtual

Implements G4VSceneHandler.

◆ AddPrimitive() [3/13]

void G4VSceneHandler::AddPrimitive ( const G4Plotter &  )
virtual

Reimplemented from G4VSceneHandler.

Definition at line 193 of file G4VSceneHandler.cc.

510 {
511 G4warn << "WARNING: Plotter not implemented for " << fSystem.GetName() << G4endl;
512 G4warn << " Open a plotter-aware graphics system or remove plotter with" << G4endl;
513 G4warn << " /vis/scene/removeModel Plotter" << G4endl;
514}
G4VGraphicsSystem::GetName
const G4String & GetName() const
Definition: G4VGraphicsSystem.hh:79
G4VSceneHandler::fSystem
G4VGraphicsSystem & fSystem
Definition: G4VSceneHandler.hh:434

◆ AddPrimitive() [4/13]

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Polyhedron &  polyhedron)
virtual

Implements G4VSceneHandler.

Definition at line 1342 of file G4HepRepFileSceneHandler.cc.

1343{
1344#ifdef G4HEPREPFILEDEBUG
1345 G4cout << "G4HepRepFileSceneHandler::AddPrimitive(const G4Polyhedron& "
1346 "polyhedron) called."
1347 << G4endl;
1348 PrintThings();
1349#endif
1350
1351 G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
1352
1353 if(fpVisAttribs && (fpVisAttribs->IsVisible() == 0) &&
1354 messenger->getCullInvisibles())
1355 return;
1356
1357 if(polyhedron.GetNoFacets() == 0)
1358 return;
1359
1360 if(drawingTraj)
1361 return;
1362
1363 if(drawingHit)
1364 InitHit();
1365
1366 haveVisible = true;
1367 AddHepRepInstance("Polygon", polyhedron);
1368
1369 G4Normal3D surfaceNormal;
1370 G4Point3D vertex;
1371
1372 G4bool notLastFace;
1373 do
1374 {
1375 hepRepXMLWriter->addPrimitive();
1376 notLastFace = polyhedron.GetNextNormal(surfaceNormal);
1377
1378 G4int edgeFlag = 1;
1379 G4bool notLastEdge;
1380 do
1381 {
1382 notLastEdge = polyhedron.GetNextVertex(vertex, edgeFlag);
1383 vertex = (fObjectTransformation) *vertex;
1384 hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z());
1385 } while(notLastEdge);
1386 } while(notLastFace);
1387}
HepPolyhedron::GetNextNormal
G4bool GetNextNormal(G4Normal3D &normal) const
Definition: HepPolyhedron.cc:1746
HepPolyhedron::GetNextVertex
G4bool GetNextVertex(G4Point3D &vertex, G4int &edgeFlag) const
Definition: HepPolyhedron.cc:1451
HepPolyhedron::GetNoFacets
G4int GetNoFacets() const
Definition: HepPolyhedron.h:309

◆ AddPrimitive() [5/13]

virtual void G4VSceneHandler::AddPrimitive ( const G4Polyhedron &  )
virtual

Implements G4VSceneHandler.

◆ AddPrimitive() [6/13]

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Polyline &  polyline)
virtual

Implements G4VSceneHandler.

Definition at line 1087 of file G4HepRepFileSceneHandler.cc.

1088{
1089#ifdef G4HEPREPFILEDEBUG
1090 G4cout << "G4HepRepFileSceneHandler::AddPrimitive(const G4Polyline& "
1091 "polyline) called:"
1092 "\n polyline: "
1093 << polyline << G4endl;
1094 PrintThings();
1095#endif
1096
1097 G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
1098
1099 if(fpVisAttribs && (fpVisAttribs->IsVisible() == 0) &&
1100 messenger->getCullInvisibles())
1101 return;
1102
1103 if(inPrimitives2D)
1104 {
1105 if(!warnedAbout2DMarkers)
1106 {
1107 G4cout << "HepRepFile does not currently support 2D lines." << G4endl;
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) *polyline[i];
1127 hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z());
1128 }
1129}

◆ AddPrimitive() [7/13]

virtual void G4VSceneHandler::AddPrimitive ( const G4Polyline &  )
virtual

Implements G4VSceneHandler.

◆ AddPrimitive() [8/13]

void G4VSceneHandler::AddPrimitive ( const G4Polymarker &  polymarker)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 191 of file G4VSceneHandler.cc.

467 {
468 switch (polymarker.GetMarkerType()) {
469 default:
470 case G4Polymarker::dots:
471 {
472 G4Circle dot (polymarker);
473 dot.SetWorldSize (0.);
474 dot.SetScreenSize (0.1); // Very small circle.
475 for (std::size_t iPoint = 0; iPoint < polymarker.size (); ++iPoint) {
476 dot.SetPosition (polymarker[iPoint]);
477 AddPrimitive (dot);
478 }
479 }
480 break;
481 case G4Polymarker::circles:
482 {
483 G4Circle circle (polymarker); // Default circle
484 for (std::size_t iPoint = 0; iPoint < polymarker.size (); ++iPoint) {
485 circle.SetPosition (polymarker[iPoint]);
486 AddPrimitive (circle);
487 }
488 }
489 break;
490 case G4Polymarker::squares:
491 {
492 G4Square square (polymarker); // Default square
493 for (std::size_t iPoint = 0; iPoint < polymarker.size (); ++iPoint) {
494 square.SetPosition (polymarker[iPoint]);
495 AddPrimitive (square);
496 }
497 }
498 break;
499 }
500}
G4HepRepFileSceneHandler::AddPrimitive
void AddPrimitive(const G4Polyline &)
Definition: G4HepRepFileSceneHandler.cc:1087
G4Polymarker::GetMarkerType
MarkerType GetMarkerType() const

◆ AddPrimitive() [9/13]

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Polymarker &  line)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 1131 of file G4HepRepFileSceneHandler.cc.

1132{
1133#ifdef G4HEPREPFILEDEBUG
1134 G4cout
1135 << "G4HepRepFileSceneHandler::AddPrimitive(const G4Polymarker& line) called"
1136 << G4endl;
1137 PrintThings();
1138#endif
1139
1140 G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
1141
1142 if(fpVisAttribs && (fpVisAttribs->IsVisible() == 0) &&
1143 messenger->getCullInvisibles())
1144 return;
1145
1146 if(inPrimitives2D)
1147 {
1148 if(!warnedAbout2DMarkers)
1149 {
1150 G4cout << "HepRepFile does not currently support 2D lines." << G4endl;
1151 warnedAbout2DMarkers = true;
1152 }
1153 return;
1154 }
1155
1156 MarkerSizeType sizeType;
1157 G4double size = GetMarkerSize(line, sizeType);
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", "Dot");
1171 hepRepXMLWriter->addAttValue("MarkSize", (G4int) size);
1172
1173 hepRepXMLWriter->addPrimitive();
1174
1175 for(size_t i = 0; i < line.size(); i++)
1176 {
1177 G4Point3D vertex = (fObjectTransformation) *line[i];
1178 hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z());
1179 }
1180}

◆ AddPrimitive() [10/13]

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Square &  square)
virtual

Implements G4VSceneHandler.

Definition at line 1293 of file G4HepRepFileSceneHandler.cc.

1294{
1295#ifdef G4HEPREPFILEDEBUG
1296 G4cout
1297 << "G4HepRepFileSceneHandler::AddPrimitive(const G4Square& square) called:"
1298 "\n side: "
1299 << square.GetWorldRadius() << G4endl;
1300 PrintThings();
1301#endif
1302
1303 G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
1304
1305 if(fpVisAttribs && (fpVisAttribs->IsVisible() == 0) &&
1306 messenger->getCullInvisibles())
1307 return;
1308
1309 if(inPrimitives2D)
1310 {
1311 if(!warnedAbout2DMarkers)
1312 {
1313 G4cout << "HepRepFile does not currently support 2D squares." << G4endl;
1314 warnedAbout2DMarkers = true;
1315 }
1316 return;
1317 }
1318
1319 MarkerSizeType sizeType;
1320 G4double size = GetMarkerSize(square, sizeType);
1321 if(sizeType == world)
1322 size = 4.;
1323
1324 if(drawingTraj)
1325 return;
1326
1327 if(drawingHit)
1328 InitHit();
1329
1330 haveVisible = true;
1331 AddHepRepInstance("Point", square);
1332
1333 hepRepXMLWriter->addAttValue("MarkName", "Square");
1334 hepRepXMLWriter->addAttValue("MarkSize", (G4int) size);
1335
1336 hepRepXMLWriter->addPrimitive();
1337
1338 G4Point3D center = (fObjectTransformation) *square.GetPosition();
1339 hepRepXMLWriter->addPoint(center.x(), center.y(), center.z());
1340}

◆ AddPrimitive() [11/13]

virtual void G4VSceneHandler::AddPrimitive ( const G4Square &  )
virtual

Implements G4VSceneHandler.

◆ AddPrimitive() [12/13]

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Text &  text)
virtual

Implements G4VSceneHandler.

Definition at line 1182 of file G4HepRepFileSceneHandler.cc.

1183{
1184#ifdef G4HEPREPFILEDEBUG
1185 G4cout << "G4HepRepFileSceneHandler::AddPrimitive(const G4Text& text) called:"
1186 "\n text: "
1187 << text.GetText() << G4endl;
1188 PrintThings();
1189#endif
1190
1191 if(!inPrimitives2D)
1192 {
1193 if(!warnedAbout3DText)
1194 {
1195 G4cout << "HepRepFile does not currently support 3D text." << G4endl;
1196 G4cout
1197 << "HepRep browsers can directly display text attributes on request."
1198 << G4endl;
1199 G4cout << "See Application Developers Guide for how to attach attributes "
1200 "to viewable objects."
1201 << G4endl;
1202 warnedAbout3DText = true;
1203 }
1204 return;
1205 }
1206
1207 MarkerSizeType sizeType;
1208 G4double size = GetMarkerSize(text, sizeType);
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", "Left");
1217 hepRepXMLWriter->addAttValue("FontName", "Arial");
1218 hepRepXMLWriter->addAttValue("FontStyle", "Plain");
1219 hepRepXMLWriter->addAttValue("FontSize", (G4int) size);
1220 hepRepXMLWriter->addAttValue("FontHasBanner", "TRUE");
1221 hepRepXMLWriter->addAttValue("FontBannerColor", "0,0,0");
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. && blueness == 0.)
1230 {
1231 redness = 1.;
1232 greenness = 1.;
1233 blueness = 1.;
1234 }
1235 hepRepXMLWriter->addAttValue("FontColor", redness, greenness, blueness);
1236
1237 hepRepXMLWriter->addPrimitive();
1238
1239 hepRepXMLWriter->addAttValue("Text", text.GetText());
1240 hepRepXMLWriter->addAttValue("VPos", .99 - text.GetYOffset());
1241 hepRepXMLWriter->addAttValue("HPos", text.GetXOffset());
1242}
G4Text::GetYOffset
G4double GetYOffset() const
G4Text::GetXOffset
G4double GetXOffset() const
G4Text::GetText
G4String GetText() const
G4VSceneHandler::GetTextColour
const G4Colour & GetTextColour(const G4Text &)
Definition: G4VSceneHandler.cc:1077

◆ AddPrimitive() [13/13]

virtual void G4VSceneHandler::AddPrimitive ( const G4Text &  )
virtual

Implements G4VSceneHandler.

◆ AddSolid() [1/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Box &  box)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 145 of file G4HepRepFileSceneHandler.cc.

146{
147#ifdef G4HEPREPFILEDEBUG
148 G4cout << "G4HepRepFileSceneHandler::AddSolid(const G4Box& box) called for "
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 = G4HepRepMessenger::GetInstance();
163
164 // Get and check applicable vis attributes.
165 fpVisAttribs = fpViewer->GetApplicableVisAttributes(fpVisAttribs);
166 if(fpVisAttribs && (fpVisAttribs->IsVisible() == 0) &&
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(), vertex1.y(), vertex1.z());
195 hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
196 hepRepXMLWriter->addPoint(vertex3.x(), vertex3.y(), vertex3.z());
197 hepRepXMLWriter->addPoint(vertex4.x(), vertex4.y(), vertex4.z());
198 hepRepXMLWriter->addPoint(vertex5.x(), vertex5.y(), vertex5.z());
199 hepRepXMLWriter->addPoint(vertex6.x(), vertex6.y(), vertex6.z());
200 hepRepXMLWriter->addPoint(vertex7.x(), vertex7.y(), vertex7.z());
201 hepRepXMLWriter->addPoint(vertex8.x(), vertex8.y(), vertex8.z());
202}
G4Point3D
HepGeom::Point3D< G4double > G4Point3D
Definition: G4Point3D.hh:34
G4Box::GetYHalfLength
G4double GetYHalfLength() const
G4Box::GetZHalfLength
G4double GetZHalfLength() const
G4Box::GetXHalfLength
G4double GetXHalfLength() const
G4VSolid::GetName
G4String GetName() const
G4VViewer::GetApplicableVisAttributes
const G4VisAttributes * GetApplicableVisAttributes(const G4VisAttributes *) const

◆ AddSolid() [2/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Cons &  cons)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 204 of file G4HepRepFileSceneHandler.cc.

205{
206#ifdef G4HEPREPFILEDEBUG
207 G4cout << "G4HepRepFileSceneHandler::AddSolid(const G4Cons& cons) called for "
208 << cons.GetName() << G4endl;
209 PrintThings();
210#endif
211
212 // HepRApp does not correctly represent the end faces of cones at
213 // non-standard angles, let the base class convert these solids to polygons.
214 G4RotationMatrix r = fObjectTransformation.getRotation();
215 G4bool linedUpWithAnAxis =
216 (std::fabs(r.phiX()) <= .001 || std::fabs(r.phiY()) <= .001 ||
217 std::fabs(r.phiZ()) <= .001 || std::fabs(r.phiX() - pi) <= .001 ||
218 std::fabs(r.phiY() - pi) <= .001 || std::fabs(r.phiZ() - pi) <= .001);
219 // G4cout << "Angle X:" << r.phiX() << ", Angle Y:" << r.phiY() << ", Angle
220 // Z:" << r.phiZ() << G4endl; G4cout << "linedUpWithAnAxis:" <<
221 // linedUpWithAnAxis << G4endl;
222
223 // HepRep does not have a primitive for a cut cone,
224 // so if this cone is cut, let the base class convert this
225 // solid to polygons.
226 G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
227 if(cons.GetDeltaPhiAngle() < twopi || !linedUpWithAnAxis ||
228 messenger->renderCylAsPolygons())
229 {
230 G4VSceneHandler::AddSolid(cons); // Invoke default action.
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->GetApplicableVisAttributes(fpVisAttribs);
245 if(fpVisAttribs && (fpVisAttribs->IsVisible() == 0) &&
246 messenger->getCullInvisibles())
247 return;
248
249 G4Point3D vertex1(G4Point3D(0., 0., -cons.GetZHalfLength()));
250 G4Point3D vertex2(G4Point3D(0., 0., cons.GetZHalfLength()));
251
252 vertex1 = (fObjectTransformation) *vertex1;
253 vertex2 = (fObjectTransformation) *vertex2;
254
255 // Outer cylinder.
256 hepRepXMLWriter->addPrimitive();
257 hepRepXMLWriter->addAttValue("Radius1", messenger->getScale() *
258 cons.GetOuterRadiusMinusZ());
259 hepRepXMLWriter->addAttValue("Radius2", messenger->getScale() *
260 cons.GetOuterRadiusPlusZ());
261 hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z());
262 hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
263
264 // Inner cylinder.
265 hepRepXMLWriter->addPrimitive();
266 hepRepXMLWriter->addAttValue("Radius1", messenger->getScale() *
267 cons.GetInnerRadiusMinusZ());
268 hepRepXMLWriter->addAttValue("Radius2", messenger->getScale() *
269 cons.GetInnerRadiusPlusZ());
270 hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z());
271 hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
272 }
273}
CLHEP::HepRotation::phiY
double phiY() const
Definition: Rotation.cc:128
CLHEP::HepRotation::phiX
double phiX() const
Definition: Rotation.cc:124
CLHEP::HepRotation::phiZ
double phiZ() const
Definition: Rotation.cc:132
G4Cons::GetOuterRadiusPlusZ
G4double GetOuterRadiusPlusZ() const
G4Cons::GetDeltaPhiAngle
G4double GetDeltaPhiAngle() const
G4Cons::GetInnerRadiusMinusZ
G4double GetInnerRadiusMinusZ() const
G4Cons::GetInnerRadiusPlusZ
G4double GetInnerRadiusPlusZ() const
G4Cons::GetOuterRadiusMinusZ
G4double GetOuterRadiusMinusZ() const
G4Cons::GetZHalfLength
G4double GetZHalfLength() const
G4HepRepMessenger::renderCylAsPolygons
virtual G4bool renderCylAsPolygons()
Definition: G4HepRepMessenger.cc:313
G4HepRepMessenger::getScale
virtual G4double getScale()
Definition: G4HepRepMessenger.cc:315
G4VSceneHandler::AddSolid
virtual void AddSolid(const G4Box &)
Definition: G4VSceneHandler.cc:252
HepGeom::Transform3D::getRotation
CLHEP::HepRotation getRotation() const

◆ AddSolid() [3/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Ellipsoid &  ellipsoid)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 484 of file G4HepRepFileSceneHandler.cc.

485{
486#ifdef G4HEPREPFILEDEBUG
487 G4cout << "G4HepRepFileSceneHandler::AddSolid(const G4Ellipsoid& ellipsoid) "
488 "called for "
489 << ellipsoid.GetName() << G4endl;
490 PrintThings();
491#endif
492 G4VSceneHandler::AddSolid(ellipsoid); // Invoke default action.
493}

◆ AddSolid() [4/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Orb &  orb)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 474 of file G4HepRepFileSceneHandler.cc.

475{
476#ifdef G4HEPREPFILEDEBUG
477 G4cout << "G4HepRepFileSceneHandler::AddSolid(const G4Orb& orb) called for "
478 << orb.GetName() << G4endl;
479 PrintThings();
480#endif
481 G4VSceneHandler::AddSolid(orb); // Invoke default action.
482}

◆ AddSolid() [5/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Para &  para)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 431 of file G4HepRepFileSceneHandler.cc.

432{
433#ifdef G4HEPREPFILEDEBUG
434 G4cout << "G4HepRepFileSceneHandler::AddSolid(const G4Para& para) called for "
435 << para.GetName() << G4endl;
436 PrintThings();
437#endif
438 G4VSceneHandler::AddSolid(para); // Invoke default action.
439}

◆ AddSolid() [6/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Polycone &  polycone)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 452 of file G4HepRepFileSceneHandler.cc.

453{
454#ifdef G4HEPREPFILEDEBUG
455 G4cout << "G4HepRepFileSceneHandler::AddSolid(const G4Polycone& polycone) "
456 "called for "
457 << polycone.GetName() << G4endl;
458 PrintThings();
459#endif
460 G4VSceneHandler::AddSolid(polycone); // Invoke default action.
461}

◆ AddSolid() [7/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Polyhedra &  polyhedra)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 463 of file G4HepRepFileSceneHandler.cc.

464{
465#ifdef G4HEPREPFILEDEBUG
466 G4cout << "G4HepRepFileSceneHandler::AddSolid(const G4Polyhedra& polyhedra) "
467 "called for "
468 << polyhedra.GetName() << G4endl;
469 PrintThings();
470#endif
471 G4VSceneHandler::AddSolid(polyhedra); // Invoke default action.
472}

◆ AddSolid() [8/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Sphere &  sphere)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 420 of file G4HepRepFileSceneHandler.cc.

421{
422#ifdef G4HEPREPFILEDEBUG
423 G4cout
424 << "G4HepRepFileSceneHandler::AddSolid(const G4Sphere& sphere) called for "
425 << sphere.GetName() << G4endl;
426 PrintThings();
427#endif
428 G4VSceneHandler::AddSolid(sphere); // Invoke default action.
429}

◆ AddSolid() [9/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4TessellatedSolid &  tess)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 495 of file G4HepRepFileSceneHandler.cc.

496{
497#ifdef G4HEPREPFILEDEBUG
498 G4cout << "G4HepRepFileSceneHandler::AddSolid(const G4TessellatedSolid& ) "
499 "called for "
500 << tess.GetName() << G4endl;
501 PrintThings();
502#endif
503 G4VSceneHandler::AddSolid(tess); // Invoke default action.
504}

◆ AddSolid() [10/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Torus &  torus)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 441 of file G4HepRepFileSceneHandler.cc.

442{
443#ifdef G4HEPREPFILEDEBUG
444 G4cout
445 << "G4HepRepFileSceneHandler::AddSolid(const G4Torus& torus) called for "
446 << torus.GetName() << G4endl;
447 PrintThings();
448#endif
449 G4VSceneHandler::AddSolid(torus); // Invoke default action.
450}

◆ AddSolid() [11/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Trap &  trap)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 410 of file G4HepRepFileSceneHandler.cc.

411{
412#ifdef G4HEPREPFILEDEBUG
413 G4cout << "G4HepRepFileSceneHandler::AddSolid(const G4Trap& trap) called for "
414 << trap.GetName() << G4endl;
415 PrintThings();
416#endif
417 G4VSceneHandler::AddSolid(trap); // Invoke default action.
418}

◆ AddSolid() [12/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Trd &  trd)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 349 of file G4HepRepFileSceneHandler.cc.

350{
351#ifdef G4HEPREPFILEDEBUG
352 G4cout << "G4HepRepFileSceneHandler::AddSolid(const G4Trd& trd) called for "
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 = G4HepRepMessenger::GetInstance();
367
368 // Get and check applicable vis attributes.
369 fpVisAttribs = fpViewer->GetApplicableVisAttributes(fpVisAttribs);
370 if(fpVisAttribs && (fpVisAttribs->IsVisible() == 0) &&
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(), vertex1.y(), vertex1.z());
401 hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
402 hepRepXMLWriter->addPoint(vertex3.x(), vertex3.y(), vertex3.z());
403 hepRepXMLWriter->addPoint(vertex4.x(), vertex4.y(), vertex4.z());
404 hepRepXMLWriter->addPoint(vertex5.x(), vertex5.y(), vertex5.z());
405 hepRepXMLWriter->addPoint(vertex6.x(), vertex6.y(), vertex6.z());
406 hepRepXMLWriter->addPoint(vertex7.x(), vertex7.y(), vertex7.z());
407 hepRepXMLWriter->addPoint(vertex8.x(), vertex8.y(), vertex8.z());
408}
G4Trd::GetXHalfLength2
G4double GetXHalfLength2() const
G4Trd::GetYHalfLength2
G4double GetYHalfLength2() const
G4Trd::GetXHalfLength1
G4double GetXHalfLength1() const
G4Trd::GetYHalfLength1
G4double GetYHalfLength1() const
G4Trd::GetZHalfLength
G4double GetZHalfLength() const

◆ AddSolid() [13/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Tubs &  tubs)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 275 of file G4HepRepFileSceneHandler.cc.

276{
277#ifdef G4HEPREPFILEDEBUG
278 G4cout << "G4HepRepFileSceneHandler::AddSolid(const G4Tubs& tubs) called for "
279 << tubs.GetName() << G4endl;
280 PrintThings();
281#endif
282
283 // HepRApp does not correctly represent the end faces of cylinders at
284 // non-standard angles, let the base class convert these solids to polygons.
285 G4RotationMatrix r = fObjectTransformation.getRotation();
286 G4bool linedUpWithAnAxis =
287 (std::fabs(r.phiX()) <= .001 || std::fabs(r.phiY()) <= .001 ||
288 std::fabs(r.phiZ()) <= .001 || std::fabs(r.phiX() - pi) <= .001 ||
289 std::fabs(r.phiY() - pi) <= .001 || std::fabs(r.phiZ() - pi) <= .001);
290 // G4cout << "Angle X:" << r.phiX() << ", Angle Y:" << r.phiY() << ", Angle
291 // Z:" << r.phiZ() << G4endl; G4cout << "linedUpWithAnAxis:" <<
292 // linedUpWithAnAxis << G4endl;
293
294 // HepRep does not have a primitive for a cut cylinder,
295 // so if this cylinder is cut, let the base class convert this
296 // solid to polygons.
297 G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
298 if(tubs.GetDeltaPhiAngle() < twopi || !linedUpWithAnAxis ||
299 messenger->renderCylAsPolygons())
300 {
301 G4VSceneHandler::AddSolid(tubs); // Invoke default action.
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->GetApplicableVisAttributes(fpVisAttribs);
316 if(fpVisAttribs && (fpVisAttribs->IsVisible() == 0) &&
317 messenger->getCullInvisibles())
318 return;
319
320 G4Point3D vertex1(G4Point3D(0., 0., -tubs.GetZHalfLength()));
321 G4Point3D vertex2(G4Point3D(0., 0., tubs.GetZHalfLength()));
322
323 vertex1 = (fObjectTransformation) *vertex1;
324 vertex2 = (fObjectTransformation) *vertex2;
325
326 // Outer cylinder.
327 hepRepXMLWriter->addPrimitive();
328 hepRepXMLWriter->addAttValue("Radius1",
329 messenger->getScale() * tubs.GetOuterRadius());
330 hepRepXMLWriter->addAttValue("Radius2",
331 messenger->getScale() * tubs.GetOuterRadius());
332 hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z());
333 hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
334
335 // Inner cylinder.
336 if(tubs.GetInnerRadius() != 0.)
337 {
338 hepRepXMLWriter->addPrimitive();
339 hepRepXMLWriter->addAttValue("Radius1", messenger->getScale() *
340 tubs.GetInnerRadius());
341 hepRepXMLWriter->addAttValue("Radius2", messenger->getScale() *
342 tubs.GetInnerRadius());
343 hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z());
344 hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
345 }
346 }
347}
G4Tubs::GetZHalfLength
G4double GetZHalfLength() const
G4Tubs::GetInnerRadius
G4double GetInnerRadius() const
G4Tubs::GetOuterRadius
G4double GetOuterRadius() const
G4Tubs::GetDeltaPhiAngle
G4double GetDeltaPhiAngle() const

◆ AddSolid() [14/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4VSolid &  solid)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 506 of file G4HepRepFileSceneHandler.cc.

507{
508#ifdef G4HEPREPFILEDEBUG
509 G4cout
510 << "G4HepRepFileSceneHandler::AddSolid(const G4Solid& solid) called for "
511 << solid.GetName() << G4endl;
512 PrintThings();
513#endif
514 G4VSceneHandler::AddSolid(solid); // Invoke default action.
515}

◆ BeginModeling()

void G4HepRepFileSceneHandler::BeginModeling ( )
virtual

Reimplemented from G4VSceneHandler.

Definition at line 93 of file G4HepRepFileSceneHandler.cc.

94{
95 G4VisManager* visManager = G4VisManager::GetInstance();
96 const G4VTrajectoryModel* model = visManager->CurrentTrajDrawModel();
97 trajContext = &model->GetContext();
98
99 G4VSceneHandler::BeginModeling(); // Required: see G4VSceneHandler.hh.
100}
G4VSceneHandler::BeginModeling
virtual void BeginModeling()
Definition: G4VSceneHandler.cc:213
G4VTrajectoryModel::GetContext
const G4VisTrajContext & GetContext() const
Definition: G4VTrajectoryModel.cc:53
G4VisManager::CurrentTrajDrawModel
const G4VTrajectoryModel * CurrentTrajDrawModel() const
Definition: G4VisManager.cc:829
G4VisManager::GetInstance
static G4VisManager * GetInstance()
Definition: G4VisManager.cc:249

◆ BeginPrimitives2D()

void G4HepRepFileSceneHandler::BeginPrimitives2D ( const G4Transform3D &  objectTransformation)
virtual

Reimplemented from G4VSceneHandler.

Definition at line 107 of file G4HepRepFileSceneHandler.cc.

109{
110#ifdef G4HEPREPFILEDEBUG
111 G4cout << "G4HepRepFileSceneHandler::BeginPrimitives2D() " << G4endl;
112#endif
113 inPrimitives2D = true;
114 G4VSceneHandler::BeginPrimitives2D(objectTransformation);
115}
G4VSceneHandler::BeginPrimitives2D
virtual void BeginPrimitives2D(const G4Transform3D &objectTransformation=G4Transform3D())
Definition: G4VSceneHandler.cc:190

◆ ClearTransientStore()

void G4HepRepFileSceneHandler::ClearTransientStore ( )
virtual

Reimplemented from G4VSceneHandler.

Definition at line 1713 of file G4HepRepFileSceneHandler.cc.

1714{
1715 // This is typically called after an update and before drawing hits
1716 // of the next event. To simulate the clearing of "transients"
1717 // (hits, etc.) the detector is redrawn...
1718 if(fpViewer)
1719 {
1720 fpViewer->SetView();
1721 fpViewer->ClearView();
1722 fpViewer->DrawView();
1723 }
1724}
G4VViewer::DrawView
virtual void DrawView()=0
G4VViewer::ClearView
virtual void ClearView()=0
G4VViewer::SetView
virtual void SetView()=0

◆ EndModeling()

void G4HepRepFileSceneHandler::EndModeling ( )
virtual

Reimplemented from G4VSceneHandler.

Definition at line 102 of file G4HepRepFileSceneHandler.cc.

103{
104 G4VSceneHandler::EndModeling(); // Required: see G4VSceneHandler.hh.
105}
G4VSceneHandler::EndModeling
virtual void EndModeling()
Definition: G4VSceneHandler.cc:216

◆ EndPrimitives2D()

void G4HepRepFileSceneHandler::EndPrimitives2D ( )
virtual

Reimplemented from G4VSceneHandler.

Definition at line 117 of file G4HepRepFileSceneHandler.cc.

118{
119#ifdef G4HEPREPFILEDEBUG
120 G4cout << "G4HepRepFileSceneHandler::EndPrimitives2D() " << G4endl;
121#endif
122 G4VSceneHandler::EndPrimitives2D();
123 inPrimitives2D = false;
124}
G4VSceneHandler::EndPrimitives2D
virtual void EndPrimitives2D()
Definition: G4VSceneHandler.cc:201

◆ GetHepRepXMLWriter()

G4HepRepFileXMLWriter * G4HepRepFileSceneHandler::GetHepRepXMLWriter ( )

Definition at line 1389 of file G4HepRepFileSceneHandler.cc.

1390{
1391 return hepRepXMLWriter;
1392}

Referenced by G4HepRepFileSceneHandler().

◆ InitHit()

void G4HepRepFileSceneHandler::InitHit ( )

Definition at line 1062 of file G4HepRepFileSceneHandler.cc.

1063{
1064 if(!doneInitHit)
1065 {
1066 // For every hit, add an instance of Type Hit.
1067 hepRepXMLWriter->addInstance();
1068
1069 // Write out the hit's attribute values.
1070 if(hitAttValues)
1071 {
1072 std::vector<G4AttValue>::iterator iAttVal;
1073 for(iAttVal = hitAttValues->begin(); iAttVal != hitAttValues->end();
1074 ++iAttVal)
1075 hepRepXMLWriter->addAttValue(iAttVal->GetName(), iAttVal->GetValue());
1076 delete hitAttValues;
1077 }
1078
1079 // Clean up hit attributes.
1080 if(hitAttDefs)
1081 delete hitAttDefs;
1082
1083 doneInitHit = true;
1084 }
1085}

Referenced by AddPrimitive(), and AddSolid().

◆ InitTrajectory()

void G4HepRepFileSceneHandler::InitTrajectory ( )

Definition at line 1037 of file G4HepRepFileSceneHandler.cc.

1038{
1039 if(!doneInitTraj)
1040 {
1041 // For every trajectory, add an instance of Type Trajectory.
1042 hepRepXMLWriter->addInstance();
1043
1044 // Write out the trajectory's attribute values.
1045 if(trajAttValues)
1046 {
1047 std::vector<G4AttValue>::iterator iAttVal;
1048 for(iAttVal = trajAttValues->begin(); iAttVal != trajAttValues->end();
1049 ++iAttVal)
1050 hepRepXMLWriter->addAttValue(iAttVal->GetName(), iAttVal->GetValue());
1051 delete trajAttValues;
1052 }
1053
1054 // Clean up trajectory attributes.
1055 if(trajAttDefs)
1056 delete trajAttDefs;
1057
1058 doneInitTraj = true;
1059 }
1060}

Referenced by AddCompound(), and AddPrimitive().

Member Data Documentation

◆ fSceneIdCount

G4int G4HepRepFileSceneHandler::fSceneIdCount = 0
staticprotected

Definition at line 132 of file G4HepRepFileSceneHandler.hh.

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