Layering.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 XML_LAYERING_H
#define XML_LAYERING_H
 
// Framework include files
#include <XML/XMLElements.h>
 
// C/C++ include files
#include <vector>
 
namespace dd4hep {
 
 
  class LayerSlice {
  public:
    bool _sensitive;
    double _thickness;
    std::string _material;
    LayerSlice(bool sens, double thick, const std::string& mat);
    LayerSlice(const LayerSlice& copy) = default;
    LayerSlice& operator=(const LayerSlice& copy) = default;
  };
 
  inline LayerSlice::LayerSlice(bool sens, double thick, const std::string& mat)
    : _sensitive(sens), _thickness(thick), _material(mat) {
  }
 
 
  class Layer {
  public:
    double _thickness = 0.0;
    double _preOffset = 0.0;
    std::vector<LayerSlice> _slices;
 
    Layer() = default;
    Layer(const Layer& copy) = default;
    Layer& operator=(const Layer& copy) = default;
 
    void compute();
    double thickness() const {
      return _thickness;
    }
    double thicknessWithPreOffset() const {
      return _thickness + _preOffset;
    }
    void add(const LayerSlice& slice) {
      _slices.emplace_back(slice);
    }
  };
 
 
  class LayerStack {
  public:
    std::vector<Layer*> _layers;
    LayerStack() = default;
    LayerStack(const LayerStack& copy) = default;
    ~LayerStack()  = default;
    LayerStack& operator=(const LayerStack& copy)  = default;
    std::vector<Layer*>& layers() {
      return _layers;
    }
    const std::vector<Layer*>& layers() const {
      return _layers;
    }
    double sectionThickness(size_t is, size_t ie) const;
    double totalThickness() const {
      return sectionThickness(0, _layers.size() - 1);
    }
  };
 
 
  class Layering {
  public:
    LayerStack _stack;
    Layering() = default;
    Layering(xml::Element element);
    ~Layering();
 
    std::vector<Layer*>& layers() {
      return _stack.layers();
    }
    const Layer* layer(size_t which) const;
 
    double totalThickness() const {
      return _stack.totalThickness();
    }
    double singleLayerThickness(xml::Element e) const;
    double absorberThicknessInLayer(xml::Element e) const;
    void sensitivePositionsInLayer(xml::Element e,std::vector<double>& sens_pos) const;
 
  };
 
  namespace xml {
 
 
    class LayeringCnv: public Element {
    public:
      LayeringCnv(Element e);
      void fromCompact(Layering& layering) const;
    };
 
    inline LayeringCnv::LayeringCnv(Element e)
      : Element(e) {
    }
  }
}         /* End namespace dd4hep          */
#endif // XML_LAYERING_H