#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 G4VDigi &)

virtual void	AddCompound (const G4THitsMap< G4double > &)

virtual void	AddCompound (const G4THitsMap< G4StatDouble > &)

virtual void	AddCompound (const G4Mesh &)

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	BeginPrimitives (const G4Transform3D &objectTransformation=G4Transform3D())

virtual void	EndPrimitives ()

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 ()

void	AddViewerToList (G4VViewer *pView)

void	RemoveViewerFromList (G4VViewer *pView)

Public Member Functions inherited from G4VGraphicsScene
	G4VGraphicsScene ()

virtual	~G4VGraphicsScene ()

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.

  : G4VSceneHandler(system, fSceneIdCount++, name)
{
  hepRepXMLWriter = ((G4HepRepFile*) (&system))->GetHepRepXMLWriter();
  fileCounter     = 0;
 
  inPrimitives2D       = false;
  warnedAbout3DText    = false;
  warnedAbout2DMarkers = false;
  haveVisible          = false;
  drawingTraj          = false;
  doneInitTraj         = false;
  drawingHit           = false;
  doneInitHit          = false;
  trajContext          = 0;
  trajAttValues        = 0;
  trajAttDefs          = 0;
  hitAttValues         = 0;
  hitAttDefs           = 0;
}

◆ ~G4HepRepFileSceneHandler()

G4HepRepFileSceneHandler::~G4HepRepFileSceneHandler ( )

virtual

Definition at line 91 of file G4HepRepFileSceneHandler.cc.

91{}

Member Function Documentation

◆ AddCompound() [1/6]

void G4VSceneHandler::AddCompound ( const G4Mesh & mesh )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 133 of file G4VSceneHandler.cc.

{
  G4warn <<
  "There has been an attempt to draw a mesh with option \""
  << fpViewer->GetViewParameters().GetSpecialMeshRenderingOption()
  << "\":\n" << mesh
  << "but it is not of a recognised type or is not implemented"
  "\nby the current graphics driver. Instead we draw its"
  "\ncontainer \"" << mesh.GetContainerVolume()->GetName() << "\"."
  << G4endl;
  const auto& pv = mesh.GetContainerVolume();
  const auto& lv = pv->GetLogicalVolume();
  const auto& solid = lv->GetSolid();
  const auto& transform = mesh.GetTransform();
  // Make sure container is visible
  G4VisAttributes tmpVisAtts;  // Visible, white, not forced.
  const auto& saveVisAtts = lv->GetVisAttributes();
  if (saveVisAtts) {
    tmpVisAtts = *saveVisAtts;
    tmpVisAtts.SetVisibility(true);
    auto colour = saveVisAtts->GetColour();
    colour.SetAlpha(1.);
    tmpVisAtts.SetColour(colour);
  }
  // Draw container
  PreAddSolid(transform,tmpVisAtts);
  solid->DescribeYourselfTo(*this);
  PostAddSolid();
  // Restore vis attributes
  lv->SetVisAttributes(saveVisAtts);
}

◆ AddCompound() [2/6]

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

virtual

Reimplemented from G4VSceneHandler.

Definition at line 131 of file G4VSceneHandler.cc.

                                                                   {
  using MeshScoreMap = G4VScoringMesh::MeshScoreMap;
  //G4cout << "AddCompound: hits: " << &hits << G4endl;
  G4bool scoreMapHits = false;
  G4ScoringManager* scoringManager = G4ScoringManager::GetScoringManagerIfExist();
  if (scoringManager) {
    std::size_t nMeshes = scoringManager->GetNumberOfMesh();
    for (std::size_t iMesh = 0; iMesh < nMeshes; ++iMesh) {
      G4VScoringMesh* mesh = scoringManager->GetMesh((G4int)iMesh);
      if (mesh && mesh->IsActive()) {
    MeshScoreMap scoreMap = mesh->GetScoreMap();
        const G4String& mapNam = const_cast<G4THitsMap<G4double>&>(hits).GetName();
    for(MeshScoreMap::const_iterator i = scoreMap.cbegin();
        i != scoreMap.cend(); ++i) {
      const G4String& scoreMapName = i->first;
      if (scoreMapName == mapNam) {
        G4DefaultLinearColorMap colorMap("G4VSceneHandlerColorMap");
        scoreMapHits = true;
        mesh->DrawMesh(scoreMapName, &colorMap);
      }
    }
      }
    }
  }
  if (scoreMapHits) {
    static G4bool first = true;
    if (first) {
      first = false;
      G4cout <<
    "Scoring map drawn with default parameters."
    "\n  To get gMocren file for gMocren browser:"
    "\n    /vis/open gMocrenFile"
    "\n    /vis/viewer/flush"
    "\n  Many other options available with /score/draw... commands."
    "\n  You might want to \"/vis/viewer/set/autoRefresh false\"."
         << G4endl;
    }
  } else {  // Not score map hits.  Just call DrawAllHits.
    // Cast away const because DrawAllHits is non-const!!!!
    const_cast<G4THitsMap<G4double>&>(hits).DrawAllHits();
  }
}

◆ AddCompound() [3/6]

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

virtual

Reimplemented from G4VSceneHandler.

Definition at line 132 of file G4VSceneHandler.cc.

                                                                       {
  using MeshScoreMap = G4VScoringMesh::MeshScoreMap;
  //G4cout << "AddCompound: hits: " << &hits << G4endl;
  G4bool scoreMapHits = false;
  G4ScoringManager* scoringManager = G4ScoringManager::GetScoringManagerIfExist();
  if (scoringManager) {
    std::size_t nMeshes = scoringManager->GetNumberOfMesh();
    for (std::size_t iMesh = 0; iMesh < nMeshes; ++iMesh) {
      G4VScoringMesh* mesh = scoringManager->GetMesh((G4int)iMesh);
      if (mesh && mesh->IsActive()) {
    MeshScoreMap scoreMap = mesh->GetScoreMap();
    for(MeshScoreMap::const_iterator i = scoreMap.cbegin();
        i != scoreMap.cend(); ++i) {
      const G4String& scoreMapName = i->first;
      const G4THitsMap<G4StatDouble>* foundHits = i->second;
      if (foundHits == &hits) {
        G4DefaultLinearColorMap colorMap("G4VSceneHandlerColorMap");
        scoreMapHits = true;
        mesh->DrawMesh(scoreMapName, &colorMap);
      }
    }
      }
    }
  }
  if (scoreMapHits) {
    static G4bool first = true;
    if (first) {
      first = false;
      G4cout <<
    "Scoring map drawn with default parameters."
    "\n  To get gMocren file for gMocren browser:"
    "\n    /vis/open gMocrenFile"
    "\n    /vis/viewer/flush"
    "\n  Many other options available with /score/draw... commands."
    "\n  You might want to \"/vis/viewer/set/autoRefresh false\"."
         << G4endl;
    }
  } else {  // Not score map hits.  Just call DrawAllHits.
    // Cast away const because DrawAllHits is non-const!!!!
    const_cast<G4THitsMap<G4StatDouble>&>(hits).DrawAllHits();
  }
}

◆ AddCompound() [4/6]

void G4VSceneHandler::AddCompound ( const G4VDigi & digi )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 130 of file G4VSceneHandler.cc.

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

◆ AddCompound() [5/6]

