DetectorData.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 DD4HEP_DETECTORDATA_H
#define DD4HEP_DETECTORDATA_H
 
// Framework includes
#include <DD4hep/Printout.h>
#include <DD4hep/Detector.h>
#include <DD4hep/ObjectExtensions.h>
#include <DD4hep/detail/VolumeManagerInterna.h>
 
// C/C++ include files
#include <stdexcept>
 
namespace dd4hep {
 
  // Foward declarations
  class NamedObject;
 
 
  class DetectorData  {
 
  public:
 
    struct InvalidObjectError: public std::runtime_error {
      InvalidObjectError(const std::string& msg)
        : std::runtime_error("dd4hep: " + msg) {
      }
    };
 
 
    class ObjectHandleMap: public Detector::HandleMap {
    public:
      std::string name;
    public:
      ObjectHandleMap() = default;
      ObjectHandleMap(const std::string& name);
      void append(const Handle<NamedObject>& e, bool throw_on_doubles = true) {
        if (e.isValid()) {
          std::string n = e.name();
          std::pair<iterator, bool> r = this->emplace(n, e.ptr());
          if (!throw_on_doubles || r.second) {
            if (not r.second) {
              printout(WARNING,"Detector",
                       "+++ Object '%s' is already defined. New value will be ignored",
                       n.c_str());
              delete e.ptr();
            }
            return;
          }
          throw InvalidObjectError("Attempt to add an already existing object:" + std::string(e.name()) + ".");
        }
        throw InvalidObjectError("Attempt to add an invalid object.");
      }
      template <typename T> void append(const Handle<NamedObject>& e, bool throw_on_doubles = true) {
        T* obj = dynamic_cast<T*>(e.ptr());
        if (obj) {
          this->append(e, throw_on_doubles);
          return;
        }
        throw InvalidObjectError("Attempt to add an object, which is of the wrong type.");
      }
    };
 
  protected:
  public:
    TGeoManager*             m_manager;
    ObjectHandleMap          m_idDict;
    ObjectHandleMap          m_limits;
    ObjectHandleMap          m_regions;
    ObjectHandleMap          m_readouts;
    ObjectHandleMap          m_sensitive;
    ObjectHandleMap          m_detectors;
    ObjectHandleMap          m_display;
    ObjectHandleMap          m_fields;
    // GDML fields
    ObjectHandleMap          m_define;
 
    std::map<std::string,DetElement> m_detectorParents;
 
    DetElement               m_world;
    DetElement               m_trackers;
    Volume                   m_worldVol;
    Volume                   m_parallelWorldVol;
    Volume                   m_trackingVol;
 
    Material                 m_materialAir;
    Material                 m_materialVacuum;
    VisAttr                  m_invisibleVis;
    OverlayedField           m_field;
    Header                   m_header;
    Detector::Properties     m_properties;
    DetectorBuildType        m_buildType;
 
    ObjectExtensions         m_extensions;
    VolumeManager            m_volManager;
 
    Detector::State          m_state = Detector::NOT_READY;
    
    bool                     m_inhibitConstants;
 
  protected:
  public:
    DetectorData();
    virtual ~DetectorData();
    DetectorData(DetectorData&& copy) = delete;
    DetectorData(const DetectorData& copy) = delete;
    //DetectorData& operator=(const DetectorData& copy) = delete;
  public:
    static void patchRootStreamer(TClass* cl);
    static void unpatchRootStreamer(TClass* cl);
 
    void destroyData(bool destroy_mgr=true);
    void clearData();
    void adoptData(DetectorData& source, bool CLR=true);
 
    TGeoManager& manager() const                          {    return *m_manager;         }
    dd4hep::Material air() const                          {    return m_materialAir;      }
    dd4hep::Material vacuum() const                       {    return m_materialVacuum;   }
    dd4hep::VisAttr invisible() const                     {    return m_invisibleVis;     }
    dd4hep::DetElement world() const                      {    return m_world;            }
    dd4hep::DetElement trackers() const                   {    return m_trackers;         }
    dd4hep::Volume worldVolume() const                    {    return m_worldVol;         }
    dd4hep::Volume parallelWorldVolume() const            {    return m_parallelWorldVol; }
    dd4hep::Volume trackingVolume() const                 {    return m_trackingVol;      }
    dd4hep::VolumeManager volumeManager() const           {    return m_volManager;       }
    dd4hep::OverlayedField field() const                  {    return m_field;            }
    dd4hep::Header header() const                         {    return m_header;           }
    const Detector::HandleMap& constants() const          {    return m_define;           }
    const Detector::HandleMap& visAttributes() const      {    return m_display;          }
    const Detector::HandleMap& limitsets() const          {    return m_limits;           }
    const Detector::HandleMap& regions() const            {    return m_regions;          }
    const Detector::HandleMap& readouts() const           {    return m_readouts;         }
    const Detector::HandleMap& detectors() const          {    return m_detectors;        }
    const Detector::HandleMap& sensitiveDetectors() const {    return m_sensitive;        }
    const Detector::HandleMap& fields() const             {    return m_fields;           }
    const Detector::HandleMap& idSpecifications() const   {    return m_idDict;           }
  };
 
  inline DetectorData::ObjectHandleMap::ObjectHandleMap(const std::string& nam)
    : name(nam)
  {
  }
}         /* End namespace dd4hep         */
#endif // DD4HEP_DETECTORDATA_H