G4GMocrenFileSceneHandler Class Reference

#include <G4GMocrenFileSceneHandler.hh>

Inheritance diagram for G4GMocrenFileSceneHandler:

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

Friends
class	G4GMocrenFileViewer

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

Detailed Description

Definition at line 53 of file G4GMocrenFileSceneHandler.hh.

Constructor & Destructor Documentation

G4GMocrenFileSceneHandler()

G4GMocrenFileSceneHandler::G4GMocrenFileSceneHandler	(	G4GMocrenFile &	system,
		G4GMocrenMessenger &	messenger,
		const G4String &	name = ""
	)

Definition at line 120 of file G4GMocrenFileSceneHandler.cc.

  : G4VSceneHandler(system, kSceneIdCount++, name),
    kSystem(system),
    kMessenger(messenger),
    kgMocrenIO(new G4GMocrenIO()),
    kbSetModalityVoxelSize(false),
    kbModelingTrajectory(false),
//    kGddDest(0),
    kFlagInModeling(false),
    kFlagSaving_g4_gdd(false),
    kFlagParameterization(0),
    kFlagProcessedInteractiveScorer(false) {
 
  // g4.gdd filename and its directory
  if(std::getenv("G4GMocrenFile_DEST_DIR") == NULL) {
    kGddDestDir[0] = '\0';
    //std::strcpy(kGddDestDir , "");                    // output dir
    //std::strcpy(kGddFileName, DEFAULT_GDD_FILE_NAME); // filename
    std::strncpy(kGddFileName, DEFAULT_GDD_FILE_NAME,
         std::strlen(DEFAULT_GDD_FILE_NAME)+1);   // filename
  } else {
    const char * env = std::getenv("G4GMocrenFile_DEST_DIR");
    G4int len = (G4int)std::strlen(env);
    if(len > 256) {
      G4Exception("G4GMocrenFileSceneHandler::G4GMocrenFileSceneHandler(*)",
                  "gMocren1000", FatalException,
                  "Invalid length of string set in G4GMocrenFile_DEST_DIR");
    }
    std::strncpy(kGddDestDir, env, len+1);  // output dir
    std::strncpy(kGddFileName, DEFAULT_GDD_FILE_NAME,
                 std::strlen(DEFAULT_GDD_FILE_NAME)+1);  // filename
  }
        
  // maximum number of g4.gdd files in the dest directory
  kMaxFileNum = FR_MAX_FILE_NUM ; // initialization
  if ( std::getenv( "G4GMocrenFile_MAX_FILE_NUM" ) != NULL ) {  
    char * pcFileNum = std::getenv("G4GMocrenFile_MAX_FILE_NUM");
    char c10FileNum[10];
    std::strncpy(c10FileNum, pcFileNum, 9);
    c10FileNum[9] = '\0';
    kMaxFileNum = std::atoi(c10FileNum);
 
  } else {
    kMaxFileNum = FR_MAX_FILE_NUM ;
  }
  if( kMaxFileNum < 1 ) { kMaxFileNum = 1 ; }
 
  InitializeParameters();
 
} 

~G4GMocrenFileSceneHandler()

G4GMocrenFileSceneHandler::~G4GMocrenFileSceneHandler ( )

virtual

Definition at line 175 of file G4GMocrenFileSceneHandler.cc.

{
  if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
      G4cout << "***** ~G4GMocrenFileSceneHandler" << G4endl;
 
  if(kGddDest) {
    //----- End of modeling
    // close g4.gdd
    GFEndModeling();
  }
  if(kgMocrenIO != NULL) delete kgMocrenIO;
 
}

Member Function Documentation

AddCompound() [1/11]

void G4VSceneHandler::AddCompound ( const G4Mesh &  mesh )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 133 of file G4VSceneHandler.cc.

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

AddCompound() [2/11]

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

virtual

Reimplemented from G4VSceneHandler.

Definition at line 131 of file G4VSceneHandler.cc.

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

AddCompound() [3/11]

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

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1741 of file G4GMocrenFileSceneHandler.cc.

                                                                             {
  if(GFDEBUG_HIT)
    G4cout << " ::AddCompound(const std::map<G4int, G4double*> &) >>>>>>>>> " << G4endl;
 
 
  std::vector<G4String> hitScorerNames = kMessenger.getHitScorerNames();
  G4int nhitname = (G4int)hitScorerNames.size();
  G4String scorername = static_cast<G4VHitsCollection>(hits).GetName();
 
  //-- --//
  /*
  std::vector<G4String> hitScorerNames = kMessenger.getHitScorerNames();
  if(GFDEBUG_HIT) {
    std::vector<G4String>::iterator itr = hitScorerNames.begin();
    for(; itr != hitScorerNames.end(); itr++) 
      G4cout << "  PS name : " << *itr << G4endl;
  }
  */
  
  {  // Scope bracket to avoid compiler messages about shadowing (JA).
  //for(G4int i = 0; i < nhitname; i++) {       // this selection trusts
    //if(scorername == hitScorerNames[i]) {   // thea command /vis/scene/add/psHits hit_name.
 
      G4int idx[3];
      std::map<G4int, G4double*> * map = hits.GetMap();
      std::map<G4int, G4double*>::const_iterator itr = map->begin();
      for(; itr != map->end(); itr++) {
    GetNestedVolumeIndex(itr->first, idx);
    Index3D id(idx[0], idx[1], idx[2]);
    
    std::map<G4String, std::map<Index3D, G4double> >::iterator nestedHitsListItr;
    nestedHitsListItr = kNestedHitsList.find(scorername);
    if(nestedHitsListItr != kNestedHitsList.end()) {
      nestedHitsListItr->second[id] = *(itr->second);
    } else {
      std::map<Index3D, G4double> hit;
      hit.insert(std::map<Index3D, G4double>::value_type(id, *(itr->second)));
      kNestedHitsList[scorername] = hit;
    }
      }
 
      //break;
    //}
  //}
  }
 
  if(GFDEBUG_HIT) {
    G4String meshname = static_cast<G4VHitsCollection>(hits).GetSDname();
    G4cout << "       >>>>> " << meshname << " : " << scorername  << G4endl;
 
    for(G4int i = 0; i < nhitname; i++)
      if(scorername == hitScorerNames[i]) 
    G4cout << "       !!!! Hit scorer !!!! " << scorername << G4endl;
 
    G4cout << " dimension: "
       << kNestedVolumeDimension[0] << " x "
       << kNestedVolumeDimension[1] << " x "
       << kNestedVolumeDimension[2] << G4endl;
 
    G4int id[3];
    std::map<G4int, G4double*> * map = hits.GetMap();
    std::map<G4int, G4double*>::const_iterator itr = map->begin();
    for(; itr != map->end(); itr++) {
      GetNestedVolumeIndex(itr->first, id);
      G4cout << "[" << itr->first << "] "
         << "("<< id[0] << "," << id[1] << "," << id[2] << ")"
         << *(itr->second) << ", ";
    }
    G4cout << G4endl;
  }
}

AddCompound() [4/11]

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

virtual

Reimplemented from G4VSceneHandler.

Definition at line 132 of file G4VSceneHandler.cc.

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

AddCompound() [5/11]

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

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1813 of file G4GMocrenFileSceneHandler.cc.

                                                                                 {
  if(GFDEBUG_HIT)
    G4cout << " ::AddCompound(const std::map<G4int, G4StatDouble*> &) >>>>>>>>> " << G4endl;
 
 
  std::vector<G4String> hitScorerNames = kMessenger.getHitScorerNames();
  G4int nhitname = (G4int)hitScorerNames.size();
  G4String scorername = static_cast<G4VHitsCollection>(hits).GetName();
 
  //-- --//
  /*
  std::vector<G4String> hitScorerNames = kMessenger.getHitScorerNames();
  if(GFDEBUG_HIT) {
    std::vector<G4String>::iterator itr = hitScorerNames.begin();
    for(; itr != hitScorerNames.end(); itr++) 
      G4cout << "  PS name : " << *itr << G4endl;
  }
  */
  
  {  // Scope bracket to avoid compiler messages about shadowing (JA).
  //for(G4int i = 0; i < nhitname; i++) {       // this selection trusts
    //if(scorername == hitScorerNames[i]) {   // thea command /vis/scene/add/psHits hit_name.
 
      G4int idx[3];
      std::map<G4int, G4StatDouble*> * map = hits.GetMap();
      std::map<G4int, G4StatDouble*>::const_iterator itr = map->begin();
      for(; itr != map->end(); itr++) {
    GetNestedVolumeIndex(itr->first, idx);
    Index3D id(idx[0], idx[1], idx[2]);
    
    std::map<G4String, std::map<Index3D, G4double> >::iterator nestedHitsListItr;
    nestedHitsListItr = kNestedHitsList.find(scorername);
    if(nestedHitsListItr != kNestedHitsList.end()) {
      nestedHitsListItr->second[id] = itr->second->sum_wx();
    } else {
      std::map<Index3D, G4double> hit;
      hit.insert(std::map<Index3D, G4double>::value_type(id, itr->second->sum_wx()));
      kNestedHitsList[scorername] = hit;
    }
      }
 
      //break;
    //}
  //}
  }
 
  if(GFDEBUG_HIT) {
    G4String meshname = static_cast<G4VHitsCollection>(hits).GetSDname();
    G4cout << "       >>>>> " << meshname << " : " << scorername  << G4endl;
 
    for(G4int i = 0; i < nhitname; i++)
      if(scorername == hitScorerNames[i]) 
    G4cout << "       !!!! Hit scorer !!!! " << scorername << G4endl;
 
    G4cout << " dimension: "
       << kNestedVolumeDimension[0] << " x "
       << kNestedVolumeDimension[1] << " x "
       << kNestedVolumeDimension[2] << G4endl;
 
    G4int id[3];
    std::map<G4int, G4StatDouble*> * map = hits.GetMap();
    std::map<G4int, G4StatDouble*>::const_iterator itr = map->begin();
    for(; itr != map->end(); itr++) {
      GetNestedVolumeIndex(itr->first, id);
      G4cout << "[" << itr->first << "] "
         << "("<< id[0] << "," << id[1] << "," << id[2] << ")"
         << itr->second->sum_wx() << ", ";
    }
    G4cout << G4endl;
  }
}