void G4HepRepFileSceneHandler::AddCompound ( const G4VHit & hit )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 929 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout << "G4HepRepFileSceneHandler::AddCompound(G4VHit&) " << G4endl;
#endif
 
  // Pointers to hold hit attribute values and definitions.
  std::vector<G4AttValue>* rawHitAttValues = hit.CreateAttValues();
  hitAttValues                             = new std::vector<G4AttValue>;
  hitAttDefs                               = new std::map<G4String, G4AttDef>;
 
  // Iterators to use with attribute values and definitions.
  std::vector<G4AttValue>::iterator iAttVal;
  std::map<G4String, G4AttDef>::const_iterator iAttDef;
 
  // Get hit attributes and definitions in standard HepRep style
  // (uniform units, 3Vectors decomposed).
  if(rawHitAttValues)
  {
    G4bool error = G4AttCheck(rawHitAttValues, hit.GetAttDefs())
                     .Standard(hitAttValues, hitAttDefs);
    if(error)
    {
      G4cout << "G4HepRepFileSceneHandler::AddCompound(hit):"
                "\nERROR found during conversion to standard hit attributes."
             << G4endl;
    }
#ifdef G4HEPREPFILEDEBUG
    G4cout << "G4HepRepFileSceneHandler::AddCompound(hit): standardised "
              "attributes:\n"
           << G4AttCheck(hitAttValues, hitAttDefs) << G4endl;
#endif
    delete rawHitAttValues;
  }
 
  // Open the HepRep output file if it is not already open.
  CheckFileOpen();
 
  // Add the Event Data Type if it hasn't already been added.
  if(strcmp("Event Data", hepRepXMLWriter->prevTypeName[0]) != 0)
  {
    hepRepXMLWriter->addType("Event Data", 0);
    hepRepXMLWriter->addInstance();
  }
 
  // Find out the current HitType.
  G4String hitType = "Hits";
  if(hitAttValues)
  {
    G4bool found = false;
    for(iAttVal = hitAttValues->begin();
        iAttVal != hitAttValues->end() && !found; ++iAttVal)
    {
      if(strcmp(iAttVal->GetName(), "HitType") == 0)
      {
        hitType = iAttVal->GetValue();
        found   = true;
      }
    }
  }
 
  // Add the Hits Type.
  G4String previousName = hepRepXMLWriter->prevTypeName[1];
  hepRepXMLWriter->addType(hitType, 1);
 
  // If this is the first hit of this event,
  // specify attribute values common to all hits.
  if(strcmp(hitType, previousName) != 0)
  {
    hepRepXMLWriter->addAttValue("Layer", 130);
 
    // Take all Hit attDefs from first hit.
    // Would rather be able to get these attDefs without needing a reference
    // from any particular hit, but don't know how to do that. Write out hit
    // attribute definitions.
    if(hitAttValues && hitAttDefs)
    {
      for(iAttVal = hitAttValues->begin(); iAttVal != hitAttValues->end();
          ++iAttVal)
      {
        iAttDef = hitAttDefs->find(iAttVal->GetName());
        if(iAttDef != hitAttDefs->end())
        {
          // Protect against incorrect use of Category.  Anything value other
          // than the standard ones will be considered to be in the physics
          // category.
          G4String category = iAttDef->second.GetCategory();
          if(strcmp(category, "Draw") != 0 &&
             strcmp(category, "Physics") != 0 &&
             strcmp(category, "Association") != 0 &&
             strcmp(category, "PickAction") != 0)
            category = "Physics";
          hepRepXMLWriter->addAttDef(iAttVal->GetName(),
                                     iAttDef->second.GetDesc(), category,
                                     iAttDef->second.GetExtra());
        }
      }
    }
  }  // end of special treatment for when this is the first hit.
 
  // Now that we have written out all of the attributes that are based on the
  // hit's particulars, call base class to deconstruct hit into a primitives.
  drawingHit  = true;
  doneInitHit = false;
  G4VSceneHandler::AddCompound(hit);  // Invoke default action.
  drawingHit = false;
}

◆ AddCompound() [6/6]

void G4HepRepFileSceneHandler::AddCompound ( const G4VTrajectory & traj )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 517 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout << "G4HepRepFileSceneHandler::AddCompound(const G4VTrajectory&) "
         << G4endl;
