Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2024-04-06 12:14:55

0001 ///////////////////////////////////////////////////////////////////////////////
0002 // File: DDHGCalPassiveFull.cc
0003 // Description: Geometry factory class for the passive part of a full silicon
0004 //              module
0005 // Created by Sunanda Banerjee
0006 ///////////////////////////////////////////////////////////////////////////////
0007 
0008 #include <string>
0009 #include <vector>
0010 #include <sstream>
0011 
0012 #include "DD4hep/DetFactoryHelper.h"
0013 #include "DataFormats/Math/interface/angle_units.h"
0014 #include "DetectorDescription/DDCMS/interface/DDPlugins.h"
0015 #include "DetectorDescription/DDCMS/interface/DDutils.h"
0016 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0017 
0018 //#define EDM_ML_DEBUG
0019 using namespace angle_units::operators;
0020 
0021 struct HGCalPassiveFull {
0022   HGCalPassiveFull() { throw cms::Exception("HGCalGeom") << "Wrong initialization to HGCalPassiveFull"; }
0023   HGCalPassiveFull(cms::DDParsingContext& ctxt, xml_h e) {
0024     cms::DDNamespace ns(ctxt, e, true);
0025     cms::DDAlgoArguments args(ctxt, e);
0026 #ifdef EDM_ML_DEBUG
0027     edm::LogVerbatim("HGCalGeom") << "DDHGCalPassiveFull: Creating an instance";
0028 #endif
0029     std::string parentName = args.parentName();
0030     std::string material = args.value<std::string>("ModuleMaterial");
0031     double thick = args.value<double>("ModuleThickness");
0032     double waferSize = args.value<double>("WaferSize");
0033     double waferSepar = args.value<double>("SensorSeparation");
0034 #ifdef EDM_ML_DEBUG
0035     edm::LogVerbatim("HGCalGeom") << "DDHGCalPassiveFull: Module " << parentName << " made of " << material << " T "
0036                                   << cms::convert2mm(thick) << " Wafer 2r " << cms::convert2mm(waferSize)
0037                                   << " Half Separation " << cms::convert2mm(waferSepar);
0038 #endif
0039     std::vector<std::string> layerNames = args.value<std::vector<std::string>>("LayerNames");
0040     std::vector<std::string> materials = args.value<std::vector<std::string>>("LayerMaterials");
0041     std::vector<double> layerThick = args.value<std::vector<double>>("LayerThickness");
0042     std::vector<int> copyNumber;
0043     copyNumber.resize(materials.size(), 1);
0044 #ifdef EDM_ML_DEBUG
0045     edm::LogVerbatim("HGCalGeom") << "DDHGCalPassiveFull: " << layerNames.size() << " types of volumes";
0046     for (unsigned int i = 0; i < layerNames.size(); ++i)
0047       edm::LogVerbatim("HGCalGeom") << "Volume [" << i << "] " << layerNames[i] << " of thickness "
0048                                     << cms::convert2mm(layerThick[i]) << " filled with " << materials[i];
0049 #endif
0050     std::vector<int> layerType = args.value<std::vector<int>>("LayerType");
0051 #ifdef EDM_ML_DEBUG
0052     std::ostringstream st1;
0053     for (unsigned int i = 0; i < layerType.size(); ++i)
0054       st1 << " [" << i << "] " << layerType[i];
0055     edm::LogVerbatim("HGCalGeom") << "There are " << layerType.size() << " blocks" << st1.str();
0056 
0057     edm::LogVerbatim("HGCalGeom") << "==>> Executing DDHGCalPassiveFull...";
0058 #endif
0059 
0060     static constexpr double tol = 0.00001;
0061     static const double sqrt3 = std::sqrt(3.0);
0062     double rM = 0.5 * (waferSize + waferSepar);
0063     double RM2 = rM / sqrt3;
0064 
0065     // First the mother
0066     std::vector<double> xM = {rM, 0, -rM, -rM, 0, rM};
0067     std::vector<double> yM = {RM2, 2 * RM2, RM2, -RM2, -2 * RM2, -RM2};
0068     std::vector<double> zw = {-0.5 * thick, 0.5 * thick};
0069     std::vector<double> zx(2, 0), zy(2, 0), scale(2, 1.0);
0070     dd4hep::Solid solid = dd4hep::ExtrudedPolygon(xM, yM, zw, zx, zy, scale);
0071     ns.addSolidNS(ns.prepend(parentName), solid);
0072     dd4hep::Material matter = ns.material(material);
0073     dd4hep::Volume glogM = dd4hep::Volume(solid.name(), solid, matter);
0074     ns.addVolumeNS(glogM);
0075 #ifdef EDM_ML_DEBUG
0076     edm::LogVerbatim("HGCalGeom") << "DDHGCalPassiveFull: " << solid.name() << " extruded polygon made of "
0077                                   << matter.name() << " z|x|y|s (0) " << cms::convert2mm(zw[0]) << ":"
0078                                   << cms::convert2mm(zx[0]) << ":" << cms::convert2mm(zy[0]) << ":" << scale[0]
0079                                   << " z|x|y|s (1) " << cms::convert2mm(zw[1]) << ":" << cms::convert2mm(zx[1]) << ":"
0080                                   << cms::convert2mm(zy[1]) << ":" << scale[1] << " and " << xM.size() << " edges";
0081     for (unsigned int kk = 0; kk < xM.size(); ++kk)
0082       edm::LogVerbatim("HGCalGeom") << "[" << kk << "] " << cms::convert2mm(xM[kk]) << ":" << cms::convert2mm(yM[kk]);
0083 #endif
0084 
0085     // Then the layers
0086     std::vector<dd4hep::Volume> glogs(materials.size());
0087     double zi(-0.5 * thick), thickTot(0.0);
0088     for (unsigned int l = 0; l < layerType.size(); l++) {
0089       unsigned int i = layerType[l];
0090       if (copyNumber[i] == 1) {
0091         zw[0] = -0.5 * layerThick[i];
0092         zw[1] = 0.5 * layerThick[i];
0093         std::string layerName = parentName + layerNames[i];
0094         solid = dd4hep::ExtrudedPolygon(xM, yM, zw, zx, zy, scale);
0095         ns.addSolidNS(ns.prepend(layerName), solid);
0096         matter = ns.material(materials[i]);
0097         glogs[i] = dd4hep::Volume(solid.name(), solid, matter);
0098         ns.addVolumeNS(glogs[i]);
0099 #ifdef EDM_ML_DEBUG
0100         edm::LogVerbatim("HGCalGeom") << "DDHGCalPassiveFull: Layer " << i << ":" << l << ":" << solid.name()
0101                                       << " extruded polygon made of " << matter.name() << " z|x|y|s (0) "
0102                                       << cms::convert2mm(zw[0]) << ":" << cms::convert2mm(zx[0]) << ":"
0103                                       << cms::convert2mm(zy[0]) << ":" << scale[0] << " z|x|y|s (1) "
0104                                       << cms::convert2mm(zw[1]) << ":" << cms::convert2mm(zx[1]) << ":"
0105                                       << cms::convert2mm(zy[1]) << ":" << scale[1] << " and " << xM.size() << " edges";
0106         for (unsigned int kk = 0; kk < xM.size(); ++kk)
0107           edm::LogVerbatim("HGCalGeom") << "[" << kk << "] " << cms::convert2mm(xM[kk]) << ":"
0108                                         << cms::convert2mm(yM[kk]);
0109 #endif
0110       }
0111       dd4hep::Position tran0(0, 0, (zi + 0.5 * layerThick[i]));
0112       glogM.placeVolume(glogs[i], copyNumber[i], tran0);
0113 #ifdef EDM_ML_DEBUG
0114       edm::LogVerbatim("HGCalGeom") << "DDHGCalPassiveFull: " << glogs[i].name() << " number " << copyNumber[i]
0115                                     << " positioned in " << glogM.name() << " at (0, 0, "
0116                                     << cms::convert2mm(zi + 0.5 * layerThick[i]) << ") with no rotation";
0117 #endif
0118       ++copyNumber[i];
0119       zi += layerThick[i];
0120       thickTot += layerThick[i];
0121     }
0122     if ((std::abs(thickTot - thick) >= tol) && (!layerType.empty())) {
0123       if (thickTot > thick) {
0124         edm::LogError("HGCalGeom") << "Thickness of the partition " << thick << " is smaller than " << thickTot
0125                                    << ": thickness of all its components **** ERROR ****";
0126       } else {
0127         edm::LogWarning("HGCalGeom") << "Thickness of the partition " << thick << " does not match with " << thickTot
0128                                      << " of the components";
0129       }
0130     }
0131   }
0132 };
0133 
0134 static long algorithm(dd4hep::Detector& /* description */, cms::DDParsingContext& ctxt, xml_h e) {
0135   HGCalPassiveFull passiveFullAlgo(ctxt, e);
0136   return cms::s_executed;
0137 }
0138 
0139 DECLARE_DDCMS_DETELEMENT(DDCMS_hgcal_DDHGCalPassiveFull, algorithm)