SurfaceInstaller.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_SURFACEINSTALLER_H
#define DD4HEP_SURFACEINSTALLER_H 1
 
// Framework include files
#include <DD4hep/Detector.h>
#include <DD4hep/DetectorTools.h>
#include <DD4hep/DetFactoryHelper.h>
 
// C/C++ include files
#include <map>
#include <algorithm>
 
 
 
namespace dd4hep{
  namespace rec{
    class VolSurfaceBase;
    class SurfaceType;
  }
}
 
 
namespace dd4hep  {
  
  namespace rec  {
    //    class SurfaceData;
    class VolSurfaceBase;
  }
  
  /*
   *  The class scans the geometry of a subdetector and gives callbacks
   *  to user classes, which then should install in the proper callback
   *  routines the surface instances to the detector elements.
   *
   *  \author  M.Frank
   *  \version 1.0
   *  \ingroup DD4HEP
   */
  class SurfaceInstaller  {
  protected:
    typedef detail::tools::ElementPath   ElementPath;
    typedef detail::tools::PlacementPath PlacementPath;
    typedef rec::VolSurfaceBase        SurfaceData;
    typedef rec::SurfaceType      SurfaceType;
    typedef std::map<TGeoVolume*, SurfaceData* > Surfaces;
    
    Detector&         m_detDesc;
    DetElement    m_det;
    Surfaces      m_surfaces;
    bool          m_stopScanning;
    void scan(DetElement de);
 
  public:
    SurfaceInstaller() = delete;
    SurfaceInstaller(const SurfaceInstaller& copy) = delete;
    SurfaceInstaller(Detector& description, int argc, char** argv);
    virtual ~SurfaceInstaller() = default;
    SurfaceInstaller& operator=(const SurfaceInstaller& copy) = delete;
    void stopScanning()   {  m_stopScanning = true;   }
    void invalidInstaller(const std::string& msg) const;
    Volume parentVolume(DetElement component)  const;
    const double* placementTranslation(DetElement component)  const;
    void scan();
    virtual void install(DetElement e, PlacedVolume pv);
    template <typename T> static long run(Detector& description,int argc,char** argv);
  };
 
  template <typename T> inline long SurfaceInstaller::run(Detector& description,int argc,char** argv)  {
    T installer(description, argc, argv);
    installer.scan();
    return 1;
  }
 
#define DECLARE_SURFACE_INSTALLER(name,class)                           \
  namespace dd4hep {                                                    \
    template long SurfaceInstaller::run< class >(Detector& description,int argc,char** argv); \
  }                                                                     \
  DECLARE_APPLY(name,SurfaceInstaller::run< class >)
 
}   // End namespace dd4hep
 
 
#if defined(DD4HEP_USE_SURFACEINSTALL_HELPER)
 
#include <DDRec/Surface.h>
#include <DDRec/DetectorData.h>
 
#ifndef SURFACEINSTALLER_DATA
typedef void* SURFACEINSTALLER_DATA;
#endif
 
namespace {
 
  /*
   *  See the base class SurfaceInstaller for further details.
   *
   *  \author  M.Frank
   *  \version 1.0
   *  \ingroup DD4HEP
   */
  template <typename UserData> class Installer : public dd4hep::SurfaceInstaller {
  public:
    typedef dd4hep::rec::Vector3D     Vector3D;
    typedef dd4hep::rec::VolSurface   VolSurface;
    typedef dd4hep::rec::VolPlane     VolPlane;
    typedef dd4hep::rec::SurfaceType     Type;
    UserData data;
 
    void handle_arguments(int argc, char** argv);
  public:
    Installer() = delete;
    Installer(const Installer& copy) = delete;
    Installer(dd4hep::Detector& description, int argc, char** argv);
    virtual ~Installer() = default;
    Installer& operator=(const Installer& copy) = delete;
    virtual void install(dd4hep::DetElement component, dd4hep::PlacedVolume pv);
    bool handleUsingCache(dd4hep::DetElement comp, dd4hep::Volume vol)  const;
    void addSurface(dd4hep::DetElement component, const dd4hep::rec::VolSurface& surf);
    template <typename T> bool checkShape(const T& shape) const   {
      if ( shape.isValid() ) return true;
      invalidInstaller("Shape is not of the required type:"+dd4hep::typeName(typeid(T)));
      return false;
    }
  };
 
  template <typename UserData>
  Installer<UserData>::Installer(dd4hep::Detector& description, int argc, char** argv)
    : dd4hep::SurfaceInstaller(description, argc, argv), data()
  {
    handle_arguments(argc, argv);
  }
 
  template <typename UserData>
  bool Installer<UserData>::handleUsingCache(dd4hep::DetElement comp, dd4hep::Volume vol)  const  {
    Surfaces::const_iterator is = m_surfaces.find(vol.ptr());
    if ( is != m_surfaces.end() )  {
      VolSurface surf((*is).second);
      dd4hep::rec::volSurfaceList(comp)->emplace_back(surf);
      return true;
    }
    return false;
  }
 
  template <typename UserData>
  void Installer<UserData>::addSurface(dd4hep::DetElement component, const dd4hep::rec::VolSurface& surf)   {
    m_surfaces.insert(std::make_pair(surf.volume().ptr(),surf.ptr()));
    dd4hep::rec::volSurfaceList(component)->emplace_back(surf);
  }
 
  template <typename UserData> void Installer<UserData>::handle_arguments(int, char**)  {}
#ifndef SURFACEINSTALLER_DATA
  template <> void Installer<SURFACEINSTALLER_DATA>::handle_arguments(int, char**)  {}
#endif
}
 
typedef Installer<SURFACEINSTALLER_DATA> InstallerClass;
DECLARE_SURFACE_INSTALLER(DD4HEP_USE_SURFACEINSTALL_HELPER,InstallerClass)
 
#endif /* defined(DD4HEP_USE_SURFACEINSTALL_HELPER) */
#endif // DD4HEP_SURFACEINSTALLER_H