Inheritance diagram for DDHGCalWaferFullRotated:

Public Member Functions
	DDHGCalWaferFullRotated ()

void	execute (DDCompactView &cpv) override

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

	~DDHGCalWaferFullRotated () override=default

Private Attributes
std::vector< std::string >	cellNames_

std::vector< int >	cellOffset_

int	cellType_

std::vector< int >	copyNumber_

std::vector< int >	face_

std::vector< std::string >	layerNames_

std::vector< int >	layers_

std::vector< double >	layerThick_

std::vector< int >	layerType_

std::string	material_

std::vector< std::string >	materials_

std::string	nameSpace_

int	nCells_

std::vector< int >	orient_

std::vector< std::string >	tag_

double	thick_

double	waferSepar_

double	waferSize_

std::string	waferTag_

double	waferThick_

Detailed Description

Definition at line 26 of file DDHGCalWaferFullRotated.cc.

Constructor & Destructor Documentation

◆ DDHGCalWaferFullRotated()

DDHGCalWaferFullRotated::DDHGCalWaferFullRotated ( )

Definition at line 62 of file DDHGCalWaferFullRotated.cc.

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

◆ ~DDHGCalWaferFullRotated()

DDHGCalWaferFullRotated::~DDHGCalWaferFullRotated ( )

overridedefault

Member Function Documentation

◆ execute()

void DDHGCalWaferFullRotated::execute ( DDCompactView & cpv )

override

Definition at line 127 of file DDHGCalWaferFullRotated.cc.

