Detector.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_DETECTOR_H
#define DD4HEP_DETECTOR_H
 
#include <DD4hep/Version.h>
 
// Framework includes
#include <DD4hep/Handle.h>
#include <DD4hep/Fields.h>
#include <DD4hep/Objects.h>
#include <DD4hep/Shapes.h>
#include <DD4hep/Volumes.h>
#include <DD4hep/Readout.h>
#include <DD4hep/DetElement.h>
#include <DD4hep/NamedObject.h>
#include <DD4hep/Segmentations.h>
#include <DD4hep/VolumeManager.h>
#include <DD4hep/OpticalSurfaceManager.h>
#include <DD4hep/ExtensionEntry.h>
#include <DD4hep/BuildType.h>
 
// C/C++ include files
#include <map>
#include <vector>
#include <string>
#include <memory>
 
// Forward declarations
class TGeoManager;
 
namespace dd4hep {
 
  std::string versionString();
  
  // Foward declarations
  class NamedObject;
 
  namespace xml {
    class UriReader;
  }
 
  class STD_Conditions   {
  public:
    enum  Conventions {
      STP           = 1<<0, // Standard temperature and pressure (273.15 Kelvin, 1 ATM)
      NTP           = 1<<1, // Normal   temperature and pressure (293.15 Kelvin, 1 ATM)
      USER          = 1<<2, // Explicitly set before materials are defined (recommended)
      USER_SET      = 1<<3,
      USER_NOTIFIED = 1<<4
    };
  public:
    double pressure;
    double temperature;
    long   convention;
    bool is_NTP()  const           {  return (convention&NTP)  != 0; }
    bool is_STP()  const           {  return (convention&STP)  != 0; }
    bool is_user_defined()  const  {  return (convention&USER) != 0; }
  };
  
 
  class Detector {
  public:
    typedef std::map<std::string, Handle<NamedObject> > HandleMap;
    typedef std::map<std::string, std::string>          PropertyValues;
    typedef std::map<std::string, PropertyValues>       Properties;
 
    enum State   {
      NOT_READY = 1<<0,
      LOADING   = 1<<1,
      READY     = 1<<2
    };
    
    virtual ~Detector() = default;
 
    virtual DetectorBuildType buildType() const = 0;
    virtual void init() = 0;
    virtual void endDocument(bool close_geometry = true) = 0;
    virtual void endDocument(const char* option) = 0;
 
    virtual State state()  const = 0;
    virtual TGeoManager& manager() const = 0;
    virtual Properties& properties() const = 0;
    virtual Material air() const = 0;
    virtual Material vacuum() const = 0;
    virtual VisAttr invisible() const = 0;
 
    virtual DetElement world() const = 0;
    virtual DetElement trackers() const = 0;
 
    virtual Volume worldVolume() const = 0;
    virtual Volume parallelWorldVolume() const = 0;
    virtual Volume trackingVolume() const = 0;
    virtual void setTrackingVolume(Volume vol) = 0;
 
    virtual VolumeManager volumeManager() const = 0;
 
    virtual OpticalSurfaceManager surfaceManager()  const = 0;
 
    virtual const STD_Conditions& stdConditions()  const = 0;
    virtual void setStdConditions(double temp, double pressure) = 0;
    virtual void setStdConditions(const std::string& type) = 0;
    
    
    virtual Header header() const = 0;
    virtual void setHeader(Header h) = 0;
 
    virtual OverlayedField field() const = 0;
 
    virtual const HandleMap& constants() const = 0;
    virtual const HandleMap& regions() const = 0;
    virtual const HandleMap& detectors() const = 0;
    virtual const HandleMap& sensitiveDetectors() const = 0;
    virtual const HandleMap& readouts() const = 0;
    virtual const HandleMap& visAttributes() const = 0;
    virtual const HandleMap& limitsets() const = 0;
    virtual const HandleMap& fields() const = 0;
    virtual const HandleMap& idSpecifications() const = 0;
 
#ifndef __MAKECINT__
 
 
    virtual const std::vector<DetElement>& detectors(const std::string& type,
                                                     bool throw_exc=false) const = 0;
 
    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="" ) = 0;
 
    virtual std::vector<std::string> detectorTypes() const = 0;
 
 
    virtual std::vector<DetElement> detectors(unsigned int includeFlag, 
                                              unsigned int excludeFlag=0 ) const = 0 ;
#endif
 
 
    virtual void   declareParent(const std::string& detector_name, const DetElement& det) = 0;
 
 
    virtual Volume pickMotherVolume(const DetElement& sd) const = 0;
 
    virtual std::string constantAsString(const std::string& name) const = 0;
    virtual long constantAsLong(const std::string& name) const = 0;
    virtual double constantAsDouble(const std::string& name) const = 0;
 
    virtual Constant constant(const std::string& name) const = 0;
    template <class T> T constant(const std::string& name) const;
 
