Layering.h

Go to the documentation of this file.

// $Id$
//==========================================================================
//  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_LAYERING_H
#define DD4hep_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 s, double t, const std::string& m);
    LayerSlice(const LayerSlice& c);
    LayerSlice& operator=(const LayerSlice& c);
  };

  inline LayerSlice::LayerSlice(bool s, double t, const std::string& m)
    : _sensitive(s), _thickness(t), _material(m) {
  }
  inline LayerSlice::LayerSlice(const LayerSlice& c)
    : _sensitive(c._sensitive), _thickness(c._thickness), _material(c._material) {
  }


  class Layer {
  public:
    double _thickness;
    double _preOffset;
    std::vector<LayerSlice> _slices;

    Layer();
    Layer(const Layer& c);
    Layer& operator=(const Layer& c);

    void compute();
    double thickness() const {
      return _thickness;
    }
    double thicknessWithPreOffset() const {
      return _thickness + _preOffset;
    }
    void add(const LayerSlice& s) {
      _slices.push_back(s);
    }
  };

  inline Layer::Layer() : _thickness(0.), _preOffset(0.) {
  }



  class LayerStack {
  public:
    std::vector<Layer*> _layers;
    LayerStack();
    LayerStack(const LayerStack& c);
    ~LayerStack() {
    }
    LayerStack& operator=(const LayerStack& c) {
      if ( &c != this ) _layers = c._layers;
      return *this;
    }
    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);
    }
  };

  inline LayerStack::LayerStack() {
  }
  inline LayerStack::LayerStack(const LayerStack& c)
    : _layers(c._layers) {
  }


  class Layering {
  public:
    LayerStack _stack;
    Layering();
    Layering(XML::Element e);
    virtual ~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    /* DD4hep_LAYERING_H      */