G4tgrVolumeMgr Class Reference

#include <G4tgrVolumeMgr.hh>

Public Member Functions
G4tgrSolid *	CreateSolid (const std::vector< G4String > &wl, G4bool bVOLUtag)
void	DumpSummary ()
void	DumpVolumeLeaf (const G4tgrVolume *vol, unsigned int copyNo, unsigned int leafDepth)
void	DumpVolumeTree ()
G4tgrSolid *	FindSolid (const G4String &name, G4bool exists=false)
G4tgrVolume *	FindVolume (const G4String &volname, G4bool exists=false)
std::vector< G4tgrVolume * >	FindVolumes (const G4String &volname, G4bool exists)
std::pair< G4mmapspl::iterator, G4mmapspl::iterator >	GetChildren (const G4String &name)
std::vector< G4tgrPlace * >	GetDetPlaceList ()
std::vector< G4tgrElement * >	GetElementList ()
std::vector< G4tgrIsotope * >	GetIsotopeList ()
std::vector< G4tgrMaterial * >	GetMaterialList ()
std::vector< G4tgrRotationMatrix * >	GetRotMList ()
const G4mapssol &	GetSolidMap ()
const G4tgrVolume *	GetTopVolume ()
std::vector< G4tgrVolume * >	GetVolumeList ()
const G4mapsvol &	GetVolumeMap ()
const G4mmapspl &	GetVolumeTree ()
void	RegisterMe (G4tgrElement *ele)
void	RegisterMe (G4tgrIsotope *iso)
void	RegisterMe (G4tgrMaterial *mat)
void	RegisterMe (G4tgrPlace *pl)
void	RegisterMe (G4tgrRotationMatrix *rm)
void	RegisterMe (G4tgrSolid *vol)
void	RegisterMe (G4tgrVolume *vol)
void	RegisterParentChild (const G4String &parentName, const G4tgrPlace *pl)
void	UnRegisterMe (G4tgrSolid *vol)
void	UnRegisterMe (G4tgrVolume *vol)

Static Public Member Functions
static G4tgrVolumeMgr *	GetInstance ()

Private Member Functions
	G4tgrVolumeMgr ()
	~G4tgrVolumeMgr ()

Private Attributes
std::vector< G4tgrPlace * >	theG4tgrPlaceList
G4mapssol	theG4tgrSolidMap
std::vector< G4tgrVolume * >	theG4tgrVolumeList
G4mapsvol	theG4tgrVolumeMap
G4mmapspl	theG4tgrVolumeTree
std::vector< G4tgrElement * >	theHgElemList
std::vector< G4tgrIsotope * >	theHgIsotList
std::vector< G4tgrMaterial * >	theHgMateList
std::vector< G4tgrRotationMatrix * >	theHgRotMList

Static Private Attributes
static G4ThreadLocal G4tgrVolumeMgr *	theInstance = nullptr

Detailed Description

Definition at line 52 of file G4tgrVolumeMgr.hh.

Constructor & Destructor Documentation

G4tgrVolumeMgr()

G4tgrVolumeMgr::G4tgrVolumeMgr ( )

private

Definition at line 45 of file G4tgrVolumeMgr.cc.

{
}

Referenced by GetInstance().

~G4tgrVolumeMgr()

G4tgrVolumeMgr::~G4tgrVolumeMgr ( )

private

Definition at line 50 of file G4tgrVolumeMgr.cc.

{
  delete theInstance;
}

References theInstance.

Member Function Documentation

CreateSolid()

G4tgrSolid * G4tgrVolumeMgr::CreateSolid	(	const std::vector< G4String > &	wl,
		G4bool	bVOLUtag
	)

Definition at line 66 of file G4tgrVolumeMgr.cc.

