CheckOverlap Class Reference

#include <CheckOverlap.h>

Inheritance diagram for CheckOverlap:

Public Member Functions
	CheckOverlap (edm::ParameterSet const &p)
	~CheckOverlap () override
Public Member Functions inherited from SimWatcher
const SimWatcher &	operator= (const SimWatcher &)=delete
	SimWatcher ()
	SimWatcher (const SimWatcher &)=delete
virtual	~SimWatcher ()
Public Member Functions inherited from Observer< const BeginOfRun * >
	Observer ()
void	slotForUpdate (const BeginOfRun * iT)
virtual	~Observer ()

Private Member Functions
void	checkHierarchyLeafPVLV (G4LogicalVolume *lv, unsigned int leafDepth)
void	checkPV (G4VPhysicalVolume *pv, unsigned int leafDepth)
void	dumpLV (G4LogicalVolume *lv, std::string str)
G4VPhysicalVolume *	getTopPV ()
void	update (const BeginOfRun *run) override
	This routine will be called when the appropriate signal arrives. More...

Private Attributes
std::vector< std::string >	nodeNames
int	nPoints
std::vector< G4LogicalVolume * >	topLV

Additional Inherited Members

Detailed Description

Definition at line 18 of file CheckOverlap.h.

Constructor & Destructor Documentation

CheckOverlap()

CheckOverlap::CheckOverlap

(

edm::ParameterSet const &

p

)

Definition at line 20 of file CheckOverlap.cc.

                                                   : topLV(0) {
  std::vector<std::string> defNames;
  nodeNames = p.getUntrackedParameter<std::vector<std::string> >("NodeNames", defNames);
  nPoints = p.getUntrackedParameter<int>("Resolution", 1000);
  G4cout << "CheckOverlap:: initialised with " << nodeNames.size() << " Node Names and Resolution " << nPoints
         << " the names are:" << G4endl;
  for (unsigned int ii = 0; ii < nodeNames.size(); ii++)
    G4cout << "CheckOverlap:: Node[" << ii << "] : " << nodeNames[ii] << G4endl;
}

References ecalTB2006H4_GenSimDigiReco_cfg::G4cout, cuy::ii, nodeNames, nPoints, and AlCaHLTBitMon_ParallelJobs::p.

~CheckOverlap()

CheckOverlap::~CheckOverlap ( )

override

Definition at line 30 of file CheckOverlap.cc.

{}

Member Function Documentation

checkHierarchyLeafPVLV()

void CheckOverlap::checkHierarchyLeafPVLV ( G4LogicalVolume *  lv, unsigned int  leafDepth  )

private

Definition at line 64 of file CheckOverlap.cc.

                                                                                     {
  //----- Get LV daughters from list of PV daughters
  mmlvpv lvpvDaughters;
  std::set<G4LogicalVolume*> lvDaughters;
  int NoDaughters = lv->GetNoDaughters();
  while ((NoDaughters--) > 0) {
    G4VPhysicalVolume* pvD = lv->GetDaughter(NoDaughters);
    lvpvDaughters.insert(mmlvpv::value_type(pvD->GetLogicalVolume(), pvD));
    lvDaughters.insert(pvD->GetLogicalVolume());
  }
 
  std::set<G4LogicalVolume*>::const_iterator scite;
  mmlvpv::const_iterator mmcite;
 
  //----- Check daughters of LV
  for (scite = lvDaughters.begin(); scite != lvDaughters.end(); scite++) {
    std::pair<mmlvpv::iterator, mmlvpv::iterator> mmER = lvpvDaughters.equal_range(*scite);
    //----- Check daughters PV of this LV
    for (mmcite = mmER.first; mmcite != mmER.second; mmcite++)
      checkPV((*mmcite).second, leafDepth + 1);
    //----- Check daughters LV
    checkHierarchyLeafPVLV(*scite, leafDepth + 1);
  }
}

References checkPV().

Referenced by update().

checkPV()

void CheckOverlap::checkPV ( G4VPhysicalVolume *  pv, unsigned int  leafDepth  )

private

