Inheritance diagram for CreateIdealTkAlRecords:

Public Member Functions
	CreateIdealTkAlRecords (const edm::ParameterSet &)

	~CreateIdealTkAlRecords () override

Public Member Functions inherited from edm::one::EDAnalyzer<>
	EDAnalyzer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDAnalyzerBase () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const * > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const > const &labelsToDesc, std::string const &processName) const

EDConsumerBase &	operator= (EDConsumerBase &&)=default

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

static std::string	toString (const GeomDetEnumerators::SubDetector &)

static GeomDetEnumerators::SubDetector	toSubDetector (const std::string &sub)

static std::vector< GeomDetEnumerators::SubDetector >	toSubDetectors (const std::vector< std::string > &subs)

Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
void	addAlignmentInfo (const GeomDet &)

void	alignToGT (const edm::EventSetup &)

void	analyze (const edm::Event &, const edm::EventSetup &) override

void	clearAlignmentInfos ()

std::unique_ptr< TrackerGeometry >	retrieveGeometry (const edm::EventSetup &)

void	writeToDB ()

Private Attributes
const edm::ESGetToken< AlignmentErrorsExtended, TrackerAlignmentErrorExtendedRcd >	aliErrorToken_

AlignmentErrorsExtended	alignmentErrors_

Alignments	alignments_

AlignmentSurfaceDeformations	alignmentSurfaceDeformations_

const bool	alignToGlobalTag_

const edm::ESGetToken< AlignmentSurfaceDeformations, TrackerSurfaceDeformationRcd >	aliSurfaceToken_

const edm::ESGetToken< Alignments, TrackerAlignmentRcd >	aliToken_

const bool	createReferenceRcd_

bool	firstEvent_

const edm::ESGetToken< GeometricDet, IdealGeometryRecord >	geomDetToken_

const edm::ESGetToken< PTrackerParameters, PTrackerParametersRcd >	ptpToken_

std::vector< uint32_t >	rawIDs_

const std::vector< GeomDetEnumerators::SubDetector >	skipSubDetectors_

std::vector< GeomDetEnumerators::SubDetector >	subDets_

const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	topoToken_

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

Description: Plugin to create ideal tracker alignment records.

Implementation: The plugin takes the geometry stored in the global tag and transfers this information to the format needed in the TrackerAlignmentRcd. The APEs are set to zero for all det IDs of the tracker geometry and put into an TrackerAlignmentErrorExtendedRcd. In addition an empty TrackerSurfaceDeformationRcd is created corresponding to ideal surfaces.

An option exists to align to the content of the used global tag. This is useful, if the geometry record and the tracker alignment records do not match.

Definition at line 69 of file CreateTrackerAlignmentRcds.cc.

Constructor & Destructor Documentation

◆ CreateIdealTkAlRecords()

CreateIdealTkAlRecords::CreateIdealTkAlRecords ( const edm::ParameterSet & iConfig )

explicit

Definition at line 109 of file CreateTrackerAlignmentRcds.cc.

     : geomDetToken_(esConsumes()),
       ptpToken_(esConsumes()),
       topoToken_(esConsumes()),
       aliToken_(esConsumes()),
       aliErrorToken_(esConsumes()),
       aliSurfaceToken_(esConsumes()),
       skipSubDetectors_(toSubDetectors(iConfig.getUntrackedParameter<std::vector<std::string> >("skipSubDetectors"))),
       alignToGlobalTag_(iConfig.getUntrackedParameter<bool>("alignToGlobalTag")),
       createReferenceRcd_(iConfig.getUntrackedParameter<bool>("createReferenceRcd")),
       firstEvent_(true) {}

◆ ~CreateIdealTkAlRecords()

CreateIdealTkAlRecords::~CreateIdealTkAlRecords ( )

override

Definition at line 121 of file CreateTrackerAlignmentRcds.cc.

121 {}

Member Function Documentation

◆ addAlignmentInfo()

void CreateIdealTkAlRecords::addAlignmentInfo ( const GeomDet & det )

private

Definition at line 261 of file CreateTrackerAlignmentRcds.cc.

                                                                 {
   const auto subDetector = toString(det.subDetector());
   const auto& detId = det.geographicalId().rawId();
   const auto& pos = det.position();
   const auto& rot = det.rotation();
   rawIDs_.push_back(detId);
   subDets_.push_back(det.subDetector());
  
   // TrackerAlignmentRcd entry
   if (createReferenceRcd_) {
     alignments_.m_align.emplace_back(AlignTransform(AlignTransform::Translation(), AlignTransform::Rotation(), detId));
   } else {
     const AlignTransform::Translation translation(pos.x(), pos.y(), pos.z());
     const AlignTransform::Rotation rotation(
         CLHEP::HepRep3x3(rot.xx(), rot.xy(), rot.xz(), rot.yx(), rot.yy(), rot.yz(), rot.zx(), rot.zy(), rot.zz()));
     const auto& eulerAngles = rotation.eulerAngles();
     LogDebug("Alignment") << "============================================================\n"
                           << "subdetector: " << subDetector << "\n"
                           << "detId:       " << detId << "\n"
                           << "------------------------------------------------------------\n"
                           << "     x: " << pos.x() << "\n"
                           << "     y: " << pos.y() << "\n"
                           << "     z: " << pos.z() << "\n"
                           << "   phi: " << eulerAngles.phi() << "\n"
                           << " theta: " << eulerAngles.theta() << "\n"
                           << "   psi: " << eulerAngles.psi() << "\n"
                           << "============================================================\n";
     alignments_.m_align.emplace_back(AlignTransform(translation, rotation, detId));
   }
  
   // TrackerAlignmentErrorExtendedRcd entry
   const AlignTransformError::SymMatrix zeroAPEs(6, 0);
   alignmentErrors_.m_alignError.emplace_back(AlignTransformErrorExtended(zeroAPEs, detId));
 }

References alignmentErrors_, alignments_, createReferenceRcd_, GeomDet::geographicalId(), LogDebug, Alignments::m_align, AlignmentErrorsExtended::m_alignError, GeomDet::position(), DetId::rawId(), rawIDs_, makeMuonMisalignmentScenario::rot, idealTransformation::rotation, GeomDet::rotation(), GeomDet::subDetector(), subDets_, and toString().

Referenced by analyze().

◆ alignToGT()

void CreateIdealTkAlRecords::alignToGT ( const edm::EventSetup & iSetup )

private

