#include <Alignment/TrackerAlignment/plugins/MCMisalignmentScaler.cc>

Inheritance diagram for MCMisalignmentScaler:

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

	~MCMisalignmentScaler () override=default

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

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () 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

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

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

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 Types
using	ScalerMap = std::unordered_map< unsigned int, std::unordered_map< int, double > >

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

ScalerMap	decodeSubDetectors (const edm::VParameterSet &)

Private Attributes
bool	firstEvent_ {true}

const double	outlierPullToIdealCut_

const bool	pullBadModulesToIdeal_

const ScalerMap	scalers_

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

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

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 rescale misalignment wrt. ideal geometry

Implementation:

The plugin takes the ideal geometry and the alignment object and rescales the position difference by the scaling factor provided by the user.

Definition at line 60 of file MCMisalignmentScaler.cc.

Member Typedef Documentation

using MCMisalignmentScaler::ScalerMap = std::unordered_map<unsigned int, std::unordered_map<int, double> >

private

Definition at line 68 of file MCMisalignmentScaler.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 83 of file MCMisalignmentScaler.cc.

References decodeSubDetectors(), edm::ParameterSet::getParameter(), outlierPullToIdealCut_, and pullBadModulesToIdeal_.

     : scalers_{decodeSubDetectors(iConfig.getParameter<edm::VParameterSet>("scalers"))},
       pullBadModulesToIdeal_{iConfig.getUntrackedParameter<bool>("pullBadModulesToIdeal")},
       outlierPullToIdealCut_{iConfig.getUntrackedParameter<double>("outlierPullToIdealCut")} {}

MCMisalignmentScaler::~MCMisalignmentScaler ( )

overridedefault

Member Function Documentation

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

overrideprivate

Definition at line 93 of file MCMisalignmentScaler.cc.

