#include <TrackerGeomBuilderFromGeometricDet.h>

Public Member Functions
TrackerGeometry *	build (const GeometricDet gd, const PTrackerAdditionalParametersPerDet ptitp, const PTrackerParameters &ptp, const TrackerTopology *tTopo)

Private Member Functions
void	buildGeomDet (TrackerGeometry *)

void	buildPixel (std::vector< const GeometricDet > const &, const PTrackerAdditionalParametersPerDet const &, TrackerGeometry *, GeomDetType::SubDetector det, int BIG_PIX_PER_ROC_X, int BIG_PIX_PER_ROC_Y)

void	buildPixelPhase2 (std::vector< const GeometricDet > const &, const PTrackerAdditionalParametersPerDet const &, TrackerGeometry *, GeomDetType::SubDetector det)

PlaneBuilderFromGeometricDet::ResultType	buildPlaneWithMaterial (const GeometricDet *gd, double scaleFactor=1.) const

void	buildSilicon (std::vector< const GeometricDet > const &, TrackerGeometry , GeomDetType::SubDetector det, const std::string &part)

Private Attributes
std::map< std::string, const PixelGeomDetType * >	thePixelDetTypeMap

std::map< std::string, const StripGeomDetType * >	theStripDetTypeMap

const TrackerTopology *	theTopo

Detailed Description

Definition at line 18 of file TrackerGeomBuilderFromGeometricDet.h.

Member Function Documentation

◆ build()

TrackerGeometry * TrackerGeomBuilderFromGeometricDet::build	(	const GeometricDet *	gd,
		const PTrackerAdditionalParametersPerDet *	ptitp,
		const PTrackerParameters &	ptp,
		const TrackerTopology *	tTopo
	)

Definition at line 45 of file TrackerGeomBuilderFromGeometricDet.cc.

