#include <G4HepRepFileSceneHandler.hh>

Inheritance diagram for G4HepRepFileSceneHandler:

Public Types
enum	MarkerSizeType { world , screen }

Public Member Functions
virtual void	AddCompound (const G4Mesh &)

virtual void	AddCompound (const G4THitsMap< G4double > &)

virtual void	AddCompound (const G4THitsMap< G4StatDouble > &)

virtual void	AddCompound (const G4VDigi &)

virtual void	AddCompound (const G4VHit &)

void	AddCompound (const G4VHit &)

virtual void	AddCompound (const G4VTrajectory &)

void	AddCompound (const G4VTrajectory &)

void	AddPrimitive (const G4Circle &)

virtual void	AddPrimitive (const G4Circle &)=0

virtual void	AddPrimitive (const G4Plotter &)

void	AddPrimitive (const G4Polyhedron &)

virtual void	AddPrimitive (const G4Polyhedron &)=0

void	AddPrimitive (const G4Polyline &)

virtual void	AddPrimitive (const G4Polyline &)=0

virtual void	AddPrimitive (const G4Polymarker &)

void	AddPrimitive (const G4Polymarker &)

void	AddPrimitive (const G4Square &)

virtual void	AddPrimitive (const G4Square &)=0

void	AddPrimitive (const G4Text &)

virtual void	AddPrimitive (const G4Text &)=0

void	AddSolid (const G4Box &)

void	AddSolid (const G4Cons &)

void	AddSolid (const G4Ellipsoid &)

void	AddSolid (const G4Orb &)

void	AddSolid (const G4Para &)

void	AddSolid (const G4Polycone &)

void	AddSolid (const G4Polyhedra &)

void	AddSolid (const G4Sphere &)

void	AddSolid (const G4TessellatedSolid &)

void	AddSolid (const G4Torus &)

void	AddSolid (const G4Trap &)

void	AddSolid (const G4Trd &)

void	AddSolid (const G4Tubs &)

void	AddSolid (const G4VSolid &)

template<class T >
void	AddSolidT (const T &solid)

template<class T >
void	AddSolidWithAuxiliaryEdges (const T &solid)

void	AddViewerToList (G4VViewer *pView)

void	BeginModeling ()

virtual void	BeginPrimitives (const G4Transform3D &objectTransformation=G4Transform3D())

void	BeginPrimitives2D (const G4Transform3D &objectTransformation)

virtual void	ClearStore ()

void	ClearTransientStore ()

G4ModelingParameters *	CreateModelingParameters ()

void	DrawEndOfRunModels ()

void	DrawEvent (const G4Event *)

void	EndModeling ()

virtual void	EndPrimitives ()

void	EndPrimitives2D ()

	G4HepRepFileSceneHandler (G4VGraphicsSystem &system, const G4String &name)

G4bool	GetAuxEdgeVisible (const G4VisAttributes *)

const G4Colour &	GetColor ()

const G4Colour &	GetColor (const G4Visible &)

const G4Colour &	GetColour ()

const G4Colour &	GetColour (const G4Visible &)

G4VViewer *	GetCurrentViewer () const

G4ViewParameters::DrawingStyle	GetDrawingStyle (const G4VisAttributes *)

virtual const G4VisExtent &	GetExtent () const

G4VGraphicsSystem *	GetGraphicsSystem () const

G4HepRepFileXMLWriter *	GetHepRepXMLWriter ()

G4double	GetLineWidth (const G4VisAttributes *)

G4double	GetMarkerDiameter (const G4VMarker &, MarkerSizeType &)

G4double	GetMarkerRadius (const G4VMarker &, MarkerSizeType &)

G4double	GetMarkerSize (const G4VMarker &, MarkerSizeType &)

G4bool	GetMarkForClearingTransientStore () const

G4VModel *	GetModel () const

const G4String &	GetName () const

G4int	GetNoOfSides (const G4VisAttributes *)

G4int	GetNumberOfCloudPoints (const G4VisAttributes *) const

const G4Transform3D &	GetObjectTransformation () const

G4Scene *	GetScene () const

G4int	GetSceneHandlerId () const

const G4Colour &	GetTextColor (const G4Text &)

const G4Colour &	GetTextColour (const G4Text &)

G4bool	GetTransientsDrawnThisEvent () const

G4bool	GetTransientsDrawnThisRun () const

G4int	GetViewCount () const

const G4ViewerList &	GetViewerList () const

G4int	IncrementViewCount ()

void	InitHit ()

void	InitTrajectory ()

G4bool	IsReadyForTransients () const

virtual void	PostAddSolid ()

virtual void	PreAddSolid (const G4Transform3D &objectTransformation, const G4VisAttributes &)

void	RemoveViewerFromList (G4VViewer *pView)

void	SetCurrentViewer (G4VViewer *)

void	SetMarkForClearingTransientStore (G4bool)

void	SetModel (G4VModel *)

void	SetName (const G4String &)

void	SetObjectTransformation (const G4Transform3D &)

virtual void	SetScene (G4Scene *)

void	SetTransientsDrawnThisEvent (G4bool)

void	SetTransientsDrawnThisRun (G4bool)

G4ViewerList &	SetViewerList ()

virtual	~G4HepRepFileSceneHandler ()

Protected Member Functions
virtual G4DisplacedSolid *	CreateCutawaySolid ()

virtual G4DisplacedSolid *	CreateSectionSolid ()

void	LoadAtts (const G4Visible &, G4AttHolder *)

virtual void	ProcessScene ()

virtual void	RequestPrimitives (const G4VSolid &solid)

Static Protected Attributes
static G4int	fSceneIdCount = 0

Private Member Functions
void	AddHepRepInstance (const char *primName, const G4Visible visible)

void	CheckFileOpen ()

Private Attributes
G4bool	doneInitHit

G4bool	doneInitTraj

G4bool	drawingHit

G4bool	drawingTraj

int	fileCounter

G4bool	haveVisible

G4HepRepFileXMLWriter *	hepRepXMLWriter

std::map< G4String, G4AttDef > *	hitAttDefs

std::vector< G4AttValue > *	hitAttValues

G4bool	inPrimitives2D

std::map< G4String, G4AttDef > *	trajAttDefs

std::vector< G4AttValue > *	trajAttValues

const G4VisTrajContext *	trajContext

G4bool	warnedAbout2DMarkers

G4bool	warnedAbout3DText

Detailed Description

Definition at line 58 of file G4HepRepFileSceneHandler.hh.

Member Enumeration Documentation

◆ MarkerSizeType

enum G4VSceneHandler::MarkerSizeType

inherited

Enumerator
world
screen

Definition at line 58 of file G4VSceneHandler.hh.

58{world, screen};

G4VSceneHandler::screen

@ screen

Definition: G4VSceneHandler.hh:58

G4VSceneHandler::world

@ world

Definition: G4VSceneHandler.hh:58

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;
}

References doneInitHit, doneInitTraj, drawingHit, drawingTraj, fileCounter, GetHepRepXMLWriter(), haveVisible, hepRepXMLWriter, hitAttDefs, hitAttValues, inPrimitives2D, trajAttDefs, trajAttValues, trajContext, warnedAbout2DMarkers, and warnedAbout3DText.

◆ ~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 132 of file G4VSceneHandler.cc.

{
  G4ExceptionDescription ed;
  ed << "There has been an attempt to draw a mesh (a nested parameterisation),"
  "\nbut it is not implemented by the current graphics driver. Here we simply"
  "\ndraw the container, \"" << mesh.GetContainerVolume()->GetName() << "\".";
  G4Exception("G4VSceneHandler::AddCompound(const G4Mesh&)",
          "visman0107", JustWarning, ed);
 
  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
  const auto& saveVisAtts = lv->GetVisAttributes();
  auto 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/8]

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

virtual

Reimplemented from G4VSceneHandler.

