Inheritance diagram for CreateIdealTkAlRecords:

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

	~CreateIdealTkAlRecords ()

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

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDAnalyzerBase ()

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

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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 &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, 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	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

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 &)

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

void	clearAlignmentInfos ()

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

void	writeToDB ()

Private Attributes
AlignmentErrorsExtended	alignmentErrors_

Alignments	alignments_

AlignmentSurfaceDeformations	alignmentSurfaceDeformations_

const bool	alignToGlobalTag_

const bool	createReferenceRcd_

bool	firstEvent_

std::vector< uint32_t >	rawIDs_

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

std::vector < GeomDetEnumerators::SubDetector >	subDets_

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)

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

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

Constructor & Destructor Documentation

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

explicit

Definition at line 105 of file CreateTrackerAlignmentRcds.cc.

                                                                              :
   skipSubDetectors_(toSubDetectors(iConfig.getUntrackedParameter<std::vector<std::string> >("skipSubDetectors"))),
   alignToGlobalTag_(iConfig.getUntrackedParameter<bool>("alignToGlobalTag")),
   createReferenceRcd_(iConfig.getUntrackedParameter<bool>("createReferenceRcd")),
   firstEvent_(true)
 {
 }

CreateIdealTkAlRecords::~CreateIdealTkAlRecords ( )

Definition at line 114 of file CreateTrackerAlignmentRcds.cc.

115 {

116 }

Member Function Documentation

void CreateIdealTkAlRecords::addAlignmentInfo ( const GeomDet & det )

private

Definition at line 237 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));
 }

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

private

Definition at line 280 of file CreateTrackerAlignmentRcds.cc.

References AlignmentSurfaceDeformations::add(), alignmentErrors_, alignments_, alignmentSurfaceDeformations_, HLT_25ns10e33_v2_cff::distance, spr::find(), newFWLiteAna::found, edm::EventSetup::get(), i, cmsHarvester::index, LogDebug, Alignments::m_align, AlignmentErrorsExtended::m_alignError, rawIDs_, skipSubDetectors_, subDets_, and toString().

Referenced by analyze().

 {
   LogDebug("Alignment") << "Aligning to global tag\n";
 
   edm::ESHandle<Alignments> alignments;
   iSetup.get<TrackerAlignmentRcd>().get(alignments);
   edm::ESHandle<AlignmentErrorsExtended> alignmentErrors;
   iSetup.get<TrackerAlignmentErrorExtendedRcd>().get(alignmentErrors);
   edm::ESHandle<AlignmentSurfaceDeformations> surfaceDeformations;
   iSetup.get<TrackerSurfaceDeformationRcd>().get(surfaceDeformations);
 
   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);
   }
 }

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

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 125 of file CreateTrackerAlignmentRcds.cc.

References a, addAlignmentInfo(), alignToGlobalTag_, alignToGT(), b, clearAlignmentInfos(), createReferenceRcd_, firstEvent_, retrieveGeometry(), patCandidatesForDimuonsSequences_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;
   }
 }

void CreateIdealTkAlRecords::clearAlignmentInfos ( )

private

Definition at line 207 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();
 }

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

static

Definition at line 395 of file CreateTrackerAlignmentRcds.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::addUntracked(), and edm::ParameterSetDescription::setComment().

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

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

private

Definition at line 217 of file CreateTrackerAlignmentRcds.cc.

References TrackerGeomBuilderFromGeometricDet::build(), edm::EventSetup::get(), and edm::ESHandle< class >::product().

Referenced by analyze().

 {
   edm::ESHandle<GeometricDet> geometricDet;
   iSetup.get<IdealGeometryRecord>().get(geometricDet);
 
   edm::ESHandle<PTrackerParameters> ptp;
   iSetup.get<PTrackerParametersRcd>().get(ptp);
 
   edm::ESHandle<TrackerTopology> tTopoHandle;
   iSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
   const auto* const tTopo = tTopoHandle.product();
 
   TrackerGeomBuilderFromGeometricDet trackerBuilder;
 
   return std::unique_ptr<TrackerGeometry> {
     trackerBuilder.build(&(*geometricDet), *ptp, tTopo )};
 }

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

static

Definition at line 145 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::P2PXEC:      return "P2PXEC";
   case GeomDetEnumerators::invalidDet:  return "invalidDet";
   default:
     throw cms::Exception("UnknownSubdetector");
   }
 }

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

static

Definition at line 173 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 == "P2PXEC")      return GeomDetEnumerators::P2PXEC;
   else if (sub == "invalidDet")  return GeomDetEnumerators::invalidDet;
   else throw cms::Exception("UnknownSubdetector") << sub;
 }

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

static

Definition at line 198 of file CreateTrackerAlignmentRcds.cc.

References mps_fire::result, and toSubDetector().

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

void CreateIdealTkAlRecords::writeToDB ( )

private

Definition at line 376 of file CreateTrackerAlignmentRcds.cc.

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

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