HCalEndcapAlgo Struct Reference

Public Member Functions
void	constructGeneralVolume (cms::DDNamespace &ns, dd4hep::Volume &parent)
void	constructInsideModule (cms::DDNamespace &ns, dd4hep::Volume &module, int mod)
void	constructInsideModule0 (cms::DDNamespace &ns, dd4hep::Volume &module, int mod)
void	constructInsideSector (cms::DDNamespace &ns, dd4hep::Volume &sector)
void	constructScintLayer (cms::DDNamespace &ns, dd4hep::Volume &detector, double dz, double yh, double bl, double tl, double alp, const std::string &nm, int id)
int	getLayer (unsigned int i, unsigned int j) const
dd4hep::Rotation3D	getRotation (const std::string &rotation, cms::DDNamespace &ns)
double	getTrim (unsigned int i, unsigned int j) const
	HCalEndcapAlgo ()=delete
	HCalEndcapAlgo (cms::DDParsingContext &ctxt, xml_h e)
void	parameterLayer (int iphi, double rinF, double routF, double rinB, double routB, double zi, double zo, double &yh1, double &bl1, double &tl1, double &yh2, double &bl2, double &tl2, double &alp, double &theta, double &phi, double &xpos, double &ypos, double &zpos)
void	parameterLayer0 (int mod, int layer, int iphi, double &yh, double &bl, double &tl, double &alp, double &xpos, double &ypos, double &zpos)

Public Attributes
std::string	absMat
double	angBot
double	angGap
double	angTop
double	drEnd
double	dzShift
double	dzStep
std::vector< int >	eModule
std::string	genMaterial
double	heboxDepth
std::string	idName
int	idOffset
std::vector< int >	layerN
std::vector< int >	layerN0
std::vector< int >	layerN1
std::vector< int >	layerN2
std::vector< int >	layerN3
std::vector< int >	layerN4
std::vector< int >	layerN5
std::vector< std::string >	layerName
int	layers
std::vector< double >	layerT
std::vector< int >	layerType
std::vector< std::string >	modMat
std::vector< std::string >	modName
std::vector< int >	modType
int	modules
int	nEndcap
int	nsectors
int	nsectortot
std::vector< std::string >	phiName
int	phiSections
std::string	plastMat
double	riDip
double	riKink
std::vector< double >	rinBlock1
std::vector< double >	rinBlock2
double	roDip
std::string	rotation
std::string	rotHalf
std::string	rotmat
double	rout
std::vector< double >	routBlock1
std::vector< double >	routBlock2
std::string	scintMat
std::vector< double >	scintT
std::vector< int >	sectionModule
double	slope
std::vector< double >	thick
double	tolAbs
double	tolPos
std::vector< double >	trimLeft
std::vector< double >	trimRight
double	z0Beam
double	z1Beam
double	zEnd
double	zFront
double	ziBody
double	ziDip
double	ziKink
double	ziL0Body
double	ziL0Nose
double	ziNose
std::vector< double >	zmaxBlock
std::vector< double >	zminBlock
double	zShift
double	zShiftHac2

Detailed Description

Definition at line 23 of file DDHCalEndcapAlgo.cc.

Constructor & Destructor Documentation

HCalEndcapAlgo() [1/2]

HCalEndcapAlgo::HCalEndcapAlgo ( )

delete

HCalEndcapAlgo() [2/2]

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

inline

Definition at line 93 of file DDHCalEndcapAlgo.cc.

References writedatasetfile::args, cms::convert2mm(), angle_units::operators::convertRadToDeg(), MillePedeFileConverter_cfg::e, muonTiming_cfi::etamin, JetChargeProducer_cfi::exp, HLT_2023v12_cff::gap, mps_fire::i, versionedElectronIDProducer_cfi::idName, dqmiolumiharvest::j, hgcalTBTopologyTester_cfi::layers, callgraph::module, LogMessageMonitor_cff::modules, cms::DDNamespace::name(), class-composition::parent, idealTransformation::rotation, funct::sin(), slope, AlCaHLTBitMon_QueryRunRegistry::string, funct::tan(), and cms::DDNamespace::volume().

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

    genMaterial = args.value<std::string>("MaterialName");
    rotation = args.value<std::string>("Rotation");
    nsectors = args.value<int>("Sector");
    nsectortot = args.value<int>("SectorTot");
    nEndcap = args.value<int>("Endcap");
    rotHalf = args.value<std::string>("RotHalf");
    zShift = args.value<double>("ZShift");
    zFront = args.value<double>("ZFront");
    zEnd = args.value<double>("ZEnd");
    ziNose = args.value<double>("ZiNose");
    ziL0Nose = args.value<double>("ZiL0Nose");
    ziBody = args.value<double>("ZiBody");
    ziL0Body = args.value<double>("ZiL0Body");
    z0Beam = args.value<double>("Z0Beam");
    ziDip = args.value<double>("ZiDip");
    dzStep = args.value<double>("DzStep");
    zShiftHac2 = args.value<double>("ZShiftHac2");
    double gap = args.value<double>("Gap");
    double z1 = args.value<double>("Z1");
    double r1 = args.value<double>("R1");
    rout = args.value<double>("Rout");
    heboxDepth = args.value<double>("HEboxDepth");
    drEnd = args.value<double>("DrEnd");
    double etamin = args.value<double>("Etamin");
    angBot = args.value<double>("AngBot");
    angGap = args.value<double>("AngGap");
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: General material " << genMaterial << "\tSectors " << nsectors
                                 << ",  " << nsectortot << "\tEndcaps " << nEndcap << "\tRotation matrix for half "
                                 << rotHalf << "\n\tzFront " << cms::convert2mm(zFront) << " zEnd "
                                 << cms::convert2mm(zEnd) << " ziNose " << cms::convert2mm(ziNose) << " ziL0Nose "
                                 << cms::convert2mm(ziL0Nose) << " ziBody " << cms::convert2mm(ziBody) << " ziL0Body "
                                 << cms::convert2mm(ziL0Body) << " z0Beam " << cms::convert2mm(z0Beam) << " ziDip "
                                 << cms::convert2mm(ziDip) << " dzStep " << cms::convert2mm(dzStep) << " Gap "
                                 << cms::convert2mm(gap) << " z1 " << cms::convert2mm(z1) << "\n\tr1 "
                                 << cms::convert2mm(r1) << " rout " << cms::convert2mm(rout) << " HeboxDepth "
                                 << cms::convert2mm(heboxDepth) << " drEnd " << cms::convert2mm(drEnd) << "\tetamin "
                                 << etamin << " Bottom angle " << angBot << " Gap angle " << angGap << " Z-Shift "
                                 << cms::convert2mm(zShift) << " " << cms::convert2mm(zShiftHac2);
#endif

    //Derived quantities
    angTop = 2.0 * atan(exp(-etamin));
    slope = tan(angGap);
    z1Beam = z1 - r1 / slope;
    ziKink = z1Beam + rout / slope;
    riKink = ziKink * tan(angBot);
    riDip = ziDip * tan(angBot);
    roDip = rout - heboxDepth;
    dzShift = (z1Beam - z0Beam) - gap / sin(angGap);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: angTop " << convertRadToDeg(angTop) << "\tSlope " << slope
                                 << "\tDzShift " << cms::convert2mm(dzShift) << "\n\tz1Beam " << cms::convert2mm(z1Beam)
                                 << "\tziKink" << cms::convert2mm(ziKink) << "\triKink " << cms::convert2mm(riKink)
                                 << "\triDip " << cms::convert2mm(riDip) << "\n\troDip " << cms::convert2mm(roDip)
                                 << "\tRotation " << rotation;
