HGCalGeomParameters Class Reference

#include <HGCalGeomParameters.h>

Classes
struct	cellParameters
struct	layerParameters

Public Member Functions
	HGCalGeomParameters ()
void	loadCellParsHexagon (const DDCompactView *cpv, HGCalParameters &php)
void	loadCellParsHexagon (const cms::DDVectorsMap &, HGCalParameters &php)
void	loadCellParsHexagon (const HGCalParameters &php)
void	loadCellTrapezoid (HGCalParameters &php)
void	loadGeometryHexagon (const DDFilteredView &, HGCalParameters &, const std::string &, const DDCompactView *, const std::string &, const std::string &, HGCalGeometryMode::WaferMode)
void	loadGeometryHexagon (const cms::DDFilteredView &, HGCalParameters &, const std::string &, const cms::DDCompactView *, const std::string &, const std::string &, HGCalGeometryMode::WaferMode)
void	loadGeometryHexagon8 (const DDFilteredView &, HGCalParameters &, int)
void	loadGeometryHexagon8 (const cms::DDFilteredView &, HGCalParameters &, int)
void	loadSpecParsHexagon (const DDFilteredView &, HGCalParameters &, const DDCompactView *, const std::string &, const std::string &)
void	loadSpecParsHexagon (const cms::DDFilteredView &, HGCalParameters &, const cms::DDCompactView *, const std::string &, const std::string &, const std::string &, const std::string &)
void	loadSpecParsHexagon8 (const DDFilteredView &, HGCalParameters &)
void	loadSpecParsHexagon8 (const cms::DDFilteredView &, const cms::DDVectorsMap &, HGCalParameters &, const std::string &)
void	loadSpecParsTrapezoid (const DDFilteredView &, HGCalParameters &)
void	loadSpecParsTrapezoid (const cms::DDFilteredView &, const cms::DDVectorsMap &, HGCalParameters &, const std::string &)
void	loadWaferHexagon (HGCalParameters &php)
void	loadWaferHexagon8 (HGCalParameters &php)
	~HGCalGeomParameters ()

Private Member Functions
std::pair< double, double >	cellPosition (const std::vector< cellParameters > &wafers, std::vector< cellParameters >::const_iterator &itrf, int wafer, double xx, double yy)
std::vector< double >	getDDDArray (const std::string &, const DDsvalues_type &, const int)
void	loadGeometryHexagon (const std::map< int, HGCalGeomParameters::layerParameters > &layers, std::vector< HGCalParameters::hgtrform > &trforms, std::vector< bool > &trformUse, const std::unordered_map< int32_t, int32_t > &copies, const HGCalParameters::layer_map &copiesInLayers, const std::vector< int32_t > &wafer2copy, const std::vector< HGCalGeomParameters::cellParameters > &wafers, const std::map< int, int > &wafertype, const std::map< int, HGCalGeomParameters::cellParameters > &cellsf, const std::map< int, HGCalGeomParameters::cellParameters > &cellsc, HGCalParameters &php)
void	loadGeometryHexagon8 (const std::map< int, HGCalGeomParameters::layerParameters > &layers, std::map< std::pair< int, int >, HGCalParameters::hgtrform > &trforms, const int &firstLayer, HGCalParameters &php)
void	loadSpecParsHexagon (const HGCalParameters &php)
void	loadSpecParsHexagon8 (const HGCalParameters &php)
void	loadSpecParsTrapezoid (const HGCalParameters &php)
void	rescale (std::vector< double > &, const double s)

Private Attributes
HGCalGeomTools	geomTools_
const double	sqrt3_
double	waferSize_

Detailed Description

this class extracts some geometry constants from CompactView to be used by Reco Geometry/Topology

Date

2015/06/25 00:06:50

Author

Sunanda Banerjee, Fermilab sunan.nosp@m.da.b.nosp@m.anerj.nosp@m.ee@c.nosp@m.ern.c.nosp@m.h

Lindsey Gray, Fermilab lagra.nosp@m.y@fn.nosp@m.al.go.nosp@m.v (for fixes)

Definition at line 29 of file HGCalGeomParameters.h.

Constructor & Destructor Documentation

HGCalGeomParameters::HGCalGeomParameters

(

)

Definition at line 27 of file HGCalGeomParameters.cc.

                                         : sqrt3_(std::sqrt(3.0)) {
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters::HGCalGeomParameters "
                                << "constructor";
#endif
}

HGCalGeomParameters::~HGCalGeomParameters

(

)

Definition at line 34 of file HGCalGeomParameters.cc.

                                          {
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters::destructed!!!";
#endif
}

Member Function Documentation

std::pair< double, double > HGCalGeomParameters::cellPosition ( const std::vector< cellParameters > &  wafers, std::vector< cellParameters >::const_iterator &  itrf, int  wafer, double  xx, double  yy  )

private

Definition at line 1367 of file HGCalGeomParameters.cc.

References funct::abs(), PVValHelper::dx, PVValHelper::dy, and tolerance.

Referenced by HGCalGeomParameters::cellParameters::cellParameters(), and loadGeometryHexagon().

               {
  if (itrf == wafers.end()) {
    for (std::vector<HGCalGeomParameters::cellParameters>::const_iterator itr = wafers.begin(); itr != wafers.end();
         ++itr) {
      if (itr->wafer == wafer) {
        itrf = itr;
        break;
      }
    }
  }
  double dx(0), dy(0);
  if (itrf != wafers.end()) {
    dx = (xx - itrf->xyz.x());
    if (std::abs(dx) < tolerance)
      dx = 0;
    dy = (yy - itrf->xyz.y());
    if (std::abs(dy) < tolerance)
      dy = 0;
  }
  return std::make_pair(dx, dy);
}

std::vector< double > HGCalGeomParameters::getDDDArray ( const std::string &  str, const DDsvalues_type &  sv, const int  nmin  )

private

Definition at line 1338 of file HGCalGeomParameters.cc.

References DDfetch(), DDValue::doubles(), Exception, str, and relativeConstraints::value.

Referenced by HGCalGeomParameters::cellParameters::cellParameters(), loadSpecParsHexagon(), loadSpecParsHexagon8(), and loadSpecParsTrapezoid().

                                                                                                                 {
  DDValue value(str);
  if (DDfetch(&sv, value)) {
    const std::vector<double>& fvec = value.doubles();
    int nval = fvec.size();
    if (nmin > 0) {
      if (nval < nmin) {
        edm::LogError("HGCalGeom") << "HGCalGeomParameters : # of " << str << " bins " << nval << " < " << nmin
                                   << " ==> illegal";
        throw cms::Exception("DDException") << "HGCalGeomParameters: cannot get array " << str;
      }
    } else {
      if (nval < 1 && nmin == 0) {
        edm::LogError("HGCalGeom") << "HGCalGeomParameters : # of " << str << " bins " << nval << " < 1 ==> illegal"
                                   << " (nmin=" << nmin << ")";
        throw cms::Exception("DDException") << "HGCalGeomParameters: cannot get array " << str;
      }
    }
    return fvec;
  } else {
    if (nmin >= 0) {
      edm::LogError("HGCalGeom") << "HGCalGeomParameters: cannot get array " << str;
      throw cms::Exception("DDException") << "HGCalGeomParameters: cannot get array " << str;
    }
    std::vector<double> fvec;
    return fvec;
  }
}

void HGCalGeomParameters::loadCellParsHexagon	(	const DDCompactView *	cpv,
		HGCalParameters &	php
	)

Definition at line 1177 of file HGCalGeomParameters.cc.

References HGCalParameters::cellCoarse_, HGCalParameters::cellFine_, dbl_to_int(), DDFilteredView::firstChild(), DDVectorGetter::get(), convertSQLiteXML::ok, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by loadCellParsHexagon().

                                                                                            {
  // Special parameters for cell parameters
  std::string attribute = "OnlyForHGCalNumbering";
  DDSpecificsHasNamedValueFilter filter1{attribute};
  DDFilteredView fv1(*cpv, filter1);
  bool ok = fv1.firstChild();

  if (ok) {
    php.cellFine_ = dbl_to_int(DDVectorGetter::get("waferFine"));
    php.cellCoarse_ = dbl_to_int(DDVectorGetter::get("waferCoarse"));
  }

  loadCellParsHexagon(php);
}

void HGCalGeomParameters::loadCellParsHexagon	(	const cms::DDVectorsMap &	vmap,
		HGCalParameters &	php
	)

Definition at line 1192 of file HGCalGeomParameters.cc.

References HGCalParameters::cellCoarse_, HGCalParameters::cellFine_, cms::dd::compareEqual(), mps_fire::i, loadCellParsHexagon(), and cms::dd::noNamespace().

                                                                                               {
  for (auto const& it : vmap) {
    if (cms::dd::compareEqual(cms::dd::noNamespace(it.first), "waferFine")) {
      for (const auto& i : it.second)
        php.cellFine_.emplace_back(std::round(i));
    } else if (cms::dd::compareEqual(cms::dd::noNamespace(it.first), "waferCoarse")) {
      for (const auto& i : it.second)
        php.cellCoarse_.emplace_back(std::round(i));
    }
  }

  loadCellParsHexagon(php);
}

void HGCalGeomParameters::loadCellParsHexagon

(

const HGCalParameters &

php

)

Definition at line 1206 of file HGCalGeomParameters.cc.

References HGCalParameters::cellCoarse_, HGCalParameters::cellFine_, and dqmdumpme::k.

                                                                        {
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "HGCalLoadCellPars: " << php.cellFine_.size() << " rows for fine cells";
  for (unsigned int k = 0; k < php.cellFine_.size(); ++k)
    edm::LogVerbatim("HGCalGeom") << "[" << k << "]: " << php.cellFine_[k];
  edm::LogVerbatim("HGCalGeom") << "HGCalLoadCellPars: " << php.cellCoarse_.size() << " rows for coarse cells";
  for (unsigned int k = 0; k < php.cellCoarse_.size(); ++k)
    edm::LogVerbatim("HGCalGeom") << "[" << k << "]: " << php.cellCoarse_[k];
#endif
}

void HGCalGeomParameters::loadCellTrapezoid

(

HGCalParameters &

php

)

Definition at line 1217 of file HGCalGeomParameters.cc.

