DetectorImp.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_DETECTORIMP_H
#define DD4HEP_DETECTORIMP_H
 
//==========================================================================
//
// Please note:
//
// This header file is purely DD4hep internal. It should never be used
// independently outside DetectorImp.cpp and certain DD4hep specific plugins.
// This header files is only publicly present to satisfy the ROOT interpreter
// when loading precompiled dictionary libraries.
//
//==========================================================================
#if !defined(DD4HEP_MUST_USE_DETECTORIMP_H) && !defined(G__ROOT)
#error "DetectorImp.h is a dd4hep internal header. Never use it in a depending compilation unit!"
#endif
 
// Framework include files
#include <DD4hep/DetectorData.h>
#include <DD4hep/DetectorLoad.h>
#include <TNamed.h>
 
// Forward declarations
class TGeoManager;
 
// C/C++ include files
#include <map>
 
namespace dd4hep {
 
  namespace detail  {
    class OpticalSurfaceManagerObject;
  }
  
 
  class DetectorImp: public TNamed, public Detector, public DetectorData, public DetectorLoad  {
  protected:
    typedef std::map<std::string, std::vector<DetElement> > DetectorTypeMap;
 
    mutable STD_Conditions m_std_conditions;
    
    DetectorTypeMap   m_detectorTypes;
 
    DetectorBuildType m_buildType;
 
    detail::OpticalSurfaceManagerObject* m_surfaceManager {nullptr};   
 
  private:
    DetectorImp(DetectorImp&& copy) = delete;
 
    DetectorImp(const DetectorImp& copy) = delete;
 
    DetectorImp& operator=(const DetectorImp& copy) = delete;
 
    void mapDetectorTypes();
 
    Int_t saveObject(const char *name=0, Int_t option=0, Int_t bufsize=0) const;
  public:
 
    void imp_loadVolumeManager();
    
    DetectorImp();
 
    DetectorImp(const std::string& name);
 
    virtual ~DetectorImp();
 
    virtual State state()  const  override   {
      return m_state;
    }
 
    virtual DetectorBuildType buildType() const   override;
 
    virtual void fromCompact(const std::string& fname, DetectorBuildType type = BUILD_DEFAULT)   override {
      fromXML(fname, type);
    }
 
    virtual void fromXML(const std::string& fname, DetectorBuildType type = BUILD_DEFAULT)  override;
 
    virtual void fromXML(const std::string& fname,
                         xml::UriReader* entity_resolver,
                         DetectorBuildType type = BUILD_DEFAULT)  override;
 
    virtual void dump() const  override;
 
    virtual long apply(const char* factory, int argc, char** argv)  const  override;
 
    virtual void init()  override;
 
    virtual void endDocument(bool close_geometry)  override;
 
    virtual void* addUserExtension(unsigned long long int key, ExtensionEntry* entry)  override;
 
    virtual void* removeUserExtension(unsigned long long int key, bool destroy=true)  override;
 
    virtual void* userExtension(unsigned long long int key, bool alert=true) const  override;
 
    virtual Handle<NamedObject> getRefChild(const HandleMap& e, const std::string& name, bool throw_if_not = true) const;
 
    virtual void   declareParent(const std::string& detector_name, const DetElement& parent)  override;
 
    virtual Volume pickMotherVolume(const DetElement& sd) const  override;
 
    virtual TGeoManager& manager() const   override  {
      return *m_manager;
    }
    Properties& properties() const  override {
      return *(Properties*)&m_properties;
    }
    virtual Material air() const  override {
      return m_materialAir;
    }
    virtual Material vacuum() const  override {
      return m_materialVacuum;
    }
    virtual VisAttr invisible() const  override {
      return m_invisibleVis;
    }
    virtual DetElement world() const  override {
      return m_world;
    }
    virtual DetElement trackers() const  override {
      return m_trackers;
    }
    virtual Volume worldVolume() const  override {
      return m_worldVol;
    }
    virtual Volume parallelWorldVolume() const override  {
      return m_parallelWorldVol;
    }
    virtual Volume trackingVolume() const  override {
      return m_trackingVol;
    }
    virtual void setTrackingVolume(Volume vol)  override {
      m_trackingVol = vol;
    }
    virtual VolumeManager volumeManager() const  override {
      return m_volManager;
    }
    virtual OpticalSurfaceManager surfaceManager()  const  override  {
      return OpticalSurfaceManager(m_surfaceManager);
    }
 
    virtual OverlayedField field() const  override {
      return m_field;
    }
 
    virtual const STD_Conditions& stdConditions()  const  override;
    virtual void setStdConditions(double temp, double pressure) override;
    virtual void setStdConditions(const std::string& type)  override;
 
    virtual Header header() const  override {
      return m_header;
    }
    virtual void setHeader(Header h)  override {
      m_header = h;
    }
 
    virtual std::string constantAsString(const std::string& name) const  override;
 
    virtual long constantAsLong(const std::string& name) const  override;
 