{
  G4tgrSolid* sol = FindSolid(wl[1]);
  if(sol != nullptr)
  {
    G4String ErrMessage = "Solid already exists... " + wl[1];
    G4Exception("G4tgrVolumeMgr::CreateSolid()", "InvalidSetup", FatalException,
                ErrMessage);
  }
 
  std::vector<G4String> wlc = wl;
  if(bVOLUtag)
  {
    wlc.pop_back();
  }
 
  G4String wl2 = wlc[2];
  for(std::size_t ii = 0; ii < wl2.length(); ++ii)
  {
    wl2[ii] = toupper(wl2[ii]);
  }
  if((wl2 == "UNION") || (wl2 == "SUBTRACTION") || (wl2 == "INTERSECTION"))
  {
    //---------- Boolean solid
    //---------- Create G4tgrSolidBoolean and fill the solid params
    sol = new G4tgrSolidBoolean(wlc);
  }
  else if(wl2 == "SCALED")
  {
    //---------- Create G4tgrSolidScaled and fill the solid params
    sol = new G4tgrSolidScaled(wlc);
  }
  else if(wl2 == "MULTIUNION")
  {
    //---------- Create G4tgrSolidMultiUnion and fill the solid params
    sol = new G4tgrSolidMultiUnion(wlc);
  }
  else
  {
    //---------- Create G4tgrSolidSimple and fill the solid params
    sol = new G4tgrSolid(wlc);
  }
 
  return sol;
}

References FatalException, FindSolid(), and G4Exception().

Referenced by G4tgrVolume::G4tgrVolume(), and G4tgrLineProcessor::ProcessLine().

DumpSummary()

void G4tgrVolumeMgr::DumpSummary

(

)

Definition at line 385 of file G4tgrVolumeMgr.cc.

{
  //---------- Dump number of objects of each class
  G4cout << " @@@@@@@@@@@@@@@@@@ Dumping Detector Summary " << G4endl;
  G4cout << " @@@ Geometry built inside world volume: "
         << GetTopVolume()->GetName() << G4endl;
  G4cout << " Number of G4tgrVolume's: " << theG4tgrVolumeMap.size() << G4endl;
  unsigned int nPlace = 0;
  for(auto cite = theG4tgrVolumeMap.cbegin();
      cite != theG4tgrVolumeMap.cend(); ++cite)
  {
    nPlace += ((*cite).second)->GetPlacements().size();
  }
  G4cout << " Number of G4tgrPlace's: " << nPlace << G4endl;
 
  G4tgrMaterialFactory* matef = G4tgrMaterialFactory::GetInstance();
  G4cout << " Number of G4tgrIsotope's: " << matef->GetIsotopeList().size()
         << G4endl;
  G4cout << " Number of G4tgrElement's: " << matef->GetElementList().size()
         << G4endl;
  G4cout << " Number of G4tgrMaterial's: " << matef->GetMaterialList().size()
         << G4endl;
 
  G4tgrRotationMatrixFactory* rotmf = G4tgrRotationMatrixFactory::GetInstance();
  G4cout << " Number of G4tgrRotationMatrix's: "
         << rotmf->GetRotMatList().size() << G4endl;
 
  //---------- Dump detail list of objects of each class
  DumpVolumeTree();
 
  matef->DumpIsotopeList();
  matef->DumpElementList();
  matef->DumpMaterialList();
  rotmf->DumpRotmList();
}

References G4tgrMaterialFactory::DumpElementList(), G4tgrMaterialFactory::DumpIsotopeList(), G4tgrMaterialFactory::DumpMaterialList(), G4tgrRotationMatrixFactory::DumpRotmList(), DumpVolumeTree(), G4cout, G4endl, G4tgrMaterialFactory::GetElementList(), G4tgrMaterialFactory::GetInstance(), G4tgrRotationMatrixFactory::GetInstance(), G4tgrMaterialFactory::GetIsotopeList(), G4tgrMaterialFactory::GetMaterialList(), G4tgrVolume::GetName(), G4tgrRotationMatrixFactory::GetRotMatList(), GetTopVolume(), and theG4tgrVolumeMap.

DumpVolumeLeaf()

void G4tgrVolumeMgr::DumpVolumeLeaf	(	const G4tgrVolume *	vol,
		unsigned int	copyNo,
		unsigned int	leafDepth
	)

Definition at line 357 of file G4tgrVolumeMgr.cc.

