G4UA::VolumeDebugger Class Reference

a user action to debug G4 geometries More...

#include <VolumeDebugger.h>

Inheritance diagram for G4UA::VolumeDebugger:

Collaboration diagram for G4UA::VolumeDebugger:

Classes
struct	Config

Public Member Functions
	VolumeDebugger (const Config &config)
virtual void	BeginOfRunAction (const G4Run *) override
	hook for G4 UA functionality
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Private Member Functions
void	DumpGeometry () const
	wrapper function for the gdml dump
void	PullVolumes (G4LogicalVolume *v) const
	volume filter
bool	recursiveCheck (G4VPhysicalVolume *pv) const
	Returns true if there were overlaps.
std::string	printVolume (const G4VPhysicalVolume *pv, const std::string &delim="") const
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
Config	m_config
	configuration data
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

a user action to debug G4 geometries

It looks for the volume specified by the user in the TargetVolume parameter. (If it does not find it, it prints a very long list of possibilities, and exits without doing a check). The user can specifiy whether or not to make a GDML dump (I found it a waste of time and disk-space). It checks the specified volume, then does a recursive search through all child volumes. But it only enters into each LogVol once (no point in rechecking inside a LogVol over and over again for each PhysVol that points to it), saving quite some time. Furthermore, the user can specify a new parameter, MaxCopiesToCheck, as a double. Setting this to say 1.e20 will check all PhysVols are inside their MotherVol, and do not collide with any sisters. Setting it to say 10. means max. 10 copies of a LogVol checked. The others are skipped. The 10 chosen are spread out through the list of PhysVols that use the LogVol in question. Setting this parameter to say 2.0 gives a very fast check, while still checking every single type of LogVol at least once. Finds most overlaps very fast.

Definition at line 36 of file VolumeDebugger.h.

Constructor & Destructor Documentation

VolumeDebugger()

G4UA::VolumeDebugger::VolumeDebugger

(

const Config &

config

)

Definition at line 34 of file VolumeDebugger.cxx.

    : AthMessaging(Gaudi::svcLocator()->service< IMessageSvc >( "MessageSvc" ),
                   "VolumeDebugger"),
      m_config(config)
  {}

Member Function Documentation

BeginOfRunAction()

void G4UA::VolumeDebugger::BeginOfRunAction ( const G4Run * )

overridevirtual

hook for G4 UA functionality

Definition at line 132 of file VolumeDebugger.cxx.

  {
    std::call_once(VolumeDebugger_DumpGeometryOnce,
                   &G4UA::VolumeDebugger::DumpGeometry, this);
  }

DumpGeometry()

void G4UA::VolumeDebugger::DumpGeometry ( ) const

private

wrapper function for the gdml dump

