OpticalSurfaces.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_OPTICALSURFACES_H
#define DD4HEP_OPTICALSURFACES_H
 
// Framework include files
#include <DD4hep/Volumes.h>
#include <DD4hep/DetElement.h>
 
// ROOT include files
#include <TGeoOpticalSurface.h>
 
namespace dd4hep {
 
 
  class OpticalSurface : public Handle<TGeoOpticalSurface> {
  public:
    typedef TGeoOpticalSurface     Object;
    typedef Object Finish;
    typedef Object Model;
    typedef Object Type;
    typedef Object::ESurfaceModel  EModel;
    typedef Object::ESurfaceFinish EFinish;
    typedef Object::ESurfaceType   EType;
    typedef const TGDMLMatrix*     Property;
    
  public:
    OpticalSurface() = default;
    OpticalSurface(const OpticalSurface& e) = default;
    OpticalSurface(Object* obj) : Handle<Object>(obj) { }
    OpticalSurface(const Handle<Object>& e) : Handle<Object>(e) {  }
    template <typename Q>
    OpticalSurface(const Handle<Q>& e) : Handle<Object>(e) { }
    OpticalSurface(Detector& detector,
                   const std::string& name,
                   EModel  model    = Model::kMglisur,
                   EFinish finish   = Finish::kFpolished,
                   EType   type     = Type::kTdielectric_dielectric,
                   double  value    = 1.0);
 
    OpticalSurface& operator=(const OpticalSurface& m) = default;
 
    Property property(const char* name)  const;
    
    Property property(const std::string& name)  const;
 
    static EType   stringToType(const std::string& type)   {
      return Object::StringToType(type.c_str());
    }
    static std::string  typeToString(EType type)   {
      return Object::TypeToString(type);
    }
    static EModel  stringToModel(const std::string& model)  {
      return Object::StringToModel(model.c_str());
    }
    static std::string  modelToString(EModel model)  {
      return Object::ModelToString(model);
    }
    static EFinish stringToFinish(const std::string& finish)  {
      return Object::StringToFinish(finish.c_str());
    }
    static std::string  finishToString(EFinish finish)  {
      return Object::FinishToString(finish);
    }
  };
 
 
  class SkinSurface : public Handle<TGeoSkinSurface> {
  public:
    typedef TGeoSkinSurface        Object;
    typedef const TGDMLMatrix*     Property;    
 
  public:
    SkinSurface() = default;
    SkinSurface(const SkinSurface& e) = default;
    SkinSurface(Object* obj) : Handle<Object>(obj) { }
    SkinSurface(const Handle<Object>& e) : Handle<Object>(e) {  }
    template <typename Q>
    SkinSurface(const Handle<Q>& e) : Handle<Object>(e) { }
    SkinSurface(Detector&          detector,
                DetElement         de,
                const std::string& nam,
                OpticalSurface     surf,
                Volume             vol);
 
    SkinSurface& operator=(const SkinSurface& m) = default;
 
    OpticalSurface surface()  const;
    Volume  volume()   const;
    Property property(const char* name)  const;    
    Property property(const std::string& name)  const;    
  };
 
 
  class BorderSurface : public Handle<TGeoBorderSurface> {
  public:
    typedef TGeoBorderSurface      Object;
    typedef const TGDMLMatrix*     Property;    
 
  public:
    BorderSurface() = default;
    BorderSurface(const BorderSurface& e) = default;
    BorderSurface(Object* obj) : Handle<Object>(obj) { }
    BorderSurface(const Handle<Object>& e) : Handle<Object>(e) {  }
    template <typename Q>
    BorderSurface(const Handle<Q>& e) : Handle<Object>(e) { }
    BorderSurface(Detector&          detector,
                  DetElement         de,
                  const std::string& nam,
                  OpticalSurface     surf,
                  PlacedVolume       left,
                  PlacedVolume       right);
 
    BorderSurface& operator=(const BorderSurface& m) = default;
    OpticalSurface surface()  const;
    Property property(const char* name)  const;    
    Property property(const std::string& name)  const;
    PlacedVolume   left()   const;
    PlacedVolume   right()  const;
  };
}      /* End namespace dd4hep              */
#endif // DD4HEP_OPTICALSURFACES_H