{
  for(std::size_t ii = 0; ii < leafDepth; ++ii)
  {
    G4cout << "  ";
  }
  G4cout << " VOL:(" << leafDepth << ")" << vol->GetName() << "   copy No "
         << copyNo << G4endl;
 
  //---------- construct the children of this VOL
  std::pair<G4mmapspl::iterator, G4mmapspl::iterator> children =
    GetChildren(vol->GetName());
  G4mmapspl::const_iterator cite;
 
  ++leafDepth;
  for(cite = children.first; cite != children.second; ++cite)
  {
    //---- find G4tgrVolume pointed by G4tgrPlace
    const G4tgrPlace* pla       = (*cite).second;
    const G4tgrVolume* volchild = pla->GetVolume();
    //--- find copyNo
    unsigned int cn = pla->GetCopyNo();
    DumpVolumeLeaf(volchild, cn, leafDepth);
  }
}

References DumpVolumeLeaf(), G4cout, G4endl, GetChildren(), G4tgrPlace::GetCopyNo(), G4tgrVolume::GetName(), and G4tgrPlace::GetVolume().

Referenced by DumpVolumeLeaf(), and DumpVolumeTree().

DumpVolumeTree()

void G4tgrVolumeMgr::DumpVolumeTree

(

)

Definition at line 347 of file G4tgrVolumeMgr.cc.

{
  G4cout << " @@@@@@@@@@@@@@@@ DUMPING G4tgrVolume's Tree  " << G4endl;
 
  const G4tgrVolume* vol = GetTopVolume();
 
  DumpVolumeLeaf(vol, 0, 0);
}

References DumpVolumeLeaf(), G4cout, G4endl, and GetTopVolume().

Referenced by DumpSummary().

FindSolid()

G4tgrSolid * G4tgrVolumeMgr::FindSolid	(	const G4String &	name,
		G4bool	exists = false
	)

Definition at line 190 of file G4tgrVolumeMgr.cc.

{
  G4tgrSolid* vol = nullptr;
 
  G4mapssol::const_iterator svite = theG4tgrSolidMap.find(volname);
  if(svite == theG4tgrSolidMap.cend())
  {
    if(exists)
    {
      for(svite = theG4tgrSolidMap.cbegin();
          svite != theG4tgrSolidMap.cend(); ++svite)
      {
        G4cerr << " VOL:" << (*svite).first << G4endl;
      }
      G4String ErrMessage = "Solid not found... " + volname;
      G4Exception("G4tgrVolumeMgr::FindSolid()", "InvalidSetup", FatalException,
                  ErrMessage);
    }
  }
  else
  {
    vol = const_cast<G4tgrSolid*>((*svite).second);
  }
 
  return vol;
}

References FatalException, G4cerr, G4endl, G4Exception(), and theG4tgrSolidMap.

Referenced by CreateSolid(), G4tgrSolidBoolean::G4tgrSolidBoolean(), G4tgrSolidMultiUnion::G4tgrSolidMultiUnion(), G4tgrSolidScaled::G4tgrSolidScaled(), and G4tgrVolume::G4tgrVolume().

FindVolume()

G4tgrVolume * G4tgrVolumeMgr::FindVolume	(	const G4String &	volname,
		G4bool	exists = false
	)

Definition at line 218 of file G4tgrVolumeMgr.cc.

{
  G4tgrVolume* vol = nullptr;
 
  G4mapsvol::const_iterator svite = theG4tgrVolumeMap.find(volname);
  if(svite == theG4tgrVolumeMap.cend())
  {
    if(exists)
    {
      for(svite = theG4tgrVolumeMap.cbegin();
          svite != theG4tgrVolumeMap.cend(); ++svite)
      {
        G4cerr << " VOL:" << (*svite).first << G4endl;
      }
      G4String ErrMessage = "Volume not found... " + volname;
      G4Exception("G4tgrVolumeMgr::FindVolume()", "InvalidSetup",
                  FatalException, ErrMessage);
    }
    else
    {
      G4String WarMessage = "Volume does not exists... " + volname;
      G4Exception("G4tgrVolumeMgr::FindVolume()", "SearchFailed", JustWarning,
                  WarMessage);
    }
  }
  else
  {
    vol = const_cast<G4tgrVolume*>((*svite).second);
  }
 
  return vol;
}

References FatalException, G4cerr, G4endl, G4Exception(), JustWarning, and theG4tgrVolumeMap.

Referenced by G4tgrLineProcessor::FindVolume(), G4tgrSolidBoolean::G4tgrSolidBoolean(), G4tgrSolidMultiUnion::G4tgrSolidMultiUnion(), G4tgrSolidScaled::G4tgrSolidScaled(), G4tgrVolumeDivision::G4tgrVolumeDivision(), and GetTopVolume().

