HCalEndcapModuleAlgo Struct Reference

Classes
struct	HcalEndcapPar

Public Member Functions
void	constructInsideModule (cms::DDParsingContext &ctxt, xml_h e, dd4hep::Volume &module)
void	constructInsideModule0 (cms::DDParsingContext &ctxt, xml_h e, dd4hep::Volume &module)
void	constructScintLayer (dd4hep::Volume &detector, double dz, HCalEndcapModuleAlgo::HcalEndcapPar parm, const std::string &nm, int id, cms::DDNamespace &ns)
dd4hep::Rotation3D	getRotation (const std::string &rotstr, cms::DDNamespace &ns)
double	getRout (double z) const
double	getTrim (unsigned int j) const
	HCalEndcapModuleAlgo ()=delete
	HCalEndcapModuleAlgo (cms::DDParsingContext &ctxt, xml_h e)
HcalEndcapPar	parameterLayer (unsigned int iphi, double rinF, double routF, double rinB, double routB, double zi, double zo)
HcalEndcapPar	parameterLayer0 (unsigned int iphi)

Public Attributes
std::string	absorberMat
double	dzStep
std::string	genMaterial
std::string	idName
int	idOffset
std::vector< std::string >	layerName
std::vector< int >	layerNumber
double	layerThick
int	layerType
std::string	modName
int	modNumber
int	modType
double	moduleThick
std::vector< std::string >	phiName
std::string	plasticMat
double	rMaxBack
double	rMaxFront
std::string	rotstr
std::string	scintMat
double	scintThick
int	sectors
double	slopeBot
double	slopeTop
double	slopeTopF
double	tolAbs
double	trimLeft
double	trimRight
double	z1Beam
double	ziDip
double	zMaxBlock
double	zMinBlock

Detailed Description

Definition at line 22 of file DDHCalEndcapModuleAlgo.cc.

Constructor & Destructor Documentation

HCalEndcapModuleAlgo() [1/2]

HCalEndcapModuleAlgo::HCalEndcapModuleAlgo ( )

delete

HCalEndcapModuleAlgo() [2/2]

HCalEndcapModuleAlgo::HCalEndcapModuleAlgo ( cms::DDParsingContext &  ctxt, xml_h  e  )

inline

Definition at line 86 of file DDHCalEndcapModuleAlgo.cc.

References writedatasetfile::args, cms::convert2mm(), MillePedeFileConverter_cfg::e, mps_fire::i, versionedElectronIDProducer_cfi::idName, cms::DDNamespace::name(), volumeBasedMagneticField_160812_cfi::sectors, AlCaHLTBitMon_QueryRunRegistry::string, and cms::DDNamespace::volume().

                                                           {
    cms::DDNamespace ns(ctxt, e, true);
    cms::DDAlgoArguments args(ctxt, e);

    genMaterial = args.value<std::string>("MaterialName");
    absorberMat = args.value<std::string>("AbsorberMat");
    plasticMat = args.value<std::string>("PlasticMat");
    scintMat = args.value<std::string>("ScintMat");
    rotstr = args.value<std::string>("Rotation");
    sectors = args.value<int>("Sectors");
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: General material " << genMaterial << "\tAbsorber "
                                 << absorberMat << "\tPlastic " << plasticMat << "\tScintillator " << scintMat
                                 << "\tRotation " << rotstr << "\tSectors " << sectors;
#endif
    zMinBlock = args.value<double>("ZMinBlock");
    zMaxBlock = args.value<double>("ZMaxBlock");
    z1Beam = args.value<double>("Z1Beam");
    ziDip = args.value<double>("ZiDip");
    dzStep = args.value<double>("DzStep");
    moduleThick = args.value<double>("ModuleThick");
    layerThick = args.value<double>("LayerThick");
    scintThick = args.value<double>("ScintThick");
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: Zmin " << cms::convert2mm(zMinBlock) << "\tZmax "
                                 << cms::convert2mm(zMaxBlock) << "\tZ1Beam " << cms::convert2mm(z1Beam) << "\tZiDip "
                                 << cms::convert2mm(ziDip) << "\tDzStep " << cms::convert2mm(dzStep) << "\tModuleThick "
                                 << cms::convert2mm(moduleThick) << "\tLayerThick " << cms::convert2mm(layerThick)
                                 << "\tScintThick " << cms::convert2mm(scintThick);
#endif
    rMaxFront = args.value<double>("RMaxFront");
    rMaxBack = args.value<double>("RMaxBack");
    trimLeft = args.value<double>("TrimLeft");
    trimRight = args.value<double>("TrimRight");
    tolAbs = args.value<double>("TolAbs");
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: RMaxFront " << cms::convert2mm(rMaxFront) << "\tRmaxBack "
                                 << cms::convert2mm(rMaxBack) << "\tTrims " << cms::convert2mm(trimLeft) << ":"
                                 << cms::convert2mm(trimRight) << "\tTolAbs " << cms::convert2mm(tolAbs);
#endif
    slopeBot = args.value<double>("SlopeBottom");
    slopeTop = args.value<double>("SlopeTop");
    slopeTopF = args.value<double>("SlopeTopFront");
    modType = args.value<int>("ModType");
    modNumber = args.value<int>("ModNumber");
    layerType = args.value<int>("LayerType");
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: slopeBot " << slopeBot << "\tslopeTop " << slopeTop
                                 << "\tslopeTopF " << slopeTopF << "\tmodType " << modType << "\tmodNumber "
                                 << modNumber << "\tlayerType " << layerType;
#endif
    layerNumber = args.value<std::vector<int> >("LayerNumber");
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: " << layerNumber.size() << " layer Numbers";
    for (unsigned int i = 0; i < layerNumber.size(); ++i)
      edm::LogVerbatim("HCalGeom") << "LayerNumber[" << i << "] = " << layerNumber[i];
#endif
    phiName = args.value<std::vector<std::string> >("PhiName");
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: " << phiName.size() << " phi sectors";
    for (unsigned int i = 0; i < phiName.size(); ++i)
      edm::LogVerbatim("HCalGeom") << "PhiName[" << i << "] = " << phiName[i];
#endif
    layerName = args.value<std::vector<std::string> >("LayerName");
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: " << layerName.size() << " layers";
    for (unsigned int i = 0; i < layerName.size(); ++i)
      edm::LogVerbatim("HCalGeom") << "LayerName[" << i << "] = " << layerName[i];
#endif
    idName = args.value<std::string>("MotherName");
    idOffset = args.value<int>("IdOffset");
    modName = args.value<std::string>("ModName");
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: Parent " << args.parentName() << "   " << modName
                                 << " idName " << idName << " NameSpace " << ns.name() << " Offset " << idOffset;
#endif

#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "==>> Constructing DDHCalEndcapModuleAlgo...";
#endif

    dd4hep::Volume mother = ns.volume(args.parentName());
    if (modType == 0)
      constructInsideModule0(ctxt, e, mother);
    else
      constructInsideModule(ctxt, e, mother);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "<<== End of DDHCalEndcapModuleAlgo construction ...";
#endif
  }