References HGCalParameters::hgtrap::alpha, HGCalParameters::hgtrap::bl, HGCalParameters::hgtrap::cellSize, HGCalParameters::cellSize_, HGCalParameters::hgtrap::dz, PVValHelper::eta, JetChargeProducer_cfi::exp, HGCalParameters::fillModule(), HGCalParameters::firstLayer_, HGCalParameters::firstModule_, HGCalParameters::hgtrap::h, LaserClient_cfi::high, createfilelist::int, HGCalParameters::iradMaxBH_, HGCalParameters::iradMinBH_, dqmdumpme::k, HGCalParameters::k_ScaleFromDDD, HGCalParameters::k_ScaleToDDD, GetRecoTauVFromDQM_MC_cff::kk, HGCalParameters::lastModule_, HGCalParameters::hgtrap::lay, HGCalParameters::layerFrontBH_, dqm-mbProfile::log, LaserClient_cfi::low, HGCalParameters::minTileSize_, HGCalParameters::nSectors_, HGCalParameters::radiusLayer_, HGCalParameters::rMaxLayHex_, HGCalParameters::rMinLayerBH_, HGCalParameters::rMinLayHex_, HGCalParameters::scintCellSize(), HGCalParameters::scintType(), funct::tan(), HGCalParameters::hgtrap::tl, HGCalParameters::waferThick_, HGCalParameters::waferUVMax_, and HGCalParameters::zLayerHex_.

                                                                {
  // Find the radius of each eta-partitions
  for (unsigned k = 0; k < 2; ++k) {
    double rmax = ((k == 0) ? (php.rMaxLayHex_[php.layerFrontBH_[1] - php.firstLayer_] - 1)
                            : (php.rMaxLayHex_[php.rMaxLayHex_.size() - 1]));
    double rv = php.rMinLayerBH_[k];
    double zv = ((k == 0) ? (php.zLayerHex_[php.layerFrontBH_[1] - php.firstLayer_])
                          : (php.zLayerHex_[php.zLayerHex_.size() - 1]));
    php.radiusLayer_[k].emplace_back(rv);
#ifdef EDM_ML_DEBUG
    double eta = -(std::log(std::tan(0.5 * std::atan(rv / zv))));
    edm::LogVerbatim("HGCalGeom") << "[" << k << "] rmax " << rmax << " Z = " << zv << " dEta = " << php.cellSize_[k]
                                  << "\n[0] new R = " << rv << " Eta = " << eta;
    int kount(1);
#endif
    while (rv < rmax) {
      double eta = -(php.cellSize_[k] + std::log(std::tan(0.5 * std::atan(rv / zv))));
      rv = zv * std::tan(2.0 * std::atan(std::exp(-eta)));
      php.radiusLayer_[k].emplace_back(rv);
#ifdef EDM_ML_DEBUG
      edm::LogVerbatim("HGCalGeom") << "[" << kount << "] new R = " << rv << " Eta = " << eta;
      ++kount;
#endif
    }
  }

  // Find minimum and maximum radius index for each layer
  for (unsigned k = 0; k < php.zLayerHex_.size(); ++k) {
    int kk = php.scintType(php.firstLayer_ + (int)(k));
    std::vector<double>::iterator low, high;
    low = std::lower_bound(php.radiusLayer_[kk].begin(), php.radiusLayer_[kk].end(), php.rMinLayHex_[k]);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "[" << k << "] RLow = " << php.rMinLayHex_[k] << " pos "
                                  << (int)(low - php.radiusLayer_[kk].begin());
#endif
    if (low == php.radiusLayer_[kk].begin())
      ++low;
    int irlow = (int)(low - php.radiusLayer_[kk].begin());
    double drlow = php.radiusLayer_[kk][irlow] - php.rMinLayHex_[k];
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "irlow " << irlow << " dr " << drlow << " min " << php.minTileSize_;
#endif
    if (drlow < php.minTileSize_) {
      ++irlow;
#ifdef EDM_ML_DEBUG
      drlow = php.radiusLayer_[kk][irlow] - php.rMinLayHex_[k];
      edm::LogVerbatim("HGCalGeom") << "Modified irlow " << irlow << " dr " << drlow;
#endif
    }
    high = std::lower_bound(php.radiusLayer_[kk].begin(), php.radiusLayer_[kk].end(), php.rMaxLayHex_[k]);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "[" << k << "] RHigh = " << php.rMaxLayHex_[k] << " pos "
                                  << (int)(high - php.radiusLayer_[kk].begin());
#endif
    if (high == php.radiusLayer_[kk].end())
      --high;
    int irhigh = (int)(high - php.radiusLayer_[kk].begin());
    double drhigh = php.rMaxLayHex_[k] - php.radiusLayer_[kk][irhigh - 1];
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "irhigh " << irhigh << " dr " << drhigh << " min " << php.minTileSize_;
#endif
    if (drhigh < php.minTileSize_) {
      --irhigh;
#ifdef EDM_ML_DEBUG
      drhigh = php.rMaxLayHex_[k] - php.radiusLayer_[kk][irhigh - 1];
      edm::LogVerbatim("HGCalGeom") << "Modified irhigh " << irhigh << " dr " << drhigh;
#endif
    }
    php.iradMinBH_.emplace_back(irlow);
    php.iradMaxBH_.emplace_back(irhigh);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGcalGeom") << "Layer " << k << " Type " << kk << " Low edge " << irlow << ":" << drlow
                                  << " Top edge " << irhigh << ":" << drhigh;
#endif
  }

  // Now define the volumes
  int im(0);
  php.waferUVMax_ = 0;
  HGCalParameters::hgtrap mytr;
  mytr.alpha = 0.0;
  for (unsigned int k = 0; k < php.zLayerHex_.size(); ++k) {
    if (php.iradMaxBH_[k] > php.waferUVMax_)
      php.waferUVMax_ = php.iradMaxBH_[k];
    int kk = ((php.firstLayer_ + (int)(k)) < php.layerFrontBH_[1]) ? 0 : 1;
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "Layer " << php.firstLayer_ + k << ":" << kk << " Radius range "
                                  << php.iradMinBH_[k] << ":" << php.iradMaxBH_[k];
#endif
    mytr.lay = php.firstLayer_ + k;
    for (int irad = php.iradMinBH_[k]; irad <= php.iradMaxBH_[k]; ++irad) {
      double rmin = php.radiusLayer_[kk][irad - 1];
      double rmax = php.radiusLayer_[kk][irad];
      mytr.bl = 0.5 * rmin * php.scintCellSize(mytr.lay);
      mytr.tl = 0.5 * rmax * php.scintCellSize(mytr.lay);
      mytr.h = 0.5 * (rmax - rmin);
      mytr.dz = 0.5 * php.waferThick_;
      mytr.cellSize = 0.5 * (rmax + rmin) * php.scintCellSize(mytr.lay);
      php.fillModule(mytr, true);
      mytr.bl *= HGCalParameters::k_ScaleToDDD;
      mytr.tl *= HGCalParameters::k_ScaleToDDD;
      mytr.h *= HGCalParameters::k_ScaleToDDD;
      mytr.dz *= HGCalParameters::k_ScaleToDDD;
      mytr.cellSize *= HGCalParameters::k_ScaleFromDDD;
      php.fillModule(mytr, false);
      if (irad == php.iradMinBH_[k])
        php.firstModule_.emplace_back(im);
      ++im;
      if (irad == php.iradMaxBH_[k] - 1)
        php.lastModule_.emplace_back(im);
    }
  }
  php.nSectors_ = php.waferUVMax_;
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "Maximum radius index " << php.waferUVMax_;
  for (unsigned int k = 0; k < php.firstModule_.size(); ++k)
    edm::LogVerbatim("HGCalGeom") << "Layer " << k + php.firstLayer_ << " Modules " << php.firstModule_[k] << ":"
                                  << php.lastModule_[k];
#endif
}

void HGCalGeomParameters::loadGeometryHexagon	(	const DDFilteredView &	_fv,
		HGCalParameters &	php,
		const std::string &	sdTag1,
		const DDCompactView *	cpv,
		const std::string &	sdTag2,
		const std::string &	sdTag3,
		HGCalGeometryMode::WaferMode	mode
	)

Definition at line 40 of file HGCalGeomParameters.cc.

References funct::abs(), HGCalParameters::hgtrap::alpha, HGCalParameters::hgtrap::bl, HGCalParameters::hgtrap::cellSize, HGCalParameters::cellSize_, filterCSVwithJSON::copy, DDFilteredView::copyNumbers(), funct::cos(), SimDataFormats::CaloAnalysis::cp, ddpolyhedra_rrz, ddpolyhedra_rz, ddtubs, HGCalParameters::hgtrap::dz, PVValHelper::dz, Exception, HGCalParameters::fillModule(), spr::find(), DDFilteredView::firstChild(), HGCalParameters::hgtrap::h, AnalysisDataFormats_SUSYBSMObjects::hr, createfilelist::int, HGCalParameters::k_ScaleFromDDD, HGCalParameters::hgtrap::lay, HGCalParameters::layer_, hgcalTopologyTester_cfi::layers, DDFilteredView::logicalPart(), Skims_PA_cff::name, DDName::name(), DDBase< N, C >::name(), names, DDFilteredView::next(), convertSQLiteXML::ok, AlCaHLTBitMon_ParallelJobs::p, p1, p2, HGCalGeometryMode::Polyhedra, DDTubs::rIn(), DDPolyhedra::rMaxVec(), DDPolyhedra::rMinVec(), idealTransformation::rotation, DDFilteredView::rotation(), DDTubs::rOut(), DDSolid::shape(), DDLogicalPart::solid(), AlCaHLTBitMon_QueryRunRegistry::string, HGCalParameters::hgtrap::tl, tolerance, DDFilteredView::translation(), HGCalParameters::waferR_, waferSize_, HGCalParameters::waferSize_, x, DDExtrudedPolygon::xVec(), geometryCSVtoXML::xx, y, geometryCSVtoXML::yy, z, HGCalParameters::hgtrform::zp, DDPolyhedra::zVec(), and DDExtrudedPolygon::zVec().