References a, b, cond::TimeTypeSpecs::beginValue, TrackerGeomBuilderFromGeometricDet::build(), Exception, firstEvent_, edm::EventSetup::get(), edm::Service< T >::isAvailable(), SiStripQuality::IsModuleBad(), SiPixelQuality::IsModuleBad(), Alignments::m_align, eostools::move(), outlierPullToIdealCut_, PixelSubdetector::PixelBarrel, edm::ESHandle< T >::product(), pullBadModulesToIdeal_, AlignTransform::rawId(), cond::runnumber, multiplicitycorr_cfi::scaleFactor, scalers_, writeEcalDQMStatus::since, GeomDetEnumerators::subDetId, StripSubdetector::TIB, cond::timeTypeSpecs, StripSubdetector::TOB, ecaldqm::topology(), PbPb_ZMuSkimMuonDPG_cff::tracker, and cond::service::PoolDBOutputService::writeOne().

                                                                                {
   if (!firstEvent_)
     return;
   firstEvent_ = false;
 
   // get handle on bad modules
   edm::ESHandle<SiPixelQuality> pixelModules;
   iSetup.get<SiPixelQualityRcd>().get(pixelModules);
   edm::ESHandle<SiStripQuality> stripModules;
   iSetup.get<SiStripQualityRcd>().get(stripModules);
 
   // get the tracker geometry
   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 topology = tTopoHandle.product();
   TrackerGeomBuilderFromGeometricDet trackerBuilder;
   auto tracker = std::unique_ptr<TrackerGeometry>{trackerBuilder.build(&(*geometricDet), *ptp, topology)};
 
   auto dets = tracker->dets();
   std::sort(dets.begin(), dets.end(), [](const auto& a, const auto& b) {
     return a->geographicalId().rawId() < b->geographicalId().rawId();
   });
 
   // get the input alignment
   edm::ESHandle<Alignments> alignments;
   iSetup.get<TrackerAlignmentRcd>().get(alignments);
 
   if (dets.size() != alignments->m_align.size()) {
     throw cms::Exception("GeometryMismatch") << "Size mismatch between alignments (size=" << alignments->m_align.size()
                                              << ") and ideal geometry (size=" << dets.size() << ")";
   }
 
   Alignments rescaledAlignments{};
   {
     auto outlierCounter{0};
     auto ideal = dets.cbegin();
     const auto& ideal_end = dets.cend();
     auto misaligned = alignments->m_align.cbegin();
     for (; ideal != ideal_end; ++ideal, ++misaligned) {
       if ((*ideal)->geographicalId().rawId() != misaligned->rawId()) {
         throw cms::Exception("GeometryMismatch") << "Order differs between Dets in alignments ideal geometry.";
       }
 
       // determine scale factor
       const auto& subDetId = (*ideal)->geographicalId().subdetId();
       auto side = topology->side((*ideal)->geographicalId());
       if (side == 0) {
         switch (subDetId) {
           case PixelSubdetector::PixelBarrel:
             side = 1;  // both sides are treated identical -> pick one of them
             break;
           case StripSubdetector::TIB:
             side = topology->tibSide((*ideal)->geographicalId());
             break;
           case StripSubdetector::TOB:
             side = topology->tobSide((*ideal)->geographicalId());
             break;
           default:
             break;
         }
       }
       auto scaleFactor = scalers_.find(subDetId)->second.find(side)->second;
 
       if (pullBadModulesToIdeal_ &&
           (pixelModules->IsModuleBad(misaligned->rawId()) || stripModules->IsModuleBad(misaligned->rawId()))) {
         scaleFactor = 0.0;
       }
 
       auto x_diff = misaligned->translation().x() - (*ideal)->position().x();
       auto y_diff = misaligned->translation().y() - (*ideal)->position().y();
       auto z_diff = misaligned->translation().z() - (*ideal)->position().z();
 
       auto xx_diff = misaligned->rotation().xx() - (*ideal)->rotation().xx();
       auto xy_diff = misaligned->rotation().xy() - (*ideal)->rotation().xy();
       auto xz_diff = misaligned->rotation().xz() - (*ideal)->rotation().xz();
       auto yx_diff = misaligned->rotation().yx() - (*ideal)->rotation().yx();
       auto yy_diff = misaligned->rotation().yy() - (*ideal)->rotation().yy();
       auto yz_diff = misaligned->rotation().yz() - (*ideal)->rotation().yz();
       auto zx_diff = misaligned->rotation().zx() - (*ideal)->rotation().zx();
       auto zy_diff = misaligned->rotation().zy() - (*ideal)->rotation().zy();
       auto zz_diff = misaligned->rotation().zz() - (*ideal)->rotation().zz();
 
       if (outlierPullToIdealCut_ > 0.0 &&
           (x_diff * x_diff + y_diff * y_diff + z_diff * z_diff) > outlierPullToIdealCut_ * outlierPullToIdealCut_) {
         ++outlierCounter;
         edm::LogInfo("Alignment") << outlierCounter << ") Outlier found in subdetector " << subDetId
                                   << ":  delta x: " << x_diff << ",  delta y: " << y_diff << ",  delta z: " << z_diff
                                   << ",  delta xx: " << xx_diff << ",  delta xy: " << xy_diff
                                   << ",  delta xz: " << xz_diff << ",  delta yx: " << yx_diff
                                   << ",  delta yx: " << yy_diff << ",  delta yy: " << yz_diff
                                   << ",  delta zz: " << zx_diff << ",  delta zy: " << zy_diff
                                   << ",  delta zz: " << zz_diff << "\n";
         scaleFactor = 0.0;
       }
 
       const AlignTransform::Translation rescaledTranslation{(*ideal)->position().x() + scaleFactor * x_diff,
                                                             (*ideal)->position().y() + scaleFactor * y_diff,
                                                             (*ideal)->position().z() + scaleFactor * z_diff};
 
       const AlignTransform::Rotation rescaledRotation{
           CLHEP::HepRep3x3{(*ideal)->rotation().xx() + scaleFactor * xx_diff,
                            (*ideal)->rotation().xy() + scaleFactor * xy_diff,
                            (*ideal)->rotation().xz() + scaleFactor * xz_diff,
                            (*ideal)->rotation().yx() + scaleFactor * yx_diff,
                            (*ideal)->rotation().yy() + scaleFactor * yy_diff,
                            (*ideal)->rotation().yz() + scaleFactor * yz_diff,
                            (*ideal)->rotation().zx() + scaleFactor * zx_diff,
                            (*ideal)->rotation().zy() + scaleFactor * zy_diff,
                            (*ideal)->rotation().zz() + scaleFactor * zz_diff}};
 
       const AlignTransform rescaledTransform{rescaledTranslation, rescaledRotation, misaligned->rawId()};
       rescaledAlignments.m_align.emplace_back(std::move(rescaledTransform));
     }
   }
 
   edm::Service<cond::service::PoolDBOutputService> poolDb;
   if (!poolDb.isAvailable()) {
     throw cms::Exception("NotAvailable") << "PoolDBOutputService not available";
   }
   edm::LogInfo("Alignment") << "Writing rescaled tracker-alignment record.";
   const auto& since = cond::timeTypeSpecs[cond::runnumber].beginValue;
   poolDb->writeOne(&rescaledAlignments, since, "TrackerAlignmentRcd");
 }

MCMisalignmentScaler::ScalerMap MCMisalignmentScaler::decodeSubDetectors ( const edm::VParameterSet & psets )

private

Definition at line 221 of file MCMisalignmentScaler.cc.

References funct::abs(), Exception, DQMScaleToClient_cfi::factor, Skims_PA_cff::name, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, muonDTDigis_cfi::pset, AlCaHLTBitMon_QueryRunRegistry::string, GeomDetEnumerators::subDetId, StripSubdetector::TEC, StripSubdetector::TIB, StripSubdetector::TID, and StripSubdetector::TOB.