    virtual Material material(const std::string& name) const = 0;
    virtual IDDescriptor idSpecification(const std::string& name) const = 0;
    virtual Region region(const std::string& name) const = 0;
    virtual VisAttr visAttributes(const std::string& name) const = 0;
    virtual LimitSet limitSet(const std::string& name) const = 0;
    virtual Readout readout(const std::string& name) const = 0;
    virtual SensitiveDetector sensitiveDetector(const std::string& name) const = 0;
    virtual CartesianField field(const std::string& name) const = 0;
    virtual DetElement detector(const std::string& name) const = 0;
 
    virtual Detector& add(Constant constant) = 0;
    virtual Detector& add(VisAttr attr) = 0;
    virtual Detector& add(LimitSet limitset) = 0;
    virtual Detector& add(Region region) = 0;
    virtual Detector& add(IDDescriptor spec) = 0;
    virtual Detector& add(Readout readout) = 0;
    virtual Detector& add(SensitiveDetector entry) = 0;
    virtual Detector& add(DetElement detector) = 0;
    virtual Detector& add(CartesianField entry) = 0;
 
    virtual Detector& addConstant(const Handle<NamedObject>& element) = 0;
    virtual Detector& addVisAttribute(const Handle<NamedObject>& element) = 0;
    virtual Detector& addLimitSet(const Handle<NamedObject>& limset) = 0;
    virtual Detector& addIDSpecification(const Handle<NamedObject>& element) = 0;
    virtual Detector& addRegion(const Handle<NamedObject>& region) = 0;
    virtual Detector& addReadout(const Handle<NamedObject>& readout) = 0;
    virtual Detector& addSensitiveDetector(const Handle<NamedObject>& element) = 0;
    virtual Detector& addDetector(const Handle<NamedObject>& detector) = 0;
    virtual Detector& addField(const Handle<NamedObject>& field) = 0;
    
    virtual void fromCompact(const std::string& fname,
                             DetectorBuildType type = BUILD_DEFAULT) = 0;
    virtual void fromXML    (const std::string& fname,
                             DetectorBuildType type = BUILD_DEFAULT) = 0;
    virtual void fromXML    (const std::string& fname,
                             xml::UriReader* entity_resolver,
                             DetectorBuildType type = BUILD_DEFAULT) = 0;
 
    virtual void dump() const = 0;
    virtual long apply(const char* factory, int argc, char** argv)  const = 0;
 
    virtual void* addUserExtension(unsigned long long int key, ExtensionEntry* entry) = 0;
 
 
    virtual void* removeUserExtension(unsigned long long int key, bool destroy) = 0;
 
    virtual void* userExtension(unsigned long long int key, bool alert=true) const = 0;
 
    template <typename IFACE, typename CONCRETE> IFACE* addExtension(CONCRETE* c)  {
      return (IFACE*) addUserExtension(detail::typeHash64<IFACE>(),
                                       new detail::DeleteExtension<IFACE,CONCRETE>(c));
    }
 
    template <class IFACE> IFACE* removeExtension(bool destroy=true)  {
      return (IFACE*) removeUserExtension(detail::typeHash64<IFACE>(),destroy);
    }
 
    template <class IFACE> IFACE* extension(bool alert=true) const {
      return (IFACE*) userExtension(detail::typeHash64<IFACE>(),alert);
    }
 
    static Detector& getInstance(const std::string& name="default");
    static void destroyInstance(const std::string& name="default");
    static std::unique_ptr<Detector> make_unique(const std::string& name);
 
  };
 
  /*
   *   The following are convenience implementations to access constants by type.
   *   I do not think this violates the interface approach, but it is so much
   *   more intuitiv to say constant<int>(name) than constantAsInt(name).
   */
#ifndef __CINT__
  template <> inline short Detector::constant<short>(const std::string& name) const {
    return (short) constantAsLong(name);
  }
 
  template <> inline unsigned short Detector::constant<unsigned short>(const std::string& name) const {
    return (unsigned short) constantAsLong(name);
  }
 
  template <> inline int Detector::constant<int>(const std::string& name) const {
    return (int) constantAsLong(name);
  }
 
  template <> inline unsigned int Detector::constant<unsigned int>(const std::string& name) const {
    return (unsigned int) constantAsLong(name);
  }
 
  template <> inline long Detector::constant<long>(const std::string& name) const {
    return constantAsLong(name);
  }
 
  template <> inline unsigned long Detector::constant<unsigned long>(const std::string& name) const {
    return (unsigned long) constantAsLong(name);
  }
 
  template <> inline float Detector::constant<float>(const std::string& name) const {
    return (float) constantAsDouble(name);
  }
 
  template <> inline double Detector::constant<double>(const std::string& name) const {
    return constantAsDouble(name);
  }
 
  template <> inline std::string Detector::constant<std::string>(const std::string& name) const {
    return constantAsString(name);
  }
#endif
}         /* End namespace dd4hep           */
#endif // DD4HEP_DETECTOR_H