Referenced by HGCalGeomParameters::cellParameters::cellParameters().

                                                                               {
  DDFilteredView fv = _fv;
  bool dodet(true);
  std::map<int, HGCalGeomParameters::layerParameters> layers;
  std::vector<HGCalParameters::hgtrform> trforms;
  std::vector<bool> trformUse;

  while (dodet) {
    const DDSolid& sol = fv.logicalPart().solid();
    // Layers first
    std::vector<int> copy = fv.copyNumbers();
    int nsiz = (int)(copy.size());
    int lay = (nsiz > 0) ? copy[nsiz - 1] : 0;
    int zp = (nsiz > 2) ? copy[nsiz - 3] : -1;
    if (zp != 1)
      zp = -1;
    if (lay == 0) {
      throw cms::Exception("DDException") << "Funny layer # " << lay << " zp " << zp << " in " << nsiz << " components";
    } else {
      if (std::find(php.layer_.begin(), php.layer_.end(), lay) == php.layer_.end())
        php.layer_.emplace_back(lay);
      auto itr = layers.find(lay);
      if (itr == layers.end()) {
        double rin(0), rout(0);
        if ((sol.shape() == DDSolidShape::ddpolyhedra_rz) || (sol.shape() == DDSolidShape::ddpolyhedra_rrz)) {
          const DDPolyhedra& polyhedra = static_cast<DDPolyhedra>(sol);
          const std::vector<double>& rmin = polyhedra.rMinVec();
          const std::vector<double>& rmax = polyhedra.rMaxVec();
          rin = 0.5 * HGCalParameters::k_ScaleFromDDD * (rmin[0] + rmin[1]);
          rout = 0.5 * HGCalParameters::k_ScaleFromDDD * (rmax[0] + rmax[1]);
        } else if (sol.shape() == DDSolidShape::ddtubs) {
          const DDTubs& tube = static_cast<DDTubs>(sol);
          rin = HGCalParameters::k_ScaleFromDDD * tube.rIn();
          rout = HGCalParameters::k_ScaleFromDDD * tube.rOut();
        }
        double zp = HGCalParameters::k_ScaleFromDDD * fv.translation().Z();
        HGCalGeomParameters::layerParameters laypar(rin, rout, zp);
        layers[lay] = laypar;
      }
      DD3Vector x, y, z;
      fv.rotation().GetComponents(x, y, z);
      const CLHEP::HepRep3x3 rotation(x.X(), y.X(), z.X(), x.Y(), y.Y(), z.Y(), x.Z(), y.Z(), z.Z());
      const CLHEP::HepRotation hr(rotation);
      double xx = HGCalParameters::k_ScaleFromDDD * fv.translation().X();
      if (std::abs(xx) < tolerance)
        xx = 0;
      double yy = HGCalParameters::k_ScaleFromDDD * fv.translation().Y();
      if (std::abs(yy) < tolerance)
        yy = 0;
      const CLHEP::Hep3Vector h3v(xx, yy, fv.translation().Z());
      HGCalParameters::hgtrform mytrf;
      mytrf.zp = zp;
      mytrf.lay = lay;
      mytrf.sec = 0;
      mytrf.subsec = 0;
      mytrf.h3v = h3v;
      mytrf.hr = hr;
      trforms.emplace_back(mytrf);
      trformUse.emplace_back(false);
    }
    dodet = fv.next();
  }

  // Then wafers
  // This assumes layers are build starting from 1 (which on 25 Jan 2016, they
  // were) to ensure that new copy numbers are always added to the end of the
  // list.
  std::unordered_map<int32_t, int32_t> copies;
  HGCalParameters::layer_map copiesInLayers(layers.size() + 1);
  std::vector<int32_t> wafer2copy;
  std::vector<HGCalGeomParameters::cellParameters> wafers;
  std::string attribute = "Volume";
  DDValue val1(attribute, sdTag2, 0.0);
  DDSpecificsMatchesValueFilter filter1{val1};
  DDFilteredView fv1(*cpv, filter1);
  bool ok = fv1.firstChild();
  if (!ok) {
    edm::LogError("HGCalGeom") << " Attribute " << val1 << " not found but needed.";
    throw cms::Exception("DDException") << "Attribute " << val1 << " not found but needed.";
  } else {
    dodet = true;
    std::unordered_set<std::string> names;
    while (dodet) {
      const DDSolid& sol = fv1.logicalPart().solid();
      const std::string& name = fv1.logicalPart().name().name();
      std::vector<int> copy = fv1.copyNumbers();
      int nsiz = (int)(copy.size());
      int wafer = (nsiz > 0) ? copy[nsiz - 1] : 0;
      int layer = (nsiz > 1) ? copy[nsiz - 2] : 0;
      if (nsiz < 2) {
        edm::LogError("HGCalGeom") << "Funny wafer # " << wafer << " in " << nsiz << " components";
        throw cms::Exception("DDException") << "Funny wafer # " << wafer;
      } else if (layer > (int)(layers.size())) {
        edm::LogWarning("HGCalGeom") << "Funny wafer # " << wafer << " Layer " << layer << ":" << layers.size()
                                     << " among " << nsiz << " components";
      } else {
        auto itr = copies.find(wafer);
        auto cpy = copiesInLayers[layer].find(wafer);
        if (itr != copies.end() && cpy == copiesInLayers[layer].end()) {
          copiesInLayers[layer][wafer] = itr->second;
        }
        if (itr == copies.end()) {
          copies[wafer] = wafer2copy.size();
          copiesInLayers[layer][wafer] = wafer2copy.size();
          double xx = HGCalParameters::k_ScaleFromDDD * fv1.translation().X();
          if (std::abs(xx) < tolerance)
            xx = 0;
          double yy = HGCalParameters::k_ScaleFromDDD * fv1.translation().Y();
          if (std::abs(yy) < tolerance)
            yy = 0;
          wafer2copy.emplace_back(wafer);
          GlobalPoint p(xx, yy, HGCalParameters::k_ScaleFromDDD * fv1.translation().Z());
          HGCalGeomParameters::cellParameters cell(false, wafer, p);
          wafers.emplace_back(cell);
          if (names.count(name) == 0) {
            std::vector<double> zv, rv;
            if (mode == HGCalGeometryMode::Polyhedra) {
              const DDPolyhedra& polyhedra = static_cast<DDPolyhedra>(sol);
              zv = polyhedra.zVec();
              rv = polyhedra.rMaxVec();
            } else {
              const DDExtrudedPolygon& polygon = static_cast<DDExtrudedPolygon>(sol);
              zv = polygon.zVec();
              rv = polygon.xVec();
            }
            php.waferR_ = rv[0] / std::cos(30._deg);
            php.waferSize_ = HGCalParameters::k_ScaleFromDDD * rv[0];
            double dz = 0.5 * (zv[1] - zv[0]);
#ifdef EDM_ML_DEBUG
            edm::LogVerbatim("HGCalGeom")
                << "Mode " << mode << " R " << php.waferSize_ << ":" << php.waferR_ << " z " << dz;
#endif
            HGCalParameters::hgtrap mytr;
            mytr.lay = 1;
            mytr.bl = php.waferR_;
            mytr.tl = php.waferR_;
            mytr.h = php.waferR_;
            mytr.dz = dz;
            mytr.alpha = 0.0;
            mytr.cellSize = waferSize_;
            php.fillModule(mytr, false);
            names.insert(name);
          }
        }
      }
      dodet = fv1.next();
    }
  }

  // Finally the cells
  std::map<int, int> wafertype;
  std::map<int, HGCalGeomParameters::cellParameters> cellsf, cellsc;
  DDValue val2(attribute, sdTag3, 0.0);
  DDSpecificsMatchesValueFilter filter2{val2};
  DDFilteredView fv2(*cpv, filter2);
  ok = fv2.firstChild();
  if (!ok) {
    edm::LogError("HGCalGeom") << " Attribute " << val2 << " not found but needed.";
    throw cms::Exception("DDException") << "Attribute " << val2 << " not found but needed.";
  } else {
    dodet = true;
    while (dodet) {
      const DDSolid& sol = fv2.logicalPart().solid();
      const std::string& name = sol.name().name();
      std::vector<int> copy = fv2.copyNumbers();
      int nsiz = (int)(copy.size());
      int cellx = (nsiz > 0) ? copy[nsiz - 1] : 0;
      int wafer = (nsiz > 1) ? copy[nsiz - 2] : 0;
      int cell = cellx % 1000;
      int type = cellx / 1000;
      if (type != 1 && type != 2) {
        edm::LogError("HGCalGeom") << "Funny cell # " << cell << " type " << type << " in " << nsiz << " components";
        throw cms::Exception("DDException") << "Funny cell # " << cell;
      } else {
        auto ktr = wafertype.find(wafer);
        if (ktr == wafertype.end())
          wafertype[wafer] = type;
        bool newc(false);
        std::map<int, HGCalGeomParameters::cellParameters>::iterator itr;
        double cellsize = php.cellSize_[0];
        if (type == 1) {
          itr = cellsf.find(cell);
          newc = (itr == cellsf.end());
        } else {
          itr = cellsc.find(cell);
          newc = (itr == cellsc.end());
          cellsize = php.cellSize_[1];
        }
        if (newc) {
          bool half = (name.find("Half") != std::string::npos);
          double xx = HGCalParameters::k_ScaleFromDDD * fv2.translation().X();
          double yy = HGCalParameters::k_ScaleFromDDD * fv2.translation().Y();
          if (half) {
            math::XYZPointD p1(-2.0 * cellsize / 9.0, 0, 0);
            math::XYZPointD p2 = fv2.rotation()(p1);
            xx += (HGCalParameters::k_ScaleFromDDD * (p2.X()));
            yy += (HGCalParameters::k_ScaleFromDDD * (p2.Y()));
#ifdef EDM_ML_DEBUG
            edm::LogVerbatim("HGCalGeom")
                << "Type " << type << " Cell " << cellx << " local " << xx << ":" << yy << " new " << p1 << ":" << p2;
#endif
          }
          HGCalGeomParameters::cellParameters cp(half, wafer, GlobalPoint(xx, yy, 0));
          if (type == 1) {
            cellsf[cell] = cp;
          } else {
            cellsc[cell] = cp;
          }
        }
      }
      dodet = fv2.next();
    }
  }

  loadGeometryHexagon(
      layers, trforms, trformUse, copies, copiesInLayers, wafer2copy, wafers, wafertype, cellsf, cellsc, php);
}

void HGCalGeomParameters::loadGeometryHexagon	(	const cms::DDFilteredView &	fv,
		HGCalParameters &	php,
		const std::string &	sdTag1,
		const cms::DDCompactView *	cpv,
		const std::string &	sdTag2,
		const std::string &	sdTag3,
		HGCalGeometryMode::WaferMode	mode
	)

Definition at line 264 of file HGCalGeomParameters.cc.

                                                                               {}

void HGCalGeomParameters::loadGeometryHexagon ( const std::map< int, HGCalGeomParameters::layerParameters > &  layers, std::vector< HGCalParameters::hgtrform > &  trforms, std::vector< bool > &  trformUse, const std::unordered_map< int32_t, int32_t > &  copies, const HGCalParameters::layer_map &  copiesInLayers, const std::vector< int32_t > &  wafer2copy, const std::vector< HGCalGeomParameters::cellParameters > &  wafers, const std::map< int, int > &  wafertype, const std::map< int, HGCalGeomParameters::cellParameters > &  cellsf, const std::map< int, HGCalGeomParameters::cellParameters > &  cellsc, HGCalParameters &  php  )

private

Definition at line 272 of file HGCalGeomParameters.cc.