Definition at line 89 of file CheckOverlap.cc.

                                                                        {
  //----- PV info
#ifndef G4V7
  std::string mother = "DDDWorld";
  if (pv->GetMotherLogical())
    mother = pv->GetMotherLogical()->GetName();
  if (!pv->IsReplicated()) {
    G4PVPlacement* pvplace = dynamic_cast<G4PVPlacement*>(pv);
    G4bool ok = pvplace->CheckOverlaps(nPoints);
    G4cout << "Placed PV " << pvplace->GetName() << " Number " << pvplace->GetCopyNo() << " in mother " << mother
           << " at depth " << leafDepth << " Status " << ok << G4endl;
    if (ok) {
      if (pv->GetRotation() == nullptr) {
        G4cout << "Translation " << pv->GetTranslation() << " and with no rotation" << G4endl;
      } else {
        G4cout << "Translation " << pv->GetTranslation() << " and with rotation " << *(pv->GetRotation()) << G4endl;
      }
      G4LogicalVolume* lv = pv->GetLogicalVolume();
      dumpLV(lv, "Self");
      if (pv->GetMotherLogical()) {
        lv = pv->GetMotherLogical();
        dumpLV(lv, "Mother");
      }
    }
  } else {
    if (pv->GetParameterisation() != nullptr) {
      G4PVParameterised* pvparam = dynamic_cast<G4PVParameterised*>(pv);
      G4bool ok = pvparam->CheckOverlaps(nPoints);
      G4cout << "Parametrized PV " << pvparam->GetName() << " in mother " << mother << " at depth " << leafDepth
             << " Status " << ok << G4endl;
    }
  }
#endif
}

References dumpLV(), ecalTB2006H4_GenSimDigiReco_cfg::G4cout, nPoints, convertSQLiteXML::ok, MetAnalyzer::pv(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by checkHierarchyLeafPVLV().

dumpLV()

void CheckOverlap::dumpLV ( G4LogicalVolume *  lv, std::string  str  )

private

Definition at line 128 of file CheckOverlap.cc.

                                                            {
  G4cout << "Dump of " << str << " Logical Volume " << lv->GetName() << "  Solid: " << lv->GetSolid()->GetName()
         << "  Material: " << lv->GetMaterial()->GetName() << G4endl;
  G4cout << *(lv->GetSolid()) << G4endl;
}

References ecalTB2006H4_GenSimDigiReco_cfg::G4cout, and str.

Referenced by checkPV().

getTopPV()

G4VPhysicalVolume * CheckOverlap::getTopPV ( )

private

Definition at line 124 of file CheckOverlap.cc.

                                          {
  return G4TransportationManager::GetTransportationManager()->GetNavigatorForTracking()->GetWorldVolume();
}

Referenced by update().

update()

void CheckOverlap::update ( const BeginOfRun *  )

overrideprivatevirtual

This routine will be called when the appropriate signal arrives.

Implements Observer< const BeginOfRun * >.

Definition at line 32 of file CheckOverlap.cc.

                                               {
  if (!nodeNames.empty()) {
    const G4LogicalVolumeStore* lvs = G4LogicalVolumeStore::GetInstance();
    G4cout << "CheckOverlap::update nLV= " << lvs->size() << G4endl;
    std::vector<G4LogicalVolume*>::const_iterator lvcite;
    int i = 0;
    for (lvcite = lvs->begin(); lvcite != lvs->end(); lvcite++) {
      for (unsigned int ii = 0; ii < nodeNames.size(); ii++) {
        if ((*lvcite)->GetName() == (G4String)(nodeNames[ii])) {
          topLV.push_back((*lvcite));
          break;
        }
      }
      G4cout << "Name of node " << (++i) << " : " << (*lvcite)->GetName() << G4endl;
      if (topLV.size() == nodeNames.size())
        break;
    }
  } else {
    G4VPhysicalVolume* theTopPV = getTopPV();
    topLV.push_back(theTopPV->GetLogicalVolume());
  }
 
  if (topLV.empty()) {
    G4cout << "No Top LV Found" << G4endl;
  } else {
    for (unsigned int ii = 0; ii < topLV.size(); ++ii) {
      G4cout << "Top LV Name " << topLV[ii]->GetName() << G4endl;
      checkHierarchyLeafPVLV(topLV[ii], 0);
    }
  }
}

References checkHierarchyLeafPVLV(), ecalTB2006H4_GenSimDigiReco_cfg::G4cout, getTopPV(), mps_fire::i, cuy::ii, nodeNames, and topLV.

Referenced by MatrixUtil.Matrix::__setitem__(), MatrixUtil.Steps::__setitem__(), and MatrixUtil.Steps::overwrite().

Member Data Documentation

nodeNames

std::vector<std::string> CheckOverlap::nodeNames

private

Definition at line 31 of file CheckOverlap.h.

Referenced by CheckOverlap(), and update().

nPoints

int CheckOverlap::nPoints

private

Definition at line 32 of file CheckOverlap.h.

Referenced by CheckOverlap(), and checkPV().

topLV

std::vector<G4LogicalVolume *> CheckOverlap::topLV

private

Definition at line 33 of file CheckOverlap.h.

Referenced by update().