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 "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::long64 , std::vector<dd4hep::long64 > > sameLayer ; 

      std::map<dd4hep::long64 , std::vector<dd4hep::long64 > > prevLayer ;

      std::map<dd4hep::long64 , std::vector<dd4hep::long64 > > 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 ) ;

  } /* namespace rec */
} /* namespace dd4hep */

#endif // DDREC_DETECTORDATA_H