References HGCalParameters::addTrForm(), HGCalParameters::hgtrap::bl, HGCalParameters::boundR_, HGCalParameters::cellCoarseHalf_, HGCalParameters::cellCoarseX_, HGCalParameters::cellCoarseY_, HGCalParameters::cellFineHalf_, HGCalParameters::cellFineX_, HGCalParameters::cellFineY_, cellPosition(), HGCalParameters::hgtrap::cellSize, HGCalParameters::copiesInLayers_, TauDecayModes::dec, LEDCalibrationChannels::depth, HGCalParameters::depth_, HGCalParameters::depthIndex_, HGCalParameters::depthLayerF_, HGCalParameters::hgtrap::dz, PVValHelper::dz, Exception, HGCalParameters::fillModule(), HGCalParameters::fillTrForm(), dqmdumpme::first, HGCalParameters::firstLayer_, HGCalParameters::getModule(), HGCalParameters::hgtrap::h, mps_fire::i, testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, createfilelist::int, dqmdumpme::k, HGCalParameters::k_ScaleFromDDD, HGCalParameters::layer_, HGCalParameters::layerGroup_, HGCalParameters::layerIndex_, HGCalParameters::moduleAlphaR_, HGCalParameters::moduleAlphaS_, HGCalParameters::moduleBlR_, HGCalParameters::moduleBlS_, HGCalParameters::moduleDzR_, HGCalParameters::moduleDzS_, HGCalParameters::moduleHR_, HGCalParameters::moduleHS_, HGCalParameters::moduleLayR_, HGCalParameters::moduleLayS_, HGCalParameters::moduleTlR_, HGCalParameters::moduleTlS_, HGCalParameters::nSectors_, alignCSCRings::r, HGCalParameters::rMaxLayHex_, HGCalParameters::rMinLayHex_, HGCalParameters::scaleTrForm(), HGCalParameters::hgtrap::tl, HGCalParameters::trformIndex_, HGCalParameters::trformRotXX_, HGCalParameters::trformRotXY_, HGCalParameters::trformRotXZ_, HGCalParameters::trformRotYX_, HGCalParameters::trformRotYY_, HGCalParameters::trformRotYZ_, HGCalParameters::trformRotZX_, HGCalParameters::trformRotZY_, HGCalParameters::trformRotZZ_, HGCalParameters::trformTranX_, HGCalParameters::trformTranY_, HGCalParameters::trformTranZ_, HGCalParameters::waferCopy_, HGCalParameters::waferPosX_, HGCalParameters::waferPosY_, HGCalParameters::waferR_, HGCalParameters::waferTypeL_, HGCalParameters::waferTypeT_, geometryCSVtoXML::xx, geometryCSVtoXML::xy, geometryCSVtoXML::yy, and HGCalParameters::zLayerHex_.

                                                                    {
  if (((cellsf.size() + cellsc.size()) == 0) || (wafers.empty()) || (layers.empty())) {
    edm::LogError("HGCalGeom") << "HGCalGeomParameters : number of cells " << cellsf.size() << ":" << cellsc.size()
                               << " wafers " << wafers.size() << " layers " << layers.size() << " illegal";
    throw cms::Exception("DDException") << "HGCalGeomParameters: mismatch between geometry and specpar: cells "
                                        << cellsf.size() << ":" << cellsc.size() << " wafers " << wafers.size()
                                        << " layers " << layers.size();
  }

  for (unsigned int i = 0; i < layers.size(); ++i) {
    for (auto& layer : layers) {
      if (layer.first == (int)(i + php.firstLayer_)) {
        php.layerIndex_.emplace_back(i);
        php.rMinLayHex_.emplace_back(layer.second.rmin);
        php.rMaxLayHex_.emplace_back(layer.second.rmax);
        php.zLayerHex_.emplace_back(layer.second.zpos);
        break;
      }
    }
  }
  for (unsigned int i = 0; i < php.layer_.size(); ++i) {
    for (unsigned int i1 = 0; i1 < trforms.size(); ++i1) {
      if (!trformUse[i1] && php.layerGroup_[trforms[i1].lay - 1] == (int)(i + 1)) {
        trforms[i1].h3v *= static_cast<double>(HGCalParameters::k_ScaleFromDDD);
        trforms[i1].lay = (i + 1);
        trformUse[i1] = true;
        php.fillTrForm(trforms[i1]);
        int nz(1);
        for (unsigned int i2 = i1 + 1; i2 < trforms.size(); ++i2) {
          if (!trformUse[i2] && trforms[i2].zp == trforms[i1].zp &&
              php.layerGroup_[trforms[i2].lay - 1] == (int)(i + 1)) {
            php.addTrForm(HGCalParameters::k_ScaleFromDDD * trforms[i2].h3v);
            nz++;
            trformUse[i2] = true;
          }
        }
        if (nz > 0) {
          php.scaleTrForm(double(1.0 / nz));
        }
      }
    }
  }

  double rmin = HGCalParameters::k_ScaleFromDDD * php.waferR_;
  for (unsigned i = 0; i < wafer2copy.size(); ++i) {
    php.waferCopy_.emplace_back(wafer2copy[i]);
    php.waferPosX_.emplace_back(wafers[i].xyz.x());
    php.waferPosY_.emplace_back(wafers[i].xyz.y());
    auto ktr = wafertype.find(wafer2copy[i]);
    int typet = (ktr == wafertype.end()) ? 0 : (ktr->second);
    php.waferTypeT_.emplace_back(typet);
    double r = wafers[i].xyz.perp();
    int type(3);
    for (int k = 1; k < 4; ++k) {
      if ((r + rmin) <= php.boundR_[k]) {
        type = k;
        break;
      }
    }
    php.waferTypeL_.emplace_back(type);
  }
  php.copiesInLayers_ = copiesInLayers;
  php.nSectors_ = (int)(php.waferCopy_.size());

  std::vector<HGCalGeomParameters::cellParameters>::const_iterator itrf = wafers.end();
  for (unsigned int i = 0; i < cellsf.size(); ++i) {
    auto itr = cellsf.find(i);
    if (itr == cellsf.end()) {
      edm::LogError("HGCalGeom") << "HGCalGeomParameters: missing info for"
                                 << " fine cell number " << i;
      throw cms::Exception("DDException") << "HGCalGeomParameters: missing info for fine cell number " << i;
    } else {
      double xx = (itr->second).xyz.x();
      double yy = (itr->second).xyz.y();
      int waf = (itr->second).wafer;
      std::pair<double, double> xy = cellPosition(wafers, itrf, waf, xx, yy);
      php.cellFineX_.emplace_back(xy.first);
      php.cellFineY_.emplace_back(xy.second);
      php.cellFineHalf_.emplace_back((itr->second).half);
    }
  }
  itrf = wafers.end();
  for (unsigned int i = 0; i < cellsc.size(); ++i) {
    auto itr = cellsc.find(i);
    if (itr == cellsc.end()) {
      edm::LogError("HGCalGeom") << "HGCalGeomParameters: missing info for"
                                 << " coarse cell number " << i;
      throw cms::Exception("DDException") << "HGCalGeomParameters: missing info for coarse cell number " << i;
    } else {
      double xx = (itr->second).xyz.x();
      double yy = (itr->second).xyz.y();
      int waf = (itr->second).wafer;
      std::pair<double, double> xy = cellPosition(wafers, itrf, waf, xx, yy);
      php.cellCoarseX_.emplace_back(xy.first);
      php.cellCoarseY_.emplace_back(xy.second);
      php.cellCoarseHalf_.emplace_back((itr->second).half);
    }
  }
  int depth(0);
  for (unsigned int i = 0; i < php.layerGroup_.size(); ++i) {
    bool first(true);
    for (unsigned int k = 0; k < php.layerGroup_.size(); ++k) {
      if (php.layerGroup_[k] == (int)(i + 1)) {
        if (first) {
          php.depth_.emplace_back(i + 1);
          php.depthIndex_.emplace_back(depth);
          php.depthLayerF_.emplace_back(k);
          ++depth;
          first = false;
        }
      }
    }
  }
  HGCalParameters::hgtrap mytr = php.getModule(0, false);
  mytr.bl *= HGCalParameters::k_ScaleFromDDD;
  mytr.tl *= HGCalParameters::k_ScaleFromDDD;
  mytr.h *= HGCalParameters::k_ScaleFromDDD;
  mytr.dz *= HGCalParameters::k_ScaleFromDDD;
  mytr.cellSize *= HGCalParameters::k_ScaleFromDDD;
  double dz = mytr.dz;
  php.fillModule(mytr, true);
  mytr.dz = 2 * dz;
  php.fillModule(mytr, true);
  mytr.dz = 3 * dz;
  php.fillModule(mytr, true);
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters finds " << php.zLayerHex_.size() << " layers";
  for (unsigned int i = 0; i < php.zLayerHex_.size(); ++i) {
    int k = php.layerIndex_[i];
    edm::LogVerbatim("HGCalGeom") << "Layer[" << i << ":" << k << ":" << php.layer_[k]
                                  << "] with r = " << php.rMinLayHex_[i] << ":" << php.rMaxLayHex_[i]
                                  << " at z = " << php.zLayerHex_[i];
  }
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters has " << php.depthIndex_.size() << " depths";
  for (unsigned int i = 0; i < php.depthIndex_.size(); ++i) {
    int k = php.depthIndex_[i];
    edm::LogVerbatim("HGCalGeom") << "Reco Layer[" << i << ":" << k << "]  First Layer " << php.depthLayerF_[i]
                                  << " Depth " << php.depth_[k];
  }
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters finds " << php.nSectors_ << " wafers";
  for (unsigned int i = 0; i < php.waferCopy_.size(); ++i)
    edm::LogVerbatim("HGCalGeom") << "Wafer[" << i << ": " << php.waferCopy_[i] << "] type " << php.waferTypeL_[i]
                                  << ":" << php.waferTypeT_[i] << " at (" << php.waferPosX_[i] << ","
                                  << php.waferPosY_[i] << ",0)";
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters: wafer radius " << php.waferR_ << " and dimensions of the "
                                << "wafers:";
  edm::LogVerbatim("HGCalGeom") << "Sim[0] " << php.moduleLayS_[0] << " dx " << php.moduleBlS_[0] << ":"
                                << php.moduleTlS_[0] << " dy " << php.moduleHS_[0] << " dz " << php.moduleDzS_[0]
                                << " alpha " << php.moduleAlphaS_[0];
  for (unsigned int k = 0; k < php.moduleLayR_.size(); ++k)
    edm::LogVerbatim("HGCalGeom") << "Rec[" << k << "] " << php.moduleLayR_[k] << " dx " << php.moduleBlR_[k] << ":"
                                  << php.moduleTlR_[k] << " dy " << php.moduleHR_[k] << " dz " << php.moduleDzR_[k]
                                  << " alpha " << php.moduleAlphaR_[k];
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters finds " << php.cellFineX_.size() << " fine cells in a  wafer";
  for (unsigned int i = 0; i < php.cellFineX_.size(); ++i)
    edm::LogVerbatim("HGCalGeom") << "Fine Cell[" << i << "] at (" << php.cellFineX_[i] << "," << php.cellFineY_[i]
                                  << ",0)";
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters finds " << php.cellCoarseX_.size()
                                << " coarse cells in a wafer";
  for (unsigned int i = 0; i < php.cellCoarseX_.size(); ++i)
    edm::LogVerbatim("HGCalGeom") << "Coarse Cell[" << i << "] at (" << php.cellCoarseX_[i] << ","
                                  << php.cellCoarseY_[i] << ",0)";
  edm::LogVerbatim("HGCalGeom") << "Obtained " << php.trformIndex_.size() << " transformation matrices";
  for (unsigned int k = 0; k < php.trformIndex_.size(); ++k) {
    edm::LogVerbatim("HGCalGeom") << "Matrix[" << k << "] (" << std::hex << php.trformIndex_[k] << std::dec
                                  << ") Translation (" << php.trformTranX_[k] << ", " << php.trformTranY_[k] << ", "
                                  << php.trformTranZ_[k] << " Rotation (" << php.trformRotXX_[k] << ", "
                                  << php.trformRotYX_[k] << ", " << php.trformRotZX_[k] << ", " << php.trformRotXY_[k]
                                  << ", " << php.trformRotYY_[k] << ", " << php.trformRotZY_[k] << ", "
                                  << php.trformRotXZ_[k] << ", " << php.trformRotYZ_[k] << ", " << php.trformRotZZ_[k]
                                  << ")";
  }
  edm::LogVerbatim("HGCalGeom") << "Dump copiesInLayers for " << php.copiesInLayers_.size() << " layers";
  for (unsigned int k = 0; k < php.copiesInLayers_.size(); ++k) {
    const auto& theModules = php.copiesInLayers_[k];
    edm::LogVerbatim("HGCalGeom") << "Layer " << k << ":" << theModules.size();
    int k2(0);
    for (std::unordered_map<int, int>::const_iterator itr = theModules.begin(); itr != theModules.end(); ++itr, ++k2) {
      edm::LogVerbatim("HGCalGeom") << "[" << k2 << "] " << itr->first << ":" << itr->second;
    }
  }
#endif
}

void HGCalGeomParameters::loadGeometryHexagon8	(	const DDFilteredView &	_fv,
		HGCalParameters &	php,
		int	firstLayer
	)

Definition at line 466 of file HGCalGeomParameters.cc.

References funct::abs(), filterCSVwithJSON::copy, DDFilteredView::copyNumbers(), Exception, spr::find(), AnalysisDataFormats_SUSYBSMObjects::hr, createfilelist::int, HGCalParameters::k_ScaleFromDDD, HGCalParameters::layer_, hgcalTopologyTester_cfi::layers, HGCalParameters::levelT_, HGCalParameters::levelZSide_, DDFilteredView::logicalPart(), SiStripPI::max, DDFilteredView::next(), DDTubs::rIn(), idealTransformation::rotation, DDFilteredView::rotation(), DDTubs::rOut(), DDLogicalPart::solid(), tolerance, DDFilteredView::translation(), x, geometryCSVtoXML::xx, y, geometryCSVtoXML::yy, z, HGCalParameters::hgtrform::zp, and ecaldqm::zside().

Referenced by HGCalGeomParameters::cellParameters::cellParameters().

                                                                                                              {
  DDFilteredView fv = _fv;
  bool dodet(true);
  std::map<int, HGCalGeomParameters::layerParameters> layers;
  std::map<std::pair<int, int>, HGCalParameters::hgtrform> trforms;
  int levelTop = 3 + std::max(php.levelT_[0], php.levelT_[1]);
  while (dodet) {
    const DDSolid& sol = fv.logicalPart().solid();
    // Layers first
    std::vector<int> copy = fv.copyNumbers();
    int nsiz = (int)(copy.size());
    int lay = (nsiz > levelTop) ? copy[nsiz - 4] : copy[nsiz - 1];
    int zside = (nsiz > php.levelZSide_) ? copy[php.levelZSide_] : -1;
    if (zside != 1)
      zside = -1;
    if (lay == 0) {
      edm::LogError("HGCalGeom") << "Funny layer # " << lay << " zp " << zside << " in " << nsiz << " components";
      throw cms::Exception("DDException") << "Funny layer # " << lay;
    } else {
      if (std::find(php.layer_.begin(), php.layer_.end(), lay) == php.layer_.end())
        php.layer_.emplace_back(lay);
      auto itr = layers.find(lay);
      if (itr == layers.end()) {
        const DDTubs& tube = static_cast<DDTubs>(sol);
        double rin = HGCalParameters::k_ScaleFromDDD * tube.rIn();
        double rout = HGCalParameters::k_ScaleFromDDD * tube.rOut();
        double zp = HGCalParameters::k_ScaleFromDDD * fv.translation().Z();
        HGCalGeomParameters::layerParameters laypar(rin, rout, zp);
        layers[lay] = laypar;
      }
      if (trforms.find(std::make_pair(lay, zside)) == trforms.end()) {
        DD3Vector x, y, z;
        fv.rotation().GetComponents(x, y, z);
        const CLHEP::HepRep3x3 rotation(x.X(), y.X(), z.X(), x.Y(), y.Y(), z.Y(), x.Z(), y.Z(), z.Z());
        const CLHEP::HepRotation hr(rotation);
        double xx = ((std::abs(fv.translation().X()) < tolerance) ? 0 : fv.translation().X());
        double yy = ((std::abs(fv.translation().Y()) < tolerance) ? 0 : fv.translation().Y());
        const CLHEP::Hep3Vector h3v(xx, yy, fv.translation().Z());
        HGCalParameters::hgtrform mytrf;
        mytrf.zp = zside;
        mytrf.lay = lay;
        mytrf.sec = 0;
        mytrf.subsec = 0;
        mytrf.h3v = h3v;
        mytrf.hr = hr;
        trforms[std::make_pair(lay, zside)] = mytrf;
      }
    }
    dodet = fv.next();
  }

  loadGeometryHexagon8(layers, trforms, firstLayer, php);
}

void HGCalGeomParameters::loadGeometryHexagon8	(	const cms::DDFilteredView &	_fv,
		HGCalParameters &	php,
		int	firstLayer
	)

Definition at line 520 of file HGCalGeomParameters.cc.

{}

void HGCalGeomParameters::loadGeometryHexagon8 ( const std::map< int, HGCalGeomParameters::layerParameters > &  layers, std::map< std::pair< int, int >, HGCalParameters::hgtrform > &  trforms, const int &  firstLayer, HGCalParameters &  php  )

private

Definition at line 522 of file HGCalGeomParameters.cc.