Definition at line 63 of file VolumeDebugger.cxx.

  {
    G4VPhysicalVolume* W =
      G4TransportationManager::GetTransportationManager()->
      GetNavigatorForTracking()->GetWorldVolume();
 
   
    // Clear out the EMEC if necessary
    PullVolumes( W->GetLogicalVolume() );
 
    if(m_config.targetVolume!=""){
      G4LogicalVolumeStore *lvs = G4LogicalVolumeStore::GetInstance();
      for (unsigned int i=0;i<lvs->size();++i){
        for (unsigned int j=0;j<(*lvs)[i]->GetNoDaughters();++j){
          if ( (*lvs)[i]->GetDaughter(j)->GetName().c_str()==m_config.targetVolume ){
             //Create a World volume for the sub-tree that will be dumped in the GDML file
             //NB: without a world volume, the dumped geometry will not be properly defined
             //in Geant4 and in simulation this will lead to segfaults
             G4NistManager* nist = G4NistManager::Instance();
             G4Material* world_mat = nist->FindOrBuildMaterial("G4_AIR");
             G4VSolid* vBox = W->GetLogicalVolume()->GetSolid();
             G4LogicalVolume* logicWorld = new G4LogicalVolume(vBox,world_mat,"World");
             W  = new G4PVPlacement(0,G4ThreeVector(),logicWorld,"World",0,false,0,false);
             new G4PVPlacement(0,G4ThreeVector(),(*lvs)[i]->GetDaughter(j)->GetLogicalVolume(),m_config.targetVolume,logicWorld,false,0,false);
            // FIXME: Remove this goto!!!
            goto exitLoop;
          } // If we found the volume
        } // Loop over PVs in the LV
      } // Loop over volumes
 
      // Did not find the volume
      ATH_MSG_FATAL("Did not find the volume named " << m_config.targetVolume << ". Please set parameter TargetVolume to one of:\n\n");
 
      for (unsigned int i = 0; i < lvs->size(); ++i) {
    for (unsigned int j = 0; j < (*lvs)[i]->GetNoDaughters(); ++j) {
      ATH_MSG_FATAL( (*lvs)[i]->GetDaughter(j)->GetName());
    } // Loop over PVs in the LV
      } // Loop over volumes
      ATH_MSG_FATAL("\n\n ================= E N D   O F   L I S T ========================\n\n");
 
      return; // Really no point in doing anything on the entire Atlas volume
 
    } // Requested a volume
 
  exitLoop:
    
    if (m_config.printGeo) {
        ATH_MSG_INFO("Dump of the Geant4 world "<<std::endl<<printVolume(W));
    }
    if (m_config.dumpGDML) {
      ATH_MSG_INFO( "Writing to GDML volume " << W->GetName() << " to path " << m_config.path );
      G4GDMLParser parser;
      parser.SetRegionExport(m_config.dumpPhysicsRegions);
      parser.Write(m_config.path, W, true);
    }
    if(m_config.volumeCheck){
      ATH_MSG_INFO( "Running overlap test with parameters " << m_config.res << " " << m_config.tol << " " << m_config.verbose );
 
      bool hasOverlaps = recursiveCheck(W);
      if (hasOverlaps) {
    ATH_MSG_INFO("Overlap check: there were problems with the geometry.");
      }
      else {
    ATH_MSG_INFO("Overlap check: All looks good!");
      }
    }
 
  }

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 163 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 178 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

printVolume()

std::string G4UA::VolumeDebugger::printVolume ( const G4VPhysicalVolume * pv, const std::string & delim = "" ) const

private

Definition at line 190 of file VolumeDebugger.cxx.

                                                                                                      {
      std::stringstream sstr{};
      const G4ThreeVector trans = pv->GetFrameTranslation();
      const G4RotationMatrix* rot = pv->GetFrameRotation();
    
      sstr<<"Volume: "<<pv->GetName()<<", location: "<<Amg::toString(trans, 2)<<", ";
      if (rot) {
        sstr<<"orientation: {"<<Amg::toString(rot->colX(), 3)<<", ";
        sstr<<Amg::toString(rot->colY(), 3)<<", ";
        sstr<<Amg::toString(rot->colZ(), 3)<<"}";        
      }
      sstr<<std::endl;    
      G4LogicalVolume* log = pv->GetLogicalVolume();
      for (size_t d= 0; d <log->GetNoDaughters(); ++d){         
         sstr<<childDelim<<(d+1)<<": "<< printVolume(log->GetDaughter(d),
                                                     childDelim + "    ");
      }      
      return sstr.str();
   }

PullVolumes()

void G4UA::VolumeDebugger::PullVolumes ( G4LogicalVolume * v ) const

private

volume filter

