Detector.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation for LCD
//--------------------------------------------------------------------------
// 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

// 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"

// C/C++ include files
#include <map>
#include <typeinfo>

namespace DD4hep {

  namespace Geometry {

    // Forward declarations
    class LCDD;
    class DetElementObject;
    class SensitiveDetectorObject;


    class SensitiveDetector: public Handle<SensitiveDetectorObject> {
    public:
      typedef void (*destruct_t)(void*);
      typedef SensitiveDetectorObject Object;
      typedef Handle<SensitiveDetectorObject> RefObject;
    protected:

      template <typename T> static void _delete(void* ptr) {
        delete (T*) (ptr);
      }

      void* i_addExtension(void* ptr, const std::type_info& info, void (*destruct)(void*));

      void* i_extension(const std::type_info& info) const;

    public:

      SensitiveDetector() : RefObject() {     }

      SensitiveDetector(Object* obj_pointer) : RefObject(obj_pointer) {      }

      SensitiveDetector(const RefObject& sd) : RefObject(sd) {      }

      SensitiveDetector(const SensitiveDetector& sd) = default;

      template <typename Q> SensitiveDetector(const Handle<Q>& e) : RefObject(e) { }

      SensitiveDetector(const std::string& name, const std::string& type = "sensitive");

      SensitiveDetector& operator=(const SensitiveDetector& sd)  = default;

      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;

      SensitiveDetector& setEnergyCutoff(double value);

      double energyCutoff() const;

      SensitiveDetector& setRegion(Region reg);

      Region region() const;

      SensitiveDetector& setLimitSet(LimitSet limits);

      LimitSet limits() const;

      template <typename IFACE, typename CONCRETE> IFACE* addExtension(CONCRETE* c) {
        return (IFACE*) i_addExtension(dynamic_cast<IFACE*>(c), typeid(IFACE), _delete<IFACE>);
      }

      template <typename IFACE> IFACE* extension() const {
        return (IFACE*) i_extension(typeid(IFACE));
      }
    };


    class DetElement: public Handle<DetElementObject>  {
    public:

      class Processor {
      public:
        Processor();
        virtual ~Processor();
        virtual int processElement(DetElement detector) = 0;
      };

      typedef DetElementObject         Object;
      typedef Handle<DetElementObject> RefObject;
      typedef DetElement               Parent;
      typedef Alignments::Alignment    Alignment;

      typedef void* (*copy_t)(const void*, DetElement);
      typedef void (*destruct_t)(void*);

      typedef std::map<std::string, DetElement> Children;
      typedef std::map<const std::type_info*, void*> Extensions;

      enum CopyParameters {
        COPY_NONE = 0, COPY_PLACEMENT = 1 << 0, COPY_PARENT = 1 << 1, COPY_ALIGNMENT = 1 << 2, 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 T> static void _delete(void* ptr) {
        delete (T*) (ptr);
      }
      template <typename T> static void* _copy(const void* ptr, DetElement elt) {
        return new T(*(dynamic_cast<const T*>((T*) ptr)), elt);
      }

      void* i_addExtension(void* ptr, const std::type_info& info, copy_t ctor, destruct_t dtor) const;
      void* i_extension(const std::type_info& info) const;
      void i_addUpdateCall(unsigned int callback_type, const Callback& callback)  const;

    public:

      DetElement() : RefObject() {  }

      DetElement(Object* object_ptr) : RefObject(object_ptr) { }

      DetElement(Object* data, const std::string& name, const std::string& type);

      template <typename Q> DetElement(const Handle<Q>& e) : RefObject(e) {}

      DetElement(const DetElement& e) = default;

#ifdef __MAKECINT__
      DetElement(const Ref_t& e)
        : RefObject(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);

      Object& _data() const {
        return object<Object>();
      }

      bool operator <(const DetElement e) const {
        return ptr() < e.ptr();
      }

      bool operator ==(const DetElement e) const {
        return ptr() == e.ptr();
      }

      DetElement& operator=(const DetElement& e) = default;

      DetElement clone(const std::string& new_name) const;

      DetElement clone(const std::string& new_name, int new_id) const;

      template <typename IFACE, typename CONCRETE> IFACE* addExtension(CONCRETE* c) const {
        CallbackSequence::checkTypes(typeid(IFACE), typeid(CONCRETE), dynamic_cast<IFACE*>(c));
        return (IFACE*) i_addExtension(dynamic_cast<IFACE*>(c), typeid(IFACE), _copy<CONCRETE>, _delete<IFACE>);
      }
      template <typename IFACE> IFACE* extension() const {
        return (IFACE*) i_extension(typeid(IFACE));
      }
      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 LCDD& lcdd, const Volume& volume, const std::string& region, const std::string& limits,
                                const std::string& vis);

      DetElement& setVisAttributes(const LCDD& lcdd, const std::string& name, const Volume& volume);
      DetElement& setRegion(const LCDD& lcdd, const std::string& name, const Volume& volume);
      DetElement& setLimitSet(const LCDD& lcdd, const std::string& name, const Volume& volume);

      Volume volume() const;

      PlacedVolume placement() 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 parent() const;
      DetElement world()  const;

      bool hasConditions() const;
      bool hasAlignments() const;

      Alignment nominal() const;
      Alignment survey() const;

      // Deprecated functions to be removed soon:

      //DetElement& setReference(DetElement reference);

      const TGeoHMatrix& worldTransformation() const;
      const TGeoHMatrix& parentTransformation() const;
      //const TGeoHMatrix& referenceTransformation() const;

      bool localToWorld(const Position& local, Position& global) const;
      bool localToParent(const Position& local, Position& parent) const;
      //bool localToReference(const Position& local, Position& reference) const;

      bool worldToLocal(const Position& global, Position& local) const;
      bool parentToLocal(const Position& parent, Position& local) const;
      //bool referenceToLocal(const Position& reference, Position& local) const;
    };

  } /* End namespace Geometry      */
} /* End namespace DD4hep        */

#include "DD4hep/AlignmentData.h"

#endif    /* DD4HEP_DETECTOR_H      */