#endif
 
  G4TrajectoriesModel* pTrModel = dynamic_cast<G4TrajectoriesModel*>(fpModel);
  if(!pTrModel)
    G4Exception("G4HepRepFileSceneHandler::AddCompound(const G4VTrajectory&)",
                "vis-HepRep0001", FatalException, "Not a G4TrajectoriesModel.");
 
  // Pointers to hold trajectory attribute values and definitions.
  std::vector<G4AttValue>* rawTrajAttValues = traj.CreateAttValues();
  trajAttValues                             = new std::vector<G4AttValue>;
  trajAttDefs                               = new std::map<G4String, G4AttDef>;
 
  // Iterators to use with attribute values and definitions.
  std::vector<G4AttValue>::iterator iAttVal;
  std::map<G4String, G4AttDef>::const_iterator iAttDef;
  G4int i;
 
  // Get trajectory attributes and definitions in standard HepRep style
  // (uniform units, 3Vectors decomposed).
  if(rawTrajAttValues)
  {
    G4bool error = G4AttCheck(rawTrajAttValues, traj.GetAttDefs())
                     .Standard(trajAttValues, trajAttDefs);
    if(error)
    {
      G4cout
        << "G4HepRepFileSceneHandler::AddCompound(traj):"
           "\nERROR found during conversion to standard trajectory attributes."
        << G4endl;
    }
#ifdef G4HEPREPFILEDEBUG
    G4cout << "G4HepRepFileSceneHandler::AddCompound(traj): standardised "
              "attributes:\n"
           << G4AttCheck(trajAttValues, trajAttDefs) << G4endl;
#endif
    delete rawTrajAttValues;
  }
 
  // Open the HepRep output file if it is not already open.
  CheckFileOpen();
 
  // Add the Event Data Type if it hasn't already been added.
  if(strcmp("Event Data", hepRepXMLWriter->prevTypeName[0]) != 0)
  {
    hepRepXMLWriter->addType("Event Data", 0);
    hepRepXMLWriter->addInstance();
  }
 
  // Add the Trajectories Type.
  G4String previousName = hepRepXMLWriter->prevTypeName[1];
  hepRepXMLWriter->addType("Trajectories", 1);
 
  // If this is the first trajectory of this event,
  // specify attribute values common to all trajectories.
  if(strcmp("Trajectories", previousName) != 0)
  {
    hepRepXMLWriter->addAttValue("Layer", 100);
 
    // Take all Trajectory attDefs from first trajectory.
    // Would rather be able to get these attDefs without needing a reference
    // from any particular trajectory, but don't know how to do that. Write out
    // trajectory attribute definitions.
    if(trajAttValues && trajAttDefs)
    {
      for(iAttVal = trajAttValues->begin(); iAttVal != trajAttValues->end();
          ++iAttVal)
      {
        iAttDef = trajAttDefs->find(iAttVal->GetName());
        if(iAttDef != trajAttDefs->end())
        {
          // Protect against incorrect use of Category.  Anything value other
          // than the standard ones will be considered to be in the physics
          // category.
          G4String category = iAttDef->second.GetCategory();
          if(strcmp(category, "Draw") != 0 &&
             strcmp(category, "Physics") != 0 &&
             strcmp(category, "Association") != 0 &&
             strcmp(category, "PickAction") != 0)
            category = "Physics";
          hepRepXMLWriter->addAttDef(iAttVal->GetName(),
                                     iAttDef->second.GetDesc(), category,
                                     iAttDef->second.GetExtra());
        }
      }
    }
 
    // Take all TrajectoryPoint attDefs from first point of first trajectory.
    // Would rather be able to get these attDefs without needing a reference
    // from any particular point, but don't know how to do that.
    if((trajContext->GetDrawStepPts() || trajContext->GetDrawAuxPts()) &&
       traj.GetPointEntries() > 0)
    {
      G4VTrajectoryPoint* aTrajectoryPoint = traj.GetPoint(0);
 
      // Pointers to hold trajectory point attribute values and definitions.
      std::vector<G4AttValue>* rawPointAttValues =
        aTrajectoryPoint->CreateAttValues();
      std::vector<G4AttValue>* pointAttValues = new std::vector<G4AttValue>;
      std::map<G4String, G4AttDef>* pointAttDefs =
        new std::map<G4String, G4AttDef>;
 
      // Get first trajectory point's attributes and definitions in standard
      // HepRep style (uniform units, 3Vectors decomposed).
      if(rawPointAttValues)
      {
        G4bool error =
          G4AttCheck(rawPointAttValues, aTrajectoryPoint->GetAttDefs())
            .Standard(pointAttValues, pointAttDefs);
        if(error)
        {
          G4cout << "G4HepRepFileSceneHandler::AddCompound(traj):"
                    "\nERROR found during conversion to standard first point "
                    "attributes."
                 << G4endl;
        }
 
        // Write out point attribute definitions.
        if(pointAttValues && pointAttDefs)
        {
          for(iAttVal = pointAttValues->begin();
              iAttVal != pointAttValues->end(); ++iAttVal)
          {
            iAttDef = pointAttDefs->find(iAttVal->GetName());
            if(iAttDef != pointAttDefs->end())
            {
              // Protect against incorrect use of Category.  Anything value
              // other than the standard ones will be considered to be in the
              // physics category.
              G4String category = iAttDef->second.GetCategory();
              if(strcmp(category, "Draw") != 0 &&
                 strcmp(category, "Physics") != 0 &&
                 strcmp(category, "Association") != 0 &&
                 strcmp(category, "PickAction") != 0)
                category = "Physics";
              // Do not write out the Aux or Pos attribute.  Aux does not
              // conform to the HepRep rule that each object can have only one
              // instance of a given AttValue. Both of these attributes are
              // redundant to actual position information of the point.
              if(strcmp(iAttVal->GetName(), "Aux-X") != 0 &&
                 strcmp(iAttVal->GetName(), "Aux-Y") != 0 &&
                 strcmp(iAttVal->GetName(), "Aux-Z") != 0 &&
                 strcmp(iAttVal->GetName(), "Pos-X") != 0 &&
                 strcmp(iAttVal->GetName(), "Pos-Y") != 0 &&
                 strcmp(iAttVal->GetName(), "Pos-Z") != 0)
                hepRepXMLWriter->addAttDef(iAttVal->GetName(),
                                           iAttDef->second.GetDesc(), category,
                                           iAttDef->second.GetExtra());
            }
          }
        }
        delete rawPointAttValues;
      }
 
      // Clean up point attributes.
      if(pointAttValues)
        delete pointAttValues;
      if(pointAttDefs)
        delete pointAttDefs;
    }
  }  // end of special treatment for when this is the first trajectory.
 
  // Now that we have written out all of the attributes that are based on the
  // trajectory's particulars, call base class to deconstruct trajectory into
  // polyline and/or points (or nothing if trajectory is to be filtered out). If
  // base class calls for drawing points, no points will actually be drawn there
  // since we instead need to do point drawing from here (in order to obtain the
  // points attributes, not available from AddPrimitive(...point).  Instead,
  // such a call will just serve to set the flag that tells us that point
  // drawing was requested for this trajectory (depends on several factors
  // including trajContext and filtering).
  drawingTraj  = true;
  doneInitTraj = false;
  G4VSceneHandler::AddCompound(traj);
  drawingTraj = false;
 
  // Draw step points.
  if(trajContext->GetDrawStepPts())
  {
    if(!doneInitTraj)
      InitTrajectory();
    // Create Trajectory Points as a subType of Trajectories.
    // Note that we should create this heprep type even if there are no actual
    // points. This allows the user to tell that points don't exist (admittedly
    // odd) rather than that they were omitted by the drawing mode.
    previousName = hepRepXMLWriter->prevTypeName[2];
    hepRepXMLWriter->addType("Trajectory Step Points", 2);
 
    float redness;
    float greenness;
    float blueness;
    G4int markSize;
    G4bool visible;
    G4bool square;
    G4Colour colour = trajContext->GetStepPtsColour();
    redness         = colour.GetRed();
    greenness       = colour.GetGreen();
    blueness        = colour.GetBlue();
    markSize        = (G4int) trajContext->GetStepPtsSize();
    visible         = (G4int) trajContext->GetStepPtsVisible();
    square          = (trajContext->GetStepPtsType() == G4Polymarker::squares);
 
    // Avoiding drawing anything black on black.
    if(redness == 0. && greenness == 0. && blueness == 0.)
    {
      redness   = 1.;
      greenness = 1.;
      blueness  = 1.;
    }
 
    // Specify attributes common to all trajectory points.
    if(strcmp("Trajectory Step Points", previousName) != 0)
    {
      hepRepXMLWriter->addAttValue("DrawAs", "Point");
      hepRepXMLWriter->addAttValue("MarkColor", redness, greenness, blueness);
      hepRepXMLWriter->addAttValue("MarkSize", markSize);
      hepRepXMLWriter->addAttValue("Layer", 110);
      hepRepXMLWriter->addAttValue("Visibility", visible);
      if(square)
        hepRepXMLWriter->addAttValue("MarkName", "square");
      else
        hepRepXMLWriter->addAttValue("MarkName", "dot");
    }
 
    // Loop over all points on this trajectory.
    for(i = 0; i < traj.GetPointEntries(); i++)
    {
      G4VTrajectoryPoint* aTrajectoryPoint = traj.GetPoint(i);
 
      // Each point is a separate instance of the type Trajectory Points.
      hepRepXMLWriter->addInstance();
 
      // Pointers to hold trajectory point attribute values and definitions.
      std::vector<G4AttValue>* rawPointAttValues =
        aTrajectoryPoint->CreateAttValues();
      std::vector<G4AttValue>* pointAttValues = new std::vector<G4AttValue>;
      std::map<G4String, G4AttDef>* pointAttDefs =
        new std::map<G4String, G4AttDef>;
 
      // Get trajectory point attributes and definitions in standard HepRep
      // style (uniform units, 3Vectors decomposed).
      if(rawPointAttValues)
      {
        G4bool error =
          G4AttCheck(rawPointAttValues, aTrajectoryPoint->GetAttDefs())
            .Standard(pointAttValues, pointAttDefs);
        if(error)
        {
          G4cout
            << "G4HepRepFileSceneHandler::AddCompound(traj):"
               "\nERROR found during conversion to standard point attributes."
            << G4endl;
        }
 
        // Write out point attribute values.
        if(pointAttValues)
        {
          for(iAttVal = pointAttValues->begin();
              iAttVal != pointAttValues->end(); ++iAttVal)
            // Do not write out the Aux or Pos attribute.  Aux does not conform
            // to the HepRep rule that each object can have only one instance of
            // a given AttValue. Both of these attributes are redundant to
            // actual position information of the point.
            if(strcmp(iAttVal->GetName(), "Aux-X") != 0 &&
               strcmp(iAttVal->GetName(), "Aux-Y") != 0 &&
               strcmp(iAttVal->GetName(), "Aux-Z") != 0 &&
               strcmp(iAttVal->GetName(), "Pos-X") != 0 &&
               strcmp(iAttVal->GetName(), "Pos-Y") != 0 &&
               strcmp(iAttVal->GetName(), "Pos-Z") != 0)
              hepRepXMLWriter->addAttValue(iAttVal->GetName(),
                                           iAttVal->GetValue());
        }
      }
 
      // Clean up point attributes.
      delete pointAttDefs;
      delete pointAttValues;
      delete rawPointAttValues;
 
      // Each trajectory point is made of a single primitive, a point.
      hepRepXMLWriter->addPrimitive();
      G4Point3D vertex = aTrajectoryPoint->GetPosition();
      hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z());
    }
  }
 
  // Draw Auxiliary Points
  if(trajContext->GetDrawAuxPts())
  {
    if(!doneInitTraj)
      InitTrajectory();
    // Create Trajectory Points as a subType of Trajectories.
    // Note that we should create this heprep type even if there are no actual
    // points. This allows the user to tell that points don't exist (admittedly
    // odd) rather than that they were omitted by the drawing mode.
    previousName = hepRepXMLWriter->prevTypeName[2];
    hepRepXMLWriter->addType("Trajectory Auxiliary Points", 2);
 
    float redness;
    float greenness;
    float blueness;
    G4int markSize;
    G4bool visible;
    G4bool square;
    G4Colour colour = trajContext->GetAuxPtsColour();
    redness         = colour.GetRed();
    greenness       = colour.GetGreen();
    blueness        = colour.GetBlue();
    markSize        = (G4int) trajContext->GetAuxPtsSize();
    visible         = (G4int) trajContext->GetAuxPtsVisible();
    square          = (trajContext->GetAuxPtsType() == G4Polymarker::squares);
 
    // Avoiding drawing anything black on black.
    if(redness == 0. && greenness == 0. && blueness == 0.)
    {
      redness   = 1.;
      greenness = 1.;
      blueness  = 1.;
    }
 
    // Specify attributes common to all trajectory points.
    if(strcmp("Trajectory Auxiliary Points", previousName) != 0)
    {
      hepRepXMLWriter->addAttValue("DrawAs", "Point");
      hepRepXMLWriter->addAttValue("MarkColor", redness, greenness, blueness);
      hepRepXMLWriter->addAttValue("MarkSize", markSize);
      hepRepXMLWriter->addAttValue("Layer", 110);
      hepRepXMLWriter->addAttValue("Visibility", visible);
      if(square)
        hepRepXMLWriter->addAttValue("MarkName", "Square");
      else
        hepRepXMLWriter->addAttValue("MarkName", "Dot");
    }
 
    // Loop over all points on this trajectory.
    for(i = 0; i < traj.GetPointEntries(); i++)
    {
      G4VTrajectoryPoint* aTrajectoryPoint = traj.GetPoint(i);
 
      // Each point is a separate instance of the type Trajectory Points.
      hepRepXMLWriter->addInstance();
 
      // Pointers to hold trajectory point attribute values and definitions.
      std::vector<G4AttValue>* rawPointAttValues =
        aTrajectoryPoint->CreateAttValues();
      std::vector<G4AttValue>* pointAttValues = new std::vector<G4AttValue>;
      std::map<G4String, G4AttDef>* pointAttDefs =
        new std::map<G4String, G4AttDef>;
 
      // Get trajectory point attributes and definitions in standard HepRep
      // style (uniform units, 3Vectors decomposed).
      if(rawPointAttValues)
      {
        G4bool error =
          G4AttCheck(rawPointAttValues, aTrajectoryPoint->GetAttDefs())
            .Standard(pointAttValues, pointAttDefs);
        if(error)
        {
          G4cout
            << "G4HepRepFileSceneHandler::AddCompound(traj):"
               "\nERROR found during conversion to standard point attributes."
            << G4endl;
        }
 
        // Write out point attribute values.
        if(pointAttValues)
        {
          for(iAttVal = pointAttValues->begin();
              iAttVal != pointAttValues->end(); ++iAttVal)
            // Do not write out the Aux or Pos attribute.  Aux does not conform
            // to the HepRep rule that each object can have only one instance of
            // a given AttValue. Both of these attributes are redundant to
            // actual position information of the point.
            if(strcmp(iAttVal->GetName(), "Aux-X") != 0 &&
               strcmp(iAttVal->GetName(), "Aux-Y") != 0 &&
               strcmp(iAttVal->GetName(), "Aux-Z") != 0 &&
               strcmp(iAttVal->GetName(), "Pos-X") != 0 &&
               strcmp(iAttVal->GetName(), "Pos-Y") != 0 &&
               strcmp(iAttVal->GetName(), "Pos-Z") != 0)
              hepRepXMLWriter->addAttValue(iAttVal->GetName(),
                                           iAttVal->GetValue());
        }
      }
 
      // Clean up point attributes.
      delete pointAttDefs;
      delete pointAttValues;
      delete rawPointAttValues;
 
      // Each trajectory point is made of a single primitive, a point.
      G4Point3D vertex = aTrajectoryPoint->GetPosition();
 
      // Loop over auxiliary points associated with this Trajectory Point.
      const std::vector<G4ThreeVector>* auxiliaries =
        aTrajectoryPoint->GetAuxiliaryPoints();
      if(0 != auxiliaries)
      {
        for(size_t iAux = 0; iAux < auxiliaries->size(); ++iAux)
        {
          const G4ThreeVector auxPos((*auxiliaries)[iAux]);
          hepRepXMLWriter->addPrimitive();
          hepRepXMLWriter->addPoint(auxPos.x(), auxPos.y(), auxPos.z());
        }
      }
    }
  }
}

