GEMGeometryBuilderFromCondDB Class Reference

#include <GEMGeometryBuilderFromCondDB.h>

Public Member Functions
void	build (GEMGeometry &theGeometry, const RecoIdealGeometry &rgeo)
	GEMGeometryBuilderFromCondDB ()
	~GEMGeometryBuilderFromCondDB ()

Private Types
typedef ReferenceCountingPointer< BoundPlane >	RCPBoundPlane

Private Member Functions
RCPBoundPlane	boundPlane (const RecoIdealGeometry &rgeo, unsigned int gid, GEMDetId detId) const
GEMChamber *	buildChamber (const RecoIdealGeometry &rgeo, unsigned int gid, GEMDetId detId) const
GEMEtaPartition *	buildEtaPartition (const RecoIdealGeometry &rgeo, unsigned int gid, GEMDetId detId) const
GEMSuperChamber *	buildSuperChamber (const RecoIdealGeometry &rgeo, unsigned int gid, GEMDetId detId) const

Detailed Description

Build the GEMGeometry from the RecoIdealGeometry description stored in Condition DB

Author

M. Maggi - INFN Bari

Definition at line 14 of file GEMGeometryBuilderFromCondDB.h.

Member Typedef Documentation

RCPBoundPlane

typedef ReferenceCountingPointer<BoundPlane> GEMGeometryBuilderFromCondDB::RCPBoundPlane

private

Definition at line 23 of file GEMGeometryBuilderFromCondDB.h.

Constructor & Destructor Documentation

GEMGeometryBuilderFromCondDB()

GEMGeometryBuilderFromCondDB::GEMGeometryBuilderFromCondDB

(

)

Definition at line 17 of file GEMGeometryBuilderFromCondDB.cc.

{}

~GEMGeometryBuilderFromCondDB()

GEMGeometryBuilderFromCondDB::~GEMGeometryBuilderFromCondDB

(

)

Definition at line 19 of file GEMGeometryBuilderFromCondDB.cc.

{}

Member Function Documentation

boundPlane()

GEMGeometryBuilderFromCondDB::RCPBoundPlane GEMGeometryBuilderFromCondDB::boundPlane ( const RecoIdealGeometry &  rgeo, unsigned int  gid, GEMDetId  detId  ) const

private

Definition at line 187 of file GEMGeometryBuilderFromCondDB.cc.

References cms::cuda::be, angle_units::operators::convertMmToCm(), TkRotation< T >::rotateAxes(), RecoIdealGeometry::rotStart(), RecoIdealGeometry::shapeStart(), and RecoIdealGeometry::tranStart().

                                                                                                           {
  std::vector<double>::const_iterator shapeStart = rgeo.shapeStart(gid);
  float be = convertMmToCm(*(shapeStart + 0));
  float te = convertMmToCm(*(shapeStart + 1));
  float ap = convertMmToCm(*(shapeStart + 2));
  float ti = convertMmToCm(*(shapeStart + 3));
  Bounds* bounds = new TrapezoidalPlaneBounds(be, te, ap, ti);

  std::vector<double>::const_iterator tranStart = rgeo.tranStart(gid);
  Surface::PositionType posResult(
      convertMmToCm(*(tranStart)), convertMmToCm(*(tranStart + 1)), convertMmToCm(*(tranStart + 2)));

  std::vector<double>::const_iterator rotStart = rgeo.rotStart(gid);
  Surface::RotationType rotResult(*(rotStart + 0),
                                  *(rotStart + 1),
                                  *(rotStart + 2),
                                  *(rotStart + 3),
                                  *(rotStart + 4),
                                  *(rotStart + 5),
                                  *(rotStart + 6),
                                  *(rotStart + 7),
                                  *(rotStart + 8));

  //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));
}

build()

void GEMGeometryBuilderFromCondDB::build	(	GEMGeometry &	theGeometry,
		const RecoIdealGeometry &	rgeo
	)

Definition at line 21 of file GEMGeometryBuilderFromCondDB.cc.

References GEMGeometry::add(), relativeConstraints::chamber, GEMDetId::chamber(), GEMDetId::chamberId(), chambers, RecoIdealGeometry::detIds(), triggerObjects_cff::id, GEMDetId::layer(), LogDebug, GEMDetId::maxLayerId, GEMDetId::maxRollId, GEMDetId::maxStationId, Skims_PA_cff::name, DetId::rawId(), HLT_2022v12_cff::region, relativeConstraints::ring, GEMDetId::roll(), Validation_hcalonly_cfi::sign, relativeConstraints::station, AlCaHLTBitMon_QueryRunRegistry::string, GEMDetId::superChamberId(), and cond::impl::to_string().

Referenced by GEMGeometryESModule::produce().

                                                                                                {
  const std::vector<DetId>& detids(rgeo.detIds());
  std::unordered_map<uint32_t, GEMSuperChamber*> superChambers;
  std::unordered_map<uint32_t, GEMChamber*> chambers;
  std::unordered_map<uint32_t, GEMEtaPartition*> partitions;

  for (unsigned int id = 0; id < detids.size(); ++id) {
    GEMDetId gemid(detids[id]);
    LogDebug("GEMGeometryBuilder") << "GEMGeometryBuilder adding " << gemid;
    if (gemid.roll() == 0) {
      if (gemid.layer() == 0) {
        GEMSuperChamber* gsc = buildSuperChamber(rgeo, id, gemid);
        superChambers.emplace(gemid.rawId(), gsc);
      } else {
        GEMChamber* gch = buildChamber(rgeo, id, gemid);
        chambers.emplace(gemid.rawId(), gch);
      }
    } else {
      GEMEtaPartition* gep = buildEtaPartition(rgeo, id, gemid);
      partitions.emplace(gemid.rawId(), gep);
    }
  }

  // TEMP - for backward compatability with old geometry
  // no superchambers or chambers in old geometry, using etpartitions
  if (superChambers.empty()) {
    for (unsigned int id = 0; id < detids.size(); ++id) {
      GEMDetId gemid(detids[id]);
      if (gemid.roll() == 1) {
        GEMChamber* gch = buildChamber(rgeo, id, gemid.chamberId());
        chambers.emplace(gemid.chamberId().rawId(), gch);
        if (gemid.layer() == 1) {
          GEMSuperChamber* gsc = buildSuperChamber(rgeo, id, gemid.superChamberId());
          superChambers.emplace(gemid.superChamberId().rawId(), gsc);
        }
      }
    }
  }

  // construct the regions, stations and rings.
  for (int re = -1; re <= 1; re = re + 2) {
    GEMRegion* region = new GEMRegion(re);

    for (int st = 0; 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 sch : superChambers) {
          auto superChamber = sch.second;
          const GEMDetId scId(superChamber->id());
          if (scId.region() != re || scId.station() != st || scId.ring() != ri)
            continue;
          int ch = scId.chamber();

          for (int ly = 1; ly <= GEMDetId::maxLayerId; ++ly) {
            const GEMDetId chId(re, ri, st, ly, ch, 0);
            auto chamberIt = chambers.find(chId.rawId());
            if (chamberIt == chambers.end())
              continue;
            auto chamber = chamberIt->second;

            for (int roll = 1; roll <= GEMDetId::maxRollId; ++roll) {
              const GEMDetId rollId(re, ri, st, ly, ch, roll);
              auto gepIt = partitions.find(rollId.rawId());
              if (gepIt == partitions.end())
                continue;
              auto gep = gepIt->second;

              chamber->add(gep);
              theGeometry.add(gep);
            }

            superChamber->add(chamber);
            theGeometry.add(chamber);
          }

          LogDebug("GEMGeometryBuilder") << "Adding super chamber " << scId << " to ring:";
          ring->add(superChamber);
          theGeometry.add(superChamber);
        }  // end superChambers

        if (ring->nSuperChambers()) {
          LogDebug("GEMGeometryBuilder") << "Adding ring " << ri << " to station "
                                         << "re " << re << " st " << st;
          station->add(ring);
          theGeometry.add(ring);
        } else {
          delete ring;
        }
      }  // end ring

      if (station->nRings()) {
        LogDebug("GEMGeometryBuilder") << "Adding station " << st << " to region " << re;
        region->add(station);
        theGeometry.add(station);
      } else {
        delete station;
      }
    }  // end station

    LogDebug("GEMGeometryBuilder") << "Adding region " << re << " to the geometry";
    theGeometry.add(region);
  }
}