#endif

    //Modules
    absMat = args.value<std::string>("AbsMat");
    modules = args.value<int>("Modules");
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: Number of modules " << modules << " and absorber material "
                                 << absMat;
#endif

    modName = args.value<std::vector<std::string> >("ModuleName");
    modMat = args.value<std::vector<std::string> >("ModuleMat");
    modType = args.value<std::vector<int> >("ModuleType");
    sectionModule = args.value<std::vector<int> >("SectionModule");
    thick = args.value<std::vector<double> >("ModuleThick");
    trimLeft = args.value<std::vector<double> >("TrimLeft");
    trimRight = args.value<std::vector<double> >("TrimRight");
    eModule = args.value<std::vector<int> >("EquipModule");
    layerN = args.value<std::vector<int> >("LayerN");
    layerN0 = args.value<std::vector<int> >("LayerN0");
    layerN1 = args.value<std::vector<int> >("LayerN1");
    layerN2 = args.value<std::vector<int> >("LayerN2");
    layerN3 = args.value<std::vector<int> >("LayerN3");
    layerN4 = args.value<std::vector<int> >("LayerN4");
    layerN5 = args.value<std::vector<int> >("LayerN5");
#ifdef EDM_ML_DEBUG
    for (int i = 0; i < modules; i++) {
      edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: " << modName[i] << " type " << modType[i] << " Sections "
                                   << sectionModule[i] << " thickness of absorber/air " << cms::convert2mm(thick[i])
                                   << " trim " << cms::convert2mm(trimLeft[i]) << ", " << cms::convert2mm(trimRight[i])
                                   << " equip module " << eModule[i] << " with " << layerN[i] << " layers";
      if (i == 0) {
        for (int j = 0; j < layerN[i]; j++) {
          edm::LogVerbatim("HCalGeom") << "\t " << layerN0[j] << "/" << layerN0[j + 1];
        }
      } else if (i == 1) {
        for (int j = 0; j < layerN[i]; j++) {
          edm::LogVerbatim("HCalGeom") << "\t " << layerN1[j] << "/" << layerN1[j + 1];
        }
      } else if (i == 2) {
        for (int j = 0; j < layerN[i]; j++) {
          edm::LogVerbatim("HCalGeom") << "\t " << layerN2[j];
        }
      } else if (i == 3) {
        for (int j = 0; j < layerN[i]; j++) {
          edm::LogVerbatim("HCalGeom") << "\t " << layerN3[j];
        }
      } else if (i == 4) {
        for (int j = 0; j < layerN[i]; j++) {
          edm::LogVerbatim("HCalGeom") << "\t " << layerN4[j];
        }
      } else if (i == 5) {
        for (int j = 0; j < layerN[i]; j++) {
          edm::LogVerbatim("HCalGeom") << "\t " << layerN5[j];
        }
      }
    }
#endif

    //Layers
    phiSections = args.value<int>("PhiSections");
    phiName = args.value<std::vector<std::string> >("PhiName");
    layers = args.value<int>("Layers");
    layerName = args.value<std::vector<std::string> >("LayerName");
    layerType = args.value<std::vector<int> >("LayerType");
    layerT = args.value<std::vector<double> >("LayerT");
    scintT = args.value<std::vector<double> >("ScintT");
    scintMat = args.value<std::string>("ScintMat");
    plastMat = args.value<std::string>("PlastMat");
    rotmat = args.value<std::string>("RotMat");
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: Phi Sections " << phiSections;
    for (int i = 0; i < phiSections; i++)
      edm::LogVerbatim("HCalGeom") << "\tName[" << i << "] : " << phiName[i];
    edm::LogVerbatim("HCalGeom") << "\tPlastic: " << plastMat << "\tScintillator: " << scintMat << "\tRotation matrix "
                                 << rotmat << "\n\tNumber of layers " << layers;
    for (int i = 0; i < layers; i++) {
      edm::LogVerbatim("HCalGeom") << "\t" << layerName[i] << "\tType " << layerType[i] << "\tThickness "
                                   << cms::convert2mm(layerT[i]) << "\tScint.Thick " << cms::convert2mm(scintT[i]);
    }
#endif

    // Derive bounding of the modules
    int module = 0;
    // Layer 0 (Nose)
    if (modules > 0) {
      zminBlock.emplace_back(ziL0Nose);
      zmaxBlock.emplace_back(zminBlock[module] + layerT[0] + 0.5 * dzStep);
      rinBlock1.emplace_back(zminBlock[module] * tan(angTop));
      rinBlock2.emplace_back(zmaxBlock[module] * tan(angTop));
      routBlock1.emplace_back((zminBlock[module] - z1Beam) * slope);
      routBlock2.emplace_back((zmaxBlock[module] - z1Beam) * slope);
      module++;
    }
    // Layer 0 (Body)
    if (modules > 1) {
      zminBlock.emplace_back(ziL0Body);
      zmaxBlock.emplace_back(zminBlock[module] + layerT[0] + 0.5 * dzStep);
      rinBlock1.emplace_back(zminBlock[module] * tan(angBot));
      rinBlock2.emplace_back(zmaxBlock[module] * tan(angBot));
      routBlock1.emplace_back(zminBlock[module] * tan(angTop));
      routBlock2.emplace_back(zmaxBlock[module] * tan(angTop));
      module++;
    }
    // Hac1
    if (modules > 2) {
      zminBlock.emplace_back(ziNose);
      zmaxBlock.emplace_back(ziBody);
      rinBlock1.emplace_back(zminBlock[module] * tan(angTop));
      rinBlock2.emplace_back(zmaxBlock[module] * tan(angTop));
      routBlock1.emplace_back((zminBlock[module] - z1Beam) * slope);
      routBlock2.emplace_back((zmaxBlock[module] - z1Beam) * slope);
      module++;
    }
    // Hac2
    if (modules > 3) {
      zminBlock.emplace_back(ziBody);
      zmaxBlock.emplace_back(zminBlock[module] + layerN[3] * dzStep);
      rinBlock1.emplace_back(zminBlock[module] * tan(angBot));
      rinBlock2.emplace_back(zmaxBlock[module] * tan(angBot));
      routBlock1.emplace_back((zmaxBlock[module - 1] - z1Beam) * slope);
      routBlock2.emplace_back(rout);
      module++;
    }
    // Hac3
    if (modules > 4) {
      zminBlock.emplace_back(zmaxBlock[module - 1]);
      zmaxBlock.emplace_back(zminBlock[module] + layerN[4] * dzStep);
      rinBlock1.emplace_back(zminBlock[module] * tan(angBot));
      rinBlock2.emplace_back(zmaxBlock[module] * tan(angBot));
      routBlock1.emplace_back(rout);
      routBlock2.emplace_back(rout);
      module++;
    }
    // Hac4
    if (modules > 5) {
      zminBlock.emplace_back(zmaxBlock[module - 1]);
      zmaxBlock.emplace_back(zminBlock[module] + layerN[5] * dzStep);
      rinBlock1.emplace_back(zminBlock[module] * tan(angBot));
      rinBlock2.emplace_back(zmaxBlock[module] * tan(angBot));
      routBlock1.emplace_back(rout);
      routBlock2.emplace_back(roDip);
      module++;
    }