    virtual double constantAsDouble(const std::string& name) const  override;
 
    virtual Constant constant(const std::string& name) const  override;
 
    virtual LimitSet limitSet(const std::string& name) const  override {
      return getRefChild(m_limits, name);
    }
    virtual VisAttr visAttributes(const std::string& name) const  override {
      return getRefChild(m_display, name, false);
    }
    virtual Material material(const std::string& name) const  override;
 
    virtual Region region(const std::string& name) const  override {
      return getRefChild(m_regions, name);
    }
    virtual IDDescriptor idSpecification(const std::string& name) const  override {
      return getRefChild(m_idDict, name);
    }
    virtual Readout readout(const std::string& name) const  override {
      return getRefChild(m_readouts, name);
    }
    virtual DetElement detector(const std::string& name) const  override;
    //{      return getRefChild(m_detectors, name);    }
    virtual SensitiveDetector sensitiveDetector(const std::string& name) const  override {
      return getRefChild(m_sensitive, name, false);
    }
    virtual CartesianField field(const std::string& name) const  override {
      return getRefChild(m_fields, name, false);
    }
 
    virtual const HandleMap& constants() const  override {
      return m_define;
    }
    virtual const HandleMap& visAttributes() const  override {
      return m_display;
    }
    virtual const HandleMap& limitsets() const  override {
      return m_limits;
    }
    virtual const HandleMap& regions() const  override {
      return m_regions;
    }
    virtual const HandleMap& readouts() const  override {
      return m_readouts;
    }
    virtual const HandleMap& detectors() const  override {
      return m_detectors;
    }
    virtual const HandleMap& sensitiveDetectors() const  override {
      return m_sensitive;
    }
    virtual const HandleMap& fields() const  override {
      return m_fields;
    }
    virtual const HandleMap& idSpecifications() const  override {
      return m_idDict;
    }
 
 
    virtual const std::vector<DetElement>& detectors(const std::string& type, bool throw_exc) const override;
 
    virtual std::vector<DetElement> detectors(const std::string& type1,
                                              const std::string& type2,
                                              const std::string& type3="",
                                              const std::string& type4="",
                                              const std::string& type5="" )  override;
 
    virtual std::vector<std::string> detectorTypes() const  override;
 
    virtual std::vector<DetElement> detectors(unsigned int includeFlag, 
                                              unsigned int excludeFlag=0 ) const   override;
 
 
#define __R  return *this
    virtual Detector& add(Constant x)  override {
      return addConstant(x);
    }
    virtual Detector& add(LimitSet x)  override {
      return addLimitSet(x);
    }
    virtual Detector& add(Region x)  override {
      return addRegion(x);
    }
    virtual Detector& add(VisAttr x)  override {
      return addVisAttribute(x);
    }
    virtual Detector& add(IDDescriptor x)  override {
      return addIDSpecification(x);
    }
    virtual Detector& add(Readout x)  override {
      return addReadout(x);
    }
    virtual Detector& add(SensitiveDetector x)  override {
      return addSensitiveDetector(x);
    }
    virtual Detector& add(DetElement x)  override {
      return addDetector(x);
    }
    virtual Detector& add(CartesianField x)  override {
      return addField(x);
    }
 
    virtual Detector& addConstant(const Handle<NamedObject>& x)  override;
 
    virtual Detector& addLimitSet(const Handle<NamedObject>& x)  override {
      m_limits.append(x);
      __R;
    }
    virtual Detector& addRegion(const Handle<NamedObject>& x)  override {
      m_regions.append(x);
      __R;
    }
    virtual Detector& addIDSpecification(const Handle<NamedObject>& x)  override {
      m_idDict.append(x);
      __R;
    }
    virtual Detector& addReadout(const Handle<NamedObject>& x)  override {
      m_readouts.append(x);
      __R;
    }
    virtual Detector& addVisAttribute(const Handle<NamedObject>& x)  override {
      m_display.append(x);
      __R;
    }
    virtual Detector& addSensitiveDetector(const Handle<NamedObject>& x)  override {
      m_sensitive.append(x);
      __R;
    }
    virtual Detector& addDetector(const Handle<NamedObject>& x)  override;
    virtual Detector& addField(const Handle<NamedObject>& x)  override;
#undef __R
    virtual Int_t       Write(const char *name=0, Int_t option=0, Int_t bufsize=0)  override  {
      return saveObject(name, option, bufsize);
    }
    virtual Int_t       Write(const char *name=0, Int_t option=0, Int_t bufsize=0) const override  {
      return saveObject(name, option, bufsize);
    }
 
    ClassDefOverride(DetectorImp,100);
    
  };
} /* End namespace dd4hep   */
 
#if defined(__CINT__) || defined(__MAKECINT__) || defined(__CLING__) || defined(__ROOTCLING__)
#pragma link C++ class dd4hep::DetectorImp+;
#endif
#endif // DD4HEP_DETECTORIMP_H