Inheritance diagram for DDHGCalWaferF:

Public Member Functions
	DDHGCalWaferF ()

void	execute (DDCompactView &cpv) override

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

	~DDHGCalWaferF () override

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

int	cellType_

std::vector< int >	copyNumber_

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_

double	thick_

double	waferSepar_

double	waferSize_

Detailed Description

Definition at line 20 of file DDHGCalWaferF.cc.

Constructor & Destructor Documentation

◆ DDHGCalWaferF()

DDHGCalWaferF::DDHGCalWaferF ( )

Definition at line 50 of file DDHGCalWaferF.cc.

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

◆ ~DDHGCalWaferF()

DDHGCalWaferF::~DDHGCalWaferF ( )

override

Definition at line 56 of file DDHGCalWaferF.cc.

56 {}

Member Function Documentation

◆ execute()

void DDHGCalWaferF::execute ( DDCompactView & cpv )

override

Definition at line 101 of file DDHGCalWaferF.cc.

                                               {
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "==>> Executing DDHGCalWaferF...";
 #endif
  
   static constexpr double tol = 0.00001;
   static const double sqrt3 = std::sqrt(3.0);
   double rM = 0.5 * (waferSize_ + waferSepar_);
   double RM2 = rM / sqrt3;
   double R = waferSize_ / (3.0 * nCells_);
   double r = 0.5 * R * sqrt3;
   double r2 = 0.5 * waferSize_;
   double R2 = r2 / sqrt3;
  
   // 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);
   DDName parentName = parent().name();
   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") << "DDHGCalWaferF: " << 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 k = 0; k < xM.size(); ++k)
     edm::LogVerbatim("HGCalGeom") << "[" << k << "] " << xM[k] << ":" << yM[k];
 #endif
  
   // Then the types
   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());
   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) {
       zw[0] = -0.5 * layerThick_[i];
       zw[1] = 0.5 * layerThick_[i];
       solid = DDSolidFactory::extrudedpolygon(layerNames_[i], 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") << "DDHGCalWaferF: " << 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 k = 0; k < xL.size(); ++k)
         edm::LogVerbatim("HGCalGeom") << "[" << k << "] " << xL[k] << ":" << yL[k];
 #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") << "DDHGCalWaferF: " << 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) {
       for (int u = 0; u < 2 * nCells_; ++u) {
         for (int v = 0; v < 2 * nCells_; ++v) {
           if (((v - u) < nCells_) && (u - v) <= nCells_) {
             int n2 = nCells_ / 2;
             double yp = (u - 0.5 * v - n2) * 2 * r;
             double xp = (1.5 * (v - nCells_) + 1.0) * R;
             int cell(0);
             if ((u == 0) && (v == 0))
               cell = 7;
             else if ((u == 0) && (v == nCells_ - 1))
               cell = 8;
             else if ((u == nCells_) && (v == 2 * nCells_ - 1))
               cell = 9;
             else if ((u == 2 * nCells_ - 1) && (v == 2 * nCells_ - 1))
               cell = 10;
             else if ((u == 2 * nCells_ - 1) && (v == nCells_ - 1))
               cell = 11;
             else if ((u == nCells_) && (v == 0))
               cell = 12;
             else if (u == 0)
               cell = 1;
             else if ((v - u) == (nCells_ - 1))
               cell = 4;
             else if (v == (2 * nCells_ - 1))
               cell = 2;
             else if (u == (2 * nCells_ - 1))
               cell = 5;
             else if ((u - v) == nCells_)
               cell = 3;
             else if (v == 0)
               cell = 6;
             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")
                 << "DDHGCalWaferF: " << 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";
     }
   }
 }

References funct::abs(), cellNames_, cellType_, filterCSVwithJSON::copy, copyNumber_, DDBase< N, C >::ddname(), DDSplit(), DDSolidFactory::extrudedpolygon(), first, mps_fire::i, dqmdumpme::k, cmsLHEtoEOSManager::l, layerNames_, layers_, layerThick_, layerType_, material_, materials_, DDBase< N, C >::name(), nCells_, HGCalTypes::packCellTypeUV(), class-composition::parent, DDCompactView::position(), dttmaxenums::R, alignCSCRings::r, diffTwoXMLs::r2, makeMuonMisalignmentScenario::rot, L1EGammaCrystalsEmulatorProducer_cfi::scale, edm::second(), mathSSE::sqrt(), thick_, findQualityFiles::v, waferSepar_, waferSize_, and zw().

◆ initialize()

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

override

Definition at line 58 of file DDHGCalWaferF.cc.

                                                                       {
   material_ = sArgs["ModuleMaterial"];
   thick_ = nArgs["ModuleThickness"];
   waferSize_ = nArgs["WaferSize"];
   waferSepar_ = nArgs["SensorSeparation"];
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DDHGCalWaferF: Module " << parent().name() << " made of " << material_ << " T "
                                 << thick_ << " Wafer 2r " << waferSize_ << " Half Separation " << waferSepar_;
 #endif
   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") << "DDHGCalWaferF: " << 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_ = (int)(nArgs["NCells"]);
   cellType_ = (int)(nArgs["CellType"]);
   cellNames_ = vsArgs["CellNames"];
   nameSpace_ = DDCurrentNamespace::ns();
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DDHGCalWaferF: Cells/Wafer " << nCells_ << " Cell Type " << cellType_
                                 << " NameSpace " << nameSpace_ << " # of cells " << cellNames_.size();
   for (unsigned int k = 0; k < cellNames_.size(); ++k)
     edm::LogVerbatim("HGCalGeom") << "DDHGCalWaferF: Cell[" << k << "] " << cellNames_[k];
 #endif
 }