DDVolumeProcessor.h

Go to the documentation of this file.

#ifndef DETECTOR_DESCRIPTION_DD_VOLUME_PROCESSOR_H
#define DETECTOR_DESCRIPTION_DD_VOLUME_PROCESSOR_H
 
#include "DD4hep/VolumeProcessor.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "DetectorDescription/DDCMS/interface/DDSpecParRegistry.h"
 
#include <string>
#include <string_view>
#include <vector>
 
namespace cms {
 
  class DDVolumeProcessor : public dd4hep::PlacedVolumeProcessor {
  public:
    using Volume = dd4hep::Volume;
    using PlacedVolume = dd4hep::PlacedVolume;
    using PlacedVolumeProcessor = dd4hep::PlacedVolumeProcessor;
 
    DDVolumeProcessor() = default;
    ~DDVolumeProcessor() override = default;
 
    std::string_view stripNamespace(std::string_view v) {
      auto first = v.find_first_of(":");
      v.remove_prefix(std::min(first + 1, v.size()));
      return v;
    }
 
    std::string_view stripCopyNo(std::string_view v) {
      auto found = v.find_last_of("_");
      if (found != v.npos) {
        v.remove_suffix(v.size() - found);
      }
      return v;
    }
 
    std::vector<std::string_view> split(std::string_view str, const char* delims) {
      std::vector<std::string_view> ret;
 
      std::string_view::size_type start = 0;
      auto pos = str.find_first_of(delims, start);
      while (pos != std::string_view::npos) {
        if (pos != start) {
          ret.emplace_back(str.substr(start, pos - start));
        }
        start = pos + 1;
        pos = str.find_first_of(delims, start);
      }
      if (start < str.length())
        ret.emplace_back(str.substr(start, str.length() - start));
      return ret;
    }
 
    bool compare(std::string_view s1, std::string_view s2) {
      if (s1 == s2)
        return true;
      edm::LogVerbatim("Geometry") << '\"' << s1 << "\" does not match \"" << s2 << "\"\n";
      return false;
    }
 
    int process(PlacedVolume pv, int level, bool recursive) override {
      m_volumes.emplace_back(pv.name());
      int ret = PlacedVolumeProcessor::process(pv, level, recursive);
      m_volumes.pop_back();
      return ret;
    }
 
    int operator()(PlacedVolume pv, int level) override {
      Volume vol = pv.volume();
      edm::LogVerbatim("Geometry").log([&level, &vol, this](auto& log) {
        log << "\nHierarchical level:" << level << "   Placement:";
        for (const auto& i : m_volumes)
          log << "/" << i << ", \n";
        log << "\n\tMaterial:" << vol.material().name() << "\tSolid:   " << vol.solid().name() << "\n";
      });
      ++m_count;
      return 1;
    }
    int count() const { return m_count; }
 
  private:
    int m_count = 0;
    std::vector<std::string_view> m_volumes;
  };
}  // namespace cms
 
#endif