src/XML/Layering.cpp

0001 //==========================================================================
0002 //  AIDA Detector description implementation
0003 //--------------------------------------------------------------------------
0004 // Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
0005 // All rights reserved.
0006 //
0007 // For the licensing terms see $DD4hepINSTALL/LICENSE.
0008 // For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
0009 //
0010 // Author     : M.Frank
0011 //
0012 //==========================================================================
0013 #ifndef DD4HEP_NONE
0014
0015 // Framework include files
0016 #include <DD4hep/Primitives.h>
0017 #include <DD4hep/Printout.h>
0018 #include <XML/Layering.h>
0019 #include <XML/XML.h>
0020
0021 void dd4hep::Layer::compute() {
0022   _thickness = 0.;
0023   for (std::vector<LayerSlice>::const_iterator i = _slices.begin(); i != _slices.end(); ++i)
0024     _thickness += (*i)._thickness;
0025 }
0026
0027 double dd4hep::LayerStack::sectionThickness(std::size_t is, std::size_t ie) const {
0028   double thick = 0.;
0029   if (is > ie)
0030     except("LayerStack",
0031            "sectionThickness: First index (%ld) must be <= second index (%ld)!", is, ie);
0032   else if (is > _layers.size())
0033     except("LayerStack",
0034            "sectionThickness: First index (%ld) out of range. #layers=%ld).", is, _layers.size());
0035   else if (ie > _layers.size())
0036     except("LayerStack",
0037            "sectionThickness: Second index (%ld) out of range. #layers=%ld).", is, _layers.size());
0038   for (std::size_t i = is; i <= ie; ++i)
0039     thick += _layers[i]->thicknessWithPreOffset();
0040   return thick;
0041 }
0042
0043 void dd4hep::xml::LayeringCnv::fromCompact(Layering& layering) const {
0044   std::vector<Layer*>& layers = layering.layers();
0045   int count = 0;
0046   for_each(layers.begin(), layers.end(), detail::deletePtr<Layer>);
0047   for( xml_coll_t c(m_element, _U (layer)); c; ++c ) {
0048     Layer lay;
0049     xml_comp_t layer = c;
0050     int repeat = layer.hasAttr(_U(repeat)) ? layer.repeat() : 1;
0051     ++count;
0052     for (xml_coll_t s(c, _U(slice)); s; ++s) {
0053       xml_comp_t  slice = s;
0054       std::string material = slice.materialStr();
0055       LayerSlice  lslice(slice.isSensitive(), slice.thickness(), material);
0056       lay.add(lslice);
0057     }
0058     lay.compute();
0059     // Add layer to stack once for each repetition
0060     for( int k = 0; k < repeat; ++k )
0061       layers.emplace_back(new Layer(lay));
0062   }
0063   if (0 == count) {
0064     throw std::runtime_error("LayeringCnv::fromCompact: No layer children to be build!");
0065   }
0066 }
0067
0068 dd4hep::Layering::Layering(xml_elt_t e)  {
0069   xml::LayeringCnv(e).fromCompact(*this);
0070 }
0071
0072 const dd4hep::Layer* dd4hep::Layering::layer(std::size_t which) const {
0073   return _stack.layers()[which];
0074 }
0075
0076 double dd4hep::Layering::singleLayerThickness(xml_elt_t e) const {
0077   xml_comp_t lay = e;
0078   double thickness = 0e0;
0079   for (xml_coll_t s(lay, _U(slice)); s; ++s) {
0080     xml_comp_t slice = s;
0081     thickness += slice.thickness();
0082   }
0083   return thickness;
0084 }
0085
0086 double dd4hep::Layering::absorberThicknessInLayer(xml_elt_t e) const {
0087   xml_comp_t lay = e;
0088   double thickness = 0e0;
0089   for (xml_coll_t s(lay, _U(slice)); s; ++s) {
0090     xml_comp_t slice = s;
0091     if (slice.isRadiator())
0092         thickness += slice.thickness();
0093   }
0094   return thickness;
0095 }
0096
0097 void dd4hep::Layering::sensitivePositionsInLayer(xml_elt_t e, std::vector<double>& sens_pos) const {
0098   xml_comp_t lay = e;
0099   double pos =- singleLayerThickness(e)/2.0;
0100   for (xml_coll_t s(lay, _U(slice)); s; ++s) {
0101     xml_comp_t slice = s;
0102     pos += slice.thickness();
0103     if (slice.isSensitive()){
0104         //store the position at the center of the slice
0105         sens_pos.emplace_back(pos - slice.thickness()/2.);
0106     }
0107   }
0108 }
0109
0110
0111 dd4hep::Layering::~Layering(){
0112   std::vector<Layer*>& layers = this->layers();
0113   for_each(layers.begin(), layers.end(), detail::deletePtr<Layer>);
0114   layers.clear();
0115 }
0116 #endif