AddCompound() [6/11]

void G4VSceneHandler::AddCompound ( const G4VDigi &  digi )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 130 of file G4VSceneHandler.cc.

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

AddCompound() [7/11]

void G4GMocrenFileSceneHandler::AddCompound ( const G4VDigi &  hit )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1736 of file G4GMocrenFileSceneHandler.cc.

                                                                 {
  if(GFDEBUG_DIGI) G4cout << " ::AddCompound(const G4VDigi&) >>>>>>>>> " << G4endl;
  G4VSceneHandler::AddCompound(digi);
}

AddCompound() [8/11]

void G4VSceneHandler::AddCompound ( const G4VHit &  hit )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 129 of file G4VSceneHandler.cc.

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

AddCompound() [9/11]

void G4GMocrenFileSceneHandler::AddCompound ( const G4VHit &  hit )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1636 of file G4GMocrenFileSceneHandler.cc.

                                                               {
  if(GFDEBUG_HIT) G4cout << " ::AddCompound(const G4VHit&) >>>>>>>>> " << G4endl;
 
  G4VSceneHandler::AddCompound(hit);
 
  /*
    const std::map<G4String, G4AttDef> * map = hit.GetAttDefs();
    if(!map) return;
    std::map<G4String, G4AttDef>::const_iterator itr = map->begin();
    for(; itr != map->end(); itr++) {
    G4cout << itr->first << " : " << itr->second.GetName()
    << " , " << itr->second.GetDesc() << G4endl;
    }
  */
 
  std::vector<G4String> hitNames = kMessenger.getHitNames();
  if(GFDEBUG_HIT) {
    std::vector<G4String>::iterator itr = hitNames.begin();
    for(; itr != hitNames.end(); itr++) 
      G4cout << "  hit name : " << *itr << G4endl;
  }
  
  std::vector<G4AttValue> * attval = hit.CreateAttValues();
  if(!attval) {G4cout << "0 empty " << G4endl;}
  else {
 
    G4bool bid[3] = {false, false, false};
    Index3D id;
 
    std::vector<G4AttValue>::iterator itr;
    // First, get IDs
    for(itr = attval->begin(); itr != attval->end(); itr++) {
      std::string stmp = itr->GetValue();
      std::istringstream sval(stmp.c_str());
 
      if(itr->GetName() == G4String("XID")) {
    sval >> id.x;
    bid[0] = true;
    continue;
      }
      if(itr->GetName() == G4String("YID")) {
    sval >> id.y;
    bid[1] = true;
    continue;
      }
      if(itr->GetName() == G4String("ZID")) {
    sval >> id.z;
    bid[2] = true;
    continue;
      }
    }
 
    G4int nhitname = (G4int)hitNames.size();
 
    if(bid[0] && bid[1] && bid[2]) {
 
      if(GFDEBUG_HIT)
    G4cout << " Hit : index(" << id.x << ", " << id.y << ", "
           << id.z << ")" << G4endl;
 
      // Get attributes
      for(itr = attval->begin(); itr != attval->end(); itr++) {
    for(G4int i = 0; i < nhitname; i++) {
      if(itr->GetName() == hitNames[i]) {
 
        std::string stmp = itr->GetValue();
        std::istringstream sval(stmp.c_str());
        G4double value;
        G4String unit;
        sval >> value >> unit;
 
        std::map<G4String, std::map<Index3D, G4double> >::iterator kNestedHitsListItr;
        kNestedHitsListItr = kNestedHitsList.find(hitNames[i]);
        if(kNestedHitsListItr != kNestedHitsList.end()) {
          //fTempNestedHits = &kNestedHitsListItr->second;
          //(*fTempNestedHits)[id] = value;
          kNestedHitsListItr->second[id] = value;
        } else {
          std::map<Index3D, G4double> hits;
          hits.insert(std::map<Index3D, G4double>::value_type(id, value));
          kNestedHitsList[hitNames[i]] = hits;
        }
 
        
        if(GFDEBUG_HIT)
          G4cout << "     : " << hitNames[i] << " -> " << value
             << " [" << unit << "]" << G4endl;
      }
    }
      }
    } else {
      G4Exception("G4GMocrenFileSceneHandler::AddCompound(const G4VHit &)",
          "gMocren0014", FatalException, "Error");
    }
 
    delete attval;
  }
 
}

AddCompound() [10/11]

void G4VSceneHandler::AddCompound ( const G4VTrajectory &  traj )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 128 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() [11/11]

void G4GMocrenFileSceneHandler::AddCompound ( const G4VTrajectory &  traj )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1596 of file G4GMocrenFileSceneHandler.cc.

                                                                      {
 
  kbModelingTrajectory = true;
 
  G4VSceneHandler::AddCompound(traj);
 
  if(GFDEBUG_TRK) {
    G4cout << " ::AddCompound(const G4VTrajectory&) >>>>>>>>> " << G4endl;
    G4TrajectoriesModel * pTrModel = dynamic_cast<G4TrajectoriesModel*>(fpModel);
    if (!pTrModel) { 
      G4Exception 
    ("G4VSceneHandler::AddCompound(const G4VTrajectory&)",
     "gMocren0013", FatalException, "Not a G4TrajectoriesModel.");
    } else {
      traj.DrawTrajectory();
 
      const G4VTrajectory * trj = pTrModel->GetCurrentTrajectory();
      G4cout << "------ track" << G4endl;
      G4cout << "    name:     " << trj->GetParticleName() << G4endl;
      G4cout << "    id:       " << trj->GetTrackID() << G4endl;
      G4cout << "    charge:   " << trj->GetCharge() << G4endl;
      G4cout << "    momentum: " << trj->GetInitialMomentum() << G4endl;
      
      G4int nPnt = trj->GetPointEntries();
      G4cout << "    point:    ";
      for(G4int i = 0; i < nPnt; i++) {
    G4cout << trj->GetPoint(i)->GetPosition() << ", ";
      }
      G4cout << G4endl;
    }
    G4cout << G4endl;
  }
 
  kbModelingTrajectory = false;
}

AddPrimitive() [1/12]

void G4GMocrenFileSceneHandler::AddPrimitive ( const G4Circle &  mark_circle )

virtual

Implements G4VSceneHandler.

Definition at line 662 of file G4GMocrenFileSceneHandler.cc.

{
  // to avoid a warning in the compile process
  G4Circle dummycircle = mark_circle;
 
  if (fProcessing2D) {
    static G4bool warned = false;
    if (!warned) {
      warned = true;
      G4Exception
    ("G4GMocrenFileSceneHandler::AddPrimitive (const G4Circle&)",
     "gMocren1003", JustWarning,
     "2D circles not implemented.  Ignored.");
    }
    return;
  }
 
  //----- 
  if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
    G4cout << "***** AddPrimitive( G4Circle )" << G4endl;
 
  //----- Initialize IF NECESSARY
  GFBeginModeling();
 
 
} // G4GMocrenFileSceneHandler::AddPrimitive ( mark_circle )

AddPrimitive() [2/12]

virtual void G4VSceneHandler::AddPrimitive ( const G4Circle &  )

virtual

Implements G4VSceneHandler.

AddPrimitive() [3/12]

void G4VSceneHandler::AddPrimitive ( const G4Plotter &  )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 193 of file G4VSceneHandler.cc.

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

AddPrimitive() [4/12]

virtual void G4VSceneHandler::AddPrimitive ( const G4Polyhedron &  )

virtual

Implements G4VSceneHandler.

AddPrimitive() [5/12]

void G4GMocrenFileSceneHandler::AddPrimitive ( const G4Polyhedron &  p )

virtual

Implements G4VSceneHandler.

Definition at line 719 of file G4GMocrenFileSceneHandler.cc.