Referenced by SurveyInputTrackerFromDB::analyze(), SurveyMisalignmentInput::analyze(), CreateSurveyRcds::analyze(), TrackerSystematicMisalignments::analyze(), TrackerTreeGenerator::analyze(), AlignmentMonitorAsAnalyzer::analyze(), MCMisalignmentScaler::analyze(), TrackerGeometryIntoNtuples::analyze(), MillePedeDQMModule::beginRun(), AlignmentProducerBase::createGeometries(), TrackerGeometryCompare::createROOTGeometry(), TrackerDigiGeometryESModule::produce(), MisalignedTrackerESProducer::produce(), LaserAlignment::produce(), and CreateIdealTkAlRecords::retrieveGeometry().

                                                                                          {
   if (ptp.vpars.size() != 6) {
     throw cms::Exception("TrackerGeomBuilderFromGeometricDet")
         << "Tracker parameters block from XMLs called vPars is expected to have 6 entries, but has " << ptp.vpars.size()
         << " entrie(s).";
   }
 
   // phase-0, phase-1; BIG_PIX_PER_ROC from trackerParameters.xml
   // phase-2: BIG_PIX_PER_ROC from pixelStructureTopology.xml (redefined later in buildPixel() )
   const int BIG_PIX_PER_ROC_X = ptp.vpars[2];
   const int BIG_PIX_PER_ROC_Y = ptp.vpars[3];
 
   thePixelDetTypeMap.clear();
   theStripDetTypeMap.clear();
 
   TrackerGeometry* tracker = new TrackerGeometry(gd);
   std::vector<const GeometricDet*> comp;
   gd->deepComponents(comp);
 
   if (tTopo)
     theTopo = tTopo;
 
   //define a vector which associate to the detid subdetector index -1 (from 0 to 5) the GeometridDet enumerator to be able to know which type of subdetector it is
 
   std::vector<GeometricDet::GDEnumType> gdsubdetmap(
       6, GeometricDet::unknown);  // hardcoded "6" should not be a surprise...
   GeometricDet::ConstGeometricDetContainer subdetgd = gd->components();
 
   LogDebug("SubDetectorGeometricDetType") << "GeometriDet enumerator values of the subdetectors";
   for (unsigned int i = 0; i < subdetgd.size(); ++i) {
     assert(subdetgd[i]->geographicalId().subdetId() > 0 && subdetgd[i]->geographicalId().subdetId() < 7);
     gdsubdetmap[subdetgd[i]->geographicalId().subdetId() - 1] = subdetgd[i]->type();
     LogTrace("SubDetectorGeometricDetType")
         << "subdet " << i << " type " << subdetgd[i]->type() << " detid " << subdetgd[i]->geographicalId().rawId()
         << " subdetid " << subdetgd[i]->geographicalId().subdetId();
   }
 
   std::vector<const GeometricDet*> dets[6];
   std::vector<const GeometricDet*>& pixB = dets[0];
   pixB.reserve(comp.size());
   std::vector<const GeometricDet*>& pixF = dets[1];
   pixF.reserve(comp.size());
   std::vector<const GeometricDet*>& tib = dets[2];
   tib.reserve(comp.size());
   std::vector<const GeometricDet*>& tid = dets[3];
   tid.reserve(comp.size());
   std::vector<const GeometricDet*>& tob = dets[4];
   tob.reserve(comp.size());
   std::vector<const GeometricDet*>& tec = dets[5];
   tec.reserve(comp.size());
 
   for (auto& i : comp)
     dets[i->geographicalId().subdetId() - 1].emplace_back(i);
 
   //loop on all the six elements of dets and firstly check if they are from pixel-like detector and call buildPixel, then loop again and check if they are strip and call buildSilicon. "unknown" can be filled either way but the vector of GeometricDet must be empty !!
   // this order is VERY IMPORTANT!!!!! For the moment I (AndreaV) understand that some pieces of code rely on pixel-like being before strip-like
 
   // now building the Pixel-like subdetectors
   for (unsigned int i = 0; i < 6; ++i) {
     if (gdsubdetmap[i] == GeometricDet::PixelBarrel)
       buildPixel(
           dets[i], ptitpx, tracker, GeomDetEnumerators::SubDetector::PixelBarrel, BIG_PIX_PER_ROC_X, BIG_PIX_PER_ROC_Y);
     if (gdsubdetmap[i] == GeometricDet::PixelPhase1Barrel)
       buildPixel(
           dets[i], ptitpx, tracker, GeomDetEnumerators::SubDetector::P1PXB, BIG_PIX_PER_ROC_X, BIG_PIX_PER_ROC_Y);
     if (gdsubdetmap[i] == GeometricDet::PixelEndCap)
       buildPixel(
           dets[i], ptitpx, tracker, GeomDetEnumerators::SubDetector::PixelEndcap, BIG_PIX_PER_ROC_X, BIG_PIX_PER_ROC_Y);
     if (gdsubdetmap[i] == GeometricDet::PixelPhase1EndCap)
       buildPixel(
           dets[i], ptitpx, tracker, GeomDetEnumerators::SubDetector::P1PXEC, BIG_PIX_PER_ROC_X, BIG_PIX_PER_ROC_Y);
     // Phase2 case
     if (gdsubdetmap[i] == GeometricDet::PixelPhase2Barrel)
       buildPixelPhase2(dets[i], ptitpx, tracker, GeomDetEnumerators::SubDetector::P2PXB);
     if (gdsubdetmap[i] == GeometricDet::PixelPhase2EndCap)
       buildPixelPhase2(dets[i], ptitpx, tracker, GeomDetEnumerators::SubDetector::P2PXEC);
     if (gdsubdetmap[i] == GeometricDet::OTPhase2Barrel)
       buildPixelPhase2(dets[i], ptitpx, tracker, GeomDetEnumerators::SubDetector::P2OTB);
     if (gdsubdetmap[i] == GeometricDet::OTPhase2EndCap)
       buildPixelPhase2(dets[i], ptitpx, tracker, GeomDetEnumerators::SubDetector::P2OTEC);
   }
   //now building Strips
   for (unsigned int i = 0; i < 6; ++i) {
     if (gdsubdetmap[i] == GeometricDet::TIB)
       buildSilicon(dets[i], tracker, GeomDetEnumerators::SubDetector::TIB, "barrel");
     if (gdsubdetmap[i] == GeometricDet::TID)
       buildSilicon(dets[i], tracker, GeomDetEnumerators::SubDetector::TID, "endcap");
     if (gdsubdetmap[i] == GeometricDet::TOB)
       buildSilicon(dets[i], tracker, GeomDetEnumerators::SubDetector::TOB, "barrel");
     if (gdsubdetmap[i] == GeometricDet::TEC)
       buildSilicon(dets[i], tracker, GeomDetEnumerators::SubDetector::TEC, "endcap");
   }
   // and finally the "empty" subdetectors (maybe it is not needed)
   for (unsigned int i = 0; i < 6; ++i) {
     if (gdsubdetmap[i] == GeometricDet::unknown) {
       if (!dets[i].empty())
         throw cms::Exception("NotEmptyUnknownSubDet")
             << "Subdetector " << i + 1 << " is unknown but it is not empty: " << dets[i].size();
       buildSilicon(
           dets[i], tracker, GeomDetEnumerators::tkDetEnum[i + 1], "barrel");  // "barrel" is used but it is irrelevant
     }
   }
   buildGeomDet(tracker);  //"GeomDet"
 
   verifyDUinTG(*tracker);
 
   return tracker;
 }