FindVolumes()

std::vector< G4tgrVolume * > G4tgrVolumeMgr::FindVolumes	(	const G4String &	volname,
		G4bool	exists
	)

Definition at line 252 of file G4tgrVolumeMgr.cc.

{
  std::vector<G4tgrVolume*> vols;
 
  G4mapsvol::const_iterator svite;
  for(svite = theG4tgrVolumeMap.cbegin();
      svite != theG4tgrVolumeMap.cend(); ++svite)
  {
    if(G4tgrUtils::AreWordsEquivalent(volname, (*svite).second->GetName()))
    {
      vols.push_back(const_cast<G4tgrVolume*>((*svite).second));
    }
  }
 
  if(vols.size() == 0)
  {
    if(exists)
    {
      for(svite = theG4tgrVolumeMap.cbegin();
          svite != theG4tgrVolumeMap.cend(); ++svite)
      {
        G4cerr << " VOL:" << (*svite).first << G4endl;
      }
      G4String ErrMessage = "Volume not found... " + volname;
      G4Exception("G4tgrVolumeMgr::FindVolumes()", "InvalidSetup",
                  FatalException, ErrMessage);
    }
    else
    {
      G4String WarMessage = "Volume does not exists... " + volname;
      G4Exception("G4tgrVolumeMgr::FindVolumes()", "SearchFailed", JustWarning,
                  WarMessage);
    }
  }
 
  return vols;
}

References G4tgrUtils::AreWordsEquivalent(), FatalException, G4cerr, G4endl, G4Exception(), JustWarning, and theG4tgrVolumeMap.

Referenced by G4tgrLineProcessor::ProcessLine().

GetChildren()

std::pair< G4mmapspl::iterator, G4mmapspl::iterator > G4tgrVolumeMgr::GetChildren

(

const G4String &

name

)

Definition at line 339 of file G4tgrVolumeMgr.cc.

{
  std::pair<G4mmapspl::iterator, G4mmapspl::iterator> dite;
  dite = theG4tgrVolumeTree.equal_range(name);
  return dite;
}

References G4InuclParticleNames::name(), and theG4tgrVolumeTree.

Referenced by G4tgbVolume::ConstructG4Volumes(), and DumpVolumeLeaf().

GetDetPlaceList()

std::vector< G4tgrPlace * > G4tgrVolumeMgr::GetDetPlaceList ( )

inline

Definition at line 110 of file G4tgrVolumeMgr.hh.

{ return theG4tgrPlaceList; }

References theG4tgrPlaceList.

GetElementList()

std::vector< G4tgrElement * > G4tgrVolumeMgr::GetElementList ( )

inline

Definition at line 112 of file G4tgrVolumeMgr.hh.

{ return theHgElemList; }

References theHgElemList.

GetInstance()

G4tgrVolumeMgr * G4tgrVolumeMgr::GetInstance ( )

static

Definition at line 56 of file G4tgrVolumeMgr.cc.

{
  if(theInstance == nullptr)
  {
    theInstance = new G4tgrVolumeMgr;
  }
  return theInstance;
}

References G4tgrVolumeMgr(), and theInstance.

Referenced by G4tgrVolume::AddPlace(), G4tgrVolumeAssembly::AddPlace(), G4tgrVolume::AddPlaceParam(), G4tgrVolume::AddPlaceReplica(), G4tgbDetectorConstruction::Construct(), G4tgbVolume::ConstructG4Volumes(), G4tgbVolumeMgr::CopyVolumes(), G4tgrLineProcessor::G4tgrLineProcessor(), G4tgrSolid::G4tgrSolid(), G4tgrSolidBoolean::G4tgrSolidBoolean(), G4tgrSolidMultiUnion::G4tgrSolidMultiUnion(), G4tgrSolidScaled::G4tgrSolidScaled(), G4tgrVolume::G4tgrVolume(), G4tgrVolumeDivision::G4tgrVolumeDivision(), and G4tgbDetectorBuilder::ReadDetector().

GetIsotopeList()

std::vector< G4tgrIsotope * > G4tgrVolumeMgr::GetIsotopeList ( )

inline

Definition at line 111 of file G4tgrVolumeMgr.hh.

{ return theHgIsotList; }

References theHgIsotList.

GetMaterialList()

std::vector< G4tgrMaterial * > G4tgrVolumeMgr::GetMaterialList ( )

inline

Definition at line 113 of file G4tgrVolumeMgr.hh.

{ return theHgMateList; }

References theHgMateList.

GetRotMList()

std::vector< G4tgrRotationMatrix * > G4tgrVolumeMgr::GetRotMList ( )

inline

Definition at line 114 of file G4tgrVolumeMgr.hh.

{ return theHgRotMList; }

References theHgRotMList.

GetSolidMap()

const G4mapssol & G4tgrVolumeMgr::GetSolidMap ( )

inline

Definition at line 106 of file G4tgrVolumeMgr.hh.

{ return theG4tgrSolidMap; }

References theG4tgrSolidMap.

GetTopVolume()

const G4tgrVolume * G4tgrVolumeMgr::GetTopVolume

(

)

Definition at line 292 of file G4tgrVolumeMgr.cc.

{
  //--- Start from any G4tgrVolume and go upwards until you get to the top.
  //    Check that indeed all volumes drive to the same top volume
 
  const G4tgrVolume* topVol = nullptr;
  for(auto itetv = theG4tgrVolumeMap.cbegin();
           itetv != theG4tgrVolumeMap.cend(); ++itetv)
  {
    const G4tgrVolume* vol = (*itetv).second;
#ifdef G4VERBOSE
    if(G4tgrMessenger::GetVerboseLevel() >= 3)
    {
      G4cout << " G4tgrVolumeMgr::GetTopVolume() - Vol: " << vol->GetName()
             << " no place = " << vol->GetPlacements().size() << G4endl;
    }
#endif
 
    while(vol->GetPlacements().size() != 0)
    {
      vol = FindVolume((*(vol->GetPlacements()).cbegin())->GetParentName(), 1);
#ifdef G4VERBOSE
      if(G4tgrMessenger::GetVerboseLevel() >= 3)
      {
        G4cout << " G4tgrVolumeMgr::GetTopVolume() - Vol: " << vol->GetName()
               << " N place = " << vol->GetPlacements().size() << G4endl;
      }
#endif
    }
    if((topVol != nullptr) && (topVol != vol) &&
       (topVol->GetType() != "VOLDivision") &&
       (vol->GetType() != "VOLDivision"))
    {
      G4Exception("G4tgrVolumeMgr::GetTopVolume()",
                  "Two world volumes found, second will be taken", JustWarning,
                  (G4String("Both volumes are at the top of a hierarchy: ") +
                   topVol->GetName() + " & " + vol->GetName())
                    .c_str());
    }
    topVol = vol;
  }
 
  return topVol;
}

References FindVolume(), G4cout, G4endl, G4Exception(), G4tgrVolume::GetName(), G4tgrVolume::GetPlacements(), G4tgrVolume::GetType(), G4tgrMessenger::GetVerboseLevel(), JustWarning, and theG4tgrVolumeMap.

Referenced by G4tgbDetectorConstruction::Construct(), DumpSummary(), DumpVolumeTree(), and G4tgbDetectorBuilder::ReadDetector().

GetVolumeList()

std::vector< G4tgrVolume * > G4tgrVolumeMgr::GetVolumeList ( )

inline

Definition at line 109 of file G4tgrVolumeMgr.hh.

{ return theG4tgrVolumeList; }

References theG4tgrVolumeList.

GetVolumeMap()

const G4mapsvol & G4tgrVolumeMgr::GetVolumeMap ( )

inline

Definition at line 107 of file G4tgrVolumeMgr.hh.

{ return theG4tgrVolumeMap; }

References theG4tgrVolumeMap.

Referenced by G4tgbVolumeMgr::CopyVolumes().

GetVolumeTree()

const G4mmapspl & G4tgrVolumeMgr::GetVolumeTree ( )

inline

Definition at line 108 of file G4tgrVolumeMgr.hh.

{ return theG4tgrVolumeTree; }

References theG4tgrVolumeTree.

RegisterMe() [1/7]

void G4tgrVolumeMgr::RegisterMe ( G4tgrElement *  ele )

inline

Definition at line 100 of file G4tgrVolumeMgr.hh.

