DDHGCalPassive Class Reference

Inheritance diagram for DDHGCalPassive:

Public Member Functions
	DDHGCalPassive ()
void	execute (DDCompactView &cpv) override
void	initialize (const DDNumericArguments &nArgs, const DDVectorArguments &vArgs, const DDMapArguments &mArgs, const DDStringArguments &sArgs, const DDStringVectorArguments &vsArgs) override
	~DDHGCalPassive () override=default

Private Attributes
std::vector< int >	absN_
std::vector< std::string >	absNames_
std::vector< double >	absX_
std::vector< double >	absY_
double	dphi_
std::vector< std::string >	layerMaterial_
std::vector< std::string >	layerNames_
std::vector< double >	layerThick_
std::vector< int >	layerType_
std::string	moduleMaterial_
double	moduleThick_
double	phi0_
int	position_
int	sectors_
std::vector< std::string >	tagpos_
std::vector< std::string >	tagsector_
std::vector< int >	xsignpos_

Detailed Description

Definition at line 28 of file DDHGCalPassive.cc.

Constructor & Destructor Documentation

DDHGCalPassive()

DDHGCalPassive::DDHGCalPassive

(

)

Definition at line 61 of file DDHGCalPassive.cc.

                               {
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "DDHGCalPassive: Creating an instance";
#endif
}

~DDHGCalPassive()

DDHGCalPassive::~DDHGCalPassive ( )

overridedefault

Member Function Documentation

execute()

void DDHGCalPassive::execute ( DDCompactView &  cpv )

override

Definition at line 132 of file DDHGCalPassive.cc.

References funct::abs(), ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), funct::cos(), DDBase< N, C >::ddname(), DDSplit(), DDSolidFactory::extrudedpolygon(), dqmdumpme::first, mps_fire::i, testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, dqmiolumiharvest::j, isotrackApplyRegressor::k, GetRecoTauVFromDQM_MC_cff::kk, MainPageGenerator::l, DDBase< N, C >::name(), class-composition::parent, DDCompactView::position(), makeMuonMisalignmentScenario::rot, isotrackNtupler::scale, edm::second(), funct::sin(), AlCaHLTBitMon_QueryRunRegistry::string, and zw().

                                               {
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "==>> Executing DDHGCalPassive...";
#endif
  static constexpr double tol = 0.00001;

  // Loop over positions
  for (unsigned int i1 = 0; i1 < tagpos_.size(); ++i1) {
    // Loop over sectors
    for (int i2 = 0; i2 < sectors_; ++i2) {
      double phi = phi0_ + i2 * dphi_;
      double cphi = std::cos(phi);
      double sphi = std::sin(phi);
      // Loop over passive volumes
      int j(0);
      for (unsigned i3 = 0; i3 < absNames_.size(); ++i3) {
        //First make the mother
        std::string parentName = parent().name().name() + absNames_[i3] + tagsector_[i2] + tagpos_[i1];
        std::vector<double> zw = {-0.5 * moduleThick_, 0.5 * moduleThick_};
        std::vector<double> zx(2, 0), zy(2, 0), scale(2, 1.0);
        std::vector<double> xM(absN_[i3], 0), yM(absN_[i3], 0);
        for (int k = 0; k < absN_[i3]; ++k) {
          xM[k] = xsignpos_[i1] * (cphi * absX_[j + k] + sphi * absY_[j + k]);
          yM[k] = -sphi * absX_[j + k] + cphi * absY_[j + k];
        }
        j += absN_[i3];
        DDSolid solid = DDSolidFactory::extrudedpolygon(parentName, xM, yM, zw, zx, zy, scale);
        DDName matName(DDSplit(moduleMaterial_).first, DDSplit(moduleMaterial_).second);
        DDMaterial matter(matName);
        DDLogicalPart glogM = DDLogicalPart(solid.ddname(), matter, solid);
#ifdef EDM_ML_DEBUG
        edm::LogVerbatim("HGCalGeom") << "DDHGCalPassive: " << solid.name() << " extruded polygon made of " << matName
                                      << " z|x|y|s (0) " << zw[0] << ":" << zx[0] << ":" << zy[0] << ":" << scale[0]
                                      << " z|x|y|s (1) " << zw[1] << ":" << zx[1] << ":" << zy[1] << ":" << scale[1]
                                      << " and " << xM.size() << " edges";
        for (unsigned int kk = 0; kk < xM.size(); ++kk)
          edm::LogVerbatim("HGCalGeom") << "[" << kk << "] " << xM[kk] << ":" << yM[kk];
#endif
        // Then the layers
        std::vector<DDLogicalPart> glogs(layerMaterial_.size());
        std::vector<int> copyNumber(layerMaterial_.size(), 1);
        double zi(-0.5 * moduleThick_), thickTot(0.0);
        for (unsigned int l = 0; l < layerType_.size(); l++) {
          unsigned int i = layerType_[l];
          if (copyNumber[i] == 1) {
            zw[0] = -0.5 * layerThick_[i];
            zw[1] = 0.5 * layerThick_[i];
            std::string layerName = parentName + layerNames_[i];
            solid = DDSolidFactory::extrudedpolygon(layerName, xM, yM, zw, zx, zy, scale);
            DDName matN(DDSplit(layerMaterial_[i]).first, DDSplit(layerMaterial_[i]).second);
            DDMaterial matter(matN);
            glogs[i] = DDLogicalPart(solid.ddname(), matter, solid);
#ifdef EDM_ML_DEBUG
            edm::LogVerbatim("HGCalGeom")
                << "DDHGCalPassive: Layer " << i << ":" << l << ":" << solid.name() << " extruded polygon made of "
                << matN << " z|x|y|s (0) " << zw[0] << ":" << zx[0] << ":" << zy[0] << ":" << scale[0]
                << " z|x|y|s (1) " << zw[1] << ":" << zx[1] << ":" << zy[1] << ":" << scale[1] << " and " << xM.size()
                << " edges";
            for (unsigned int kk = 0; kk < xM.size(); ++kk)
              edm::LogVerbatim("HGCalGeom") << "[" << kk << "] " << xM[kk] << ":" << yM[kk];
#endif
          }
          DDTranslation tran0(0, 0, (zi + 0.5 * layerThick_[i]));
          DDRotation rot;
          cpv.position(glogs[i], glogM, copyNumber[i], tran0, rot);
#ifdef EDM_ML_DEBUG
          edm::LogVerbatim("HGCalGeom") << "DDHGCalPassive: " << glogs[i].name() << " number " << copyNumber[i]
                                        << " positioned in " << glogM.name() << " at " << tran0 << " with no rotation";
#endif
          ++copyNumber[i];
          zi += layerThick_[i];
          thickTot += layerThick_[i];
        }
        if ((std::abs(thickTot - moduleThick_) >= tol) && (!layerType_.empty())) {
          if (thickTot > moduleThick_) {
            edm::LogError("HGCalGeom") << "Thickness of the partition " << moduleThick_ << " is smaller than "
                                       << thickTot << ": thickness of all its components **** ERROR ****";
          } else {
            edm::LogWarning("HGCalGeom") << "Thickness of the partition " << moduleThick_ << " does not match with "
                                         << thickTot << " of the components";
          }
        }
      }
    }
  }
}

