Volumes.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_VOLUMES_H
#define DD4HEP_VOLUMES_H
 
// Framework include files
#include <DD4hep/Handle.h>
#include <DD4hep/Shapes.h>
#include <DD4hep/Objects.h>
#include <DD4hep/BitField64.h>
 
// C/C++ include files
#include <map>
#include <memory>
 
// ROOT include file (includes TGeoVolume + TGeoShape)
#include <TGeoNode.h>
#include <TGeoPatternFinder.h>
#include <TGeoExtension.h>
 
namespace dd4hep {
 
  class  Detector;
  class  Region;
  class  LimitSet;
  class  Material;
  class  VisAttr;
  class  DetElement;
  class  SensitiveDetector;
 
  // Forward declarations
  class  Volume;
  class  PlacedVolume;
 
 
  class  ReflectionBuilder   {
    Detector& detector;
  public:
    ReflectionBuilder(Detector& desc) : detector(desc) {}
    ~ReflectionBuilder() = default;
    void execute()  const;
  };
    
 
  class PlacedVolumeExtension : public TGeoExtension  {
  public:
    typedef std::pair<std::string, int> VolID;
 
    class VolIDs: public std::vector<VolID> {
    public:
      typedef std::vector<VolID> Base;
      VolIDs() = default;
      VolIDs(VolIDs&& copy) = default;
      VolIDs(const VolIDs& copy) = default;
      VolIDs& operator=(VolIDs&& copy)  = default;
      VolIDs& operator=(const VolIDs& c)  = default;
      std::vector<VolID>::const_iterator find(const std::string& name) const;
      std::pair<std::vector<VolID>::iterator, bool> insert(const std::string& name, int value);
      template< class InputIt>
      iterator insert(InputIt first, InputIt last)
      {  return this->Base::insert(this->Base::end(), first, last);    }
#if !defined __GNUCC__ || (defined __GNUCC__ && __GNUC__ > 5)
      template< class InputIt>
      iterator insert(std::vector<VolID>::const_iterator pos, InputIt first, InputIt last)
      {  return this->Base::insert(pos, first, last);    }
#endif
      std::string str()  const;
    };
    class Parameterisation;
 
    unsigned long magic { 0 };
    long   refCount     { 0 };
    Parameterisation* params   { nullptr };
    VolIDs volIDs;
 
  public:
    PlacedVolumeExtension();
    PlacedVolumeExtension(PlacedVolumeExtension&& copy);
    PlacedVolumeExtension(const PlacedVolumeExtension& c);
    virtual ~PlacedVolumeExtension();
    PlacedVolumeExtension& operator=(PlacedVolumeExtension&& copy)  {
      magic  = std::move(copy.magic);
      params = std::move(copy.params);
      volIDs = std::move(copy.volIDs);
      return *this;
    }
    PlacedVolumeExtension& operator=(const PlacedVolumeExtension& copy) {
      magic  = copy.magic;
      params = copy.params;
      volIDs = copy.volIDs;
      return *this;
    }
    virtual TGeoExtension *Grab()  override;
    virtual void Release() const  override;
    ClassDefOverride(PlacedVolumeExtension,200);
  };
  class PlacedVolumeFeatureExtension : public  PlacedVolumeExtension {
  public:
  public:
  };
 
 
  class PlacedVolume : public Handle<TGeoNode> {
  public:
    typedef PlacedVolumeExtension         Object;
    typedef PlacedVolumeExtension::VolIDs VolIDs;
 
 
    class Processor {
    public:
      Processor();
      virtual ~Processor();
      virtual int processPlacement(PlacedVolume pv) = 0;
    };
 
    PlacedVolume() = default;
    PlacedVolume(PlacedVolume&& e) = default;
    PlacedVolume(const PlacedVolume& e) = default;
    template <typename T> PlacedVolume(const Handle<T>& e) : Handle<TGeoNode>(e) {  }
    PlacedVolume(const TGeoNode* e) : Handle<TGeoNode>(e) {  }
    PlacedVolume& operator=(PlacedVolume&& v)  = default;
    PlacedVolume& operator=(const PlacedVolume& v)  = 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();
    }
 
