GEMGeometryBuilderFromDDD Class Reference

#include <GEMGeometryBuilderFromDDD.h>

Public Member Functions
void	build (GEMGeometry &theGeometry, const cms::DDCompactView *cview, const MuonGeometryConstants &muonConstants)
void	build (GEMGeometry &theGeometry, const DDCompactView *cview, const MuonGeometryConstants &muonConstants)
	GEMGeometryBuilderFromDDD ()
	~GEMGeometryBuilderFromDDD ()

Private Types
typedef ReferenceCountingPointer< BoundPlane >	RCPBoundPlane

Private Member Functions
RCPBoundPlane	boundPlane (const cms::DDFilteredView &fv, Bounds *bounds, bool isOddChamber) const
RCPBoundPlane	boundPlane (const DDFilteredView &fv, Bounds *bounds, bool isOddChamber) const
GEMChamber *	buildChamber (cms::DDFilteredView &fv, GEMDetId detId) const
GEMChamber *	buildChamber (DDFilteredView &fv, GEMDetId detId) const
GEMEtaPartition *	buildEtaPartition (cms::DDFilteredView &fv, GEMDetId detId) const
GEMEtaPartition *	buildEtaPartition (DDFilteredView &fv, GEMDetId detId) const
GEMSuperChamber *	buildSuperChamber (cms::DDFilteredView &fv, GEMDetId detId) const
GEMSuperChamber *	buildSuperChamber (DDFilteredView &fv, GEMDetId detId) const

Private Attributes
std::map< GEMDetId, std::vector< GEMDetId > >	chids

Detailed Description

Definition at line 34 of file GEMGeometryBuilderFromDDD.h.

Member Typedef Documentation

RCPBoundPlane

typedef ReferenceCountingPointer<BoundPlane> GEMGeometryBuilderFromDDD::RCPBoundPlane

private

Definition at line 49 of file GEMGeometryBuilderFromDDD.h.

Constructor & Destructor Documentation

GEMGeometryBuilderFromDDD()

GEMGeometryBuilderFromDDD::GEMGeometryBuilderFromDDD

(

)

Definition at line 40 of file GEMGeometryBuilderFromDDD.cc.

{}

~GEMGeometryBuilderFromDDD()

GEMGeometryBuilderFromDDD::~GEMGeometryBuilderFromDDD

(

)

Definition at line 42 of file GEMGeometryBuilderFromDDD.cc.

{}

Member Function Documentation

boundPlane() [1/2]

GEMGeometryBuilderFromDDD::RCPBoundPlane GEMGeometryBuilderFromDDD::boundPlane ( const cms::DDFilteredView &  fv, Bounds *  bounds, bool  isOddChamber  ) const

private

Definition at line 506 of file GEMGeometryBuilderFromDDD.cc.

                                                                                                        {
  // extract the position
  const Double_t* tran = fv.trans();
  Surface::PositionType posResult(tran[0], tran[1], tran[2]);
 
  // now the rotation
  DDRotationMatrix rota;
  fv.rot(rota);
  DD3Vector x, y, z;
  rota.GetComponents(x, y, z);
  Surface::RotationType rotResult(float(x.X()),
                                  float(x.Y()),
                                  float(x.Z()),
                                  float(y.X()),
                                  float(y.Y()),
                                  float(y.Z()),
                                  float(z.X()),
                                  float(z.Y()),
                                  float(z.Z()));
 
  //Change of axes for the forward
  Basic3DVector<float> newX(1., 0., 0.);
  Basic3DVector<float> newY(0., 0., -1.);
  Basic3DVector<float> newZ(0., 1., 0.);
 
  rotResult.rotateAxes(newX, newY, newZ);
 
  return RCPBoundPlane(new BoundPlane(posResult, rotResult, bounds));
}

References cms::DDFilteredView::rot(), TkRotation< T >::rotateAxes(), and cms::DDFilteredView::trans().

boundPlane() [2/2]

GEMGeometryBuilderFromDDD::RCPBoundPlane GEMGeometryBuilderFromDDD::boundPlane ( const DDFilteredView &  fv, Bounds *  bounds, bool  isOddChamber  ) const

private