{
  //----- 
  if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
    G4cout << "***** AddPrimitive( G4Polyhedron )" << G4endl;
 
 
  if (polyhedron.GetNoFacets() == 0) return;
 
  if (fProcessing2D) {
    static G4bool warned = false;
    if (!warned) {
      warned = true;
      G4Exception
    ("G4GMocrenFileSceneHandler::AddPrimitive (const G4Polyhedron&)",
     "gMocren1005", JustWarning,
     "2D polyhedra not implemented.  Ignored.");
    }
    return;
  }
 
  //----- Initialize if necessary
  GFBeginModeling();
 
  //---------- (3) Facet block
  for (G4int f = polyhedron.GetNoFacets(); f; f--){
    G4bool notLastEdge = true;
    G4int index = -1; // initialization
    G4int edgeFlag = 1;
    //G4int preedgeFlag = 1;
    //G4int work[4], i = 0;
    G4int i = 0;
    do {
      //preedgeFlag = edgeFlag;
      notLastEdge = polyhedron.GetNextVertexIndex(index, edgeFlag);
      //work[i++] = index;
      i++;
    }while (notLastEdge);
    switch (i){
    case 3:
      //SendStrInt3(FR_FACET, work[0], work[1], work[2] );
      break;
    case 4:
      //SendStrInt4(FR_FACET, work[0], work[1], work[2], work[3] );
      break;
    default:
      if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
    G4cout <<
      "ERROR G4GMocrenFileSceneHandler::AddPrimitive(G4Polyhedron)" << G4endl;
      G4PhysicalVolumeModel* pPVModel =
        dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
      if (pPVModel)   
    if(G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
      G4cout << "Volume " << pPVModel->GetCurrentPV()->GetName() <<
        ", Solid " << pPVModel->GetCurrentLV()->GetSolid()->GetName() <<
        " (" << pPVModel->GetCurrentLV()->GetSolid()->GetEntityType();
 
      if(G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
    G4cout <<
      "\nG4Polyhedron facet with " << i << " edges" << G4endl;  
    }
  }
 
} // G4GMocrenFileSceneHandler::AddPrimitive (polyhedron) 

AddPrimitive() [6/12]

virtual void G4VSceneHandler::AddPrimitive ( const G4Polyline &  )

virtual

Implements G4VSceneHandler.

AddPrimitive() [7/12]

void G4GMocrenFileSceneHandler::AddPrimitive ( const G4Polyline &  line )

virtual

Implements G4VSceneHandler.

Definition at line 542 of file G4GMocrenFileSceneHandler.cc.

{
  if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
    G4cout << "***** AddPrimitive" << G4endl;
 
  if (fProcessing2D) {
    static G4bool warned = false;
    if (!warned) {
      warned = true;
      G4Exception
    ("G4GMocrenFileSceneHandler::AddPrimitive (const G4Polyline&)",
     "gMocren1001", JustWarning,
     "2D polylines not implemented.  Ignored.");
    }
    return;
  }
 
  //----- Initialize if necessary
  GFBeginModeling();
 
  static G4int numTrajectories = 0;
  if(numTrajectories >= MAX_NUM_TRAJECTORIES) return;
 
  // draw trajectories
  if(kbModelingTrajectory) {
    
    G4TrajectoriesModel * pTrModel = dynamic_cast<G4TrajectoriesModel*>(fpModel);
    if (!pTrModel) { 
      G4Exception 
    ("G4VSceneHandler::AddCompound(const G4Polyline&)",
     "gMocren0002", FatalException, "Not a G4TrajectoriesModel.");
    }
 
    G4ThreeVector trans;
    G4RotationMatrix rot;
    trans = kVolumeTrans3D.getTranslation();
    rot = kVolumeTrans3D.getRotation().inverse();
 
    if(GFDEBUG_TRK) G4cout << "   trajectory points : " << G4endl;
    std::vector<G4float *> trajectory;
    if(polyline.size() < 2) return;
    G4Polyline::const_iterator preitr = polyline.begin();
    G4Polyline::const_iterator postitr = preitr; postitr++;
    for(; postitr != polyline.end(); preitr++, postitr++) {
      G4ThreeVector prePts(preitr->x(), preitr->y(), preitr->z());
      prePts -= trans;
      prePts.transform(rot);
      G4ThreeVector postPts(postitr->x(), postitr->y(), postitr->z());
      postPts -= trans;
      postPts.transform(rot);
      G4float * stepPts = new G4float[6];
      stepPts[0] = prePts.x();
      stepPts[1] = prePts.y();
      stepPts[2] = prePts.z();
      stepPts[3] = postPts.x();
      stepPts[4] = postPts.y();
      stepPts[5] = postPts.z();
      trajectory.push_back(stepPts);
 
      if(GFDEBUG_TRK) {
    G4cout << "                       ("
           << stepPts[0] << ", "
           << stepPts[1] << ", "
           << stepPts[2] << ") - (" 
           << stepPts[3] << ", "
           << stepPts[4] << ", "
           << stepPts[5] << ")" << G4endl;
      }
    }
 
    const G4VisAttributes * att = polyline.GetVisAttributes();
    G4Color color = att->GetColor();
    unsigned char trkcolor[3];
    trkcolor[0] = (unsigned char)(color.GetRed()*255);
    trkcolor[1] = (unsigned char)(color.GetGreen()*255);
    trkcolor[2] = (unsigned char)(color.GetBlue()*255);
    if(GFDEBUG_TRK) {
      G4cout << "              color  : ["
         << color.GetRed() << ", "
         << color.GetGreen() << ", "
         << color.GetBlue() << "]" << G4endl;
    }
 
    kgMocrenIO->addTrack(trajectory, trkcolor);
 
    numTrajectories++;
  }
 
} // G4GMocrenFileSceneHandler::AddPrimitive (polyline)

AddPrimitive() [8/12]

void G4VSceneHandler::AddPrimitive ( const G4Polymarker &  polymarker )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 191 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 (std::size_t iPoint = 0; iPoint < polymarker.size (); ++iPoint) {
        dot.SetPosition (polymarker[iPoint]);
        AddPrimitive (dot);
      }
    }
      break;
    case G4Polymarker::circles:
    {
      G4Circle circle (polymarker);  // Default circle
      for (std::size_t iPoint = 0; iPoint < polymarker.size (); ++iPoint) {
        circle.SetPosition (polymarker[iPoint]);
        AddPrimitive (circle);
      }
    }
      break;
    case G4Polymarker::squares:
    {
      G4Square square (polymarker);  // Default square
      for (std::size_t iPoint = 0; iPoint < polymarker.size (); ++iPoint) {
        square.SetPosition (polymarker[iPoint]);
        AddPrimitive (square);
      }
    }
      break;
  }
}

AddPrimitive() [9/12]

void G4GMocrenFileSceneHandler::AddPrimitive ( const G4Square &  mark_square )

virtual

Implements G4VSceneHandler.

Definition at line 691 of file G4GMocrenFileSceneHandler.cc.

{
  // to avoid a warning in the compile process
  G4Square dummysquare = mark_square;
 
  if (fProcessing2D) {
    static G4bool warned = false;
    if (!warned) {
      warned = true;
      G4Exception
    ("G4GMocrenFileSceneHandler::AddPrimitive (const G4Square&)",
     "gMocren1004", JustWarning,
     "2D squares not implemented.  Ignored.");
    }
    return;
  }
 
  //----- 
  if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
    G4cout << "***** AddPrimitive( G4Square )" << G4endl;
 
  //----- Initialize if necessary
  GFBeginModeling();
 
} // G4GMocrenFileSceneHandler::AddPrimitive ( mark_square )

AddPrimitive() [10/12]

virtual void G4VSceneHandler::AddPrimitive ( const G4Square &  )

virtual

Implements G4VSceneHandler.

AddPrimitive() [11/12]

void G4GMocrenFileSceneHandler::AddPrimitive ( const G4Text &  text )

virtual

Implements G4VSceneHandler.

Definition at line 634 of file G4GMocrenFileSceneHandler.cc.

{
  if (fProcessing2D) {
    static G4bool warned = false;
    if (!warned) {
      warned = true;
      G4Exception
    ("G4GMocrenFileSceneHandler::AddPrimitive (const G4Text&)",
     "gMocren1002", JustWarning,
     "2D text not implemented.  Ignored.");
    }
    return;
  }
 
  // to avoid a warning in the compile process
  G4Text dummytext = text;
 
  //----- 
  if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
    G4cout << "***** AddPrimitive( G4Text )" << G4endl;
 
  //----- Initialize IF NECESSARY
  GFBeginModeling();
 
} // G4GMocrenFileSceneHandler::AddPrimitive ( text )

AddPrimitive() [12/12]

virtual void G4VSceneHandler::AddPrimitive ( const G4Text &  )

virtual

Implements G4VSceneHandler.

AddSolid() [1/23]

void G4VSceneHandler::AddSolid ( const G4Box &  box )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 99 of file G4VSceneHandler.cc.

                                                {
  AddSolidT (box);
  // If your graphics system is sophisticated enough to handle a
  //  particular solid shape as a primitive, in your derived class write a
  //  function to override this.
  // Your function might look like this...
  // void G4MySceneHandler::AddSolid (const G4Box& box) {
  // Get and check applicable vis attributes.
  //   fpVisAttribs = fpViewer->GetApplicableVisAttributes(fpVisAttribs);
  // Do not draw if not visible.
  //   if (fpVisAttribs->IsVisible()) {
  //   Get parameters of appropriate object, e.g.:
  //     G4double dx = box.GetXHalfLength ();
  //     G4double dy = box.GetYHalfLength ();
  //     G4double dz = box.GetZHalfLength ();
  //     ...
  //     and Draw or Store in your display List.
}

AddSolid() [2/23]

void G4GMocrenFileSceneHandler::AddSolid ( const G4Box &  box )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 838 of file G4GMocrenFileSceneHandler.cc.

