JA Namespace Reference

Classes
struct	Node

Typedefs
typedef G4PhysicalVolumeModel::G4PhysicalVolumeNodeID	PVNodeID
typedef std::vector< PVNodeID >	PVPath

Functions
void	Insert (const PVNodeID *pvPath, size_t pathLength, G4int index, Node *node)
void	PrintTree (std::ostream &, Node *)
void	Clear (Node *)

Typedef Documentation

PVNodeID

typedef G4PhysicalVolumeModel::G4PhysicalVolumeNodeID JA::PVNodeID

Definition at line 44 of file G4XXXSGSceneHandler.hh.

PVPath

typedef std::vector<PVNodeID> JA::PVPath

Definition at line 45 of file G4XXXSGSceneHandler.hh.

Function Documentation

Clear()

void JA::Clear

(

Node *

node

)

Definition at line 479 of file G4XXXSGSceneHandler.cc.

{
  const size_t& nDaughters = node->fDaughters.size();
  for (size_t i = 0; i < nDaughters; ++i) {
    Clear(node->fDaughters[i]);
    delete node->fDaughters[i];
  }
}

Referenced by Clear(), G4XXXSGSceneHandler::ClearStore(), and G4XXXSGSceneHandler::ClearTransientStore().

Insert()

void JA::Insert	(	const PVNodeID *	pvPath,
		size_t	pathLength,
		G4int	index,
		Node *	node
	)

Definition at line 412 of file G4XXXSGSceneHandler.cc.

                                 {
  // Path passed as a PVNodeID* to avoid copying.
 
  /* Debug
  for (size_t i = 0; i < pathLength; ++i) {
    std::cout << pvPath[i].GetPhysicalVolume()->GetName() << ":"
              << pvPath[i].GetCopyNo() << " ("
              << index << "), ";
  }
  */
 
  // See if node has been encountered before
  G4bool found = false; size_t foundPosition = 0;
  for (size_t i = 0; i < node->fDaughters.size(); ++i) {
    PVNodeID& daughterPVNodeID = node->fDaughters[i]->fPVNodeID;
    // It is enough to compare volume and copy number at a given position in the tree
    if (daughterPVNodeID.GetPhysicalVolume() == pvPath[0].GetPhysicalVolume() &&
    daughterPVNodeID.GetCopyNo() == pvPath[0].GetCopyNo()) {
      found = true;
      foundPosition = i;
      break;
    }
  }
 
  if (pathLength == 1) {  // This is a leaf
    if (found) {  // Update index
      node->fDaughters[foundPosition]->fIndex = index;
    } else {      // Make a new full entry
      node->fDaughters.push_back(new Node(pvPath[0],index));
    }
    /* Debug
    std::cout << std::endl;
    */
  } else {  // Not a leaf - carry on with rest of path
    if (found) {  // Just carry on
      Insert(pvPath+1,--pathLength,index,
         node->fDaughters[foundPosition]);
    } else {      // Insert place holder, then carry on
      node->fDaughters.push_back(new Node(pvPath[0]));
      Insert(pvPath+1,--pathLength,index,
         node->fDaughters[node->fDaughters.size()-1]);
    }
  }
}

Referenced by G4XXXSGSceneHandler::CreateCurrentItem(), and Insert().

PrintTree()

void JA::PrintTree	(	std::ostream &	os,
		Node *	node
	)

Definition at line 458 of file G4XXXSGSceneHandler.cc.

{
  static G4int depth = -1;
  depth++;
  PVNodeID& thisPVNodeID = node->fPVNodeID;
  G4int& thisIndex = node->fIndex;
  const size_t& nDaughters = node->fDaughters.size();
  G4VPhysicalVolume* thisPhysicalVolume= thisPVNodeID.GetPhysicalVolume();
  if (!thisPhysicalVolume) os << "Root" << std::endl;
  else {
    for (G4int i = 0; i < depth; ++i) os << "__";
    os << thisPVNodeID.GetPhysicalVolume()->GetName() << ":"
       << thisPVNodeID.GetCopyNo() << " ("
       << thisIndex << ")" << std::endl;;
  }
  for (size_t i = 0; i < nDaughters; ++i) {
    PrintTree(os, node->fDaughters[i]);
  }
  depth--;
}

Referenced by G4XXXSGViewer::DrawFromStore(), and PrintTree().