Definition at line 296 of file CreateTrackerAlignmentRcds.cc.

                                                                   {
   LogDebug("Alignment") << "Aligning to global tag\n";
  
   const Alignments* alignments = &iSetup.getData(aliToken_);
   const AlignmentErrorsExtended* alignmentErrors = &iSetup.getData(aliErrorToken_);
   const AlignmentSurfaceDeformations* surfaceDeformations = &iSetup.getData(aliSurfaceToken_);
  
   if (alignments->m_align.size() != alignmentErrors->m_alignError.size())
     throw cms::Exception("GeometryMismatch")
         << "Size mismatch between alignments (size=" << alignments->m_align.size()
         << ") and alignment errors (size=" << alignmentErrors->m_alignError.size() << ")";
  
   std::vector<uint32_t> commonIDs;
   auto itAlignErr = alignmentErrors->m_alignError.cbegin();
   for (auto itAlign = alignments->m_align.cbegin(); itAlign != alignments->m_align.cend(); ++itAlign, ++itAlignErr) {
     const auto id = itAlign->rawId();
     auto found = std::find(rawIDs_.cbegin(), rawIDs_.cend(), id);
     if (found != rawIDs_.cend()) {
       if (id != itAlignErr->rawId())
         throw cms::Exception("GeometryMismatch") << "DetId mismatch between alignments (rawId=" << id
                                                  << ") and alignment errors (rawId=" << itAlignErr->rawId() << ")";
  
       const auto index = std::distance(rawIDs_.cbegin(), found);
       if (std::find(skipSubDetectors_.begin(), skipSubDetectors_.end(), subDets_[index]) != skipSubDetectors_.end())
         continue;
  
       if (alignments_.m_align[index].rawId() != alignmentErrors_.m_alignError[index].rawId())
         throw cms::Exception("GeometryMismatch")
             << "DetId mismatch between alignments (rawId=" << alignments_.m_align[index].rawId()
             << ") and alignment errors (rawId=" << alignmentErrors_.m_alignError[index].rawId() << ")";
  
       LogDebug("Alignment") << "============================================================\n"
                             << "\nGeometry content (" << toString(subDets_[index]) << ", "
                             << alignments_.m_align[index].rawId() << "):\n"
                             << "\tx: " << alignments_.m_align[index].translation().x()
                             << "\ty: " << alignments_.m_align[index].translation().y()
                             << "\tz: " << alignments_.m_align[index].translation().z()
                             << "\tphi: " << alignments_.m_align[index].rotation().phi()
                             << "\ttheta: " << alignments_.m_align[index].rotation().theta()
                             << "\tpsi: " << alignments_.m_align[index].rotation().psi()
                             << "============================================================\n";
       alignments_.m_align[index] = *itAlign;
       alignmentErrors_.m_alignError[index] = *itAlignErr;
       commonIDs.push_back(id);
       LogDebug("Alignment") << "============================================================\n"
                             << "Global tag content (" << toString(subDets_[index]) << ", "
                             << alignments_.m_align[index].rawId() << "):\n"
                             << "\tx: " << alignments_.m_align[index].translation().x()
                             << "\ty: " << alignments_.m_align[index].translation().y()
                             << "\tz: " << alignments_.m_align[index].translation().z()
                             << "\tphi: " << alignments_.m_align[index].rotation().phi()
                             << "\ttheta: " << alignments_.m_align[index].rotation().theta()
                             << "\tpsi: " << alignments_.m_align[index].rotation().psi()
                             << "============================================================\n";
     }
   }
  
   // - surface deformations are stored differently
   //   -> different treatment
   // - the above payloads contain also entries for ideal modules
   // - no entry is created for ideal surfaces
   //   -> size of surface deformation payload does not necessarily match the
   //      size of the other tracker alignment payload
   for (const auto& id : commonIDs) {
     // search for common raw ID in surface deformation items
     auto item = std::find_if(surfaceDeformations->items().cbegin(),
                              surfaceDeformations->items().cend(),
                              [&id](const auto& i) { return i.m_rawId == id; });
     if (item == surfaceDeformations->items().cend())
       continue;  // not found
  
     // copy surface deformation item
     const auto index = std::distance(surfaceDeformations->items().cbegin(), item);
     const auto beginEndPair = surfaceDeformations->parameters(index);
     std::vector<align::Scalar> params(beginEndPair.first, beginEndPair.second);
     alignmentSurfaceDeformations_.add(item->m_rawId, item->m_parametrizationType, params);
   }
 }

References AlignmentSurfaceDeformations::add(), aliErrorToken_, alignmentErrors_, alignments_, alignmentSurfaceDeformations_, aliSurfaceToken_, aliToken_, HLT_FULL_cff::distance, spr::find(), newFWLiteAna::found, edm::EventSetup::getData(), mps_fire::i, triggerObjects_cff::id, B2GTnPMonitor_cfi::item, AlignmentSurfaceDeformations::items(), LogDebug, Alignments::m_align, AlignmentErrorsExtended::m_alignError, AlignmentSurfaceDeformations::parameters(), CalibrationSummaryClient_cfi::params, rawIDs_, skipSubDetectors_, subDets_, and toString().

Referenced by analyze().

◆ analyze()

void CreateIdealTkAlRecords::analyze	(	const edm::Event &	,
		const edm::EventSetup &	iSetup
	)

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 128 of file CreateTrackerAlignmentRcds.cc.

                                                                                  {
   if (firstEvent_) {
     clearAlignmentInfos();
     const auto tracker = retrieveGeometry(iSetup);
  
     auto dets = tracker->dets();
     std::sort(dets.begin(), dets.end(), [](const auto& a, const auto& b) {
       return a->geographicalId().rawId() < b->geographicalId().rawId();
     });
  
     for (const auto& det : dets)
       addAlignmentInfo(*det);
     if (alignToGlobalTag_ && !createReferenceRcd_)
       alignToGT(iSetup);
     writeToDB();
     firstEvent_ = false;
   }
 }