References TauDecayModes::dec, HGCalParameters::depth_, HGCalParameters::depthIndex_, HGCalParameters::depthLayerF_, HGCalParameters::fillTrForm(), mps_fire::i, dqmdumpme::k, HGCalParameters::k_ScaleFromDDD, HGCalParameters::layer_, HGCalParameters::layerIndex_, HGCalParameters::rLimit_, HGCalParameters::rMaxLayHex_, HGCalParameters::rMinLayHex_, HGCalParameters::trformIndex_, HGCalParameters::trformRotXX_, HGCalParameters::trformRotXY_, HGCalParameters::trformRotXZ_, HGCalParameters::trformRotYX_, HGCalParameters::trformRotYY_, HGCalParameters::trformRotYZ_, HGCalParameters::trformRotZX_, HGCalParameters::trformRotZY_, HGCalParameters::trformRotZZ_, HGCalParameters::trformTranX_, HGCalParameters::trformTranY_, HGCalParameters::trformTranZ_, and HGCalParameters::zLayerHex_.

                                                                     {
  double rmin(0), rmax(0);
  for (unsigned int i = 0; i < layers.size(); ++i) {
    for (auto& layer : layers) {
      if (layer.first == (int)(i + firstLayer)) {
        php.layerIndex_.emplace_back(i);
        php.rMinLayHex_.emplace_back(layer.second.rmin);
        php.rMaxLayHex_.emplace_back(layer.second.rmax);
        php.zLayerHex_.emplace_back(layer.second.zpos);
        if (i == 0) {
          rmin = layer.second.rmin;
          rmax = layer.second.rmax;
        } else {
          if (rmin > layer.second.rmin)
            rmin = layer.second.rmin;
          if (rmax < layer.second.rmax)
            rmax = layer.second.rmax;
        }
        break;
      }
    }
  }
  php.rLimit_.emplace_back(rmin);
  php.rLimit_.emplace_back(rmax);
  php.depth_ = php.layer_;
  php.depthIndex_ = php.layerIndex_;
  php.depthLayerF_ = php.layerIndex_;

  for (unsigned int i = 0; i < php.layer_.size(); ++i) {
    for (auto& trform : trforms) {
      if (trform.first.first == (int)(i + firstLayer)) {
        trform.second.h3v *= HGCalParameters::k_ScaleFromDDD;
        php.fillTrForm(trform.second);
      }
    }
  }

#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters: Minimum/maximum R " << php.rLimit_[0] << ":" << php.rLimit_[1];
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters finds " << php.zLayerHex_.size() << " layers";
  for (unsigned int i = 0; i < php.zLayerHex_.size(); ++i) {
    int k = php.layerIndex_[i];
    edm::LogVerbatim("HGCalGeom") << "Layer[" << i << ":" << k << ":" << php.layer_[k]
                                  << "] with r = " << php.rMinLayHex_[i] << ":" << php.rMaxLayHex_[i]
                                  << " at z = " << php.zLayerHex_[i];
  }
  edm::LogVerbatim("HGCalGeom") << "Obtained " << php.trformIndex_.size() << " transformation matrices";
  for (unsigned int k = 0; k < php.trformIndex_.size(); ++k) {
    edm::LogVerbatim("HGCalGeom") << "Matrix[" << k << "] (" << std::hex << php.trformIndex_[k] << std::dec
                                  << ") Translation (" << php.trformTranX_[k] << ", " << php.trformTranY_[k] << ", "
                                  << php.trformTranZ_[k] << " Rotation (" << php.trformRotXX_[k] << ", "
                                  << php.trformRotYX_[k] << ", " << php.trformRotZX_[k] << ", " << php.trformRotXY_[k]
                                  << ", " << php.trformRotYY_[k] << ", " << php.trformRotZY_[k] << ", "
                                  << php.trformRotXZ_[k] << ", " << php.trformRotYZ_[k] << ", " << php.trformRotZZ_[k]
                                  << ")";
  }
#endif
}

void HGCalGeomParameters::loadSpecParsHexagon	(	const DDFilteredView &	fv,
		HGCalParameters &	php,
		const DDCompactView *	cpv,
		const std::string &	sdTag1,
		const std::string &	sdTag2
	)

Definition at line 584 of file HGCalGeomParameters.cc.

References HGCalParameters::boundR_, HGCalParameters::cellSize_, dbl_to_int(), DDFilteredView::firstChild(), getDDDArray(), HGCalParameters::k_ScaleFromDDD, HGCalParameters::layerGroup_, HGCalParameters::layerGroupM_, HGCalParameters::layerGroupO_, HGCalParameters::levelT_, DDFilteredView::mergedSpecifics(), rescale(), HGCalParameters::rLimit_, HGCalParameters::slopeMin_, AlCaHLTBitMon_QueryRunRegistry::string, pfDeepBoostedJetPreprocessParams_cfi::sv, and waferSize_.

Referenced by HGCalGeomParameters::cellParameters::cellParameters(), and loadSpecParsHexagon().

                                                                       {
  DDsvalues_type sv(fv.mergedSpecifics());
  php.boundR_ = getDDDArray("RadiusBound", sv, 4);
  rescale(php.boundR_, HGCalParameters::k_ScaleFromDDD);
  php.rLimit_ = getDDDArray("RadiusLimits", sv, 2);
  rescale(php.rLimit_, HGCalParameters::k_ScaleFromDDD);
  php.levelT_ = dbl_to_int(getDDDArray("LevelTop", sv, 0));

  // Grouping of layers
  php.layerGroup_ = dbl_to_int(getDDDArray("GroupingZFine", sv, 0));
  php.layerGroupM_ = dbl_to_int(getDDDArray("GroupingZMid", sv, 0));
  php.layerGroupO_ = dbl_to_int(getDDDArray("GroupingZOut", sv, 0));
  php.slopeMin_ = getDDDArray("Slope", sv, 1);

  // Wafer size
  std::string attribute = "Volume";
  DDSpecificsMatchesValueFilter filter1{DDValue(attribute, sdTag1, 0.0)};
  DDFilteredView fv1(*cpv, filter1);
  if (fv1.firstChild()) {
    DDsvalues_type sv(fv1.mergedSpecifics());
    const auto& dummy = getDDDArray("WaferSize", sv, 0);
    waferSize_ = dummy[0];
  }

  // Cell size
  DDSpecificsMatchesValueFilter filter2{DDValue(attribute, sdTag2, 0.0)};
  DDFilteredView fv2(*cpv, filter2);
  if (fv2.firstChild()) {
    DDsvalues_type sv(fv2.mergedSpecifics());
    php.cellSize_ = getDDDArray("CellSize", sv, 0);
  }

  loadSpecParsHexagon(php);
}

void HGCalGeomParameters::loadSpecParsHexagon	(	const cms::DDFilteredView &	fv,
		HGCalParameters &	php,
		const cms::DDCompactView *	cpv,
		const std::string &	sdTag1,
		const std::string &	sdTag2,
		const std::string &	sdTag3,
		const std::string &	sdTag4
	)

Definition at line 623 of file HGCalGeomParameters.cc.

References HGCalParameters::boundR_, HGCalParameters::cellSize_, dbl_to_int(), cms::DDFilteredView::get(), HGCalParameters::k_ScaleFromDD4Hep, HGCalParameters::k_ScaleFromDD4HepToG4, HGCalParameters::layerGroup_, HGCalParameters::layerGroupM_, HGCalParameters::layerGroupO_, HGCalParameters::levelT_, loadSpecParsHexagon(), rescale(), HGCalParameters::rLimit_, HGCalParameters::slopeMin_, and waferSize_.

                                                                       {
  php.boundR_ = fv.get<std::vector<double> >(sdTag4, "RadiusBound");
  rescale(php.boundR_, HGCalParameters::k_ScaleFromDD4Hep);
  php.rLimit_ = fv.get<std::vector<double> >(sdTag4, "RadiusLimits");
  rescale(php.rLimit_, HGCalParameters::k_ScaleFromDD4Hep);
  php.levelT_ = dbl_to_int(fv.get<std::vector<double> >(sdTag4, "LevelTop"));

  // Grouping of layers
  php.layerGroup_ = dbl_to_int(fv.get<std::vector<double> >(sdTag1, "GroupingZFine"));
  php.layerGroupM_ = dbl_to_int(fv.get<std::vector<double> >(sdTag1, "GroupingZMid"));
  php.layerGroupO_ = dbl_to_int(fv.get<std::vector<double> >(sdTag1, "GroupingZOut"));
  php.slopeMin_ = fv.get<std::vector<double> >(sdTag4, "Slope");

  // Wafer size
  const auto& dummy = fv.get<std::vector<double> >(sdTag2, "WaferSize");
  waferSize_ = dummy[0] * HGCalParameters::k_ScaleFromDD4HepToG4;

  // Cell size
  php.cellSize_ = fv.get<std::vector<double> >(sdTag3, "CellSize");
  rescale(php.cellSize_, HGCalParameters::k_ScaleFromDD4HepToG4);

  loadSpecParsHexagon(php);
}

void HGCalGeomParameters::loadSpecParsHexagon ( const HGCalParameters &  php )

private

Definition at line 653 of file HGCalGeomParameters.cc.

References HGCalParameters::boundR_, HGCalParameters::cellSize_, dqmdumpme::k, HGCalParameters::layerGroup_, HGCalParameters::layerGroupM_, HGCalParameters::layerGroupO_, HGCalParameters::levelT_, HGCalParameters::rLimit_, HGCalParameters::slopeMin_, and waferSize_.

                                                                        {
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters: wafer radius ranges"
                                << " for cell grouping " << php.boundR_[0] << ":" << php.boundR_[1] << ":"
                                << php.boundR_[2] << ":" << php.boundR_[3];
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters: Minimum/maximum R " << php.rLimit_[0] << ":" << php.rLimit_[1];
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters: LevelTop " << php.levelT_[0];
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters: minimum slope " << php.slopeMin_[0] << " and layer groupings "
                                << "for the 3 ranges:";
  for (unsigned int k = 0; k < php.layerGroup_.size(); ++k)
    edm::LogVerbatim("HGCalGeom") << "[" << k << "] " << php.layerGroup_[k] << ":" << php.layerGroupM_[k] << ":"
                                  << php.layerGroupO_[k];
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters: Wafer Size: " << waferSize_;
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters: " << php.cellSize_.size() << " cells of sizes:";
  for (unsigned int k = 0; k < php.cellSize_.size(); ++k)
    edm::LogVerbatim("HGCalGeom") << " [" << k << "] " << php.cellSize_[k];
#endif
}

void HGCalGeomParameters::loadSpecParsHexagon8	(	const DDFilteredView &	fv,
		HGCalParameters &	php
	)

Definition at line 672 of file HGCalGeomParameters.cc.

References HGCalParameters::cellThickness_, HGCalParameters::choiceType_, dbl_to_int(), HGCalParameters::fracAreaMin_, DDVectorGetter::get(), getDDDArray(), createfilelist::int, HGCalParameters::k_ScaleFromDDD, HGCalParameters::layerCenter_, HGCalParameters::layerOffset_, DDFilteredView::mergedSpecifics(), HGCalParameters::nCornerCut_, HGCalParameters::radius100to200_, HGCalParameters::radius200to300_, HGCalParameters::radiusMixBoundary_, rescale(), HGCalParameters::rMaxFront_, HGCalParameters::rMinFront_, HGCalParameters::slopeMin_, HGCalParameters::slopeTop_, pfDeepBoostedJetPreprocessParams_cfi::sv, HGCalParameters::zFrontMin_, HGCalParameters::zFrontTop_, HGCalParameters::zMinForRad_, and HGCalParameters::zRanges_.

Referenced by HGCalGeomParameters::cellParameters::cellParameters(), and loadSpecParsHexagon8().

                                                                                             {
  DDsvalues_type sv(fv.mergedSpecifics());
  php.cellThickness_ = getDDDArray("CellThickness", sv, 3);
  rescale(php.cellThickness_, HGCalParameters::k_ScaleFromDDD);

  php.radius100to200_ = getDDDArray("Radius100to200", sv, 5);
  php.radius200to300_ = getDDDArray("Radius200to300", sv, 5);

  const auto& dummy = getDDDArray("RadiusCuts", sv, 4);
  php.choiceType_ = (int)(dummy[0]);
  php.nCornerCut_ = (int)(dummy[1]);
  php.fracAreaMin_ = dummy[2];
  php.zMinForRad_ = HGCalParameters::k_ScaleFromDDD * dummy[3];

  php.radiusMixBoundary_ = DDVectorGetter::get("RadiusMixBoundary");
  rescale(php.radiusMixBoundary_, HGCalParameters::k_ScaleFromDDD);

  php.slopeMin_ = getDDDArray("SlopeBottom", sv, 0);
  php.zFrontMin_ = getDDDArray("ZFrontBottom", sv, 0);
  rescale(php.zFrontMin_, HGCalParameters::k_ScaleFromDDD);
  php.rMinFront_ = getDDDArray("RMinFront", sv, 0);
  rescale(php.rMinFront_, HGCalParameters::k_ScaleFromDDD);

  php.slopeTop_ = getDDDArray("SlopeTop", sv, 0);
  php.zFrontTop_ = getDDDArray("ZFrontTop", sv, 0);
  rescale(php.zFrontTop_, HGCalParameters::k_ScaleFromDDD);
  php.rMaxFront_ = getDDDArray("RMaxFront", sv, 0);
  rescale(php.rMaxFront_, HGCalParameters::k_ScaleFromDDD);

  php.zRanges_ = DDVectorGetter::get("ZRanges");
  rescale(php.zRanges_, HGCalParameters::k_ScaleFromDDD);

  const auto& dummy2 = getDDDArray("LayerOffset", sv, 1);
  php.layerOffset_ = dummy2[0];
  php.layerCenter_ = dbl_to_int(DDVectorGetter::get("LayerCenter"));

  loadSpecParsHexagon8(php);
}

