Geant4RegexSensitivesConstruction.cpp

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation 
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
//  \author Markus Frank
//  \date   2015-11-09
//
//==========================================================================
 
// Framework include files
#include <DDG4/Geant4DetectorConstruction.h>
 
// C/C++ include files
#include <set>
#include <regex>
 
namespace dd4hep {
 
  namespace sim {
 
 
    class Geant4RegexSensitivesConstruction : public Geant4DetectorConstruction   {
    public:
      std::string detector_name;
      std::vector<std::string> regex_values;
      std::size_t collect_volumes(std::set<Volume>&  volumes,
                                  PlacedVolume       pv,
                                  const std::string& path,
                                  const std::vector<std::regex>& matches);
    public:
      Geant4RegexSensitivesConstruction(Geant4Context* ctxt, const std::string& nam);
      virtual ~Geant4RegexSensitivesConstruction();
      void constructSensitives(Geant4DetectorConstructionContext* ctxt);
    };
  }    // End namespace sim
}      // End namespace dd4hep
 
 
// Framework include files
#include <DD4hep/InstanceCount.h>
#include <DD4hep/Printout.h>
#include <DD4hep/Plugins.h>
#include <DD4hep/Detector.h>
#include <DD4hep/DetectorTools.h>
 
#include <DDG4/Geant4Mapping.h>
#include <DDG4/Geant4Kernel.h>
#include <DDG4/Factories.h>
 
// ROOT include files
#include <TTimeStamp.h>
#include <TGeoManager.h>
// Geant4 include files
#include <G4PVPlacement.hh>
#include <G4VSensitiveDetector.hh>
 
using namespace dd4hep::sim;
 
DECLARE_GEANT4ACTION(Geant4RegexSensitivesConstruction)
 
Geant4RegexSensitivesConstruction::Geant4RegexSensitivesConstruction(Geant4Context* ctxt, const std::string& nam)
: Geant4DetectorConstruction(ctxt,nam)
{
  declareProperty("Detector", detector_name);
  declareProperty("Match",    regex_values);
  InstanceCount::increment(this);
}
 
Geant4RegexSensitivesConstruction::~Geant4RegexSensitivesConstruction() {
  InstanceCount::decrement(this);
}
 
std::size_t
Geant4RegexSensitivesConstruction::collect_volumes(std::set<Volume>&  volumes,
                                                   PlacedVolume       pv,
                                                   const std::string& path,
                                                   const std::vector<std::regex>& matches)
{
  std::size_t count = 0;
  // Try to minimize a bit the number of regex matches.
  if ( volumes.find(pv.volume()) == volumes.end() )  {
    if( !path.empty() )  {
      for( const auto& match : matches )  {
        std::smatch sm;
        bool stat = std::regex_search(path, sm, match);
        if( stat )  {
          volumes.insert(pv.volume());
          ++count;
          break;
        }
      }
    }
    // Now recurse down the daughters
    for( int i=0, num = pv->GetNdaughters(); i < num; ++i )  {
      PlacedVolume daughter = pv->GetDaughter(i);
      std::string  daughter_path = path + "/" + daughter.name();
      count += this->collect_volumes(volumes, daughter, daughter_path, matches);
    }
  }
  return count;
}
 
void Geant4RegexSensitivesConstruction::constructSensitives(Geant4DetectorConstructionContext* ctxt)   {
  Geant4GeometryInfo* g4info = Geant4Mapping::instance().ptr();
  const Geant4Kernel& kernel = context()->kernel();
  const auto&         types  = kernel.sensitiveDetectorTypes();
  const std::string&  dflt   = kernel.defaultSensitiveDetectorType();
  const char*         det    = detector_name.c_str();
  
  DetElement de = detail::tools::findElement(ctxt->description, detector_name);
  if( !de.isValid() )  {
    except("Failed to locate subdetector DetElement %s to manage Geant4 energy deposits.", det);
  }
  SensitiveDetector sd = ctxt->description.sensitiveDetector(detector_name);
  if( !sd.isValid() )  {
    except("Failed to locate sensitive detector %s to manage Geant4 energy deposits.", det);
  }
  std::string nam  = sd.name();
  auto        iter = types.find(nam);
  std::string typ  = (iter != types.end()) ? (*iter).second : dflt;
  G4VSensitiveDetector* g4sd = this->createSensitiveDetector(typ, nam);
 
  std::set<Volume> volumes;
  int flags = std::regex_constants::icase | std::regex_constants::ECMAScript;
  std::vector<std::regex> expressions;
  for( const auto& val : regex_values )  {
    std::regex e(val, (std::regex_constants::syntax_option_type)flags);
    expressions.emplace_back(e);
  }
  TTimeStamp start;
  info("%s Starting to scan volume....", det);
  std::size_t num_nodes = this->collect_volumes(volumes, de.placement(), de.placementPath(), expressions);
  for( const auto& vol : volumes )  {
    G4LogicalVolume* g4vol = g4info->g4Volumes[vol];
    if( !g4vol )  {
      except("+++ Failed to access G4LogicalVolume for SD %s of type %s", nam.c_str(), typ.c_str());
    }
    debug("%s Assign sensitive detector [%s] to volume: %s.",
          nam.c_str(), typ.c_str(), vol.name());
    ctxt->setSensitiveDetector(g4vol, g4sd);
  }
  TTimeStamp stop;
  info("%s Handled %ld nodes with %ld sensitive volume type(s). Total of %7.3f seconds.",
       det, num_nodes, volumes.size(), stop.AsDouble()-start.AsDouble() );
}