{
  if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
    G4cout << "***** AddSolid ( box )" << G4endl;
  
  if(GFDEBUG_DET > 0)
    G4cout << "G4GMocrenFileSceneHandler::AddSolid(const G4Box&)  : "
       << box.GetName() << G4endl;
  
  //----- skip drawing invisible primitive
  if( !IsVisible() ) { return ; }
  
  //----- Initialize if necessary
  GFBeginModeling();
  
  
  //--
  if(GFDEBUG_DET > 1) {
    G4cout << "-------" << G4endl;
    G4cout << "    " << box.GetName() << G4endl;
    G4Polyhedron * poly = box.CreatePolyhedron();
    poly->Transform(fObjectTransformation);
    //G4int nv = poly->GetNoVertices();
    G4Point3D v1, v2;
    G4int next;
    //while(1) { // next flag isn't functional.
    for(G4int i = 0; i < 12; i++) { // # of edges is 12.
      poly->GetNextEdge(v1, v2, next);
      if(next == 0) break;
      G4cout << "    (" << v1.x() << ", "
         << v1.y() << ", "
         << v1.z() << ") - ("
         << v2.x() << ", "
         << v2.y() << ", "
         << v2.z() << ") [" << next << "]"
         << G4endl;
    }
    delete poly;
  }
  
  
  // the volume name set by /vis/gMocren/setVolumeName
  G4String volName = kMessenger.getVolumeName();
  
  
  if(kFlagParameterization != 2) {
    G4ScoringManager * pScrMan = G4ScoringManager::GetScoringManager();
    if(pScrMan) {
      G4ScoringBox * pScBox = dynamic_cast<G4ScoringBox*>(pScrMan->FindMesh(volName));
      G4bool bMesh = false;
      if(pScBox != NULL) bMesh = true;
      if(bMesh) kFlagParameterization = 2;
      if(GFDEBUG_DET > 0) G4cout << "   G4ScoringManager::FindMesh() : "
        << volName << " - " << bMesh << G4endl;
    }
  }
  
  const G4VModel* pv_model  = GetModel();
  if (!pv_model) { return ; }
  G4PhysicalVolumeModel* pPVModel =
  dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
  if (!pPVModel) { return ; }
 
  
  //-- debug information
  if(GFDEBUG_DET > 0) {
    G4Material * mat = pPVModel->GetCurrentMaterial();
    G4String name = mat->GetName();
    G4double dens = mat->GetDensity()/(g/cm3);
    G4int copyNo = pPVModel->GetCurrentPV()->GetCopyNo();
    G4int depth = pPVModel->GetCurrentDepth();
    G4cout << "    copy no.: " << copyNo << G4endl;
    G4cout << "    depth   : " << depth << G4endl;
    G4cout << "    density : " << dens << " [g/cm3]" << G4endl;
    G4cout << "    location: " << pPVModel->GetCurrentPV()->GetObjectTranslation() << G4endl;
    G4cout << "    Multiplicity        : " << pPVModel->GetCurrentPV()->GetMultiplicity() << G4endl;
    G4cout << "    Is replicated?      : " << pPVModel->GetCurrentPV()->IsReplicated() << G4endl;
    G4cout << "    Is parameterised?   : " << pPVModel->GetCurrentPV()->IsParameterised() << G4endl;
    G4cout << "    top phys. vol. name : " << pPVModel->GetTopPhysicalVolume()->GetName() << G4endl;
  }
  
  //-- check the parameterised volume
  if(box.GetName() == volName) {
    
    kVolumeTrans3D = fObjectTransformation;
    // coordination system correction for gMocren
    G4ThreeVector raxis(1., 0., 0.), dummy(0.,0.,0.);
    G4RotationMatrix rot(raxis, pi*rad);
    G4Transform3D trot(rot, dummy);
    if(GFDEBUG_DET) {
      G4ThreeVector trans1 = kVolumeTrans3D.getTranslation();
      G4RotationMatrix rot1 = kVolumeTrans3D.getRotation().inverse();
      G4cout << "kVolumeTrans3D: " << trans1 << G4endl << rot1 << G4endl;
    }
    kVolumeTrans3D = kVolumeTrans3D*trot;
    if(GFDEBUG_DET) G4cout << " Parameterised volume : " << box.GetName() << G4endl;
    
    
    
    //
    G4VPhysicalVolume * pv[3] = {0,0,0};
    pv[0] = pPVModel->GetCurrentPV()->GetLogicalVolume()->GetDaughter(0);
    if(!pv[0]) {
      G4Exception("G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )",
                  "gMocren0003", FatalException, "Unexpected volume.");
    }
    G4int dirAxis[3] = {-1,-1,-1};
    G4int nDaughters[3] = {0,0,0};
    
    EAxis axis; G4int nReplicas; G4double width; G4double offset; G4bool consuming;
    pv[0]->GetReplicationData(axis, nReplicas, width, offset, consuming);
    nDaughters[0] = nReplicas;
    switch(axis) {
      case kXAxis: dirAxis[0] = 0; break;
      case kYAxis: dirAxis[0] = 1; break;
      case kZAxis: dirAxis[0] = 2; break;
      default:
        G4Exception("G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )",
                    "gMocren0004", FatalException, "Error.");
    }
    kNestedVolumeNames.push_back(pv[0]->GetName());
    if(GFDEBUG_DET)
      G4cout << "        daughter name :  " << pv[0]->GetName()
         << "   # : " << nDaughters[0] << G4endl;
    
    //
    if(GFDEBUG_DET) {
      if(pv[0]->GetLogicalVolume()->GetNoDaughters()) {
        G4cout << "# of daughters : "
           << pv[0]->GetLogicalVolume()->GetNoDaughters() << G4endl;
      } else {
        //G4Exception("G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )",
        //      "gMocren0005", FatalException, "Error.");
      }
    }
    
    // check whether nested or regular parameterization
    if(GFDEBUG_DET) G4cout << "# of daughters : "
               << pv[0]->GetLogicalVolume()->GetNoDaughters() << G4endl;
    if(pv[0]->GetLogicalVolume()->GetNoDaughters() == 0) {
      kFlagParameterization = 1;
      //G4Exception("G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )",
      //        "gMocren0006", FatalException, "Error.");
    }
    
    if(kFlagParameterization == 0) {
      
      pv[1] = pv[0]->GetLogicalVolume()->GetDaughter(0);
      if(pv[1]) {
        pv[1]->GetReplicationData(axis, nReplicas, width, offset, consuming);
        nDaughters[1] = nReplicas;
        switch(axis) {
          case kXAxis: dirAxis[1] = 0; break;
          case kYAxis: dirAxis[1] = 1; break;
          case kZAxis: dirAxis[1] = 2; break;
          default:
            G4Exception("G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )",
                        "gMocren0007", FatalException, "Error.");
        }
        kNestedVolumeNames.push_back(pv[1]->GetName());
        if(GFDEBUG_DET)
          G4cout << "        sub-daughter name :  " << pv[1]->GetName()
          << "   # : " << nDaughters[1]<< G4endl;
        
        //
        pv[2] = pv[1]->GetLogicalVolume()->GetDaughter(0);
        if(pv[2]) {
          nDaughters[2] = pv[2]->GetMultiplicity();
          kNestedVolumeNames.push_back(pv[2]->GetName());
          if(GFDEBUG_DET)
            G4cout << "        sub-sub-daughter name :  " << pv[2]->GetName()
            << "   # : " << nDaughters[2] << G4endl;
          
          if(nDaughters[2] > 1) {
            G4VNestedParameterisation * nestPara
            = dynamic_cast<G4VNestedParameterisation*>(pv[2]->GetParameterisation());
            if(nestPara == NULL)
              G4Exception("G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )",
                          "gMocren0008", FatalException, "Non-nested parameterisation");
            
            nestPara->ComputeTransformation(0, pv[2]);
            G4ThreeVector trans0 = pv[2]->GetObjectTranslation();
            nestPara->ComputeTransformation(1, pv[2]);
            G4ThreeVector trans1 = pv[2]->GetObjectTranslation();
            G4ThreeVector diff(trans0 - trans1);
            if(GFDEBUG_DET)
              G4cout << trans0 << " - " << trans1 << " - " << diff << G4endl;
            
            if(diff.x() != 0.) dirAxis[2] = 0;
            else if(diff.y() != 0.) dirAxis[2] = 1;
            else if(diff.z() != 0.) dirAxis[2] = 2;
            else
              G4Exception("G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )",
                          "gMocren0009", FatalException, "Unexpected nested parameterisation");
          }
        }
      }
      
      for(G4int i = 0; i < 3; i++) {
        kNestedVolumeDimension[i] = nDaughters[i];
        //kNestedVolumeDimension[i] = nDaughters[dirAxis[i]];
        kNestedVolumeDirAxis[i] = dirAxis[i];
      }
      //G4cout << "@@@@@@@@@ "
      //       << dirAxis[0] << ", " << dirAxis[1] << ", " << dirAxis[2] << G4endl;
      
      // get densities
      G4VNestedParameterisation * nestPara
      = dynamic_cast<G4VNestedParameterisation*>(pv[2]->GetParameterisation());
      if(nestPara != NULL) {
        G4double prexyz[3] = {0.,0.,0.}, xyz[3] = {0.,0.,0.};
        for(G4int n0 = 0; n0 < nDaughters[0]; n0++) {
          for(G4int n1 = 0; n1 < nDaughters[1]; n1++) {
            for(G4int n2 = 0; n2 < nDaughters[2]; n2++) {
              
              G4GMocrenTouchable * touch = new G4GMocrenTouchable(n1, n0);
              if(GFDEBUG_DET)
                G4cout << "   retrieve volume : copy # : " << n0
                << ", " << n1 << ", " << n2 << G4endl;
              G4Material * mat = nestPara->ComputeMaterial(pv[2], n2, touch);
              delete touch;
              G4double dens = mat->GetDensity()/(g/cm3);
              
              if(GFDEBUG_DET)
                G4cout << "           density :" << dens << " [g/cm3]" << G4endl;
              
              G4Box tbox(box);
              nestPara->ComputeDimensions(tbox, n2, pv[2]);
              xyz[0] = tbox.GetXHalfLength()/mm;
              xyz[1] = tbox.GetYHalfLength()/mm;
              xyz[2] = tbox.GetZHalfLength()/mm;
              if(n0 != 0 || n1 != 0 || n2 != 0) {
                for(G4int i = 0; i < 3; i++) {
                  if(xyz[i] != prexyz[i])
                    G4Exception("G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )",
                                "gMocren0010", FatalException, "Unsupported parameterisation");
                }
              }
              if(GFDEBUG_DET)
                G4cout << "              size : " << tbox.GetXHalfLength()/mm << " x "
                << tbox.GetYHalfLength()/mm << " x "
                << tbox.GetZHalfLength()/mm << " [mm3]" << G4endl;
              
              G4int idx[3];
              idx[dirAxis[0]] = n0;
              idx[dirAxis[1]] = n1;
              idx[dirAxis[2]] = n2;
              Index3D i3d(idx[0],idx[1],idx[2]);
              kNestedModality[i3d] = dens;
              if(GFDEBUG_DET)
                G4cout << " index: " << idx[0] << ", " << idx[1] << ", " << idx[2]
                << "  density: " << dens << G4endl;
              
              for(G4int i = 0; i < 3; i++) prexyz[i] = xyz[i];
            }
          }
        }
        
        kVolumeSize.set(box.GetXHalfLength()*2/mm,
                        box.GetYHalfLength()*2/mm,
                        box.GetZHalfLength()*2/mm);
        // mesh size
        if(!kbSetModalityVoxelSize) {
          G4float spacing[3] = {static_cast<G4float>(2*xyz[0]),
            static_cast<G4float>(2*xyz[1]),
            static_cast<G4float>(2*xyz[2])};
          kgMocrenIO->setVoxelSpacing(spacing);
          kVoxelDimension.set(spacing[0], spacing[1], spacing[2]);
          kbSetModalityVoxelSize = true;
        }
        
      } else {
        if(GFDEBUG_DET)
          G4cout << pv[2]->GetName() << G4endl;
        G4Exception("G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )",
                    "gMocren0011", FatalException, "Non-nested parameterisation");
      }
      
      
      
      //-- debug
      if(GFDEBUG_DET > 1) {
        if(pPVModel->GetCurrentPV()->IsParameterised()) {
          G4VPVParameterisation * para = pPVModel->GetCurrentPV()->GetParameterisation();
          G4cout << " Is nested parameterisation? : " << para->IsNested() << G4endl;
          
          
          G4int npvp = pPVModel->GetDrawnPVPath().size();
          G4cout << "     physical volume node id : "
          << "size: " << npvp << ", PV name: ";
          for(G4int i = 0; i < npvp; i++) {
            G4cout << pPVModel->GetDrawnPVPath()[i].GetPhysicalVolume()->GetName()
            << " [param:"
            << pPVModel->GetDrawnPVPath()[i].GetPhysicalVolume()->IsParameterised()
            << ",rep:"
            << pPVModel->GetDrawnPVPath()[i].GetPhysicalVolume()->IsReplicated();
            if(pPVModel->GetDrawnPVPath()[i].GetPhysicalVolume()->GetParameterisation()) {
              G4cout << ",nest:"
              << pPVModel->GetDrawnPVPath()[i].GetPhysicalVolume()->GetParameterisation()->IsNested();
            }
            G4cout << ",copyno:"
            << pPVModel->GetDrawnPVPath()[i].GetPhysicalVolume()->GetCopyNo();
            G4cout << "] - ";
          }
          G4cout << G4endl;
          
          
          pPVModel->GetCurrentPV()->GetReplicationData(axis, nReplicas, width, offset, consuming);
          G4cout << "     # replicas : " << nReplicas << G4endl;
          G4double pareDims[3] = {0.,0.,0.};
          G4Box * pbox = dynamic_cast<G4Box *>(pPVModel->GetDrawnPVPath()[npvp-2].GetPhysicalVolume()->GetLogicalVolume()->GetSolid());
          if(pbox) {
            pareDims[0] = 2.*pbox->GetXHalfLength()*mm;
            pareDims[1] = 2.*pbox->GetYHalfLength()*mm;
            pareDims[2] = 2.*pbox->GetZHalfLength()*mm;
            G4cout << "     mother size ["
            << pPVModel->GetDrawnPVPath()[npvp-2].GetPhysicalVolume()->GetName()
            << "] : "
            << pareDims[0] << " x "
            << pareDims[1] << " x "
            << pareDims[2] << " [mm3]"
            << G4endl;
          }
          G4double paraDims[3];
          G4Box * boxP = dynamic_cast<G4Box *>(pPVModel->GetDrawnPVPath()[npvp-1].GetPhysicalVolume()->GetLogicalVolume()->GetSolid());
          if(boxP) {
            paraDims[0] = 2.*boxP->GetXHalfLength()*mm;
            paraDims[1] = 2.*boxP->GetYHalfLength()*mm;
            paraDims[2] = 2.*boxP->GetZHalfLength()*mm;
            G4cout << "     parameterised volume? ["
            << pPVModel->GetDrawnPVPath()[npvp-1].GetPhysicalVolume()->GetName()
            << "] : "
            << paraDims[0] << " x "
            << paraDims[1] << " x "
            << paraDims[2] << " [mm3]  : "
            << G4int(pareDims[0]/paraDims[0]) << " x "
            << G4int(pareDims[1]/paraDims[1]) << " x "
            << G4int(pareDims[2]/paraDims[2]) << G4endl;
          } else {
            G4cout << pPVModel->GetDrawnPVPath()[npvp-2].GetPhysicalVolume()->GetName()
            << " isn't a G4Box." << G4endl;
          }
        }
      }
      
      
    } else if(kFlagParameterization == 1) { // G4PhantomParameterisation based geom. construnction
      
      // get the dimension of the parameterized patient geometry
      G4PhantomParameterisation * phantomPara
      = dynamic_cast<G4PhantomParameterisation*>(pv[0]->GetParameterisation());
      if(phantomPara == NULL) {
        G4Exception("G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )",
                    "gMocren0012", FatalException, "no G4PhantomParameterisation");
      } else {
        ;
      }
      
      kNestedVolumeDimension[0] = (G4int)phantomPara->GetNoVoxelsX();
      kNestedVolumeDimension[1] = (G4int)phantomPara->GetNoVoxelsY();
      kNestedVolumeDimension[2] = (G4int)phantomPara->GetNoVoxelsZ();
      kNestedVolumeDirAxis[0] = 0;
      kNestedVolumeDirAxis[1] = 1;
      kNestedVolumeDirAxis[2] = 2;
      
      // get densities of the parameterized patient geometry
      G4int nX = kNestedVolumeDimension[0];
      G4int nXY = kNestedVolumeDimension[0]*kNestedVolumeDimension[1];
      
      for(G4int n0 = 0; n0 < kNestedVolumeDimension[0]; n0++) {
        for(G4int n1 = 0; n1 < kNestedVolumeDimension[1]; n1++) {
          for(G4int n2 = 0; n2 < kNestedVolumeDimension[2]; n2++) {
            
            G4int repNo = n0 + n1*nX + n2*nXY;
            G4Material * mat = phantomPara->ComputeMaterial(repNo, pv[0]);
            G4double dens = mat->GetDensity()/(g/cm3);
            
            
            G4int idx[3];
            idx[kNestedVolumeDirAxis[0]] = n0;
            idx[kNestedVolumeDirAxis[1]] = n1;
            idx[kNestedVolumeDirAxis[2]] = n2;
            Index3D i3d(idx[0],idx[1],idx[2]);
            kNestedModality[i3d] = dens;
            
            if(GFDEBUG_DET)
              G4cout << " index: " << idx[0] << ", " << idx[1] << ", " << idx[2]
              << "  density: " << dens << G4endl;
            
          }
        }
      }
      
      kVolumeSize.set(box.GetXHalfLength()*2/mm,
                      box.GetYHalfLength()*2/mm,
                      box.GetZHalfLength()*2/mm);
      
      // mesh size
      if(!kbSetModalityVoxelSize) {
        G4float spacing[3] = {static_cast<G4float>(2*phantomPara->GetVoxelHalfX()),
          static_cast<G4float>(2*phantomPara->GetVoxelHalfY()),
          static_cast<G4float>(2*phantomPara->GetVoxelHalfZ())};
        kgMocrenIO->setVoxelSpacing(spacing);
        kVoxelDimension.set(spacing[0], spacing[1], spacing[2]);
        kbSetModalityVoxelSize = true;
      }
    }
    
  } // if(box.GetName() == volName)
  
  
  // processing geometry construction based on the interactive PS
  if(!kFlagProcessedInteractiveScorer) {
    
    
    // get the dimension of the geometry defined in G4VScoringMesh
    G4ScoringManager * pScrMan = G4ScoringManager::GetScoringManager();
    //if(!pScrMan) return;
    if(pScrMan) {
    G4ScoringBox * scoringBox
    = dynamic_cast<G4ScoringBox*>(pScrMan->FindMesh(volName));
    //if(scoringBox == NULL) return;
    if(scoringBox) {
 
    
    
    G4int nVoxels[3];
    scoringBox->GetNumberOfSegments(nVoxels);
    // this order depends on the G4ScoringBox
    kNestedVolumeDimension[0] = nVoxels[2];
    kNestedVolumeDimension[1] = nVoxels[1];
    kNestedVolumeDimension[2] = nVoxels[0];
    kNestedVolumeDirAxis[0] = 2;
    kNestedVolumeDirAxis[1] = 1;
    kNestedVolumeDirAxis[2] = 0;
    
    // get densities of the parameterized patient geometry
    for(G4int n0 = 0; n0 < kNestedVolumeDimension[0]; n0++) {
      for(G4int n1 = 0; n1 < kNestedVolumeDimension[1]; n1++) {
        for(G4int n2 = 0; n2 < kNestedVolumeDimension[2]; n2++) {
          
          G4double dens = 0.*(g/cm3);
          
          G4int idx[3];
          idx[kNestedVolumeDirAxis[0]] = n0;
          idx[kNestedVolumeDirAxis[1]] = n1;
          idx[kNestedVolumeDirAxis[2]] = n2;
          Index3D i3d(idx[0],idx[1],idx[2]);
          kNestedModality[i3d] = dens;
          
        }
      }
    }
    
    G4ThreeVector boxSize = scoringBox->GetSize();
    if(GFDEBUG_DET > 1) {
      G4cout << "Interactive Scorer : size - "
         << boxSize.x()/cm << " x "
         << boxSize.y()/cm << " x "
         << boxSize.z()/cm << " [cm3]" << G4endl;
      G4cout << "Interactive Scorer : # voxels - "
         << nVoxels[0] << " x "
         << nVoxels[1] << " x "
         << nVoxels[2] << G4endl;
    }
    kVolumeSize.set(boxSize.x()*2,
                    boxSize.y()*2,
                    boxSize.z()*2);
    
    // mesh size
    if(!kbSetModalityVoxelSize) {
      G4float spacing[3] = {static_cast<G4float>(boxSize.x()*2/nVoxels[0]),
        static_cast<G4float>(boxSize.y()*2/nVoxels[1]),
        static_cast<G4float>(boxSize.z()*2/nVoxels[2])};
      
      kgMocrenIO->setVoxelSpacing(spacing);
      kVoxelDimension.set(spacing[0], spacing[1], spacing[2]);
      kbSetModalityVoxelSize = true;
      
    }
    
    
    kVolumeTrans3D = fObjectTransformation;
    
    // translation for the scoring mesh
    G4ThreeVector sbth = scoringBox->GetTranslation();
    G4Translate3D sbtranslate(sbth);
    kVolumeTrans3D = kVolumeTrans3D*sbtranslate;
    
    // rotation matrix for the scoring mesh 
    G4RotationMatrix sbrm;
    sbrm = scoringBox->GetRotationMatrix();
    if(!sbrm.isIdentity()) {
      G4ThreeVector sbdummy(0.,0.,0.); 
      G4Transform3D sbrotate(sbrm.inverse(), sbdummy);
      kVolumeTrans3D = kVolumeTrans3D*sbrotate;
    }
    
    
    // coordination system correction for gMocren
    G4ThreeVector raxisY(0., 1., 0.), dummyY(0.,0.,0.); 
    G4RotationMatrix rotY(raxisY, pi*rad);
    G4Transform3D trotY(rotY, dummyY);
    G4ThreeVector raxisZ(0., 0., 1.), dummyZ(0.,0.,0.); 
    G4RotationMatrix rotZ(raxisZ, pi*rad);
    G4Transform3D trotZ(rotZ, dummyZ);
    
    kVolumeTrans3D = kVolumeTrans3D*trotY*trotZ;
    
    }
    }
    //
    kFlagProcessedInteractiveScorer = true;
  }
  
  
  static G4VPhysicalVolume * volPV = NULL;
  if(pPVModel->GetCurrentPV()->GetName() == volName) {
    volPV = pPVModel->GetCurrentPV();
  }
  
  //-- add detectors
  G4bool bAddDet = true;
  if(!kMessenger.getDrawVolumeGrid()) {
 
    if(kFlagParameterization == 0) { // nested parameterisation
      /*
      G4String volDSolidName;
      if(volPV) {
        G4int nDaughter = volPV->GetLogicalVolume()->GetNoDaughters();
        G4VPhysicalVolume * volDPV = NULL;
        if(nDaughter > 0) volDPV = volPV->GetLogicalVolume()->GetDaughter(0);
        if(volDPV) {
          nDaughter = volDPV->GetLogicalVolume()->GetNoDaughters();
          if(nDaughter > 0)
            volDSolidName = volDPV->GetLogicalVolume()->GetDaughter(0)
                           ->GetLogicalVolume()->GetSolid()->GetName();
        }
      }
      */
      
      //std::cout << "Parameterization volume: " << volName << " - "
      //          << box.GetName() << std::endl;
      
      if(volName == box.GetName()) {
        bAddDet = false;
      }
      
      std::vector<G4String>::iterator itr = kNestedVolumeNames.begin();
      for(; itr != kNestedVolumeNames.end(); itr++) {
        if(*itr == box.GetName())  {
          bAddDet = false;
          break;
        }
      }
    } else if(kFlagParameterization == 1) { // phantom paramemterisation
      
      G4String volDSolidName;
      if(volPV) {
        volDSolidName = volPV->GetLogicalVolume()->GetDaughter(0)
                        ->GetLogicalVolume()->GetSolid()->GetName();
      }
 
      //std::cout << "Phantom Parameterization volume: " << volDSolidName
      //          << " - " << box.GetName() << std::endl;
      
      if(volDSolidName == box.GetName()) {
        bAddDet = false;
      }
      
    } else if(kFlagParameterization == 2) { // interactive primitive scorer
      //std::cout << "Regular Parameterization volume: " << box.GetName() << std::endl;
    }
    
  }
  if(bAddDet) AddDetector(box);
  
 
} // void G4GMocrenFileSceneHandler::AddSolid( const G4Box& box )