◆ AddPrimitive() [1/7]

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Circle & circle )

virtual

Implements G4VSceneHandler.

Definition at line 1244 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout
    << "G4HepRepFileSceneHandler::AddPrimitive(const G4Circle& circle) called:"
       "\n  radius: "
    << circle.GetWorldRadius() << G4endl;
  PrintThings();
#endif
 
  G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
 
  if(fpVisAttribs && (fpVisAttribs->IsVisible() == 0) &&
     messenger->getCullInvisibles())
    return;
 
  if(inPrimitives2D)
  {
    if(!warnedAbout2DMarkers)
    {
      G4cout << "HepRepFile does not currently support 2D circles." << G4endl;
      warnedAbout2DMarkers = true;
    }
    return;
  }
 
  MarkerSizeType sizeType;
  G4double size = GetMarkerSize(circle, sizeType);
  if(sizeType == world)
    size = 4.;
 
  if(drawingTraj)
    return;
 
  if(drawingHit)
    InitHit();
 
  haveVisible = true;
  AddHepRepInstance("Point", circle);
 
  hepRepXMLWriter->addAttValue("MarkName", "Dot");
  hepRepXMLWriter->addAttValue("MarkSize", (G4int) size);
 
  hepRepXMLWriter->addPrimitive();
 
  G4Point3D center = (fObjectTransformation) *circle.GetPosition();
  hepRepXMLWriter->addPoint(center.x(), center.y(), center.z());
}

