G4CheckOverlap.cc

Go to the documentation of this file.

#include "SimG4Core/Geometry/interface/G4CheckOverlap.h"

#include "FWCore/MessageLogger/interface/MessageLogger.h"

#include "G4GDMLParser.hh"
#include "G4GeomTestVolume.hh"
#include "G4LogicalVolume.hh"
#include "G4LogicalVolumeStore.hh"
#include "G4PhysicalVolumeStore.hh"
#include "G4Region.hh"
#include "G4RegionStore.hh"
#include "G4SystemOfUnits.hh"
#include "G4VPhysicalVolume.hh"
#include "globals.hh"

#include <string>

G4CheckOverlap::G4CheckOverlap(const edm::ParameterSet &p) {
  std::vector<std::string> nodeNames = p.getParameter<std::vector<std::string>>("NodeNames");
  std::string PVname = p.getParameter<std::string>("PVname");
  std::string LVname = p.getParameter<std::string>("LVname");
  double tolerance = p.getUntrackedParameter<double>("Tolerance", 0.0) * CLHEP::mm;
  int nPoints = p.getUntrackedParameter<int>("Resolution", 10000);
  bool verbose = p.getUntrackedParameter<bool>("Verbose", true);
  bool regionFlag = p.getUntrackedParameter<bool>("RegionFlag", true);
  bool gdmlFlag = p.getUntrackedParameter<bool>("gdmlFlag", false);
  int nPrints = p.getUntrackedParameter<int>("ErrorThreshold", 1);
  int level = p.getUntrackedParameter<int>("Level", 0);
  int depth = p.getUntrackedParameter<int>("Depth", -1);

  const G4RegionStore *regStore = G4RegionStore::GetInstance();

  G4LogicalVolume *lv;
  const G4PhysicalVolumeStore *pvs = G4PhysicalVolumeStore::GetInstance();
  const G4LogicalVolumeStore *lvs = G4LogicalVolumeStore::GetInstance();
  unsigned int numPV = pvs->size();
  unsigned int numLV = lvs->size();
  unsigned int nn = nodeNames.size();

  std::vector<G4String> savedgdml;

  G4cout << "G4OverlapCheck is initialised with " << nodeNames.size() << " nodes; "
         << " nPoints= " << nPoints << "; tolerance= " << tolerance / mm << " mm; verbose: " << verbose << "\n"
         << "               RegionFlag: " << regionFlag << "  PVname: " << PVname << "  LVname: " << LVname << "\n"
         << "               Nlv= " << numLV << "   Npv= " << numPV << G4endl;

  if (0 < nn) {
    for (unsigned int ii = 0; ii < nn; ++ii) {
      if (nodeNames[ii].empty() || "world" == nodeNames[ii] || "World" == nodeNames[ii]) {
        nodeNames[ii] = "DDDWorld";
        G4cout << "### Check overlaps for DDDWorld " << G4endl;
        G4VPhysicalVolume *pv = pvs->GetVolume("DDDWorld");
        G4GeomTestVolume test(pv, tolerance, nPoints, verbose);
        test.SetErrorsThreshold(nPrints);
        test.TestRecursiveOverlap(level, depth);
      } else if (regionFlag) {
        G4cout << "---------------------------------------------------------------" << G4endl;
        G4cout << "### Check overlaps for G4Region Node[" << ii << "] : " << nodeNames[ii] << G4endl;
        G4Region *reg = regStore->GetRegion((G4String)nodeNames[ii]);
        if (!reg) {
          G4cout << "### NO G4Region found - EXIT" << G4endl;
          return;
        }
        std::vector<G4LogicalVolume *>::iterator rootLVItr = reg->GetRootLogicalVolumeIterator();
        unsigned int numRootLV = reg->GetNumberOfRootVolumes();
        G4cout << "      " << numRootLV << " Root Logical Volumes in this region" << G4endl;

        for (unsigned int iLV = 0; iLV < numRootLV; ++iLV, ++rootLVItr) {
          // Cover each root logical volume in this region
          lv = *rootLVItr;
          G4cout << "### Check overlaps for G4LogicalVolume " << lv->GetName() << G4endl;
          for (unsigned int i = 0; i < numPV; ++i) {
            if (((*pvs)[i])->GetLogicalVolume() == lv) {
              G4String pvname = ((*pvs)[i])->GetName();
              G4bool isNew = true;
              for (unsigned int k = 0; k < savedgdml.size(); ++k) {
                if (pvname == savedgdml[k]) {
                  isNew = false;
                  break;
                }
              }
              if (!isNew) {
                G4cout << "### Check overlaps for PhysVolume  " << pvname << " is skipted because was already done"
                       << G4endl;
                continue;
              }
              savedgdml.push_back(pvname);
              G4cout << "### Check overlaps for PhysVolume  " << pvname << G4endl;
              // gdml dump only for 1 volume
              if (gdmlFlag) {
                G4GDMLParser gdml;
                gdml.Write(pvname + ".gdml", (*pvs)[i], true);
              }
              G4GeomTestVolume test(((*pvs)[i]), tolerance, nPoints, verbose);
              test.SetErrorsThreshold(nPrints);
              test.TestRecursiveOverlap(level, depth);
            }
          }
        }

      } else {
        G4cout << "### Check overlaps for PhysVolume Node[" << ii << "] : " << nodeNames[ii] << G4endl;
        G4VPhysicalVolume *pv = pvs->GetVolume((G4String)nodeNames[ii]);
        G4GeomTestVolume test(pv, tolerance, nPoints, verbose);
        test.SetErrorsThreshold(nPrints);
        test.TestRecursiveOverlap(level, depth);
      }
    }
  }
  if (!PVname.empty()) {
    G4cout << "----------- List of PhysVolumes by name -----------------" << G4endl;
    for (unsigned int i = 0; i < numPV; ++i) {
      if (PVname == ((*pvs)[i])->GetName()) {
        G4cout << " ##### PhysVolume " << PVname << " [" << ((*pvs)[i])->GetCopyNo()
               << "]  LV: " << ((*pvs)[i])->GetLogicalVolume()->GetName()
               << " Mother LV: " << ((*pvs)[i])->GetMotherLogical()->GetName()
               << " Region: " << ((*pvs)[i])->GetLogicalVolume()->GetRegion()->GetName() << G4endl;
        G4cout << "       Translation: " << ((*pvs)[i])->GetObjectTranslation() << G4endl;
        G4cout << "       Rotation:    " << ((*pvs)[i])->GetObjectRotationValue() << G4endl;
        if (gdmlFlag) {
          G4GDMLParser gdml;
          gdml.Write(PVname + ".gdml", (*pvs)[i], true);
        }
      }
    }
  }
  if (!LVname.empty()) {
    G4cout << "---------- List of Logical Volumes by name ------------------" << G4endl;
    for (unsigned int i = 0; i < numLV; ++i) {
      if (LVname == ((*lvs)[i])->GetName()) {
        G4int np = ((*lvs)[i])->GetNoDaughters();
        G4cout << " ##### LogVolume " << LVname << "  " << np << " daughters"
               << " Region: " << ((*lvs)[i])->GetRegion()->GetName() << G4endl;
        G4cout << *(((*lvs)[i])->GetSolid()) << G4endl;
        for (G4int j = 0; j < np; ++j) {
          G4VPhysicalVolume *pv = ((*lvs)[i])->GetDaughter(j);
          if (pv) {
            G4cout << "   PV: " << pv->GetName() << " [" << pv->GetCopyNo() << "]"
                   << " type: " << pv->VolumeType() << "  multiplicity: " << pv->GetMultiplicity()
                   << " LV: " << pv->GetLogicalVolume()->GetName() << G4endl;
            G4cout << "       Translation: " << pv->GetObjectTranslation() << G4endl;
            G4cout << "       Rotation:    " << pv->GetObjectRotationValue() << G4endl;
            G4cout << *(pv->GetLogicalVolume()->GetSolid()) << G4endl;
          }
        }
      }
    }
  }
  G4cout << "---------------- End of overlap checks ---------------------" << G4endl;
}

G4CheckOverlap::~G4CheckOverlap() {}