◆ buildGeomDet()

void TrackerGeomBuilderFromGeometricDet::buildGeomDet ( TrackerGeometry * tracker )

private

Definition at line 268 of file TrackerGeomBuilderFromGeometricDet.cc.

References TrackerTopology::doubleSensor(), Exception, TrackerTopology::glued(), mps_fire::i, findQualityFiles::jj, TrackerTopology::partnerDetId(), PlaneBuilderForGluedDet::plane(), TrackerTopology::stack(), GeomDet::surface(), theTopo, and PbPb_ZMuSkimMuonDPG_cff::tracker.

Referenced by build().

                                                                               {
   PlaneBuilderForGluedDet gluedplaneBuilder;
   auto const& gdu = tracker->detUnits();
   auto const& gduId = tracker->detUnitIds();
 
   for (u_int32_t i = 0; i < gdu.size(); i++) {
     tracker->addDet(gdu[i]);
     tracker->addDetId(gduId[i]);
     string gduTypeName = gdu[i]->type().name();
 
     //this step is time consuming >> TO FIX with a MAP?
     if ((gduTypeName.find("Ster") != std::string::npos || gduTypeName.find("Lower") != std::string::npos ||
          gduTypeName.find("One") != std::string::npos) &&
         (theTopo->glued(gduId[i]) != 0 || theTopo->stack(gduId[i]) != 0 || theTopo->doubleSensor(gduId[i]))) {
       int partner_pos = -1;
       for (u_int32_t jj = 0; jj < gduId.size(); jj++) {
         if (theTopo->partnerDetId(gduId[i]) == gduId[jj]) {
           partner_pos = jj;
           break;
         }
       }
       if (partner_pos == -1) {
         throw cms::Exception("Configuration") << "Module Type is Stereo or Lower but no partner detector found \n"
                                               << "There is a problem on Tracker geometry configuration\n";
       }
 
       const GeomDetUnit* dus = gdu[i];
       const GeomDetUnit* dum = gdu[partner_pos];
       std::vector<const GeomDetUnit*> composed(2);
       composed[0] = dum;
       composed[1] = dus;
       DetId composedDetId;
       if (gduTypeName.find("Ster") != std::string::npos) {
         PlaneBuilderForGluedDet::ResultType plane = gluedplaneBuilder.plane(composed);
         composedDetId = theTopo->glued(gduId[i]);
         GluedGeomDet* gluedDet = new GluedGeomDet(&(*plane), dum, dus, composedDetId);
         tracker->addDet((GeomDet*)gluedDet);
         tracker->addDetId(composedDetId);
 
       } else if (gduTypeName.find("Lower") != std::string::npos) {
         //The plane is *not* built in the middle, but on the Lower surface
         Plane* plane = new Plane(dus->surface());
         composedDetId = theTopo->stack(gduId[i]);
         StackGeomDet* stackDet = new StackGeomDet(&(*plane), dus, dum, composedDetId);
         tracker->addDet((GeomDet*)stackDet);
         tracker->addDetId(composedDetId);
       }
     }
   }
 }

◆ buildPixel()

void TrackerGeomBuilderFromGeometricDet::buildPixel	(	std::vector< const GeometricDet *> const &	gdv,
		const PTrackerAdditionalParametersPerDet *const &	ptitp,
		TrackerGeometry *	tracker,
		GeomDetType::SubDetector	det,
		int	BIG_PIX_PER_ROC_X,
		int	BIG_PIX_PER_ROC_Y
	)

private

Definition at line 157 of file TrackerGeomBuilderFromGeometricDet.cc.

References PixelTopologyBuilder::build(), buildPlaneWithMaterial(), mps_fire::i, createfilelist::int, LogDebug, AlCaHLTBitMon_QueryRunRegistry::string, GeomDetEnumerators::subDetGeom, submitPVValidationJobs::t, groupFilesInBlocks::temp, thePixelDetTypeMap, and PbPb_ZMuSkimMuonDPG_cff::tracker.

Referenced by build().

 {
   LogDebug("BuildingGeomDetUnits") << " Pixel type. Size of vector: " << gdv.size()
                                    << " GeomDetType subdetector: " << det
                                    << " logical subdetector: " << GeomDetEnumerators::subDetGeom[det]
                                    << " big pix per ROC x: " << BIG_PIX_PER_ROC_X << " y: " << BIG_PIX_PER_ROC_Y;
 
   tracker->setOffsetDU(GeomDetEnumerators::subDetGeom[det]);
 
   for (auto const& i : gdv) {
     std::string const& detName = i->name();
     if (thePixelDetTypeMap.find(detName) == thePixelDetTypeMap.end()) {
       std::unique_ptr<const Bounds> bounds(i->bounds());
       PixelTopology* t = PixelTopologyBuilder().build(bounds.get(),
                                                       (int)i->pixROCRows(),
                                                       (int)i->pixROCCols(),
                                                       BIG_PIX_PER_ROC_X,
                                                       BIG_PIX_PER_ROC_Y,
                                                       (int)i->pixROCx(),
                                                       (int)i->pixROCy());
 
       thePixelDetTypeMap[detName] = new PixelGeomDetType(t, detName, det);
       tracker->addType(thePixelDetTypeMap[detName]);
     }
 
     PlaneBuilderFromGeometricDet::ResultType plane = buildPlaneWithMaterial(i);
     GeomDetUnit* temp = new PixelGeomDetUnit(&(*plane), thePixelDetTypeMap[detName], i->geographicalId());
 
     tracker->addDetUnit(temp);
     tracker->addDetUnitId(i->geographicalId());
   }
   tracker->setEndsetDU(GeomDetEnumerators::subDetGeom[det]);
 }

◆ buildPixelPhase2()

void TrackerGeomBuilderFromGeometricDet::buildPixelPhase2	(	std::vector< const GeometricDet *> const &	gdv,
		const PTrackerAdditionalParametersPerDet *const &	ptitp,
		TrackerGeometry *	tracker,
		GeomDetType::SubDetector	det
	)

private

Definition at line 196 of file TrackerGeomBuilderFromGeometricDet.cc.

References PixelPhase2TopologyBuilder::build(), buildPlaneWithMaterial(), mps_fire::i, createfilelist::int, LogDebug, AlCaHLTBitMon_QueryRunRegistry::string, GeomDetEnumerators::subDetGeom, submitPVValidationJobs::t, groupFilesInBlocks::temp, thePixelDetTypeMap, and PbPb_ZMuSkimMuonDPG_cff::tracker.

Referenced by build().

                                                                                       {
   LogDebug("BuildingGeomDetUnits") << " Phase2 Pixel type. Size of vector: " << gdv.size()
                                    << " GeomDetType subdetector: " << det
                                    << " logical subdetector: " << GeomDetEnumerators::subDetGeom[det];
 
   tracker->setOffsetDU(GeomDetEnumerators::subDetGeom[det]);
 
   for (auto const& i : gdv) {
     std::string const& detName = i->name();
     if (thePixelDetTypeMap.find(detName) == thePixelDetTypeMap.end()) {
       std::unique_ptr<const Bounds> bounds(i->bounds());
       int BIG_PIX_PER_ROC_X = i->bigPixelsx();       // in x direction, rows
       int BIG_PIX_PER_ROC_Y = i->bigPixelsy();       // in y direction, cols
       float BIG_PIX_PITCH_X = i->bigPixelsPitchx();  // in x direction, rows
       float BIG_PIX_PITCH_Y = i->bigPixelsPitchy();  // in y direction, cols
       PixelTopology* t = PixelPhase2TopologyBuilder().build(bounds.get(),
                                                             (int)i->pixROCRows(),
                                                             (int)i->pixROCCols(),
                                                             BIG_PIX_PER_ROC_X,
                                                             BIG_PIX_PER_ROC_Y,
                                                             BIG_PIX_PITCH_X,
                                                             BIG_PIX_PITCH_Y,
                                                             (int)i->pixROCx(),
                                                             (int)i->pixROCy());
 
       thePixelDetTypeMap[detName] = new PixelGeomDetType(t, detName, det);
       tracker->addType(thePixelDetTypeMap[detName]);
     }
 
     PlaneBuilderFromGeometricDet::ResultType plane = buildPlaneWithMaterial(i);
     GeomDetUnit* temp = new PixelGeomDetUnit(&(*plane), thePixelDetTypeMap[detName], i->geographicalId());
 
     tracker->addDetUnit(temp);
     tracker->addDetUnitId(i->geographicalId());
   }
   tracker->setEndsetDU(GeomDetEnumerators::subDetGeom[det]);
 }

