DetectorData.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     : F.Gaede
//
//==========================================================================
#ifndef DDREC_DETECTORDATA_H
#define DDREC_DETECTORDATA_H
 
#include <map>
#include <bitset>
#include <ostream>
 
#include <boost/variant.hpp>
 
#include "DD4hep/DetElement.h"
 
namespace dd4hep {
  namespace rec {
    
    template< class T>
    struct StructExtension : public T {
      StructExtension() : T()  { } 
      StructExtension(const StructExtension<T>& t) : T(t) {} 
      StructExtension(const T& t) : T(t) {} 
      StructExtension(const DetElement& d) : T( *d.extension<StructExtension<T> >() )  {}
      StructExtension(const StructExtension<T>& t, const DetElement&) : T(t) {}
      std::string toString(){
    std::stringstream s ;
    s << *this ;
    return s.str();
      }
    };
 
 
 
    struct FixedPadSizeTPCStruct{
      double zHalf ;
      double rMin ;
      double rMax ;
      double driftLength ;
      double zMinReadout ;
      double rMinReadout ;
      double rMaxReadout ;
      double innerWallThickness ;
      double outerWallThickness ;
      double padHeight ;
      double padWidth ;
      double maxRow ;
      double padGap ;
    };
    typedef StructExtension<FixedPadSizeTPCStruct> FixedPadSizeTPCData ;
 
    std::ostream& operator<<( std::ostream& io , const FixedPadSizeTPCData& d ) ;
    
 
    struct ZPlanarStruct{
      double zHalfShell ;
      double  gapShell ;
      double rInnerShell ;
      double rOuterShell ;
      
      double widthStrip ;
      double lengthStrip ;
      double pitchStrip ;
      double angleStrip ;
      
      struct LayerLayout{
 
    // default c'tor with zero initialization
    LayerLayout() :
      ladderNumber(0),
      phi0(0), 
      sensorsPerLadder(0),
      lengthSensor(0),
      distanceSupport(0),
      thicknessSupport(0),
      offsetSupport(0), 
      widthSupport(0),
      zHalfSupport(0),
      distanceSensitive(0),
      thicknessSensitive(0),
      offsetSensitive(0), 
      widthSensitive(0),
      zHalfSensitive(0) {
    }
 
 
    int ladderNumber ;
 
    double phi0 ; 
 
    int sensorsPerLadder ;
    double lengthSensor ;
    
    double distanceSupport ;
    double thicknessSupport ;
    double offsetSupport ; 
    double widthSupport ;
    double zHalfSupport ;
 
    double distanceSensitive ;
    double thicknessSensitive ;
    double offsetSensitive ; 
    double widthSensitive ;
    double zHalfSensitive ;
      } ;
 
      std::vector<LayerLayout> layers ;
 
    } ;
    typedef StructExtension<ZPlanarStruct> ZPlanarData ;
 
    std::ostream& operator<<( std::ostream& io , const ZPlanarData& d ) ;
 
 
 
    struct ZDiskPetalsStruct{
 
      double widthStrip ;
      double lengthStrip ;
      double pitchStrip ;
      double angleStrip ;
      
      struct SensorType{
    enum {
      DoubleSided=0,
      Pixel
    };
      } ;
 
      struct LayerLayout{
 
    LayerLayout() :
      petalHalfAngle(0),
      alphaPetal(0),
      zPosition(0),
      petalNumber(0),
      sensorsPerPetal(0),
      typeFlags(0),
      phi0(0), 
      zOffsetSupport(0),
      distanceSupport(0),
      thicknessSupport(0),
      widthInnerSupport(0),
      widthOuterSupport(0),
      lengthSupport(0),
      zOffsetSensitive(0),
      distanceSensitive(0),
      thicknessSensitive(0),
      widthInnerSensitive(0),
      widthOuterSensitive(0),
      lengthSensitive(0) {
    }
    
    double  petalHalfAngle ;
    
    double  alphaPetal ;
    
    double  zPosition ;
 
    int petalNumber ;
 
    int sensorsPerPetal ;
 
    std::bitset<32> typeFlags ;
 
    double phi0 ; 
 
    double  zOffsetSupport ;
    double distanceSupport ;
    double thicknessSupport ;
    double widthInnerSupport ;
    double widthOuterSupport ;
    double lengthSupport ;
 
    double  zOffsetSensitive ;
    double distanceSensitive ;
    double thicknessSensitive ;
    double widthInnerSensitive ;
    double widthOuterSensitive ;
    double lengthSensitive ;
      } ;
 