References funct::abs(), hgcalTopologyTester_cfi::cell1, cellNames_, cellOffset_, HGCalCell::cellPlacementIndex(), cellType_, HGCalCell::cellUV2Cell(), HGCalCell::cellUV2XY1(), filterCSVwithJSON::copy, copyNumber_, DDBase< N, C >::ddname(), DDSplit(), DDSolidFactory::extrudedpolygon(), face_, first, mps_fire::i, cuy::ii, dqmdumpme::k, GetRecoTauVFromDQM_MC_cff::kk, cmsLHEtoEOSManager::l, phase1PixelTopology::layerName, layerNames_, layers_, layerThick_, layerType_, material_, materials_, DDBase< N, C >::name(), nCells_, orient_, HGCalTypes::packCellTypeUV(), class-composition::parent, DDCompactView::position(), diffTwoXMLs::r2, makeMuonMisalignmentScenario::rot, L1EGammaClusterEmuProducer_cfi::scale, edm::second(), mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, tag_, thick_, findQualityFiles::v, HGCalTypes::waferFrontBack(), waferSepar_, waferSize_, waferTag_, waferThick_, and zw().

                                                         {
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "==>> Executing DDHGCalWaferFullRotated...";
 #endif
 
   static constexpr double tol = 0.00001;
   static const double sqrt3 = std::sqrt(3.0);
   double rM = 0.5 * waferSize_;
   double RM2 = rM / sqrt3;
   double r2 = 0.5 * waferSize_;
   double R2 = r2 / sqrt3;
   const int nFine(nCells_), nCoarse(nCells_);
   HGCalCell wafer((waferSize_ + waferSepar_), nFine, nCoarse);
   for (unsigned int k = 0; k < tag_.size(); ++k) {
     // First the mother
     std::vector<double> xM = {rM, 0, -rM, -rM, 0, rM};
     std::vector<double> yM = {RM2, 2 * RM2, RM2, -RM2, -2 * RM2, -RM2};
     std::vector<double> zw = {-0.5 * thick_, 0.5 * thick_};
     std::vector<double> zx(2, 0), zy(2, 0), scale(2, 1.0);
     std::string parentName = parent().name().name();
     parentName = parentName + tag_[k] + waferTag_;
     DDSolid solid = DDSolidFactory::extrudedpolygon(parentName, xM, yM, zw, zx, zy, scale);
     DDName matName(DDSplit(material_).first, DDSplit(material_).second);
     DDMaterial matter(matName);
     DDLogicalPart glogM = DDLogicalPart(solid.ddname(), matter, solid);
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeom") << "DDHGCalWaferFullRotated: " << 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<double> xL = {r2, 0, -r2, -r2, 0, r2};
     std::vector<double> yL = {R2, 2 * R2, R2, -R2, -2 * R2, -R2};
     std::vector<DDLogicalPart> glogs(materials_.size());
     for (unsigned int ii = 0; ii < copyNumber_.size(); ii++) {
       copyNumber_[ii] = 1;
     }
     double zi(-0.5 * thick_), thickTot(0.0);
     for (unsigned int l = 0; l < layers_.size(); l++) {
       unsigned int i = layers_[l];
       if (copyNumber_[i] == 1) {
         if (layerType_[i] > 0) {
           zw[0] = -0.5 * waferThick_;
           zw[1] = 0.5 * waferThick_;
         } else {
           zw[0] = -0.5 * layerThick_[i];
           zw[1] = 0.5 * layerThick_[i];
         }
         std::string layerName = layerNames_[i] + tag_[k] + waferTag_;
         solid = DDSolidFactory::extrudedpolygon(layerName, xL, yL, zw, zx, zy, scale);
         DDName matN(DDSplit(materials_[i]).first, DDSplit(materials_[i]).second);
         DDMaterial matter(matN);
         glogs[i] = DDLogicalPart(solid.ddname(), matter, solid);
 
 #ifdef EDM_ML_DEBUG
         edm::LogVerbatim("HGCalGeom") << "DDHGCalWaferFullRotated: " << 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 " << xL.size() << " edges";
         for (unsigned int kk = 0; kk < xL.size(); ++kk)
           edm::LogVerbatim("HGCalGeom") << "[" << kk << "] " << xL[kk] << ":" << yL[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") << "DDHGCalWaferFullRotated: " << 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 ((layerType_[i] > 0) && (nCells_ > 0)) {
         for (int u = 0; u < 2 * nCells_; ++u) {
           for (int v = 0; v < 2 * nCells_; ++v) {
             if (((v - u) < nCells_) && ((u - v) <= nCells_)) {
               int placeIndex = wafer.cellPlacementIndex(1, HGCalTypes::waferFrontBack(face_[k]), orient_[k]);
               std::pair<double, double> xy1 = wafer.cellUV2XY1(u, v, placeIndex, cellType_);
               double yp = xy1.second;
               double xp = xy1.first;
               int cell(0);
               std::pair<int, int> cell1 = wafer.cellUV2Cell(u, v, placeIndex, cellType_);
               cell = cell1.first + cellOffset_[cell1.second];
               DDTranslation tran(xp, yp, 0);
               int copy = HGCalTypes::packCellTypeUV(cellType_, u, v);
               cpv.position(DDName(cellNames_[cell]), glogs[i], copy, tran, rot);
 #ifdef EDM_ML_DEBUG
               edm::LogVerbatim("HGCalGeom")
                   << "DDHGCalWaferFullRotated: " << cellNames_[cell] << " number " << copy << " positioned in "
                   << glogs[i].name() << " at " << tran << " with no rotation";
 #endif
             }
           }
         }
       }
     }
     if (std::abs(thickTot - thick_) >= tol) {
       if (thickTot > thick_) {
         edm::LogError("HGCalGeom") << "Thickness of the partition " << thick_ << " is smaller than " << thickTot
                                    << ": thickness of all its components **** ERROR ****";
       } else {
         edm::LogWarning("HGCalGeom") << "Thickness of the partition " << thick_ << " does not match with " << thickTot
                                      << " of the components";
       }
     }
   }
 }

◆ initialize()

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

override

Definition at line 68 of file DDHGCalWaferFullRotated.cc.

References cellNames_, cellOffset_, cellType_, copyNumber_, dbl_to_int(), face_, mps_fire::i, dqmdumpme::k, layerNames_, layers_, layerThick_, layerType_, material_, materials_, nameSpace_, nCells_, DDCurrentNamespace::ns(), orient_, class-composition::parent, tag_, thick_, waferSepar_, waferSize_, waferTag_, and waferThick_.

                                                                                 {
   material_ = sArgs["ModuleMaterial"];
   thick_ = nArgs["ModuleThickness"];
   waferSize_ = nArgs["WaferSize"];
   waferSepar_ = nArgs["SensorSeparation"];
   waferThick_ = nArgs["WaferThickness"];
   waferTag_ = sArgs["WaferTag"];
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DDHGCalWaferFullRotated: Module " << parent().name() << " made of " << material_
                                 << " T " << thick_ << " Wafer 2r " << waferSize_ << " Half Separation " << waferSepar_
                                 << " T " << waferThick_;
 #endif
   orient_ = dbl_to_int(vArgs["WaferOrient"]);
   face_ = dbl_to_int(vArgs["WaferFace"]);
   tag_ = vsArgs["WaferPlacementIndex"];
   layerNames_ = vsArgs["LayerNames"];
   materials_ = vsArgs["LayerMaterials"];
   layerThick_ = vArgs["LayerThickness"];
   layerType_ = dbl_to_int(vArgs["LayerTypes"]);
   copyNumber_.resize(materials_.size(), 1);
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DDHGCalWaferFullRotated: " << 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 " << materials_[i] << " type " << layerType_[i];
 #endif
   layers_ = dbl_to_int(vArgs["Layers"]);
 #ifdef EDM_ML_DEBUG
   std::ostringstream st1;
   for (unsigned int i = 0; i < layers_.size(); ++i)
     st1 << " [" << i << "] " << layers_[i];
   edm::LogVerbatim("HGCalGeom") << "There are " << layers_.size() << " blocks" << st1.str();
 #endif
   nCells_ = static_cast<int>(nArgs["NCells"]);
   if (nCells_ > 0) {
     cellType_ = static_cast<int>(nArgs["CellType"]);
     cellNames_ = vsArgs["CellNames"];
     cellOffset_ = dbl_to_int(vArgs["CellOffset"]);
   } else {
     cellType_ = -1;
   }
   nameSpace_ = DDCurrentNamespace::ns();
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DDHGCalWaferFullRotated: Cells/Wafer " << nCells_ << " Cell Type " << cellType_
                                 << " NameSpace " << nameSpace_ << ": # of cells " << cellNames_.size();
   std::ostringstream st2;
   for (unsigned int i = 0; i < cellOffset_.size(); ++i)
     st2 << " [" << i << "] " << cellOffset_[i];
   edm::LogVerbatim("HGCalGeom") << "DDHGCalWaferFullRotated: " << cellOffset_.size() << " types of cells with offsets "
                                 << st2.str();
   for (unsigned int k = 0; k < cellNames_.size(); ++k)
     edm::LogVerbatim("HGCalGeom") << "DDHGCalWaferFullRotated: Cell[" << k << "] " << cellNames_[k];
 #endif
 }