Definition at line 130 of file G4VSceneHandler.cc.

                                                                   {
  using MeshScoreMap = G4VScoringMesh::MeshScoreMap;
  //G4cout << "AddCompound: hits: " << &hits << G4endl;
  G4bool scoreMapHits = false;
  G4ScoringManager* scoringManager = G4ScoringManager::GetScoringManagerIfExist();
  if (scoringManager) {
    size_t nMeshes = scoringManager->GetNumberOfMesh();
    for (size_t iMesh = 0; iMesh < nMeshes; ++iMesh) {
      G4VScoringMesh* mesh = scoringManager->GetMesh(iMesh);
      if (mesh && mesh->IsActive()) {
    MeshScoreMap scoreMap = mesh->GetScoreMap();
        const G4String& mapNam = const_cast<G4THitsMap<G4double>&>(hits).GetName();
    for(MeshScoreMap::const_iterator i = scoreMap.begin();
        i != scoreMap.end(); ++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/8]

void G4VSceneHandler::AddCompound ( const G4THitsMap< G4StatDouble > & 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) {
    size_t nMeshes = scoringManager->GetNumberOfMesh();
    for (size_t iMesh = 0; iMesh < nMeshes; ++iMesh) {
      G4VScoringMesh* mesh = scoringManager->GetMesh(iMesh);
      if (mesh && mesh->IsActive()) {
    MeshScoreMap scoreMap = mesh->GetScoreMap();
    for(MeshScoreMap::const_iterator i = scoreMap.begin();
        i != scoreMap.end(); ++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/8]

void G4VSceneHandler::AddCompound ( const G4VDigi & digi )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 129 of file G4VSceneHandler.cc.

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

◆ AddCompound() [5/8]

void G4VSceneHandler::AddCompound ( const G4VHit & hit )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 128 of file G4VSceneHandler.cc.

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

◆ AddCompound() [6/8]

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;
}

References G4HepRepFileXMLWriter::addAttDef(), G4HepRepFileXMLWriter::addAttValue(), G4VSceneHandler::AddCompound(), G4HepRepFileXMLWriter::addInstance(), G4HepRepFileXMLWriter::addType(), CheckFileOpen(), G4VHit::CreateAttValues(), doneInitHit, drawingHit, error, G4cout, G4endl, G4VHit::GetAttDefs(), hepRepXMLWriter, hitAttDefs, hitAttValues, G4HepRepFileXMLWriter::prevTypeName, and G4AttCheck::Standard().

◆ AddCompound() [7/8]

void G4VSceneHandler::AddCompound ( const G4VTrajectory & traj )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 127 of file G4VSceneHandler.cc.

                                                            {
  G4TrajectoriesModel* trajectoriesModel =
    dynamic_cast<G4TrajectoriesModel*>(fpModel);
  if (trajectoriesModel)
    traj.DrawTrajectory();
  else {
    G4Exception
    ("G4VSceneHandler::AddCompound(const G4VTrajectory&)",
     "visman0105", FatalException, "Not a G4TrajectoriesModel.");
  }
}

◆ AddCompound() [8/8]

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

◆ AddHepRepInstance()

void G4HepRepFileSceneHandler::AddHepRepInstance	(	const char *	primName,
		const G4Visible	visible
	)

private

Definition at line 1394 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout << "G4HepRepFileSceneHandler::AddHepRepInstance called." << G4endl;
#endif
 
  // Open the HepRep output file if it is not already open.
  CheckFileOpen();
 
  G4VPhysicalVolume* pCurrentPV = 0;
  G4LogicalVolume* pCurrentLV   = 0;
  G4int currentDepth            = 0;
  G4PhysicalVolumeModel* pPVModel =
    dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
  if(pPVModel)
  {
    pCurrentPV   = pPVModel->GetCurrentPV();
    pCurrentLV   = pPVModel->GetCurrentLV();
    currentDepth = pPVModel->GetCurrentDepth();
  }
 
#ifdef G4HEPREPFILEDEBUG
  G4cout << "pCurrentPV:" << pCurrentPV
         << ", readyForTransients:" << fReadyForTransients << G4endl;
#endif
 
  if(drawingTraj || drawingHit)
  {
    // In this case, HepRep type, layer and instance were already created
    // in the AddCompound method.
  }
  else if(fReadyForTransients)
  {
    if(strcmp("Event Data", hepRepXMLWriter->prevTypeName[0]) != 0)
    {
      hepRepXMLWriter->addType("Event Data", 0);
      hepRepXMLWriter->addInstance();
    }
 
    // Applications have the option of either calling AddSolid(G4VTrajectory&)
    // and AddSolid(G4VHits&), or of just decomposing these into simpler
    // primitives. In the former case, drawing will be handled above and will
    // include setting of physics attributes. In the latter case, which is an
    // older style of working, we end up drawing the trajectories and hits here,
    // where we have no access to physics attributes. We receive primitives
    // here.  We can figure out that these are transients, but we have to guess
    // exactly what these transients represent. We assume the primitives are
    // being used as in G4VTrajectory, hence we assume: Lines are Trajectories
    // Squares that come after we've seen trajectories are Auxiliary Points
    // Circles that come after we've seen trajectories are Step Points
    // Other primitives are Hits
 
    int layer;
 
    if(strcmp("Text", primName) == 0)
    {
      hepRepXMLWriter->addType("EventID", 1);
    }
    else
    {
      if(strcmp("Line", primName) == 0)
      {
        hepRepXMLWriter->addType("TransientPolylines", 1);
        layer = 100;
      }
      else
      {
        if(strcmp(hepRepXMLWriter->prevTypeName[1], "TransientPolylines") ==
             0 &&
           strcmp("Square", primName) == 0)
        {
          hepRepXMLWriter->addType("AuxiliaryPoints", 2);
          layer = 110;
        }
        else
        {
          if(strcmp(hepRepXMLWriter->prevTypeName[1], "TransientPolylines") ==
               0 &&
             strcmp("Circle", primName) == 0)
          {
            hepRepXMLWriter->addType("StepPoints", 2);
            layer = 120;
          }
          else
          {
            hepRepXMLWriter->addType("Hits", 1);
            layer = 130;
          }
        }
      }
      hepRepXMLWriter->addAttValue("Layer", layer);
    }
 
    hepRepXMLWriter->addInstance();
 
    // Handle Type declaration for Axes, Ruler, etc.
  }
  else if(pCurrentPV == 0)
  {
    if(strcmp("AxesEtc", hepRepXMLWriter->prevTypeName[0]) != 0)
    {
      hepRepXMLWriter->addType("AxesEtc", 0);
      hepRepXMLWriter->addInstance();
    }
 
    int layer;
 
    if(strcmp("Text", primName) == 0)
    {
      hepRepXMLWriter->addType("Text", 1);
    }
    else
    {
      if(strcmp("Line", primName) == 0)
      {
        hepRepXMLWriter->addType("Polylines", 1);
        layer = 100;
      }
      else
      {
        hepRepXMLWriter->addType("Points", 1);
        layer = 130;
      }
      hepRepXMLWriter->addAttValue("Layer", layer);
    }
 
    hepRepXMLWriter->addInstance();
 
    // Handle Type declaration for Detector Geometry,
    // replacing G4's top geometry level name "worldPhysical" with the
    // name "Detector Geometry".
  }
  else
  {
    // G4cout << "CurrentDepth" << currentDepth << G4endl;
    // G4cout << "currentName" << pCurrentPV->GetName() << G4endl;
    if(strcmp("Detector Geometry", hepRepXMLWriter->prevTypeName[0]) != 0)
    {
      // G4cout << "Adding Det Geom type" << G4endl;
      hepRepXMLWriter->addType("Detector Geometry", 0);
      hepRepXMLWriter->addInstance();
    }
 
    // Re-insert any layers of the hierarchy that were removed by G4's culling
    // process. Don't bother checking if same type name as last instance.
    if(strcmp(hepRepXMLWriter->prevTypeName[currentDepth + 1],
              pCurrentPV->GetName()) != 0)
    {
      // G4cout << "Looking for mother of:" << pCurrentLV->GetName() << G4endl;
      typedef G4PhysicalVolumeModel::G4PhysicalVolumeNodeID PVNodeID;
      typedef std::vector<PVNodeID> PVPath;
      const PVPath& drawnPVPath         = pPVModel->GetDrawnPVPath();
      PVPath::const_reverse_iterator ri = ++drawnPVPath.rbegin();
      G4int drawnMotherDepth;
      if(ri != drawnPVPath.rend())
      {
        // This volume has a mother.
        drawnMotherDepth = ri->GetNonCulledDepth();
        // G4cout << "drawnMotherDepth" << drawnMotherDepth << G4endl;
      }
      else
      {
        // This volume has no mother.  Must be a top level volume.
        drawnMotherDepth = -1;
        // G4cout << "Mother must be very top" << G4endl;
      }
 
      while(drawnMotherDepth < (currentDepth - 1))
      {
        G4String culledParentName = "Culled parent of " + pCurrentPV->GetName();
        // G4cout << "Inserting culled layer " << culledParentName << " at
        // depth:" << drawnMotherDepth+2 << G4endl;
        hepRepXMLWriter->addType(culledParentName, drawnMotherDepth + 2);
        hepRepXMLWriter->addInstance();
        drawnMotherDepth++;
      }
    }
 
    // Add the HepRepType for the current volume.
    hepRepXMLWriter->addType(pCurrentPV->GetName(), currentDepth + 1);
    hepRepXMLWriter->addInstance();
 
    G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
 
    if(fpVisAttribs && (fpVisAttribs->IsVisible() == 0) &&
       messenger->getCullInvisibles())
      return;
 
    // Additional attributes.
    hepRepXMLWriter->addAttValue("Layer", hepRepXMLWriter->typeDepth);
    hepRepXMLWriter->addAttValue("LVol", pCurrentLV->GetName());
    G4Region* region    = pCurrentLV->GetRegion();
    G4String regionName = region ? region->GetName() : G4String("No region");
    hepRepXMLWriter->addAttValue("Region", regionName);
    hepRepXMLWriter->addAttValue("RootRegion", pCurrentLV->IsRootRegion());
    hepRepXMLWriter->addAttValue("Solid", pCurrentLV->GetSolid()->GetName());
    hepRepXMLWriter->addAttValue("EType",
                                 pCurrentLV->GetSolid()->GetEntityType());
    G4Material* material = pPVModel->GetCurrentMaterial();
    G4String matName = material ? material->GetName() : G4String("No material");
    hepRepXMLWriter->addAttValue("Material", matName);
    G4double matDensity = material ? material->GetDensity() : 0.;
    hepRepXMLWriter->addAttValue("Density", matDensity * m3 / kg);
    G4State matState = material ? material->GetState() : kStateUndefined;
    hepRepXMLWriter->addAttValue("State", matState);
    G4double matRadlen = material ? material->GetRadlen() : 0.;
    hepRepXMLWriter->addAttValue("Radlen", matRadlen / m);
  }
 
  hepRepXMLWriter->addAttValue("DrawAs", primName);
 
  // Handle color and visibility attributes.
  float redness;
  float greenness;
  float blueness;
  G4bool isVisible;
 
  if(fpVisAttribs || haveVisible)
  {
    G4Colour colour;
 
    if(fpVisAttribs)
    {
      colour    = fpVisAttribs->GetColour();
      isVisible = fpVisAttribs->IsVisible();
    }
    else
    {
      colour = visible.GetVisAttributes()->GetColour();
      isVisible =
        fpViewer->GetApplicableVisAttributes(visible.GetVisAttributes())
          ->IsVisible();
    }
 
    redness   = colour.GetRed();
    greenness = colour.GetGreen();
    blueness  = colour.GetBlue();
 
    // Avoiding drawing anything black on black.
    if(redness == 0. && greenness == 0. && blueness == 0.)
    {
      redness   = 1.;
      greenness = 1.;
      blueness  = 1.;
    }
  }
  else
  {
#ifdef G4HEPREPFILEDEBUG
    G4cout
      << "G4HepRepFileSceneHandler::AddHepRepInstance using default colour."
      << G4endl;
#endif
    redness   = 1.;
    greenness = 1.;
    blueness  = 1.;
    isVisible = true;
  }
 
  if(strcmp(primName, "Point") == 0)
    hepRepXMLWriter->addAttValue("MarkColor", redness, greenness, blueness);
  else
    hepRepXMLWriter->addAttValue("LineColor", redness, greenness, blueness);
 
  hepRepXMLWriter->addAttValue("Visibility", isVisible);
}

References G4HepRepFileXMLWriter::addAttValue(), G4HepRepFileXMLWriter::addInstance(), G4HepRepFileXMLWriter::addType(), CheckFileOpen(), drawingHit, drawingTraj, G4VSceneHandler::fpModel, G4VSceneHandler::fpViewer, G4VSceneHandler::fpVisAttribs, G4VSceneHandler::fReadyForTransients, G4cout, G4endl, G4VViewer::GetApplicableVisAttributes(), G4Colour::GetBlue(), G4VisAttributes::GetColour(), G4HepRepMessenger::getCullInvisibles(), G4PhysicalVolumeModel::GetCurrentDepth(), G4PhysicalVolumeModel::GetCurrentLV(), G4PhysicalVolumeModel::GetCurrentMaterial(), G4PhysicalVolumeModel::GetCurrentPV(), G4PhysicalVolumeModel::GetDrawnPVPath(), G4VSolid::GetEntityType(), G4Colour::GetGreen(), G4HepRepMessenger::GetInstance(), G4LogicalVolume::GetName(), G4Region::GetName(), G4VPhysicalVolume::GetName(), G4VSolid::GetName(), G4Colour::GetRed(), G4LogicalVolume::GetRegion(), G4LogicalVolume::GetSolid(), G4Visible::GetVisAttributes(), haveVisible, hepRepXMLWriter, G4LogicalVolume::IsRootRegion(), G4VisAttributes::IsVisible(), kg, kStateUndefined, m, m3, eplot::material, G4HepRepFileXMLWriter::prevTypeName, and G4HepRepFileXMLWriter::typeDepth.

Referenced by AddPrimitive(), and AddSolid().

◆ AddPrimitive() [1/13]

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

References G4HepRepFileXMLWriter::addAttValue(), AddHepRepInstance(), G4HepRepFileXMLWriter::addPoint(), G4HepRepFileXMLWriter::addPrimitive(), drawingHit, drawingTraj, G4VSceneHandler::fObjectTransformation, G4VSceneHandler::fpVisAttribs, G4cout, G4endl, G4HepRepMessenger::getCullInvisibles(), G4HepRepMessenger::GetInstance(), G4VSceneHandler::GetMarkerSize(), G4VMarker::GetPosition(), G4VMarker::GetWorldRadius(), haveVisible, hepRepXMLWriter, InitHit(), inPrimitives2D, G4VisAttributes::IsVisible(), warnedAbout2DMarkers, G4VSceneHandler::world, HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

◆ 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 192 of file G4VSceneHandler.cc.

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

◆ AddPrimitive() [4/13]

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);
}

References AddHepRepInstance(), G4HepRepFileXMLWriter::addPoint(), G4HepRepFileXMLWriter::addPrimitive(), drawingHit, drawingTraj, G4VSceneHandler::fObjectTransformation, G4VSceneHandler::fpVisAttribs, G4cout, G4endl, G4HepRepMessenger::getCullInvisibles(), G4HepRepMessenger::GetInstance(), HepPolyhedron::GetNextNormal(), HepPolyhedron::GetNextVertex(), HepPolyhedron::GetNoFacets(), haveVisible, hepRepXMLWriter, InitHit(), G4VisAttributes::IsVisible(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

◆ 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.

{
#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());
  }
}

References AddHepRepInstance(), G4HepRepFileXMLWriter::addPoint(), G4HepRepFileXMLWriter::addPrimitive(), drawingHit, drawingTraj, G4VSceneHandler::fObjectTransformation, G4VSceneHandler::fpVisAttribs, G4cout, G4endl, G4HepRepMessenger::getCullInvisibles(), G4HepRepMessenger::GetInstance(), haveVisible, hepRepXMLWriter, InitHit(), InitTrajectory(), inPrimitives2D, G4VisAttributes::IsVisible(), warnedAbout2DMarkers, HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

◆ 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 190 of file G4VSceneHandler.cc.

                                                                  {
  switch (polymarker.GetMarkerType()) {
    default:
    case G4Polymarker::dots:
    {
      G4Circle dot (polymarker);
      dot.SetWorldSize  (0.);
      dot.SetScreenSize (0.1);  // Very small circle.
      for (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
        dot.SetPosition (polymarker[iPoint]);
        AddPrimitive (dot);
      }
    }
      break;
    case G4Polymarker::circles:
    {
      G4Circle circle (polymarker);  // Default circle
      for (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
        circle.SetPosition (polymarker[iPoint]);
        AddPrimitive (circle);
      }
    }
      break;
    case G4Polymarker::squares:
    {
      G4Square square (polymarker);  // Default square
      for (size_t iPoint = 0; iPoint < polymarker.size (); iPoint++) {
        square.SetPosition (polymarker[iPoint]);
        AddPrimitive (square);
      }
    }
      break;
  }
}

◆ AddPrimitive() [9/13]

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

References G4HepRepFileXMLWriter::addAttValue(), AddHepRepInstance(), G4HepRepFileXMLWriter::addPoint(), G4HepRepFileXMLWriter::addPrimitive(), drawingHit, drawingTraj, G4VSceneHandler::fObjectTransformation, G4VSceneHandler::fpVisAttribs, G4cout, G4endl, G4HepRepMessenger::getCullInvisibles(), G4HepRepMessenger::GetInstance(), G4VSceneHandler::GetMarkerSize(), haveVisible, hepRepXMLWriter, InitHit(), inPrimitives2D, G4VisAttributes::IsVisible(), warnedAbout2DMarkers, G4VSceneHandler::world, HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

◆ AddPrimitive() [10/13]

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

References G4HepRepFileXMLWriter::addAttValue(), AddHepRepInstance(), G4HepRepFileXMLWriter::addPoint(), G4HepRepFileXMLWriter::addPrimitive(), drawingHit, drawingTraj, G4VSceneHandler::fObjectTransformation, G4VSceneHandler::fpVisAttribs, G4cout, G4endl, G4HepRepMessenger::getCullInvisibles(), G4HepRepMessenger::GetInstance(), G4VSceneHandler::GetMarkerSize(), G4VMarker::GetPosition(), G4VMarker::GetWorldRadius(), haveVisible, hepRepXMLWriter, InitHit(), inPrimitives2D, G4VisAttributes::IsVisible(), warnedAbout2DMarkers, G4VSceneHandler::world, HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

◆ 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.

{
#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());
}

References G4HepRepFileXMLWriter::addAttValue(), AddHepRepInstance(), G4HepRepFileXMLWriter::addPrimitive(), G4cout, G4endl, G4Colour::GetBlue(), G4Colour::GetGreen(), G4VSceneHandler::GetMarkerSize(), G4Colour::GetRed(), G4Text::GetText(), G4VSceneHandler::GetTextColour(), G4Text::GetXOffset(), G4Text::GetYOffset(), haveVisible, hepRepXMLWriter, inPrimitives2D, warnedAbout3DText, and G4VSceneHandler::world.

◆ 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.

{
#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());
}

References AddHepRepInstance(), G4HepRepFileXMLWriter::addPoint(), G4HepRepFileXMLWriter::addPrimitive(), drawingHit, drawingTraj, G4VSceneHandler::fObjectTransformation, G4VSceneHandler::fpViewer, G4VSceneHandler::fpVisAttribs, G4cout, G4endl, G4VViewer::GetApplicableVisAttributes(), G4HepRepMessenger::getCullInvisibles(), G4HepRepMessenger::GetInstance(), G4VSolid::GetName(), G4Box::GetXHalfLength(), G4Box::GetYHalfLength(), G4Box::GetZHalfLength(), haveVisible, hepRepXMLWriter, InitHit(), G4VisAttributes::IsVisible(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::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());
  }
}

References G4HepRepFileXMLWriter::addAttValue(), AddHepRepInstance(), G4HepRepFileXMLWriter::addPoint(), G4HepRepFileXMLWriter::addPrimitive(), G4VSceneHandler::AddSolid(), drawingHit, drawingTraj, G4VSceneHandler::fObjectTransformation, G4VSceneHandler::fpViewer, G4VSceneHandler::fpVisAttribs, G4cout, G4endl, G4VViewer::GetApplicableVisAttributes(), G4HepRepMessenger::getCullInvisibles(), G4Cons::GetDeltaPhiAngle(), G4Cons::GetInnerRadiusMinusZ(), G4Cons::GetInnerRadiusPlusZ(), G4HepRepMessenger::GetInstance(), G4VSolid::GetName(), G4Cons::GetOuterRadiusMinusZ(), G4Cons::GetOuterRadiusPlusZ(), HepGeom::Transform3D::getRotation(), G4HepRepMessenger::getScale(), G4Cons::GetZHalfLength(), haveVisible, hepRepXMLWriter, InitHit(), G4VisAttributes::IsVisible(), CLHEP::HepRotation::phiX(), CLHEP::HepRotation::phiY(), CLHEP::HepRotation::phiZ(), pi, G4HepRepMessenger::renderCylAsPolygons(), twopi, HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::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.
}