◆ AddPrimitive() [2/7]

void G4VSceneHandler::AddPrimitive ( const G4Plotter & )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 193 of file G4VSceneHandler.cc.

                                                    {
  G4warn << "WARNING: Plotter not implemented for " << fSystem.GetName() << G4endl;
  G4warn << "  Open a plotter-aware graphics system or remove plotter with" << G4endl;
  G4warn << "  /vis/scene/removeModel Plotter" << G4endl;
}

◆ AddPrimitive() [3/7]

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Polyhedron & polyhedron )

virtual

Implements G4VSceneHandler.

Definition at line 1342 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout << "G4HepRepFileSceneHandler::AddPrimitive(const G4Polyhedron& "
            "polyhedron) called."
         << G4endl;
  PrintThings();
#endif
 
  G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
 
  if(fpVisAttribs && (fpVisAttribs->IsVisible() == 0) &&
     messenger->getCullInvisibles())
    return;
 
  if(polyhedron.GetNoFacets() == 0)
    return;
 
  if(drawingTraj)
    return;
 
  if(drawingHit)
    InitHit();
 
  haveVisible = true;
  AddHepRepInstance("Polygon", polyhedron);
 
  G4Normal3D surfaceNormal;
  G4Point3D vertex;
 
  G4bool notLastFace;
  do
  {
    hepRepXMLWriter->addPrimitive();
    notLastFace = polyhedron.GetNextNormal(surfaceNormal);
 
    G4int edgeFlag = 1;
    G4bool notLastEdge;
    do
    {
      notLastEdge = polyhedron.GetNextVertex(vertex, edgeFlag);
      vertex      = (fObjectTransformation) *vertex;
      hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z());
    } while(notLastEdge);
  } while(notLastFace);
}

◆ AddPrimitive() [4/7]

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Polyline & polyline )

virtual

Implements G4VSceneHandler.

Definition at line 1087 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout << "G4HepRepFileSceneHandler::AddPrimitive(const G4Polyline& "
            "polyline) called:"
            "\n  polyline: "
         << polyline << G4endl;
  PrintThings();
#endif
 
  G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
 
  if(fpVisAttribs && (fpVisAttribs->IsVisible() == 0) &&
     messenger->getCullInvisibles())
    return;
 
  if(inPrimitives2D)
  {
    if(!warnedAbout2DMarkers)
    {
      G4cout << "HepRepFile does not currently support 2D lines." << G4endl;
      warnedAbout2DMarkers = true;
    }
    return;
  }
 
  if(drawingTraj)
    InitTrajectory();
 
  if(drawingHit)
    InitHit();
 
  haveVisible = true;
  AddHepRepInstance("Line", polyline);
 
  hepRepXMLWriter->addPrimitive();
 
  for(size_t i = 0; i < polyline.size(); i++)
  {
    G4Point3D vertex = (fObjectTransformation) *polyline[i];
    hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z());
  }
}

◆ AddPrimitive() [5/7]

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Polymarker & line )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1131 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout
    << "G4HepRepFileSceneHandler::AddPrimitive(const G4Polymarker& line) called"
    << G4endl;
  PrintThings();
#endif
 
  G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
 
  if(fpVisAttribs && (fpVisAttribs->IsVisible() == 0) &&
     messenger->getCullInvisibles())
    return;
 
  if(inPrimitives2D)
  {
    if(!warnedAbout2DMarkers)
    {
      G4cout << "HepRepFile does not currently support 2D lines." << G4endl;
      warnedAbout2DMarkers = true;
    }
    return;
  }
 
  MarkerSizeType sizeType;
  G4double size = GetMarkerSize(line, sizeType);
  if(sizeType == world)
    size = 4.;
 
  if(drawingTraj)
    return;
 
  if(drawingHit)
    InitHit();
 
  haveVisible = true;
  AddHepRepInstance("Point", line);
 
  hepRepXMLWriter->addAttValue("MarkName", "Dot");
  hepRepXMLWriter->addAttValue("MarkSize", (G4int) size);
 
  hepRepXMLWriter->addPrimitive();
 
  for(size_t i = 0; i < line.size(); i++)
  {
    G4Point3D vertex = (fObjectTransformation) *line[i];
    hepRepXMLWriter->addPoint(vertex.x(), vertex.y(), vertex.z());
  }
}

◆ AddPrimitive() [6/7]

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Square & square )

virtual

Implements G4VSceneHandler.

Definition at line 1293 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout
    << "G4HepRepFileSceneHandler::AddPrimitive(const G4Square& square) called:"
       "\n  side: "
    << square.GetWorldRadius() << G4endl;
  PrintThings();
#endif
 
  G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
 
  if(fpVisAttribs && (fpVisAttribs->IsVisible() == 0) &&
     messenger->getCullInvisibles())
    return;
 
  if(inPrimitives2D)
  {
    if(!warnedAbout2DMarkers)
    {
      G4cout << "HepRepFile does not currently support 2D squares." << G4endl;
      warnedAbout2DMarkers = true;
    }
    return;
  }
 
  MarkerSizeType sizeType;
  G4double size = GetMarkerSize(square, sizeType);
  if(sizeType == world)
    size = 4.;
 
  if(drawingTraj)
    return;
 
  if(drawingHit)
    InitHit();
 
  haveVisible = true;
  AddHepRepInstance("Point", square);
 
  hepRepXMLWriter->addAttValue("MarkName", "Square");
  hepRepXMLWriter->addAttValue("MarkSize", (G4int) size);
 
  hepRepXMLWriter->addPrimitive();
 
  G4Point3D center = (fObjectTransformation) *square.GetPosition();
  hepRepXMLWriter->addPoint(center.x(), center.y(), center.z());
}

◆ AddPrimitive() [7/7]

void G4HepRepFileSceneHandler::AddPrimitive ( const G4Text & text )

virtual

Implements G4VSceneHandler.

Definition at line 1182 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout << "G4HepRepFileSceneHandler::AddPrimitive(const G4Text& text) called:"
            "\n  text: "
         << text.GetText() << G4endl;
  PrintThings();
