SurfaceInstaller.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_DDREC_SURFACEINSTALLER_H
#define DD4HEP_DDREC_SURFACEINSTALLER_H 1

// Framework include files
#include "DD4hep/LCDD.h"
#include "DD4hep/DetectorTools.h"
#include "DD4hep/DetFactoryHelper.h"

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

namespace DDSurfaces  {
  class SurfaceType;
}

namespace DD4hep  {
  
  namespace DDRec  {
    //    class SurfaceData;
    class VolSurfaceBase;
  }
  
  class SurfaceInstaller  {
  protected:
    typedef Geometry::LCDD         LCDD;
    typedef Geometry::DetElement   DetElement;
    typedef Geometry::Volume       Volume;
    typedef Geometry::PlacedVolume PlacedVolume;
    typedef Geometry::DetectorTools::ElementPath   ElementPath;
    typedef Geometry::DetectorTools::PlacementPath PlacementPath;
    typedef DDRec::VolSurfaceBase      SurfaceData;
    typedef DDSurfaces::SurfaceType SurfaceType;

    typedef std::map<TGeoVolume*, SurfaceData* > Surfaces;
    LCDD&         m_lcdd;
    DetElement    m_det;
    Surfaces      m_surfaces;
    bool          m_stopScanning;
    void scan(DetElement de);

  public:
    SurfaceInstaller(LCDD& lcdd, int argc, char** argv);
    virtual ~SurfaceInstaller() {}
    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(LCDD& lcdd,int argc,char** argv);
  };

  template <typename T> inline long SurfaceInstaller::run(Geometry::LCDD& lcdd,int argc,char** argv)  {
    T installer(lcdd, argc, argv);
    installer.scan();
    return 1;
  }

#define DECLARE_SURFACE_INSTALLER(name,class)                           \
  namespace DD4hep {                                                    \
    template long SurfaceInstaller::run< class >(Geometry::LCDD& lcdd,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 {

  template <typename UserData> class Installer : public DD4hep::SurfaceInstaller {
  public:
    typedef DD4hep::DDRec::Vector3D     Vector3D;
    typedef DD4hep::DDRec::VolSurface   VolSurface;
    typedef DD4hep::DDRec::VolPlane     VolPlane;
    typedef DDSurfaces::SurfaceType     Type;
    UserData data;

    void handle_arguments(int argc, char** argv);
  public:
    Installer(LCDD& lcdd, int argc, char** argv);
    virtual ~Installer() {}
    virtual void install(DetElement component, PlacedVolume pv);
    bool handleUsingCache(DetElement comp, Volume vol)  const;
    void addSurface(DetElement component, const DD4hep::DDRec::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(LCDD& lcdd, int argc, char** argv)
    : DD4hep::SurfaceInstaller(lcdd, argc, argv) 
  {
    handle_arguments(argc, argv);
  }

  template <typename UserData>
  bool Installer<UserData>::handleUsingCache(DetElement comp, Volume vol)  const  {
    Surfaces::const_iterator is = m_surfaces.find(vol.ptr());
    if ( is != m_surfaces.end() )  {
      VolSurface surf((*is).second);
      DD4hep::DDRec::volSurfaceList(comp)->push_back(surf);
      return true;
    }
    return false;
  }

  template <typename UserData>
  void Installer<UserData>::addSurface(DetElement component, const DD4hep::DDRec::VolSurface& surf)   {
    m_surfaces.insert(std::make_pair(surf.volume().ptr(),surf.ptr()));
    DD4hep::DDRec::volSurfaceList(component)->push_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_DDREC_SURFACEINSTALLER_H */