Volumes.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_GEOMETRY_VOLUMES_H
#define DD4HEP_GEOMETRY_VOLUMES_H

// Framework include files
#include "DD4hep/Handle.h"
#include "DD4hep/Shapes.h"
#include "DD4hep/Objects.h"

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

// ROOT include file (includes TGeoVolume + TGeoShape)
#include "TGeoNode.h"
#include "TGeoPatternFinder.h"

#if ROOT_VERSION_CODE > ROOT_VERSION(5,34,9)
// Recent ROOT versions
#include "TGeoExtension.h"

#else
// Older ROOT version
#define DD4HEP_EMULATE_TGEOEXTENSIONS
class TGeoExtension : public TObject  {
public:
  virtual ~TGeoExtension() {}
  virtual TGeoExtension *Grab() = 0;
  virtual void Release() const = 0;
};
#endif

namespace DD4hep {

  namespace Geometry {

    // Forward declarations
    class  LCDD;
    class  Region;
    class  LimitSet;
    class  Material;
    class  VisAttr;
    class  Volume;
    class  DetElement;
    class  PlacedVolume;
    class  SensitiveDetector;


    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() : std::vector<VolID>() {}
        VolIDs(const VolIDs& c) : std::vector<VolID>(c) {}
        ~VolIDs() {}
        VolIDs& operator=(const VolIDs& c) {
          if ( &c != this ) this->std::vector<VolID>::operator=(c);
          return *this;
        }
        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);
      };
      unsigned long magic;
      long   refCount;
      VolIDs volIDs;
      PlacedVolumeExtension();
      PlacedVolumeExtension(const PlacedVolumeExtension& c);
      virtual ~PlacedVolumeExtension();
      PlacedVolumeExtension& operator=(const PlacedVolumeExtension& c) {
        magic = c.magic;
        volIDs = c.volIDs;
        return *this;
      }
      virtual TGeoExtension *Grab();
      virtual void Release() const;
      ClassDef(PlacedVolumeExtension,1);
    };


    class PlacedVolume : public Handle<TGeoNode> {
    public:
      typedef PlacedVolumeExtension Object;
      typedef Object::VolIDs VolIDs;
      typedef Object::VolID  VolID;

      PlacedVolume(const TGeoNode* e)
        : Handle<TGeoNode>(e) {
      }
      PlacedVolume()
        : Handle<TGeoNode>() {
      }
      PlacedVolume(const PlacedVolume& e)
        : Handle<TGeoNode>(e) {
      }
      template <typename T> PlacedVolume(const Handle<T>& e)
        : Handle<TGeoNode>(e) {
      }
      PlacedVolume& operator=(const PlacedVolume& v) {
        m_element = v.m_element;
        return *this;
      }
      Object* data() const;
      PlacedVolume& addPhysVolID(const std::string& name, int value);
      Material material() const;
      Volume volume() const;
      Volume motherVol() const;
      const VolIDs& volIDs() const;
      std::string toString() const;
    };


    class VolumeExtension : public TGeoExtension {
    public:
      unsigned long magic;
      long          refCount;
      Region        region;
      LimitSet      limits;
      VisAttr       vis;
      Ref_t         sens_det;

      int           referenced;
      VolumeExtension();
      virtual ~VolumeExtension();
      void copy(const VolumeExtension& c) {
        magic = c.magic;
        region = c.region;
        limits = c.limits;
        vis = c.vis;
        sens_det = c.sens_det;
        referenced = c.referenced;
      }
      virtual TGeoExtension *Grab();
      virtual void Release() const;
      ClassDef(VolumeExtension,1);
    };


    class Volume: public Handle<TGeoVolume> {

    public:
      typedef Handle<TGeoVolume> Base;
      typedef VolumeExtension Object;

    public:
      Volume()
        : Base(0) {
      }

      Volume(const TGeoVolume* v)
        : Base(v) {
      }

      Volume(const Volume& v)
        : Base(v) {
      }

      template <typename T> Volume(const Handle<T>& v)
        : Base(v) {
      }

      Volume(const std::string& name);

      Volume(const std::string& name, const Solid& s, const Material& m);

      Volume& operator=(const Volume& a) {
        m_element = a.m_element;
        return *this;
      }

      Object* data() const;
      PlacedVolume placeVolume(const Volume& vol) const;
      PlacedVolume placeVolume(const Volume& volume, const Transform3D& tr) const;
      PlacedVolume placeVolume(const Volume& vol, const Position& pos) const;
      PlacedVolume placeVolume(const Volume& vol, const RotationZYX& rot) const;
      PlacedVolume placeVolume(const Volume& vol, const Rotation3D& rot) const;

      const Volume& setAttributes(const LCDD& lcdd, const std::string& region, const std::string& limits,
                                  const std::string& vis) const;

      const Volume& setRegion(const LCDD& lcdd, const std::string& name) const;
      const Volume& setRegion(const Region& obj) const;
      Region region() const;

      const Volume& setLimitSet(const LCDD& lcdd, 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 LCDD& lcdd, const std::string& name) const;
      VisAttr visAttributes() const;

      const Volume& setSensitiveDetector(const SensitiveDetector& obj) const;
      Ref_t sensitiveDetector() const;
      bool isSensitive() const;

      const Volume& setSolid(const Solid& s) const;
      Solid solid() const;

      const Volume& setMaterial(const Material& m) const;
      Material material() const;

      operator TGeoVolume*() const {
        return m_element;
      }
    };


    class Assembly: public Volume {
    public:
      Assembly()
        : Volume() {
      }

      Assembly(const Assembly& v)
        : Volume(v) {
      }

      template <typename T> Assembly(const Handle<T>& v)
        : Volume(v) {
      }

      Assembly(const std::string& name);

      Assembly& operator=(const Assembly& a) {
        m_element = a.m_element;
        return *this;
      }
    };

  } /* End namespace Geometry          */
}   /* End namespace DD4hep            */
#endif    /* DD4HEP_GEOMETRY_VOLUMES_H       */