Definition at line 304 of file GEMGeometryBuilderFromDDD.cc.

                                                                                                        {
  // extract the position
  const DDTranslation& trans(fv.translation());
  const Surface::PositionType posResult(float(trans.x() / cm), float(trans.y() / cm), float(trans.z() / cm));
 
  // now the rotation
  const DDRotationMatrix& rotation = fv.rotation();
  DD3Vector x, y, z;
  rotation.GetComponents(x, y, z);
 
  Surface::RotationType rotResult(float(x.X()),
                                  float(x.Y()),
                                  float(x.Z()),
                                  float(y.X()),
                                  float(y.Y()),
                                  float(y.Z()),
                                  float(z.X()),
                                  float(z.Y()),
                                  float(z.Z()));
 
  //Change of axes for the forward
  Basic3DVector<float> newX(1., 0., 0.);
  Basic3DVector<float> newY(0., 0., -1.);
  Basic3DVector<float> newZ(0., 1., 0.);
 
  rotResult.rotateAxes(newX, newY, newZ);
 
  return RCPBoundPlane(new BoundPlane(posResult, rotResult, bounds));
}

References TkRotation< T >::rotateAxes(), idealTransformation::rotation, DDFilteredView::rotation(), and DDFilteredView::translation().

build() [1/2]

void GEMGeometryBuilderFromDDD::build	(	GEMGeometry &	theGeometry,
		const cms::DDCompactView *	cview,
		const MuonGeometryConstants &	muonConstants
	)

Definition at line 338 of file GEMGeometryBuilderFromDDD.cc.

                                                                                  {
  std::string attribute = "MuStructure";
  std::string value = "MuonEndCapGEM";
  cms::DDFilteredView fv(cview->detector(), cview->detector()->worldVolume());
  cms::DDSpecParRefs refs;
  const cms::DDSpecParRegistry& mypar = cview->specpars();
  mypar.filter(refs, attribute, value);
  fv.mergedSpecifics(refs);
 
  bool doChambers = fv.firstChild();
 
  // loop over superchambers
  std::vector<GEMSuperChamber*> superChambers;
 
  while (doChambers) {
    MuonDDDNumbering mdddnum(muonConstants);
    GEMNumberingScheme gemNum(muonConstants);
    int rawidCh = gemNum.baseNumberToUnitNumber(mdddnum.geoHistoryToBaseNumber(fv.history()));
    GEMDetId detIdCh = GEMDetId(rawidCh);
 
    if (detIdCh.layer() == 1) {  // only make superChambers when doing layer 1
      GEMSuperChamber* gemSuperChamber = buildSuperChamber(fv, detIdCh);
      superChambers.push_back(gemSuperChamber);
    }
 
    //  GEMChamber* gemChamber = ((detIdCh.station() == GEMDetId::minStationId0) ? nullptr : buildChamber(fv, detIdCh));
    GEMChamber* gemChamber = buildChamber(fv, detIdCh);
 
    fv.down();
    fv.down();
    bool doEtaPart = fv.nextSibling();
    while (doEtaPart) {
      int rawid = gemNum.baseNumberToUnitNumber(mdddnum.geoHistoryToBaseNumber(fv.history()));
      GEMDetId detId = GEMDetId(rawid);
      GEMEtaPartition* etaPart = buildEtaPartition(fv, detId);
 
      gemChamber->add(etaPart);
 
      theGeometry.add(etaPart);
      doEtaPart = fv.sibling();
    }
    theGeometry.add(gemChamber);
    fv.up();
    fv.up();
    fv.up();
 
    doChambers = fv.firstChild();
 
  }  // close while Chambers
 
  // construct the regions, stations and rings.
  for (int re = -1; re <= 1; re = re + 2) {
    GEMRegion* region = new GEMRegion(re);
    for (int st = 1; st <= GEMDetId::maxStationId; ++st) {
      GEMStation* station = new GEMStation(re, st);
      std::string sign(re == -1 ? "-" : "");
      std::string name("GE" + sign + std::to_string(st) + "/1");
      station->setName(name);
      for (int ri = 1; ri <= 1; ++ri) {
        GEMRing* ring = new GEMRing(re, st, ri);
        for (auto superChamber : superChambers) {
          const GEMDetId detId(superChamber->id());
          if (detId.region() != re || detId.station() != st || detId.ring() != ri)
            continue;
 
          superChamber->add(
              theGeometry.chamber(GEMDetId(detId.region(), detId.ring(), detId.station(), 1, detId.chamber(), 0)));
          superChamber->add(
              theGeometry.chamber(GEMDetId(detId.region(), detId.ring(), detId.station(), 2, detId.chamber(), 0)));
 
          ring->add(superChamber);
          theGeometry.add(superChamber);
 
          LogDebug("GEMGeometryBuilderFromDDD") << "Adding super chamber " << detId << " to ring: "
                                                << "re " << re << " st " << st << " ri " << ri << std::endl;
        }
        LogDebug("GEMGeometryBuilderFromDDD") << "Adding ring " << ri << " to station "
                                              << "re " << re << " st " << st << std::endl;
 
        station->add(ring);
        theGeometry.add(ring);
      }
      LogDebug("GEMGeometryBuilderFromDDD") << "Adding station " << st << " to region " << re << std::endl;
 
      region->add(station);
      theGeometry.add(station);
    }
    LogDebug("GEMGeometryBuilderFromDDD") << "Adding region " << re << " to the geometry " << std::endl;
 
    theGeometry.add(region);
  }
}