initialize()

void DDHGCalPassive::initialize ( const DDNumericArguments &  nArgs, const DDVectorArguments &  vArgs, const DDMapArguments &  mArgs, const DDStringArguments &  sArgs, const DDStringVectorArguments &  vsArgs  )

override

Definition at line 67 of file DDHGCalPassive.cc.

References angle_units::operators::convertDegToRad(), angle_units::operators::convertRadToDeg(), dbl_to_int(), mps_fire::i, dqmiolumiharvest::j, isotrackApplyRegressor::k, class-composition::parent, and to_string().

                                                                       {
  moduleMaterial_ = sArgs["ModuleMaterial"];
  moduleThick_ = nArgs["ModuleThick"];
  sectors_ = static_cast<int>(nArgs["Sectors"]);
  position_ = static_cast<int>(nArgs["Position"]);
  phi0_ = convertDegToRad(nArgs["PhiStart"]);
  dphi_ = (2._pi) / sectors_;
  if (position_ == 0) {
    tagpos_.emplace_back("PN");
    xsignpos_.emplace_back(-1);
  } else {
    tagpos_.emplace_back("PP");
    xsignpos_.emplace_back(1);
  }
  for (int k = 0; k < sectors_; ++k)
    tagsector_.emplace_back("F" + std::to_string(k));
#ifdef EDM_ML_DEBUG
  std::ostringstream st0, st1;
  for (unsigned int k = 0; k < tagsector_.size(); ++k)
    st0 << ": " << tagsector_[k];
  for (unsigned int k = 0; k < tagpos_.size(); ++k)
    st1 << " " << tagpos_[k] << ":" << xsignpos_[k];
  edm::LogVerbatim("HGCalGeom") << "DDHGCalPassive: " << tagpos_.size() << " Modules with base name " << parent().name()
                                << " made of " << moduleMaterial_ << " T " << moduleThick_ << " having " << sectors_
                                << " sectors" << st0.str() << " phi0 " << convertRadToDeg(phi0_) << " dphi "
                                << convertRadToDeg(dphi_) << " Tags:" << st1.str();
#endif

  layerNames_ = vsArgs["LayerNames"];
  layerMaterial_ = vsArgs["LayerMaterials"];
  layerThick_ = vArgs["LayerThickness"];
  layerType_ = dbl_to_int(vArgs["LayerType"]);
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "DDHGCalPassive: " << layerNames_.size() << " types of volumes";
  for (unsigned int i = 0; i < layerNames_.size(); ++i)
    edm::LogVerbatim("HGCalGeom") << "Volume [" << i << "] " << layerNames_[i] << " of thickness " << layerThick_[i]
                                  << " filled with " << layerMaterial_[i];
  std::ostringstream st2;
  for (unsigned int i = 0; i < layerType_.size(); ++i)
    st2 << " [" << i << "] " << layerType_[i];
  edm::LogVerbatim("HGCalGeom") << "There are " << layerType_.size() << " blocks" << st2.str();
#endif

  absNames_ = vsArgs["AbsorberName"];
  absN_ = dbl_to_int(vArgs["AbsorberN"]);
  absX_ = vArgs["AbsorberX"];
  absY_ = vArgs["AbsorberY"];
#ifdef EDM_ML_DEBUG
  edm::LogVerbatim("HGCalGeom") << "There are " << absNames_.size() << " basic absorber shapes:";
  unsigned int j(0);
  for (unsigned int k = 0; k < absNames_.size(); ++k) {
    std::ostringstream st3;
    st3 << absNames_[k] << " with " << absN_[k] << " points:";
    for (int i = 0; i < absN_[k]; ++i)
      st3 << " (" << absX_[j + i] << ", " << absY_[j + i] << ")";
    j += absN_[k];
    edm::LogVerbatim("HGCalGeom") << st3.str();
  }
#endif
}