References G4VSceneHandler::AddSolid(), G4cout, G4endl, and G4VSolid::GetName().

◆ 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.
}

References G4VSceneHandler::AddSolid(), G4cout, G4endl, and G4VSolid::GetName().

◆ 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.
}

References G4VSceneHandler::AddSolid(), G4cout, G4endl, and G4VSolid::GetName().

◆ 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.
}

References G4VSceneHandler::AddSolid(), G4cout, G4endl, and G4VSolid::GetName().

◆ 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.
}

References G4VSceneHandler::AddSolid(), G4cout, G4endl, and G4VSolid::GetName().

◆ 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.
}

References G4VSceneHandler::AddSolid(), G4cout, G4endl, and G4VSolid::GetName().

◆ 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.
}

References G4VSceneHandler::AddSolid(), G4cout, G4endl, and G4VSolid::GetName().

◆ 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.
}

References G4VSceneHandler::AddSolid(), G4cout, G4endl, and G4VSolid::GetName().

◆ 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.
}

References G4VSceneHandler::AddSolid(), G4cout, G4endl, and G4VSolid::GetName().

◆ 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());
}

References AddHepRepInstance(), G4HepRepFileXMLWriter::addPoint(), G4HepRepFileXMLWriter::addPrimitive(), drawingHit, drawingTraj, G4VSceneHandler::fObjectTransformation, G4VSceneHandler::fpViewer, G4VSceneHandler::fpVisAttribs, G4cout, G4endl, G4VViewer::GetApplicableVisAttributes(), G4HepRepMessenger::getCullInvisibles(), G4HepRepMessenger::GetInstance(), G4VSolid::GetName(), G4Trd::GetXHalfLength1(), G4Trd::GetXHalfLength2(), G4Trd::GetYHalfLength1(), G4Trd::GetYHalfLength2(), G4Trd::GetZHalfLength(), haveVisible, hepRepXMLWriter, InitHit(), G4VisAttributes::IsVisible(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::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());
    }
  }
}

References G4HepRepFileXMLWriter::addAttValue(), AddHepRepInstance(), G4HepRepFileXMLWriter::addPoint(), G4HepRepFileXMLWriter::addPrimitive(), G4VSceneHandler::AddSolid(), drawingHit, drawingTraj, G4VSceneHandler::fObjectTransformation, G4VSceneHandler::fpViewer, G4VSceneHandler::fpVisAttribs, G4cout, G4endl, G4VViewer::GetApplicableVisAttributes(), G4HepRepMessenger::getCullInvisibles(), G4Tubs::GetDeltaPhiAngle(), G4Tubs::GetInnerRadius(), G4HepRepMessenger::GetInstance(), G4VSolid::GetName(), G4Tubs::GetOuterRadius(), HepGeom::Transform3D::getRotation(), G4HepRepMessenger::getScale(), G4Tubs::GetZHalfLength(), haveVisible, hepRepXMLWriter, InitHit(), G4VisAttributes::IsVisible(), CLHEP::HepRotation::phiX(), CLHEP::HepRotation::phiY(), CLHEP::HepRotation::phiZ(), pi, G4HepRepMessenger::renderCylAsPolygons(), twopi, HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::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.
}

References G4VSceneHandler::AddSolid(), G4cout, G4endl, and G4VSolid::GetName().

◆ AddSolidT()

template<class T >

void G4VSceneHandler::AddSolidT ( const T & solid )

inherited

Definition at line 220 of file G4VSceneHandler.cc.

{
  // Get and check applicable vis attributes.
  fpVisAttribs = fpViewer->GetApplicableVisAttributes(fpVisAttribs);
  RequestPrimitives (solid);
}

References G4VSceneHandler::fpViewer, G4VSceneHandler::fpVisAttribs, G4VViewer::GetApplicableVisAttributes(), and G4VSceneHandler::RequestPrimitives().

Referenced by G4VSceneHandler::AddSolid().

◆ AddSolidWithAuxiliaryEdges()

template<class T >

void G4VSceneHandler::AddSolidWithAuxiliaryEdges ( const T & solid )

inherited

Definition at line 228 of file G4VSceneHandler.cc.

{
  // Get and check applicable vis attributes.
  fpVisAttribs = fpViewer->GetApplicableVisAttributes(fpVisAttribs);
  // Draw with auxiliary edges unless otherwise specified.
  if (!fpVisAttribs->IsForceAuxEdgeVisible()) {
    // Create a vis atts object for the modified vis atts.
    // It is static so that we may return a reliable pointer to it.
    static G4VisAttributes visAttsWithAuxEdges;
    // Initialise it with the current vis atts and reset the pointer.
    visAttsWithAuxEdges = *fpVisAttribs;
    // Force auxiliary edges visible.
    visAttsWithAuxEdges.SetForceAuxEdgeVisible();
    fpVisAttribs = &visAttsWithAuxEdges;
  }
  RequestPrimitives (solid);
}

References G4VSceneHandler::fpViewer, G4VSceneHandler::fpVisAttribs, G4VViewer::GetApplicableVisAttributes(), G4VisAttributes::IsForceAuxEdgeVisible(), G4VSceneHandler::RequestPrimitives(), and G4VisAttributes::SetForceAuxEdgeVisible().

Referenced by G4VSceneHandler::AddSolid().

◆ AddViewerToList()

void G4VSceneHandler::AddViewerToList ( G4VViewer * pView )

inherited

Definition at line 454 of file G4VSceneHandler.cc.

                                                         {
  fViewerList.push_back (pViewer);
}

References G4VSceneHandler::fViewerList.

◆ 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.
}

References G4VSceneHandler::BeginModeling(), G4VisManager::CurrentTrajDrawModel(), G4VTrajectoryModel::GetContext(), G4VisManager::GetInstance(), and trajContext.

◆ BeginPrimitives()

void G4VSceneHandler::BeginPrimitives ( const G4Transform3D & objectTransformation = G4Transform3D() )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLSceneHandler, G4OpenGLStoredSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, and G4VRML2FileSceneHandler.

Definition at line 160 of file G4VSceneHandler.cc.

                                            {
  //static G4int count = 0;
  //G4cout << "G4VSceneHandler::BeginPrimitives: " << count++ << G4endl;
  fNestingDepth++;
  if (fNestingDepth > 1)
    G4Exception
      ("G4VSceneHandler::BeginPrimitives",
       "visman0101", FatalException,
       "Nesting detected. It is illegal to nest Begin/EndPrimitives.");
  fObjectTransformation = objectTransformation;
}

References FatalException, G4VSceneHandler::fNestingDepth, G4VSceneHandler::fObjectTransformation, and G4Exception().

Referenced by G4GMocrenFileSceneHandler::BeginPrimitives(), G4OpenGLSceneHandler::BeginPrimitives(), G4OpenInventorSceneHandler::BeginPrimitives(), G4Qt3DSceneHandler::BeginPrimitives(), and G4VSceneHandler::RequestPrimitives().

◆ 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);
}

References G4VSceneHandler::BeginPrimitives2D(), G4cout, G4endl, and inPrimitives2D.

◆ CheckFileOpen()

void G4HepRepFileSceneHandler::CheckFileOpen ( )

private

Definition at line 1662 of file G4HepRepFileSceneHandler.cc.

{
#ifdef G4HEPREPFILEDEBUG
  G4cout << "G4HepRepFileSceneHandler::CheckFileOpen called." << G4endl;
#endif
 
  if(!hepRepXMLWriter->isOpen)
  {
    G4String newFileSpec;
 
    G4HepRepMessenger* messenger = G4HepRepMessenger::GetInstance();
 
    if(messenger->getOverwrite())
    {
      newFileSpec =
        messenger->getFileDir() + messenger->getFileName() + ".heprep";
    }
    else
    {
      newFileSpec = messenger->getFileDir() + messenger->getFileName() +
                    G4UIcommand::ConvertToString(fileCounter) + ".heprep";
    }
 
    G4cout << "HepRepFile writing to " << newFileSpec << G4endl;
 
    hepRepXMLWriter->open(newFileSpec);
 
    if(!messenger->getOverwrite())
      fileCounter++;
 
    hepRepXMLWriter->addAttDef("Generator", "HepRep Data Generator", "Physics",
                               "");
    G4String versionString = G4Version;
    versionString          = versionString.substr(1, versionString.size() - 2);
    versionString = " Geant4 version " + versionString + "   " + G4Date;
    hepRepXMLWriter->addAttValue("Generator", versionString);
 
    hepRepXMLWriter->addAttDef("LVol", "Logical Volume", "Physics", "");
    hepRepXMLWriter->addAttDef("Region", "Cuts Region", "Physics", "");
    hepRepXMLWriter->addAttDef("RootRegion", "Root Region", "Physics", "");
    hepRepXMLWriter->addAttDef("Solid", "Solid Name", "Physics", "");
    hepRepXMLWriter->addAttDef("EType", "Entity Type", "Physics", "");
    hepRepXMLWriter->addAttDef("Material", "Material Name", "Physics", "");
    hepRepXMLWriter->addAttDef("Density", "Material Density", "Physics",
                               "kg/m3");
    hepRepXMLWriter->addAttDef("State", "Material State", "Physics", "");
    hepRepXMLWriter->addAttDef("Radlen", "Material Radiation Length", "Physics",
                               "m");
  }
}