References GEMChamber::add(), GEMGeometry::add(), GEMNumberingScheme::baseNumberToUnitNumber(), GEMGeometry::chamber(), cms::DDCompactView::detector(), cms::DDSpecParRegistry::filter(), MuonDDDNumbering::geoHistoryToBaseNumber(), GEMDetId::layer(), LogDebug, GEMDetId::maxStationId, Skims_PA_cff::name, HLT_2018_cff::region, relativeConstraints::ring, Validation_hcalonly_cfi::sign, cms::DDCompactView::specpars(), relativeConstraints::station, AlCaHLTBitMon_QueryRunRegistry::string, and cms::DDDetector::worldVolume().

build() [2/2]

void GEMGeometryBuilderFromDDD::build	(	GEMGeometry &	theGeometry,
		const DDCompactView *	cview,
		const MuonGeometryConstants &	muonConstants
	)

Definition at line 45 of file GEMGeometryBuilderFromDDD.cc.

                                                                                  {
  std::string attribute = "MuStructure";
  std::string value = "MuonEndCapGEM";
 
  // Asking only for the MuonGEM's
  DDSpecificsMatchesValueFilter filter{DDValue(attribute, value, 0.0)};
  DDFilteredView fv(*cview, filter);
 
  LogDebug("GEMGeometryBuilderFromDDD") << "Building the geometry service";
  LogDebug("GEMGeometryBuilderFromDDD") << "About to run through the GEM structure\n"
                                        << " First logical part " << fv.logicalPart().name().name();
 
  bool doSuper = fv.firstChild();
 
  LogDebug("GEMGeometryBuilderFromDDD") << "doSuperChamber = " << doSuper;
  // loop over superchambers
  std::vector<GEMSuperChamber*> superChambers;
 
  while (doSuper) {
    // getting chamber id from eta partitions
    fv.firstChild();
    fv.firstChild();
 
    MuonDDDNumbering mdddnumCh(muonConstants);
    GEMNumberingScheme gemNumCh(muonConstants);
    int rawidCh = gemNumCh.baseNumberToUnitNumber(mdddnumCh.geoHistoryToBaseNumber(fv.geoHistory()));
    GEMDetId detIdCh = GEMDetId(rawidCh);
 
    // back to chambers
 
    fv.parent();
    fv.parent();
 
    // currently there is no superchamber in the geometry
    // only 2 chambers are present separated by a gap.
    // making superchamber out of the first chamber layer including the gap between chambers
    if (detIdCh.layer() == 1) {  // only make superChambers when doing layer 1
      GEMSuperChamber* gemSuperChamber = buildSuperChamber(fv, detIdCh);
      superChambers.push_back(gemSuperChamber);
    }
    GEMChamber* gemChamber = ((detIdCh.station() == GEMDetId::minStationId0) ? nullptr : buildChamber(fv, detIdCh));
 
    // loop over chambers
    // only 1 chamber
    bool doChambers = fv.firstChild();
    bool loopExecuted = false;
 
    while (doChambers) {
      loopExecuted = true;
 
      if (detIdCh.station() == GEMDetId::minStationId0) {
        fv.firstChild();
        MuonDDDNumbering mdddnum(muonConstants);
        GEMNumberingScheme ge0Num(muonConstants);
        int rawId = ge0Num.baseNumberToUnitNumber(mdddnum.geoHistoryToBaseNumber(fv.geoHistory()));
        GEMDetId detId = GEMDetId(rawId);
        fv.parent();
 
        gemChamber = buildChamber(fv, detId);
      }
 
      // loop over GEMEtaPartitions
      bool doEtaPart = fv.firstChild();
 
      while (doEtaPart) {
        MuonDDDNumbering mdddnum(muonConstants);
        GEMNumberingScheme gemNum(muonConstants);
        int rawid = gemNum.baseNumberToUnitNumber(mdddnum.geoHistoryToBaseNumber(fv.geoHistory()));
        GEMDetId detId = GEMDetId(rawid);
        GEMEtaPartition* etaPart = buildEtaPartition(fv, detId);
        gemChamber->add(etaPart);
        theGeometry.add(etaPart);
        doEtaPart = fv.nextSibling();
      }
 
      fv.parent();
 
      theGeometry.add(gemChamber);
 
      doChambers = fv.nextSibling();
    }
    fv.parent();
 
    doSuper = fv.nextSibling();
 
    if (!loopExecuted) {
      delete gemChamber;
    }
  }
 
  // construct the regions, stations and rings.
  for (int re = -1; re <= 1; re = re + 2) {
    GEMRegion* region = new GEMRegion(re);
    for (int st = GEMDetId::minStationId0; st <= GEMDetId::maxStationId; ++st) {
      bool ge0Station = st == GEMDetId::minStationId0;
      GEMStation* station = new GEMStation(re, st);
      std::string sign(re == -1 ? "-" : "");
      std::string suffix = ge0Station ? "" : "/1";
      std::string name = "GE" + sign + std::to_string(st) + suffix;
      station->setName(name);
      bool foundSuperChamber = false;
      for (int ri = 1; ri <= 1; ++ri) {
        GEMRing* ring = new GEMRing(re, st, ri);
        for (auto superChamber : superChambers) {
          const GEMDetId detId(superChamber->id());
          if (detId.region() != re || detId.station() != st || detId.ring() != ri)
            continue;
 
          foundSuperChamber = true;
          int nlayers = ge0Station ? GEMDetId::maxLayerId0 : GEMDetId::maxLayerId;
 
          // GEMDetId::minLayerId is to id the superchamber, so minLayerId+1 is the first layer
          for (int la = GEMDetId::minLayerId + 1; la <= nlayers; ++la) {
            GEMDetId chId(detId.region(), detId.ring(), detId.station(), la, detId.chamber(), 0);
            auto chamber = theGeometry.chamber(chId);
            if (!chamber) {
              edm::LogWarning("GEMGeometryBuilderFromDDD") << "Missing chamber " << chId << std::endl;
            }
            superChamber->add(chamber);
          }
          ring->add(superChamber);
          theGeometry.add(superChamber);
          LogDebug("GEMGeometryBuilderFromDDD") << "Adding super chamber " << detId << " to ring: "
                                                << "re " << re << " st " << st << " ri " << ri << std::endl;
        }
        LogDebug("GEMGeometryBuilderFromDDD") << "Adding ring " << ri << " to station "
                                              << "re " << re << " st " << st << std::endl;
        if (!foundSuperChamber) {
          delete ring;
        } else {
          station->add(ring);
          theGeometry.add(ring);
        }
      }
      if (!foundSuperChamber) {
        LogDebug("GEMGeometryBuilderFromDDD") << "No superchamber found: re:" << re << " st:" << st << std::endl;
        delete station;
      } else {
        LogDebug("GEMGeometryBuilderFromDDD") << "Adding station " << st << " to region " << re << std::endl;
        region->add(station);
        theGeometry.add(station);
      }
    }
    LogDebug("GEMGeometryBuilderFromDDD") << "Adding region " << re << " to the geometry " << std::endl;
 
    theGeometry.add(region);
  }
}

References GEMChamber::add(), GEMGeometry::add(), GEMNumberingScheme::baseNumberToUnitNumber(), relativeConstraints::chamber, GEMGeometry::chamber(), ALCARECOTkAlBeamHalo_cff::filter, DDFilteredView::firstChild(), DDFilteredView::geoHistory(), MuonDDDNumbering::geoHistoryToBaseNumber(), GEMDetId::layer(), LogDebug, DDFilteredView::logicalPart(), GEMDetId::maxLayerId, GEMDetId::maxLayerId0, GEMDetId::maxStationId, GEMDetId::minLayerId, GEMDetId::minStationId0, Skims_PA_cff::name, DDName::name(), DDBase< N, C >::name(), DDFilteredView::nextSibling(), nlayers, DDFilteredView::parent(), HLT_2018_cff::region, relativeConstraints::ring, Validation_hcalonly_cfi::sign, relativeConstraints::station, GEMDetId::station(), AlCaHLTBitMon_QueryRunRegistry::string, and createPayload::suffix.

Referenced by GEMGeometryESModule::produce().

buildChamber() [1/2]

GEMChamber * GEMGeometryBuilderFromDDD::buildChamber ( cms::DDFilteredView &  fv, GEMDetId  detId  ) const

private

Definition at line 459 of file GEMGeometryBuilderFromDDD.cc.

                                                                                               {
  cms::DDSolid solid(fv.solid());
  auto solidA = solid.solidA();
  std::vector<double> dpar = solidA.dimensions();
 
  double dy = dpar[3];   //length is along local Y
  double dz = dpar[2];   // thickness is long local Z
  double dx1 = dpar[0];  // bottom width is along local X
  double dx2 = dpar[1];  // top width is along local X
 
  auto solidB = solid.solidB();
  dpar = solidB.dimensions();
 
  dz += dpar[2];  // chamber thickness
 
  bool isOdd = detId.chamber() % 2;
  RCPBoundPlane surf(boundPlane(fv, new TrapezoidalPlaneBounds(dx1, dx2, dy, dz), isOdd));
 
  GEMChamber* chamber = new GEMChamber(detId.chamberId(), surf);
  return chamber;
}