      std::vector<LayerLayout> layers ;
 
    } ;
    typedef StructExtension<ZDiskPetalsStruct> ZDiskPetalsData ;
 
    std::ostream& operator<<( std::ostream& io , const ZDiskPetalsData& d ) ;
 
    struct ConicalSupportStruct{
 
      bool isSymmetricInZ ;
 
      struct Section{
 
    Section() :
      rInner(0),
      rOuter(0),
      zPos(0){
    }
 
    double rInner ;
    double rOuter ;
    double zPos ;
      } ;
 
      std::vector<Section> sections ;   
 
    } ;
 
    typedef StructExtension<ConicalSupportStruct> ConicalSupportData ;
 
    std::ostream& operator<<( std::ostream& io , const ConicalSupportData& d ) ;
 
 
    struct LayeredCalorimeterStruct{
      
      enum LayoutType{
    BarrelLayout=0,
    EndcapLayout,
    ConicalLayout
      };
 
      LayoutType layoutType ;
 
      double extent[6] ;
 
      int outer_symmetry ;
 
      int inner_symmetry ;
 
      double  outer_phi0  ;
 
      double  inner_phi0  ;
      
 
      double  phi0  ;
           
      
      double gap0;
      
      double gap1;
      
      double gap2;
      
 
      struct Layer {
    
    Layer() :
      distance(0),
      phi0(0),
      absorberThickness(0),
      inner_nRadiationLengths(0),
      inner_nInteractionLengths(0),        
      outer_nRadiationLengths(0),
      outer_nInteractionLengths(0), 
      inner_thickness(0),
      outer_thickness(0),
      sensitive_thickness(0),
      cellSize0(0),
      cellSize1(0) {
    }
    
    double distance;
        
    double phi0 ;
    
    double absorberThickness ;
        
        double inner_nRadiationLengths ;
        double inner_nInteractionLengths ;        
        
        double outer_nRadiationLengths ;
        double outer_nInteractionLengths ; 
        
        double inner_thickness;
        
        double outer_thickness;
        
        double sensitive_thickness;
        
        
        
    double cellSize0 ;
    double cellSize1 ;
      } ;   
 
      std::vector<Layer> layers ;   
    } ;
 
    typedef StructExtension<LayeredCalorimeterStruct> LayeredCalorimeterData ;
 
    std::ostream& operator<<( std::ostream& io , const LayeredCalorimeterData& d ) ;
 
 
 
 
    struct NeighbourSurfacesStruct {
 
      std::map<dd4hep::CellID , std::vector<dd4hep::CellID > > sameLayer ; 
 
      std::map<dd4hep::CellID , std::vector<dd4hep::CellID > > prevLayer ;
 
      std::map<dd4hep::CellID , std::vector<dd4hep::CellID > > nextLayer ;
 
    } ;
    typedef StructExtension<NeighbourSurfacesStruct> NeighbourSurfacesData ;
 
    std::ostream& operator<<( std::ostream& io , const NeighbourSurfacesData& d ) ;
 
    struct MapStringDoubleStruct {
      std::map<std::string, double> doubleParameters{};
    };
    using DoubleParameters = StructExtension<MapStringDoubleStruct>;
    std::ostream& operator<<( std::ostream& io , const DoubleParameters& d ) ;
 
    struct MapStringVariantStruct {
      std::map<std::string, boost::variant<double, int, std::string, bool>> variantParameters{};
 
      template <typename T>
      const T& get(const std::string& key) const {
        auto it = variantParameters.find(key);
        if(it == variantParameters.end()) {
          throw std::runtime_error{"Key "+key+" not found"};
        }
        return boost::get<T>(it->second);
      }
 
      template <typename T>
      T& get(const std::string& key) {
        auto it = variantParameters.find(key);
        if(it == variantParameters.end()) {
          throw std::runtime_error{"Key "+key+" not found"};
        }
        return boost::get<T>(it->second);
      }
 
      template <typename T>
      T value_or(const std::string& key, T alternative) const {
        auto it = variantParameters.find(key);
        if(it == variantParameters.end()) {
          return alternative;
        }
        return boost::get<T>(it->second);
      }
 
      template <typename T>
      void set(const std::string& key, T value) {
        variantParameters[key] = value;
      }
 
      bool contains(const std::string& key) const {
        return variantParameters.find(key) != variantParameters.end();
      }
    };
    using VariantParameters = StructExtension<MapStringVariantStruct>;
    std::ostream& operator<<( std::ostream& io , const VariantParameters& d ) ;
 
 
  } /* namespace rec */
} /* namespace dd4hep */
 
#endif // DDREC_DETECTORDATA_H