void HGCalGeomParameters::loadSpecParsHexagon8	(	const cms::DDFilteredView &	fv,
		const cms::DDVectorsMap &	vmap,
		HGCalParameters &	php,
		const std::string &	sdTag1
	)

Definition at line 711 of file HGCalGeomParameters.cc.

References HGCalParameters::cellThickness_, HGCalParameters::choiceType_, cms::dd::compareEqual(), HGCalParameters::fracAreaMin_, cms::DDFilteredView::get(), mps_fire::i, HGCalParameters::k_ScaleFromDD4Hep, HGCalParameters::k_ScaleFromDD4HepToG4, HGCalParameters::layerCenter_, HGCalParameters::layerOffset_, loadSpecParsHexagon8(), HGCalParameters::nCornerCut_, cms::dd::noNamespace(), HGCalParameters::radius100to200_, HGCalParameters::radius200to300_, HGCalParameters::radiusMixBoundary_, rescale(), HGCalParameters::rMaxFront_, HGCalParameters::rMinFront_, HGCalParameters::slopeMin_, HGCalParameters::slopeTop_, HGCalParameters::zFrontMin_, HGCalParameters::zFrontTop_, HGCalParameters::zMinForRad_, and HGCalParameters::zRanges_.

                                                                        {
  php.cellThickness_ = fv.get<std::vector<double> >(sdTag1, "CellThickness");
  rescale(php.cellThickness_, HGCalParameters::k_ScaleFromDD4Hep);

  php.radius100to200_ = fv.get<std::vector<double> >(sdTag1, "Radius100to200");
  php.radius200to300_ = fv.get<std::vector<double> >(sdTag1, "Radius200to300");
  rescale(php.radius100to200_, HGCalParameters::k_ScaleFromDD4HepToG4);
  rescale(php.radius200to300_, HGCalParameters::k_ScaleFromDD4HepToG4);

  const auto& dummy = fv.get<std::vector<double> >(sdTag1, "RadiusCuts");
  php.choiceType_ = static_cast<int>(dummy[0]);
  php.nCornerCut_ = static_cast<int>(dummy[1]);
  php.fracAreaMin_ = HGCalParameters::k_ScaleFromDD4HepToG4 * dummy[2];
  php.zMinForRad_ = HGCalParameters::k_ScaleFromDD4Hep * dummy[3];

  php.slopeMin_ = fv.get<std::vector<double> >(sdTag1, "SlopeBottom");
  php.zFrontMin_ = fv.get<std::vector<double> >(sdTag1, "ZFrontBottom");
  rescale(php.zFrontMin_, HGCalParameters::k_ScaleFromDD4Hep);
  php.rMinFront_ = fv.get<std::vector<double> >(sdTag1, "RMinFront");
  rescale(php.rMinFront_, HGCalParameters::k_ScaleFromDD4Hep);

  php.slopeTop_ = fv.get<std::vector<double> >(sdTag1, "SlopeTop");
  php.zFrontTop_ = fv.get<std::vector<double> >(sdTag1, "ZFrontTop");
  rescale(php.zFrontTop_, HGCalParameters::k_ScaleFromDD4Hep);
  php.rMaxFront_ = fv.get<std::vector<double> >(sdTag1, "RMaxFront");
  rescale(php.rMaxFront_, HGCalParameters::k_ScaleFromDD4Hep);

  const auto& dummy2 = fv.get<std::vector<double> >(sdTag1, "LayerOffset");
  php.layerOffset_ = dummy2[0];

  for (auto const& it : vmap) {
    if (cms::dd::compareEqual(cms::dd::noNamespace(it.first), "RadiusMixBoundary")) {
      for (const auto& i : it.second)
        php.radiusMixBoundary_.emplace_back(HGCalParameters::k_ScaleFromDD4Hep * i);
    } else if (cms::dd::compareEqual(cms::dd::noNamespace(it.first), "zRanges")) {
      for (const auto& i : it.second)
        php.zRanges_.emplace_back(HGCalParameters::k_ScaleFromDD4Hep * i);
    } else if (cms::dd::compareEqual(cms::dd::noNamespace(it.first), "LayerCenter")) {
      for (const auto& i : it.second)
        php.layerCenter_.emplace_back(std::round(i));
    }
  }

  loadSpecParsHexagon8(php);
}

void HGCalGeomParameters::loadSpecParsHexagon8 ( const HGCalParameters &  php )

private

Definition at line 760 of file HGCalGeomParameters.cc.

References HGCalParameters::cellThickness_, HGCalParameters::choiceType_, HGCalParameters::fracAreaMin_, dqmdumpme::k, HGCalParameters::layerCenter_, HGCalParameters::layerOffset_, HGCalParameters::nCornerCut_, HGCalParameters::radius100to200_, HGCalParameters::radius200to300_, HGCalParameters::radiusMixBoundary_, HGCalParameters::rMaxFront_, HGCalParameters::rMinFront_, HGCalParameters::slopeMin_, HGCalParameters::slopeTop_, HGCalParameters::zFrontMin_, HGCalParameters::zFrontTop_, HGCalParameters::zMinForRad_, and HGCalParameters::zRanges_.

                                                                         {
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters: cell Thickness " << php.cellThickness_[0] << ":"
                                << php.cellThickness_[1] << ":" << php.cellThickness_[2];
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters: Polynomial "
                                << "parameters for 120 to 200 micron "
                                << "transition " << php.radius100to200_[0] << ":" << php.radius100to200_[1] << ":"
                                << php.radius100to200_[2] << ":" << php.radius100to200_[3] << ":"
                                << php.radius100to200_[4];
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters: Polynomial "
                                << "parameters for 200 to 300 micron "
                                << "transition " << php.radius200to300_[0] << ":" << php.radius200to300_[1] << ":"
                                << php.radius200to300_[2] << ":" << php.radius200to300_[3] << ":"
                                << php.radius200to300_[4];
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters: Parameters for the"
                                << " transition " << php.choiceType_ << ":" << php.nCornerCut_ << ":"
                                << php.fracAreaMin_ << ":" << php.zMinForRad_;
  for (unsigned int k = 0; k < php.radiusMixBoundary_.size(); ++k)
    edm::LogVerbatim("HGCalGeom") << "HGCalParameters: Mix[" << k << "] R = " << php.radiusMixBoundary_[k];
  for (unsigned int k = 0; k < php.zFrontMin_.size(); ++k)
    edm::LogVerbatim("HGCalGeom") << "HGCalParameters: Boundary[" << k << "] Bottom Z = " << php.zFrontMin_[k]
                                  << " Slope = " << php.slopeMin_[k] << " rMax = " << php.rMinFront_[k];
  for (unsigned int k = 0; k < php.zFrontTop_.size(); ++k)
    edm::LogVerbatim("HGCalGeom") << "HGCalParameters: Boundary[" << k << "] Top Z = " << php.zFrontTop_[k]
                                  << " Slope = " << php.slopeTop_[k] << " rMax = " << php.rMaxFront_[k];
  edm::LogVerbatim("HGCalGeom") << "HGCalParameters: Z-Boundary " << php.zRanges_[0] << ":" << php.zRanges_[1] << ":"
                                << php.zRanges_[2] << ":" << php.zRanges_[3];
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters: LayerOffset " << php.layerOffset_ << " in array of size "
                                << php.layerCenter_.size();
  for (unsigned int k = 0; k < php.layerCenter_.size(); ++k)
    edm::LogVerbatim("HGCalGeom") << "[" << k << "] " << php.layerCenter_[k];
#endif
}

void HGCalGeomParameters::loadSpecParsTrapezoid	(	const DDFilteredView &	fv,
		HGCalParameters &	php
	)

Definition at line 794 of file HGCalGeomParameters.cc.

References HGCalParameters::cellSize_, dbl_to_int(), DDVectorGetter::get(), getDDDArray(), dqmdumpme::k, HGCalParameters::k_ScaleFromDDD, HGCalParameters::layerCenter_, HGCalParameters::layerFrontBH_, HGCalParameters::layerOffset_, M_PI, DDFilteredView::mergedSpecifics(), HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, HGCalParameters::nPhiBinBH_, HGCalParameters::radiusMixBoundary_, rescale(), HGCalParameters::rMaxFront_, HGCalParameters::rMinFront_, HGCalParameters::rMinLayerBH_, HGCalParameters::slopeMin_, HGCalParameters::slopeTop_, pfDeepBoostedJetPreprocessParams_cfi::sv, HGCalParameters::xLayerHex_, HGCalParameters::yLayerHex_, HGCalParameters::zFrontMin_, HGCalParameters::zFrontTop_, HGCalParameters::zLayerHex_, and HGCalParameters::zRanges_.

Referenced by HGCalGeomParameters::cellParameters::cellParameters(), and loadSpecParsTrapezoid().

                                                                                              {
  DDsvalues_type sv(fv.mergedSpecifics());
  php.radiusMixBoundary_ = DDVectorGetter::get("RadiusMixBoundary");
  rescale(php.radiusMixBoundary_, HGCalParameters::k_ScaleFromDDD);

  php.nPhiBinBH_ = dbl_to_int(getDDDArray("NPhiBinBH", sv, 0));
  php.layerFrontBH_ = dbl_to_int(getDDDArray("LayerFrontBH", sv, 0));
  php.rMinLayerBH_ = getDDDArray("RMinLayerBH", sv, 0);
  rescale(php.rMinLayerBH_, HGCalParameters::k_ScaleFromDDD);
  php.nCellsFine_ = php.nPhiBinBH_[0];
  php.nCellsCoarse_ = php.nPhiBinBH_[1];
  php.cellSize_.emplace_back(2.0 * M_PI / php.nCellsFine_);
  php.cellSize_.emplace_back(2.0 * M_PI / php.nCellsCoarse_);

  php.slopeMin_ = getDDDArray("SlopeBottom", sv, 0);
  php.zFrontMin_ = getDDDArray("ZFrontBottom", sv, 0);
  rescale(php.zFrontMin_, HGCalParameters::k_ScaleFromDDD);
  php.rMinFront_ = getDDDArray("RMinFront", sv, 0);
  rescale(php.rMinFront_, HGCalParameters::k_ScaleFromDDD);

  php.slopeTop_ = getDDDArray("SlopeTop", sv, 0);
  php.zFrontTop_ = getDDDArray("ZFrontTop", sv, 0);
  rescale(php.zFrontTop_, HGCalParameters::k_ScaleFromDDD);
  php.rMaxFront_ = getDDDArray("RMaxFront", sv, 0);
  rescale(php.rMaxFront_, HGCalParameters::k_ScaleFromDDD);

  php.zRanges_ = DDVectorGetter::get("ZRanges");
  rescale(php.zRanges_, HGCalParameters::k_ScaleFromDDD);

  // Offsets
  const auto& dummy2 = getDDDArray("LayerOffset", sv, 1);
  php.layerOffset_ = dummy2[0];
  php.layerCenter_ = dbl_to_int(DDVectorGetter::get("LayerCenter"));

  php.xLayerHex_.clear();
  php.yLayerHex_.clear();
  for (unsigned int k = 0; k < php.zLayerHex_.size(); ++k) {
    php.xLayerHex_.emplace_back(0);
    php.yLayerHex_.emplace_back(0);
  }

  loadSpecParsTrapezoid(php);
}

void HGCalGeomParameters::loadSpecParsTrapezoid	(	const cms::DDFilteredView &	fv,
		const cms::DDVectorsMap &	vmap,
		HGCalParameters &	php,
		const std::string &	sdTag1
	)

Definition at line 838 of file HGCalGeomParameters.cc.