References relativeConstraints::chamber, GEMDetId::chamber(), GEMDetId::chamberId(), PVValHelper::dy, PVValHelper::dz, cms::DDFilteredView::solid(), and cms::DDSolid::solidA().

buildChamber() [2/2]

GEMChamber * GEMGeometryBuilderFromDDD::buildChamber ( DDFilteredView &  fv, GEMDetId  detId  ) const

private

Definition at line 229 of file GEMGeometryBuilderFromDDD.cc.

                                                                                            {
  LogDebug("GEMGeometryBuilderFromDDD") << "buildChamber " << fv.logicalPart().name().name() << " " << detId
                                        << std::endl;
 
  DDBooleanSolid solid = (DDBooleanSolid)(fv.logicalPart().solid());
  bool ge0Station = detId.station() == GEMDetId::minStationId0;
  std::vector<double> dpar = ge0Station ? solid.parameters() : solid.solidA().parameters();
 
  double dy = geant_units::operators::convertMmToCm(dpar[0]);   //length is along local Y
  double dz = geant_units::operators::convertMmToCm(dpar[3]);   // thickness is long local Z
  double dx1 = geant_units::operators::convertMmToCm(dpar[4]);  // bottom width is along local X
  double dx2 = geant_units::operators::convertMmToCm(dpar[8]);  // top width is along local X
 
  if (!ge0Station) {
    dpar = solid.solidB().parameters();
    dz += geant_units::operators::convertMmToCm(dpar[3]);  // chamber thickness
  }
 
  bool isOdd = ge0Station ? false : detId.chamber() % 2;
 
  RCPBoundPlane surf(boundPlane(fv, new TrapezoidalPlaneBounds(dx1, dx2, dy, dz), isOdd));
 
  LogDebug("GEMGeometryBuilderFromDDD") << "size " << dx1 << " " << dx2 << " " << dy << " " << dz << std::endl;
 
  GEMChamber* chamber = new GEMChamber(detId.chamberId(), surf);
  return chamber;
}

References relativeConstraints::chamber, GEMDetId::chamber(), GEMDetId::chamberId(), geant_units::operators::convertMmToCm(), PVValHelper::dy, PVValHelper::dz, funct::false, LogDebug, DDFilteredView::logicalPart(), GEMDetId::minStationId0, DDName::name(), DDBase< N, C >::name(), DDSolid::parameters(), DDLogicalPart::solid(), DDBooleanSolid::solidA(), DDBooleanSolid::solidB(), and GEMDetId::station().

buildEtaPartition() [1/2]

GEMEtaPartition * GEMGeometryBuilderFromDDD::buildEtaPartition ( cms::DDFilteredView &  fv, GEMDetId  detId  ) const

private

