DetElement.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_DETELEMENT_H
#define DD4HEP_DETELEMENT_H
 
// Framework include files
#include <DD4hep/Handle.h>
#include <DD4hep/Callback.h>
#include <DD4hep/Objects.h>
#include <DD4hep/Volumes.h>
#include <DD4hep/Readout.h>
#include <DD4hep/Alignments.h>
#include <DD4hep/Segmentations.h>
#include <DD4hep/ObjectExtensions.h>
 
// C/C++ include files
#include <map>
 
namespace dd4hep {
 
  // Forward declarations
  class Detector;
  class DetElementObject;
  class SensitiveDetectorObject;
 
 
  class SensitiveDetector: public Handle<SensitiveDetectorObject> {
  public:
 
    SensitiveDetector() : Handle<SensitiveDetectorObject>() {     }
 
    SensitiveDetector(Object* obj_pointer)
      : Handle<SensitiveDetectorObject>(obj_pointer) {      }
 
    SensitiveDetector(Handle<SensitiveDetectorObject>&& sd)
      : Handle<SensitiveDetectorObject>(sd) {      }
 
    SensitiveDetector(const Handle<SensitiveDetectorObject>& sd)
      : Handle<SensitiveDetectorObject>(sd) {      }
 
    SensitiveDetector(SensitiveDetector&& sd) = default;
 
    SensitiveDetector(const SensitiveDetector& sd) = default;
 
    template <typename Q> SensitiveDetector(const Handle<Q>& e)
      : Handle<SensitiveDetectorObject>(e) { }
 
    SensitiveDetector(const std::string& name, const std::string& type = "sensitive");
 
    SensitiveDetector& operator=(SensitiveDetector&& sd)  = default;
 
    SensitiveDetector& operator=(const SensitiveDetector& sd)  = default;
 
    template <typename T> bool operator ==(const Handle<T>& e) const {
      return ptr() == e.ptr();
    }
    template <typename T> bool operator !=(const Handle<T>& e) const {
      return ptr() != e.ptr();
    }
 
    std::string type() const;
 
    SensitiveDetector& setType(const std::string& typ);
 
    SensitiveDetector& setVerbose(bool value);
 
    bool verbose() const;
 
    SensitiveDetector& setCombineHits(bool value);
 
    bool combineHits() const;
 
    SensitiveDetector& setHitsCollection(const std::string& spec);
 
    const std::string& hitsCollection() const;
 
    SensitiveDetector& setReadout(Readout readout);
 
    Readout readout() const;
 
    IDDescriptor idSpec() const;
 
    SensitiveDetector& setEnergyCutoff(double value);
 
    double energyCutoff() const;
 
    SensitiveDetector& setRegion(Region reg);
 
    Region region() const;
 
    SensitiveDetector& setLimitSet(LimitSet limits);
 
    LimitSet limits() const;
 
    void* addExtension(unsigned long long int key, ExtensionEntry* entry)  const;
 
    void* extension(unsigned long long int key) const;
 
    void* extension(unsigned long long int key, bool alert) const;
 
    template <typename IFACE, typename CONCRETE> IFACE* addExtension(CONCRETE* c)  const {
      return (IFACE*) this->addExtension(detail::typeHash64<IFACE>(),
                                         new detail::DeleteExtension<IFACE,CONCRETE>(c));
    }
 
    template <typename IFACE> IFACE* extension() const {
      return (IFACE*) this->extension(detail::typeHash64<IFACE>());
    }
  };
 
 
  class DetElement: public Handle<DetElementObject>  {
  public:
 
    class Processor {
    public:
      Processor();
      virtual ~Processor();
      virtual int processElement(DetElement detector) = 0;
    };
 
    typedef std::map<std::string, DetElement> Children;
 
    enum CopyParameters {
      COPY_NONE           = 0,
      COPY_PLACEMENT      = 1 << 0,
      COPY_PARENT         = 1 << 1,
      COPY_ALIGNMENT      = 1 << 2,
      PROPAGATE_PARENT_ID = 1 << 3,
      LAST
    };
 
    enum UpdateParam {
      CONDITIONS_CHANGED  = 1<<0,
      PLACEMENT_CHANGED   = 1<<1,
      SOMETHING_CHANGED   = 1<<2,
      PLACEMENT_ELEMENT   = 1<<20,
      PLACEMENT_HIGHEST   = 1<<21,
      PLACEMENT_DETECTOR  = 1<<22,
      PLACEMENT_NONE
    };
 
    void check(bool condition, const std::string& msg) const;
 
  protected:
 
 
    template <typename Q, typename T> class DetElementExtension : public ExtensionEntry  {
    protected:
      T* ptr = 0;
      mutable Q* iface = 0;  
    public:
      DetElementExtension() = delete;
      DetElementExtension(T* p) : ptr(p) {  iface = dynamic_cast<Q*>(p); }
      DetElementExtension(const DetElementExtension& copy) = default;
      DetElementExtension& operator=(const DetElementExtension& copy) = default;
      virtual ~DetElementExtension() = default;
      T* copy(DetElement de)  const                 { return new T(*ptr,de);   }
      virtual void  destruct()  const override      { delete ptr;              }
      virtual void* object()  const override
      { return iface ? iface : (iface=dynamic_cast<Q*>(ptr));                  }
      virtual void* copy(void* det)  const override
      { return copy(DetElement((Object*)det));                                 }
      virtual ExtensionEntry* clone(void* det)  const  override
      {  return new DetElementExtension<Q,T>((T*)this->copy(det));             }
      virtual unsigned long long int hash64()  const override
      {  return detail::typeHash64<Q>();                                       }
    };
 