Member Data Documentation

absN_

std::vector<int> DDHGCalPassive::absN_

private

Definition at line 52 of file DDHGCalPassive.cc.

absNames_

std::vector<std::string> DDHGCalPassive::absNames_

private

Definition at line 51 of file DDHGCalPassive.cc.

absX_

std::vector<double> DDHGCalPassive::absX_

private

Definition at line 53 of file DDHGCalPassive.cc.

absY_

std::vector<double> DDHGCalPassive::absY_

private

Definition at line 54 of file DDHGCalPassive.cc.

dphi_

double DDHGCalPassive::dphi_

private

Definition at line 50 of file DDHGCalPassive.cc.

layerMaterial_

std::vector<std::string> DDHGCalPassive::layerMaterial_

private

Definition at line 56 of file DDHGCalPassive.cc.

layerNames_

std::vector<std::string> DDHGCalPassive::layerNames_

private

Definition at line 55 of file DDHGCalPassive.cc.

layerThick_

std::vector<double> DDHGCalPassive::layerThick_

private

Definition at line 57 of file DDHGCalPassive.cc.

layerType_

std::vector<int> DDHGCalPassive::layerType_

private

Definition at line 58 of file DDHGCalPassive.cc.

moduleMaterial_

std::string DDHGCalPassive::moduleMaterial_

private

Definition at line 42 of file DDHGCalPassive.cc.

moduleThick_

double DDHGCalPassive::moduleThick_

private

Definition at line 43 of file DDHGCalPassive.cc.

phi0_

double DDHGCalPassive::phi0_

private

Definition at line 49 of file DDHGCalPassive.cc.

position_

int DDHGCalPassive::position_

private

Definition at line 46 of file DDHGCalPassive.cc.

sectors_

int DDHGCalPassive::sectors_

private

Definition at line 44 of file DDHGCalPassive.cc.

tagpos_

std::vector<std::string> DDHGCalPassive::tagpos_

private

Definition at line 47 of file DDHGCalPassive.cc.

tagsector_

std::vector<std::string> DDHGCalPassive::tagsector_

private

Definition at line 45 of file DDHGCalPassive.cc.

xsignpos_

std::vector<int> DDHGCalPassive::xsignpos_

private

Definition at line 48 of file DDHGCalPassive.cc.