AddSolid() [3/23]

void G4VSceneHandler::AddSolid ( const G4Cons &  cons )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 100 of file G4VSceneHandler.cc.

                                                  {
  AddSolidT (cons);
}

AddSolid() [4/23]

void G4GMocrenFileSceneHandler::AddSolid ( const G4Cons &  cons )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1464 of file G4GMocrenFileSceneHandler.cc.

{
  if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
    G4cout << "***** AddSolid ( cons )" << G4endl;
 
  //----- skip drawing invisible primitive
  if( !IsVisible() ) { return ; }
 
  //----- Initialize if necessary
  GFBeginModeling();
 
  //
  AddDetector(cons);
 
}// G4GMocrenFileSceneHandler::AddSolid( cons )

AddSolid() [5/23]

void G4VSceneHandler::AddSolid ( const G4Ellipsoid &  ellipsoid )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 110 of file G4VSceneHandler.cc.

                                                            {
  AddSolidWithAuxiliaryEdges (ellipsoid);
}

AddSolid() [6/23]

void G4VSceneHandler::AddSolid ( const G4Orb &  orb )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 101 of file G4VSceneHandler.cc.

                                                {
  AddSolidWithAuxiliaryEdges (orb);
}

AddSolid() [7/23]

void G4VSceneHandler::AddSolid ( const G4Para &  para )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 102 of file G4VSceneHandler.cc.

                                                  {
  AddSolidT (para);
}