References G4HepRepFileXMLWriter::addAttDef(), G4HepRepFileXMLWriter::addAttValue(), G4UIcommand::ConvertToString(), fileCounter, G4cout, G4Date, G4endl, G4Version, G4HepRepMessenger::getFileDir(), G4HepRepMessenger::getFileName(), G4HepRepMessenger::GetInstance(), G4HepRepMessenger::getOverwrite(), hepRepXMLWriter, G4HepRepFileXMLWriter::isOpen, and G4HepRepFileXMLWriter::open().

Referenced by AddCompound(), and AddHepRepInstance().

◆ ClearStore()

void G4VSceneHandler::ClearStore ( )

virtualinherited

Reimplemented in G4OpenGLStoredQtSceneHandler, G4OpenGLStoredSceneHandler, G4OpenInventorSceneHandler, G4Qt3DSceneHandler, G4RayTracerSceneHandler, and G4ToolsSGSceneHandler.

Definition at line 216 of file G4VSceneHandler.cc.

216{}

Referenced by G4OpenGLStoredSceneHandler::ClearStore(), G4VisManager::GeometryHasChanged(), G4VisManager::NotifyHandlers(), G4VViewer::ProcessView(), and G4OpenGLSceneHandler::~G4OpenGLSceneHandler().

◆ 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();
  }
}

References G4VViewer::ClearView(), G4VViewer::DrawView(), G4VSceneHandler::fpViewer, and G4VViewer::SetView().

◆ CreateCutawaySolid()

G4DisplacedSolid * G4VSceneHandler::CreateCutawaySolid ( )

protectedvirtualinherited

Reimplemented in G4OpenGLSceneHandler.

Definition at line 904 of file G4VSceneHandler.cc.

{
  // To be reviewed.
  return 0;
  /*** An alternative way of getting a cutaway is to use
  Command /vis/scene/add/volume
  Guidance :
  Adds a physical volume to current scene, with optional clipping volume.
  If physical-volume-name is "world" (the default), the top of the
  main geometry tree (material world) is added.  If "worlds", the
  top of all worlds - material world and parallel worlds, if any - are
    added.  Otherwise a search of all worlds is made, taking the first
    matching occurrence only.  To see a representation of the geometry
    hierarchy of the worlds, try "/vis/drawTree [worlds]" or one of the
    driver/browser combinations that have the required functionality, e.g., HepRep.
    If clip-volume-type is specified, the subsequent parameters are used to
    to define a clipping volume.  For example,
    "/vis/scene/add/volume ! ! ! -box km 0 1 0 1 0 1" will draw the world
    with the positive octant cut away.  (If the Boolean Processor issues
    warnings try replacing 0 by 0.000000001 or something.)
    If clip-volume-type is prepended with '-', the clip-volume is subtracted
    (cutaway). (This is the default if there is no prepended character.)
    If '*' is prepended, the intersection of the physical-volume and the
    clip-volume is made. (You can make a section/DCUT with a thin box, for
    example).
    For "box", the parameters are xmin,xmax,ymin,ymax,zmin,zmax.
    Only "box" is programmed at present.
   ***/
}

Referenced by G4VSceneHandler::CreateModelingParameters().

◆ CreateModelingParameters()

G4ModelingParameters * G4VSceneHandler::CreateModelingParameters ( )

inherited

Definition at line 798 of file G4VSceneHandler.cc.

{
  // Create modeling parameters from View Parameters...
  if (!fpViewer) return NULL;
 
  const G4ViewParameters& vp = fpViewer -> GetViewParameters ();
 
  // Convert drawing styles...
  G4ModelingParameters::DrawingStyle modelDrawingStyle =
  G4ModelingParameters::wf;
  switch (vp.GetDrawingStyle ()) {
    default:
    case G4ViewParameters::wireframe:
      modelDrawingStyle = G4ModelingParameters::wf;
      break;
    case G4ViewParameters::hlr:
      modelDrawingStyle = G4ModelingParameters::hlr;
      break;
    case G4ViewParameters::hsr:
      modelDrawingStyle = G4ModelingParameters::hsr;
      break;
    case G4ViewParameters::hlhsr:
      modelDrawingStyle = G4ModelingParameters::hlhsr;
      break;
    case G4ViewParameters::cloud:
      modelDrawingStyle = G4ModelingParameters::cloud;
      break;
  }
 
  // Decide if covered daughters are really to be culled...
  G4bool reallyCullCovered =
    vp.IsCullingCovered()   // Culling daughters depends also on...
    && !vp.IsSection ()     // Sections (DCUT) not requested.
    && !vp.IsCutaway ()     // Cutaways not requested.
    ;
 
  G4ModelingParameters* pModelingParams = new G4ModelingParameters
    (vp.GetDefaultVisAttributes (),
     modelDrawingStyle,
     vp.IsCulling (),
     vp.IsCullingInvisible (),
     vp.IsDensityCulling (),
     vp.GetVisibleDensity (),
     reallyCullCovered,
     vp.GetNoOfSides ()
     );
 
  pModelingParams->SetNumberOfCloudPoints(vp.GetNumberOfCloudPoints());
  pModelingParams->SetWarning
    (G4VisManager::GetVerbosity() >= G4VisManager::warnings);
 
  pModelingParams->SetCBDAlgorithmNumber(vp.GetCBDAlgorithmNumber());
  pModelingParams->SetCBDParameters(vp.GetCBDParameters());
 
  pModelingParams->SetExplodeFactor(vp.GetExplodeFactor());
  pModelingParams->SetExplodeCentre(vp.GetExplodeCentre());
 
  pModelingParams->SetSectionSolid(CreateSectionSolid());
  pModelingParams->SetCutawaySolid(CreateCutawaySolid());
  // The polyhedron objects are deleted in the modeling parameters destructor.
  
  pModelingParams->SetVisAttributesModifiers(vp.GetVisAttributesModifiers());
 
  pModelingParams->SetSpecialMeshRendering(vp.IsSpecialMeshRendering());
  pModelingParams->SetSpecialMeshVolumes(vp.GetSpecialMeshVolumes());
 
  return pModelingParams;
}

Referenced by G4VSceneHandler::DrawEndOfRunModels(), G4VSceneHandler::DrawEvent(), and G4VSceneHandler::ProcessScene().

◆ CreateSectionSolid()

G4DisplacedSolid * G4VSceneHandler::CreateSectionSolid ( )

protectedvirtualinherited

Reimplemented in G4OpenGLSceneHandler.

Definition at line 867 of file G4VSceneHandler.cc.

{
  G4DisplacedSolid* sectioner = 0;
 
  const G4ViewParameters& vp = fpViewer->GetViewParameters();
  if (vp.IsSection () ) {
 
    G4double radius = fpScene->GetExtent().GetExtentRadius();
    G4double safe = radius + fpScene->GetExtent().GetExtentCentre().mag();
    G4VSolid* sectionBox =
      new G4Box("_sectioner", safe, safe, 1.e-5 * radius);  // Thin in z-plane...
    const G4Normal3D originalNormal(0,0,1);  // ...so this is original normal.
 
    const G4Plane3D& sp = vp.GetSectionPlane ();
    const G4double& a = sp.a();
    const G4double& b = sp.b();
    const G4double& c = sp.c();
    const G4double& d = sp.d();
    const G4Normal3D newNormal(a,b,c);
 
    G4Transform3D requiredTransform;
    // Rotate
    if (newNormal != originalNormal) {
      const G4double& angle = std::acos(newNormal.dot(originalNormal));
      const G4Vector3D& axis = originalNormal.cross(newNormal);
      requiredTransform = G4Rotate3D(angle, axis);
    }
    // Translate
    requiredTransform = requiredTransform * G4TranslateZ3D(-d);
 
    sectioner = new G4DisplacedSolid
      ("_displaced_sectioning_box", sectionBox, requiredTransform);
  }
  
  return sectioner;
}

References angle, HepGeom::BasicVector3D< T >::cross(), HepGeom::BasicVector3D< T >::dot(), G4VSceneHandler::fpScene, G4VSceneHandler::fpViewer, G4Scene::GetExtent(), G4VisExtent::GetExtentCentre(), G4VisExtent::GetExtentRadius(), G4ViewParameters::GetSectionPlane(), G4VViewer::GetViewParameters(), G4ViewParameters::IsSection(), HepGeom::BasicVector3D< T >::mag(), and G4InuclParticleNames::sp.

Referenced by G4VSceneHandler::CreateModelingParameters(), and G4OpenGLSceneHandler::CreateSectionSolid().

◆ DrawEndOfRunModels()

void G4VSceneHandler::DrawEndOfRunModels ( )

inherited

Definition at line 777 of file G4VSceneHandler.cc.

{
  const std::vector<G4Scene::Model>& EORModelList =
    fpScene -> GetEndOfRunModelList ();
  size_t nModels = EORModelList.size();
  if (nModels) {
    G4ModelingParameters* pMP = CreateModelingParameters();
    pMP->SetEvent(0);
    for (size_t i = 0; i < nModels; i++) {
      if (EORModelList[i].fActive) {
        fpModel = EORModelList[i].fpModel;
    fpModel -> SetModelingParameters(pMP);
    fpModel -> DescribeYourselfTo (*this);
    fpModel -> SetModelingParameters(0);
      }
    }
    fpModel = 0;
    delete pMP;
  }
}

References G4VSceneHandler::CreateModelingParameters(), G4VSceneHandler::fpModel, G4VSceneHandler::fpScene, and G4ModelingParameters::SetEvent().

Referenced by G4VisManager::EndOfRun(), and G4VSceneHandler::ProcessScene().

◆ DrawEvent()

void G4VSceneHandler::DrawEvent ( const G4Event * event )

inherited

Definition at line 756 of file G4VSceneHandler.cc.

{
  const std::vector<G4Scene::Model>& EOEModelList =
    fpScene -> GetEndOfEventModelList ();
  size_t nModels = EOEModelList.size();
  if (nModels) {
    G4ModelingParameters* pMP = CreateModelingParameters();
    pMP->SetEvent(event);
    for (size_t i = 0; i < nModels; i++) {
      if (EOEModelList[i].fActive) {
    fpModel = EOEModelList[i].fpModel;
    fpModel -> SetModelingParameters(pMP);
    fpModel -> DescribeYourselfTo (*this);
    fpModel -> SetModelingParameters(0);
      }
    }
    fpModel = 0;
    delete pMP;
  }
}

References G4VSceneHandler::CreateModelingParameters(), G4VSceneHandler::fpModel, G4VSceneHandler::fpScene, and G4ModelingParameters::SetEvent().

Referenced by G4VisManager::EndOfEvent(), and G4VSceneHandler::ProcessScene().

◆ EndModeling()

void G4HepRepFileSceneHandler::EndModeling ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 102 of file G4HepRepFileSceneHandler.cc.

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

References G4VSceneHandler::EndModeling().

◆ EndPrimitives()

void G4VSceneHandler::EndPrimitives ( )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4DAWNFILESceneHandler, G4GMocrenFileSceneHandler, G4OpenGLImmediateSceneHandler, G4OpenGLSceneHandler, G4OpenGLStoredSceneHandler, G4Qt3DSceneHandler, and G4VRML2FileSceneHandler.

Definition at line 173 of file G4VSceneHandler.cc.

                                     {
  if (fNestingDepth <= 0)
    G4Exception("G4VSceneHandler::EndPrimitives",
        "visman0102", FatalException, "Nesting error.");
  fNestingDepth--;
  if (fReadyForTransients) {
    fTransientsDrawnThisEvent = true;
    fTransientsDrawnThisRun = true;
  }
}

References FatalException, G4VSceneHandler::fNestingDepth, G4VSceneHandler::fReadyForTransients, G4VSceneHandler::fTransientsDrawnThisEvent, G4VSceneHandler::fTransientsDrawnThisRun, and G4Exception().

Referenced by G4GMocrenFileSceneHandler::EndPrimitives(), G4OpenGLSceneHandler::EndPrimitives(), G4Qt3DSceneHandler::EndPrimitives(), and G4VSceneHandler::RequestPrimitives().

◆ 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;
}

References G4VSceneHandler::EndPrimitives2D(), G4cout, G4endl, and inPrimitives2D.

◆ GetAuxEdgeVisible()

G4bool G4VSceneHandler::GetAuxEdgeVisible ( const G4VisAttributes * pVisAttribs )

inherited

Definition at line 1081 of file G4VSceneHandler.cc.

                                                                             {
  G4bool isAuxEdgeVisible = fpViewer->GetViewParameters().IsAuxEdgeVisible ();
  if (pVisAttribs -> IsForceAuxEdgeVisible()) {
    isAuxEdgeVisible = pVisAttribs->IsForcedAuxEdgeVisible();
  }
  return isAuxEdgeVisible;
}

References G4VSceneHandler::fpViewer, G4VViewer::GetViewParameters(), G4ViewParameters::IsAuxEdgeVisible(), and G4VisAttributes::IsForcedAuxEdgeVisible().

Referenced by G4OpenGLSceneHandler::AddPrimitive(), and G4OpenInventorSceneHandler::AddProperties().

◆ GetColor() [1/2]

const G4Colour & G4VSceneHandler::GetColor ( )

inherited

◆ GetColor() [2/2]

const G4Colour & G4VSceneHandler::GetColor ( const G4Visible & )

inherited

◆ GetColour() [1/2]

const G4Colour & G4VSceneHandler::GetColour ( )

inherited

Definition at line 994 of file G4VSceneHandler.cc.

                                            {
  fpVisAttribs = fpViewer->GetApplicableVisAttributes(fpVisAttribs);
  const G4Colour& colour = fpVisAttribs -> GetColour ();
  return colour;
}

References G4VSceneHandler::fpViewer, G4VSceneHandler::fpVisAttribs, G4VViewer::GetApplicableVisAttributes(), and G4VSceneHandler::GetColour().

Referenced by G4OpenGLQtViewer::addNonPVSceneTreeElement(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLQtViewer::addPVSceneTreeElement(), G4VSceneHandler::GetColour(), and G4OpenGLQtViewer::parseAndInsertInSceneTree().

◆ GetColour() [2/2]

const G4Colour & G4VSceneHandler::GetColour ( const G4Visible & visible )

inherited

Definition at line 1000 of file G4VSceneHandler.cc.

                                                                    {
  auto pVA = visible.GetVisAttributes();
  if (!pVA) pVA = fpViewer->GetViewParameters().GetDefaultVisAttributes();
  return pVA->GetColour();
}

References G4VSceneHandler::fpViewer, G4VisAttributes::GetColour(), G4ViewParameters::GetDefaultVisAttributes(), G4VViewer::GetViewParameters(), and G4Visible::GetVisAttributes().

◆ GetCurrentViewer()

G4VViewer * G4VSceneHandler::GetCurrentViewer ( ) const

inherited

◆ GetDrawingStyle()

G4ViewParameters::DrawingStyle G4VSceneHandler::GetDrawingStyle ( const G4VisAttributes * pVisAttribs )

inherited

Definition at line 1021 of file G4VSceneHandler.cc.

                                     {
  // Drawing style is normally determined by the view parameters, but
  // it can be overriddden by the ForceDrawingStyle flag in the vis
  // attributes.
  const G4ViewParameters& vp = fpViewer->GetViewParameters();
  const G4ViewParameters::DrawingStyle viewerStyle = vp.GetDrawingStyle();
  G4ViewParameters::DrawingStyle resultantStyle = viewerStyle;
  if (pVisAttribs -> IsForceDrawingStyle ()) {
    G4VisAttributes::ForcedDrawingStyle forcedStyle =
    pVisAttribs -> GetForcedDrawingStyle ();
    // This is complicated because if hidden line and surface removal
    // has been requested we wish to preserve this sometimes.
    switch (forcedStyle) {
      case (G4VisAttributes::solid):
        switch (viewerStyle) {
          case (G4ViewParameters::hlr):
            resultantStyle = G4ViewParameters::hlhsr;
            break;
          case (G4ViewParameters::wireframe):
            resultantStyle = G4ViewParameters::hsr;
            break;
          case (G4ViewParameters::cloud):
            resultantStyle = G4ViewParameters::hsr;
            break;
          case (G4ViewParameters::hlhsr):
          case (G4ViewParameters::hsr):
            break;
        }
        break;
      case (G4VisAttributes::cloud):
        resultantStyle = G4ViewParameters::cloud;
        break;
      case (G4VisAttributes::wireframe):
      default:
        // But if forced style is wireframe, do it, because one of its
        // main uses is in displaying the consituent solids of a Boolean
        // solid and their surfaces overlap with the resulting Booean
        // solid, making a mess if hlr is specified.
        resultantStyle = G4ViewParameters::wireframe;
        break;
    }
  }
  return resultantStyle;
}

References G4VisAttributes::cloud, G4ViewParameters::cloud, G4VSceneHandler::fpViewer, G4ViewParameters::GetDrawingStyle(), G4VViewer::GetViewParameters(), G4ViewParameters::hlhsr, G4ViewParameters::hlr, G4ViewParameters::hsr, G4VisAttributes::solid, G4VisAttributes::wireframe, and G4ViewParameters::wireframe.

Referenced by G4OpenGLSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitiveTensorGlyph(), G4OpenInventorSceneHandler::AddProperties(), G4OpenInventorSceneHandler::GeneratePrerequisites(), and G4VSceneHandler::RequestPrimitives().

◆ GetExtent()

const G4VisExtent & G4VSceneHandler::GetExtent ( ) const

virtualinherited

Reimplemented from G4VGraphicsScene.

Definition at line 134 of file G4VSceneHandler.cc.

{
  if (fpScene) {
    return fpScene->GetExtent();
  } else {
    static const G4VisExtent defaultExtent = G4VisExtent();
    return defaultExtent;
  }
}

References G4VSceneHandler::fpScene, and G4Scene::GetExtent().

Referenced by G4VtkViewer::SetView().

◆ GetGraphicsSystem()

G4VGraphicsSystem * G4VSceneHandler::GetGraphicsSystem ( ) const

inherited

Referenced by G4ASCIITreeSceneHandler::BeginModeling(), G4ASCIITreeSceneHandler::EndModeling(), G4OpenInventorViewer::G4OpenInventorViewer(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4VisCommandViewerList::SetNewValue(), and G4ASCIITreeSceneHandler::WriteHeader().

◆ GetHepRepXMLWriter()

G4HepRepFileXMLWriter * G4HepRepFileSceneHandler::GetHepRepXMLWriter ( )

Definition at line 1389 of file G4HepRepFileSceneHandler.cc.

{
  return hepRepXMLWriter;
}

References hepRepXMLWriter.

Referenced by G4HepRepFileSceneHandler().

◆ GetLineWidth()

G4double G4VSceneHandler::GetLineWidth ( const G4VisAttributes * pVisAttribs )

inherited

Definition at line 1012 of file G4VSceneHandler.cc.

{
  G4double lineWidth = pVisAttribs->GetLineWidth();
  if (lineWidth < 1.) lineWidth = 1.;
  lineWidth *= fpViewer -> GetViewParameters().GetGlobalLineWidthScale();
  if (lineWidth < 1.) lineWidth = 1.;
  return lineWidth;
}

References G4VSceneHandler::fpViewer, and G4VisAttributes::GetLineWidth().

Referenced by G4OpenGLSceneHandler::AddPrimitive().

◆ GetMarkerDiameter()

G4double G4VSceneHandler::GetMarkerDiameter	(	const G4VMarker &	,
		MarkerSizeType &
	)

inherited

◆ GetMarkerRadius()

G4double G4VSceneHandler::GetMarkerRadius	(	const G4VMarker &	,
		MarkerSizeType &
	)

inherited

◆ GetMarkerSize()

G4double G4VSceneHandler::GetMarkerSize	(	const G4VMarker &	marker,
		G4VSceneHandler::MarkerSizeType &	markerSizeType
	)

inherited

Definition at line 1089 of file G4VSceneHandler.cc.

{
  G4bool userSpecified = marker.GetWorldSize() || marker.GetScreenSize();
  const G4VMarker& defaultMarker =
    fpViewer -> GetViewParameters().GetDefaultMarker();
  G4double size = userSpecified ?
    marker.GetWorldSize() : defaultMarker.GetWorldSize();
  if (size) {
    // Draw in world coordinates.
    markerSizeType = world;
  }
  else {
    size = userSpecified ?
      marker.GetScreenSize() : defaultMarker.GetScreenSize();
    // Draw in screen coordinates.
    markerSizeType = screen;
  }
  size *= fpViewer -> GetViewParameters().GetGlobalMarkerScale();
  if (markerSizeType == screen && size < 1.) size = 1.;
  return size;
}

References G4VSceneHandler::fpViewer, G4VMarker::GetScreenSize(), G4VMarker::GetWorldSize(), G4VSceneHandler::screen, and G4VSceneHandler::world.

Referenced by G4OpenInventorSceneHandler::AddCircleSquare(), G4Qt3DSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitive(), AddPrimitive(), G4OpenGLSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenGLQtViewer::DrawText(), G4OpenGLViewer::DrawText(), and G4OpenGLXViewer::DrawText().

◆ GetMarkForClearingTransientStore()

G4bool G4VSceneHandler::GetMarkForClearingTransientStore ( ) const

inherited

Referenced by G4VisManager::ClearTransientStoreIfMarked().

◆ GetModel()

G4VModel * G4VSceneHandler::GetModel ( ) const

inherited

Referenced by G4GMocrenFileSceneHandler::AddDetector(), G4GMocrenFileSceneHandler::AddSolid(), and G4VtkSceneHandler::AddSolid().

◆ GetName()

const G4String & G4VSceneHandler::GetName ( ) const

inherited

Referenced by G4VSceneHandler::AddCompound(), G4GMocrenFileSceneHandler::AddCompound(), G4GMocrenFileSceneHandler::AddSolid(), G4VViewer::G4VViewer(), G4OpenGLViewerMessenger::SetNewValue(), G4VisCommandSceneNotifyHandlers::SetNewValue(), G4VisCommandSceneHandlerList::SetNewValue(), G4VisCommandViewerRefresh::SetNewValue(), and G4VisCommandViewerUpdate::SetNewValue().

◆ GetNoOfSides()

G4int G4VSceneHandler::GetNoOfSides ( const G4VisAttributes * pVisAttribs )

inherited

Definition at line 1113 of file G4VSceneHandler.cc.

{
  // No. of sides (lines segments per circle) is normally determined
  // by the view parameters, but it can be overriddden by the
  // ForceLineSegmentsPerCircle in the vis attributes.
  G4int lineSegmentsPerCircle = fpViewer->GetViewParameters().GetNoOfSides();
  if (pVisAttribs) {
    if (pVisAttribs->IsForceLineSegmentsPerCircle())
      lineSegmentsPerCircle = pVisAttribs->GetForcedLineSegmentsPerCircle();
    if (lineSegmentsPerCircle < pVisAttribs->GetMinLineSegmentsPerCircle()) {
      lineSegmentsPerCircle = pVisAttribs->GetMinLineSegmentsPerCircle();
      G4cout <<
    "G4VSceneHandler::GetNoOfSides: attempt to set the"
    "\nnumber of line segments per circle < " << lineSegmentsPerCircle
         << "; forced to " << pVisAttribs->GetMinLineSegmentsPerCircle() << G4endl;
    }
  }
  return lineSegmentsPerCircle;
}

References G4VSceneHandler::fpViewer, G4cout, G4endl, G4VisAttributes::GetForcedLineSegmentsPerCircle(), G4VisAttributes::GetMinLineSegmentsPerCircle(), G4ViewParameters::GetNoOfSides(), G4VViewer::GetViewParameters(), and G4VisAttributes::IsForceLineSegmentsPerCircle().

Referenced by G4OpenGLSceneHandler::AddPrimitive(), and G4VSceneHandler::RequestPrimitives().

◆ GetNumberOfCloudPoints()

G4int G4VSceneHandler::GetNumberOfCloudPoints ( const G4VisAttributes * pVisAttribs ) const

inherited

Definition at line 1067 of file G4VSceneHandler.cc.

                                           {
  // Returns no of cloud points from current view parameters, unless the user
  // has forced through the vis attributes, thereby over-riding the
  // current view parameter.
  G4int numberOfCloudPoints = fpViewer->GetViewParameters().GetNumberOfCloudPoints();
  if (pVisAttribs -> IsForceDrawingStyle() &&
      pVisAttribs -> GetForcedDrawingStyle() == G4VisAttributes::cloud &&
      pVisAttribs -> GetForcedNumberOfCloudPoints() > 0) {
    numberOfCloudPoints = pVisAttribs -> GetForcedNumberOfCloudPoints();
  }
  return numberOfCloudPoints;
}

References G4VisAttributes::cloud, G4VSceneHandler::fpViewer, G4ViewParameters::GetNumberOfCloudPoints(), and G4VViewer::GetViewParameters().

Referenced by G4VSceneHandler::RequestPrimitives().

◆ GetObjectTransformation()

const G4Transform3D & G4VSceneHandler::GetObjectTransformation ( ) const

inherited

Referenced by G4VisManager::DrawT(), and G4VisManager::DrawT2D().

◆ GetScene()

G4Scene * G4VSceneHandler::GetScene ( ) const

inherited

Referenced by G4OpenGLXmViewer::actions_callback(), G4VVisCommand::CheckSceneAndNotifyHandlers(), G4OpenGLStoredViewer::DrawDisplayLists(), G4OpenGLViewer::getSceneDepth(), G4OpenGLViewer::getSceneFarWidth(), G4OpenGLViewer::getSceneNearWidth(), G4GMocrenFileSceneHandler::GFBeginModeling(), G4OpenGLImmediateQtViewer::initializeGL(), G4OpenGLStoredQtViewer::initializeGL(), G4OpenGLXmViewer::left_right_pan_callback(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::mouse_move(), G4VVisCommand::RefreshIfRequired(), G4OpenGLXmViewer::ResetView(), G4OpenGLViewer::rotateSceneInViewDirection(), G4OpenGLViewer::rotateSceneThetaPhi(), G4DAWNFILEViewer::SendViewParameters(), G4VRML2FileViewer::SendViewParameters(), G4VisCommandViewerCentreOn::SetNewValue(), G4VisCommandViewerRefresh::SetNewValue(), G4VisCommandViewerSave::SetNewValue(), G4VisCommandViewerUpdate::SetNewValue(), G4VisCommandsViewerSet::SetNewValue(), G4OpenGLWin32Viewer::SetShift(), G4OpenGLViewer::SetView(), G4OpenInventorViewer::SetView(), G4Qt3DViewer::SetView(), G4RayTracerViewer::SetView(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::SetView(), G4OpenGLXmViewer::up_down_pan_callback(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

◆ GetSceneHandlerId()

G4int G4VSceneHandler::GetSceneHandlerId ( ) const

inherited

Referenced by G4OpenGLXmViewer::actions_callback(), and G4OpenGLXmViewer::misc_callback().

◆ GetTextColor()

const G4Colour & G4VSceneHandler::GetTextColor ( const G4Text & )

inherited

◆ GetTextColour()

const G4Colour & G4VSceneHandler::GetTextColour ( const G4Text & text )

inherited

Definition at line 1006 of file G4VSceneHandler.cc.

                                                                  {
  auto pVA = text.GetVisAttributes();
  if (!pVA) pVA = fpViewer->GetViewParameters().GetDefaultTextVisAttributes();
  return pVA->GetColour();
}

References G4VSceneHandler::fpViewer, G4VisAttributes::GetColour(), G4ViewParameters::GetDefaultTextVisAttributes(), G4VViewer::GetViewParameters(), and G4Visible::GetVisAttributes().

Referenced by G4OpenGLQtViewer::addNonPVSceneTreeElement(), AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenGLQtViewer::DrawText(), and G4OpenGLXViewer::DrawText().

◆ GetTransientsDrawnThisEvent()

G4bool G4VSceneHandler::GetTransientsDrawnThisEvent ( ) const

inherited

Referenced by G4VisManager::ClearTransientStoreIfMarked().

◆ GetTransientsDrawnThisRun()

G4bool G4VSceneHandler::GetTransientsDrawnThisRun ( ) const

inherited

Referenced by G4VisManager::ClearTransientStoreIfMarked().

◆ GetViewCount()

G4int G4VSceneHandler::GetViewCount ( ) const

inherited

◆ GetViewerList()

const G4ViewerList & G4VSceneHandler::GetViewerList ( ) const

inherited

◆ IncrementViewCount()

G4int G4VSceneHandler::IncrementViewCount ( )

inherited

◆ 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;
  }
}

References G4HepRepFileXMLWriter::addAttValue(), G4HepRepFileXMLWriter::addInstance(), doneInitHit, hepRepXMLWriter, hitAttDefs, and hitAttValues.

Referenced by AddPrimitive(), 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;
  }
}

References G4HepRepFileXMLWriter::addAttValue(), G4HepRepFileXMLWriter::addInstance(), doneInitTraj, hepRepXMLWriter, trajAttDefs, and trajAttValues.

Referenced by AddCompound(), and AddPrimitive().

◆ IsReadyForTransients()

G4bool G4VSceneHandler::IsReadyForTransients ( ) const

inherited

◆ LoadAtts()

void G4VSceneHandler::LoadAtts	(	const G4Visible &	visible,
		G4AttHolder *	holder
	)

protectedinherited

Definition at line 934 of file G4VSceneHandler.cc.

{
  // Load G4Atts from G4VisAttributes, if any...
  const G4VisAttributes* va = visible.GetVisAttributes();
  if (va) {
    const std::map<G4String,G4AttDef>* vaDefs =
      va->GetAttDefs();
    if (vaDefs) {
      holder->AddAtts(visible.GetVisAttributes()->CreateAttValues(), vaDefs);
    }
  }
 
  G4PhysicalVolumeModel* pPVModel =
    dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
  if (pPVModel) {
    // Load G4Atts from G4PhysicalVolumeModel...
    const std::map<G4String,G4AttDef>* pvDefs = pPVModel->GetAttDefs();
    if (pvDefs) {
      holder->AddAtts(pPVModel->CreateCurrentAttValues(), pvDefs);
    }
  }
 
  G4TrajectoriesModel* trajModel = dynamic_cast<G4TrajectoriesModel*>(fpModel);
  if (trajModel) {
    // Load G4Atts from trajectory model...
    const std::map<G4String,G4AttDef>* trajModelDefs = trajModel->GetAttDefs();
    if (trajModelDefs) {
      holder->AddAtts(trajModel->CreateCurrentAttValues(), trajModelDefs);
    }
    // Load G4Atts from trajectory...
    const G4VTrajectory* traj = trajModel->GetCurrentTrajectory();
    if (traj) {
      const std::map<G4String,G4AttDef>* trajDefs = traj->GetAttDefs();
      if (trajDefs) {
        holder->AddAtts(traj->CreateAttValues(), trajDefs);
      }
      G4int nPoints = traj->GetPointEntries();
      for (G4int i = 0; i < nPoints; ++i) {
        G4VTrajectoryPoint* trajPoint = traj->GetPoint(i);
        if (trajPoint) {
          const std::map<G4String,G4AttDef>* pointDefs = trajPoint->GetAttDefs();
          if (pointDefs) {
            holder->AddAtts(trajPoint->CreateAttValues(), pointDefs);
          }
        }
      }
    }
  }
 
  G4HitsModel* hitsModel = dynamic_cast<G4HitsModel*>(fpModel);
  if (hitsModel) {
    // Load G4Atts from hit...
    const G4VHit* hit = hitsModel->GetCurrentHit();
    const std::map<G4String,G4AttDef>* hitsDefs = hit->GetAttDefs();
    if (hitsDefs) {
      holder->AddAtts(hit->CreateAttValues(), hitsDefs);
    }
  }
}

References G4AttHolder::AddAtts(), G4VHit::CreateAttValues(), G4VisAttributes::CreateAttValues(), G4VTrajectory::CreateAttValues(), G4VTrajectoryPoint::CreateAttValues(), G4PhysicalVolumeModel::CreateCurrentAttValues(), G4TrajectoriesModel::CreateCurrentAttValues(), G4VSceneHandler::fpModel, G4VHit::GetAttDefs(), G4VisAttributes::GetAttDefs(), G4VTrajectory::GetAttDefs(), G4VTrajectoryPoint::GetAttDefs(), G4PhysicalVolumeModel::GetAttDefs(), G4TrajectoriesModel::GetAttDefs(), G4HitsModel::GetCurrentHit(), G4TrajectoriesModel::GetCurrentTrajectory(), G4VTrajectory::GetPoint(), G4VTrajectory::GetPointEntries(), and G4Visible::GetVisAttributes().

Referenced by G4OpenInventorSceneHandler::AddCircleSquare(), G4OpenInventorSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), and G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal().

◆ PostAddSolid()

void G4VSceneHandler::PostAddSolid ( )

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4Qt3DSceneHandler, and G4VTreeSceneHandler.

Definition at line 151 of file G4VSceneHandler.cc.

                                    {
  fpVisAttribs = 0;
  fProcessingSolid = false;
  if (fReadyForTransients) {
    fTransientsDrawnThisEvent = true;
    fTransientsDrawnThisRun = true;
  }
}

References G4VSceneHandler::fProcessingSolid, G4VSceneHandler::fpVisAttribs, G4VSceneHandler::fReadyForTransients, G4VSceneHandler::fTransientsDrawnThisEvent, and G4VSceneHandler::fTransientsDrawnThisRun.

Referenced by G4VSceneHandler::AddCompound(), and G4Qt3DSceneHandler::PostAddSolid().

◆ PreAddSolid()

void G4VSceneHandler::PreAddSolid	(	const G4Transform3D &	objectTransformation,
		const G4VisAttributes &	visAttribs
	)

virtualinherited

Implements G4VGraphicsScene.

Reimplemented in G4OpenGLSceneHandler, G4Qt3DSceneHandler, G4VTreeSceneHandler, and G4OpenInventorSceneHandler.

Definition at line 144 of file G4VSceneHandler.cc.

                                                      {
  fObjectTransformation = objectTransformation;
  fpVisAttribs = &visAttribs;
  fProcessingSolid = true;
}

References G4VSceneHandler::fObjectTransformation, G4VSceneHandler::fProcessingSolid, and G4VSceneHandler::fpVisAttribs.

Referenced by G4VSceneHandler::AddCompound(), G4OpenGLSceneHandler::PreAddSolid(), G4Qt3DSceneHandler::PreAddSolid(), G4VTreeSceneHandler::PreAddSolid(), and G4OpenInventorSceneHandler::PreAddSolid().

◆ ProcessScene()

void G4VSceneHandler::ProcessScene ( )

protectedvirtualinherited

Reimplemented in G4OpenGLSceneHandler.

Definition at line 612 of file G4VSceneHandler.cc.

{
  // Assumes graphics database store has already been cleared if
  // relevant for the particular scene handler.
 
  if(!fpScene)
    return;
 
  if(fpScene->GetExtent() == G4VisExtent::GetNullExtent())
  {
    G4Exception("G4VSceneHandler::ProcessScene", "visman0106", JustWarning,
                "The scene has no extent.");
  }
 
  G4VisManager* visManager = G4VisManager::GetInstance();
 
  if(!visManager->GetConcreteInstance())
    return;
 
  G4VisManager::Verbosity verbosity = visManager->GetVerbosity();
 
  fReadyForTransients = false;
 
  // Reset fMarkForClearingTransientStore. (Leaving
  // fMarkForClearingTransientStore true causes problems with
  // recomputing transients below.)  Restore it again at end...
  G4bool tmpMarkForClearingTransientStore = fMarkForClearingTransientStore;
  fMarkForClearingTransientStore          = false;
 
  // Traverse geometry tree and send drawing primitives to window(s).
 
  const std::vector<G4Scene::Model>& runDurationModelList =
    fpScene->GetRunDurationModelList();
 
  if(runDurationModelList.size())
  {
    if(verbosity >= G4VisManager::confirmations)
    {
      G4cout << "Traversing scene data..." << G4endl;
    }
 
    BeginModeling();
 
    // Create modeling parameters from view parameters...
    G4ModelingParameters* pMP = CreateModelingParameters();
 
    for(size_t i = 0; i < runDurationModelList.size(); i++)
    {
      if(runDurationModelList[i].fActive)
      {
    fpModel = runDurationModelList[i].fpModel;
    fpModel->SetModelingParameters(pMP);
    fpModel->DescribeYourselfTo(*this);
    // To see the extents of each model represented as wireframe boxes,
    // uncomment the next line and DrawExtent in namespace above
    // DrawExtent(fpModel);
    fpModel->SetModelingParameters(0);
      }
    }
 
    fpModel = 0;
    delete pMP;
 
    EndModeling();
  }
 
  fReadyForTransients = true;
 
  // Refresh event from end-of-event model list.
  // Allow only in Idle or GeomClosed state...
  G4StateManager* stateManager = G4StateManager::GetStateManager();
  G4ApplicationState state     = stateManager->GetCurrentState();
  if(state == G4State_Idle || state == G4State_GeomClosed)
  {
    visManager->SetEventRefreshing(true);
 
    if(visManager->GetRequestedEvent())
    {
      DrawEvent(visManager->GetRequestedEvent());
    }
    else
    {
      G4RunManager* runManager = G4RunManagerFactory::GetMasterRunManager();
      if(runManager)
      {
        const G4Run* run = runManager->GetCurrentRun();
        const std::vector<const G4Event*>* events =
          run ? run->GetEventVector() : 0;
        size_t nKeptEvents = 0;
        if(events)
          nKeptEvents = events->size();
        if(nKeptEvents)
        {
          if(fpScene->GetRefreshAtEndOfEvent())
          {
            if(verbosity >= G4VisManager::confirmations)
            {
              G4cout << "Refreshing event..." << G4endl;
            }
            const G4Event* event = 0;
            if(events && events->size())
              event = events->back();
            if(event)
              DrawEvent(event);
          }
          else
          {  // Accumulating events.
 
            if(verbosity >= G4VisManager::confirmations)
            {
              G4cout << "Refreshing events in run..." << G4endl;
            }
            for(const auto& event : *events)
            {
              if(event)
                DrawEvent(event);
            }
 
            if(!fpScene->GetRefreshAtEndOfRun())
            {
              if(verbosity >= G4VisManager::warnings)
              {
                G4cout << "WARNING: Cannot refresh events accumulated over more"
                          "\n  than one runs.  Refreshed just the last run."
                       << G4endl;
              }
            }
          }
        }
      }
    }
    visManager->SetEventRefreshing(false);
  }
 
  // Refresh end-of-run model list.
  // Allow only in Idle or GeomClosed state...
  if(state == G4State_Idle || state == G4State_GeomClosed)
  {
    DrawEndOfRunModels();
  }
 
  fMarkForClearingTransientStore = tmpMarkForClearingTransientStore;
}

