G4DAWNFILEViewer Class Reference

#include <G4DAWNFILEViewer.hh>

Inheritance diagram for G4DAWNFILEViewer:

Public Member Functions
	G4DAWNFILEViewer (G4DAWNFILESceneHandler &scene, const G4String &name="")
virtual	~G4DAWNFILEViewer ()
void	SetView ()
void	ClearView ()
void	DrawView ()
void	ShowView ()
void	SendViewParameters ()
const char *	GetG4PrimViewer ()
const char *	GetG4PrimViewerInvocation ()
const char *	GetPSViewer ()
void	SendDrawingStyleToDAWNGUI (std::ostream &out)
Public Member Functions inherited from G4VViewer
	G4VViewer (G4VSceneHandler &, G4int id, const G4String &name="")
virtual	~G4VViewer ()
virtual void	Initialise ()
virtual void	ResetView ()
virtual void	SetView ()=0
virtual void	ClearView ()=0
virtual void	DrawView ()=0
void	RefreshView ()
virtual void	ShowView ()
virtual void	FinishView ()
std::vector< G4ThreeVector >	ComputeFlyThrough (G4Vector3D *)
const G4String &	GetName () const
const G4String &	GetShortName () const
void	SetName (const G4String &)
G4int	GetViewId () const
G4VSceneHandler *	GetSceneHandler () const
const G4ViewParameters &	GetViewParameters () const
const G4ViewParameters &	GetDefaultViewParameters () const
G4double	GetKernelVisitElapsedTimeSeconds () const
virtual const std::vector< G4ModelingParameters::VisAttributesModifier > *	GetPrivateVisAttributesModifiers () const
void	SetViewParameters (const G4ViewParameters &vp)
void	SetDefaultViewParameters (const G4ViewParameters &vp)
const G4VisAttributes *	GetApplicableVisAttributes (const G4VisAttributes *) const
void	SetNeedKernelVisit (G4bool need)
void	NeedKernelVisit ()
void	ProcessView ()

Additional Inherited Members
Protected Member Functions inherited from G4VViewer
void	SetTouchable (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath)
void	TouchableSetVisibility (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath, G4bool visibility)
void	TouchableSetColour (const std::vector< G4PhysicalVolumeModel::G4PhysicalVolumeNodeID > &fullPath, const G4Colour &)
Protected Attributes inherited from G4VViewer
G4VSceneHandler &	fSceneHandler
G4int	fViewId
G4String	fName
G4String	fShortName
G4ViewParameters	fVP
G4ViewParameters	fDefaultVP
G4double	fKernelVisitElapsedTimeSeconds = 999.
G4bool	fNeedKernelVisit

Detailed Description

Definition at line 39 of file G4DAWNFILEViewer.hh.

Constructor & Destructor Documentation

G4DAWNFILEViewer()

G4DAWNFILEViewer::G4DAWNFILEViewer	(	G4DAWNFILESceneHandler &	scene,
		const G4String &	name = ""
	)

Definition at line 59 of file G4DAWNFILEViewer.cc.

  : G4VViewer(sceneHandler, sceneHandler.IncrementViewCount(), name)
  , fSceneHandler(sceneHandler)
{
  // Set a g4.prim-file viewer
  strcpy(fG4PrimViewer, "dawn");
  if(std::getenv("G4DAWNFILE_VIEWER") != NULL)
  {
    strcpy(fG4PrimViewer, std::getenv("G4DAWNFILE_VIEWER"));
  }
 
  // string for viewer invocation
  if(!strcmp(fG4PrimViewer, "NONE"))
  {
    strcpy(fG4PrimViewerInvocation, "");
  }
  else
  {
    strcpy(fG4PrimViewerInvocation, fG4PrimViewer);
    strcat(fG4PrimViewerInvocation, " ");
    strcat(fG4PrimViewerInvocation, fSceneHandler.GetG4PrimFileName());
  }
 
  // Set a PostScript Viewer
  //    strcpy( fPSViewer, "ghostview" );
  strcpy(fPSViewer, "gv");
  if(std::getenv("G4DAWNFILE_PS_VIEWER") != NULL)
  {
    strcpy(fPSViewer, std::getenv("G4DAWNFILE_PS_VIEWER"));
  }
}