Referenced by MCMisalignmentScaler().

                                                                                                     {
   // initialize scaler map
   ScalerMap subDetMap;
   for (unsigned int subDetId = 1; subDetId <= 6; ++subDetId) {
     subDetMap[subDetId][1] = 1.0;
     subDetMap[subDetId][2] = 1.0;
   }
 
   // apply scale factors from configuration
   for (const auto& pset : psets) {
     const auto& name = pset.getUntrackedParameter<std::string>("subDetector");
     const auto& factor = pset.getUntrackedParameter<double>("factor");
 
     std::vector<int> sides;
     if (name.find("-") != std::string::npos)
       sides.push_back(1);
     if (name.find("+") != std::string::npos)
       sides.push_back(2);
     if (sides.empty()) {  // -> use both sides
       sides.push_back(1);
       sides.push_back(2);
     }
 
     if (name.find("Tracker") != std::string::npos) {
       for (unsigned int subDetId = 1; subDetId <= 6; ++subDetId) {
         for (const auto& side : sides)
           subDetMap[subDetId][side] *= factor;
       }
       if (sides.size() == 1) {
         // if only one side to be scaled
         // -> scale also the other side for PXB (subdetid = 1)
         subDetMap[PixelSubdetector::PixelBarrel][std::abs(sides[0] - 2) + 1] *= factor;
       }
     } else if (name.find("PXB") != std::string::npos) {
       // ignore sides for PXB
       subDetMap[PixelSubdetector::PixelBarrel][1] *= factor;
       subDetMap[PixelSubdetector::PixelBarrel][2] *= factor;
     } else if (name.find("PXF") != std::string::npos) {
       for (const auto& side : sides)
         subDetMap[PixelSubdetector::PixelEndcap][side] *= factor;
     } else if (name.find("TIB") != std::string::npos) {
       for (const auto& side : sides)
         subDetMap[StripSubdetector::TIB][side] *= factor;
     } else if (name.find("TOB") != std::string::npos) {
       for (const auto& side : sides)
         subDetMap[StripSubdetector::TOB][side] *= factor;
     } else if (name.find("TID") != std::string::npos) {
       for (const auto& side : sides)
         subDetMap[StripSubdetector::TID][side] *= factor;
     } else if (name.find("TEC") != std::string::npos) {
       for (const auto& side : sides)
         subDetMap[StripSubdetector::TEC][side] *= factor;
     } else {
       throw cms::Exception("BadConfig") << "@SUB=MCMisalignmentScaler::decodeSubDetectors\n"
                                         << "Unknown tracker subdetector: " << name
                                         << "\nSupported options: Tracker, PXB, PXF, TIB, TOB, TID, TEC "
                                         << "(possibly decorated with '+' or '-')";
     }
   }
 
   std::stringstream logInfo;
   logInfo << "MC misalignment scale factors:\n";
   for (const auto& subdet : subDetMap) {
     logInfo << "  Subdet " << subdet.first << "\n";
     for (const auto& side : subdet.second) {
       logInfo << "    side " << side.first << ": " << side.second << "\n";
     }
     logInfo << "\n";
   }
   edm::LogInfo("Alignment") << logInfo.str();
 
   return subDetMap;
 }

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

static

Definition at line 296 of file MCMisalignmentScaler.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::addUntracked(), edm::ParameterSetDescription::addVPSet(), DEFINE_FWK_MODULE, edm::ParameterSetDescription::setComment(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                       {
   edm::ParameterSetDescription desc;
   desc.setComment(
       "Creates rescaled MC misalignment scenario. "
       "PoolDBOutputService must be set up for 'TrackerAlignmentRcd'.");
   edm::ParameterSetDescription descScaler;
   descScaler.setComment(
       "ParameterSet specifying the tracker part to be scaled "
       "by a given factor.");
   descScaler.addUntracked<std::string>("subDetector", "Tracker");
   descScaler.addUntracked<double>("factor", 1.0);
   desc.addVPSet("scalers", descScaler, std::vector<edm::ParameterSet>(1));
   desc.addUntracked<bool>("pullBadModulesToIdeal", false);
   desc.addUntracked<double>("outlierPullToIdealCut", -1.0);
   descriptions.add("mcMisalignmentScaler", desc);
 }

Member Data Documentation

bool MCMisalignmentScaler::firstEvent_ {true}

private

Definition at line 77 of file MCMisalignmentScaler.cc.

Referenced by analyze().

const double MCMisalignmentScaler::outlierPullToIdealCut_

private

Definition at line 76 of file MCMisalignmentScaler.cc.

Referenced by analyze(), and MCMisalignmentScaler().

const bool MCMisalignmentScaler::pullBadModulesToIdeal_

private

Definition at line 75 of file MCMisalignmentScaler.cc.

Referenced by analyze(), and MCMisalignmentScaler().

const ScalerMap MCMisalignmentScaler::scalers_

private

Definition at line 74 of file MCMisalignmentScaler.cc.

Referenced by analyze().

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation