Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2024-12-20 03:13:48

0001 ///////////////////////////////////////////////////////////////////////////////
0002 // File: DDHGCalPassive.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 #include "Geometry/HGCalCommonData/interface/HGCalGeomTools.h"
0018 
0019 //#define EDM_ML_DEBUG
0020 using namespace angle_units::operators;
0021 
0022 struct HGCalPassive {
0023   HGCalPassive() { throw cms::Exception("HGCalGeom") << "Wrong initialization to HGCalPassive"; }
0024   HGCalPassive(cms::DDParsingContext& ctxt, xml_h e) {
0025     cms::DDNamespace ns(ctxt, e, true);
0026     cms::DDAlgoArguments args(ctxt, e);
0027 #ifdef EDM_ML_DEBUG
0028     edm::LogVerbatim("HGCalGeom") << "DDHGCalPassive: Creating an instance";
0029 #endif
0030     std::string parentName = args.parentName();
0031     std::string moduleMaterial = args.value<std::string>("ModuleMaterial");  // Material name for mother volume
0032     double moduleThick = args.value<double>("ModuleThick");                  // Thickness of the overall module
0033     int sectors = args.value<int>("Sectors");                                // number of phi sectors (cassettes)
0034     std::vector<std::string> tagsector;                                      // Tag of the sector (to be added to name)
0035     tagsector.reserve(sectors);
0036     for (int k = 0; k < sectors; ++k)
0037       tagsector.emplace_back("F" + std::to_string(k));
0038     int position = args.value<int>("Position");  // 0 if -z; 1 if +z
0039     std::vector<std::string> tagpos;             // Tags for the modules
0040     std::vector<int> xsignpos;                   // sign of the x-value;
0041     if (position == 0) {
0042       tagpos.emplace_back("PN");
0043       xsignpos.emplace_back(-1);
0044     } else {
0045       tagpos.emplace_back("PP");
0046       xsignpos.emplace_back(1);
0047     }
0048     double phi0 = args.value<double>("PhiStart");  // Start phi of the first cassette
0049     double dphi = (2._pi) / tagsector.size();      // delta phi of the cassette
0050 #ifdef EDM_ML_DEBUG
0051     std::ostringstream st0, st1;
0052     for (unsigned int k = 0; k < tagsector.size(); ++k)
0053       st0 << ": " << tagsector[k];
0054     for (unsigned int k = 0; k < tagpos.size(); ++k)
0055       st1 << " " << tagpos[k] << ":" << xsignpos[k];
0056     edm::LogVerbatim("HGCalGeom") << "DDHGCalPassive: " << tagpos.size() << " Modules with base name " << parentName
0057                                   << " made of " << moduleMaterial << " T " << moduleThick << " having " << sectors
0058                                   << " sectors" << st0.str() << " phi0 " << convertRadToDeg(phi0) << " dphi "
0059                                   << convertRadToDeg(dphi) << " Tags:" << st1.str();
0060 #endif
0061     std::vector<std::string> layerNames = args.value<std::vector<std::string>>("LayerNames");  // Names of the layers
0062     std::vector<std::string> layerMaterials =
0063         args.value<std::vector<std::string>>("LayerMaterials");                          // Materials of the layers
0064     std::vector<double> layerThick = args.value<std::vector<double>>("LayerThickness");  // Thickness of layers
0065     std::vector<int> layerType = args.value<std::vector<int>>("LayerType");              // Layer types
0066 #ifdef EDM_ML_DEBUG
0067     edm::LogVerbatim("HGCalGeom") << "DDHGCalPassive: " << layerNames.size() << " types of volumes";
0068     for (unsigned int i = 0; i < layerNames.size(); ++i)
0069       edm::LogVerbatim("HGCalGeom") << "Volume [" << i << "] " << layerNames[i] << " of thickness " << layerThick[i]
0070                                     << " filled with " << layerMaterials[i];
0071     std::ostringstream st2;
0072     for (unsigned int i = 0; i < layerType.size(); ++i)
0073       st2 << " [" << i << "] " << layerType[i];
0074     edm::LogVerbatim("HGCalGeom") << "There are " << layerType.size() << " blocks" << st2.str();
0075 #endif
0076 
0077     std::vector<std::string> absNames =
0078         args.value<std::vector<std::string>>("AbsorberName");                 // Names of the absorber layers
0079     std::vector<int> absN = args.value<std::vector<int>>("AbsorberN");        // Number of point in each layer
0080     std::vector<double> absX = args.value<std::vector<double>>("AbsorberX");  // x coordinates of abs layers
0081     std::vector<double> absY = args.value<std::vector<double>>("AbsorberY");  // y coordinates of abs layers
0082 #ifdef EDM_ML_DEBUG
0083     edm::LogVerbatim("HGCalGeom") << "There are " << absNames.size() << " basic absorber shapes:";
0084     unsigned int j(0);
0085     for (unsigned int k = 0; k < absNames.size(); ++k) {
0086       std::ostringstream st3;
0087       st3 << absNames[k] << " with " << absN[k] << " points:";
0088       for (int i = 0; i < absN[k]; ++i)
0089         st3 << " (" << absX[j + i] << ", " << absY[j + i] << ")";
0090       j += absN[k];
0091       edm::LogVerbatim("HGCalGeom") << st3.str();
0092     }
0093 #endif
0094 
0095     static constexpr double tol = 0.00001;
0096 
0097     // Loop over positions
0098     for (unsigned int i1 = 0; i1 < tagpos.size(); ++i1) {
0099       // Loop over sectors
0100       for (int i2 = 0; i2 < sectors; ++i2) {
0101         double phi = phi0 + i2 * dphi;
0102         double cphi = std::cos(phi);
0103         double sphi = std::sin(phi);
0104         // Loop over passive volumes
0105         int j(0);
0106         for (unsigned i3 = 0; i3 < absNames.size(); ++i3) {
0107           //First make the mother
0108           std::string parentname = parentName + absNames[i3] + tagsector[i2] + tagpos[i1];
0109           std::vector<double> zw = {-0.5 * moduleThick, 0.5 * moduleThick};
0110           std::vector<double> zx(2, 0), zy(2, 0), scale(2, 1.0);
0111           std::vector<double> xM(absN[i3], 0), yM(absN[i3], 0);
0112           for (int k = 0; k < absN[i3]; ++k) {
0113             xM[k] = xsignpos[i1] * (cphi * absX[j + k] + sphi * absY[j + k]);
0114             yM[k] = -sphi * absX[j + k] + cphi * absY[j + k];
0115           }
0116           j += absN[i3];
0117           dd4hep::Solid solid = dd4hep::ExtrudedPolygon(xM, yM, zw, zx, zy, scale);
0118           ns.addSolidNS(ns.prepend(parentname), solid);
0119           dd4hep::Material matter = ns.material(moduleMaterial);
0120           dd4hep::Volume glogM = dd4hep::Volume(solid.name(), solid, matter);
0121 #ifdef EDM_ML_DEBUG
0122           edm::LogVerbatim("HGCalGeom") << "DDHGCalPassive: " << solid.name() << " extruded polygon made of "
0123                                         << matter.name() << " z|x|y|s (0) " << zw[0] << ":" << zx[0] << ":" << zy[0]
0124                                         << ":" << scale[0] << " z|x|y|s (1) " << zw[1] << ":" << zx[1] << ":" << zy[1]
0125                                         << ":" << scale[1] << " and " << xM.size() << " edges";
0126           for (unsigned int kk = 0; kk < xM.size(); ++kk)
0127             edm::LogVerbatim("HGCalGeom") << "[" << kk << "] " << xM[kk] << ":" << yM[kk];
0128 #endif
0129           // Then the layers
0130           std::vector<dd4hep::Volume> glogs(layerMaterials.size());
0131           std::vector<int> copyNumber(layerMaterials.size(), 1);
0132           double zi(-0.5 * moduleThick), thickTot(0.0);
0133           for (unsigned int l = 0; l < layerType.size(); l++) {
0134             unsigned int i = layerType[l];
0135             if (copyNumber[i] == 1) {
0136               zw[0] = -0.5 * layerThick[i];
0137               zw[1] = 0.5 * layerThick[i];
0138               std::string layerName = parentname + layerNames[i];
0139               solid = dd4hep::ExtrudedPolygon(xM, yM, zw, zx, zy, scale);
0140               ns.addSolidNS(ns.prepend(layerName), solid);
0141               matter = ns.material(layerMaterials[i]);
0142               glogs[i] = dd4hep::Volume(solid.name(), solid, matter);
0143 #ifdef EDM_ML_DEBUG
0144               edm::LogVerbatim("HGCalGeom")
0145                   << "DDHGCalPassive: Layer " << i << ":" << l << ":" << solid.name() << " extruded polygon made of "
0146                   << matter.name() << " z|x|y|s (0) " << zw[0] << ":" << zx[0] << ":" << zy[0] << ":" << scale[0]
0147                   << " z|x|y|s (1) " << zw[1] << ":" << zx[1] << ":" << zy[1] << ":" << scale[1] << " and " << xM.size()
0148                   << " edges";
0149               for (unsigned int kk = 0; kk < xM.size(); ++kk)
0150                 edm::LogVerbatim("HGCalGeom") << "[" << kk << "] " << xM[kk] << ":" << yM[kk];
0151 #endif
0152             }
0153             dd4hep::Position tran0(0, 0, (zi + 0.5 * layerThick[i]));
0154             glogM.placeVolume(glogs[i], copyNumber[i], tran0);
0155 #ifdef EDM_ML_DEBUG
0156             edm::LogVerbatim("HGCalGeom")
0157                 << "DDHGCalPassive: " << glogs[i].name() << " number " << copyNumber[i] << " positioned in "
0158                 << glogM.name() << " at (0, 0, " << cms::convert2mm(zi + 0.5 * layerThick[i]) << ") with no rotation";
0159 #endif
0160             ++copyNumber[i];
0161             zi += layerThick[i];
0162             thickTot += layerThick[i];
0163           }
0164           if ((std::abs(thickTot - moduleThick) >= tol) && (!layerType.empty())) {
0165             if (thickTot > moduleThick) {
0166               edm::LogError("HGCalGeom") << "Thickness of the partition " << moduleThick << " is smaller than "
0167                                          << thickTot << ": thickness of all its components **** ERROR ****";
0168             } else {
0169               edm::LogWarning("HGCalGeom") << "Thickness of the partition " << moduleThick << " does not match with "
0170                                            << thickTot << " of the components";
0171             }
0172           }
0173         }
0174       }
0175     }
0176   }
0177 };
0178 
0179 static long algorithm(dd4hep::Detector& /* description */, cms::DDParsingContext& ctxt, xml_h e) {
0180   HGCalPassive passiveAlgo(ctxt, e);
0181   return cms::s_executed;
0182 }
0183 
0184 DECLARE_DDCMS_DETELEMENT(DDCMS_hgcal_DDHGCalPassive, algorithm)