~G4DAWNFILEViewer()

G4DAWNFILEViewer::~G4DAWNFILEViewer ( )

virtual

Definition at line 93 of file G4DAWNFILEViewer.cc.

{}

Member Function Documentation

ClearView()

void G4DAWNFILEViewer::ClearView ( void  )

virtual

Implements G4VViewer.

Definition at line 107 of file G4DAWNFILEViewer.cc.

{
#if defined DEBUG_FR_VIEW
  if(G4VisManager::GetVerbosity() >= G4VisManager::errors)
    G4cout << "***** G4DAWNFILEViewer::ClearView (): No effects " << G4endl;
#endif
  if(fSceneHandler.fPrimDest.IsOpen())
  {
    fSceneHandler.fPrimDest.Close();
    // Re-open with same filename...
    fSceneHandler.fPrimDest.Open(fSceneHandler.fG4PrimFileName);
    fSceneHandler.SendStr(FR_G4_PRIM_HEADER);
    fSceneHandler.FRflag_in_modeling = false;
    fSceneHandler.FRBeginModeling();
  }
}

DrawView()

void G4DAWNFILEViewer::DrawView ( )

virtual

Implements G4VViewer.

Definition at line 125 of file G4DAWNFILEViewer.cc.

{
#if defined DEBUG_FR_VIEW
  if(G4VisManager::GetVerbosity() >= G4VisManager::errors)
    G4cout << "***** G4DAWNFILEViewer::DrawView () " << G4endl;
#endif
  //-----
  fSceneHandler.FRBeginModeling();
 
  //----- Always visit G4 kernel
  NeedKernelVisit();
 
  //----- Draw
  ProcessView();
 
}  // G4DAWNFILEViewer::DrawView ()

GetG4PrimViewer()

const char * G4DAWNFILEViewer::GetG4PrimViewer ( )

inline

Definition at line 64 of file G4DAWNFILEViewer.hh.

{ return fG4PrimViewer; }

GetG4PrimViewerInvocation()

const char * G4DAWNFILEViewer::GetG4PrimViewerInvocation ( )

inline

Definition at line 65 of file G4DAWNFILEViewer.hh.

{ return fG4PrimViewerInvocation; }

Referenced by ShowView().

GetPSViewer()

const char * G4DAWNFILEViewer::GetPSViewer ( )

inline

Definition at line 66 of file G4DAWNFILEViewer.hh.

{ return fPSViewer; }

Referenced by SendViewParameters().

SendDrawingStyleToDAWNGUI()

void G4DAWNFILEViewer::SendDrawingStyleToDAWNGUI

(

std::ostream &

out

)

Definition at line 205 of file G4DAWNFILEViewer.cc.

{
  ///////////////////////
  //#if defined DEBUG_FR_VIEW
  //  G4cout << "***** G4DAWNFILEViewer::SendDrawingStyleToDAWNGUI()" << G4endl;
  //#endif
  //////////////////////
 
  G4int style = fVP.GetDrawingStyle();
 
  enum
  {
    FR_WIREFRAME_STYLE        = 1,
    FR_WF_STORED_STYLE        = 2,
    FR_HID_STYLE              = 3,
    FR_HID2_STYLE             = 4,
    FR_HID3_STYLE             = 5,
    FR_DRAWING_MODE_END_STYLE = 6
  };
 
  switch(style)
  {
    case G4ViewParameters::wireframe:
      out << FR_WIREFRAME_STYLE << G4endl;
      break;
    case G4ViewParameters::hlr:
      out << FR_HID2_STYLE << G4endl;  // LINE
      break;
    case G4ViewParameters::hsr:
    case G4ViewParameters::hlhsr:
      out << FR_HID_STYLE << G4endl;  // SURFACE
      break;
    default:
      out << FR_WIREFRAME_STYLE << G4endl;
      break;
  }
 
}  // G4DAWNFILEViewer::SendDrawingStyle()

Referenced by SendViewParameters().

SendViewParameters()

void G4DAWNFILEViewer::SendViewParameters

(

)

Definition at line 245 of file G4DAWNFILEViewer.cc.