Definition at line 481 of file GEMGeometryBuilderFromDDD.cc.

                                                                                                         {
  // EtaPartition specific parameter (nstrips and npads)
 
  auto nStrips = fv.get<double>("nStrips");
  auto nPads = fv.get<double>("nPads");
 
  // EtaPartition specific parameter (size)
 
  std::vector<double> dpar = fv.parameters();
 
  double ti = 0.4;  // half thickness
 
  const std::vector<float> pars{float(dpar[0]), float(dpar[1]), float(dpar[3]), float(nStrips), float(nPads)};
 
  bool isOdd = detId.chamber() % 2;
  RCPBoundPlane surf(boundPlane(fv, new TrapezoidalPlaneBounds(dpar[0], dpar[1], dpar[3], ti), isOdd));
 
  std::string_view name = fv.name();
 
  GEMEtaPartitionSpecs* e_p_specs = new GEMEtaPartitionSpecs(GeomDetEnumerators::GEM, std::string(name), pars);
 
  GEMEtaPartition* etaPartition = new GEMEtaPartition(detId, surf, e_p_specs);
  return etaPartition;
}

References GEMDetId::chamber(), dqmMemoryStats::float, GeomDetEnumerators::GEM, cms::DDFilteredView::get(), Skims_PA_cff::name, cms::DDFilteredView::name(), me0TriggerPseudoDigis_cff::nStrips, cms::DDFilteredView::parameters(), and AlCaHLTBitMon_QueryRunRegistry::string.

buildEtaPartition() [2/2]

GEMEtaPartition * GEMGeometryBuilderFromDDD::buildEtaPartition ( DDFilteredView &  fv, GEMDetId  detId  ) const

private

Definition at line 257 of file GEMGeometryBuilderFromDDD.cc.

                                                                                                      {
  LogDebug("GEMGeometryBuilderFromDDD") << "buildEtaPartition " << fv.logicalPart().name().name() << " " << detId
                                        << std::endl;
 
  // EtaPartition specific parameter (nstrips and npads)
  DDValue numbOfStrips("nStrips");
  DDValue numbOfPads("nPads");
  std::vector<const DDsvalues_type*> specs(fv.specifics());
  std::vector<const DDsvalues_type*>::iterator is = specs.begin();
  double nStrips = 0., nPads = 0.;
  for (; is != specs.end(); is++) {
    if (DDfetch(*is, numbOfStrips))
      nStrips = numbOfStrips.doubles()[0];
    if (DDfetch(*is, numbOfPads))
      nPads = numbOfPads.doubles()[0];
  }
  LogDebug("GEMGeometryBuilderFromDDD") << ((nStrips == 0.) ? ("No nStrips found!!")
                                                            : ("Number of strips: " + std::to_string(nStrips)));
  LogDebug("GEMGeometryBuilderFromDDD") << ((nPads == 0.) ? ("No nPads found!!")
                                                          : ("Number of pads: " + std::to_string(nPads)));
 
  // EtaPartition specific parameter (size)
  std::vector<double> dpar = fv.logicalPart().solid().parameters();
 
  double be = geant_units::operators::convertMmToCm(dpar[4]);  // half bottom edge
  double te = geant_units::operators::convertMmToCm(dpar[8]);  // half top edge
  double ap = geant_units::operators::convertMmToCm(dpar[0]);  // half apothem
  double ti = 0.4;                                             // half thickness
 
  std::vector<float> pars;
  pars.emplace_back(be);
  pars.emplace_back(te);
  pars.emplace_back(ap);
  pars.emplace_back(nStrips);
  pars.emplace_back(nPads);
 
  bool isOdd = detId.chamber() % 2;
  RCPBoundPlane surf(boundPlane(fv, new TrapezoidalPlaneBounds(be, te, ap, ti), isOdd));
  std::string name = fv.logicalPart().name().name();
  GEMEtaPartitionSpecs* e_p_specs = new GEMEtaPartitionSpecs(GeomDetEnumerators::GEM, name, pars);
 
  LogDebug("GEMGeometryBuilderFromDDD") << "size " << be << " " << te << " " << ap << " " << ti << std::endl;
 
  GEMEtaPartition* etaPartition = new GEMEtaPartition(detId, surf, e_p_specs);
  return etaPartition;
}

References cms::cuda::be, GEMDetId::chamber(), geant_units::operators::convertMmToCm(), DDfetch(), DDValue::doubles(), GeomDetEnumerators::GEM, LogDebug, DDFilteredView::logicalPart(), Skims_PA_cff::name, DDName::name(), DDBase< N, C >::name(), me0TriggerPseudoDigis_cff::nStrips, DDSolid::parameters(), DDLogicalPart::solid(), DDFilteredView::specifics(), HistogramManager_cfi::specs, and AlCaHLTBitMon_QueryRunRegistry::string.