References a, addAlignmentInfo(), alignToGlobalTag_, alignToGT(), b, clearAlignmentInfos(), createReferenceRcd_, firstEvent_, retrieveGeometry(), jetUpdater_cfi::sort, PbPb_ZMuSkimMuonDPG_cff::tracker, and writeToDB().

◆ clearAlignmentInfos()

void CreateIdealTkAlRecords::clearAlignmentInfos ( )

private

Definition at line 244 of file CreateTrackerAlignmentRcds.cc.

                                                  {
   alignments_.clear();
   alignmentErrors_.clear();
   alignmentSurfaceDeformations_ = AlignmentSurfaceDeformations{};
   rawIDs_.clear();
 }

References alignmentErrors_, alignments_, alignmentSurfaceDeformations_, AlignmentErrorsExtended::clear(), Alignments::clear(), and rawIDs_.

Referenced by analyze().

◆ fillDescriptions()

void CreateIdealTkAlRecords::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 390 of file CreateTrackerAlignmentRcds.cc.

                                                                                         {
   edm::ParameterSetDescription desc;
   desc.setComment(
       "Creates ideal TrackerAlignmentRcd and TrackerAlignmentErrorExtendedRcd "
       "from the loaded tracker geometry. "
       "PoolDBOutputService must be set up for these records.");
   desc.addUntracked<bool>("alignToGlobalTag", false);
   desc.addUntracked<std::vector<std::string> >("skipSubDetectors", std::vector<std::string>{});
   desc.addUntracked<bool>("createReferenceRcd", false);
   descriptions.add("createIdealTkAlRecords", desc);
 }

References edm::ConfigurationDescriptions::add(), and submitPVResolutionJobs::desc.

◆ retrieveGeometry()

std::unique_ptr< TrackerGeometry > CreateIdealTkAlRecords::retrieveGeometry ( const edm::EventSetup & iSetup )

private

Definition at line 251 of file CreateTrackerAlignmentRcds.cc.

                                                                                                    {
   const GeometricDet* geometricDet = &iSetup.getData(geomDetToken_);
   const PTrackerParameters& ptp = iSetup.getData(ptpToken_);
   const TrackerTopology* tTopo = &iSetup.getData(topoToken_);
  
   TrackerGeomBuilderFromGeometricDet trackerBuilder;
  
   return std::unique_ptr<TrackerGeometry>{trackerBuilder.build(geometricDet, ptp, tTopo)};
 }

References TrackerGeomBuilderFromGeometricDet::build(), geomDetToken_, edm::EventSetup::getData(), ptpToken_, and topoToken_.

Referenced by analyze().

◆ toString()

std::string CreateIdealTkAlRecords::toString ( const GeomDetEnumerators::SubDetector & sub )

static

Definition at line 147 of file CreateTrackerAlignmentRcds.cc.

                                                                                    {
   switch (sub) {
     case GeomDetEnumerators::PixelBarrel:
       return "PixelBarrel";
     case GeomDetEnumerators::PixelEndcap:
       return "PixelEndcap";
     case GeomDetEnumerators::TIB:
       return "TIB";
     case GeomDetEnumerators::TOB:
       return "TOB";
     case GeomDetEnumerators::TID:
       return "TID";
     case GeomDetEnumerators::TEC:
       return "TEC";
     case GeomDetEnumerators::CSC:
       return "CSC";
     case GeomDetEnumerators::DT:
       return "DT";
     case GeomDetEnumerators::RPCBarrel:
       return "RPCBarrel";
     case GeomDetEnumerators::RPCEndcap:
       return "RPCEndcap";
     case GeomDetEnumerators::GEM:
       return "GEM";
     case GeomDetEnumerators::ME0:
       return "ME0";
     case GeomDetEnumerators::P2OTB:
       return "P2OTB";
     case GeomDetEnumerators::P2OTEC:
       return "P2OTEC";
     case GeomDetEnumerators::P1PXB:
       return "P1PXB";
     case GeomDetEnumerators::P1PXEC:
       return "P1PXEC";
     case GeomDetEnumerators::P2PXB:
       return "P2PXB";
     case GeomDetEnumerators::P2PXEC:
       return "P2PXEC";
     case GeomDetEnumerators::invalidDet:
       return "invalidDet";
     default:
       throw cms::Exception("UnknownSubdetector");
   }
 }