{ theHgElemList.push_back(ele); }

References ele, and theHgElemList.

RegisterMe() [2/7]

void G4tgrVolumeMgr::RegisterMe ( G4tgrIsotope *  iso )

inline

Definition at line 99 of file G4tgrVolumeMgr.hh.

{ theHgIsotList.push_back(iso); }

References theHgIsotList.

RegisterMe() [3/7]

void G4tgrVolumeMgr::RegisterMe ( G4tgrMaterial *  mat )

inline

Definition at line 101 of file G4tgrVolumeMgr.hh.

{ theHgMateList.push_back(mat); }

References theHgMateList.

RegisterMe() [4/7]

void G4tgrVolumeMgr::RegisterMe ( G4tgrPlace *  pl )

inline

Definition at line 98 of file G4tgrVolumeMgr.hh.

{ theG4tgrPlaceList.push_back(pl); }

References theG4tgrPlaceList.

RegisterMe() [5/7]

void G4tgrVolumeMgr::RegisterMe ( G4tgrRotationMatrix *  rm )

inline

Definition at line 102 of file G4tgrVolumeMgr.hh.

{ theHgRotMList.push_back(rm); }

References theHgRotMList.

RegisterMe() [6/7]

void G4tgrVolumeMgr::RegisterMe

(

G4tgrSolid *

vol

)

Definition at line 114 of file G4tgrVolumeMgr.cc.

{
  if(theG4tgrSolidMap.find(sol->GetName()) != theG4tgrSolidMap.cend())
  {
    G4String ErrMessage =
      "Cannot be two solids with the same name... " + sol->GetName();
    G4Exception("G4tgrVolumeMgr::RegisterMe()", "InvalidSetup", FatalException,
                ErrMessage);
  }
  theG4tgrSolidMap.insert(G4mapssol::value_type(sol->GetName(), sol));
}

References FatalException, G4Exception(), G4tgrSolid::GetName(), and theG4tgrSolidMap.

Referenced by G4tgrSolid::G4tgrSolid(), G4tgrSolidBoolean::G4tgrSolidBoolean(), G4tgrSolidMultiUnion::G4tgrSolidMultiUnion(), G4tgrSolidScaled::G4tgrSolidScaled(), and G4tgrLineProcessor::ProcessLine().

RegisterMe() [7/7]

void G4tgrVolumeMgr::RegisterMe

(

G4tgrVolume *

vol

)

Definition at line 143 of file G4tgrVolumeMgr.cc.

{
  theG4tgrVolumeList.push_back(vol);
  if(theG4tgrVolumeMap.find(vol->GetName()) != theG4tgrVolumeMap.cend())
  {
    G4String ErrMessage =
      "Cannot be two volumes with the same name... " + vol->GetName();
    G4Exception("G4tgrVolumeMgr::RegisterMe()", "InvalidSetup", FatalException,
                ErrMessage);
  }
  theG4tgrVolumeMap.insert(G4mapsvol::value_type(vol->GetName(), vol));
}

References FatalException, G4Exception(), G4tgrVolume::GetName(), theG4tgrVolumeList, and theG4tgrVolumeMap.

RegisterParentChild()

void G4tgrVolumeMgr::RegisterParentChild	(	const G4String &	parentName,
		const G4tgrPlace *	pl
	)

Definition at line 183 of file G4tgrVolumeMgr.cc.

{
  theG4tgrVolumeTree.insert(G4mmapspl::value_type(parentName, pl));
}

References theG4tgrVolumeTree.

Referenced by G4tgrVolume::AddPlace(), G4tgrVolumeAssembly::AddPlace(), G4tgrVolume::AddPlaceParam(), G4tgrVolume::AddPlaceReplica(), and G4tgrVolumeDivision::G4tgrVolumeDivision().

UnRegisterMe() [1/2]

void G4tgrVolumeMgr::UnRegisterMe

(

G4tgrSolid *

vol

)

Definition at line 127 of file G4tgrVolumeMgr.cc.

{
  if(theG4tgrSolidMap.find(sol->GetName()) != theG4tgrSolidMap.cend())
  {
    G4String ErrMessage =
      "Cannot unregister a solid that is not registered... " + sol->GetName();
    G4Exception("G4tgrSolidMgr::unRegisterMe()", "InvalidSetup", FatalException,
                ErrMessage);
  }
  else
  {
    theG4tgrSolidMap.erase(theG4tgrSolidMap.find(sol->GetName()));
  }
}