References G4VSceneHandler::BeginModeling(), G4VisManager::confirmations, G4VSceneHandler::CreateModelingParameters(), G4VModel::DescribeYourselfTo(), G4VSceneHandler::DrawEndOfRunModels(), G4VSceneHandler::DrawEvent(), G4VSceneHandler::EndModeling(), G4VSceneHandler::fMarkForClearingTransientStore, G4VSceneHandler::fpModel, G4VSceneHandler::fpScene, G4VSceneHandler::fReadyForTransients, G4cout, G4endl, G4Exception(), G4State_GeomClosed, G4State_Idle, G4VVisManager::GetConcreteInstance(), G4RunManager::GetCurrentRun(), G4StateManager::GetCurrentState(), G4Scene::GetExtent(), G4VisManager::GetInstance(), G4RunManagerFactory::GetMasterRunManager(), G4VisExtent::GetNullExtent(), G4Scene::GetRefreshAtEndOfEvent(), G4Scene::GetRefreshAtEndOfRun(), G4VisManager::GetRequestedEvent(), G4Scene::GetRunDurationModelList(), G4StateManager::GetStateManager(), G4VisManager::GetVerbosity(), JustWarning, G4VisManager::SetEventRefreshing(), G4VModel::SetModelingParameters(), and G4VisManager::warnings.

Referenced by G4OpenGLSceneHandler::ProcessScene(), and G4VViewer::ProcessView().

◆ RemoveViewerFromList()

void G4VSceneHandler::RemoveViewerFromList ( G4VViewer * pView )

inherited

Definition at line 493 of file G4VSceneHandler.cc.

                                                              {
  fViewerList.remove(pViewer);  // Does nothing if already removed
  // And reset current viewer
  auto visManager = G4VisManager::GetInstance();
  visManager->SetCurrentViewer(nullptr);
}

References G4VSceneHandler::fViewerList, G4VisManager::GetInstance(), and G4ViewerList::remove().

Referenced by G4VViewer::~G4VViewer().

◆ RequestPrimitives()

void G4VSceneHandler::RequestPrimitives ( const G4VSolid & solid )

protectedvirtualinherited

Reimplemented in G4ASCIITreeSceneHandler, and G4RayTracerSceneHandler.

Definition at line 516 of file G4VSceneHandler.cc.

{
  const G4ViewParameters::DrawingStyle style = GetDrawingStyle(fpVisAttribs);
  const G4ViewParameters& vp = fpViewer->GetViewParameters();
 
  switch (style) {
    default:
    case G4ViewParameters::wireframe:
    case G4ViewParameters::hlr:
    case G4ViewParameters::hsr:
    case G4ViewParameters::hlhsr:
    {
      // Use polyhedral representation
      G4Polyhedron::SetNumberOfRotationSteps (GetNoOfSides (fpVisAttribs));
      G4Polyhedron* pPolyhedron = solid.GetPolyhedron ();
      G4Polyhedron::ResetNumberOfRotationSteps ();
      if (pPolyhedron) {
        pPolyhedron -> SetVisAttributes (fpVisAttribs);
        BeginPrimitives (fObjectTransformation);
        AddPrimitive (*pPolyhedron);
        EndPrimitives ();
        break;
      } else {  // Print warnings and drop through to cloud
        G4VisManager::Verbosity verbosity = G4VisManager::GetVerbosity();
        static std::set<const G4VSolid*> problematicSolids;
        if (verbosity >= G4VisManager::errors &&
            problematicSolids.find(&solid) == problematicSolids.end()) {
          problematicSolids.insert(&solid);
          G4cerr <<
          "ERROR: G4VSceneHandler::RequestPrimitives"
          "\n  Polyhedron not available for " << solid.GetName ();
          G4PhysicalVolumeModel* pPVModel = dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
          if (pPVModel) {
            G4cerr << "\n  Touchable path: " << pPVModel->GetFullPVPath();
          }
          static G4bool explanation = false;
          if (!explanation) {
            explanation = true;
            G4cerr <<
            "\n  This means it cannot be visualized in the usual way on most systems."
            "\n  1) The solid may not have implemented the CreatePolyhedron method."
            "\n  2) For Boolean solids, the BooleanProcessor, which attempts to create"
            "\n     the resultant polyhedron, may have failed."
            "\n  Try RayTracer. It uses Geant4's tracking algorithms instead.";
          }
          G4cerr << "\n  Drawing solid with cloud of points.";
          G4cerr << G4endl;
        }
      }
    }
      [[fallthrough]];
 
    case G4ViewParameters::cloud:
    {
      // Form solid out of cloud of dots on surface of solid
      G4Polymarker dots;
      // Note: OpenGL has a fast implementation of polymarker so it's better
      // to build a polymarker rather than add a succession of circles.
      // And anyway, in Qt, in the latter case each circle would be a scene-tree
      // entry, something we would want to avoid.
      dots.SetVisAttributes(fpVisAttribs);
      dots.SetMarkerType(G4Polymarker::dots);
      dots.SetSize(G4VMarker::screen,1.);
      G4int numberOfCloudPoints = GetNumberOfCloudPoints(fpVisAttribs);
      if (numberOfCloudPoints <= 0) numberOfCloudPoints = vp.GetNumberOfCloudPoints();
      for (G4int i = 0; i < numberOfCloudPoints; ++i) {
    G4ThreeVector p = solid.GetPointOnSurface();
    dots.push_back(p);
      }
      BeginPrimitives (fObjectTransformation);
      AddPrimitive(dots);
      EndPrimitives ();
      break;
    }
  }
}

References G4VSceneHandler::AddPrimitive(), G4VSceneHandler::BeginPrimitives(), G4ViewParameters::cloud, G4Polymarker::dots, G4VSceneHandler::EndPrimitives(), G4VisManager::errors, G4VSceneHandler::fObjectTransformation, G4VSceneHandler::fpModel, G4VSceneHandler::fpViewer, G4VSceneHandler::fpVisAttribs, G4cerr, G4endl, G4VSceneHandler::GetDrawingStyle(), G4PhysicalVolumeModel::GetFullPVPath(), G4VSolid::GetName(), G4VSceneHandler::GetNoOfSides(), G4ViewParameters::GetNumberOfCloudPoints(), G4VSceneHandler::GetNumberOfCloudPoints(), G4VSolid::GetPointOnSurface(), G4VSolid::GetPolyhedron(), G4VisManager::GetVerbosity(), G4VViewer::GetViewParameters(), G4ViewParameters::hlhsr, G4ViewParameters::hlr, G4ViewParameters::hsr, HepPolyhedron::ResetNumberOfRotationSteps(), G4VMarker::screen, G4Polymarker::SetMarkerType(), HepPolyhedron::SetNumberOfRotationSteps(), G4VMarker::SetSize(), G4Visible::SetVisAttributes(), and G4ViewParameters::wireframe.

Referenced by G4VSceneHandler::AddSolidT(), and G4VSceneHandler::AddSolidWithAuxiliaryEdges().

◆ SetCurrentViewer()

void G4VSceneHandler::SetCurrentViewer ( G4VViewer * )

inherited

◆ SetMarkForClearingTransientStore()

void G4VSceneHandler::SetMarkForClearingTransientStore ( G4bool )

inherited

Referenced by G4VisManager::ClearTransientStoreIfMarked(), G4VisManager::EndOfEvent(), G4VisManager::EndOfRun(), G4VisCommandSceneEndOfEventAction::SetNewValue(), G4VisCommandSceneEndOfRunAction::SetNewValue(), and G4VisCommandViewerClearTransients::SetNewValue().

◆ SetModel()

void G4VSceneHandler::SetModel ( G4VModel * )

inherited

◆ SetName()

void G4VSceneHandler::SetName ( const G4String & )

inherited

◆ SetObjectTransformation()

void G4VSceneHandler::SetObjectTransformation ( const G4Transform3D & )

inherited

◆ SetScene()

void G4VSceneHandler::SetScene ( G4Scene * pScene )

virtualinherited

Reimplemented in G4OpenGLStoredQtSceneHandler.

Definition at line 507 of file G4VSceneHandler.cc.

                                               {
  fpScene = pScene;
  // Notify all viewers that a kernel visit is required.
  G4ViewerListIterator i;
  for (i = fViewerList.begin(); i != fViewerList.end(); i++) {
    (*i) -> SetNeedKernelVisit (true);
  }
}

References G4VSceneHandler::fpScene, and G4VSceneHandler::fViewerList.

Referenced by G4OpenGLStoredQtSceneHandler::SetScene().

◆ SetTransientsDrawnThisEvent()

void G4VSceneHandler::SetTransientsDrawnThisEvent ( G4bool )

inherited

Referenced by G4VisManager::BeginOfEvent().

◆ SetTransientsDrawnThisRun()

void G4VSceneHandler::SetTransientsDrawnThisRun ( G4bool )

inherited

Referenced by G4VisManager::BeginOfRun().

◆ SetViewerList()

G4ViewerList & G4VSceneHandler::SetViewerList ( )

inherited

Field Documentation

◆ doneInitHit

G4bool G4HepRepFileSceneHandler::doneInitHit

private

Definition at line 146 of file G4HepRepFileSceneHandler.hh.

Referenced by AddCompound(), G4HepRepFileSceneHandler(), and InitHit().

◆ doneInitTraj

G4bool G4HepRepFileSceneHandler::doneInitTraj

private

Definition at line 144 of file G4HepRepFileSceneHandler.hh.

Referenced by AddCompound(), G4HepRepFileSceneHandler(), and InitTrajectory().

◆ drawingHit

G4bool G4HepRepFileSceneHandler::drawingHit

private

Definition at line 145 of file G4HepRepFileSceneHandler.hh.

Referenced by AddCompound(), AddHepRepInstance(), AddPrimitive(), AddSolid(), and G4HepRepFileSceneHandler().

◆ drawingTraj

G4bool G4HepRepFileSceneHandler::drawingTraj

private

Definition at line 143 of file G4HepRepFileSceneHandler.hh.

Referenced by AddCompound(), AddHepRepInstance(), AddPrimitive(), AddSolid(), and G4HepRepFileSceneHandler().

◆ fIdentityTransformation

const G4Transform3D G4VSceneHandler::fIdentityTransformation

protectedinherited

Definition at line 364 of file G4VSceneHandler.hh.

◆ fileCounter

int G4HepRepFileSceneHandler::fileCounter

private

Definition at line 138 of file G4HepRepFileSceneHandler.hh.

Referenced by CheckFileOpen(), and G4HepRepFileSceneHandler().

◆ fMarkForClearingTransientStore

G4bool G4VSceneHandler::fMarkForClearingTransientStore

protectedinherited

Definition at line 352 of file G4VSceneHandler.hh.

Referenced by G4VSceneHandler::ProcessScene().

◆ fName

G4String G4VSceneHandler::fName

protectedinherited

Definition at line 347 of file G4VSceneHandler.hh.

◆ fNestingDepth

G4int G4VSceneHandler::fNestingDepth

protectedinherited

Definition at line 362 of file G4VSceneHandler.hh.

Referenced by G4VSceneHandler::BeginPrimitives(), G4VSceneHandler::BeginPrimitives2D(), G4VSceneHandler::EndPrimitives(), and G4VSceneHandler::EndPrimitives2D().

◆ fObjectTransformation

G4Transform3D G4VSceneHandler::fObjectTransformation

protectedinherited

Definition at line 360 of file G4VSceneHandler.hh.