◆ buildPlaneWithMaterial()

PlaneBuilderFromGeometricDet::ResultType TrackerGeomBuilderFromGeometricDet::buildPlaneWithMaterial	(	const GeometricDet *	gd,
		double	scaleFactor = `1.`
	)		const

private

Definition at line 319 of file TrackerGeomBuilderFromGeometricDet.cc.

References PlaneBuilderFromGeometricDet::plane(), GeometricDet::radLength(), l1tEGammaCrystalsEmulatorProducer_cfi::scale, and GeometricDet::xi().

Referenced by buildPixel(), buildPixelPhase2(), and buildSilicon().

                                                 {
   PlaneBuilderFromGeometricDet planeBuilder;
   PlaneBuilderFromGeometricDet::ResultType plane = planeBuilder.plane(gd);
   //
   // set medium properties (if defined)
   //
   plane->setMediumProperties(MediumProperties(gd->radLength() * scale, gd->xi() * scale));
 
   return plane;
 }

◆ buildSilicon()

void TrackerGeomBuilderFromGeometricDet::buildSilicon	(	std::vector< const GeometricDet *> const &	gdv,
		TrackerGeometry *	tracker,
		GeomDetType::SubDetector	det,
		const std::string &	part
	)

private

Definition at line 237 of file TrackerGeomBuilderFromGeometricDet.cc.

References StripTopologyBuilder::build(), buildPlaneWithMaterial(), mps_fire::i, LogDebug, TrackerTopology::partnerDetId(), l1tEGammaCrystalsEmulatorProducer_cfi::scale, AlCaHLTBitMon_QueryRunRegistry::string, GeomDetEnumerators::subDetGeom, submitPVValidationJobs::t, groupFilesInBlocks::temp, theStripDetTypeMap, theTopo, and PbPb_ZMuSkimMuonDPG_cff::tracker.

Referenced by build().

                                                                              {
   LogDebug("BuildingGeomDetUnits") << " Strip type. Size of vector: " << gdv.size()
                                    << " GeomDetType subdetector: " << det
                                    << " logical subdetector: " << GeomDetEnumerators::subDetGeom[det] << " part "
                                    << part;
 
   tracker->setOffsetDU(GeomDetEnumerators::subDetGeom[det]);
 
   for (auto const& i : gdv) {
     std::string const& detName = i->name();
     if (theStripDetTypeMap.find(detName) == theStripDetTypeMap.end()) {
       std::unique_ptr<const Bounds> bounds(i->bounds());
       StripTopology* t = StripTopologyBuilder().build(bounds.get(), i->siliconAPVNum(), part);
       theStripDetTypeMap[detName] = new StripGeomDetType(t, detName, det, i->stereo());
       tracker->addType(theStripDetTypeMap[detName]);
     }
 
     double scale = (theTopo->partnerDetId(i->geographicalId())) ? 0.5 : 1.0;
 
     PlaneBuilderFromGeometricDet::ResultType plane = buildPlaneWithMaterial(i, scale);
     GeomDetUnit* temp = new StripGeomDetUnit(&(*plane), theStripDetTypeMap[detName], i->geographicalId());
 
     tracker->addDetUnit(temp);
     tracker->addDetUnitId(i->geographicalId());
   }
   tracker->setEndsetDU(GeomDetEnumerators::subDetGeom[det]);
 }