{
  // Calculates view representation based on extent of object being
  // viewed and (initial) direction of camera.  (Note: it can change
  // later due to user interaction via visualization system's GUI.)
 
#if defined DEBUG_FR_VIEW
  if(G4VisManager::GetVerbosity() >= G4VisManager::errors)
  {
    G4cout << "***** G4DAWNFILEViewer::SendViewParameters()  ";
    G4cout << "(GUI parameters)" << G4endl;
  }
#endif
 
  //----- Magic number to decide camera distance automatically
  const G4double HOW_FAR        = 1000.0;  // to define "infinity"
  const G4double MIN_HALF_ANGLE = 0.01;
  const G4double MAX_HALF_ANGLE = 0.499 * pi;
 
  //----- CALC camera distance
  //..... Note: Camera cannot enter inside object
  G4double camera_distance;
  G4double radius = fSceneHandler.GetScene()->GetExtent().GetExtentRadius();
 
  G4double half_view_angle = std::fabs(fVP.GetFieldHalfAngle());
  if(half_view_angle > MAX_HALF_ANGLE)
  {
    half_view_angle = MAX_HALF_ANGLE;
  }
 
  if(half_view_angle < MIN_HALF_ANGLE)
  {
    //----- infinity (or ortho projection)
    camera_distance = radius * HOW_FAR;
  }
  else
  {
    //----- Calc camera distance from half view angle
    camera_distance = radius / std::sin(half_view_angle);
    camera_distance -= fVP.GetDolly();
  }
 
  if(camera_distance < radius)
  {
    if(G4VisManager::GetVerbosity() >= G4VisManager::errors)
    {
      G4cout << "WARNING from DAWNFILE driver:" << G4endl;
      G4cout << "  Camera cannot enter inside objects" << G4endl;
    }
    camera_distance = radius;
  }
 
  //----- CALC camera direction
  const G4Vector3D& camera_direction = fVP.GetViewpointDirection().unit();
  const G4double v_angle             = (180.0 / pi) * camera_direction.theta();
  const G4double h_angle             = (180.0 / pi) * camera_direction.phi();
 
  //########### Generation of the file .DAWN.history for DAWN GUI
  //-----
  std::ofstream gui_out(".DAWN_1.history");
 
  // ######### P1
 
  //----- camera position
  gui_out << camera_distance << G4endl;
  gui_out << v_angle << G4endl;
  gui_out << h_angle << G4endl;
  gui_out << "0" << G4endl;  // auto target
 
  //----- target point
  const G4Point3D& target_point =
    fSceneHandler.GetScene()->GetStandardTargetPoint() +
    fVP.GetCurrentTargetPoint();
  gui_out << target_point.x() << G4endl;
  gui_out << target_point.y() << G4endl;
  gui_out << target_point.z() << G4endl;
 
  //----- Magnification
  const G4double zoom_factor = fVP.GetZoomFactor();
  if(half_view_angle < MIN_HALF_ANGLE)
  {
    gui_out << zoom_factor << G4endl;
  }
  else
  {
    const G4double FR_HALF_SCREEN_SIZE = 0.5;
    G4double focal_distance = FR_HALF_SCREEN_SIZE / std::tan(half_view_angle);
    focal_distance *= zoom_factor;
 
    gui_out << "fd" << focal_distance << G4endl;
  }
  SendDrawingStyleToDAWNGUI(gui_out);  // gui_out, viewing mode
  gui_out << "0.001" << G4endl;        // 3D Tolerance
  gui_out << "0" << G4endl;            // not display parameters
 
  // ######### P2
  gui_out << 1 << G4endl;  // Source light
  gui_out << 1 << G4endl;
  gui_out << 1 << G4endl;
  gui_out << 0.5 << G4endl;  // Ambient light
  gui_out << 0.5 << G4endl;
  gui_out << 0.5 << G4endl;
  gui_out << 19.0 << G4endl;  // Light direction (Polar)
  gui_out << 71.0 << G4endl;  // Light direction (Azimuthal)
 
  // ######### P3
  gui_out << 0.1 << G4endl;   // Real edge width
  gui_out << 0.1 << G4endl;   // outline   width
  gui_out << 0.1 << G4endl;   // aux edge  width
  gui_out << 3 << G4endl;     // aux edge  style
  gui_out << 70.0 << G4endl;  // aux-edge threshold angle
  gui_out << 0.1 << G4endl;   // line width
  gui_out << 0 << G4endl;     // haloing
  gui_out << 1 << G4endl;     // Dashed edged for back faces
 
  //######### P4
  //----- drawing device
  //    enum {PS=1, XWIN=2, PS2=3, XWIN2=4, OPEN_GL=5, DEVICE_END=6};
  if(((std::getenv(FR_ENV_MULTI_WINDOW) != NULL) &&
      (strcmp(std::getenv(FR_ENV_MULTI_WINDOW), "0"))) ||
     ((std::getenv(FR_ENV_MULTI_WINDOW2) != NULL) &&
      (strcmp(std::getenv(FR_ENV_MULTI_WINDOW2), "0"))))
  {
    gui_out << 2 << G4endl;  // OpenWindow
  }
  else
  {
    gui_out << 1 << G4endl;  // Invoke PS viewer
  }
 
  gui_out << GetPSViewer() << G4endl;  // PS viewer
  gui_out << 1 << G4endl;              // Do not add showpage
  gui_out << 0 << G4endl;              // Non-append mode
 
  gui_out.close();
  //########### end of generating file .DAWN.history
}

Referenced by ShowView().

SetView()

void G4DAWNFILEViewer::SetView ( )

virtual

Implements G4VViewer.

Definition at line 96 of file G4DAWNFILEViewer.cc.

{
#if defined DEBUG_FR_VIEW
  if(G4VisManager::GetVerbosity() >= G4VisManager::errors)
    G4cout << "***** G4DAWNFILEViewer::SetView(): No effects" << G4endl;
#endif
  // Do nothing, since DAWN is running as a different process.
  // SendViewParameters () will do this job instead.
}

ShowView()

void G4DAWNFILEViewer::ShowView ( void  )

virtual

Reimplemented from G4VViewer.

Definition at line 143 of file G4DAWNFILEViewer.cc.

{
#if defined DEBUG_FR_VIEW
  if(G4VisManager::GetVerbosity() >= G4VisManager::errors)
    G4cout << "***** G4DAWNFILEViewer::ShowView () " << G4endl;
#endif
 
  if(fSceneHandler.FRIsInModeling())
  {
    //----- End of modeling
    // !EndModeling, !DrawAll, !CloseDevice,
    // close g4.prim
    fSceneHandler.FREndModeling();
 
    //----- Output DAWN GUI file
    SendViewParameters();
 
    //----- string for viewer invocation
    if(!strcmp(fG4PrimViewer, "NONE"))
    {
      strcpy(fG4PrimViewerInvocation, "");
    }
    else
    {
      strcpy(fG4PrimViewerInvocation, fG4PrimViewer);
      strcat(fG4PrimViewerInvocation, " ");
      strcat(fG4PrimViewerInvocation, fSceneHandler.GetG4PrimFileName());
    }
 
    //----- Invoke DAWN
    G4cout << G4endl;
    if(false == G4FRofstream::DoesFileExist(fSceneHandler.GetG4PrimFileName()))
    {
      G4cout << "ERROR: Failed to generate file  ";
      G4cout << fSceneHandler.GetG4PrimFileName() << G4endl;
    }
    else if(strcmp(GetG4PrimViewerInvocation(), ""))
    {
      G4cout << "File  " << fSceneHandler.GetG4PrimFileName();
      G4cout << "  is generated." << G4endl;
      G4cout << GetG4PrimViewerInvocation() << G4endl;
      int iErr = system(GetG4PrimViewerInvocation());
      if(iErr != 0)
      {
        G4ExceptionDescription ed;
        ed << "Error " << iErr << " when calling system with \""
           << GetG4PrimViewerInvocation() << "\".";
        G4Exception("G4DAWNFILEViewer::ShowView()", "dawn0005", JustWarning,
                    ed);
      }
    }
    else
    {  // no view, i.e., only file generation
      G4cout << "File  " << fSceneHandler.GetG4PrimFileName();
      G4cout << "  is generated." << G4endl;
      G4cout << "No viewer is invoked." << G4endl;
    }
  }
 
}  // G4DAWNFILEViewer::ShowView()

---

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

• G4DAWNFILEViewer.hh
• G4DAWNFILEViewer.cc