Referenced by G4VtkSceneHandler::AddCompound(), G4GMocrenFileSceneHandler::AddDetector(), G4VtkSceneHandler::AddPrimitive(), AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4VtkSceneHandler::AddPrimitiveTensorGlyph(), AddSolid(), G4GMocrenFileSceneHandler::AddSolid(), G4OpenInventorSceneHandler::AddTransform(), G4VSceneHandler::BeginPrimitives(), G4VSceneHandler::PreAddSolid(), and G4VSceneHandler::RequestPrimitives().

◆ fpModel

G4VModel* G4VSceneHandler::fpModel

protectedinherited

Definition at line 359 of file G4VSceneHandler.hh.

Referenced by AddCompound(), G4VSceneHandler::AddCompound(), G4GMocrenFileSceneHandler::AddCompound(), G4GMocrenFileSceneHandler::AddDetector(), AddHepRepInstance(), G4Qt3DSceneHandler::AddPrimitive(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenInventorSceneHandler::AddPrimitive(), G4GMocrenFileSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4GMocrenFileSceneHandler::AddSolid(), G4VtkSceneHandler::AddSolid(), G4RayTracerSceneHandler::BuildVisAttsMap(), G4Qt3DSceneHandler::CreateNewNode(), G4VSceneHandler::DrawEndOfRunModels(), G4VSceneHandler::DrawEvent(), G4VSceneHandler::EndModeling(), G4OpenGLStoredQtSceneHandler::ExtraPOProcessing(), G4OpenInventorSceneHandler::GeneratePrerequisites(), G4ToolsSGSceneHandler::GetOrCreateNode(), G4VSceneHandler::LoadAtts(), G4VTreeSceneHandler::PreAddSolid(), G4VSceneHandler::ProcessScene(), G4ASCIITreeSceneHandler::RequestPrimitives(), G4VSceneHandler::RequestPrimitives(), and G4OpenGLSceneHandler::ScaledFlush().

◆ fProcessing2D

G4bool G4VSceneHandler::fProcessing2D

protectedinherited

Definition at line 358 of file G4VSceneHandler.hh.

◆ fProcessingSolid

G4bool G4VSceneHandler::fProcessingSolid

protectedinherited

Definition at line 357 of file G4VSceneHandler.hh.

Referenced by G4OpenInventorSceneHandler::BeginPrimitives(), G4VSceneHandler::PostAddSolid(), and G4VSceneHandler::PreAddSolid().

◆ fpScene

G4Scene* G4VSceneHandler::fpScene

protectedinherited

Definition at line 351 of file G4VSceneHandler.hh.

Referenced by G4Qt3DSceneHandler::AddPrimitive(), G4VSceneHandler::CreateSectionSolid(), G4VSceneHandler::DrawEndOfRunModels(), G4VSceneHandler::DrawEvent(), G4ASCIITreeSceneHandler::EndModeling(), G4RayTracerSceneHandler::G4RayTracerSceneHandler(), G4VSceneHandler::GetExtent(), G4Qt3DViewer::mouseMoveEvent(), G4VSceneHandler::ProcessScene(), G4OpenGLSceneHandler::ScaledFlush(), G4VSceneHandler::SetScene(), and G4OpenGLStoredQtSceneHandler::SetScene().

◆ fpViewer

G4VViewer* G4VSceneHandler::fpViewer

protectedinherited

Definition at line 350 of file G4VSceneHandler.hh.

◆ fpVisAttribs

const G4VisAttributes* G4VSceneHandler::fpVisAttribs

protectedinherited

Definition at line 363 of file G4VSceneHandler.hh.

Referenced by AddHepRepInstance(), G4ToolsSGSceneHandler::AddPrimitive(), AddPrimitive(), G4OpenGLSceneHandler::AddPrimitive(), G4Qt3DSceneHandler::AddPrimitive(), G4OpenGLImmediateSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), AddSolid(), G4VSceneHandler::AddSolidT(), G4VSceneHandler::AddSolidWithAuxiliaryEdges(), G4RayTracerSceneHandler::BuildVisAttsMap(), G4OpenInventorSceneHandler::GeneratePrerequisites(), G4VSceneHandler::GetColour(), G4GMocrenFileSceneHandler::IsVisible(), G4VSceneHandler::PostAddSolid(), G4VSceneHandler::PreAddSolid(), and G4VSceneHandler::RequestPrimitives().

◆ fReadyForTransients

G4bool G4VSceneHandler::fReadyForTransients

protectedinherited

Definition at line 353 of file G4VSceneHandler.hh.

Referenced by AddHepRepInstance(), G4ToolsSGSceneHandler::AddPrimitive(), G4OpenGLStoredSceneHandler::AddPrimitivePostamble(), G4OpenGLStoredSceneHandler::AddPrimitivePreambleInternal(), G4OpenGLStoredSceneHandler::BeginPrimitives(), G4OpenGLStoredSceneHandler::BeginPrimitives2D(), G4Qt3DSceneHandler::CreateNewNode(), G4VSceneHandler::EndPrimitives(), G4VSceneHandler::EndPrimitives2D(), G4OpenInventorSceneHandler::GeneratePrerequisites(), G4ToolsSGSceneHandler::GetOrCreateNode(), G4VSceneHandler::PostAddSolid(), G4VSceneHandler::ProcessScene(), and G4OpenGLSceneHandler::ScaledFlush().

◆ fSceneHandlerId

const G4int G4VSceneHandler::fSceneHandlerId

protectedinherited

Definition at line 346 of file G4VSceneHandler.hh.

◆ fSceneIdCount

G4int G4HepRepFileSceneHandler::fSceneIdCount = 0

staticprotected

Definition at line 132 of file G4HepRepFileSceneHandler.hh.

◆ fSystem

G4VGraphicsSystem& G4VSceneHandler::fSystem

protectedinherited

Definition at line 345 of file G4VSceneHandler.hh.

Referenced by G4VSceneHandler::AddPrimitive().

◆ fTransientsDrawnThisEvent

G4bool G4VSceneHandler::fTransientsDrawnThisEvent

protectedinherited

Definition at line 355 of file G4VSceneHandler.hh.

Referenced by G4VSceneHandler::EndPrimitives(), G4VSceneHandler::EndPrimitives2D(), and G4VSceneHandler::PostAddSolid().

◆ fTransientsDrawnThisRun

G4bool G4VSceneHandler::fTransientsDrawnThisRun

protectedinherited

Definition at line 356 of file G4VSceneHandler.hh.

Referenced by G4VSceneHandler::EndPrimitives(), G4VSceneHandler::EndPrimitives2D(), and G4VSceneHandler::PostAddSolid().

◆ fViewCount

G4int G4VSceneHandler::fViewCount

protectedinherited

Definition at line 348 of file G4VSceneHandler.hh.

◆ fViewerList

G4ViewerList G4VSceneHandler::fViewerList

protectedinherited

Definition at line 349 of file G4VSceneHandler.hh.

Referenced by G4VSceneHandler::AddViewerToList(), G4VSceneHandler::RemoveViewerFromList(), and G4VSceneHandler::SetScene().

◆ haveVisible

G4bool G4HepRepFileSceneHandler::haveVisible

private

Definition at line 139 of file G4HepRepFileSceneHandler.hh.

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

◆ hepRepXMLWriter

G4HepRepFileXMLWriter* G4HepRepFileSceneHandler::hepRepXMLWriter

private

Definition at line 135 of file G4HepRepFileSceneHandler.hh.

Referenced by AddCompound(), AddHepRepInstance(), AddPrimitive(), AddSolid(), CheckFileOpen(), G4HepRepFileSceneHandler(), GetHepRepXMLWriter(), InitHit(), and InitTrajectory().

◆ hitAttDefs

std::map<G4String, G4AttDef>* G4HepRepFileSceneHandler::hitAttDefs

private

Definition at line 153 of file G4HepRepFileSceneHandler.hh.

Referenced by AddCompound(), G4HepRepFileSceneHandler(), and InitHit().

◆ hitAttValues

std::vector<G4AttValue>* G4HepRepFileSceneHandler::hitAttValues

private

Definition at line 152 of file G4HepRepFileSceneHandler.hh.

Referenced by AddCompound(), G4HepRepFileSceneHandler(), and InitHit().

◆ inPrimitives2D

G4bool G4HepRepFileSceneHandler::inPrimitives2D

private

Definition at line 140 of file G4HepRepFileSceneHandler.hh.

Referenced by AddPrimitive(), BeginPrimitives2D(), EndPrimitives2D(), and G4HepRepFileSceneHandler().

◆ trajAttDefs

std::map<G4String, G4AttDef>* G4HepRepFileSceneHandler::trajAttDefs

private

Definition at line 151 of file G4HepRepFileSceneHandler.hh.

Referenced by AddCompound(), G4HepRepFileSceneHandler(), and InitTrajectory().

◆ trajAttValues

std::vector<G4AttValue>* G4HepRepFileSceneHandler::trajAttValues

private

Definition at line 150 of file G4HepRepFileSceneHandler.hh.

Referenced by AddCompound(), G4HepRepFileSceneHandler(), and InitTrajectory().

◆ trajContext

const G4VisTrajContext* G4HepRepFileSceneHandler::trajContext

private

Definition at line 148 of file G4HepRepFileSceneHandler.hh.

Referenced by AddCompound(), BeginModeling(), and G4HepRepFileSceneHandler().

◆ warnedAbout2DMarkers

G4bool G4HepRepFileSceneHandler::warnedAbout2DMarkers

private

Definition at line 142 of file G4HepRepFileSceneHandler.hh.

Referenced by AddPrimitive(), and G4HepRepFileSceneHandler().

◆ warnedAbout3DText

G4bool G4HepRepFileSceneHandler::warnedAbout3DText

private

Definition at line 141 of file G4HepRepFileSceneHandler.hh.

Referenced by AddPrimitive(), and G4HepRepFileSceneHandler().

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

source/visualization/HepRep/include/G4HepRepFileSceneHandler.hh
source/visualization/HepRep/src/G4HepRepFileSceneHandler.cc

Protected Attributes
const G4Transform3D	fIdentityTransformation

G4bool	fMarkForClearingTransientStore

G4String	fName

G4int	fNestingDepth

G4Transform3D	fObjectTransformation

G4VModel *	fpModel

G4bool	fProcessing2D

G4bool	fProcessingSolid

G4Scene *	fpScene

G4VViewer *	fpViewer

const G4VisAttributes *	fpVisAttribs

G4bool	fReadyForTransients

const G4int	fSceneHandlerId

G4VGraphicsSystem &	fSystem

G4bool	fTransientsDrawnThisEvent

G4bool	fTransientsDrawnThisRun

G4int	fViewCount

G4ViewerList	fViewerList

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ MarkerSizeType

Constructor & Destructor Documentation

◆ G4HepRepFileSceneHandler()

◆ ~G4HepRepFileSceneHandler()

Member Function Documentation

◆ AddCompound() [1/8]

◆ AddCompound() [2/8]

◆ AddCompound() [3/8]

◆ AddCompound() [4/8]

◆ AddCompound() [5/8]

◆ AddCompound() [6/8]

◆ AddCompound() [7/8]

◆ AddCompound() [8/8]

◆ AddHepRepInstance()

◆ AddPrimitive() [1/13]

◆ AddPrimitive() [2/13]

◆ AddPrimitive() [3/13]

◆ AddPrimitive() [4/13]

◆ AddPrimitive() [5/13]

◆ AddPrimitive() [6/13]

◆ AddPrimitive() [7/13]

◆ AddPrimitive() [8/13]

◆ AddPrimitive() [9/13]

◆ AddPrimitive() [10/13]

◆ AddPrimitive() [11/13]

◆ AddPrimitive() [12/13]

◆ AddPrimitive() [13/13]

◆ 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]

◆ AddSolidT()

◆ AddSolidWithAuxiliaryEdges()

◆ AddViewerToList()

◆ BeginModeling()

◆ BeginPrimitives()

◆ BeginPrimitives2D()

◆ CheckFileOpen()

◆ ClearStore()

◆ ClearTransientStore()

◆ CreateCutawaySolid()

◆ CreateModelingParameters()

◆ CreateSectionSolid()

◆ DrawEndOfRunModels()

◆ DrawEvent()

◆ EndModeling()

◆ EndPrimitives()

◆ EndPrimitives2D()

◆ GetAuxEdgeVisible()

◆ GetColor() [1/2]

◆ GetColor() [2/2]

◆ GetColour() [1/2]

◆ GetColour() [2/2]

◆ GetCurrentViewer()

◆ GetDrawingStyle()

◆ GetExtent()

◆ GetGraphicsSystem()

◆ GetHepRepXMLWriter()

◆ GetLineWidth()

◆ GetMarkerDiameter()

◆ GetMarkerRadius()