AddSolid() [8/23]

void G4GMocrenFileSceneHandler::AddSolid ( const G4Para &  para )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1519 of file G4GMocrenFileSceneHandler.cc.

{
  if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
    G4cout << "***** AddSolid ( para )" << G4endl;
 
  //----- skip drawing invisible primitive
  if( !IsVisible() ) { return ; }
 
  //----- Initialize if necessary
  GFBeginModeling();
 
  //
  AddDetector(para);
 
} // G4GMocrenFileSceneHandler::AddSolid ( para )

AddSolid() [9/23]

void G4VSceneHandler::AddSolid ( const G4Polycone &  polycone )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 111 of file G4VSceneHandler.cc.

                                                          {
  AddSolidT (polycone);
}

AddSolid() [10/23]

void G4VSceneHandler::AddSolid ( const G4Polyhedra &  polyhedra )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 112 of file G4VSceneHandler.cc.

                                                            {
  AddSolidT (polyhedra);
}

AddSolid() [11/23]

void G4VSceneHandler::AddSolid ( const G4Sphere &  sphere )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 103 of file G4VSceneHandler.cc.

                                                      {
  AddSolidWithAuxiliaryEdges (sphere);
}

AddSolid() [12/23]

void G4GMocrenFileSceneHandler::AddSolid ( const G4Sphere &  sphere )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1501 of file G4GMocrenFileSceneHandler.cc.

{
  if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
    G4cout << "***** AddSolid ( sphere )" << G4endl;
 
  //----- skip drawing invisible primitive
  if( !IsVisible() ) { return ; }
 
  //----- Initialize if necessary
  GFBeginModeling();
 
  //
  AddDetector(sphere);
 
} // G4GMocrenFileSceneHandler::AddSolid ( sphere )

AddSolid() [13/23]

void G4VSceneHandler::AddSolid ( const G4TessellatedSolid &  tess )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 113 of file G4VSceneHandler.cc.

                                                              {
  AddSolidT (tess);
}

AddSolid() [14/23]

void G4VSceneHandler::AddSolid ( const G4Torus &  torus )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 104 of file G4VSceneHandler.cc.

                                                    {
  AddSolidWithAuxiliaryEdges (torus);
}

AddSolid() [15/23]

void G4GMocrenFileSceneHandler::AddSolid ( const G4Torus &  torus )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1556 of file G4GMocrenFileSceneHandler.cc.

{
  if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
    G4cout << "***** AddSolid ( torus )" << G4endl;
 
  //----- skip drawing invisible primitive
  if( !IsVisible() ) { return ; }
 
  //----- Initialize if necessary
  GFBeginModeling();
 
  //
  AddDetector(torus);
 
} // void G4GMocrenFileSceneHandler::AddSolid( const G4Torus& )

AddSolid() [16/23]

void G4VSceneHandler::AddSolid ( const G4Trap &  trap )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 105 of file G4VSceneHandler.cc.

                                                  {
  AddSolidT (trap);
}

AddSolid() [17/23]

void G4GMocrenFileSceneHandler::AddSolid ( const G4Trap &  trap )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1537 of file G4GMocrenFileSceneHandler.cc.

{
  if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
    G4cout << "***** AddSolid ( trap )" << G4endl;
 
  //----- skip drawing invisible primitive
  if( !IsVisible() ) { return ; }
 
  //----- Initialize if necessary
  GFBeginModeling();
 
  //
  AddDetector(trap);
 
} // G4GMocrenFileSceneHandler::AddSolid (const G4Trap& trap)

AddSolid() [18/23]

void G4VSceneHandler::AddSolid ( const G4Trd &  trd )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 106 of file G4VSceneHandler.cc.

                                                {
  AddSolidT (trd);
}

AddSolid() [19/23]

void G4GMocrenFileSceneHandler::AddSolid ( const G4Trd &  trd )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1482 of file G4GMocrenFileSceneHandler.cc.

{
  if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
    G4cout << "***** AddSolid ( trd )" << G4endl;
 
 
  //----- skip drawing invisible primitive
  if( !IsVisible() ) { return ; }
 
  //----- Initialize if necessary
  GFBeginModeling();
 
  //
  AddDetector(trd);
 
} // G4GMocrenFileSceneHandler::AddSolid ( trd )

AddSolid() [20/23]

void G4VSceneHandler::AddSolid ( const G4Tubs &  tubs )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 107 of file G4VSceneHandler.cc.

                                                  {
  AddSolidT (tubs);
}

AddSolid() [21/23]

void G4GMocrenFileSceneHandler::AddSolid ( const G4Tubs &  tubs )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1421 of file G4GMocrenFileSceneHandler.cc.

