#include <DD4hep_DDG4Builder.h>

Public Member Functions
G4VPhysicalVolume *	BuildGeometry (SensitiveDetectorCatalog &)

	DDG4Builder (const cms::DDCompactView *, dd4hep::sim::Geant4GeometryMaps::VolumeMap &, bool check)

Private Attributes
bool	check_

const cms::DDCompactView *	compactView_

dd4hep::sim::Geant4GeometryMaps::VolumeMap &	map_

Detailed Description

Definition at line 23 of file DD4hep_DDG4Builder.h.

Constructor & Destructor Documentation

◆ DDG4Builder()

DDG4Builder::DDG4Builder	(	const cms::DDCompactView *	cpv,
		dd4hep::sim::Geant4GeometryMaps::VolumeMap &	lvmap,
		bool	check
	)

Definition at line 26 of file DD4hep_DDG4Builder.cc.

27 : compactView_(cpv), map_(lvmap), check_(check) {}

Member Function Documentation

◆ BuildGeometry()

G4VPhysicalVolume * DDG4Builder::BuildGeometry ( SensitiveDetectorCatalog & catalog )

Definition at line 29 of file DD4hep_DDG4Builder.cc.

                                                                                {
   G4ReflectionFactory *refFact = G4ReflectionFactory::Instance();
   refFact->SetScalePrecision(100. * refFact->GetScalePrecision());
  
   const cms::DDDetector *det = compactView_->detector();
   DetElement world = det->description()->world();
   const Detector &detector = *det->description();
  
   // GET FULL G4 GEOMETRY
   Geant4Converter g4Geo(detector);
   g4Geo.debugMaterials = false;
   Geant4GeometryInfo *geometry = g4Geo.create(world).detach();
   map_ = geometry->g4Volumes;
  
   // FIND & STORE ALL G4 LOGICAL VOLUMES DEFINED AS SENSITIVE IN CMSSW XMLS
   std::vector<std::pair<G4LogicalVolume *, const dd4hep::SpecPar *>> dd4hepVec;
   const dd4hep::SpecParRegistry &specPars = det->specpars();
   dd4hep::SpecParRefs specs;
   specPars.filter(specs, "SensitiveDetector");
   for (auto const &it : map_) {
     bool foundMatch = false;  // Stop search at first occurrence
     for (auto const &fit : specs) {
       for (auto const &pit : fit.second->paths) {
         if (dd4hep::dd::compareEqualName(dd4hep::dd::noNamespace(dd4hep::dd::realTopName(pit)),
                                          dd4hep::dd::noNamespace(it.first.name()))) {
           dd4hepVec.emplace_back(&*it.second, &*fit.second);
  
           foundMatch = true;
           break;
         }
       }
       if (foundMatch)
         break;
     }
   }
  
   // ADD ALL SELECTED G4 LOGICAL VOLUMES TO SENSITIVE DETECTORS CATALOGUE
   for (auto const &it : dd4hepVec) {
     // Sensitive detector info
     const G4String &sensitiveDetectorG4Name = it.first->GetName();
     auto sClassName = it.second->strValue("SensitiveDetector");
     auto sROUName = it.second->strValue("ReadOutName");
     // Add to catalogue
     catalog.insert({sClassName.data(), sClassName.size()}, {sROUName.data(), sROUName.size()}, sensitiveDetectorG4Name);
  
     edm::LogVerbatim("SimG4CoreApplication") << " DDG4SensitiveConverter: Sensitive " << sensitiveDetectorG4Name
                                              << " Class Name " << sClassName << " ROU Name " << sROUName;
  
     // Reflected sensors also need to be added to the senstive detectors catalogue!
     // Similar treatment here with DD4hep, as what was done for old DD.
     const G4String &sensitiveDetectorG4ReflectedName = sensitiveDetectorG4Name + "_refl";
  
     const G4LogicalVolumeStore *const allG4LogicalVolumes = G4LogicalVolumeStore::GetInstance();
     const bool hasG4ReflectedVolume =
         std::find_if(
             allG4LogicalVolumes->begin(), allG4LogicalVolumes->end(), [&](G4LogicalVolume *const aG4LogicalVolume) {
               return (aG4LogicalVolume->GetName() == sensitiveDetectorG4ReflectedName);
             }) != allG4LogicalVolumes->end();
     if (hasG4ReflectedVolume) {
       // Add reflected sensitive detector to catalogue
       catalog.insert(
           {sClassName.data(), sClassName.size()}, {sROUName.data(), sROUName.size()}, sensitiveDetectorG4ReflectedName);
  
       edm::LogVerbatim("SimG4CoreApplication")
           << " DDG4SensitiveConverter: Sensitive " << sensitiveDetectorG4ReflectedName << " Class Name " << sClassName
           << " ROU Name " << sROUName;
     }
   }
  
   return geometry->world();
 }