Referenced by addAlignmentInfo(), and alignToGT().

◆ toSubDetector()

GeomDetEnumerators::SubDetector CreateIdealTkAlRecords::toSubDetector ( const std::string & sub )

static

Definition at line 192 of file CreateTrackerAlignmentRcds.cc.

                                                                                         {
   if (sub == "PixelBarrel")
     return GeomDetEnumerators::PixelBarrel;
   else if (sub == "PixelEndcap")
     return GeomDetEnumerators::PixelEndcap;
   else if (sub == "TIB")
     return GeomDetEnumerators::TIB;
   else if (sub == "TOB")
     return GeomDetEnumerators::TOB;
   else if (sub == "TID")
     return GeomDetEnumerators::TID;
   else if (sub == "TEC")
     return GeomDetEnumerators::TEC;
   else if (sub == "CSC")
     return GeomDetEnumerators::CSC;
   else if (sub == "DT")
     return GeomDetEnumerators::DT;
   else if (sub == "RPCBarrel")
     return GeomDetEnumerators::RPCBarrel;
   else if (sub == "RPCEndcap")
     return GeomDetEnumerators::RPCEndcap;
   else if (sub == "GEM")
     return GeomDetEnumerators::GEM;
   else if (sub == "ME0")
     return GeomDetEnumerators::ME0;
   else if (sub == "P2OTB")
     return GeomDetEnumerators::P2OTB;
   else if (sub == "P2OTEC")
     return GeomDetEnumerators::P2OTEC;
   else if (sub == "P1PXB")
     return GeomDetEnumerators::P1PXB;
   else if (sub == "P1PXEC")
     return GeomDetEnumerators::P1PXEC;
   else if (sub == "P2PXB")
     return GeomDetEnumerators::P2PXB;
   else if (sub == "P2PXEC")
     return GeomDetEnumerators::P2PXEC;
   else if (sub == "invalidDet")
     return GeomDetEnumerators::invalidDet;
   else
     throw cms::Exception("UnknownSubdetector") << sub;
 }

Referenced by toSubDetectors().

◆ toSubDetectors()

std::vector< GeomDetEnumerators::SubDetector > CreateIdealTkAlRecords::toSubDetectors ( const std::vector< std::string > & subs )

static

Definition at line 235 of file CreateTrackerAlignmentRcds.cc.

                                       {
   std::vector<GeomDetEnumerators::SubDetector> result;
   result.reserve(subs.size());
   for (const auto& sub : subs)
     result.emplace_back(toSubDetector(sub));
   return result;
 }

References mps_fire::result, and toSubDetector().

◆ writeToDB()

void CreateIdealTkAlRecords::writeToDB ( )

private

Definition at line 375 of file CreateTrackerAlignmentRcds.cc.

                                        {
   const auto& since = cond::timeTypeSpecs[cond::runnumber].beginValue;
  
   edm::Service<cond::service::PoolDBOutputService> poolDb;
   if (!poolDb.isAvailable()) {
     throw cms::Exception("NotAvailable") << "PoolDBOutputService not available";
   }
  
   edm::LogInfo("Alignment") << "Writing ideal tracker-alignment records.";
   poolDb->writeOne(&alignments_, since, "TrackerAlignmentRcd");
   poolDb->writeOne(&alignmentErrors_, since, "TrackerAlignmentErrorExtendedRcd");
   poolDb->writeOne(&alignmentSurfaceDeformations_, since, "TrackerSurfaceDeformationRcd");
 }