buildSuperChamber() [1/2]

GEMSuperChamber * GEMGeometryBuilderFromDDD::buildSuperChamber ( cms::DDFilteredView &  fv, GEMDetId  detId  ) const

private

Definition at line 433 of file GEMGeometryBuilderFromDDD.cc.

                                                                                                         {
  cms::DDSolid solid(fv.solid());
  auto solidA = solid.solidA();
  std::vector<double> dpar = solidA.dimensions();
 
  double dy = dpar[3];   //length is along local Y
  double dz = dpar[2];   // thickness is long local Z
  double dx1 = dpar[0];  // bottom width is along local X
  double dx2 = dpar[1];  // top width is along loc
 
  auto solidB = solid.solidB();
  dpar = solidB.dimensions();
  const int nch = 2;
  const double chgap = 2.105;
 
  dz += dpar[2];  // chamber thickness
  dz *= nch;      // 2 chambers in superchamber
  dz += chgap;    // gap between chambers
 
  bool isOdd = detId.chamber() % 2;
  RCPBoundPlane surf(boundPlane(fv, new TrapezoidalPlaneBounds(dx1, dx2, dy, dz), isOdd));
 
  GEMSuperChamber* superChamber = new GEMSuperChamber(detId.superChamberId(), surf);
  return superChamber;
}

References GEMDetId::chamber(), PVValHelper::dy, PVValHelper::dz, cms::DDFilteredView::solid(), cms::DDSolid::solidA(), and GEMDetId::superChamberId().

buildSuperChamber() [2/2]

GEMSuperChamber * GEMGeometryBuilderFromDDD::buildSuperChamber ( DDFilteredView &  fv, GEMDetId  detId  ) const

private

Definition at line 196 of file GEMGeometryBuilderFromDDD.cc.

                                                                                                      {
  LogDebug("GEMGeometryBuilderFromDDD") << "buildSuperChamber " << fv.logicalPart().name().name() << " " << detId
                                        << std::endl;
 
  DDBooleanSolid solid = (DDBooleanSolid)(fv.logicalPart().solid());
  bool ge0Station = detId.station() == GEMDetId::minStationId0;
  std::vector<double> dpar = ge0Station ? solid.parameters() : solid.solidA().parameters();
 
  double dy = geant_units::operators::convertMmToCm(dpar[0]);   //length is along local Y
  double dz = geant_units::operators::convertMmToCm(dpar[3]);   // thickness is long local Z
  double dx1 = geant_units::operators::convertMmToCm(dpar[4]);  // bottom width is along local X
  double dx2 = geant_units::operators::convertMmToCm(dpar[8]);  // top width is along local X
 
  if (!ge0Station) {
    const int nch = 2;
    const double chgap = 2.105;
 
    dpar = solid.solidB().parameters();
 
    dz += geant_units::operators::convertMmToCm(dpar[3]);  // chamber thickness
    dz *= nch;                                             // 2 chambers in superchamber
    dz += chgap;                                           // gap between chambers
  }
 
  bool isOdd = detId.chamber() % 2;
  RCPBoundPlane surf(boundPlane(fv, new TrapezoidalPlaneBounds(dx1, dx2, dy, dz), isOdd));
 
  LogDebug("GEMGeometryBuilderFromDDD") << "size " << dx1 << " " << dx2 << " " << dy << " " << dz << std::endl;
 
  GEMSuperChamber* superChamber = new GEMSuperChamber(detId.superChamberId(), surf);
  return superChamber;
}

References GEMDetId::chamber(), geant_units::operators::convertMmToCm(), PVValHelper::dy, PVValHelper::dz, LogDebug, DDFilteredView::logicalPart(), GEMDetId::minStationId0, DDName::name(), DDBase< N, C >::name(), DDSolid::parameters(), DDLogicalPart::solid(), DDBooleanSolid::solidA(), DDBooleanSolid::solidB(), GEMDetId::station(), and GEMDetId::superChamberId().

Member Data Documentation

chids

std::map<GEMDetId, std::vector<GEMDetId> > GEMGeometryBuilderFromDDD::chids

private

Definition at line 46 of file GEMGeometryBuilderFromDDD.h.