    void i_addUpdateCall(unsigned int callback_type, const Callback& callback)  const;
 
  public:
 
    DetElement() = default;
 
    DetElement(DetElement&& e) = default;
 
    DetElement(const DetElement& e) = default;
 
    DetElement(Object* obj) : Handle<DetElementObject>(obj) { }
 
    DetElement(Object* obj, const std::string& name, const std::string& type);
 
    template <typename Q> DetElement(const Handle<Q>& e) : Handle<DetElementObject>(e) {}
 
    DetElement(NamedObject* obj) : Handle<DetElementObject>(obj) { }
 
#ifdef __MAKECINT__
    DetElement(const Ref_t& e) : Handle<DetElementObject>(e) {  }
#endif
    DetElement(const std::string& name, const std::string& type, int id);
 
    DetElement(const std::string& name, int id);
 
    DetElement(DetElement parent, const std::string& name, int id);
 
    DetElement& operator=(DetElement&& sd)  = default;
    DetElement& operator=(const DetElement& e) = default;
 
    Object& _data() const {
      return object<Object>();
    }
 
    bool operator <(const DetElement e) const {
      return ptr() < e.ptr();
    }
    template <typename T> bool operator ==(const Handle<T>& e) const {
      return ptr() == e.ptr();
    }
    template <typename T> bool operator !=(const Handle<T>& e) const {
      return ptr() != e.ptr();
    }
 
    DetElement clone(int flag) const;
 
    DetElement clone(const std::string& new_name) const;
 
    DetElement clone(const std::string& new_name, int new_id) const;
 
    std::pair<DetElement,Volume> reflect(const std::string& new_name) const;
 
    std::pair<DetElement,Volume> reflect(const std::string& new_name, int new_id) const;
    std::pair<DetElement,Volume> reflect(const std::string& new_name, int new_id, SensitiveDetector sd) const;
 
    void* addExtension(ExtensionEntry* entry) const;
 
    void* extension(unsigned long long int key, bool alert) const;
 
    template <typename IFACE, typename CONCRETE> IFACE* addExtension(CONCRETE* c) const {
      CallbackSequence::checkTypes(typeid(IFACE), typeid(CONCRETE), dynamic_cast<IFACE*>(c));
      return (IFACE*) this->addExtension(new DetElementExtension<IFACE,CONCRETE>(c));
    }
    template <typename IFACE> IFACE* extension() const {
      return (IFACE*) this->extension(detail::typeHash64<IFACE>(),true);
    }
    template <typename IFACE> IFACE* extension(bool alert) const {
      return (IFACE*) this->extension(detail::typeHash64<IFACE>(),alert);
    }
    template <typename Q, typename T>
    void callAtUpdate(unsigned int typ, Q* pointer,
                      void (T::*pmf)(unsigned long typ, DetElement& det, void* opt_par)) const
    {
      CallbackSequence::checkTypes(typeid(T), typeid(Q), dynamic_cast<T*>(pointer));
      i_addUpdateCall(typ, Callback(pointer).make(pmf));
    }
    void removeAtUpdate(unsigned int type, void* pointer) const;
 
    int id() const;
    DetElement& setCombineHits(bool value, SensitiveDetector& sens);
    bool combineHits() const;
 
    std::string type() const;
    DetElement&  setType(const std::string& typ);
 
    // Return flag word encoding detector types ( ideally use dd4hep::DetType for decoding )
    unsigned int typeFlag() const;
 
    DetElement&  setTypeFlag(unsigned int types);
 
    unsigned int key()  const;
    int level()  const;
    const std::string& path() const;
    const std::string& placementPath() const;
 
    DetElement& setAttributes(const Detector& description,
                              const Volume& volume,
                              const std::string& region,
                              const std::string& limits,
                              const std::string& vis);
 
    DetElement& setVisAttributes(const Detector& description, const std::string& name, const Volume& volume);
    DetElement& setRegion(const Detector& description, const std::string& name, const Volume& volume);
    DetElement& setLimitSet(const Detector& description, const std::string& name, const Volume& volume);
 
    Volume volume() const;
    Solid solid() const;
 
 
    PlacedVolume placement() const;
 
    PlacedVolume idealPlacement() const;
    DetElement&  setPlacement(const PlacedVolume& volume);
    VolumeID     volumeID() const;
 
    DetElement&  add(DetElement sub_element);
    const Children& children() const;
    DetElement child(const std::string& name) const;
    DetElement child(const std::string& child_name, bool throw_if_not_found) const;
    DetElement parent() const;
    DetElement world()  const;
 
    Alignment nominal() const;
    Alignment survey() const;
  };
} /* End namespace dd4hep        */
 
#include <DD4hep/AlignmentData.h>
 
#endif // DD4HEP_DETELEMENT_H