References FatalException, G4Exception(), G4tgrSolid::GetName(), and theG4tgrSolidMap.

UnRegisterMe() [2/2]

void G4tgrVolumeMgr::UnRegisterMe

(

G4tgrVolume *

vol

)

Definition at line 157 of file G4tgrVolumeMgr.cc.

{
  std::vector<G4tgrVolume*>::const_iterator ite;
  for(ite = theG4tgrVolumeList.cbegin();
      ite != theG4tgrVolumeList.cend(); ++ite)
  {
    if((*ite) == vol)
    {
      break;
    }
  }
  if(ite == theG4tgrVolumeList.cend())
  {
    G4String ErrMessage =
      "Cannot unregister a volume not registered... " + vol->GetName();
    G4Exception("G4tgrVolumeMgr::unRegisterMe()", "InvalidSetup",
                FatalException, ErrMessage);
  }
  else
  {
    theG4tgrVolumeList.erase(ite);
  }
  theG4tgrVolumeMap.erase(theG4tgrVolumeMap.find(vol->GetName()));
}

References FatalException, G4Exception(), G4tgrVolume::GetName(), theG4tgrVolumeList, and theG4tgrVolumeMap.

Field Documentation

theG4tgrPlaceList

std::vector<G4tgrPlace*> G4tgrVolumeMgr::theG4tgrPlaceList

private

Definition at line 138 of file G4tgrVolumeMgr.hh.

Referenced by GetDetPlaceList(), and RegisterMe().

theG4tgrSolidMap

G4mapssol G4tgrVolumeMgr::theG4tgrSolidMap

private

Definition at line 123 of file G4tgrVolumeMgr.hh.

Referenced by FindSolid(), GetSolidMap(), RegisterMe(), and UnRegisterMe().

theG4tgrVolumeList

std::vector<G4tgrVolume*> G4tgrVolumeMgr::theG4tgrVolumeList

private

Definition at line 137 of file G4tgrVolumeMgr.hh.

Referenced by GetVolumeList(), RegisterMe(), and UnRegisterMe().

theG4tgrVolumeMap

G4mapsvol G4tgrVolumeMgr::theG4tgrVolumeMap

private

Definition at line 127 of file G4tgrVolumeMgr.hh.

Referenced by DumpSummary(), FindVolume(), FindVolumes(), GetTopVolume(), GetVolumeMap(), RegisterMe(), and UnRegisterMe().

theG4tgrVolumeTree

G4mmapspl G4tgrVolumeMgr::theG4tgrVolumeTree

private

Definition at line 131 of file G4tgrVolumeMgr.hh.

Referenced by GetChildren(), GetVolumeTree(), and RegisterParentChild().

theHgElemList

std::vector<G4tgrElement*> G4tgrVolumeMgr::theHgElemList

private

Definition at line 140 of file G4tgrVolumeMgr.hh.

Referenced by GetElementList(), and RegisterMe().

theHgIsotList

std::vector<G4tgrIsotope*> G4tgrVolumeMgr::theHgIsotList

private

Definition at line 139 of file G4tgrVolumeMgr.hh.

Referenced by GetIsotopeList(), and RegisterMe().

theHgMateList

std::vector<G4tgrMaterial*> G4tgrVolumeMgr::theHgMateList

private

Definition at line 141 of file G4tgrVolumeMgr.hh.

Referenced by GetMaterialList(), and RegisterMe().

theHgRotMList

std::vector<G4tgrRotationMatrix*> G4tgrVolumeMgr::theHgRotMList

private

Definition at line 142 of file G4tgrVolumeMgr.hh.

Referenced by GetRotMList(), and RegisterMe().

theInstance

G4ThreadLocal G4tgrVolumeMgr * G4tgrVolumeMgr::theInstance = nullptr

staticprivate

Definition at line 135 of file G4tgrVolumeMgr.hh.

Referenced by GetInstance(), and ~G4tgrVolumeMgr().

---

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

• source/persistency/ascii/include/G4tgrVolumeMgr.hh
• source/persistency/ascii/src/G4tgrVolumeMgr.cc