#ifdef EDM_ML_DEBUG
    for (int i = 0; i < module; i++)
      edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: Module " << i << "\tZ/Rin/Rout "
                                   << cms::convert2mm(zminBlock[i]) << ", " << cms::convert2mm(zmaxBlock[i]) << "/ "
                                   << cms::convert2mm(rinBlock1[i]) << ", " << cms::convert2mm(rinBlock2[i]) << "/ "
                                   << cms::convert2mm(routBlock1[i]) << ", " << cms::convert2mm(routBlock2[i]);
#endif

    idName = args.value<std::string>("MotherName");
    idOffset = args.value<int>("IdOffset");
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: Parent " << args.parentName() << " idName " << idName
                                 << " NameSpace " << ns.name() << " Offset " << idOffset;
#endif

    tolPos = args.value<double>("TolPos");
    tolAbs = args.value<double>("TolAbs");
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: Tolerances - Positioning " << cms::convert2mm(tolPos)
                                 << " Absorber " << cms::convert2mm(tolAbs);
    edm::LogVerbatim("HCalGeom") << "==>> Constructing DDHCalEndcapAlgo...";
#endif

    dd4hep::Volume parent = ns.volume(args.parentName());
    constructGeneralVolume(ns, parent);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "<<== End of DDHCalEndcapAlgo construction ...";
#endif
  }

Member Function Documentation

constructGeneralVolume()

void HCalEndcapAlgo::constructGeneralVolume ( cms::DDNamespace &  ns, dd4hep::Volume &  parent  )

inline

!!!!!!!!!!!!!!!!Should be zero. And removed as soon as

Definition at line 330 of file DDHCalEndcapAlgo.cc.

References cms::DDNamespace::addVolumeNS(), alpha, cms::convert2mm(), angle_units::operators::convertRadToDeg(), mps_fire::i, versionedElectronIDProducer_cfi::idName, cuy::ii, cms::DDNamespace::material(), g4SimHits_cfi::Material, Skims_PA_cff::name, class-composition::parent, HGCalGeometryMode::Polyhedra, PixelTestBeamValidation_cfi::Position, cms::DDNamespace::prepend(), makeMuonMisalignmentScenario::rot, idealTransformation::rotation, slope, AlCaHLTBitMon_QueryRunRegistry::string, and funct::tan().

                                                                        {
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: General volume...";
#endif

    bool proto = true;
    for (int i = 0; i < 3; i++)
      if (eModule[i] > 0)
        proto = false;

    dd4hep::Rotation3D rot = getRotation(rotation, ns);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << " Rotation matrix " << rotation << " Rotation " << rot;
#endif

    dd4hep::Position r0(0, 0, zShift);
    double alpha = (1._pi) / nsectors;
    double dphi = nsectortot * (2._pi) / nsectors;

    //vertical walls are allowed in SolidPolyhedra
    double delz = 0;

    std::vector<double> pgonZ, pgonRmin, pgonRmax;
    if (proto) {
      double zf = ziBody + zShiftHac2;
      pgonZ.emplace_back(zf - dzShift);
      pgonRmin.emplace_back(zf * tan(angBot));
      pgonRmax.emplace_back((zf - z1Beam) * slope);
    } else {
      pgonZ.emplace_back(zFront - dzShift);
      pgonRmin.emplace_back(zFront * tan(angTop));
      pgonRmax.emplace_back((zFront - z1Beam) * slope);
      pgonZ.emplace_back(ziL0Body - dzShift);
      pgonRmin.emplace_back(ziL0Body * tan(angTop));
      pgonRmax.emplace_back((ziL0Body - z1Beam) * slope);
      pgonZ.emplace_back(ziL0Body - dzShift);
      pgonRmin.emplace_back(ziL0Body * tan(angBot));
      pgonRmax.emplace_back((ziL0Body - z1Beam) * slope);
    }
    pgonZ.emplace_back(ziKink - dzShift);
    pgonRmin.emplace_back(riKink);
    pgonRmax.emplace_back(rout);
    pgonZ.emplace_back(ziDip - dzShift);
    pgonRmin.emplace_back(riDip);
    pgonRmax.emplace_back(rout);
    pgonZ.emplace_back(ziDip - dzShift + delz);
    pgonRmin.emplace_back(riDip);
    pgonRmax.emplace_back(roDip);
    pgonZ.emplace_back(zEnd - dzShift);
    pgonRmin.emplace_back(zEnd * tan(angBot));
    pgonRmax.emplace_back(roDip);
    pgonZ.emplace_back(zEnd);
    pgonRmin.emplace_back(zEnd * tan(angBot));
    pgonRmax.emplace_back(roDip);

    std::string name("Null");
    dd4hep::Solid solid = dd4hep::Polyhedra(ns.prepend(idName), nsectortot, -alpha, dphi, pgonZ, pgonRmin, pgonRmax);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: " << solid.name() << " Polyhedra made of " << genMaterial
                                 << " with " << nsectortot << " sectors from " << convertRadToDeg(-alpha) << " to "
                                 << convertRadToDeg(-alpha + dphi) << " and with " << pgonZ.size() << " sections";
    for (unsigned int i = 0; i < pgonZ.size(); i++)
      edm::LogVerbatim("HCalGeom") << "\t\tZ = " << cms::convert2mm(pgonZ[i])
                                   << "\tRmin = " << cms::convert2mm(pgonRmin[i])
                                   << "\tRmax = " << cms::convert2mm(pgonRmax[i]);
#endif
    dd4hep::Material matter = ns.material(genMaterial);
    dd4hep::Volume genlogic(solid.name(), solid, matter);

    parent.placeVolume(genlogic, 1, dd4hep::Transform3D(rot, r0));
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: " << genlogic.name() << " number 1 positioned in "
                                 << parent.name() << " at (0, 0, " << cms::convert2mm(zShift)
                                 << ") with rotation: " << rot;
#endif

    if (nEndcap != 1) {
      rot = getRotation(rotHalf, ns);
      parent.placeVolume(genlogic, 2, dd4hep::Transform3D(rot, r0));
#ifdef EDM_ML_DEBUG
      edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: " << genlogic.name() << " number 2 "
                                   << "positioned in " << parent.name() << " at (0, 0, " << cms::convert2mm(zShift)
                                   << ") with rotation: " << rot;
#endif
    }

    //Forward half
    name = idName + "Front";
    std::vector<double> pgonZMod, pgonRminMod, pgonRmaxMod;
    for (unsigned int i = 0; i < (pgonZ.size() - 1); i++) {
      pgonZMod.emplace_back(pgonZ[i] + dzShift);
      pgonRminMod.emplace_back(pgonRmin[i]);
      pgonRmaxMod.emplace_back(pgonRmax[i]);
    }
    solid = dd4hep::Polyhedra(ns.prepend(name), nsectortot, -alpha, dphi, pgonZMod, pgonRminMod, pgonRmaxMod);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: " << solid.name() << " Polyhedra made of " << genMaterial
                                 << " with " << nsectortot << " sectors from " << convertRadToDeg(-alpha) << " to "
                                 << convertRadToDeg(-alpha + dphi) << " and with " << pgonZMod.size() << " sections ";
    for (unsigned int i = 0; i < pgonZMod.size(); i++)
      edm::LogVerbatim("HCalGeom") << "\t\tZ = " << cms::convert2mm(pgonZMod[i])
                                   << "\tRmin = " << cms::convert2mm(pgonRminMod[i])
                                   << "\tRmax = " << cms::convert2mm(pgonRmaxMod[i]);
#endif

    dd4hep::Volume genlogich(solid.name(), solid, matter);
    ns.addVolumeNS(genlogich);
    genlogic.placeVolume(genlogich, 1, dd4hep::Position(0, 0, -dzShift));
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: " << genlogich.name() << " number 1 positioned in "
                                 << genlogic.name() << " at (0,0," << -cms::convert2mm(dzShift) << ") with no rotation";
#endif

    //Construct sector (from -alpha to +alpha)
    name = idName + "Module";
    solid = dd4hep::Polyhedra(ns.prepend(name), 1, -alpha, 2 * alpha, pgonZMod, pgonRminMod, pgonRmaxMod);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: " << solid.name() << " Polyhedra made of " << genMaterial
                                 << " with 1 sector from " << convertRadToDeg(-alpha) << " to "
                                 << convertRadToDeg(alpha) << " and with " << pgonZMod.size() << " sections";
    for (unsigned int i = 0; i < pgonZMod.size(); i++)
      edm::LogVerbatim("HCalGeom") << "\t\tZ = " << cms::convert2mm(pgonZMod[i])
                                   << "\tRmin = " << cms::convert2mm(pgonRminMod[i])
                                   << "\tRmax = " << cms::convert2mm(pgonRmaxMod[i]);
#endif

    dd4hep::Volume seclogic(solid.name(), solid, matter);
    for (int ii = 0; ii < nsectortot; ii++) {
      double phi = ii * 2 * alpha;
      dd4hep::Rotation3D rot0;
      if (phi != 0) {
        rot0 = dd4hep::RotationZ(phi);
#ifdef EDM_ML_DEBUG
        edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: Creating a new rotation \t 90," << convertRadToDeg(phi)
                                     << ", 90," << convertRadToDeg(phi + 90._deg) << ", 0, 0";
#endif
      }
      genlogich.placeVolume(seclogic, ii + 1, rot0);
#ifdef EDM_ML_DEBUG
      edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: " << seclogic.name() << " number " << (ii + 1)
                                   << " positioned in " << genlogich.name() << " at (0, 0, 0) with rotation: " << rot0;
#endif
    }

    //Construct the things inside the sector
    constructInsideSector(ns, seclogic);

    //Backward half
    name = idName + "Back";
    std::vector<double> pgonZBack, pgonRminBack, pgonRmaxBack;
    pgonZBack.emplace_back(zEnd - dzShift);
    pgonRminBack.emplace_back(pgonZBack[0] * tan(angBot) + drEnd);
    pgonRmaxBack.emplace_back(roDip);
    pgonZBack.emplace_back(zEnd);
    pgonRminBack.emplace_back(pgonZBack[1] * tan(angBot) + drEnd);
    pgonRmaxBack.emplace_back(roDip);
    solid = dd4hep::Polyhedra(ns.prepend(name), nsectortot, -alpha, dphi, pgonZBack, pgonRminBack, pgonRmaxBack);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: " << solid.name() << " Polyhedra made of " << absMat << " with "
                                 << nsectortot << " sectors from " << convertRadToDeg(-alpha) << " to "
                                 << convertRadToDeg(-alpha + dphi) << " and with " << pgonZBack.size() << " sections";
    for (unsigned int i = 0; i < pgonZBack.size(); i++)
      edm::LogVerbatim("HCalGeom") << "\t\tZ = " << cms::convert2mm(pgonZBack[i])
                                   << "\tRmin = " << cms::convert2mm(pgonRminBack[i])
                                   << "\tRmax = " << cms::convert2mm(pgonRmaxBack[i]);
#endif

    dd4hep::Material absMatter = ns.material(absMat);
    dd4hep::Volume glog(solid.name(), solid, absMatter);
    genlogic.placeVolume(glog, 1);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: " << glog.name() << " number 1 positioned in " << genlogic.name()
                                 << " at (0,0,0) with no rotation";
#endif
  }

constructInsideModule()

void HCalEndcapAlgo::constructInsideModule ( cms::DDNamespace &  ns, dd4hep::Volume &  module, int  mod  )

inline

Definition at line 691 of file DDHCalEndcapAlgo.cc.

References alpha, cms::convert2mm(), angle_units::operators::convertRadToDeg(), DDSplit(), dqmdumpme::first, pixelTopology::getLayer(), mps_fire::i, LEDCalibrationChannels::iphi, cms::DDNamespace::material(), g4SimHits_cfi::Material, mod(), callgraph::module, Skims_PA_cff::name, PixelTestBeamValidation_cfi::Position, cms::DDNamespace::prepend(), makeMuonMisalignmentScenario::rot, slope, AlCaHLTBitMon_QueryRunRegistry::string, funct::tan(), and theta().

                                                                                {
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: \t\tInside module ..." << mod;
#endif

    //Pointers to the Rotation Matrices and to the Materials
    dd4hep::Rotation3D rot = getRotation(rotmat, ns);
    dd4hep::Material matter = ns.material(genMaterial);
    dd4hep::Material matplastic = ns.material(plastMat);

    double alpha = (1._pi) / nsectors;
    double zi = zminBlock[mod];

    for (int i = 0; i < layerN[mod]; i++) {
      std::string name;
      dd4hep::Solid solid;
      dd4hep::Volume glog, plog;
      int layer = getLayer(mod, i);
      double zo = zi + 0.5 * dzStep;

      for (int iphi = 0; iphi < phiSections; iphi++) {
        double ziAir = zo - thick[mod];
        double rinF, rinB;
        if (layer == 1) {
          rinF = ziAir * tan(angTop);
          rinB = zo * tan(angTop);
        } else {
          rinF = ziAir * tan(angBot);
          rinB = zo * tan(angBot);
        }
        double routF = (ziAir - z1Beam) * slope;
        double routB = (zo - z1Beam) * slope;
        if (routF > routBlock2[mod])
          routF = routBlock2[mod];
        if (routB > routBlock2[mod])
          routB = routBlock2[mod];

#ifdef EDM_ML_DEBUG
        edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: 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

        double yh1, bl1, tl1, yh2, bl2, tl2, theta, phi, alp;
        double xpos, ypos, zpos;
        parameterLayer(
            iphi, rinF, routF, rinB, routB, ziAir, zo, yh1, bl1, tl1, yh2, bl2, tl2, alp, theta, phi, xpos, ypos, zpos);

        name = DDSplit(module.name()).first + layerName[layer] + phiName[iphi] + "Air";
        solid = dd4hep::Trap(ns.prepend(name), 0.5 * thick[mod], theta, phi, yh1, bl1, tl1, alp, yh2, bl2, tl2, alp);
#ifdef EDM_ML_DEBUG
        edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: " << solid.name() << " Trap made of " << matter.name()
                                     << " of dimensions " << cms::convert2mm(0.5 * thick[mod]) << ", "
                                     << convertRadToDeg(theta) << ", " << convertRadToDeg(phi) << ", "
                                     << cms::convert2mm(yh1) << ", " << cms::convert2mm(bl1) << ", "
                                     << cms::convert2mm(tl1) << ", " << convertRadToDeg(alp) << ", "
                                     << cms::convert2mm(yh2) << ", " << cms::convert2mm(bl2) << ", "
                                     << cms::convert2mm(tl2) << ", " << convertRadToDeg(alp);
#endif

        glog = dd4hep::Volume(solid.name(), solid, matter);
        dd4hep::Position r1(xpos, ypos, zpos);
        module.placeVolume(glog, layer + 1, dd4hep::Transform3D(rot, r1));

#ifdef EDM_ML_DEBUG
        edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: " << glog.name() << " number " << (layer + 1)
                                     << " positioned in " << module.name() << " at (" << cms::convert2mm(xpos) << ", "
                                     << cms::convert2mm(ypos) << ", " << cms::convert2mm(zpos)
                                     << ") with rotation: " << rot;
#endif

        //Now the plastic with scintillators
        double yh = 0.5 * (routF - rinB) - getTrim(mod, iphi);
        double bl = 0.5 * rinB * tan(alpha) - getTrim(mod, iphi);
        double tl = 0.5 * routF * tan(alpha) - getTrim(mod, iphi);
        name = DDSplit(module.name()).first + layerName[layer] + phiName[iphi];
        solid = dd4hep::Trap(ns.prepend(name), 0.5 * layerT[layer], 0, 0, yh, bl, tl, alp, yh, bl, tl, alp);
#ifdef EDM_ML_DEBUG
        edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: " << solid.name() << " Trap made of " << plastMat
                                     << " of dimensions " << cms::convert2mm(0.5 * layerT[layer]) << ", 0, 0, "
                                     << cms::convert2mm(yh) << ", " << cms::convert2mm(bl) << ", "
                                     << cms::convert2mm(tl) << ", " << convertRadToDeg(alp) << ", "
                                     << cms::convert2mm(yh) << ", " << cms::convert2mm(bl) << ", "
                                     << cms::convert2mm(tl) << ", " << convertRadToDeg(alp);
#endif

        plog = dd4hep::Volume(solid.name(), solid, matplastic);
        ypos = 0.5 * (routF + rinB) - xpos;
        glog.placeVolume(plog, idOffset + layer + 1, dd4hep::Position(0., ypos, 0.));

#ifdef EDM_ML_DEBUG
        edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: " << plog.name() << " number " << (idOffset + layer + 1)
                                     << " positioned in " << glog.name() << " at (0, " << cms::convert2mm(ypos)
                                     << ", 0) with no rotation";
#endif

        //Constructing the scintillators inside
        int copyNo = layer * 10 + layerType[layer];
        name = modName[mod] + layerName[layer] + phiName[iphi];
        constructScintLayer(ns, plog, scintT[layer], yh, bl, tl, alp, name, copyNo);
        zo += 0.5 * dzStep;
      }  // End of loop over phi indices
      zi = zo - 0.5 * dzStep;
    }  // End of loop on layers
  }

constructInsideModule0()

void HCalEndcapAlgo::constructInsideModule0 ( cms::DDNamespace &  ns, dd4hep::Volume &  module, int  mod  )

inline

Definition at line 578 of file DDHCalEndcapAlgo.cc.

References cms::convert2mm(), angle_units::operators::convertRadToDeg(), DDSplit(), fact, dqmdumpme::first, pixelTopology::getLayer(), LEDCalibrationChannels::iphi, cms::DDNamespace::material(), g4SimHits_cfi::Material, mod(), callgraph::module, Skims_PA_cff::name, PixelTestBeamValidation_cfi::Position, cms::DDNamespace::prepend(), diffTwoXMLs::r2, makeMuonMisalignmentScenario::rot, slope, AlCaHLTBitMon_QueryRunRegistry::string, funct::tan(), and theta().

                                                                                 {
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: \t\tInside module0 ..." << mod;
#endif

    //Pointers to the Rotation Matrices and to the Materials
    dd4hep::Rotation3D rot = getRotation(rotmat, ns);
    dd4hep::Material matabsorbr = ns.material(absMat);
    dd4hep::Material matplastic = ns.material(plastMat);

    int layer = getLayer(mod, 0);
    int layer0 = getLayer(mod, 1);
    std::string name;
    double xpos, ypos, zpos;
    dd4hep::Solid solid;
    dd4hep::Volume glog;
    for (int iphi = 0; iphi < phiSections; iphi++) {
      double yh, bl, tl, alp;
      parameterLayer0(mod, layer, iphi, yh, bl, tl, alp, xpos, ypos, zpos);
      name = DDSplit(module.name()).first + layerName[layer] + phiName[iphi];
      solid = dd4hep::Trap(ns.prepend(name), 0.5 * layerT[layer], 0, 0, yh, bl, tl, alp, yh, bl, tl, alp);
#ifdef EDM_ML_DEBUG
      edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: " << solid.name() << " Trap made of " << plastMat
                                   << " of dimensions " << cms::convert2mm(0.5 * layerT[layer]) << ", 0, 0, "
                                   << cms::convert2mm(yh) << ", " << cms::convert2mm(bl) << ", " << cms::convert2mm(tl)
                                   << ", " << convertRadToDeg(alp) << ", " << cms::convert2mm(yh) << ", "
                                   << cms::convert2mm(bl) << ", " << cms::convert2mm(tl) << ", "
                                   << convertRadToDeg(alp);
#endif

      glog = dd4hep::Volume(solid.name(), solid, matplastic);

      dd4hep::Position r1(xpos, ypos, zpos);
      module.placeVolume(glog, idOffset + layer + 1, dd4hep::Transform3D(rot, r1));

#ifdef EDM_ML_DEBUG
      edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: " << glog.name() << " number " << (idOffset + layer + 1)
                                   << " positioned in " << module.name() << " at (" << cms::convert2mm(xpos) << ", "
                                   << cms::convert2mm(ypos) << ", " << cms::convert2mm(zpos)
                                   << " with rotation: " << rot;
#endif

      //Now construct the layer of scintillator inside this
      int copyNo = layer0 * 10 + layerType[layer];
      name = modName[mod] + layerName[layer] + phiName[iphi];
      constructScintLayer(ns, glog, scintT[layer], yh, bl, tl, alp, name, copyNo);
    }

    //Now the absorber layer
    double zi = zminBlock[mod] + layerT[layer];
    double zo = zi + 0.5 * dzStep;
    double rinF, routF, rinB, routB;
    if (mod == 0) {
      rinF = zi * tan(angTop);
      routF = (zi - z1Beam) * slope;
      rinB = zo * tan(angTop);
      routB = (zo - z1Beam) * slope;
    } else {
      rinF = zi * tan(angBot);
      routF = zi * tan(angTop);
      rinB = zo * tan(angBot);
      routB = zo * tan(angTop);
    }

#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: Module " << mod << " Front " << cms::convert2mm(zi) << ", "
                                 << cms::convert2mm(rinF) << ", " << cms::convert2mm(routF) << " Back "
                                 << cms::convert2mm(zo) << ", " << cms::convert2mm(rinB) << ", "
                                 << cms::convert2mm(routB);
#endif

    double yh1, bl1, tl1, yh2, bl2, tl2, theta, phi, alp;
    parameterLayer(
        0, rinF, routF, rinB, routB, zi, zo, yh1, bl1, tl1, yh2, bl2, tl2, alp, theta, phi, xpos, ypos, zpos);
    double fact = tolAbs;

#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: Trim " << cms::convert2mm(fact) << " Param "
                                 << cms::convert2mm(yh1) << ", " << cms::convert2mm(bl1) << ", " << cms::convert2mm(tl1)
                                 << ", " << cms::convert2mm(yh2) << ", " << cms::convert2mm(bl2) << ", "
                                 << cms::convert2mm(tl2);
#endif

    bl1 -= fact;
    tl1 -= fact;
    bl2 -= fact;
    tl2 -= fact;

    name = DDSplit(module.name()).first + "Absorber";
    solid = dd4hep::Trap(ns.prepend(name), 0.5 * thick[mod], theta, phi, yh1, bl1, tl1, alp, yh2, bl2, tl2, alp);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: " << solid.name() << " Trap made of " << absMat
                                 << " of dimensions " << cms::convert2mm(0.5 * thick[mod]) << ", "
                                 << convertRadToDeg(theta) << ", " << convertRadToDeg(phi) << ", "
                                 << cms::convert2mm(yh1) << ", " << cms::convert2mm(bl1) << ", " << cms::convert2mm(tl1)
                                 << ", " << convertRadToDeg(alp) << ", " << cms::convert2mm(yh2) << ", "
                                 << cms::convert2mm(bl2) << ", " << cms::convert2mm(tl2) << ", "
                                 << convertRadToDeg(alp);
#endif

    glog = dd4hep::Volume(solid.name(), solid, matabsorbr);

    dd4hep::Position r2(xpos, ypos, zpos);
    module.placeVolume(glog, 1, dd4hep::Transform3D(rot, r2));

#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: " << glog.name() << " number 1 positioned in " << module.name()
                                 << " at (" << cms::convert2mm(xpos) << ", " << cms::convert2mm(ypos) << ", "
                                 << cms::convert2mm(zpos) << ") with rotation: " << rot;
#endif
  }

constructInsideSector()

void HCalEndcapAlgo::constructInsideSector ( cms::DDNamespace &  ns, dd4hep::Volume &  sector  )

inline

!!!!!!!!!!!!!!!!Should be zero. And removed as soon as

Definition at line 507 of file DDHCalEndcapAlgo.cc.

References alpha, cms::convert2mm(), angle_units::operators::convertRadToDeg(), mps_fire::i, versionedElectronIDProducer_cfi::idName, dqmdumpme::k, cms::DDNamespace::material(), g4SimHits_cfi::Material, LogMessageMonitor_cff::modules, Skims_PA_cff::name, HGCalGeometryMode::Polyhedra, cms::DDNamespace::prepend(), hgcalTBTopologyTester_cfi::sector, slope, AlCaHLTBitMon_QueryRunRegistry::string, and funct::tan().

                                                                       {
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: Modules (" << modules << ") ...";
#endif

    double alpha = (1._pi) / nsectors;
    for (int i = 0; i < modules; i++) {
      std::string name = idName + modName[i];
      dd4hep::Material matter = ns.material(modMat[i]);

      if (eModule[i] > 0) {
        int nsec = sectionModule[i];

        //vertical walls are allowed in SolidPolyhedra
        double deltaz = 0;

        std::vector<double> pgonZ, pgonRmin, pgonRmax;
        if (nsec == 3) {
          double zf = zminBlock[i] + zShiftHac2;
          pgonZ.emplace_back(zf);
          pgonRmin.emplace_back(zf * tan(angBot));
          pgonRmax.emplace_back((zf - z1Beam) * slope);
          pgonZ.emplace_back(ziKink);
          pgonRmin.emplace_back(riKink);
          pgonRmax.emplace_back(rout);
        } else {
          pgonZ.emplace_back(zminBlock[i]);
          pgonRmin.emplace_back(rinBlock1[i]);
          pgonRmax.emplace_back(routBlock1[i]);
        }
        if (nsec == 4) {
          pgonZ.emplace_back(ziDip);
          pgonRmin.emplace_back(riDip);
          pgonRmax.emplace_back(rout);
          pgonZ.emplace_back(pgonZ[1] + deltaz);
          pgonRmin.emplace_back(pgonRmin[1]);
          pgonRmax.emplace_back(roDip);
        }
        pgonZ.emplace_back(zmaxBlock[i]);
        pgonRmin.emplace_back(rinBlock2[i]);
        pgonRmax.emplace_back(routBlock2[i]);

        //Solid & volume
        dd4hep::Solid solid = dd4hep::Polyhedra(ns.prepend(name), 1, -alpha, 2 * alpha, pgonZ, pgonRmin, pgonRmax);
#ifdef EDM_ML_DEBUG
        edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: " << solid.name() << " Polyhedra made of " << modMat[i]
                                     << " with 1 sector from " << convertRadToDeg(-alpha) << " to "
                                     << convertRadToDeg(alpha) << " and with " << nsec << " sections";
        for (unsigned int k = 0; k < pgonZ.size(); k++)
          edm::LogVerbatim("HCalGeom") << "\t\tZ = " << cms::convert2mm(pgonZ[k])
                                       << "\tRmin = " << cms::convert2mm(pgonRmin[k])
                                       << "\tRmax = " << cms::convert2mm(pgonRmax[k]);
#endif

        dd4hep::Volume glog(solid.name(), solid, matter);

        sector.placeVolume(glog, i + 1);
#ifdef EDM_ML_DEBUG
        edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: " << glog.name() << " number " << (i + 1)
                                     << " positioned in " << sector.name() << " at (0,0,0) with no rotation";
#endif

        if (modType[i] == 0)
          constructInsideModule0(ns, glog, i);
        else
          constructInsideModule(ns, glog, i);
      }
    }
  }

constructScintLayer()

void HCalEndcapAlgo::constructScintLayer ( cms::DDNamespace &  ns, dd4hep::Volume &  detector, double  dz, double  yh, double  bl, double  tl, double  alp, const std::string &  nm, int  id  )

inline

Definition at line 799 of file DDHCalEndcapAlgo.cc.

