VolumeManager.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_VOLUMEMANAGER_H
#define DD4HEP_VOLUMEMANAGER_H
 
// Framework include files
#include <DD4hep/Volumes.h>
#include <DD4hep/DetElement.h>
#include <DD4hep/NamedObject.h>
#include <DD4hep/IDDescriptor.h>
#include <DD4hep/ConditionsMap.h>
 
// ROOT include files
#include <TGeoMatrix.h>
 
namespace dd4hep {
 
  namespace detail {
    class VolumeManagerObject;
  }
  
 
  class VolumeManagerContext {
  public:
    DetElement   element;
    VolumeID     identifier = 0;
    VolumeID     mask       = ~0x0ULL;
    long         flag       = 0;
  public:
    VolumeManagerContext() = default;
    VolumeManagerContext(const VolumeManagerContext& copy) = delete;      
    VolumeManagerContext(VolumeManagerContext&& copy) = delete;      
    VolumeManagerContext& operator=(const VolumeManagerContext& copy) = delete;      
    VolumeManagerContext& operator=(VolumeManagerContext&& copy) = delete;      
    virtual ~VolumeManagerContext();
    PlacedVolume volumePlacement()  const;
    PlacedVolume elementPlacement()  const;
    const TGeoHMatrix& toElement()  const;
    Position localToElement(const double local[3])  const;
    Position localToElement(const Position& local)  const;
    Position localToWorld(const double local[3])  const;
    Position localToWorld(const Position& local)  const;
 
    Position worldToElement(const Position& world)  const;
    Position worldToElement(const double world[3])  const;
    void worldToElement(const double world[3], double element[3])  const;
 
    Position worldToLocal(const Position& world)  const;
    Position worldToLocal(const double world[3])  const;
    void worldToLocal(const double world[3], double local[3])  const;
  };
 
 
  class VolumeManager: public Handle<detail::VolumeManagerObject> {
  public:
    // Creation flags
    enum PopulateFlags {
      NONE = 0,
      TREE = 1 << 1,   // Build 1 level DetElement hierarchy while populating
      ONE  = 1 << 2,   // Populate all daughter volumes into one big lookup-container
      // This flag may be in parallel with 'TREE'
      LAST
    };
 
  protected:
    Object& _data() const {
      return *(Object*) ptr();
    }
 
  public:
    VolumeManager() = default;
 
    VolumeManager(const VolumeManager& e) = default;
#ifndef __CINT__
    VolumeManager(const Handle<detail::VolumeManagerObject>& e)
      : Handle<detail::VolumeManagerObject>(e) {
    }
#endif
    template <typename Q>
    VolumeManager(const Handle<Q>& e) : Handle<detail::VolumeManagerObject>(e) { }
    VolumeManager(const Detector& description,
                  const std::string& name,
                  DetElement         world = DetElement(),
                  Readout            ro    = Readout(),
                  int                flags = NONE);
    VolumeManager(DetElement subdetector, Readout ro);
 
    static VolumeManager getVolumeManager(const Detector& description);
 
    VolumeManager& operator=(const VolumeManager& m) = default;
 
    VolumeManager addSubdetector(DetElement detector, Readout ro);
    VolumeManager subdetector(VolumeID id) const;
 
    DetElement detector() const;
    IDDescriptor idSpec() const;
 
    bool adoptPlacement(VolumeManagerContext* context);
    bool adoptPlacement(VolumeID volume_id, VolumeManagerContext* context);
 
    VolumeManagerContext* lookupContext(VolumeID volume_id) const;
    PlacedVolume lookupVolumePlacement(VolumeID volume_id) const;
    PlacedVolume lookupDetElementPlacement(VolumeID volume_id) const;
    DetElement lookupDetector(VolumeID volume_id) const;
    DetElement lookupDetElement(VolumeID volume_id) const;
    const TGeoMatrix& worldTransformation(const ConditionsMap& map,
                                          VolumeID volume_id) const;
  };
 
  std::ostream& operator<<(std::ostream& os, const VolumeManager& m);
}         /* End namespace dd4hep                */
#endif // DD4HEP_VOLUMEMANAGER_H