#endif
 
  if(!inPrimitives2D)
  {
    if(!warnedAbout3DText)
    {
      G4cout << "HepRepFile does not currently support 3D text." << G4endl;
      G4cout
        << "HepRep browsers can directly display text attributes on request."
        << G4endl;
      G4cout << "See Application Developers Guide for how to attach attributes "
                "to viewable objects."
             << G4endl;
      warnedAbout3DText = true;
    }
    return;
  }
 
  MarkerSizeType sizeType;
  G4double size = GetMarkerSize(text, sizeType);
  if(sizeType == world)
    size = 12.;
 
  haveVisible = true;
  AddHepRepInstance("Text", text);
 
  hepRepXMLWriter->addAttValue("VAlign", "Top");
  hepRepXMLWriter->addAttValue("HAlign", "Left");
  hepRepXMLWriter->addAttValue("FontName", "Arial");
  hepRepXMLWriter->addAttValue("FontStyle", "Plain");
  hepRepXMLWriter->addAttValue("FontSize", (G4int) size);
  hepRepXMLWriter->addAttValue("FontHasBanner", "TRUE");
  hepRepXMLWriter->addAttValue("FontBannerColor", "0,0,0");
 
  const G4Colour& colour = GetTextColour(text);
  float redness          = colour.GetRed();
  float greenness        = colour.GetGreen();
  float blueness         = colour.GetBlue();
 
  // Avoiding drawing anything black on black.
  if(redness == 0. && greenness == 0. && blueness == 0.)
  {
    redness   = 1.;
    greenness = 1.;
    blueness  = 1.;
  }
  hepRepXMLWriter->addAttValue("FontColor", redness, greenness, blueness);
 
  hepRepXMLWriter->addPrimitive();
 
  hepRepXMLWriter->addAttValue("Text", text.GetText());
  hepRepXMLWriter->addAttValue("VPos", .99 - text.GetYOffset());
  hepRepXMLWriter->addAttValue("HPos", text.GetXOffset());
}

◆ AddSolid() [1/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Box & box )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 145 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout << "G4HepRepFileSceneHandler::AddSolid(const G4Box& box) called for "
         << box.GetName() << G4endl;
  PrintThings();
#endif
 
  if(drawingTraj)
    return;
 
  if(drawingHit)
    InitHit();
 
  haveVisible = false;
  AddHepRepInstance("Prism", NULL);
 
  G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
 
  // Get and check applicable vis attributes.
  fpVisAttribs = fpViewer->GetApplicableVisAttributes(fpVisAttribs);
  if(fpVisAttribs && (fpVisAttribs->IsVisible() == 0) &&
     messenger->getCullInvisibles())
    return;
 
  hepRepXMLWriter->addPrimitive();
 
  G4double dx = box.GetXHalfLength();
  G4double dy = box.GetYHalfLength();
  G4double dz = box.GetZHalfLength();
 
  G4Point3D vertex1(G4Point3D(dx, dy, -dz));
  G4Point3D vertex2(G4Point3D(dx, -dy, -dz));
  G4Point3D vertex3(G4Point3D(-dx, -dy, -dz));
  G4Point3D vertex4(G4Point3D(-dx, dy, -dz));
  G4Point3D vertex5(G4Point3D(dx, dy, dz));
  G4Point3D vertex6(G4Point3D(dx, -dy, dz));
  G4Point3D vertex7(G4Point3D(-dx, -dy, dz));
  G4Point3D vertex8(G4Point3D(-dx, dy, dz));
 
  vertex1 = (fObjectTransformation) *vertex1;
  vertex2 = (fObjectTransformation) *vertex2;
  vertex3 = (fObjectTransformation) *vertex3;
  vertex4 = (fObjectTransformation) *vertex4;
  vertex5 = (fObjectTransformation) *vertex5;
  vertex6 = (fObjectTransformation) *vertex6;
  vertex7 = (fObjectTransformation) *vertex7;
  vertex8 = (fObjectTransformation) *vertex8;
 
  hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z());
  hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
  hepRepXMLWriter->addPoint(vertex3.x(), vertex3.y(), vertex3.z());
  hepRepXMLWriter->addPoint(vertex4.x(), vertex4.y(), vertex4.z());
  hepRepXMLWriter->addPoint(vertex5.x(), vertex5.y(), vertex5.z());
  hepRepXMLWriter->addPoint(vertex6.x(), vertex6.y(), vertex6.z());
  hepRepXMLWriter->addPoint(vertex7.x(), vertex7.y(), vertex7.z());
  hepRepXMLWriter->addPoint(vertex8.x(), vertex8.y(), vertex8.z());
}

◆ AddSolid() [2/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Cons & cons )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 204 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout << "G4HepRepFileSceneHandler::AddSolid(const G4Cons& cons) called for "
         << cons.GetName() << G4endl;
  PrintThings();
#endif
 
  // HepRApp does not correctly represent the end faces of cones at
  // non-standard angles, let the base class convert these solids to polygons.
  G4RotationMatrix r = fObjectTransformation.getRotation();
  G4bool linedUpWithAnAxis =
    (std::fabs(r.phiX()) <= .001 || std::fabs(r.phiY()) <= .001 ||
     std::fabs(r.phiZ()) <= .001 || std::fabs(r.phiX() - pi) <= .001 ||
     std::fabs(r.phiY() - pi) <= .001 || std::fabs(r.phiZ() - pi) <= .001);
  // G4cout << "Angle X:" << r.phiX() << ", Angle Y:" << r.phiY() << ", Angle
  // Z:" << r.phiZ() << G4endl; G4cout << "linedUpWithAnAxis:" <<
  // linedUpWithAnAxis << G4endl;
 
  // HepRep does not have a primitive for a cut cone,
  // so if this cone is cut, let the base class convert this
  // solid to polygons.
  G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
  if(cons.GetDeltaPhiAngle() < twopi || !linedUpWithAnAxis ||
     messenger->renderCylAsPolygons())
  {
    G4VSceneHandler::AddSolid(cons);  // Invoke default action.
  }
  else
  {
    if(drawingTraj)
      return;
 
    if(drawingHit)
      InitHit();
 
    haveVisible = false;
    AddHepRepInstance("Cylinder", NULL);
 
    // Get and check applicable vis attributes.
    fpVisAttribs = fpViewer->GetApplicableVisAttributes(fpVisAttribs);
    if(fpVisAttribs && (fpVisAttribs->IsVisible() == 0) &&
       messenger->getCullInvisibles())
      return;
 
    G4Point3D vertex1(G4Point3D(0., 0., -cons.GetZHalfLength()));
    G4Point3D vertex2(G4Point3D(0., 0., cons.GetZHalfLength()));
 
    vertex1 = (fObjectTransformation) *vertex1;
    vertex2 = (fObjectTransformation) *vertex2;
 
    // Outer cylinder.
    hepRepXMLWriter->addPrimitive();
    hepRepXMLWriter->addAttValue("Radius1", messenger->getScale() *
                                              cons.GetOuterRadiusMinusZ());
    hepRepXMLWriter->addAttValue("Radius2", messenger->getScale() *
                                              cons.GetOuterRadiusPlusZ());
    hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z());
    hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
 
    // Inner cylinder.
    hepRepXMLWriter->addPrimitive();
    hepRepXMLWriter->addAttValue("Radius1", messenger->getScale() *
                                              cons.GetInnerRadiusMinusZ());
    hepRepXMLWriter->addAttValue("Radius2", messenger->getScale() *
                                              cons.GetInnerRadiusPlusZ());
    hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z());
    hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
  }
}

◆ AddSolid() [3/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Ellipsoid & ellipsoid )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 484 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout << "G4HepRepFileSceneHandler::AddSolid(const G4Ellipsoid& ellipsoid) "
            "called for "
         << ellipsoid.GetName() << G4endl;
  PrintThings();
#endif
  G4VSceneHandler::AddSolid(ellipsoid);  // Invoke default action.
}