{
  if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
    G4cout << "***** AddSolid ( tubes )" << G4endl;
 
  //----- skip drawing invisible primitive
  if( !IsVisible() ) { return ; }
 
  //----- Initialize if necessary
  GFBeginModeling();
 
  //
  AddDetector(tubes);
 
 
  // for a debug
  if(GFDEBUG_DET > 0) {
    G4cout << "-------" << G4endl;
    G4cout << "    " << tubes.GetName() << G4endl;
    G4Polyhedron * poly = tubes.CreatePolyhedron();
    G4int nv = poly->GetNoVertices();
    for(G4int i = 0; i < nv; i++) {
      G4cout << "    (" << poly->GetVertex(i).x() << ", "
         << poly->GetVertex(i).y() << ", "
         << poly->GetVertex(i).z() << ")" << G4endl;
    }
    delete poly;
  }
 
  const G4VModel* pv_model  = GetModel();
  if (!pv_model) { return ; } 
  G4PhysicalVolumeModel* pPVModel =
    dynamic_cast<G4PhysicalVolumeModel*>(fpModel);
  if (!pPVModel) { return ; }
  G4Material * mat = pPVModel->GetCurrentMaterial();
  G4String name = mat->GetName();
 
} // void G4GMocrenFileSceneHandler::AddSolid( const G4Tubs& )

AddSolid() [22/23]

void G4VSceneHandler::AddSolid ( const G4VSolid &  solid )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 116 of file G4VSceneHandler.cc.

                                                     {
  AddSolidT (solid);
}

AddSolid() [23/23]

void G4GMocrenFileSceneHandler::AddSolid ( const G4VSolid &  solid )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1575 of file G4GMocrenFileSceneHandler.cc.

{
  //----- skip drawing invisible primitive
  if( !IsVisible() ) { return ; }
 
  //----- Initialize if necessary
  GFBeginModeling();
 
  //
  AddDetector(solid);
 
  //----- Send a primitive
  G4VSceneHandler::AddSolid( solid ) ; 
 
} //G4GMocrenFileSceneHandler::AddSolid ( const G4VSolid& ) 

BeginModeling()

virtual void G4GMocrenFileSceneHandler::BeginModeling ( )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 73 of file G4GMocrenFileSceneHandler.hh.

{ G4VSceneHandler::BeginModeling ();} 

BeginPrimitives()

void G4GMocrenFileSceneHandler::BeginPrimitives ( const G4Transform3D &  objectTransformation )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 813 of file G4GMocrenFileSceneHandler.cc.

{
  if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
    G4cout << "***** BeginPrimitives " << G4endl;
 
  GFBeginModeling();
 
  G4VSceneHandler::BeginPrimitives (objectTransformation);
 
}

BeginSavingGdd()

void G4GMocrenFileSceneHandler::BeginSavingGdd

(

void

)

Definition at line 280 of file G4GMocrenFileSceneHandler.cc.

{
  if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
      G4cout << "***** BeginSavingGdd (called)" << G4endl;
 
  if( !IsSavingGdd() ) {
 
    if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations) {
      G4cout << "*****                   (started) " ;
      G4cout << "(open g4.gdd, ##)"  << G4endl;
    }
 
    SetGddFileName() ; // result set to kGddFileName
    kFlagSaving_g4_gdd = true; 
 
 
    G4GMocrenFileCTtoDensityMap ctdens;
    short minmax[2];
    minmax[0] = ctdens.GetMinCT();
    minmax[1] = ctdens.GetMaxCT();
    kgMocrenIO->setModalityImageMinMax(minmax);
    std::vector<G4float> map;
    G4float dens;
    for(G4int i = minmax[0]; i <= minmax[1]; i++) {
      dens = ctdens.GetDensity(i);
      map.push_back(dens);
    }
    kgMocrenIO->setModalityImageDensityMap(map);
 
    /*
    G4String fname = "modality-map.dat";
    std::ifstream ifile(fname);
    if(ifile) {
      short minmax[2];
      ifile >> minmax[0] >> minmax[1];
      kgMocrenIO->setModalityImageMinMax(minmax);
      std::vector<G4float> map;
      G4float dens;
      for(G4int i = minmax[0]; i <= minmax[1]; i++) {
    ifile >> dens;
    map.push_back(dens);
      }
      kgMocrenIO->setModalityImageDensityMap(map);
      
    } else {
      G4cout << "cann't open the file : " << fname << G4endl;
    }
    */
 
    // mesh size
    //kMessenger.getNoVoxels(kModalitySize[0], kModalitySize[1], kModalitySize[2]);
    //kgMocrenIO->setModalityImageSize(kModalitySize);
    
    // initializations
    //kgMocrenIO->clearModalityImage();
    kgMocrenIO->clearDoseDistAll();
    kgMocrenIO->clearROIAll();
    kgMocrenIO->clearTracks();
    kgMocrenIO->clearDetector();
    std::vector<Detector>::iterator itr = kDetectors.begin();
    for(; itr != kDetectors.end(); itr++) {
      itr->clear();
    }
    kDetectors.clear();
    
    kNestedHitsList.clear();
    kNestedVolumeNames.clear();
      
  }
}

Referenced by GFBeginModeling().

ClearTransientStore()

void G4GMocrenFileSceneHandler::ClearTransientStore ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 1904 of file G4GMocrenFileSceneHandler.cc.

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

EndModeling()

virtual void G4GMocrenFileSceneHandler::EndModeling ( )

inlinevirtual

Reimplemented from G4VSceneHandler.

Definition at line 74 of file G4GMocrenFileSceneHandler.hh.

{ G4VSceneHandler::EndModeling   ();}

EndPrimitives()

void G4GMocrenFileSceneHandler::EndPrimitives ( )

virtual

Reimplemented from G4VSceneHandler.

Definition at line 826 of file G4GMocrenFileSceneHandler.cc.

{
  if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
    G4cout << "***** EndPrimitives " << G4endl;
 
  G4VSceneHandler::EndPrimitives ();
}

EndSavingGdd()

void G4GMocrenFileSceneHandler::EndSavingGdd

(

void

)

Definition at line 351 of file G4GMocrenFileSceneHandler.cc.

{
  if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
    G4cout << "***** EndSavingGdd (called)" << G4endl;
 
  if(IsSavingGdd()) {
    if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
      G4cout << "*****                 (started) (close "
         << kGddFileName << ")" << G4endl;
 
    if(kGddDest) kGddDest.close();
    kFlagSaving_g4_gdd = false; 
 
    std::map<Index3D, G4float>::iterator itr = kNestedModality.begin();
    G4int xmax=0, ymax=0, zmax=0;
    for(; itr != kNestedModality.end(); itr++) {
      if(itr->first.x > xmax) xmax = itr->first.x;
      if(itr->first.y > ymax) ymax = itr->first.y;
      if(itr->first.z > zmax) zmax = itr->first.z;
    }
    // mesh size
    kModalitySize[0] = xmax+1;
    kModalitySize[1] = ymax+1;
    kModalitySize[2] = zmax+1;
    kgMocrenIO->setModalityImageSize(kModalitySize);
    if(GFDEBUG) G4cout << "gMocren-file driver : modality size : "
               << kModalitySize[0] << " x "
               << kModalitySize[1] << " x "
               << kModalitySize[2] << G4endl;
 
    G4int nxy = kModalitySize[0]*kModalitySize[1];
    //std::map<G4int, G4float>::iterator itr;
    for(G4int z = 0; z < kModalitySize[2]; z++) {
      short * modality = new short[nxy];
      for(G4int y = 0; y < kModalitySize[1]; y++) {
    for(G4int x = 0; x < kModalitySize[0]; x++) {
      //for(G4int x = kModalitySize[0]-1; x >= 0 ; x--) {
      //G4int ixy = x + (kModalitySize[1]-y-1)*kModalitySize[0];
 
      G4int ixy = x + y*kModalitySize[0];
      Index3D idx(x,y,z);
      itr = kNestedModality.find(idx);
      if(itr != kNestedModality.end()) {
 
        modality[ixy] = kgMocrenIO->convertDensityToHU(itr->second);
      } else {
        modality[ixy] = -1024;
      }
 
    }
      }
      kgMocrenIO->setModalityImage(modality);
    }
 
    //-- dose
    size_t nhits = kNestedHitsList.size();
    if(GFDEBUG) G4cout << "gMocren-file driver : # hits = " << nhits << G4endl;
 
    std::map<Index3D, G4double>::iterator hitsItr;
    std::map<G4String, std::map<Index3D, G4double> >::iterator hitsListItr = kNestedHitsList.begin();
 
    for(G4int n = 0; hitsListItr != kNestedHitsList.end(); hitsListItr++, n++) {
 
      kgMocrenIO->newDoseDist();
      kgMocrenIO->setDoseDistName(hitsListItr->first, n);
      kgMocrenIO->setDoseDistSize(kModalitySize, n);
 
      G4double minmax[2] = {DBL_MAX, -DBL_MAX};
      for(G4int z = 0 ; z < kModalitySize[2]; z++) {
    G4double * values = new G4double[nxy];
    for(G4int y = 0; y < kModalitySize[1]; y++) {
      for(G4int x = 0; x < kModalitySize[0]; x++) {
 
        G4int ixy = x + y*kModalitySize[0];
        Index3D idx(x,y,z);
        hitsItr = hitsListItr->second.find(idx);
        if(hitsItr != hitsListItr->second.end()) {
 
          values[ixy] = hitsItr->second;
        } else {
          values[ixy] = 0.;
        }
        if(values[ixy] < minmax[0]) minmax[0] = values[ixy];
        if(values[ixy] > minmax[1]) minmax[1] = values[ixy];
      }
    }
    kgMocrenIO->setDoseDist(values, n);
      }
      kgMocrenIO->setDoseDistMinMax(minmax, n);
      G4double lower = 0.;
      if(minmax[0] < 0)  lower = minmax[0];
      G4double scale = (minmax[1]-lower)/25000.;
      kgMocrenIO->setDoseDistScale(scale, n);
      G4String sunit("unit?"); //temporarily
      kgMocrenIO->setDoseDistUnit(sunit, n);
    }
      
 
    //-- draw axes
    if(false) {//true,false
      G4ThreeVector trans;
      G4RotationMatrix rot;
      trans = kVolumeTrans3D.getTranslation();
      rot = kVolumeTrans3D.getRotation().inverse();
      // x
      std::vector<G4float *> tracks;
      unsigned char colors[3];
      G4float * trk = new G4float[6];
      tracks.push_back(trk);
 
      G4ThreeVector orig(0.,0.,0), xa(2000.,0.,0.), ya(0.,2000.,0.), za(0.,0.,2000.);
      orig -= trans;
      orig.transform(rot);
      xa -= trans;
      xa.transform(rot);
      ya -= trans;
      ya.transform(rot);
      za -= trans;
      za.transform(rot);
      for(G4int i = 0; i < 3; i++) trk[i] = orig[i];
      for(G4int i = 0; i < 3; i++) trk[i+3] = xa[i];
      colors[0] = 255; colors[1] = 0; colors[2] = 0;
      kgMocrenIO->addTrack(tracks, colors);
      // y
      for(G4int i = 0; i < 3; i++) trk[i+3] = ya[i];
      colors[0] = 0; colors[1] = 255; colors[2] = 0;
      kgMocrenIO->addTrack(tracks, colors);
      // z
      for(G4int i = 0; i < 3; i++) trk[i+3] = za[i];
      colors[0] = 0; colors[1] = 0; colors[2] = 255;
      kgMocrenIO->addTrack(tracks, colors);
    }
 
    //-- detector
    ExtractDetector();
 
 
    if(GFDEBUG_DET) G4cout << ">>>>>>>>>>>>>>>>>>>>>>   (";
    std::vector<G4float> transformObjects;
    for(G4int i = 0; i < 3; i++) {
      // need to check!!
      transformObjects.push_back((kVolumeSize[i]/2. - kVoxelDimension[i]/2.));
      if(GFDEBUG_DET) G4cout << transformObjects[i] << ", ";
    }
    if(GFDEBUG_DET) G4cout << ")" << G4endl;
 
 
    kgMocrenIO->translateTracks(transformObjects);
    kgMocrenIO->translateDetector(transformObjects);
 
    // store
    kgMocrenIO->storeData(kGddFileName);
  } 
 
}