Member Function Documentation

constructInsideModule()

void HCalEndcapModuleAlgo::constructInsideModule ( cms::DDParsingContext &  ctxt, xml_h  e, dd4hep::Volume &  module  )

inline

Definition at line 305 of file DDHCalEndcapModuleAlgo.cc.

References HCalEndcapModuleAlgo::HcalEndcapPar::alp, alpha, HCalEndcapModuleAlgo::HcalEndcapPar::bl1, HCalEndcapModuleAlgo::HcalEndcapPar::bl2, cms::convert2mm(), angle_units::operators::convertRadToDeg(), MillePedeFileConverter_cfg::e, mps_fire::i, versionedElectronIDProducer_cfi::idName, LEDCalibrationChannels::iphi, cms::DDNamespace::material(), g4SimHits_cfi::Material, callgraph::module, Skims_PA_cff::name, HCalEndcapModuleAlgo::HcalEndcapPar::phi, PixelTestBeamValidation_cfi::Position, cms::DDNamespace::prepend(), diffTwoXMLs::r2, makeMuonMisalignmentScenario::rot, volumeBasedMagneticField_160812_cfi::sectors, AlCaHLTBitMon_QueryRunRegistry::string, funct::tan(), HCalEndcapModuleAlgo::HcalEndcapPar::theta, HCalEndcapModuleAlgo::HcalEndcapPar::tl1, HCalEndcapModuleAlgo::HcalEndcapPar::tl2, HCalEndcapModuleAlgo::HcalEndcapPar::xpos, HCalEndcapModuleAlgo::HcalEndcapPar::yh1, HCalEndcapModuleAlgo::HcalEndcapPar::yh2, HCalEndcapModuleAlgo::HcalEndcapPar::ypos, and HCalEndcapModuleAlgo::HcalEndcapPar::zpos.

                                                                                       {
    cms::DDNamespace ns(ctxt, e, true);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: \t\tInside module";
#endif
    //Pointers to the Rotation Matrices and to the Materials
    dd4hep::Material matter = ns.material(genMaterial);
    dd4hep::Material matplastic = ns.material(plasticMat);
    dd4hep::Rotation3D rot = getRotation(rotstr, ns);

    double alpha = (1._pi) / sectors;
    double zi = zMinBlock;

    for (unsigned int i = 0; i < layerName.size(); i++) {
      std::string name;
      dd4hep::Solid solid;
      dd4hep::Volume glog, plog;
      int layer = layerNumber[i];
      double zo = zi + 0.5 * dzStep;

      for (unsigned int iphi = 0; iphi < phiName.size(); iphi++) {
        double ziAir = zo - moduleThick;
        double rinF, rinB;
        if (modNumber == 0) {
          rinF = ziAir * slopeTopF;
          rinB = zo * slopeTopF;
        } else {
          rinF = ziAir * slopeBot;
          rinB = zo * slopeBot;
        }
        double routF = getRout(ziAir);
        double routB = getRout(zo);
#ifdef EDM_ML_DEBUG
        edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: Layer " << i << " Phi " << iphi << " Front "
                                     << cms::convert2mm(ziAir) << ", " << cms::convert2mm(rinF) << ", "
                                     << cms::convert2mm(routF) << " Back " << cms::convert2mm(zo) << ", "
                                     << cms::convert2mm(rinB) << ", " << cms::convert2mm(routB);
#endif
        HCalEndcapModuleAlgo::HcalEndcapPar parm = parameterLayer(iphi, rinF, routF, rinB, routB, ziAir, zo);

        name = idName + modName + layerName[i] + phiName[iphi] + "Air";
        solid = dd4hep::Trap(ns.prepend(name),
                             0.5 * moduleThick,
                             parm.theta,
                             parm.phi,
                             parm.yh1,
                             parm.bl1,
                             parm.tl1,
                             parm.alp,
                             parm.yh2,
                             parm.bl2,
                             parm.tl2,
                             parm.alp);
#ifdef EDM_ML_DEBUG
        edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: " << solid.name() << " Trap made of " << matter.name()
                                     << " of dimensions " << cms::convert2mm(0.5 * moduleThick) << ", "
                                     << convertRadToDeg(parm.theta) << ", " << convertRadToDeg(parm.phi) << ", "
                                     << cms::convert2mm(parm.yh1) << ", " << cms::convert2mm(parm.bl1) << ", "
                                     << cms::convert2mm(parm.tl1) << ", " << convertRadToDeg(parm.alp) << ", "
                                     << cms::convert2mm(parm.yh2) << ", " << cms::convert2mm(parm.bl2) << ", "
                                     << cms::convert2mm(parm.tl2) << ", " << convertRadToDeg(parm.alp);
#endif
        glog = dd4hep::Volume(solid.name(), solid, matter);

        dd4hep::Position r1(parm.xpos, parm.ypos, parm.zpos);
        module.placeVolume(glog, layer + 1, dd4hep::Transform3D(rot, r1));
#ifdef EDM_ML_DEBUG
        edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: " << glog.name() << " number " << (layer + 1)
                                     << " positioned in " << module.name() << " at (" << cms::convert2mm(parm.xpos)
                                     << ", " << cms::convert2mm(parm.ypos) << ", " << cms::convert2mm(parm.zpos)
                                     << ") with rotation: " << rot;
#endif
        //Now the plastic with scintillators
        parm.yh1 = 0.5 * (routF - rinB) - getTrim(iphi);
        parm.bl1 = 0.5 * rinB * tan(alpha) - getTrim(iphi);
        parm.tl1 = 0.5 * routF * tan(alpha) - getTrim(iphi);
        name = idName + modName + layerName[i] + phiName[iphi];
        solid = dd4hep::Trap(ns.prepend(name),
                             0.5 * layerThick,
                             0,
                             0,
                             parm.yh1,
                             parm.bl1,
                             parm.tl1,
                             parm.alp,
                             parm.yh1,
                             parm.bl1,
                             parm.tl1,
                             parm.alp);
#ifdef EDM_ML_DEBUG
        edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: " << solid.name() << " Trap made of "
                                     << matplastic.name() << " of dimensions " << cms::convert2mm(0.5 * layerThick)
                                     << ", 0, 0, " << cms::convert2mm(parm.yh1) << ", " << cms::convert2mm(parm.bl1)
                                     << ", " << cms::convert2mm(parm.tl1) << ", " << convertRadToDeg(parm.alp) << ", "
                                     << cms::convert2mm(parm.yh1) << ", " << cms::convert2mm(parm.bl1) << ", "
                                     << cms::convert2mm(parm.tl1) << ", " << convertRadToDeg(parm.alp);
#endif
        plog = dd4hep::Volume(solid.name(), solid, matplastic);

        double ypos = 0.5 * (routF + rinB) - parm.xpos;
        dd4hep::Position r2(0., ypos, 0.);
        glog.placeVolume(plog, idOffset + layer + 1, r2);
#ifdef EDM_ML_DEBUG
        edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: " << plog.name() << " number "
                                     << (idOffset + layer + 1) << " positioned in " << glog.name() << " at (0, "
                                     << cms::convert2mm(ypos) << ", 0) with no rotation";
#endif
        //Constructin the scintillators inside
        int copyNo = layer * 10 + layerType;
        name = modName + layerName[i] + phiName[iphi];
        constructScintLayer(plog, scintThick, parm, name, copyNo, ns);
        zo += 0.5 * dzStep;
      }  // End of loop over phi indices
      zi = zo - 0.5 * dzStep;
    }  // End of loop on layers
  }

constructInsideModule0()

void HCalEndcapModuleAlgo::constructInsideModule0 ( cms::DDParsingContext &  ctxt, xml_h  e, dd4hep::Volume &  module  )

inline

Definition at line 177 of file DDHCalEndcapModuleAlgo.cc.

References HCalEndcapModuleAlgo::HcalEndcapPar::alp, HCalEndcapModuleAlgo::HcalEndcapPar::bl1, HCalEndcapModuleAlgo::HcalEndcapPar::bl2, cms::convert2mm(), angle_units::operators::convertRadToDeg(), MillePedeFileConverter_cfg::e, versionedElectronIDProducer_cfi::idName, LEDCalibrationChannels::iphi, cms::DDNamespace::material(), g4SimHits_cfi::Material, callgraph::module, Skims_PA_cff::name, HCalEndcapModuleAlgo::HcalEndcapPar::phi, PixelTestBeamValidation_cfi::Position, cms::DDNamespace::prepend(), diffTwoXMLs::r2, makeMuonMisalignmentScenario::rot, AlCaHLTBitMon_QueryRunRegistry::string, HCalEndcapModuleAlgo::HcalEndcapPar::theta, HCalEndcapModuleAlgo::HcalEndcapPar::tl1, HCalEndcapModuleAlgo::HcalEndcapPar::tl2, HCalEndcapModuleAlgo::HcalEndcapPar::xpos, HCalEndcapModuleAlgo::HcalEndcapPar::yh1, HCalEndcapModuleAlgo::HcalEndcapPar::yh2, HCalEndcapModuleAlgo::HcalEndcapPar::ypos, and HCalEndcapModuleAlgo::HcalEndcapPar::zpos.

                                                                                        {
    cms::DDNamespace ns(ctxt, e, true);

#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: \t\tInside module0";
#endif
    //Pointers to the Materials
    dd4hep::Material matabsorbr = ns.material(absorberMat);
    dd4hep::Material matplastic = ns.material(plasticMat);
    dd4hep::Rotation3D rot = getRotation(rotstr, ns);

    int layer = layerNumber[0];
    int layer0 = layerNumber[1];
    std::string name;
    dd4hep::Solid solid;
    dd4hep::Volume glog;
    for (unsigned int iphi = 0; iphi < phiName.size(); iphi++) {
      HCalEndcapModuleAlgo::HcalEndcapPar parm = parameterLayer0(iphi);
      name = idName + modName + layerName[0] + phiName[iphi];
      solid = dd4hep::Trap(ns.prepend(name),
                           0.5 * layerThick,
                           0,
                           0,
                           parm.yh1,
                           parm.bl1,
                           parm.tl1,
                           parm.alp,
                           parm.yh2,
                           parm.bl1,
                           parm.tl2,
                           parm.alp);
#ifdef EDM_ML_DEBUG
      edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: " << solid.name() << " Trap made of " << plasticMat
                                   << " of dimensions " << cms::convert2mm(0.5 * layerThick) << ", 0, 0, "
                                   << cms::convert2mm(parm.yh1) << ", " << cms::convert2mm(parm.bl1) << ", "
                                   << cms::convert2mm(parm.tl1) << ", " << convertRadToDeg(parm.alp) << ", "
                                   << cms::convert2mm(parm.yh2) << ", " << cms::convert2mm(parm.bl2) << ", "
                                   << cms::convert2mm(parm.tl2) << ", " << convertRadToDeg(parm.alp);
#endif
      glog = dd4hep::Volume(solid.name(), solid, matplastic);

      dd4hep::Position r1(parm.xpos, parm.ypos, parm.zpos);
      module.placeVolume(glog, idOffset + layer + 1, dd4hep::Transform3D(rot, r1));
#ifdef EDM_ML_DEBUG
      edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: " << glog.name() << " number " << (idOffset + layer + 1)
                                   << " positioned in " << module.name() << " at (" << cms::convert2mm(parm.xpos)
                                   << ", " << cms::convert2mm(parm.ypos) << ", " << cms::convert2mm(parm.zpos)
                                   << ") with rotation: " << rot;
#endif
      //Now construct the layer of scintillator inside this
      int copyNo = layer0 * 10 + layerType;
      name = modName + layerName[0] + phiName[iphi];
      constructScintLayer(glog, scintThick, parm, name, copyNo, ns);
    }

    //Now the absorber layer
    double zi = zMinBlock + layerThick;
    double zo = zi + 0.5 * dzStep;
    double rinF, routF, rinB, routB;
    if (modNumber == 0) {
      rinF = zi * slopeTopF;
      routF = (zi - z1Beam) * slopeTop;
      rinB = zo * slopeTopF;
      routB = (zo - z1Beam) * slopeTop;
    } else if (modNumber > 0) {
      rinF = zi * slopeBot;
      routF = zi * slopeTopF;
      rinB = zo * slopeBot;
      routB = zo * slopeTopF;
    } else {
      rinF = zi * slopeBot;
      routF = (zi - z1Beam) * slopeTop;
      rinB = zo * slopeBot;
      routB = (zo - z1Beam) * slopeTop;
    }
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: Front " << cms::convert2mm(zi) << ", "
                                 << cms::convert2mm(rinF) << ", " << cms::convert2mm(routF) << " Back "
                                 << cms::convert2mm(zo) << ", " << cms::convert2mm(rinB) << ", "
                                 << cms::convert2mm(routB);
#endif
    HCalEndcapModuleAlgo::HcalEndcapPar parm = parameterLayer(0, rinF, routF, rinB, routB, zi, zo);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: Trim " << cms::convert2mm(tolAbs) << " Param "
                                 << cms::convert2mm(parm.yh1) << ", " << cms::convert2mm(parm.bl1) << ", "
                                 << cms::convert2mm(parm.tl1) << ", " << cms::convert2mm(parm.yh2) << ", "
                                 << cms::convert2mm(parm.bl2) << ", " << cms::convert2mm(parm.tl2);
#endif
    parm.bl1 -= tolAbs;
    parm.tl1 -= tolAbs;
    parm.bl2 -= tolAbs;
    parm.tl2 -= tolAbs;

    name = idName + modName + layerName[0] + "Absorber";
    solid = dd4hep::Trap(ns.prepend(name),
                         0.5 * moduleThick,
                         parm.theta,
                         parm.phi,
                         parm.yh1,
                         parm.bl1,
                         parm.tl1,
                         parm.alp,
                         parm.yh2,
                         parm.bl2,
                         parm.tl2,
                         parm.alp);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: " << solid.name() << " Trap made of " << matabsorbr.name()
                                 << " of dimensions " << cms::convert2mm(0.5 * moduleThick) << ", "
                                 << convertRadToDeg(parm.theta) << ", " << convertRadToDeg(parm.phi) << ", "
                                 << cms::convert2mm(parm.yh1) << ", " << cms::convert2mm(parm.bl1) << ", "
                                 << cms::convert2mm(parm.tl1) << ", " << convertRadToDeg(parm.alp) << ", "
                                 << cms::convert2mm(parm.yh2) << ", " << cms::convert2mm(parm.bl2) << ", "
                                 << cms::convert2mm(parm.tl2) << ", " << convertRadToDeg(parm.alp);
#endif
    glog = dd4hep::Volume(solid.name(), solid, matabsorbr);

    dd4hep::Position r2(parm.xpos, parm.ypos, parm.zpos);
    module.placeVolume(glog, idOffset + layer + 1, dd4hep::Transform3D(rot, r2));
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: " << glog.name() << " number 1 positioned in "
                                 << module.name() << " at (" << cms::convert2mm(parm.xpos) << ", "
                                 << cms::convert2mm(parm.ypos) << ", " << cms::convert2mm(parm.zpos)
                                 << ") with rotation: " << rot;
#endif
  }

constructScintLayer()

void HCalEndcapModuleAlgo::constructScintLayer ( dd4hep::Volume &  detector, double  dz, HCalEndcapModuleAlgo::HcalEndcapPar  parm, const std::string &  nm, int  id, cms::DDNamespace &  ns  )

inline

Definition at line 533 of file DDHCalEndcapModuleAlgo.cc.

References HCalEndcapModuleAlgo::HcalEndcapPar::alp, HCalEndcapModuleAlgo::HcalEndcapPar::bl1, cms::convert2mm(), angle_units::operators::convertRadToDeg(), hgcalTestNeighbor_cfi::detector, PVValHelper::dz, versionedElectronIDProducer_cfi::idName, cms::DDNamespace::material(), g4SimHits_cfi::Material, Skims_PA_cff::name, cms::DDNamespace::prepend(), AlCaHLTBitMon_QueryRunRegistry::string, HCalEndcapModuleAlgo::HcalEndcapPar::tl1, and HCalEndcapModuleAlgo::HcalEndcapPar::yh1.

                                               {
    dd4hep::Material matter = ns.material(scintMat);
    std::string name = idName + "Scintillator" + nm;

    dd4hep::Solid solid = dd4hep::Trap(
        ns.prepend(name), 0.5 * dz, 0, 0, parm.yh1, parm.bl1, parm.tl1, parm.alp, parm.yh1, parm.bl1, parm.tl1, parm.alp);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: " << solid.name() << " Trap made of " << scintMat
                                 << " of dimensions " << cms::convert2mm(0.5 * dz) << ", 0, 0, "
                                 << cms::convert2mm(parm.yh1) << ", " << cms::convert2mm(parm.bl1) << ", "
                                 << cms::convert2mm(parm.tl1) << ", " << convertRadToDeg(parm.alp) << ", "
                                 << cms::convert2mm(parm.yh1) << ", " << cms::convert2mm(parm.bl1) << ", "
                                 << cms::convert2mm(parm.tl1) << ", " << convertRadToDeg(parm.alp);
#endif
    dd4hep::Volume glog(solid.name(), solid, matter);

    detector.placeVolume(glog, id);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapModuleAlgo: " << glog.name() << " number " << id << " positioned in "
                                 << detector.name() << " at (0,0,0) with no rotation";
#endif
  }