◆ AddSolid() [4/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Orb & orb )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 474 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout << "G4HepRepFileSceneHandler::AddSolid(const G4Orb& orb) called for "
         << orb.GetName() << G4endl;
  PrintThings();
#endif
  G4VSceneHandler::AddSolid(orb);  // Invoke default action.
}

◆ AddSolid() [5/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Para & para )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 431 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout << "G4HepRepFileSceneHandler::AddSolid(const G4Para& para) called for "
         << para.GetName() << G4endl;
  PrintThings();
#endif
  G4VSceneHandler::AddSolid(para);  // Invoke default action.
}

◆ AddSolid() [6/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Polycone & polycone )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 452 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout << "G4HepRepFileSceneHandler::AddSolid(const G4Polycone& polycone) "
            "called for "
         << polycone.GetName() << G4endl;
  PrintThings();
#endif
  G4VSceneHandler::AddSolid(polycone);  // Invoke default action.
}

◆ AddSolid() [7/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Polyhedra & polyhedra )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 463 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout << "G4HepRepFileSceneHandler::AddSolid(const G4Polyhedra& polyhedra) "
            "called for "
         << polyhedra.GetName() << G4endl;
  PrintThings();
#endif
  G4VSceneHandler::AddSolid(polyhedra);  // Invoke default action.
}

◆ AddSolid() [8/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Sphere & sphere )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 420 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout
    << "G4HepRepFileSceneHandler::AddSolid(const G4Sphere& sphere) called for "
    << sphere.GetName() << G4endl;
  PrintThings();
#endif
  G4VSceneHandler::AddSolid(sphere);  // Invoke default action.
}

◆ AddSolid() [9/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4TessellatedSolid & tess )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 495 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout << "G4HepRepFileSceneHandler::AddSolid(const G4TessellatedSolid& ) "
            "called for "
         << tess.GetName() << G4endl;
  PrintThings();
#endif
  G4VSceneHandler::AddSolid(tess);  // Invoke default action.
}

◆ AddSolid() [10/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Torus & torus )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 441 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout
    << "G4HepRepFileSceneHandler::AddSolid(const G4Torus& torus) called for "
    << torus.GetName() << G4endl;
  PrintThings();
#endif
  G4VSceneHandler::AddSolid(torus);  // Invoke default action.
}

◆ AddSolid() [11/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Trap & trap )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 410 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout << "G4HepRepFileSceneHandler::AddSolid(const G4Trap& trap) called for "
         << trap.GetName() << G4endl;
  PrintThings();
#endif
  G4VSceneHandler::AddSolid(trap);  // Invoke default action.
}

◆ AddSolid() [12/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Trd & trd )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 349 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout << "G4HepRepFileSceneHandler::AddSolid(const G4Trd& trd) called for "
         << trd.GetName() << G4endl;
  PrintThings();
#endif
 
  if(drawingTraj)
    return;
 
  if(drawingHit)
    InitHit();
 
  haveVisible = false;
  AddHepRepInstance("Prism", NULL);
 
  G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
 
  // Get and check applicable vis attributes.
  fpVisAttribs = fpViewer->GetApplicableVisAttributes(fpVisAttribs);
  if(fpVisAttribs && (fpVisAttribs->IsVisible() == 0) &&
     messenger->getCullInvisibles())
    return;
 
  hepRepXMLWriter->addPrimitive();
 
  G4double dx1 = trd.GetXHalfLength1();
  G4double dy1 = trd.GetYHalfLength1();
  G4double dx2 = trd.GetXHalfLength2();
  G4double dy2 = trd.GetYHalfLength2();
  G4double dz  = trd.GetZHalfLength();
 
  G4Point3D vertex1(G4Point3D(dx1, dy1, -dz));
  G4Point3D vertex2(G4Point3D(dx1, -dy1, -dz));
  G4Point3D vertex3(G4Point3D(-dx1, -dy1, -dz));
  G4Point3D vertex4(G4Point3D(-dx1, dy1, -dz));
  G4Point3D vertex5(G4Point3D(dx2, dy2, dz));
  G4Point3D vertex6(G4Point3D(dx2, -dy2, dz));
  G4Point3D vertex7(G4Point3D(-dx2, -dy2, dz));
  G4Point3D vertex8(G4Point3D(-dx2, dy2, dz));
 
  vertex1 = (fObjectTransformation) *vertex1;
  vertex2 = (fObjectTransformation) *vertex2;
  vertex3 = (fObjectTransformation) *vertex3;
  vertex4 = (fObjectTransformation) *vertex4;
  vertex5 = (fObjectTransformation) *vertex5;
  vertex6 = (fObjectTransformation) *vertex6;
  vertex7 = (fObjectTransformation) *vertex7;
  vertex8 = (fObjectTransformation) *vertex8;
 
  hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z());
  hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
  hepRepXMLWriter->addPoint(vertex3.x(), vertex3.y(), vertex3.z());
  hepRepXMLWriter->addPoint(vertex4.x(), vertex4.y(), vertex4.z());
  hepRepXMLWriter->addPoint(vertex5.x(), vertex5.y(), vertex5.z());
  hepRepXMLWriter->addPoint(vertex6.x(), vertex6.y(), vertex6.z());
  hepRepXMLWriter->addPoint(vertex7.x(), vertex7.y(), vertex7.z());
  hepRepXMLWriter->addPoint(vertex8.x(), vertex8.y(), vertex8.z());
}

◆ AddSolid() [13/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4Tubs & tubs )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 275 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout << "G4HepRepFileSceneHandler::AddSolid(const G4Tubs& tubs) called for "
         << tubs.GetName() << G4endl;
  PrintThings();
#endif
 
  // HepRApp does not correctly represent the end faces of cylinders at
  // non-standard angles, let the base class convert these solids to polygons.
  G4RotationMatrix r = fObjectTransformation.getRotation();
  G4bool linedUpWithAnAxis =
    (std::fabs(r.phiX()) <= .001 || std::fabs(r.phiY()) <= .001 ||
     std::fabs(r.phiZ()) <= .001 || std::fabs(r.phiX() - pi) <= .001 ||
     std::fabs(r.phiY() - pi) <= .001 || std::fabs(r.phiZ() - pi) <= .001);
  // G4cout << "Angle X:" << r.phiX() << ", Angle Y:" << r.phiY() << ", Angle
  // Z:" << r.phiZ() << G4endl; G4cout << "linedUpWithAnAxis:" <<
  // linedUpWithAnAxis << G4endl;
 
  // HepRep does not have a primitive for a cut cylinder,
  // so if this cylinder is cut, let the base class convert this
  // solid to polygons.
  G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
  if(tubs.GetDeltaPhiAngle() < twopi || !linedUpWithAnAxis ||
     messenger->renderCylAsPolygons())
  {
    G4VSceneHandler::AddSolid(tubs);  // Invoke default action.
  }
  else
  {
    if(drawingTraj)
      return;
 
    if(drawingHit)
      InitHit();
 
    haveVisible = false;
    AddHepRepInstance("Cylinder", NULL);
 
    // Get and check applicable vis attributes.
    fpVisAttribs = fpViewer->GetApplicableVisAttributes(fpVisAttribs);
    if(fpVisAttribs && (fpVisAttribs->IsVisible() == 0) &&
       messenger->getCullInvisibles())
      return;
 
    G4Point3D vertex1(G4Point3D(0., 0., -tubs.GetZHalfLength()));
    G4Point3D vertex2(G4Point3D(0., 0., tubs.GetZHalfLength()));
 
    vertex1 = (fObjectTransformation) *vertex1;
    vertex2 = (fObjectTransformation) *vertex2;
 
    // Outer cylinder.
    hepRepXMLWriter->addPrimitive();
    hepRepXMLWriter->addAttValue("Radius1",
                                 messenger->getScale() * tubs.GetOuterRadius());
    hepRepXMLWriter->addAttValue("Radius2",
                                 messenger->getScale() * tubs.GetOuterRadius());
    hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z());
    hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
 
    // Inner cylinder.
    if(tubs.GetInnerRadius() != 0.)
    {
      hepRepXMLWriter->addPrimitive();
      hepRepXMLWriter->addAttValue("Radius1", messenger->getScale() *
                                                tubs.GetInnerRadius());
      hepRepXMLWriter->addAttValue("Radius2", messenger->getScale() *
                                                tubs.GetInnerRadius());
      hepRepXMLWriter->addPoint(vertex1.x(), vertex1.y(), vertex1.z());
      hepRepXMLWriter->addPoint(vertex2.x(), vertex2.y(), vertex2.z());
    }
  }
}