buildChamber()

GEMChamber * GEMGeometryBuilderFromCondDB::buildChamber ( const RecoIdealGeometry &  rgeo, unsigned int  gid, GEMDetId  detId  ) const

private

Definition at line 144 of file GEMGeometryBuilderFromCondDB.cc.

References relativeConstraints::chamber, and LogDebug.

                                                                             {
  LogDebug("GEMGeometryBuilderFromCondDB") << "buildChamber " << detId;

  RCPBoundPlane surf(boundPlane(rgeo, gid, detId));

  GEMChamber* chamber = new GEMChamber(detId, surf);
  return chamber;
}

buildEtaPartition()

GEMEtaPartition * GEMGeometryBuilderFromCondDB::buildEtaPartition ( const RecoIdealGeometry &  rgeo, unsigned int  gid, GEMDetId  detId  ) const

private

Definition at line 155 of file GEMGeometryBuilderFromCondDB.cc.

References cms::cuda::be, angle_units::operators::convertMmToCm(), GeomDetEnumerators::GEM, LogDebug, Skims_PA_cff::name, gen::npad, RecoIdealGeometry::shapeEnd(), RecoIdealGeometry::shapeStart(), AlCaHLTBitMon_QueryRunRegistry::string, and RecoIdealGeometry::strStart().

                                                                                       {
  std::vector<std::string>::const_iterator strStart = rgeo.strStart(gid);
  std::string name = *(strStart);
  LogDebug("GEMGeometryBuilderFromCondDB") << "buildEtaPartition " << name << " " << detId;

  std::vector<double>::const_iterator shapeStart = rgeo.shapeStart(gid);
  float be = convertMmToCm(*(shapeStart + 0));
  float te = convertMmToCm(*(shapeStart + 1));
  float ap = convertMmToCm(*(shapeStart + 2));
  float ti = convertMmToCm(*(shapeStart + 3));
  float nstrip = *(shapeStart + 4);
  float npad = *(shapeStart + 5);
  float dphi = (shapeStart + 6 < rgeo.shapeEnd(gid)) ? *(shapeStart + 6) : 0.17715;

  std::vector<float> pars;
  pars.emplace_back(be);
  pars.emplace_back(te);
  pars.emplace_back(ap);
  pars.emplace_back(nstrip);
  pars.emplace_back(npad);
  pars.emplace_back(dphi);

  RCPBoundPlane surf(boundPlane(rgeo, gid, detId));
  GEMEtaPartitionSpecs* e_p_specs = new GEMEtaPartitionSpecs(GeomDetEnumerators::GEM, name, pars);

  LogDebug("GEMGeometryBuilderFromCondDB") << "size " << be << " " << te << " " << ap << " " << ti;
  GEMEtaPartition* etaPartition = new GEMEtaPartition(detId, surf, e_p_specs);
  return etaPartition;
}

buildSuperChamber()

GEMSuperChamber * GEMGeometryBuilderFromCondDB::buildSuperChamber ( const RecoIdealGeometry &  rgeo, unsigned int  gid, GEMDetId  detId  ) const

private

Definition at line 133 of file GEMGeometryBuilderFromCondDB.cc.

References LogDebug.

                                                                                       {
  LogDebug("GEMGeometryBuilderFromCondDB") << "buildSuperChamber " << detId;

  RCPBoundPlane surf(boundPlane(rgeo, gid, detId));

  GEMSuperChamber* superChamber = new GEMSuperChamber(detId, surf);
  return superChamber;
}