References HGCalParameters::cellSize_, cms::dd::compareEqual(), dbl_to_int(), cms::DDFilteredView::get(), mps_fire::i, dqmdumpme::k, HGCalParameters::k_ScaleFromDD4Hep, HGCalParameters::layerCenter_, HGCalParameters::layerFrontBH_, HGCalParameters::layerOffset_, loadSpecParsTrapezoid(), M_PI, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, cms::dd::noNamespace(), HGCalParameters::nPhiBinBH_, HGCalParameters::radiusMixBoundary_, rescale(), HGCalParameters::rMaxFront_, HGCalParameters::rMinFront_, HGCalParameters::rMinLayerBH_, HGCalParameters::slopeMin_, HGCalParameters::slopeTop_, HGCalParameters::xLayerHex_, HGCalParameters::yLayerHex_, HGCalParameters::zFrontMin_, HGCalParameters::zFrontTop_, HGCalParameters::zLayerHex_, and HGCalParameters::zRanges_.

                                                                         {
  for (auto const& it : vmap) {
    if (cms::dd::compareEqual(cms::dd::noNamespace(it.first), "RadiusMixBoundary")) {
      for (const auto& i : it.second)
        php.radiusMixBoundary_.emplace_back(HGCalParameters::k_ScaleFromDD4Hep * i);
    } else if (cms::dd::compareEqual(cms::dd::noNamespace(it.first), "zRanges")) {
      for (const auto& i : it.second)
        php.zRanges_.emplace_back(HGCalParameters::k_ScaleFromDD4Hep * i);
    } else if (cms::dd::compareEqual(cms::dd::noNamespace(it.first), "LayerCenter")) {
      for (const auto& i : it.second)
        php.layerCenter_.emplace_back(std::round(i));
    }
  }

  php.nPhiBinBH_ = dbl_to_int(fv.get<std::vector<double> >(sdTag1, "NPhiBinBH"));
  php.layerFrontBH_ = dbl_to_int(fv.get<std::vector<double> >(sdTag1, "LayerFrontBH"));
  php.rMinLayerBH_ = fv.get<std::vector<double> >(sdTag1, "RMinLayerBH");
  rescale(php.rMinLayerBH_, HGCalParameters::k_ScaleFromDD4Hep);
  php.nCellsFine_ = php.nPhiBinBH_[0];
  php.nCellsCoarse_ = php.nPhiBinBH_[1];
  php.cellSize_.emplace_back(2.0 * M_PI / php.nCellsFine_);
  php.cellSize_.emplace_back(2.0 * M_PI / php.nCellsCoarse_);

  php.slopeMin_ = fv.get<std::vector<double> >(sdTag1, "SlopeBottom");
  php.zFrontMin_ = fv.get<std::vector<double> >(sdTag1, "ZFrontBottom");
  rescale(php.zFrontMin_, HGCalParameters::k_ScaleFromDD4Hep);
  php.rMinFront_ = fv.get<std::vector<double> >(sdTag1, "RMinFront");
  rescale(php.rMinFront_, HGCalParameters::k_ScaleFromDD4Hep);

  php.slopeTop_ = fv.get<std::vector<double> >(sdTag1, "SlopeTop");
  php.zFrontTop_ = fv.get<std::vector<double> >(sdTag1, "ZFrontTop");
  rescale(php.zFrontTop_, HGCalParameters::k_ScaleFromDD4Hep);
  php.rMaxFront_ = fv.get<std::vector<double> >(sdTag1, "RMaxFront");
  rescale(php.rMaxFront_, HGCalParameters::k_ScaleFromDD4Hep);

  const auto& dummy2 = fv.get<std::vector<double> >(sdTag1, "LayerOffset");
  php.layerOffset_ = dummy2[0];

  php.xLayerHex_.clear();
  php.yLayerHex_.clear();
  for (unsigned int k = 0; k < php.zLayerHex_.size(); ++k) {
    php.xLayerHex_.emplace_back(0);
    php.yLayerHex_.emplace_back(0);
  }

  loadSpecParsTrapezoid(php);
}

void HGCalGeomParameters::loadSpecParsTrapezoid ( const HGCalParameters &  php )

private

Definition at line 889 of file HGCalGeomParameters.cc.

References HGCalParameters::cellSize_, HGCalParameters::firstLayer_, dqmdumpme::k, HGCalParameters::layerCenter_, HGCalParameters::layerFrontBH_, HGCalParameters::layerOffset_, HGCalParameters::nCellsCoarse_, HGCalParameters::nCellsFine_, HGCalParameters::radiusMixBoundary_, HGCalParameters::rMaxFront_, HGCalParameters::rMinFront_, HGCalParameters::rMinLayerBH_, HGCalParameters::scintCells(), HGCalParameters::scintCellSize(), HGCalParameters::slopeMin_, HGCalParameters::slopeTop_, HGCalParameters::xLayerHex_, HGCalParameters::yLayerHex_, HGCalParameters::zFrontMin_, HGCalParameters::zFrontTop_, HGCalParameters::zLayerHex_, and HGCalParameters::zRanges_.

                                                                          {
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters:nCells " << php.nCellsFine_ << ":" << php.nCellsCoarse_
                                << " cellSize: " << php.cellSize_[0] << ":" << php.cellSize_[1];
  for (unsigned int k = 0; k < php.layerFrontBH_.size(); ++k)
    edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters: Type[" << k << "] Front Layer = " << php.layerFrontBH_[k]
                                  << " rMin = " << php.rMinLayerBH_[k];
  for (unsigned int k = 0; k < php.radiusMixBoundary_.size(); ++k) {
    edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters: Mix[" << k << "] R = " << php.radiusMixBoundary_[k]
                                  << " Nphi = " << php.scintCells(k + php.firstLayer_)
                                  << " dPhi = " << php.scintCellSize(k + php.firstLayer_);
  }

  for (unsigned int k = 0; k < php.zFrontMin_.size(); ++k)
    edm::LogVerbatim("HGCalGeom") << "HGCalParameters: Boundary[" << k << "] Bottom Z = " << php.zFrontMin_[k]
                                  << " Slope = " << php.slopeMin_[k] << " rMax = " << php.rMinFront_[k];

  for (unsigned int k = 0; k < php.zFrontTop_.size(); ++k)
    edm::LogVerbatim("HGCalGeom") << "HGCalParameters: Boundary[" << k << "] Top Z = " << php.zFrontTop_[k]
                                  << " Slope = " << php.slopeTop_[k] << " rMax = " << php.rMaxFront_[k];

  edm::LogVerbatim("HGCalGeom") << "HGCalParameters: Z-Boundary " << php.zRanges_[0] << ":" << php.zRanges_[1] << ":"
                                << php.zRanges_[2] << ":" << php.zRanges_[3];

  edm::LogVerbatim("HGCalGeom") << "HGCalParameters: LayerOffset " << php.layerOffset_ << " in array of size "
                                << php.layerCenter_.size();
  for (unsigned int k = 0; k < php.layerCenter_.size(); ++k)
    edm::LogVerbatim("HGCalGeom") << "[" << k << "] " << php.layerCenter_[k];

  for (unsigned int k = 0; k < php.zLayerHex_.size(); ++k)
    edm::LogVerbatim("HGCalGeom") << "Layer[" << k << "] Shift " << php.xLayerHex_[k] << ":" << php.yLayerHex_[k];
#endif
}

void HGCalGeomParameters::loadWaferHexagon

(

HGCalParameters &

php

)

Definition at line 923 of file HGCalGeomParameters.cc.

References HGCalParameters::boundR_, HGCalParameters::copiesInLayers_, filterCSVwithJSON::copy, distTCMET_cfi::corner, PVValHelper::dx, PVValHelper::dy, createfilelist::int, dqmdumpme::k, HGCalParameters::k_CornerSize, HGCalParameters::k_ScaleFromDDD, HGCalParameters::layer_, EgHLTOffHistBins_cfi::nr, HGCalParameters::nSectors_, HGCalParameters::rLimit_, HGCalParameters::rMaxLayHex_, HGCalParameters::rMinLayHex_, findQualityFiles::rr, mathSSE::sqrt(), funct::tan(), HGCalParameters::waferCopy_, HGCalGeomTools::waferCorner(), HGCalWaferIndex::waferIndex(), HGCalParameters::waferPosX_, HGCalParameters::waferPosY_, HGCalParameters::waferR_, waferSize_, HGCalParameters::waferTypeL_, HGCalParameters::waferTypes_, HGCalParameters::waferTypeT_, HGCalParameters::waferUVMax_, and LaserClient_cfi::wl.

                                                               {
  double waferW(HGCalParameters::k_ScaleFromDDD * waferSize_), rmin(HGCalParameters::k_ScaleFromDDD * php.waferR_);
  double rin(php.rLimit_[0]), rout(php.rLimit_[1]), rMaxFine(php.boundR_[1]);
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "Input waferWidth " << waferW << ":" << rmin << " R Limits: " << rin << ":" << rout
                                << " Fine " << rMaxFine;
#endif
  // Clear the vectors
  php.waferCopy_.clear();
  php.waferTypeL_.clear();
  php.waferTypeT_.clear();
  php.waferPosX_.clear();
  php.waferPosY_.clear();
  double dx = 0.5 * waferW;
  double dy = 3.0 * dx * tan(30._deg);
  double rr = 2.0 * dx * tan(30._deg);
  int ncol = (int)(2.0 * rout / waferW) + 1;
  int nrow = (int)(rout / (waferW * tan(30._deg))) + 1;
  int ns2 = (2 * ncol + 1) * (2 * nrow + 1) * php.layer_.size();
  int incm(0), inrm(0), kount(0), ntot(0);
  HGCalParameters::layer_map copiesInLayers(php.layer_.size() + 1);
  HGCalParameters::waferT_map waferTypes(ns2 + 1);
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "Row " << nrow << " Column " << ncol;
#endif
  for (int nr = -nrow; nr <= nrow; ++nr) {
    int inr = (nr >= 0) ? nr : -nr;
    for (int nc = -ncol; nc <= ncol; ++nc) {
      int inc = (nc >= 0) ? nc : -nc;
      if (inr % 2 == inc % 2) {
        double xpos = nc * dx;
        double ypos = nr * dy;
        std::pair<int, int> corner = HGCalGeomTools::waferCorner(xpos, ypos, dx, rr, rin, rout, true);
        double rpos = std::sqrt(xpos * xpos + ypos * ypos);
        int typet = (rpos < rMaxFine) ? 1 : 2;
        int typel(3);
        for (int k = 1; k < 4; ++k) {
          if ((rpos + rmin) <= php.boundR_[k]) {
            typel = k;
            break;
          }
        }
        ++ntot;
        if (corner.first > 0) {
          int copy = inr * 100 + inc;
          if (nc < 0)
            copy += 10000;
          if (nr < 0)
            copy += 100000;
          if (inc > incm)
            incm = inc;
          if (inr > inrm)
            inrm = inr;
          kount++;
#ifdef EDM_ML_DEBUG
          edm::LogVerbatim("HGCalGeom") << kount << ":" << ntot << " Copy " << copy << " Type " << typel << ":" << typet
                                        << " Location " << corner.first << " Position " << xpos << ":" << ypos
                                        << " Layers " << php.layer_.size();
#endif
          php.waferCopy_.emplace_back(copy);
          php.waferTypeL_.emplace_back(typel);
          php.waferTypeT_.emplace_back(typet);
          php.waferPosX_.emplace_back(xpos);
          php.waferPosY_.emplace_back(ypos);
          for (unsigned int il = 0; il < php.layer_.size(); ++il) {
            std::pair<int, int> corner =
                HGCalGeomTools::waferCorner(xpos, ypos, dx, rr, php.rMinLayHex_[il], php.rMaxLayHex_[il], true);
            if (corner.first > 0) {
              auto cpy = copiesInLayers[php.layer_[il]].find(copy);
              if (cpy == copiesInLayers[php.layer_[il]].end())
                copiesInLayers[php.layer_[il]][copy] =
                    ((corner.first == (int)(HGCalParameters::k_CornerSize)) ? php.waferCopy_.size() : -1);
            }
            if ((corner.first > 0) && (corner.first < (int)(HGCalParameters::k_CornerSize))) {
              int wl = HGCalWaferIndex::waferIndex(php.layer_[il], copy, 0, true);
              waferTypes[wl] = std::make_pair(corner.first, corner.second);
            }
          }
        }
      }
    }
  }
  php.copiesInLayers_ = copiesInLayers;
  php.waferTypes_ = waferTypes;
  php.nSectors_ = (int)(php.waferCopy_.size());
  php.waferUVMax_ = 0;
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "HGCalWaferHexagon: # of columns " << incm << " # of rows " << inrm << " and "
                                << kount << ":" << ntot << " wafers; R " << rin << ":" << rout;
  edm::LogVerbatim("HGCalGeom") << "Dump copiesInLayers for " << php.copiesInLayers_.size() << " layers";
  for (unsigned int k = 0; k < copiesInLayers.size(); ++k) {
    const auto& theModules = copiesInLayers[k];
    edm::LogVerbatim("HGCalGeom") << "Layer " << k << ":" << theModules.size();
    int k2(0);
    for (std::unordered_map<int, int>::const_iterator itr = theModules.begin(); itr != theModules.end(); ++itr, ++k2) {
      edm::LogVerbatim("HGCalGeom") << "[" << k2 << "] " << itr->first << ":" << itr->second;
    }
  }
#endif
}

