Import Geant4 3.2.0 source tree

This commit is contained in:
Gabriele Cosmo
2016-06-08 16:10:37 +02:00
parent 137e303ecc
commit 36c080dca6
3464 changed files with 119310 additions and 52696 deletions
@@ -0,0 +1,296 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// Satoshi Tanaka 31th May 2001
// A scene handler to dump geometry hierarchy to GAG.
#include "g4std/strstream"
#include "G4GAGTreeSceneHandler.hh"
#include "G4GAGTree.hh"
#include "G4VSolid.hh"
#include "G4PhysicalVolumeModel.hh"
#include "G4VPhysicalVolume.hh"
#include "G4LogicalVolume.hh"
#include "G4VPVParameterisation.hh"
// #define DEBUG_GAG_TREE
const G4String GAG_TREE_WORLD_VOLUME_NAME ( "WORLD" );
const G4String GAG_TREE_BEGIN_DTREE ( "@@DTREEBegin" );
const G4String GAG_TREE_END_DTREE ( "@@DTREEEnd" );
//-----
G4GAGTreeSceneHandler::G4GAGTreeSceneHandler(G4VGraphicsSystem& system,
const G4String& name):
G4VTreeSceneHandler(system, name)
{
ClearPVList();
}
//-----
G4GAGTreeSceneHandler::~G4GAGTreeSceneHandler ()
{
ClearPVList();
}
//-----
void G4GAGTreeSceneHandler::ClearPVList(void)
{
fPVNameList.Clear() ;
fPrevDepth = 0 ;
fPrevAbsPVName = "";
fPVCounter = 0 ;
}
//-----
void G4GAGTreeSceneHandler::InitializePVList(void)
{
fPVNameList.Clear();
fPVNameList.Push( GAG_TREE_WORLD_VOLUME_NAME );
fPrevDepth = 0 ;
fPrevAbsPVName = "";
fPVCounter = 0 ;
}
//-----
void G4GAGTreeSceneHandler::BeginModeling ()
{
// To re-use "culling off" code.
G4VTreeSceneHandler::BeginModeling ();
// Initialize the stack the the tree generation
InitializePVList();
// Get the current verbosity level
const G4GAGTree* pSystem = (G4GAGTree*)GetGraphicsSystem();
const G4int verbosity = pSystem->GetVerbosity();
// Beginning of the tree output
G4cout << "\nG4GAGTreeSceneHandler::BeginModeling:"
"\n set verbosity with \"/vis/GAGTree/verbose <verbosity>\":"
"\n < 10: - does not print daughters of repeated logical volumes."
"\n - does not repeat replicas."
"\n >= 10: prints all physical volumes."
"\n FORMAT: PV_name.copy_no.index"
"\n For level of detail add:"
"\n >= 0: prints physical volume name and copy number."
"\n FORMAT: PV_name.copy_no.index"
"\n >= 1: prints logical volume name."
"\n FORMAT: PV_name.copy_no.LV_name.index"
"\n >= 2: prints solid name and type."
"\n FORMAT: PV_name.copy_no.LV_name.solid_name.solid_type.index"
"\n Note: all culling, if any, is switched off so all volumes are seen."
"\n Now printing with verbosity " << verbosity << G4endl;
// Declare to start GAG tree
G4cout << GAG_TREE_BEGIN_DTREE << G4endl;
}
void G4GAGTreeSceneHandler::EndModeling ()
{
// Dump the last PV node
if( fPrevAbsPVName != "" ) { G4cout << fPrevAbsPVName << G4endl; }
// Declare to end GAG tree
G4cout << GAG_TREE_END_DTREE << G4endl;
G4cout << "G4GAGTreeSceneHandler::EndModeling" << G4endl;
// Clear the sets
fLVSet.clear();
fReplicaSet.clear();
// Clear the stack for the tree generation
ClearPVList();
// To re-use "culling off" code.
G4VTreeSceneHandler::EndModeling ();
}
void G4GAGTreeSceneHandler::Dump (const G4VSolid& solid)
{
//////////////////////////////
G4String cur_abs_pv_name ;
G4String pv_name_tmp ;
G4String cur_pv_name ( fpCurrentPV->GetName() ) ;
//////////////////////////////
const G4GAGTree* pSystem = (G4GAGTree*)GetGraphicsSystem();
const G4int verbosity = pSystem->GetVerbosity();
const G4int detail = verbosity % 10;
if (verbosity < 10 && fReplicaSet.find(fpCurrentPV) != fReplicaSet.end()) {
// Ignore if an already treated replica. (Assumes that the model
// which has invoked this function is a G4PhysicalVolumeModel - we
// check this by testing fpCurrentPV.)
if (fpCurrentPV) {
((G4PhysicalVolumeModel*)fpModel)->CurtailDescent();
return;
}
}
///////////////////////////////////////////////////////////
// Add the extension ".details.index" to the current PV node
// Step 1: Initialize the extension
const int CHAR_LENGTH = 1024;
char pv_ext [CHAR_LENGTH]; pv_ext[0] = '\0';
G4std::ostrstream ost (pv_ext, CHAR_LENGTH);
// Step 2: Generate the extension
// copy number
ost << "." << fpCurrentPV->GetCopyNo() ;
if (detail >= 1) {
// LV name
ost << "." << fpCurrentLV->GetName() ;
}
if (detail >= 2) {
// Solid info
ost << "." << fpCurrentLV->GetSolid()->GetName();
ost << "." << fpCurrentLV->GetSolid()->GetEntityType() ;
}
// Tree index (0 for the world)
ost << "." << fPVCounter << '\0' ;
// Step 3: Add the extention to the current PV name
cur_pv_name += pv_ext ;
// End of adding extension
// Search a mother PV node for the current PV
// in the direction to the root node.
// depth_mother = depth_current - 1
if( fCurrentDepth > fPrevDepth )
{
// Do nothing (The mother is the previous PV node)
} else {
while (1)
{
// Delete the head item of the list
fPVNameList.Pop();
// Is the right mother at the head of the list?
// Note: The mother of the world has depth -1.
// It happens when the current node is the world volume,
// and so the list becomes empty with the popping above.
G4int trial_mother_depth = fPVNameList.GetHeadIndex() ;
if ( fCurrentDepth > trial_mother_depth ) break ;
}
} // if-else
// Add the curent PV to the tree as a new node/leaf
fPVNameList.Push( cur_pv_name );
// Make the absolute path name
fPVNameList.ToTail() ;
while ( fPVNameList.GetItem ( pv_name_tmp ) ) {
cur_abs_pv_name += "/" ;
cur_abs_pv_name += pv_name_tmp ;
fPVNameList.Upward();
}
// Add "/" to the PREVIOUS PV node name if it is not a leaf.
if( fPrevAbsPVName != "" )
{
// Add "/"
if( fCurrentDepth > fPrevDepth ) {fPrevAbsPVName += "/" ;}
}
// Print the PREVIOUS node after node/leaf distiction
// is made clear by reading the current node.
if( fPrevAbsPVName != "" ) { G4cout << fPrevAbsPVName ; }
///////////////////////////////////////////////////////////
if (fpCurrentPV->IsReplicated()) {
fReplicaSet.insert(fpCurrentPV); // Record new replica volume.
if (verbosity < 10) {
// Add printing for replicas (when replicas are ignored)...
EAxis axis;
G4int nReplicas;
G4double width;
G4double offset;
G4bool consuming;
fpCurrentPV->GetReplicationData(axis,nReplicas,width,offset,consuming);
G4VPVParameterisation* pP = fpCurrentPV->GetParameterisation();
#if defined DEBUG_GAG_TREE
G4cout << "_(" << nReplicas;
#endif
if (pP) {
#if defined DEBUG_GAG_TREE
G4cout << " parametrised volumes)";
#endif
}
else {
#if defined DEBUG_GAG_TREE
G4cout << " replicas)";
#endif
}
}
}
else {
if (fLVSet.find(fpCurrentLV) != fLVSet.end()) {
if (verbosity < 10) {
// Add printing for repeated logical volume...
#if defined DEBUG_GAG_TREE
G4cout << " (repeated logical volume)";
#endif
// Ignore if an already treated logical volume.
if (fpCurrentPV) {
((G4PhysicalVolumeModel*)fpModel)->CurtailDescent();
G4cout << G4endl;
return;
}
}
}
}
if (fLVSet.find(fpCurrentLV) == fLVSet.end()) {
fLVSet.insert(fpCurrentLV); // Record new logical volume.
}
////////////////////////
// End of printing
if( fPrevAbsPVName != "" ) { G4cout << G4endl;}
// Prepare for the next call, i.e. the next PV.
fPrevDepth = fCurrentDepth ;
fPrevAbsPVName = cur_abs_pv_name ;
fPVCounter++ ;
////////////////////////
return;
}