Definition at line 41 of file VolumeDebugger.cxx.

  {
    if (v==0) return;
    std::vector<G4VPhysicalVolume*> pv_to_remove;
    for (unsigned int i=0;i<v->GetNoDaughters();++i){
      G4VPhysicalVolume * n_v = v->GetDaughter(i);
      if ( n_v->GetName() == "LArMgr::LAr::EMEC::Pos::InnerWheel" ||
       n_v->GetName() == "LArMgr::LAr::EMEC::Neg::InnerWheel" ||
       n_v->GetName() == "LArMgr::LAr::EMEC::Pos::OuterWheel" ||
       n_v->GetName() == "LArMgr::LAr::EMEC::Neg::OuterWheel" ){
    // This is one to remove
    pv_to_remove.push_back(n_v);
      } else {
    // Recurse
    PullVolumes( n_v->GetLogicalVolume() );
      }
    }
    for (unsigned int j=0;j<pv_to_remove.size();++j){
      v->RemoveDaughter( pv_to_remove[j] );
    }
  }

recursiveCheck()

bool G4UA::VolumeDebugger::recursiveCheck ( G4VPhysicalVolume * pv ) const

private

Returns true if there were overlaps.

Definition at line 138 of file VolumeDebugger.cxx.

  {
    bool somethingOverlapped = false;
    bool hasOverlaps = topPV->CheckOverlaps(m_config.res, m_config.tol, m_config.verbose);
    if (hasOverlaps && m_config.verbose) ATH_MSG_ERROR("Volume " << topPV->GetName() << " has overlaps.");
    somethingOverlapped |= hasOverlaps;
    //
    //    Make a list of PVs keyed by their LVs
    //
    std::multimap<G4LogicalVolume *, G4VPhysicalVolume *> lv2pvMap;
    G4LogicalVolume *lv = topPV->GetLogicalVolume();
    unsigned int nDaughters = lv->GetNoDaughters();
    for (unsigned int i = 0; i < nDaughters; ++i) {
      G4VPhysicalVolume *daughterPV = lv->GetDaughter(i);
      G4LogicalVolume *daughterLV = daughterPV->GetLogicalVolume();
      lv2pvMap.insert(std::pair<G4LogicalVolume *, G4VPhysicalVolume *>(daughterLV, daughterPV));
    }
 
    for (std::multimap<G4LogicalVolume *, G4VPhysicalVolume *>::iterator mapEl = lv2pvMap.begin(); mapEl != lv2pvMap.end(); ) {
      //
      //  The first of each LV gets checked externally and internally (recursively).
      //
      G4VPhysicalVolume *daughterPV = mapEl->second;
      hasOverlaps = recursiveCheck(daughterPV);
      somethingOverlapped |= hasOverlaps;
      if (hasOverlaps && m_config.verbose) ATH_MSG_ERROR("Volume " << daughterPV->GetName() << " has overlaps.");
      //
      //  Subsequent PVs with the same LV get only external checks
      //
      std::pair <std::multimap<G4LogicalVolume *, G4VPhysicalVolume *>::iterator,
    std::multimap<G4LogicalVolume *, G4VPhysicalVolume *>::iterator> range = lv2pvMap.equal_range(mapEl->first);
      ++mapEl;
      //
      // Sometimes there are huge numbers of the same item, in the same juxtaposition with nearby elements.
      // Takes too long to check them all, and in typical geometries it is a waste of time.
      // So we skip some, controlled by m_targetMaxCopiesToCheck
      //
      int n = std::distance(range.first, range.second); // n is total number in this group.
      int checkEveryNth = int(n / m_config.targetMaxCopiesToCheck + 0.5);
      if (checkEveryNth <= 0) checkEveryNth = 1;
      for (int i = 1; i < n; ++i) { // "i = 0" already done
    if (i % checkEveryNth == 0) {
      hasOverlaps = mapEl->second->CheckOverlaps(m_config.res, m_config.tol, m_config.verbose);
      somethingOverlapped |= hasOverlaps;
      if (hasOverlaps && m_config.verbose) ATH_MSG_ERROR("Volume " << mapEl->second->GetLogicalVolume()->GetName() << " has overlaps.");
    }
    ++mapEl;
      }
    }
    return somethingOverlapped;
  }

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

m_config

Config G4UA::VolumeDebugger::m_config

private

configuration data

Definition at line 62 of file VolumeDebugger.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

---

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

• VolumeDebugger.h
• VolumeDebugger.cxx