DetectorChecksum.h

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     : M.Frank
//
//==========================================================================
#ifndef DDCORE_SRC_PLUGINS_DETECTORCHECKSUM_H
#define DDCORE_SRC_PLUGINS_DETECTORCHECKSUM_H
 
#include <DD4hep/Detector.h>
#include <DD4hep/GeoHandler.h>
#include <DD4hep/DD4hepUnits.h>
 
#include <sstream>
 
 
namespace dd4hep {
 
  namespace detail {
 
 
    class DetectorChecksum: public GeoHandler {
    public:
      using hash_t       = uint64_t;
      struct entry_t   {
        hash_t      hash { 0 };
        std::string data { "" };
      };
      using ElementMap       = std::map<Atom,              entry_t>;
      using MaterialMap      = std::map<Material,          entry_t>;
      using LimitMap         = std::map<LimitSet,          entry_t>;
      using PlacementMap     = std::map<PlacedVolume,      entry_t>;
      using RegionMap        = std::map<Region,            entry_t>;
      using SensDetMap       = std::map<SensitiveDetector, entry_t>;
      using VolumeMap        = std::map<Volume,            entry_t>;
      using IdSpecMap        = std::map<IDDescriptor,      entry_t>;
      using SegmentationMap  = std::map<Segmentation,      entry_t>;
      using VisMap           = std::map<VisAttr,           entry_t>;
      using AlignmentMap     = std::map<Alignment,         entry_t>;
      using SolidMap         = std::map<Solid,             entry_t>;
      using FieldMap         = std::map<OverlayedField,    entry_t>;
      using TrafoMap         = std::map<const TGeoMatrix*, entry_t>;
      using MapOfDetElements = std::map<DetElement,        entry_t>;
 
 
      class GeometryInfo: public GeoHandler::GeometryInfo {
      public:
        ElementMap       mapOfElements;
        MaterialMap      mapOfMaterials;
        SolidMap         mapOfSolids;
        VolumeMap        mapOfVolumes;
        PlacementMap     mapOfPlacements;
        RegionMap        mapOfRegions;
        VisMap           mapOfVis;
        LimitMap         mapOfLimits;
        IdSpecMap        mapOfIdSpecs;
        SegmentationMap  mapOfSegmentations;
        SensDetMap       mapOfSensDets;
        TrafoMap         mapOfPositions;
        TrafoMap         mapOfRotations;
        FieldMap         mapOfFields;
        AlignmentMap     mapOfAlignments;
        MapOfDetElements mapOfDetElements;
        entry_t  header;
 
        GeometryInfo() = default;
      };
 
      Detector& m_detDesc;
      GeometryInfo* m_dataPtr;
      mutable std::stringstream debug_hash;
 
      std::string  m_len_unit_nam = "mm";
      std::string  m_ang_unit_nam = "deg";
      std::string  m_ene_unit_nam = "GeV";
      std::string  m_densunit_nam = "g/cm3";
      std::string  m_atomunit_nam = "g/mole";
      double       m_len_unit = dd4hep::mm;
      double       m_ang_unit = dd4hep::deg;
      double       m_ene_unit = dd4hep::GeV;
      double       m_densunit = dd4hep::g/dd4hep::cm3;
      double       m_atomunit = dd4hep::g/dd4hep::mole;
 
      double       m_len__def = dd4hep::mm;
      double       m_ang__def = dd4hep::deg;
      double       m_ene__def = dd4hep::GeV;
      double       m_dens_def = dd4hep::g/dd4hep::cm3;
      double       m_atom_def = dd4hep::g/dd4hep::mole;
 
      entry_t      empty_entry { 0UL, "" };
      std::string  newline = "";
 
      mutable int precision     { 6 };
      int hash_meshes           { 0 };
      int hash_readout          { 0 };
      int max_level             { 1 };
      int have_hash_strings     { 0 };
      int debug                 { 4 };
      int reorder               { 1 };
      int write_files           { 1 };
 
      GeometryInfo& data() const {
        return *m_dataPtr;
      }
      void configure();
      void hash_debug(const std::string& prefix, const entry_t& str, int flag=0)  const;
      entry_t make_entry(std::stringstream& log)  const;
      std::stringstream logger()   const;
 
      DetectorChecksum(Detector& description);
 
      virtual ~DetectorChecksum();
 
      template <typename T> std::string refName(T handle)  const;
      template <typename T> std::string attr_name(T  handle)  const;
      void collect_det_elements(DetElement top)  const;
 
      void analyzeDetector(DetElement top);
      typedef std::vector<hash_t> hashes_t;
      void checksumPlacement(PlacedVolume pv, hashes_t& hashes, bool recursive)  const;
      void checksumDetElement(int level, DetElement det, hashes_t& hashes, bool recursive)  const;
 
      virtual const entry_t& handleHeader() const;
 
      virtual const entry_t& handleMaterial(Material medium) const;
 
      virtual const entry_t& handleElement(Atom element) const;
 
      virtual const entry_t& handleSolid(Solid solid) const;
 
      virtual const entry_t& handleVolume(Volume volume) const;
      virtual void collectVolume(Volume volume) const;
 
      virtual const entry_t& handlePlacement(PlacedVolume node) const;
 
      const entry_t& handleAlignment(Alignment alignment)  const;
 
 
      virtual const entry_t& handleRegion(Region region) const;
 
      virtual const entry_t& handleVis(VisAttr vis) const;
 
      virtual const entry_t& handleIdSpec(IDDescriptor idspec) const;
 
      virtual const entry_t& handleLimitSet(LimitSet limitset) const;
 
      virtual const entry_t& handleDetElement(DetElement det)  const;
 
      virtual const entry_t& handleSensitive(SensitiveDetector sens_det) const;
 
      virtual const entry_t& handleSegmentation(Segmentation seg) const;
 
      virtual const entry_t& handlePosition(const TGeoMatrix* trafo) const;
 
      virtual const entry_t& handleRotation(const TGeoMatrix* trafo) const;
 
      virtual const entry_t& handleField(OverlayedField field) const;
 
      const entry_t& handleProperties(Detector::Properties& prp) const;
 
      void dump_elements()   const;
      void dump_materials()   const;
      void dump_solids()   const;
      void dump_volumes()   const;
      void dump_positions()   const;
      void dump_rotations()   const;
      void dump_placements()   const;
      void dump_detelements()   const;
      void dump_iddescriptors()   const;
      void dump_segmentations()   const;
      void dump_sensitives()   const;
 
    };
  }    // End namespace xml
}      // End namespace dd4hep
#endif // DDCORE_SRC_PLUGINS_DETECTORCHECKSUM_H