void HGCalGeomParameters::loadWaferHexagon8

(

HGCalParameters &

php

)

Definition at line 1024 of file HGCalGeomParameters.cc.

References funct::abs(), HGCalParameters::hgtrap::alpha, HGCalParameters::hgtrap::bl, HGCalParameters::hgtrap::cellSize, HGCalParameters::cellThickness_, HGCalParameters::choiceType_, filterCSVwithJSON::copy, distTCMET_cfi::corner, TauDecayModes::dec, HGCalParameters::defineFull_, PVValHelper::dy, HGCalParameters::hgtrap::dz, PVValHelper::dz, HGCalParameters::fillModule(), HGCalParameters::fracAreaMin_, geomTools_, HGCalParameters::getModule(), HGCalParameters::hgtrap::h, mps_fire::i, triggerObjects_cff::id, createfilelist::int, dqmdumpme::k, HGCalParameters::k_CornerSize, HGCalParameters::k_ScaleFromDDD, HGCalParameters::k_ScaleToDDD, HGCalParameters::hgtrap::lay, HGCalParameters::layer_, HGCalParameters::layerCenter_, HGCalParameters::layerIndex_, HGCalParameters::layerOffset_, SiStripPI::max, N, HGCalParameters::nCornerCut_, EgHLTOffHistBins_cfi::nr, HGCalParameters::nSectors_, dttmaxenums::R, alignCSCRings::r, HGCalParameters::radius100to200_, HGCalParameters::radius200to300_, HGCalParameters::rLimit_, HGCalParameters::rMaxLayHex_, HGCalParameters::rMinLayHex_, HGCalParameters::sensorSeparation_, HGCalGeomTools::shiftXY(), sqrt3_, HGCalParameters::hgtrap::tl, HGCalParameters::typesInLayers_, findQualityFiles::v, HGCalParameters::waferCopy_, HGCalGeomTools::waferCorner(), HGCalWaferIndex::waferIndex(), HGCalWaferIndex::waferLayer(), HGCalParameters::waferPosX_, HGCalParameters::waferPosY_, HGCalParameters::waferR_, HGCalParameters::wafersInLayers_, HGCalParameters::waferSize_, HGCalParameters::waferTypeL_, HGCalParameters::waferTypes_, HGCalParameters::waferTypeT_, HGCalWaferIndex::waferU(), HGCalParameters::waferUVMax_, HGCalParameters::waferUVMaxLayer_, HGCalWaferIndex::waferV(), LaserClient_cfi::wl, HGCalParameters::xLayerHex_, HGCalParameters::yLayerHex_, HGCalParameters::zLayerHex_, and HGCalParameters::zMinForRad_.

                                                                {
  double waferW(php.waferSize_);
  double waferS(php.sensorSeparation_);
  auto wType = std::make_unique<HGCalWaferType>(php.radius100to200_,
                                                php.radius200to300_,
                                                HGCalParameters::k_ScaleToDDD * (waferW + waferS),
                                                HGCalParameters::k_ScaleToDDD * php.zMinForRad_,
                                                php.choiceType_,
                                                php.nCornerCut_,
                                                php.fracAreaMin_);

  double rout(php.rLimit_[1]);
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "Input waferWidth " << waferW << ":" << waferS << " R Max: " << rout;
#endif
  // Clear the vectors
  php.waferCopy_.clear();
  php.waferTypeL_.clear();
  php.waferTypeT_.clear();
  php.waferPosX_.clear();
  php.waferPosY_.clear();
  double r = 0.5 * (waferW + waferS);
  double R = 2.0 * r / sqrt3_;
  double dy = 0.75 * R;
  int N = (r == 0) ? 3 : ((int)(0.5 * rout / r) + 3);
  int ns1 = (2 * N + 1) * (2 * N + 1);
  int ns2 = ns1 * php.zLayerHex_.size();
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "r " << r << " dy " << dy << " N " << N << " sizes " << ns1 << ":" << ns2;
  std::vector<int> indtypes(ns1 + 1);
  indtypes.clear();
#endif
  HGCalParameters::wafer_map wafersInLayers(ns1 + 1);
  HGCalParameters::wafer_map typesInLayers(ns2 + 1);
  HGCalParameters::waferT_map waferTypes(ns2 + 1);
  int ipos(0), lpos(0), uvmax(0);
  std::vector<int> uvmx(php.zLayerHex_.size(), 0);
  for (int v = -N; v <= N; ++v) {
    for (int u = -N; u <= N; ++u) {
      int nr = 2 * v;
      int nc = -2 * u + v;
      double xpos = nc * r;
      double ypos = nr * dy;
      int indx = HGCalWaferIndex::waferIndex(0, u, v);
      php.waferCopy_.emplace_back(indx);
      php.waferPosX_.emplace_back(xpos);
      php.waferPosY_.emplace_back(ypos);
      wafersInLayers[indx] = ipos;
      ++ipos;
      std::pair<int, int> corner = HGCalGeomTools::waferCorner(xpos, ypos, r, R, 0, rout, false);
      if ((corner.first == (int)(HGCalParameters::k_CornerSize)) || ((corner.first > 0) && php.defineFull_)) {
        uvmax = std::max(uvmax, std::max(std::abs(u), std::abs(v)));
      }
      for (unsigned int i = 0; i < php.zLayerHex_.size(); ++i) {
        int copy = i + php.layerOffset_;
        std::pair<double, double> xyoff = geomTools_.shiftXY(php.layerCenter_[copy], (waferW + waferS));
        int lay = php.layer_[php.layerIndex_[i]];
        double zpos = php.zLayerHex_[i];
        int type = wType->getType(HGCalParameters::k_ScaleToDDD * (xpos + xyoff.first),
                                  HGCalParameters::k_ScaleToDDD * (ypos + xyoff.second),
                                  HGCalParameters::k_ScaleToDDD * zpos);
        php.waferTypeL_.emplace_back(type);
        int kndx = HGCalWaferIndex::waferIndex(lay, u, v);
        typesInLayers[kndx] = lpos;
        ++lpos;
#ifdef EDM_ML_DEBUG
        indtypes.emplace_back(kndx);
#endif
        std::pair<int, int> corner =
            HGCalGeomTools::waferCorner(xpos, ypos, r, R, php.rMinLayHex_[i], php.rMaxLayHex_[i], false);
#ifdef EDM_ML_DEBUG
        if (((corner.first == 0) && std::abs(u) < 5 && std::abs(v) < 5) || (std::abs(u) < 2 && std::abs(v) < 2)) {
          edm::LogVerbatim("HGCalGeom") << "Layer " << lay << " R " << php.rMinLayHex_[i] << ":" << php.rMaxLayHex_[i]
                                        << " u " << u << " v " << v << " with " << corner.first << " corners";
        }
#endif
        if ((corner.first == (int)(HGCalParameters::k_CornerSize)) || ((corner.first > 0) && php.defineFull_)) {
          uvmx[i] = std::max(uvmx[i], std::max(std::abs(u), std::abs(v)));
        }
        if ((corner.first < (int)(HGCalParameters::k_CornerSize)) && (corner.first > 0)) {
#ifdef EDM_ML_DEBUG
          edm::LogVerbatim("HGCalGeom") << "Layer " << lay << " u|v " << u << ":" << v << " with " << corner.first
                                        << " corners First " << corner.second;
#endif
          int wl = HGCalWaferIndex::waferIndex(lay, u, v);
          waferTypes[wl] = std::make_pair(corner.first, corner.second);
        }
      }
    }
  }
  php.waferUVMax_ = uvmax;
  php.waferUVMaxLayer_ = uvmx;
  php.wafersInLayers_ = wafersInLayers;
  php.typesInLayers_ = typesInLayers;
  php.waferTypes_ = waferTypes;
  php.nSectors_ = (int)(php.waferCopy_.size());
  HGCalParameters::hgtrap mytr;
  mytr.lay = 1;
  mytr.bl = php.waferR_;
  mytr.tl = php.waferR_;
  mytr.h = php.waferR_;
  mytr.alpha = 0.0;
  mytr.cellSize = HGCalParameters::k_ScaleToDDD * php.waferSize_;
  for (auto const& dz : php.cellThickness_) {
    mytr.dz = 0.5 * HGCalParameters::k_ScaleToDDD * dz;
    php.fillModule(mytr, false);
  }
  for (unsigned k = 0; k < php.cellThickness_.size(); ++k) {
    HGCalParameters::hgtrap mytr = php.getModule(k, false);
    mytr.bl *= HGCalParameters::k_ScaleFromDDD;
    mytr.tl *= HGCalParameters::k_ScaleFromDDD;
    mytr.h *= HGCalParameters::k_ScaleFromDDD;
    mytr.dz *= HGCalParameters::k_ScaleFromDDD;
    mytr.cellSize *= HGCalParameters::k_ScaleFromDDD;
    php.fillModule(mytr, true);
  }
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "HGCalGeomParameters: Total of " << php.waferCopy_.size() << " wafers";
  for (unsigned int k = 0; k < php.waferCopy_.size(); ++k) {
    int id = php.waferCopy_[k];
    edm::LogVerbatim("HGCalGeom") << "[" << k << "] " << std::hex << id << std::dec << ":"
                                  << HGCalWaferIndex::waferLayer(id) << ":" << HGCalWaferIndex::waferU(id) << ":"
                                  << HGCalWaferIndex::waferV(id) << " x " << php.waferPosX_[k] << " y "
                                  << php.waferPosY_[k] << " index " << php.wafersInLayers_[id];
  }
  edm::LogVerbatim("HGCalGeom") << "HGCalParameters: Total of " << php.waferTypeL_.size() << " wafer types";
  for (unsigned int k = 0; k < php.waferTypeL_.size(); ++k) {
    int id = indtypes[k];
    edm::LogVerbatim("HGCalGeom") << "[" << k << "] " << php.typesInLayers_[id] << ":" << php.waferTypeL_[k] << " ID "
                                  << std::hex << id << std::dec << ":" << HGCalWaferIndex::waferLayer(id) << ":"
                                  << HGCalWaferIndex::waferU(id) << ":" << HGCalWaferIndex::waferV(id);
  }
#endif

  //Wafer offset
  php.xLayerHex_.clear();
  php.yLayerHex_.clear();
  double waferSize = php.waferSize_ + php.sensorSeparation_;
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "WaferSize " << waferSize;
#endif
  for (unsigned int k = 0; k < php.zLayerHex_.size(); ++k) {
    int copy = k + php.layerOffset_;
    std::pair<double, double> xyoff = geomTools_.shiftXY(php.layerCenter_[copy], waferSize);
    php.xLayerHex_.emplace_back(xyoff.first);
    php.yLayerHex_.emplace_back(xyoff.second);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HGCalGeom") << "Layer[" << k << "] Off " << copy << ":" << php.layerCenter_[copy] << " Shift "
                                  << xyoff.first << ":" << xyoff.second;
#endif
  }
}

void HGCalGeomParameters::rescale ( std::vector< double > &  v, const double  s  )

private

Definition at line 1394 of file HGCalGeomParameters.cc.

References dqmiodumpmetadata::n, and alignCSCRings::s.

Referenced by HGCalGeomParameters::cellParameters::cellParameters(), loadSpecParsHexagon(), loadSpecParsHexagon8(), and loadSpecParsTrapezoid().

                                                                      {
  std::for_each(v.begin(), v.end(), [s](double& n) { n *= s; });
}

Member Data Documentation

HGCalGeomTools HGCalGeomParameters::geomTools_

private

Definition at line 107 of file HGCalGeomParameters.h.

Referenced by loadWaferHexagon8().

const double HGCalGeomParameters::sqrt3_

private

Definition at line 108 of file HGCalGeomParameters.h.

Referenced by loadWaferHexagon8().

double HGCalGeomParameters::waferSize_

private

Definition at line 109 of file HGCalGeomParameters.h.

Referenced by loadGeometryHexagon(), loadSpecParsHexagon(), and loadWaferHexagon().