getRotation()

dd4hep::Rotation3D HCalEndcapModuleAlgo::getRotation ( const std::string &  rotstr, cms::DDNamespace &  ns  )

inline

Definition at line 580 of file DDHCalEndcapModuleAlgo.cc.

References NAMESPACE_SEP, makeMuonMisalignmentScenario::rot, cms::DDNamespace::rotation(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                            {
    std::string rot = (strchr(rotstr.c_str(), NAMESPACE_SEP) == nullptr) ? ("rotations:" + rotstr) : rotstr;
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "getRotation: " << rotstr << ":" << rot << ":" << ns.rotation(rot);
#endif
    return ns.rotation(rot);
  }

getRout()

double HCalEndcapModuleAlgo::getRout ( double  z ) const

inline

Definition at line 568 of file DDHCalEndcapModuleAlgo.cc.

                                 {
    double r = (modNumber >= 0) ? ((z - z1Beam) * slopeTop) : z * slopeTopF;
    if (z > ziDip) {
      if (r > rMaxBack)
        r = rMaxBack;
    } else {
      if (r > rMaxFront)
        r = rMaxFront;
    }
    return r;
  }

getTrim()

double HCalEndcapModuleAlgo::getTrim ( unsigned int  j ) const

inline

Definition at line 561 of file DDHCalEndcapModuleAlgo.cc.

References dqmiolumiharvest::j.

                                       {
    if (j == 0)
      return trimLeft;
    else
      return trimRight;
  }

parameterLayer()

HcalEndcapPar HCalEndcapModuleAlgo::parameterLayer ( unsigned int  iphi, double  rinF, double  routF, double  rinB, double  routB, double  zi, double  zo  )

inline

Definition at line 480 of file DDHCalEndcapModuleAlgo.cc.

References HCalEndcapModuleAlgo::HcalEndcapPar::alp, alpha, HCalEndcapModuleAlgo::HcalEndcapPar::bl1, HCalEndcapModuleAlgo::HcalEndcapPar::bl2, cms::convert2mm(), angle_units::operators::convertRadToDeg(), PVValHelper::dx, PVValHelper::dy, MillePedeFileConverter_cfg::e, LEDCalibrationChannels::iphi, HCalEndcapModuleAlgo::HcalEndcapPar::phi, volumeBasedMagneticField_160812_cfi::sectors, mathSSE::sqrt(), funct::tan(), HCalEndcapModuleAlgo::HcalEndcapPar::theta, HCalEndcapModuleAlgo::HcalEndcapPar::tl1, HCalEndcapModuleAlgo::HcalEndcapPar::tl2, HCalEndcapModuleAlgo::HcalEndcapPar::xpos, HCalEndcapModuleAlgo::HcalEndcapPar::yh1, HCalEndcapModuleAlgo::HcalEndcapPar::yh2, HCalEndcapModuleAlgo::HcalEndcapPar::ypos, and HCalEndcapModuleAlgo::HcalEndcapPar::zpos.

                                                                                                     {
    HCalEndcapModuleAlgo::HcalEndcapPar parm;
    //Given rin, rout compute parameters of the trapezoid and
    //position of the trapezoid for a standrd layer
    double alpha = (1._pi) / sectors;
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "Input " << iphi << " Front " << cms::convert2mm(rinF) << " "
                                 << cms::convert2mm(routF) << " " << cms::convert2mm(zi) << " Back "
                                 << cms::convert2mm(rinB) << " " << cms::convert2mm(routB) << " " << cms::convert2mm(zo)
                                 << " Alpha " << convertRadToDeg(alpha);
#endif
    parm.yh1 = 0.5 * (routF - rinB);
    parm.bl1 = 0.5 * rinB * tan(alpha);
    parm.tl1 = 0.5 * routF * tan(alpha);
    parm.yh2 = 0.5 * (routF - rinB);
    parm.bl2 = 0.5 * rinB * tan(alpha);
    parm.tl2 = 0.5 * routF * tan(alpha);
    double dx = 0.25 * (parm.bl2 + parm.tl2 - parm.bl1 - parm.tl1);
    double dy = 0.5 * (rinB + routF - rinB - routF);
    parm.xpos = 0.25 * (rinB + routF + rinB + routF);
    parm.ypos = 0.25 * (parm.bl2 + parm.tl2 + parm.bl1 + parm.tl1);
    parm.zpos = 0.5 * (zi + zo);
    parm.alp = atan(0.5 * tan(alpha));
    if (iphi == 0) {
      parm.ypos = -parm.ypos;
    } else {
      parm.alp = -parm.alp;
      dx = -dx;
    }
    double r = sqrt(dx * dx + dy * dy);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "dx|dy|r " << cms::convert2mm(dx) << ":" << cms::convert2mm(dy) << ":"
                                 << cms::convert2mm(r);
#endif
    if (r > 1.0e-8) {
      parm.theta = atan(r / (zo - zi));
      parm.phi = atan2(dy, dx);
    } else {
      parm.theta = parm.phi = 0;
    }
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "Output Dimensions " << cms::convert2mm(parm.yh1) << " "
                                 << cms::convert2mm(parm.bl1) << " " << cms::convert2mm(parm.tl1) << " "
                                 << cms::convert2mm(parm.yh2) << " " << cms::convert2mm(parm.bl2) << " "
                                 << cms::convert2mm(parm.tl2) << " " << convertRadToDeg(parm.alp) << " "
                                 << convertRadToDeg(parm.theta) << " " << convertRadToDeg(parm.phi) << " Position "
                                 << cms::convert2mm(parm.xpos) << " " << cms::convert2mm(parm.ypos) << " "
                                 << cms::convert2mm(parm.zpos);
#endif
    return parm;
  }

parameterLayer0()

HcalEndcapPar HCalEndcapModuleAlgo::parameterLayer0 ( unsigned int  iphi )

inline

Definition at line 423 of file DDHCalEndcapModuleAlgo.cc.

References HCalEndcapModuleAlgo::HcalEndcapPar::alp, alpha, HCalEndcapModuleAlgo::HcalEndcapPar::bl1, HCalEndcapModuleAlgo::HcalEndcapPar::bl2, cms::convert2mm(), angle_units::operators::convertRadToDeg(), LEDCalibrationChannels::iphi, volumeBasedMagneticField_160812_cfi::sectors, funct::tan(), HCalEndcapModuleAlgo::HcalEndcapPar::tl1, HCalEndcapModuleAlgo::HcalEndcapPar::tl2, HCalEndcapModuleAlgo::HcalEndcapPar::xpos, HCalEndcapModuleAlgo::HcalEndcapPar::yh1, HCalEndcapModuleAlgo::HcalEndcapPar::yh2, HCalEndcapModuleAlgo::HcalEndcapPar::ypos, and HCalEndcapModuleAlgo::HcalEndcapPar::zpos.

                                                   {
    HCalEndcapModuleAlgo::HcalEndcapPar parm;
    //Given module and layer number compute parameters of trapezoid
    //and positioning parameters
    double alpha = (1._pi) / sectors;
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "Input " << iphi << " Alpha " << convertRadToDeg(alpha);
#endif
    double zi, zo;
    if (iphi == 0) {
      zi = zMinBlock;
      zo = zi + layerThick;
    } else {
      zo = zMaxBlock;
      zi = zo - layerThick;
    }
    double rin, rout;
    if (modNumber == 0) {
      rin = zo * slopeTopF;
      rout = (zi - z1Beam) * slopeTop;
    } else if (modNumber > 0) {
      rin = zo * slopeBot;
      rout = zi * slopeTopF;
    } else {
      rin = zo * slopeBot;
      rout = (zi - z1Beam) * slopeTop;
    }
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "ModNumber " << modNumber << " " << cms::convert2mm(zi) << " "
                                 << cms::convert2mm(zo) << " " << slopeTopF << " " << slopeTop << " " << slopeBot << " "
                                 << cms::convert2mm(rin) << " " << cms::convert2mm(rout) << " "
                                 << cms::convert2mm(getTrim(iphi));
#endif
    double yh = 0.5 * (rout - rin);
    double bl = 0.5 * rin * tan(alpha);
    double tl = 0.5 * rout * tan(alpha);
    parm.xpos = 0.5 * (rin + rout);
    parm.ypos = 0.5 * (bl + tl);
    parm.zpos = 0.5 * (zi + zo);
    parm.yh1 = parm.yh2 = yh - getTrim(iphi);
    parm.bl1 = parm.bl2 = bl - getTrim(iphi);
    parm.tl1 = parm.tl2 = tl - getTrim(iphi);
    parm.alp = atan(0.5 * tan(alpha));
    if (iphi == 0) {
      parm.ypos = -parm.ypos;
    } else {
      parm.alp = -parm.alp;
    }
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "Output Dimensions " << cms::convert2mm(parm.yh1) << " "
                                 << cms::convert2mm(parm.bl1) << " " << cms::convert2mm(parm.tl1) << " "
                                 << convertRadToDeg(parm.alp) << " Position " << cms::convert2mm(parm.xpos) << " "
                                 << cms::convert2mm(parm.ypos) << " " << cms::convert2mm(parm.zpos);
#endif
    return parm;
  }

Member Data Documentation

absorberMat

std::string HCalEndcapModuleAlgo::absorberMat

Definition at line 24 of file DDHCalEndcapModuleAlgo.cc.

dzStep

double HCalEndcapModuleAlgo::dzStep

Definition at line 33 of file DDHCalEndcapModuleAlgo.cc.

genMaterial

std::string HCalEndcapModuleAlgo::genMaterial

Definition at line 23 of file DDHCalEndcapModuleAlgo.cc.

idName

std::string HCalEndcapModuleAlgo::idName

Definition at line 52 of file DDHCalEndcapModuleAlgo.cc.

idOffset

int HCalEndcapModuleAlgo::idOffset

Definition at line 54 of file DDHCalEndcapModuleAlgo.cc.

layerName

std::vector<std::string> HCalEndcapModuleAlgo::layerName

Definition at line 50 of file DDHCalEndcapModuleAlgo.cc.

layerNumber

std::vector<int> HCalEndcapModuleAlgo::layerNumber

Definition at line 48 of file DDHCalEndcapModuleAlgo.cc.

layerThick

double HCalEndcapModuleAlgo::layerThick

Definition at line 35 of file DDHCalEndcapModuleAlgo.cc.

layerType

int HCalEndcapModuleAlgo::layerType

Definition at line 47 of file DDHCalEndcapModuleAlgo.cc.

modName

std::string HCalEndcapModuleAlgo::modName

Definition at line 53 of file DDHCalEndcapModuleAlgo.cc.

modNumber

int HCalEndcapModuleAlgo::modNumber

Definition at line 46 of file DDHCalEndcapModuleAlgo.cc.

modType

int HCalEndcapModuleAlgo::modType

Definition at line 45 of file DDHCalEndcapModuleAlgo.cc.

moduleThick

double HCalEndcapModuleAlgo::moduleThick

Definition at line 34 of file DDHCalEndcapModuleAlgo.cc.

phiName

std::vector<std::string> HCalEndcapModuleAlgo::phiName

Definition at line 49 of file DDHCalEndcapModuleAlgo.cc.

plasticMat

std::string HCalEndcapModuleAlgo::plasticMat

Definition at line 25 of file DDHCalEndcapModuleAlgo.cc.

rMaxBack

double HCalEndcapModuleAlgo::rMaxBack

Definition at line 37 of file DDHCalEndcapModuleAlgo.cc.

rMaxFront

double HCalEndcapModuleAlgo::rMaxFront

Definition at line 38 of file DDHCalEndcapModuleAlgo.cc.

rotstr

std::string HCalEndcapModuleAlgo::rotstr

Definition at line 27 of file DDHCalEndcapModuleAlgo.cc.

scintMat

std::string HCalEndcapModuleAlgo::scintMat

Definition at line 26 of file DDHCalEndcapModuleAlgo.cc.

scintThick

double HCalEndcapModuleAlgo::scintThick

Definition at line 36 of file DDHCalEndcapModuleAlgo.cc.

sectors

int HCalEndcapModuleAlgo::sectors

Definition at line 28 of file DDHCalEndcapModuleAlgo.cc.

slopeBot

double HCalEndcapModuleAlgo::slopeBot

Definition at line 39 of file DDHCalEndcapModuleAlgo.cc.

slopeTop

double HCalEndcapModuleAlgo::slopeTop

Definition at line 40 of file DDHCalEndcapModuleAlgo.cc.

slopeTopF

double HCalEndcapModuleAlgo::slopeTopF

Definition at line 41 of file DDHCalEndcapModuleAlgo.cc.

tolAbs

double HCalEndcapModuleAlgo::tolAbs

Definition at line 44 of file DDHCalEndcapModuleAlgo.cc.

trimLeft

double HCalEndcapModuleAlgo::trimLeft

Definition at line 42 of file DDHCalEndcapModuleAlgo.cc.

trimRight

double HCalEndcapModuleAlgo::trimRight

Definition at line 43 of file DDHCalEndcapModuleAlgo.cc.

z1Beam

double HCalEndcapModuleAlgo::z1Beam

Definition at line 31 of file DDHCalEndcapModuleAlgo.cc.

ziDip

double HCalEndcapModuleAlgo::ziDip

Definition at line 32 of file DDHCalEndcapModuleAlgo.cc.

zMaxBlock

double HCalEndcapModuleAlgo::zMaxBlock

Definition at line 30 of file DDHCalEndcapModuleAlgo.cc.

zMinBlock

double HCalEndcapModuleAlgo::zMinBlock

Definition at line 29 of file DDHCalEndcapModuleAlgo.cc.