    Object* data() const;
    const char* type() const;
    int copyNumber() const;
    Material material() const;
    Volume volume() const;
    Volume motherVol() const;
    std::size_t num_daughters()  const;
    PlacedVolume daughter(std::size_t which)  const;
    const TGeoMatrix& matrix()  const;
    Position position()  const;
    const PlacedVolumeExtension::VolIDs& volIDs() const;
    PlacedVolume& addPhysVolID(const std::string& name, int value);
    std::string toString() const;
  };
 
  // This needs full knowledge of the PlacedVolume class, at least for ROOT 6.28/04
  // so we place it here
 
  class PlacedVolumeExtension::Parameterisation {
  public:
    using Dimension = std::pair<Transform3D, size_t>;
    Transform3D   start    {   };
    Dimension     trafo1D  { {}, 0UL };
    Dimension     trafo2D  { {}, 0UL };
    Dimension     trafo3D  { {}, 0UL };
    unsigned long flags    { 0 };
    unsigned long refCount { 0 };
    std::vector<PlacedVolume> placements {  };
    const detail::BitFieldElement* field { nullptr };
 
  public:
    Parameterisation() = default;
    Parameterisation(Parameterisation&& copy) = default;
    Parameterisation(const Parameterisation& c) = default;
    virtual ~Parameterisation() = default;
    Parameterisation& operator=(Parameterisation&& copy) = default;
    Parameterisation& operator=(const Parameterisation& copy) = default;
    Parameterisation* addref();
    void release();
    ClassDef(Parameterisation,200);
  };
 
 
 
  class VolumeExtension : public TGeoExtension {
  public:
    unsigned long       magic      = 0;
    long                refCount   = 0;
    int                 referenced = 0;
    int                 flags      = 0;
    Region              region;
    LimitSet            limits;
    VisAttr             vis;
    Handle<NamedObject> sens_det;
    Handle<TGeoVolume>  reflected;
    TList* properties  { nullptr };
 
    virtual ~VolumeExtension();
    VolumeExtension();
    VolumeExtension(VolumeExtension&& copy) = delete;
    VolumeExtension(const VolumeExtension& copy);
    VolumeExtension& operator=(VolumeExtension&& copy) = delete;
    VolumeExtension& operator=(const VolumeExtension& copy);
    void copy(const VolumeExtension& c);
    virtual TGeoExtension *Grab()  override;
    virtual void Release() const  override;
    ClassDefOverride(VolumeExtension,200);
  };
 
 
  class Volume: public Handle<TGeoVolume> {
  public:
    typedef VolumeExtension Object;
    enum  {
      VETO_SIMU     = 1,
      VETO_RECO     = 2,
      VETO_DISPLAY  = 3,
      REFLECTED     = 10,
    };
    enum ReplicationAxis  {
      REPLICATED    = 1UL << 4,
      PARAMETERIZED = 1UL << 5,
      Undefined     = 1UL << 7,
      X_axis        = 1UL << 8,
      Y_axis        = 1UL << 9,
      Z_axis        = 1UL << 10,
      Rho_axis      = 1UL << 11,
      Phi_axis      = 1UL << 12
    };
  
  public:
    Volume() = default;
    Volume(Volume&& v) = default;
    Volume(const Volume& v) = default;
    Volume(const TGeoVolume* v) : Handle<TGeoVolume>(v) { }
    template <typename T> Volume(const Handle<T>& v) : Handle<TGeoVolume>(v) {  }
 
    Volume(const std::string& name);
    Volume(const std::string& name, const std::string& title);
 
    Volume(const std::string& name, const Solid& s, const Material& m);
 
    Volume(const std::string& name, const std::string& title, const Solid& s, const Material& m);
 
    Volume& operator=(Volume&& a)  = default;
    Volume& operator=(const Volume& a)  = 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();
    }
 
 
    static void enableCopyNumberCheck(bool value);
    
    Object* data() const;
 
    const char* type() const;
 
    Volume reflect()  const;
 
 
    Volume reflect(SensitiveDetector sd)  const;
    
    Volume& import();
 
    Volume divide(const std::string& divname, int iaxis, int ndiv, double start, double step, int numed = 0, const char* option = "");
    PlacedVolume placeVolume(const Volume& volume) const;
    PlacedVolume placeVolume(const Volume& volume, const Transform3D& tr) const;
    PlacedVolume placeVolume(const Volume& volume, const Position& pos) const;
    PlacedVolume placeVolume(const Volume& volume, const RotationZYX& rot) const;
    PlacedVolume placeVolume(const Volume& volume, const Rotation3D& rot) const;
 
    PlacedVolume placeVolume(const Volume& volume, int copy_no) const;
    PlacedVolume placeVolume(const Volume& volume, int copy_no, const Transform3D& tr) const;
    PlacedVolume placeVolume(const Volume& volume, int copy_no, const Position& pos) const;
    PlacedVolume placeVolume(const Volume& volume, int copy_no, const RotationZYX& rot) const;
    PlacedVolume placeVolume(const Volume& volume, int copy_no, const Rotation3D& rot) const;
    PlacedVolume placeVolume(const Volume& volume, TGeoMatrix* tr) const;
    PlacedVolume placeVolume(const Volume& volume, int copy_nr, TGeoMatrix* tr) const;
 
    PlacedVolume replicate(const Volume entity, ReplicationAxis axis, size_t count, double inc, double start=0e0);
 
    PlacedVolume paramVolume1D(const Transform3D& start, Volume entity, size_t count, const Transform3D& inc);
 
    PlacedVolume paramVolume1D(Volume entity, size_t count, const Transform3D& trafo);
 
    PlacedVolume paramVolume1D(Volume entity, size_t count, const Position& inc);
 
    PlacedVolume paramVolume1D(Volume entity, size_t count, const RotationZYX& inc);
 
 
    PlacedVolume paramVolume2D(Volume entity, 
                   size_t count_1, const Transform3D& inc_1,
                   size_t count_2, const Transform3D& inc_2);
 
 
    PlacedVolume paramVolume2D(const Transform3D& start,
                   Volume entity,
                   size_t count_1,
                   const Position& inc_1,
                   size_t count_2,
                   const Position& inc_2);
 
 
    PlacedVolume paramVolume2D(Volume entity,
                   size_t count_1,
                   const Position& inc_1,
                   size_t count_2,
                   const Position& inc_2);
 
 
    PlacedVolume paramVolume2D(const Transform3D& start, Volume entity, 
                   size_t count_1, const Transform3D& inc_1,
                   size_t count_2, const Transform3D& inc_2);
 
 
    PlacedVolume paramVolume3D(Volume entity, 
                   size_t count_1, const Transform3D& inc_1,
                   size_t count_2, const Transform3D& inc_2,
                   size_t count_3, const Transform3D& inc_3);
 
 
    PlacedVolume paramVolume3D(const Transform3D& start, Volume entity, 
                   size_t count_1, const Transform3D& inc_1,
                   size_t count_2, const Transform3D& inc_2,
                   size_t count_3, const Transform3D& inc_3);
 
 
    PlacedVolume paramVolume3D(Volume entity, 
                   size_t count_1, const Position& inc_1,
                   size_t count_2, const Position& inc_2,
                   size_t count_3, const Position& inc_3);
 
 
    PlacedVolume paramVolume3D(const Transform3D& start, Volume entity, 
                   size_t count_1, const Position& inc_1,
                   size_t count_2, const Position& inc_2,
                   size_t count_3, const Position& inc_3);
 
    void setFlagBit(unsigned int bit);
    bool testFlagBit(unsigned int bit)   const;
 
    bool isReflected()   const;
    
    bool isAssembly()   const;
 
    const Volume& setOption(const std::string& opt) const;
    std::string option() const;
 
    const Volume& setAttributes(const Detector& description, const std::string& region, const std::string& limits,
                                const std::string& vis) const;
 
    const Volume& setRegion(const Detector& description, const std::string& name) const;
    const Volume& setRegion(const Region& obj) const;
    Region region() const;
 
    const Volume& setLimitSet(const Detector& description, const std::string& name) const;
    const Volume& setLimitSet(const LimitSet& obj) const;
    LimitSet limitSet() const;
 
    const Volume& setVisAttributes(const VisAttr& obj) const;
    const Volume& setVisAttributes(const Detector& description, const std::string& name) const;
    VisAttr visAttributes() const;
 
    const Volume& setSensitiveDetector(const SensitiveDetector& obj) const;
    Handle<NamedObject> sensitiveDetector() const;
    bool isSensitive() const;
 
    const Volume& setSolid(const Solid& s) const;
    Solid solid() const;
    Box boundingBox() const;
 
    const Volume& setMaterial(const Material& m) const;
    Material material() const;
 
    bool hasProperties()  const;
 
    void addProperty(const std::string& nam, const std::string& val)  const;
 
    std::string getProperty(const std::string& nam, const std::string& default_val="")  const;
 
    operator TGeoVolume*() const {
      return m_element;
    }
  };
 
 
  class VolumeMulti : public Volume   {
    void verifyVolumeMulti();
 
  public:
    VolumeMulti() = default;
    VolumeMulti(const VolumeMulti& v) = default;
    VolumeMulti(TGeoVolume* v) : Volume(v)  {
      verifyVolumeMulti();
    }
    template <typename T> VolumeMulti(const Handle<T>& v) : Volume(v) {
      verifyVolumeMulti();
    }
    VolumeMulti(const std::string& name, Material material);
    VolumeMulti& operator=(const VolumeMulti& a) = default;
  };
 
 
  class Assembly: public Volume {
  public:
    Assembly() = default;
    Assembly(const Assembly& v) = default;
    template <typename T> Assembly(const Handle<T>& v) : Volume(v) {  }
    Assembly(const std::string& name);
    Assembly& operator=(const Assembly& a) = default;
  };
 
  std::string toStringMesh(PlacedVolume solid, int precision=2);
}         /* End namespace dd4hep          */
#endif // DD4HEP_VOLUMES_H