References 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(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                   {
    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, yh, bl, tl, alp, yh, bl, tl, alp);
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "DDHCalEndcapAlgo: " << solid.name() << " Trap made of " << scintMat
                                 << " of dimensions " << cms::convert2mm(0.5 * dz) << ", 0, 0, " << cms::convert2mm(yh)
                                 << ", " << cms::convert2mm(bl) << ", " << cms::convert2mm(tl) << ", "
                                 << convertRadToDeg(alp) << ", " << cms::convert2mm(yh) << ", " << cms::convert2mm(bl)
                                 << ", " << cms::convert2mm(tl) << ", " << convertRadToDeg(alp);
#endif

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

getLayer()

int HCalEndcapAlgo::getLayer ( unsigned int  i, unsigned int  j  ) const

inline

Definition at line 828 of file DDHCalEndcapAlgo.cc.

References mps_fire::i, and dqmiolumiharvest::j.

                                                     {
    switch (i) {
      case 0:
        return layerN0[j];
        break;
      case 1:
        return layerN1[j];
        break;
      case 2:
        return layerN2[j];
        break;
      case 3:
        return layerN3[j];
        break;
      case 4:
        return layerN4[j];
        break;
      case 5:
        return layerN5[j];
        break;
      default:
        return 0;
    }
  }

getRotation()

dd4hep::Rotation3D HCalEndcapAlgo::getRotation ( const std::string &  rotation, cms::DDNamespace &  ns  )

inline

Definition at line 981 of file DDHCalEndcapAlgo.cc.

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

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

getTrim()

double HCalEndcapAlgo::getTrim ( unsigned int  i, unsigned int  j  ) const

inline

Definition at line 853 of file DDHCalEndcapAlgo.cc.

References mps_fire::i, and dqmiolumiharvest::j.

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

parameterLayer()

void HCalEndcapAlgo::parameterLayer ( int  iphi, double  rinF, double  routF, double  rinB, double  routB, double  zi, double  zo, double &  yh1, double &  bl1, double &  tl1, double &  yh2, double &  bl2, double &  tl2, double &  alp, double &  theta, double &  phi, double &  xpos, double &  ypos, double &  zpos  )

inline

Definition at line 918 of file DDHCalEndcapAlgo.cc.

References alpha, cms::convert2mm(), angle_units::operators::convertRadToDeg(), PVValHelper::dx, PVValHelper::dy, LEDCalibrationChannels::iphi, mathSSE::sqrt(), funct::tan(), and theta().

                                    {
    //Given rin, rout compute parameters of the trapezoid and
    //position of the trapezoid for a standrd layer
    double alpha = (1._pi) / nsectors;

#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

    yh1 = 0.5 * (routF - rinB);
    bl1 = 0.5 * rinB * tan(alpha);
    tl1 = 0.5 * routF * tan(alpha);
    yh2 = 0.5 * (routF - rinB);
    bl2 = 0.5 * rinB * tan(alpha);
    tl2 = 0.5 * routF * tan(alpha);
    double dx = 0.25 * (bl2 + tl2 - bl1 - tl1);
    double dy = 0.5 * (rinB + routF - rinB - routF);
    xpos = 0.25 * (rinB + routF + rinB + routF);
    ypos = 0.25 * (bl2 + tl2 + bl1 + tl1);
    zpos = 0.5 * (zi + zo);
    alp = atan(0.5 * tan(alpha));
    //  ypos-= tolPos;
    if (iphi == 0) {
      ypos = -ypos;
    } else {
      alp = -alp;
      dx = -dx;
    }
    double r = sqrt(dx * dx + dy * dy);
    theta = atan(r / (zo - zi));
    phi = atan2(dy, dx);

#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "Output Dimensions " << cms::convert2mm(yh1) << " " << cms::convert2mm(bl1) << " "
                                 << cms::convert2mm(tl1) << " " << cms::convert2mm(yh2) << " " << cms::convert2mm(bl2)
                                 << " " << cms::convert2mm(tl2) << " " << convertRadToDeg(alp) << " "
                                 << convertRadToDeg(theta) << " " << convertRadToDeg(phi) << " Position "
                                 << cms::convert2mm(xpos) << " " << cms::convert2mm(ypos) << " "
                                 << cms::convert2mm(zpos);
#endif
  }

parameterLayer0()

void HCalEndcapAlgo::parameterLayer0 ( int  mod, int  layer, int  iphi, double &  yh, double &  bl, double &  tl, double &  alp, double &  xpos, double &  ypos, double &  zpos  )

inline

Definition at line 860 of file DDHCalEndcapAlgo.cc.

References alpha, cms::convert2mm(), angle_units::operators::convertRadToDeg(), LEDCalibrationChannels::iphi, mod(), slope, and funct::tan().

                                     {
    //Given module and layer number compute parameters of trapezoid
    //and positioning parameters
    double alpha = (1._pi) / nsectors;
#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "Input " << iphi << " " << layer << " " << iphi << " Alpha "
                                 << convertRadToDeg(alpha);
#endif

    double zi, zo;
    if (iphi == 0) {
      zi = zminBlock[mod];
      zo = zi + layerT[layer];
    } else {
      zo = zmaxBlock[mod];
      zi = zo - layerT[layer];
    }
    double rin, rout;
    if (mod == 0) {
      rin = zo * tan(angTop);
      rout = (zi - z1Beam) * slope;
    } else {
      rin = zo * tan(angBot);
      rout = zi * tan(angTop);
    }
    yh = 0.5 * (rout - rin);
    bl = 0.5 * rin * tan(alpha);
    tl = 0.5 * rout * tan(alpha);
    xpos = 0.5 * (rin + rout);
    ypos = 0.5 * (bl + tl);
    zpos = 0.5 * (zi + zo);
    yh -= getTrim(mod, iphi);
    bl -= getTrim(mod, iphi);
    tl -= getTrim(mod, iphi);
    alp = atan(0.5 * tan(alpha));
    if (iphi == 0) {
      ypos = -ypos;
    } else {
      alp = -alp;
    }

#ifdef EDM_ML_DEBUG
    edm::LogVerbatim("HCalGeom") << "Output Dimensions " << cms::convert2mm(yh) << " " << cms::convert2mm(bl) << " "
                                 << cms::convert2mm(tl) << " " << convertRadToDeg(alp) << " Position "
                                 << cms::convert2mm(xpos) << " " << cms::convert2mm(ypos) << " "
                                 << cms::convert2mm(zpos);
#endif
  }

Member Data Documentation

absMat

std::string HCalEndcapAlgo::absMat

Definition at line 55 of file DDHCalEndcapAlgo.cc.

angBot

double HCalEndcapAlgo::angBot

Definition at line 52 of file DDHCalEndcapAlgo.cc.

angGap

double HCalEndcapAlgo::angGap

Definition at line 53 of file DDHCalEndcapAlgo.cc.

angTop

double HCalEndcapAlgo::angTop

Definition at line 51 of file DDHCalEndcapAlgo.cc.

drEnd

double HCalEndcapAlgo::drEnd

Definition at line 50 of file DDHCalEndcapAlgo.cc.

dzShift

double HCalEndcapAlgo::dzShift

Definition at line 43 of file DDHCalEndcapAlgo.cc.

dzStep

double HCalEndcapAlgo::dzStep

Definition at line 42 of file DDHCalEndcapAlgo.cc.

eModule

std::vector<int> HCalEndcapAlgo::eModule

Definition at line 28 of file DDHCalEndcapAlgo.cc.

genMaterial

std::string HCalEndcapAlgo::genMaterial

Definition at line 24 of file DDHCalEndcapAlgo.cc.

heboxDepth

double HCalEndcapAlgo::heboxDepth

Definition at line 49 of file DDHCalEndcapAlgo.cc.

idName

std::string HCalEndcapAlgo::idName

Definition at line 87 of file DDHCalEndcapAlgo.cc.

idOffset

int HCalEndcapAlgo::idOffset

Definition at line 88 of file DDHCalEndcapAlgo.cc.

layerN

std::vector<int> HCalEndcapAlgo::layerN

Definition at line 61 of file DDHCalEndcapAlgo.cc.

layerN0

std::vector<int> HCalEndcapAlgo::layerN0

Definition at line 62 of file DDHCalEndcapAlgo.cc.

layerN1

std::vector<int> HCalEndcapAlgo::layerN1

Definition at line 63 of file DDHCalEndcapAlgo.cc.

layerN2

std::vector<int> HCalEndcapAlgo::layerN2

Definition at line 64 of file DDHCalEndcapAlgo.cc.

layerN3

std::vector<int> HCalEndcapAlgo::layerN3

Definition at line 65 of file DDHCalEndcapAlgo.cc.

layerN4

std::vector<int> HCalEndcapAlgo::layerN4

Definition at line 66 of file DDHCalEndcapAlgo.cc.

layerN5

std::vector<int> HCalEndcapAlgo::layerN5

Definition at line 67 of file DDHCalEndcapAlgo.cc.

layerName

std::vector<std::string> HCalEndcapAlgo::layerName

Definition at line 80 of file DDHCalEndcapAlgo.cc.

layers

int HCalEndcapAlgo::layers

Definition at line 79 of file DDHCalEndcapAlgo.cc.

layerT

std::vector<double> HCalEndcapAlgo::layerT

Definition at line 82 of file DDHCalEndcapAlgo.cc.

layerType

std::vector<int> HCalEndcapAlgo::layerType

Definition at line 81 of file DDHCalEndcapAlgo.cc.

modMat

std::vector<std::string> HCalEndcapAlgo::modMat

Definition at line 58 of file DDHCalEndcapAlgo.cc.

modName

std::vector<std::string> HCalEndcapAlgo::modName

Definition at line 57 of file DDHCalEndcapAlgo.cc.

modType

std::vector<int> HCalEndcapAlgo::modType

Definition at line 59 of file DDHCalEndcapAlgo.cc.

modules

int HCalEndcapAlgo::modules

Definition at line 56 of file DDHCalEndcapAlgo.cc.

Referenced by postprocessor.PostProcessor::run().

nEndcap

int HCalEndcapAlgo::nEndcap

Definition at line 27 of file DDHCalEndcapAlgo.cc.

nsectors

int HCalEndcapAlgo::nsectors

Definition at line 25 of file DDHCalEndcapAlgo.cc.

nsectortot

int HCalEndcapAlgo::nsectortot

Definition at line 26 of file DDHCalEndcapAlgo.cc.

phiName

std::vector<std::string> HCalEndcapAlgo::phiName

Definition at line 78 of file DDHCalEndcapAlgo.cc.

phiSections

int HCalEndcapAlgo::phiSections

Definition at line 77 of file DDHCalEndcapAlgo.cc.

plastMat

std::string HCalEndcapAlgo::plastMat

Definition at line 84 of file DDHCalEndcapAlgo.cc.

riDip

double HCalEndcapAlgo::riDip

Definition at line 47 of file DDHCalEndcapAlgo.cc.

riKink

double HCalEndcapAlgo::riKink

Definition at line 46 of file DDHCalEndcapAlgo.cc.

rinBlock1

std::vector<double> HCalEndcapAlgo::rinBlock1

Definition at line 73 of file DDHCalEndcapAlgo.cc.

rinBlock2

std::vector<double> HCalEndcapAlgo::rinBlock2

Definition at line 75 of file DDHCalEndcapAlgo.cc.

roDip

double HCalEndcapAlgo::roDip

Definition at line 48 of file DDHCalEndcapAlgo.cc.

rotation

std::string HCalEndcapAlgo::rotation

Definition at line 30 of file DDHCalEndcapAlgo.cc.

rotHalf

std::string HCalEndcapAlgo::rotHalf

Definition at line 29 of file DDHCalEndcapAlgo.cc.

rotmat

std::string HCalEndcapAlgo::rotmat

Definition at line 86 of file DDHCalEndcapAlgo.cc.

rout

double HCalEndcapAlgo::rout

Definition at line 45 of file DDHCalEndcapAlgo.cc.

routBlock1

std::vector<double> HCalEndcapAlgo::routBlock1

Definition at line 74 of file DDHCalEndcapAlgo.cc.

routBlock2

std::vector<double> HCalEndcapAlgo::routBlock2

Definition at line 76 of file DDHCalEndcapAlgo.cc.

scintMat

std::string HCalEndcapAlgo::scintMat

Definition at line 85 of file DDHCalEndcapAlgo.cc.

scintT

std::vector<double> HCalEndcapAlgo::scintT

Definition at line 83 of file DDHCalEndcapAlgo.cc.

sectionModule

std::vector<int> HCalEndcapAlgo::sectionModule

Definition at line 60 of file DDHCalEndcapAlgo.cc.

slope

double HCalEndcapAlgo::slope

Definition at line 54 of file DDHCalEndcapAlgo.cc.

thick

std::vector<double> HCalEndcapAlgo::thick

Definition at line 68 of file DDHCalEndcapAlgo.cc.

tolAbs

double HCalEndcapAlgo::tolAbs

Definition at line 89 of file DDHCalEndcapAlgo.cc.

tolPos

double HCalEndcapAlgo::tolPos

Definition at line 89 of file DDHCalEndcapAlgo.cc.

trimLeft

std::vector<double> HCalEndcapAlgo::trimLeft

Definition at line 69 of file DDHCalEndcapAlgo.cc.

trimRight

std::vector<double> HCalEndcapAlgo::trimRight

Definition at line 70 of file DDHCalEndcapAlgo.cc.

z0Beam

double HCalEndcapAlgo::z0Beam

Definition at line 39 of file DDHCalEndcapAlgo.cc.

z1Beam

double HCalEndcapAlgo::z1Beam

Definition at line 40 of file DDHCalEndcapAlgo.cc.

zEnd

double HCalEndcapAlgo::zEnd

Definition at line 33 of file DDHCalEndcapAlgo.cc.

zFront

double HCalEndcapAlgo::zFront

Definition at line 32 of file DDHCalEndcapAlgo.cc.

ziBody

double HCalEndcapAlgo::ziBody

Definition at line 36 of file DDHCalEndcapAlgo.cc.

ziDip

double HCalEndcapAlgo::ziDip

Definition at line 41 of file DDHCalEndcapAlgo.cc.

ziKink

double HCalEndcapAlgo::ziKink

Definition at line 38 of file DDHCalEndcapAlgo.cc.

ziL0Body

double HCalEndcapAlgo::ziL0Body

Definition at line 37 of file DDHCalEndcapAlgo.cc.

ziL0Nose

double HCalEndcapAlgo::ziL0Nose

Definition at line 35 of file DDHCalEndcapAlgo.cc.

ziNose

double HCalEndcapAlgo::ziNose

Definition at line 34 of file DDHCalEndcapAlgo.cc.

zmaxBlock

std::vector<double> HCalEndcapAlgo::zmaxBlock

Definition at line 72 of file DDHCalEndcapAlgo.cc.

zminBlock

std::vector<double> HCalEndcapAlgo::zminBlock

Definition at line 71 of file DDHCalEndcapAlgo.cc.

zShift

double HCalEndcapAlgo::zShift

Definition at line 31 of file DDHCalEndcapAlgo.cc.

zShiftHac2

double HCalEndcapAlgo::zShiftHac2

Definition at line 44 of file DDHCalEndcapAlgo.cc.