Inheritance diagram for CreateIdealTkAlRecords:

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

	~CreateIdealTkAlRecords () override

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

	EDAnalyzer (const EDAnalyzer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

const EDAnalyzer &	operator= (const EDAnalyzer &)=delete

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 const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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 const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

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< PTrackerAdditionalParametersPerDet, PTrackerAdditionalParametersPerDetRcd >	ptitpToken_

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
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

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

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

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<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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

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

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

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

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

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

void	resetItemsToGetFrom (BranchType iType)

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 71 of file CreateTrackerAlignmentRcds.cc.

Constructor & Destructor Documentation

◆ CreateIdealTkAlRecords()

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

explicit

Definition at line 112 of file CreateTrackerAlignmentRcds.cc.

     : geomDetToken_(esConsumes()),
       ptpToken_(esConsumes()),
       ptitpToken_(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 125 of file CreateTrackerAlignmentRcds.cc.

125 {}

Member Function Documentation

◆ addAlignmentInfo()

void CreateIdealTkAlRecords::addAlignmentInfo ( const GeomDet & det )

private

Definition at line 266 of file CreateTrackerAlignmentRcds.cc.

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().

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

◆ alignToGT()

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

private

Definition at line 301 of file CreateTrackerAlignmentRcds.cc.

References AlignmentSurfaceDeformations::add(), aliErrorToken_, alignmentErrors_, alignments_, alignmentSurfaceDeformations_, aliSurfaceToken_, aliToken_, HLT_2022v12_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(), submitPVValidationJobs::params, rawIDs_, skipSubDetectors_, subDets_, and toString().

Referenced by analyze().

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

◆ analyze()

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

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 132 of file CreateTrackerAlignmentRcds.cc.

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

                                                                                  {
   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;
   }
 }

◆ clearAlignmentInfos()

void CreateIdealTkAlRecords::clearAlignmentInfos ( )

private

Definition at line 248 of file CreateTrackerAlignmentRcds.cc.

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

Referenced by analyze().

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

◆ fillDescriptions()

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

static

Definition at line 395 of file CreateTrackerAlignmentRcds.cc.

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

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

◆ retrieveGeometry()

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

private

Definition at line 255 of file CreateTrackerAlignmentRcds.cc.

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

Referenced by analyze().

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

◆ toString()

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

static

Definition at line 151 of file CreateTrackerAlignmentRcds.cc.

Referenced by addAlignmentInfo(), and alignToGT().

                                                                                    {
   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");
   }
 }

◆ toSubDetector()

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

static

Definition at line 196 of file CreateTrackerAlignmentRcds.cc.

Referenced by toSubDetectors().

                                                                                         {
   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;
 }

◆ toSubDetectors()

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

static

Definition at line 239 of file CreateTrackerAlignmentRcds.cc.

References mps_fire::result, and toSubDetector().

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

◆ writeToDB()

void CreateIdealTkAlRecords::writeToDB ( )

private

Definition at line 380 of file CreateTrackerAlignmentRcds.cc.

References alignmentErrors_, alignments_, alignmentSurfaceDeformations_, cond::TimeTypeSpecs::beginValue, Exception, edm::Service< T >::isAvailable(), cond::runnumber, SiStripBadComponentsDQMServiceTemplate_cfg::since, cond::timeTypeSpecs, and cond::service::PoolDBOutputService::writeOneIOV().

Referenced by analyze().

                                        {
   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->writeOneIOV(alignments_, since, "TrackerAlignmentRcd");
   poolDb->writeOneIOV(alignmentErrors_, since, "TrackerAlignmentErrorExtendedRcd");
   poolDb->writeOneIOV(alignmentSurfaceDeformations_, since, "TrackerSurfaceDeformationRcd");
 }