Referenced by GFEndModeling().

GetGddFileName()

const char * G4GMocrenFileSceneHandler::GetGddFileName ( )

inline

Definition at line 111 of file G4GMocrenFileSceneHandler.hh.

{ return kGddFileName ; }

Referenced by G4GMocrenFileViewer::G4GMocrenFileViewer(), and G4GMocrenFileViewer::ShowView().

GetSystem()

G4GMocrenFile & G4GMocrenFileSceneHandler::GetSystem ( )

inline

Definition at line 110 of file G4GMocrenFileSceneHandler.hh.

{ return kSystem   ; }

GFBeginModeling()

void G4GMocrenFileSceneHandler::GFBeginModeling

(

void

)

Definition at line 509 of file G4GMocrenFileSceneHandler.cc.

{
  G4VSceneHandler::BeginModeling();
 
  if( !GFIsInModeling() ) {
 
    if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
      G4cout << "***** G4GMocrenFileSceneHandler::GFBeginModeling (called & started)" << G4endl;
 
    //----- Send saving command and heading comment
    BeginSavingGdd();
 
    kFlagInModeling = true ;
 
    // These models are entrusted to user commands /vis/scene/add/psHits or hits
    //GetScene()->AddEndOfEventModel(new G4PSHitsModel());
    //GetScene()->AddEndOfRunModel(new G4PSHitsModel());
    //scene->AddEndOfEventModel(new G4HitsModel());
    if(GFDEBUG_HIT) {
      G4Scene * scene = GetScene();
      std::vector<G4Scene::Model> vmodel = scene->GetEndOfEventModelList();
      std::vector<G4Scene::Model>::iterator itr = vmodel.begin();
      for(; itr != vmodel.end(); itr++) {
        G4cout << " IIIIII model name: " << itr->fpModel->GetGlobalTag() << G4endl;
      }
    }
  }
}

Referenced by AddPrimitive(), AddSolid(), BeginPrimitives(), G4GMocrenFileViewer::ClearView(), and G4GMocrenFileViewer::DrawView().

GFEndModeling()

void G4GMocrenFileSceneHandler::GFEndModeling

(

)

Definition at line 786 of file G4GMocrenFileSceneHandler.cc.

{
  G4VSceneHandler::EndModeling();
 
  //-----       
  if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations)
    G4cout << "***** GFEndModeling (called)" << G4endl;
 
  if( GFIsInModeling() ) {
 
    if(GFDEBUG || G4VisManager::GetVerbosity() >= G4VisManager::confirmations) {
      G4cout << "***** GFEndModeling (started) " ; 
      G4cout << "(/EndModeling, /DrawAll, /CloseDevice)" << G4endl;
    }
 
    //----- End saving data to g4.gdd
    EndSavingGdd() ;
 
    //------ Reset flag 
    kFlagInModeling = false ;
 
  }
 
}

Referenced by G4GMocrenFileViewer::ShowView(), and ~G4GMocrenFileSceneHandler().

GFIsInModeling()

G4bool G4GMocrenFileSceneHandler::GFIsInModeling ( )

inline

Definition at line 103 of file G4GMocrenFileSceneHandler.hh.

{ return kFlagInModeling ; }

Referenced by GFBeginModeling(), GFEndModeling(), and G4GMocrenFileViewer::ShowView().

IsSavingGdd()

G4bool G4GMocrenFileSceneHandler::IsSavingGdd ( void  )

inline

Definition at line 105 of file G4GMocrenFileSceneHandler.hh.

{ return kFlagSaving_g4_gdd ;   }

Referenced by BeginSavingGdd(), and EndSavingGdd().

SetGddFileName()

void G4GMocrenFileSceneHandler::SetGddFileName

(

)

Definition at line 205 of file G4GMocrenFileSceneHandler.cc.

{
  // g4_00.gdd, g4_01.gdd, ..., g4_MAX_FILE_INDEX.gdd
  const G4int MAX_FILE_INDEX = kMaxFileNum - 1 ;
 
  // dest directory (null if no environmental variables is set)
  std::strncpy(kGddFileName, kGddDestDir, sizeof(kGddFileName)-1);
  kGddFileName[sizeof(kGddFileName)-1] = '\0';
 
  // create full path name (default)
  std::strncat ( kGddFileName, DEFAULT_GDD_FILE_NAME,
                sizeof(kGddFileName) - std::strlen(kGddFileName) - 1);
 
  // Automatic updation of file names
  static G4int currentNumber = 0;
  for( G4int i = currentNumber ; i < kMaxFileNum ; i++) { 
 
    // Message in the final execution
    if( i == MAX_FILE_INDEX ) 
      {
    if (G4VisManager::GetVerbosity() >= G4VisManager::warnings) {
      G4cout << "==========================================="   << G4endl; 
      G4cout << "WARNING MESSAGE from GMocrenFile driver:   "   << G4endl;
      G4cout << "  This file name is the final one in the   "   << G4endl;
      G4cout << "  automatic updation of the output file name." << G4endl; 
      G4cout << "  You may overwrite existing files, i.e.   "   << G4endl; 
      G4cout << "  g4_XX.gdd."   << G4endl;
      G4cout << "==========================================="   << G4endl; 
    }
      }
 
    // re-determine file name as G4GMocrenFile_DEST_DIR/g4_XX.gdd 
    std::ostringstream filename;
    filename
    << kGddDestDir << GDD_FILE_HEADER
    << std::setw(2) << std::setfill('0') << i << ".wrl";
    strncpy(kGddFileName,filename.str().c_str(),sizeof(kGddFileName)-1);
    kGddFileName[sizeof(kGddFileName)-1] = '\0';
 
    // check validity of the file name
    std::ifstream fin(kGddFileName); 
    if(GFDEBUG)
      G4cout << "FILEOPEN: " << i << " : " << kGddFileName << fin.fail()
         << G4endl;
    if(!fin) { 
      // new file   
      fin.close();
      currentNumber = i+1;
      break; 
    } else { 
      // already exists (try next) 
      fin.close(); 
    } 
 
  } // for 
 
  G4cout << "======================================================================" << G4endl; 
  G4cout << "Output file: " << kGddFileName                          << G4endl; 
  G4cout << "Destination directory (current dir if NULL): " << kGddDestDir << G4endl; 
  G4cout << "Maximum number of files in the destination directory: " << kMaxFileNum << G4endl; 
  G4cout << "Note:" << G4endl; 
  G4cout << "  * The maximum number is customizable as:           " << G4endl;
  G4cout << "      % setenv  G4GMocrenFile_MAX_FILE_NUM  number " << G4endl;        
  G4cout << "  * The destination directory is customizable as:" << G4endl;
  G4cout << "      % setenv  G4GMocrenFile_DEST_DIR  dir_name/  " << G4endl;        
  G4cout << "     ** Do not forget \"/\" at the end of the dir_name, e.g. \"./tmp/\"." << G4endl;              
  //G4cout << "        dir_name, e.g. \"./tmp/\"."                 << G4endl;              
  G4cout << G4endl;
  G4cout << "Maximum number of trajectories is set to " << MAX_NUM_TRAJECTORIES << "."<< G4endl;
  G4cout << "======================================================================" << G4endl; 
 
} // G4GMocrenFileSceneHandler::SetGddFileName()

Referenced by BeginSavingGdd().

Friends And Related Function Documentation

G4GMocrenFileViewer

friend class G4GMocrenFileViewer

friend

Definition at line 55 of file G4GMocrenFileSceneHandler.hh.

---

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

• G4GMocrenFileSceneHandler.hh
• G4GMocrenFileSceneHandler.cc