◆ AddSolid() [14/14]

void G4HepRepFileSceneHandler::AddSolid ( const G4VSolid & solid )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 506 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout
    << "G4HepRepFileSceneHandler::AddSolid(const G4Solid& solid) called for "
    << solid.GetName() << G4endl;
  PrintThings();
#endif
  G4VSceneHandler::AddSolid(solid);  // Invoke default action.
}

◆ BeginModeling()

void G4HepRepFileSceneHandler::BeginModeling ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 93 of file G4HepRepFileSceneHandler.cc.

{
  G4VisManager* visManager        = G4VisManager::GetInstance();
  const G4VTrajectoryModel* model = visManager->CurrentTrajDrawModel();
  trajContext                     = &model->GetContext();
 
  G4VSceneHandler::BeginModeling();  // Required: see G4VSceneHandler.hh.
}

◆ BeginPrimitives2D()

void G4HepRepFileSceneHandler::BeginPrimitives2D ( const G4Transform3D & objectTransformation )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 107 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout << "G4HepRepFileSceneHandler::BeginPrimitives2D() " << G4endl;
#endif
  inPrimitives2D = true;
  G4VSceneHandler::BeginPrimitives2D(objectTransformation);
}

◆ ClearTransientStore()

void G4HepRepFileSceneHandler::ClearTransientStore ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1713 of file G4HepRepFileSceneHandler.cc.

{
  // This is typically called after an update and before drawing hits
  // of the next event.  To simulate the clearing of "transients"
  // (hits, etc.) the detector is redrawn...
  if(fpViewer)
  {
    fpViewer->SetView();
    fpViewer->ClearView();
    fpViewer->DrawView();
  }
}

◆ EndModeling()

void G4HepRepFileSceneHandler::EndModeling ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 102 of file G4HepRepFileSceneHandler.cc.

{
  G4VSceneHandler::EndModeling();  // Required: see G4VSceneHandler.hh.
}

◆ EndPrimitives2D()

void G4HepRepFileSceneHandler::EndPrimitives2D ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 117 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout << "G4HepRepFileSceneHandler::EndPrimitives2D() " << G4endl;
#endif
  G4VSceneHandler::EndPrimitives2D();
  inPrimitives2D = false;
}

◆ GetHepRepXMLWriter()

G4HepRepFileXMLWriter * G4HepRepFileSceneHandler::GetHepRepXMLWriter ( )

Definition at line 1389 of file G4HepRepFileSceneHandler.cc.

{
  return hepRepXMLWriter;
}

Referenced by G4HepRepFileSceneHandler().

◆ InitHit()

void G4HepRepFileSceneHandler::InitHit ( )

Definition at line 1062 of file G4HepRepFileSceneHandler.cc.

{
  if(!doneInitHit)
  {
    // For every hit, add an instance of Type Hit.
    hepRepXMLWriter->addInstance();
 
    // Write out the hit's attribute values.
    if(hitAttValues)
    {
      std::vector<G4AttValue>::iterator iAttVal;
      for(iAttVal = hitAttValues->begin(); iAttVal != hitAttValues->end();
          ++iAttVal)
        hepRepXMLWriter->addAttValue(iAttVal->GetName(), iAttVal->GetValue());
      delete hitAttValues;
    }
 
    // Clean up hit attributes.
    if(hitAttDefs)
      delete hitAttDefs;
 
    doneInitHit = true;
  }
}

Referenced by AddPrimitive(), AddPrimitive(), AddPrimitive(), AddPrimitive(), AddPrimitive(), AddSolid(), AddSolid(), AddSolid(), and AddSolid().

◆ InitTrajectory()

void G4HepRepFileSceneHandler::InitTrajectory ( )

Definition at line 1037 of file G4HepRepFileSceneHandler.cc.

{
  if(!doneInitTraj)
  {
    // For every trajectory, add an instance of Type Trajectory.
    hepRepXMLWriter->addInstance();
 
    // Write out the trajectory's attribute values.
    if(trajAttValues)
    {
      std::vector<G4AttValue>::iterator iAttVal;
      for(iAttVal = trajAttValues->begin(); iAttVal != trajAttValues->end();
          ++iAttVal)
        hepRepXMLWriter->addAttValue(iAttVal->GetName(), iAttVal->GetValue());
      delete trajAttValues;
    }
 
    // Clean up trajectory attributes.
    if(trajAttDefs)
      delete trajAttDefs;
 
    doneInitTraj = true;
  }
}

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:

Public Member Functions

Static Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4HepRepFileSceneHandler()

◆ ~G4HepRepFileSceneHandler()

Member Function Documentation

◆ AddCompound() [1/6]

◆ AddCompound() [2/6]

◆ AddCompound() [3/6]

◆ AddCompound() [4/6]

◆ AddCompound() [5/6]

◆ AddCompound() [6/6]

◆ AddPrimitive() [1/7]

◆ AddPrimitive() [2/7]

◆ AddPrimitive() [3/7]

◆ AddPrimitive() [4/7]

◆ AddPrimitive() [5/7]

◆ AddPrimitive() [6/7]

◆ AddPrimitive() [7/7]

◆ AddSolid() [1/14]

◆ AddSolid() [2/14]

◆ AddSolid() [3/14]

◆ AddSolid() [4/14]

◆ AddSolid() [5/14]

◆ AddSolid() [6/14]

◆ AddSolid() [7/14]

◆ AddSolid() [8/14]

◆ AddSolid() [9/14]

◆ AddSolid() [10/14]

◆ AddSolid() [11/14]

◆ AddSolid() [12/14]

◆ AddSolid() [13/14]

◆ AddSolid() [14/14]

◆ BeginModeling()

◆ BeginPrimitives2D()

◆ ClearTransientStore()

◆ EndModeling()

◆ EndPrimitives2D()

◆ GetHepRepXMLWriter()

◆ InitHit()

◆ InitTrajectory()

Member Data Documentation

◆ fSceneIdCount